Context Navigation

Reverse Diff

Changes in / [375b458:51c910]

Location:

src

Files:

: 1 added
: 22 edited

Makefile.am (modified) (1 diff)
analyzer.cpp (modified) (1 diff)
atom.cpp (modified) (6 diffs)
bond.cpp (modified) (11 diffs)
boundary.cpp (modified) (42 diffs)
boundary.hpp (modified) (2 diffs)
builder.cpp (modified) (41 diffs)
config.cpp (modified) (14 diffs)
datacreator.cpp (modified) (26 diffs)
datacreator.hpp (modified) (1 diff)
defs.hpp (modified) (4 diffs)
ellipsoid.cpp (modified) (2 diffs)
graph.cpp (modified) (1 diff)
graph.hpp (added)
helpers.cpp (modified) (1 diff)
joiner.cpp (modified) (1 diff)
moleculelist.cpp (modified) (8 diffs)
molecules.cpp (modified) (24 diffs)
molecules.hpp (modified) (12 diffs)
parser.cpp (modified) (25 diffs)
parser.hpp (modified) (5 diffs)
periodentafel.cpp (modified) (12 diffs)
verbose.cpp (modified) (3 diffs)

Legend:

: Unmodified
: Added
: Removed

src/Makefile.am

r375b458	r51c910
10	10
11	11
12		#EXTRA_DIST = ${molecuilder_DATA}
	12	EXTRA_DIST = ${molecuilder_DATA}

src/analyzer.cpp

-              r375b458
+              r51c910
 int main(int argc, char **argv)
+{
+        periodentafel *periode = NULL; // and a period table of all elements
+        EnergyMatrix Energy;
+        EnergyMatrix Hcorrection;
+        ForceMatrix Force;
+        ForceMatrix Shielding;
+        ForceMatrix ShieldingPAS;
+        EnergyMatrix Time;
+        EnergyMatrix EnergyFragments;
+        EnergyMatrix HcorrectionFragments;
+        ForceMatrix ForceFragments;
+        ForceMatrix ShieldingFragments;
+        ForceMatrix ShieldingPASFragments;
+        KeySetsContainer KeySet;
+        ofstream output;
+        ofstream output2;
+        ofstream output3;
+        ofstream output4;
+        ifstream input;
+        stringstream filename;
+        time_t t = time(NULL);
+        struct tm *ts = localtime(&t);
+        char *datum = asctime(ts);
+        stringstream Orderxrange;
+        stringstream Fragmentxrange;
+        stringstream yrange;
+        char *dir = NULL;
+        bool Hcorrected = true;
+        double norm;
+        int counter;
+        cout << "ANOVA Analyzer" << endl;
+        cout << "==============" << endl;
+        // Get the command line options
+        if (argc < 4) {
+                cout << "Usage: " << argv[0] << " <inputdir> <prefix> <outputdir> [elementsdb]" << endl;
+                cout << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl;
+                cout << "<prefix>\tprefix of energy and forces file." << endl;
+                cout << "<outputdir>\tcreated plotfiles and datafiles are placed into this directory " << endl;
+                cout << "[elementsdb]\tpath to elements database, needed for shieldings." << endl;
+                return 1;
+        } else {
+                dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+                strcpy(dir, "/");
+                strcat(dir, argv[2]);
+        }
+        if (argc > 4) {
+                cout << "Loading periodentafel." << endl;
+                periode = new periodentafel;
+                periode->LoadPeriodentafel(argv[4]);
+        }
+        // Test the given directory
+        if (!TestParams(argc, argv))
+                return 1;
+        // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
+        // ------------- Parse through all Fragment subdirs --------
+        if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix,0,0)) return 1;
+        Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0);
+        if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix,0,0)) return 1;
+        if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
+                if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
+        }
+        // ---------- Parse the TE Factors into an array -----------------
+        if (!Energy.ParseIndices()) return 1;
+        if (Hcorrected) Hcorrection.ParseIndices();
+        // ---------- Parse the Force indices into an array ---------------
+        if (!Force.ParseIndices(argv[1])) return 1;
+        if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
+        if (!ForceFragments.ParseIndices(argv[1])) return 1;
+        // ---------- Parse the shielding indices into an array ---------------
+        if (periode != NULL) { // also look for PAS values
+                if(!Shielding.ParseIndices(argv[1])) return 1;
+                if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
+                if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
+                if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
+                if(!ShieldingFragments.ParseIndices(argv[1])) return 1;
+                if(!ShieldingPASFragments.ParseIndices(argv[1])) return 1;
+        }
+        // ---------- Parse the KeySets into an array ---------------
+        if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+        if (!KeySet.ParseManyBodyTerms()) return 1;
+        // ---------- Parse fragment files created by 'joiner' into an array -------------
+        if (!EnergyFragments.ParseFragmentMatrix(argv[1], dir, EnergyFragmentSuffix,0,0)) return 1;
+        if (Hcorrected) HcorrectionFragments.ParseFragmentMatrix(argv[1], dir, HcorrectionFragmentSuffix,0,0);
+        if (!ForceFragments.ParseFragmentMatrix(argv[1], dir, ForceFragmentSuffix,0,0)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!ShieldingFragments.ParseFragmentMatrix(argv[1], dir, ShieldingFragmentSuffix, 1, 0)) return 1;
+                if (!ShieldingPASFragments.ParseFragmentMatrix(argv[1], dir, ShieldingPASFragmentSuffix, 1, 0)) return 1;
+        }
+        // +++++++++++++++ TESTING ++++++++++++++++++++++++++++++
+        // print energy and forces to file
+        filename.str("");
+        filename << argv[3] << "/" << "energy-forces.all";
+        output.open(filename.str().c_str(), ios::out);
+        output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header << endl;
+        for(int j=0;j<Energy.RowCounter[Energy.MatrixCounter];j++) {
+                for(int k=0;k<Energy.ColumnCounter;k++)
+                        output << scientific << Energy.Matrix[ Energy.MatrixCounter ][j][k] << "\t";
+                output << endl;
+        }
+        output << endl;
+        output << endl << "Total Forces" << endl << "===============" << endl << Force.Header << endl;
+        for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
+                for(int k=0;k<Force.ColumnCounter;k++)
+                        output << scientific << Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
+                output << endl;
+        }
+        output << endl;
+        if (periode != NULL) { // also look for PAS values
+                output << endl << "Total Shieldings" << endl << "===============" << endl << Shielding.Header << endl;
+                for(int j=0;j<Shielding.RowCounter[Shielding.MatrixCounter];j++) {
+                        for(int k=0;k<Shielding.ColumnCounter;k++)
+                                output << scientific << Shielding.Matrix[ Shielding.MatrixCounter ][j][k] << "\t";
+                        output << endl;
+                }
+                output << endl;
+                output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header << endl;
+                for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
+                        for(int k=0;k<ShieldingPAS.ColumnCounter;k++)
+                                output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t";
+                        output << endl;
+                }
+                output << endl;
+        }
+        output << endl << "Total Times" << endl << "===============" << endl << Time.Header << endl;
+        for(int j=0;j<Time.RowCounter[Time.MatrixCounter];j++) {
+                for(int k=0;k<Time.ColumnCounter;k++) {
+                        output << scientific << Time.Matrix[ Time.MatrixCounter ][j][k] << "\t";
+                }
+                output << endl;
+        }
+        output << endl;
+        output.close();
+        for(int k=0;k<Time.ColumnCounter;k++)
+                Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k] = Time.Matrix[ Time.MatrixCounter ][Time.RowCounter[Time.MatrixCounter]-1][k];
+        // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
+        cout << "Analyzing ..." << endl;
+        // ======================================= Creating the data files ==============================================================
+        // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
+        // +++++++++++++++++++++++++++++++++++++++ Plotting Delta Simtime vs Bond Order
+        if (!OpenOutputFile(output, argv[3], "SimTime-Order.dat" )) return false;
+        if (!OpenOutputFile(output2, argv[3], "DeltaSimTime-Order.dat" )) return false;
+        for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+                for(int k=Time.ColumnCounter;k--;) {
+                        Time.Matrix[ Time.MatrixCounter ][j][k] = 0.;
+                }
+        counter = 0;
+        output << "#Order\tFrag.No.\t" << Time.Header << endl;
+        output2 << "#Order\tFrag.No.\t" << Time.Header << endl;
+        for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+                for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;)
+                        for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+                                for(int k=Time.ColumnCounter;k--;) {
+                                        Time.Matrix[ Time.MatrixCounter ][j][k] += Time.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+                                }
+                counter += KeySet.FragmentsPerOrder[BondOrder];
+                output << BondOrder+1 << "\t" << counter;
+                output2 << BondOrder+1 << "\t" << counter;
+                for(int k=0;k<Time.ColumnCounter;k++) {
+                        output << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+                        if (fabs(Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k]) > MYEPSILON)
+                                output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k] / Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k];
+                        else
+                                output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+                }
+                output << endl;
+                output2 << endl;
+        }
+        output.close();
+        output2.close();
+        // +++++++++++++++++++++++++++++++++++++++ Plotting shieldings
+        if (periode != NULL) { // also look for PAS values
+                if (!CreateDataDeltaForcesOrderPerAtom(ShieldingPAS, ShieldingPASFragments, KeySet, argv[3], "DeltaShieldingsPAS-Order", "Plot of error between approximated shieldings and full shieldings versus the Bond Order", datum)) return 1;
+                if (!CreateDataForcesOrderPerAtom(ShieldingPASFragments, KeySet, argv[3], "ShieldingsPAS-Order", "Plot of approximated shieldings versus the Bond Order", datum)) return 1;
+                if (!AppendOutputFile(output, argv[3], "ShieldingsPAS-Order.dat" )) return false;
+                output << endl << "# Full" << endl;
+                for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
+                        output << j << "\t";
+                        for(int k=0;k<ShieldingPAS.ColumnCounter;k++)
+                                output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t"; //*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
+                        output << endl;
+                }
+        }
+        output.close();
+        // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
+        if (!CreateDataDeltaEnergyOrder(Energy, EnergyFragments, KeySet, argv[3], "DeltaEnergies-Order", "Plot of error between approximated and full energies energies versus the Bond Order", datum)) return 1;
+        // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
+        if (!CreateDataEnergyOrder(EnergyFragments, KeySet, argv[3], "Energies-Order", "Plot of approximated energies versus the Bond Order", datum)) return 1;
+        // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in forces to full QM
+        if (!CreateDataDeltaForcesOrderPerAtom(Force, ForceFragments, KeySet, argv[3], "DeltaForces-Order", "Plot of error between approximated forces and full forces versus the Bond Order", datum)) return 1;
+        // min force
+        if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMinForces-Order", "Plot of min error between approximated forces and full forces versus the Bond Order", datum, CreateMinimumForce)) return 1;
+        // mean force
+        if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMeanForces-Order", "Plot of mean error between approximated forces and full forces versus the Bond Order", datum, CreateMeanForce)) return 1;
+        // max force
+        if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMaxForces-Order", "Plot of max error between approximated forces and full forces versus the Bond Order", datum, CreateMaximumForce)) return 1;
+        // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
+        if (!CreateDataForcesOrderPerAtom(ForceFragments, KeySet, argv[3], "Forces-Order", "Plot of approximated forces versus the Bond Order", datum)) return 1;
+        if (!AppendOutputFile(output, argv[3], "Forces-Order.dat" )) return false;
+        output << endl << "# Full" << endl;
+        for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
+                output << j << "\t";
+                for(int k=0;k<Force.ColumnCounter;k++)
+                        output << scientific << Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
+                output << endl;
+        }
+        output.close();
+        // min force
+        if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MinForces-Order", "Plot of min approximated forces versus the Bond Order", datum, CreateMinimumForce)) return 1;
+        // mean force
+        if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MeanForces-Order", "Plot of mean approximated forces versus the Bond Order", datum, CreateMeanForce)) return 1;
+        // max force
+        if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MaxForces-Order", "Plot of max approximated forces versus the Bond Order", datum, CreateMaximumForce)) return 1;
+        // ++++++++++++++++++++++++++++++++++++++Plotting vector sum (should be 0) vs. bond order
+        if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "VectorSum-Order", "Plot of vector sum of the approximated forces versus the Bond Order", datum, CreateVectorSumForce)) return 1;
+        // +++++++++++++++++++++++++++++++Plotting energyfragments vs. order
+        if (!CreateDataFragment(EnergyFragments, KeySet, argv[3], "Energies-Fragment", "Plot of fragment energy versus the Fragment No", datum, CreateEnergy)) return 1;
+        if (!CreateDataFragment(EnergyFragments, KeySet, argv[3], "Energies-FragmentOrder", "Plot of fragment energy of each Fragment No vs. Bond Order", datum, CreateEnergy)) return 1;
+        if (!CreateDataFragmentOrder(EnergyFragments, KeySet, argv[3], "MaxEnergies-FragmentOrder", "Plot of maximum of fragment energy vs. Bond Order", datum, CreateMaxFragmentOrder)) return 1;
+        if (!CreateDataFragmentOrder(EnergyFragments, KeySet, argv[3], "MinEnergies-FragmentOrder", "Plot of minimum of fragment energy vs. Bond Order", datum, CreateMinFragmentOrder)) return 1;
+        // +++++++++++++++++++++++++++++++Ploting min/mean/max forces for each fragment
+        // min force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MinForces-Fragment", "Plot of min approximated forces versus the Fragment No", datum, CreateMinimumForce)) return 1;
+        // mean force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MeanForces-Fragment", "Plot of mean approximated forces versus the Fragment No", datum, CreateMeanForce)) return 1;
+        // max force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MaxForces-Fragment", "Plot of max approximated forces versus the Fragment No", datum, CreateMaximumForce)) return 1;
+        // +++++++++++++++++++++++++++++++Ploting min/mean/max forces for each fragment per order
+        // min force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MinForces-FragmentOrder", "Plot of min approximated forces of each Fragment No vs. Bond Order", datum, CreateMinimumForce)) return 1;
+        // mean force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MeanForces-FragmentOrder", "Plot of mean approximated forces of each Fragment No vs. Bond Order", datum, CreateMeanForce)) return 1;
+        // max force
+        if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", "Plot of max approximated forces of each Fragment No vs. Bond Order", datum, CreateMaximumForce)) return 1;
+        // ======================================= Creating the plot files ==============================================================
+        Orderxrange << "[1:" << KeySet.Order << "]";
+        Fragmentxrange << "[0:" << KeySet.FragmentCounter+1 << "]";
+        yrange.str("[1e-8:1e+1]");
+        // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
+        if (!CreatePlotOrder(Time, KeySet, argv[3], "SimTime-Order", 1, "below", "y", "",       1, 1, "bond order k", "Evaluation time [s]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
+        if (!CreatePlotOrder(Energy, KeySet, argv[3], "DeltaEnergies-Order", 1, "outside", "y", "",     1, 1, "bond order k", "absolute error in energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
+        if (!CreatePlotOrder(Energy, KeySet, argv[3], "Energies-Order", 1, "outside", "", "",   1, 1, "bond order k", "approximate energy [Ht]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in forces to full QM
+        yrange.str("[1e-8:1e+0]");
+        // min force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMinForces-Order", 2, "top right", "y", "",   1, 1, "bond order k", "absolute error in min force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+        // mean force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMeanForces-Order", 2, "top right", "y", "",  1, 1, "bond order k", "absolute error in mean force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsFirstForceValuePlotLine)) return 1;
+        // max force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMaxForces-Order", 2, "top right", "y", "",   1, 1, "bond order k", "absolute error in max force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+        // min/mean/max comparison for total force
+        if(!OpenOutputFile(output, argv[3], "DeltaMinMeanMaxTotalForce-Order.pyx")) return 1;
+        CreatePlotHeader(output, "DeltaMinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL,        1, 1, "bond order k", "absolute error in total forces [Ht/a.u.]");
+        output << "plot " << Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
+        output << "'DeltaMinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
+        output << "'DeltaMeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
+        output << "'DeltaMaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
+        output.close();
+        // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
+        // min force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "MinForces-Order", 2, "bottom right", "y", "",     1, 1, "bond order k", "absolute approximated min force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+        // mean force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "MeanForces-Order", 2, "bottom right", "y", "",    1, 1, "bond order k", "absolute approximated mean force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", AbsFirstForceValuePlotLine)) return 1;
+        // max force
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "MaxForces-Order", 2, "bottom right", "y", "",     1, 1, "bond order k", "absolute approximated max force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+        // min/mean/max comparison for total force
+        if(!OpenOutputFile(output, argv[3],"MinMeanMaxTotalForce-Order.pyx")) return 1;
+        CreatePlotHeader(output, "MinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL, 1, 1, "bond order k", "absolute total force [Ht/a.u.]");
+        output << "plot "<< Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
+        output << "'MinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
+        output << "'MeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
+        output << "'MaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
+        output.close();
+        // ++++++++++++++++++++++++++++++++++++++Plotting vector sum vs. Order
+        if (!CreatePlotOrder(Force, KeySet, argv[3], "VectorSum-Order", 2, "bottom right", "y" ,"", 1, 1, "bond order k", "vector sum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++Plotting energyfragments vs. order
+        yrange.str("");
+        yrange << "[" << EnergyFragments.FindMinValue() << ":" << EnergyFragments.FindMaxValue() << "]";
+        if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "Energies-Fragment", 5, "below", "y", "", 1, 5, "fragment number", "Energies of each fragment [Ht]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with points", AbsEnergyPlotLine)) return 1;
+        if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "Energies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Energies of each fragment [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with points", AbsEnergyPlotLine)) return 1;
+        if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "MaxEnergies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Maximum fragment energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+        if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "MinEnergies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Minimum fragment energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++=Ploting min/mean/max forces for each fragment
+        yrange.str("");
+        yrange << "[" << ForceFragments.FindMinValue() << ":" << ForceFragments.FindMaxValue()<< "]";
+        // min
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "minimum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+        // mean
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "mean of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
+        // max
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "maximum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++=Ploting min/mean/max forces for each fragment per bond order
+        // min
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "minimum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+        // mean
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "mean of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
+        // max
+        if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "maximum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+        // +++++++++++++++++++++++++++++++=Ploting approximated and true shielding for each atom
+        if (periode != NULL) { // also look for PAS values
+                if(!OpenOutputFile(output, argv[3], "ShieldingsPAS-Order.pyx")) return 1;
+                if(!OpenOutputFile(output2, argv[3], "DeltaShieldingsPAS-Order.pyx")) return 1;
+                CreatePlotHeader(output, "ShieldingsPAS-Order", 1, "top right", NULL, NULL,     1, 5, "nuclei index", "iso chemical shielding value [ppm]");
+                CreatePlotHeader(output2, "DeltaShieldingsPAS-Order", 1, "top right", NULL, NULL,       1, 5, "nuclei index", "iso chemical shielding value [ppm]");
+                double step=0.8/KeySet.Order;
+                output << "set boxwidth " << step << endl;
+                output << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
+                output2 << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
+                for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+                        output << "'ShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
+                        output2 << "'DeltaShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
+                        if (BondOrder-1 != KeySet.Order)
+                                output2 << ", \\" << endl;
+                }
+                output << "'ShieldingsPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
+                output.close();
+                output2.close();
+        }
+        // create Makefile
+        if(!OpenOutputFile(output, argv[3], "Makefile")) return 1;
+        output << "PYX = $(shell ls *.pyx)" << endl << endl;
+        output << "EPS = $(PYX:.pyx=.eps)" << endl << endl;
+        output << "%.eps: %.pyx" << endl;
+        output << "\t~/build/pyxplot/pyxplot $<" << endl << endl;
+        output << "all: $(EPS)" << endl << endl;
+        output << ".PHONY: clean" << endl;
+        output << "clean:" << endl;
+        output << "\trm -rf $(EPS)" << endl;
+        output.close();
+        // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
+        delete(periode);
+        Free((void **)&dir, "main: *dir");
+        cout << "done." << endl;
+        return 0;
+  periodentafel *periode = NULL; // and a period table of all elements
+  EnergyMatrix Energy;
+  EnergyMatrix EnergyFragments;
+  ForceMatrix Force;
+  ForceMatrix ForceFragments;
+  HessianMatrix Hessian;
+  HessianMatrix HessianFragments;
+  EnergyMatrix Hcorrection;
+  EnergyMatrix HcorrectionFragments;
+  ForceMatrix Shielding;
+  ForceMatrix ShieldingPAS;
+  ForceMatrix Chi;
+  ForceMatrix ChiPAS;
+  EnergyMatrix Time;
+  ForceMatrix ShieldingFragments;
+  ForceMatrix ShieldingPASFragments;
+  ForceMatrix ChiFragments;
+  ForceMatrix ChiPASFragments;
+  KeySetsContainer KeySet;
+  ofstream output;
+  ofstream output2;
+  ofstream output3;
+  ofstream output4;
+  ifstream input;
+  stringstream filename;
+  time_t t = time(NULL);
+  struct tm *ts = localtime(&t);
+  char *datum = asctime(ts);
+  stringstream Orderxrange;
+  stringstream Fragmentxrange;
+  stringstream yrange;
+  char *dir = NULL;
+  bool NoHessian = false;
+  bool NoTime = false;
+  bool NoHCorrection = true;
+  int counter;
+  cout << "ANOVA Analyzer" << endl;
+  cout << "==============" << endl;
+  // Get the command line options
+  if (argc < 4) {
+    cout << "Usage: " << argv[0] << " <inputdir> <prefix> <outputdir> [elementsdb]" << endl;
+    cout << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl;
+    cout << "<prefix>\tprefix of energy and forces file." << endl;
+    cout << "<outputdir>\tcreated plotfiles and datafiles are placed into this directory " << endl;
+    cout << "[elementsdb]\tpath to elements database, needed for shieldings." << endl;
+    return 1;
+  } else {
+    dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+    strcpy(dir, "/");
+    strcat(dir, argv[2]);
+  }
+  if (argc > 4) {
+    cout << "Loading periodentafel." << endl;
+    periode = new periodentafel;
+    periode->LoadPeriodentafel(argv[4]);
+  }
+  // Test the given directory
+  if (!TestParams(argc, argv))
+    return 1;
+  // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
+  // ------------- Parse through all Fragment subdirs --------
+  if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix,0,0)) return 1;
+  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0)) {
+    NoHCorrection = true;
+    cout << "No HCorrection file found, skipping these." << endl;
+  }
+  if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix,0,0)) return 1;
+  if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix,0,0)) {
+    NoHessian = true;
+    cout << "No Hessian file found, skipping these." << endl;
+  }
+  if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) {
+    NoTime = true;
+    cout << "No speed file found, skipping these." << endl;
+  }
+  if (periode != NULL) { // also look for PAS values
+    if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
+    if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
+    if (!Chi.ParseFragmentMatrix(argv[1], dir, ChiSuffix, 1, 0)) return 1;
+    if (!ChiPAS.ParseFragmentMatrix(argv[1], dir, ChiPASSuffix, 1, 0)) return 1;
+  }
+  // ---------- Parse the TE Factors into an array -----------------
+  if (!Energy.ParseIndices()) return 1;
+  if (!NoHCorrection) Hcorrection.ParseIndices();
+  // ---------- Parse the Force indices into an array ---------------
+  if (!Force.ParseIndices(argv[1])) return 1;
+  if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
+  if (!ForceFragments.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
+  // ---------- Parse hessian indices into an array -----------------
+  if (!NoHessian) {
+    if (!Hessian.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
+    if (!HessianFragments.AllocateMatrix(Hessian.Header, Hessian.MatrixCounter, Hessian.RowCounter, Hessian.ColumnCounter)) return 1;
+    if (!HessianFragments.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
+  }
+  // ---------- Parse the shielding indices into an array ---------------
+  if (periode != NULL) { // also look for PAS values
+    if(!Shielding.ParseIndices(argv[1])) return 1;
+    if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
+    if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
+    if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
+    if(!ShieldingFragments.ParseIndices(argv[1])) return 1;
+    if(!ShieldingPASFragments.ParseIndices(argv[1])) return 1;
+    if(!Chi.ParseIndices(argv[1])) return 1;
+    if(!ChiPAS.ParseIndices(argv[1])) return 1;
+    if (!ChiFragments.AllocateMatrix(Chi.Header, Chi.MatrixCounter, Chi.RowCounter, Chi.ColumnCounter)) return 1;
+    if (!ChiPASFragments.AllocateMatrix(ChiPAS.Header, ChiPAS.MatrixCounter, ChiPAS.RowCounter, ChiPAS.ColumnCounter)) return 1;
+    if(!ChiFragments.ParseIndices(argv[1])) return 1;
+    if(!ChiPASFragments.ParseIndices(argv[1])) return 1;
+  }
+  // ---------- Parse the KeySets into an array ---------------
+  if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+  if (!KeySet.ParseManyBodyTerms()) return 1;
+  // ---------- Parse fragment files created by 'joiner' into an array -------------
+  if (!EnergyFragments.ParseFragmentMatrix(argv[1], dir, EnergyFragmentSuffix,0,0)) return 1;
+  if (!NoHCorrection)
+    HcorrectionFragments.ParseFragmentMatrix(argv[1], dir, HcorrectionFragmentSuffix,0,0);
+  if (!ForceFragments.ParseFragmentMatrix(argv[1], dir, ForceFragmentSuffix,0,0)) return 1;
+  if (!NoHessian)
+    if (!HessianFragments.ParseFragmentMatrix(argv[1], dir, HessianFragmentSuffix,0,0)) return 1;
+  if (periode != NULL) { // also look for PAS values
+    if (!ShieldingFragments.ParseFragmentMatrix(argv[1], dir, ShieldingFragmentSuffix, 1, 0)) return 1;
+    if (!ShieldingPASFragments.ParseFragmentMatrix(argv[1], dir, ShieldingPASFragmentSuffix, 1, 0)) return 1;
+    if (!ChiFragments.ParseFragmentMatrix(argv[1], dir, ChiFragmentSuffix, 1, 0)) return 1;
+    if (!ChiPASFragments.ParseFragmentMatrix(argv[1], dir, ChiPASFragmentSuffix, 1, 0)) return 1;
+  }
+  // +++++++++++++++ TESTING ++++++++++++++++++++++++++++++
+  // print energy and forces to file
+  filename.str("");
+  filename << argv[3] << "/" << "energy-forces.all";
+  output.open(filename.str().c_str(), ios::out);
+  output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header[Energy.MatrixCounter] << endl;
+  for(int j=0;j<Energy.RowCounter[Energy.MatrixCounter];j++) {
+    for(int k=0;k<Energy.ColumnCounter[Energy.MatrixCounter];k++)
+      output << scientific << Energy.Matrix[ Energy.MatrixCounter ][j][k] << "\t";
+    output << endl;
+  }
+  output << endl;
+  output << endl << "Total Forces" << endl << "===============" << endl << Force.Header[Force.MatrixCounter] << endl;
+  for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
+    for(int k=0;k<Force.ColumnCounter[Force.MatrixCounter];k++)
+      output << scientific << Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
+    output << endl;
+  }
+  output << endl;
+  if (!NoHessian) {
+    output << endl << "Total Hessian" << endl << "===============" << endl << Hessian.Header[Hessian.MatrixCounter] << endl;
+    for(int j=0;j<Hessian.RowCounter[Hessian.MatrixCounter];j++) {
+      for(int k=0;k<Hessian.ColumnCounter[Hessian.MatrixCounter];k++)
+        output << scientific << Hessian.Matrix[ Hessian.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output << endl;
+  }
+  if (periode != NULL) { // also look for PAS values
+    output << endl << "Total Shieldings" << endl << "===============" << endl << Shielding.Header[Hessian.MatrixCounter] << endl;
+    for(int j=0;j<Shielding.RowCounter[Shielding.MatrixCounter];j++) {
+      for(int k=0;k<Shielding.ColumnCounter[Shielding.MatrixCounter];k++)
+        output << scientific << Shielding.Matrix[ Shielding.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output << endl;
+    output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header[ShieldingPAS.MatrixCounter] << endl;
+    for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
+      for(int k=0;k<ShieldingPAS.ColumnCounter[ShieldingPAS.MatrixCounter];k++)
+        output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output << endl;
+    output << endl << "Total Chis" << endl << "===============" << endl << Chi.Header[Chi.MatrixCounter] << endl;
+    for(int j=0;j<Chi.RowCounter[Chi.MatrixCounter];j++) {
+      for(int k=0;k<Chi.ColumnCounter[Chi.MatrixCounter];k++)
+        output << scientific << Chi.Matrix[ Chi.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output << endl;
+    output << endl << "Total Chis PAS" << endl << "===============" << endl << ChiPAS.Header[ChiPAS.MatrixCounter] << endl;
+    for(int j=0;j<ChiPAS.RowCounter[ChiPAS.MatrixCounter];j++) {
+      for(int k=0;k<ChiPAS.ColumnCounter[ChiPAS.MatrixCounter];k++)
+        output << scientific << ChiPAS.Matrix[ ChiPAS.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output << endl;
+  }
+  if (!NoTime) {
+    output << endl << "Total Times" << endl << "===============" << endl << Time.Header[Time.MatrixCounter] << endl;
+    for(int j=0;j<Time.RowCounter[Time.MatrixCounter];j++) {
+      for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++) {
+        output << scientific << Time.Matrix[ Time.MatrixCounter ][j][k] << "\t";
+      }
+      output << endl;
+    }
+    output << endl;
+  }
+  output.close();
+  if (!NoTime)
+    for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++)
+      Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k] = Time.Matrix[ Time.MatrixCounter ][Time.RowCounter[Time.MatrixCounter]-1][k];
+  // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
+  cout << "Analyzing ..." << endl;
+  // ======================================= Creating the data files ==============================================================
+  // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
+  // +++++++++++++++++++++++++++++++++++++++ Plotting Delta Simtime vs Bond Order
+  if (!NoTime) {
+    if (!OpenOutputFile(output, argv[3], "SimTime-Order.dat" )) return false;
+    if (!OpenOutputFile(output2, argv[3], "DeltaSimTime-Order.dat" )) return false;
+    for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+      for(int k=Time.ColumnCounter[Time.MatrixCounter];k--;) {
+        Time.Matrix[ Time.MatrixCounter ][j][k] = 0.;
+      }
+    counter = 0;
+    output << "#Order\tFrag.No.\t" << Time.Header[Time.MatrixCounter] << endl;
+    output2 << "#Order\tFrag.No.\t" << Time.Header[Time.MatrixCounter] << endl;
+    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+      for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;)
+        for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+          for(int k=Time.ColumnCounter[Time.MatrixCounter];k--;) {
+            Time.Matrix[ Time.MatrixCounter ][j][k] += Time.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+          }
+      counter += KeySet.FragmentsPerOrder[BondOrder];
+      output << BondOrder+1 << "\t" << counter;
+      output2 << BondOrder+1 << "\t" << counter;
+      for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++) {
+        output << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+        if (fabs(Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k]) > MYEPSILON)
+          output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k] / Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k];
+        else
+          output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+      }
+      output << endl;
+      output2 << endl;
+    }
+    output.close();
+    output2.close();
+  }
+  if (!NoHessian) {
+    // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in hessian to full QM
+    if (!CreateDataDeltaHessianOrderPerAtom(Hessian, HessianFragments, KeySet, argv[3], "DeltaHessian_xx-Order", "Plot of error between approximated hessian and full hessian versus the Bond Order", datum)) return 1;
+    if (!CreateDataDeltaFrobeniusOrderPerAtom(Hessian, HessianFragments, KeySet, argv[3], "DeltaFrobeniusHessian_xx-Order", "Plot of error between approximated hessian and full hessian in the frobenius norm versus the Bond Order", datum)) return 1;
+    // ++++++++++++++++++++++++++++++++++++++Plotting Hessian vs. Order
+    if (!CreateDataHessianOrderPerAtom(HessianFragments, KeySet, argv[3], "Hessian_xx-Order", "Plot of approximated hessian versus the Bond Order", datum)) return 1;
+    if (!AppendOutputFile(output, argv[3], "Hessian_xx-Order.dat" )) return false;
+    output << endl << "# Full" << endl;
+    for(int j=0;j<Hessian.RowCounter[Hessian.MatrixCounter];j++) {
+      output << j << "\t";
+      for(int k=0;k<Hessian.ColumnCounter[Force.MatrixCounter];k++)
+        output << scientific <<  Hessian.Matrix[ Hessian.MatrixCounter ][j][k] << "\t";
+      output << endl;
+    }
+    output.close();
+  }
+  // +++++++++++++++++++++++++++++++++++++++ Plotting shieldings
+  if (periode != NULL) { // also look for PAS values
+    if (!CreateDataDeltaForcesOrderPerAtom(ShieldingPAS, ShieldingPASFragments, KeySet, argv[3], "DeltaShieldingsPAS-Order", "Plot of error between approximated shieldings and full shieldings versus the Bond Order", datum)) return 1;
+    if (!CreateDataForcesOrderPerAtom(ShieldingPASFragments, KeySet, argv[3], "ShieldingsPAS-Order", "Plot of approximated shieldings versus the Bond Order", datum)) return 1;
+    if (!AppendOutputFile(output, argv[3], "ShieldingsPAS-Order.dat" )) return false;
+    output << endl << "# Full" << endl;
+    for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
+      output << j << "\t";
+      for(int k=0;k<ShieldingPAS.ColumnCounter[ShieldingPAS.MatrixCounter];k++)
+        output << scientific <<  ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t"; //*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
+      output << endl;
+    }
+    output.close();
+    if (!CreateDataDeltaForcesOrderPerAtom(ChiPAS, ChiPASFragments, KeySet, argv[3], "DeltaChisPAS-Order", "Plot of error between approximated Chis and full Chis versus the Bond Order", datum)) return 1;
+    if (!CreateDataForcesOrderPerAtom(ChiPASFragments, KeySet, argv[3], "ChisPAS-Order", "Plot of approximated Chis versus the Bond Order", datum)) return 1;
+    if (!AppendOutputFile(output, argv[3], "ChisPAS-Order.dat" )) return false;
+    output << endl << "# Full" << endl;
+    for(int j=0;j<ChiPAS.RowCounter[ChiPAS.MatrixCounter];j++) {
+      output << j << "\t";
+      for(int k=0;k<ChiPAS.ColumnCounter[ChiPAS.MatrixCounter];k++)
+        output << scientific <<  ChiPAS.Matrix[ ChiPAS.MatrixCounter ][j][k] << "\t"; //*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
+      output << endl;
+    }
+    output.close();
+  }
+  // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
+  if (!CreateDataDeltaEnergyOrder(Energy, EnergyFragments, KeySet, argv[3], "DeltaEnergies-Order", "Plot of error between approximated and full energies energies versus the Bond Order", datum)) return 1;
+  // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
+  if (!CreateDataEnergyOrder(EnergyFragments, KeySet, argv[3], "Energies-Order", "Plot of approximated energies versus the Bond Order", datum)) return 1;
+  // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in forces to full QM
+  if (!CreateDataDeltaForcesOrderPerAtom(Force, ForceFragments, KeySet, argv[3], "DeltaForces-Order", "Plot of error between approximated forces and full forces versus the Bond Order", datum)) return 1;
+  // min force
+  if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMinForces-Order", "Plot of min error between approximated forces and full forces versus the Bond Order", datum, CreateMinimumForce)) return 1;
+  // mean force
+  if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMeanForces-Order", "Plot of mean error between approximated forces and full forces versus the Bond Order", datum, CreateMeanForce)) return 1;
+  // max force
+  if (!CreateDataDeltaForcesOrder(Force, ForceFragments, KeySet, argv[3], "DeltaMaxForces-Order", "Plot of max error between approximated forces and full forces versus the Bond Order", datum, CreateMaximumForce)) return 1;
+  // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
+  if (!CreateDataForcesOrderPerAtom(ForceFragments, KeySet, argv[3], "Forces-Order", "Plot of approximated forces versus the Bond Order", datum)) return 1;
+  if (!AppendOutputFile(output, argv[3], "Forces-Order.dat" )) return false;
+  output << endl << "# Full" << endl;
+  for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
+    output << j << "\t";
+    for(int k=0;k<Force.ColumnCounter[Force.MatrixCounter];k++)
+      output << scientific <<  Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
+    output << endl;
+  }
+  output.close();
+  // min force
+  if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MinForces-Order", "Plot of min approximated forces versus the Bond Order", datum, CreateMinimumForce)) return 1;
+  // mean force
+  if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MeanForces-Order", "Plot of mean approximated forces versus the Bond Order", datum, CreateMeanForce)) return 1;
+  // max force
+  if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MaxForces-Order", "Plot of max approximated forces versus the Bond Order", datum, CreateMaximumForce)) return 1;
+  // ++++++++++++++++++++++++++++++++++++++Plotting vector sum (should be 0) vs. bond order
+  if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "VectorSum-Order", "Plot of vector sum of the approximated forces versus the Bond Order", datum, CreateVectorSumForce)) return 1;
+  // +++++++++++++++++++++++++++++++Plotting energyfragments vs. order
+  if (!CreateDataFragment(EnergyFragments, KeySet, argv[3], "Energies-Fragment", "Plot of fragment energy versus the Fragment No", datum, CreateEnergy)) return 1;
+  if (!CreateDataFragment(EnergyFragments, KeySet, argv[3], "Energies-FragmentOrder", "Plot of fragment energy of each Fragment No vs. Bond Order", datum, CreateEnergy)) return 1;
+  if (!CreateDataFragmentOrder(EnergyFragments, KeySet, argv[3], "MaxEnergies-FragmentOrder", "Plot of maximum of fragment energy vs. Bond Order", datum, CreateMaxFragmentOrder)) return 1;
+  if (!CreateDataFragmentOrder(EnergyFragments, KeySet, argv[3], "MinEnergies-FragmentOrder", "Plot of minimum of fragment energy vs. Bond Order", datum, CreateMinFragmentOrder)) return 1;
+  // +++++++++++++++++++++++++++++++Ploting min/mean/max forces for each fragment
+  // min force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MinForces-Fragment", "Plot of min approximated forces versus the Fragment No", datum, CreateMinimumForce)) return 1;
+  // mean force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MeanForces-Fragment", "Plot of mean approximated forces versus the Fragment No", datum, CreateMeanForce)) return 1;
+  // max force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MaxForces-Fragment", "Plot of max approximated forces versus the Fragment No", datum, CreateMaximumForce)) return 1;
+  // +++++++++++++++++++++++++++++++Ploting min/mean/max forces for each fragment per order
+  // min force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MinForces-FragmentOrder", "Plot of min approximated forces of each Fragment No vs. Bond Order", datum, CreateMinimumForce)) return 1;
+  // mean force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MeanForces-FragmentOrder", "Plot of mean approximated forces of each Fragment No vs. Bond Order", datum, CreateMeanForce)) return 1;
+  // max force
+  if (!CreateDataFragment(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", "Plot of max approximated forces of each Fragment No vs. Bond Order", datum, CreateMaximumForce)) return 1;
+  // ======================================= Creating the plot files ==============================================================
+  Orderxrange << "[1:" << KeySet.Order << "]";
+  Fragmentxrange << "[0:" << KeySet.FragmentCounter+1 << "]";
+  yrange.str("[1e-8:1e+1]");
+  if (!NoTime) {
+    // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
+    if (!CreatePlotOrder(Time, KeySet, argv[3], "SimTime-Order", 1, "below", "y", "",  1, 1, "bond order k", "Evaluation time [s]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
+  }
+  // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
+  if (!CreatePlotOrder(Energy, KeySet, argv[3], "DeltaEnergies-Order", 1, "outside", "y", "",  1, 1, "bond order k", "absolute error in energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++++++Plotting Energies vs. Order
+  if (!CreatePlotOrder(Energy, KeySet, argv[3], "Energies-Order", 1, "outside", "", "",  1, 1, "bond order k", "approximate energy [Ht]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in forces to full QM
+  yrange.str("[1e-8:1e+0]");
+  // min force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMinForces-Order", 2, "top right", "y", "",  1, 1, "bond order k", "absolute error in min force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+  // mean force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMeanForces-Order", 2, "top right", "y", "",  1, 1, "bond order k", "absolute error in mean force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsFirstForceValuePlotLine)) return 1;
+  // max force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "DeltaMaxForces-Order", 2, "top right", "y", "",  1, 1, "bond order k", "absolute error in max force [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+  // min/mean/max comparison for total force
+  if(!OpenOutputFile(output, argv[3], "DeltaMinMeanMaxTotalForce-Order.pyx")) return 1;
+  CreatePlotHeader(output, "DeltaMinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL,  1, 1, "bond order k", "absolute error in total forces [Ht/a.u.]");
+  output << "plot " << Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
+  output << "'DeltaMinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
+  output << "'DeltaMeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
+  output << "'DeltaMaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
+  output.close();
+  // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
+  // min force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "MinForces-Order", 2, "bottom right", "y", "",  1, 1, "bond order k", "absolute approximated min force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+  // mean force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "MeanForces-Order", 2, "bottom right", "y", "",  1, 1, "bond order k", "absolute approximated mean force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", AbsFirstForceValuePlotLine)) return 1;
+  // max force
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "MaxForces-Order", 2, "bottom right", "y", "",  1, 1, "bond order k", "absolute approximated max force [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+  // min/mean/max comparison for total force
+  if(!OpenOutputFile(output, argv[3],"MinMeanMaxTotalForce-Order.pyx")) return 1;
+  CreatePlotHeader(output, "MinMeanMaxTotalForce-Order", 1, "bottom left", "y", NULL, 1, 1, "bond order k", "absolute total force [Ht/a.u.]");
+  output << "plot "<< Orderxrange.str().c_str() << " [1e-8:1e+0] \\" << endl;
+  output << "'MinForces-Order.dat' title 'minimum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints, \\" << endl;
+  output << "'MeanForces-Order.dat' title 'mean' using 1:(abs($" << 8 << ")) with linespoints, \\" << endl;
+  output << "'MaxForces-Order.dat' title 'maximum' using 1:(sqrt($" << 8 << "*$" << 8 << "+$" << 8+1 << "*$" << 8+1 << "+$" << 8+2 << "*$" << 8+2 << ")) with linespoints" << endl;
+  output.close();
+  // ++++++++++++++++++++++++++++++++++++++Plotting vector sum vs. Order
+  if (!CreatePlotOrder(Force, KeySet, argv[3], "VectorSum-Order", 2, "bottom right", "y" ,"", 1, 1, "bond order k", "vector sum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), "", "1" , "with linespoints", ForceMagnitudePlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++Plotting energyfragments vs. order
+  yrange.str("");
+  yrange << "[" << EnergyFragments.FindMinValue() << ":" << EnergyFragments.FindMaxValue() << "]";
+  if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "Energies-Fragment", 5, "below", "y", "", 1, 5, "fragment number", "Energies of each fragment [Ht]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with points", AbsEnergyPlotLine)) return 1;
+  if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "Energies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Energies of each fragment [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with points", AbsEnergyPlotLine)) return 1;
+  if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "MaxEnergies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Maximum fragment energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+  if (!CreatePlotOrder(EnergyFragments, KeySet, argv[3], "MinEnergies-FragmentOrder", 5, "below", "y", "", 1, 1, "bond order", "Minimum fragment energy [Ht]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with linespoints", AbsEnergyPlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++=Ploting min/mean/max forces for each fragment
+  yrange.str("");
+  yrange << "[" << ForceFragments.FindMinValue() << ":" << ForceFragments.FindMaxValue()<< "]";
+  // min
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "minimum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+  // mean
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "mean of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
+  // max
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-Fragment", 5, "below", "y", "set boxwidth 0.2", 1, 5, "fragment number", "maximum of approximated forces [Ht/a.u.]", Fragmentxrange.str().c_str(), yrange.str().c_str(), "2" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++=Ploting min/mean/max forces for each fragment per bond order
+  // min
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MinForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "minimum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+  // mean
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MeanForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "mean of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesFirstForceValuePlotLine)) return 1;
+  // max
+  if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "maximum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
+  // +++++++++++++++++++++++++++++++=Ploting approximated and true shielding for each atom
+  if (periode != NULL) { // also look for PAS values
+    if(!OpenOutputFile(output, argv[3], "ShieldingsPAS-Order.pyx")) return 1;
+    if(!OpenOutputFile(output2, argv[3], "DeltaShieldingsPAS-Order.pyx")) return 1;
+    CreatePlotHeader(output, "ShieldingsPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical shielding value [ppm]");
+    CreatePlotHeader(output2, "DeltaShieldingsPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical shielding value [ppm]");
+    double step=0.8/KeySet.Order;
+    output << "set boxwidth " << step << endl;
+    output << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
+    output2 << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
+    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+      output << "'ShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
+      output2 << "'DeltaShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
+      if (BondOrder-1 != KeySet.Order)
+        output2 << ", \\" << endl;
+    }
+    output << "'ShieldingsPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
+    output2.close();
+    if(!OpenOutputFile(output, argv[3], "ChisPAS-Order.pyx")) return 1;
+    if(!OpenOutputFile(output2, argv[3], "DeltaChisPAS-Order.pyx")) return 1;
+    CreatePlotHeader(output, "ChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
+    CreatePlotHeader(output2, "DeltaChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
+    output << "set boxwidth " << step << endl;
+    output << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
+    output2 << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
+    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+      output << "'ChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
+      output2 << "'DeltaChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
+      if (BondOrder-1 != KeySet.Order)
+        output2 << ", \\" << endl;
+    }
+    output << "'ChisPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
+    output.close();
+    output2.close();
+    if(!OpenOutputFile(output, argv[3], "ChisPAS-Order.pyx")) return 1;
+    if(!OpenOutputFile(output2, argv[3], "DeltaChisPAS-Order.pyx")) return 1;
+    CreatePlotHeader(output, "ChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
+    CreatePlotHeader(output2, "DeltaChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
+    output << "set boxwidth " << step << endl;
+    output << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
+    output2 << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
+    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+      output << "'ChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
+      output2 << "'DeltaChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
+      if (BondOrder-1 != KeySet.Order)
+        output2 << ", \\" << endl;
+    }
+    output << "'ChisPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
+    output.close();
+    output2.close();
+  }
+  // create Makefile
+  if(!OpenOutputFile(output, argv[3], "Makefile")) return 1;
+  output << "PYX = $(shell ls *.pyx)" << endl << endl;
+  output << "EPS = $(PYX:.pyx=.eps)" << endl << endl;
+  output << "%.eps: %.pyx" << endl;
+  output << "\t~/build/pyxplot/pyxplot $<" << endl << endl;
+  output << "all: $(EPS)" << endl << endl;
+  output << ".PHONY: clean" << endl;
+  output << "clean:" << endl;
+  output << "\trm -rf $(EPS)" << endl;
+  output.close();
+  // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
+  delete(periode);
+  Free((void **)&dir, "main: *dir");
+  cout << "done." << endl;
+  return 0;
 };

src/atom.cpp

-              r375b458
+              r51c910
 atom::atom()
+{
         Name = NULL;
         previous = NULL;
         next = NULL;
         father = this;  // generally, father is itself
         Ancestor = NULL;
         type = NULL;
         sort = NULL;
         FixedIon = 0;
         nr = -1;
         GraphNr = -1;
         ComponentNr = NULL;
         IsCyclic = false;
         SeparationVertex = false;
         LowpointNr = -1;
         AdaptiveOrder = 0;
         MaxOrder = false;
+  Name = NULL;
+  previous = NULL;
+  next = NULL;
+  father = this;  // generally, father is itself
+  Ancestor = NULL;
+  type = NULL;
+  sort = NULL;
+  FixedIon = 0;
+  nr = -1;
+  GraphNr = -1;
+  ComponentNr = NULL;
+  IsCyclic = false;
+  SeparationVertex = false;
+  LowpointNr = -1;
+  AdaptiveOrder = 0;
+  MaxOrder = false;
 };
 …
 atom::~atom()
+{
         Free((void **)&Name, "atom::~atom: *Name");
         Free((void **)&ComponentNr, "atom::~atom: *ComponentNr");
+  Free((void **)&Name, "atom::~atom: *Name");
+  Free((void **)&ComponentNr, "atom::~atom: *ComponentNr");
 };
 …
 atom *atom::GetTrueFather()
+{
         atom *walker = this;
         do {
                 if (walker == walker->father) // top most father is the one that points on itself
                         break;
                 walker = walker->father;
         } while (walker != NULL);
         return walker;
+  atom *walker = this;
+  do {
+    if (walker == walker->father) // top most father is the one that points on itself
+      break;
+    walker = walker->father;
+  } while (walker != NULL);
+  return walker;
 };
 …
 bool atom::Output(int ElementNo, int AtomNo, ofstream *out, const char *comment) const
+{
         if (out != NULL) {
                 *out << "Ion_Type" << ElementNo << "_" << AtomNo << "\t"        << fixed << setprecision(9) << showpoint;
                 *out << x.x[0] << "\t" << x.x[1] << "\t" << x.x[2];
                 *out << "\t" << FixedIon;
                 if (v.Norm() > MYEPSILON)
                         *out << "\t" << scientific << setprecision(6) << v.x[0] << "\t" << v.x[1] << "\t" << v.x[2] << "\t";
                 if (comment != NULL)
                   *out << " # " << comment << endl;
                 else
                   *out << " # molecule nr " << nr << endl;
                 return true;
         } else
                 return false;
+  if (out != NULL) {
+    *out << "Ion_Type" << ElementNo << "_" << AtomNo << "\t"  << fixed << setprecision(9) << showpoint;
+    *out << x.x[0] << "\t" << x.x[1] << "\t" << x.x[2];
+    *out << "\t" << FixedIon;
+    if (v.Norm() > MYEPSILON)
+      *out << "\t" << scientific << setprecision(6) << v.x[0] << "\t" << v.x[1] << "\t" << v.x[2] << "\t";
+    if (comment != NULL)
+      *out << " # " << comment << endl;
+    else
+      *out << " # molecule nr " << nr << endl;
+    return true;
+  } else
+    return false;
 };
 …
 bool atom::OutputXYZLine(ofstream *out) const
+{
         if (out != NULL) {
                 *out << type->symbol << "\t" << x.x[0] << "\t" << x.x[1] << "\t" << x.x[2] << "\t" << endl;
                 return true;
         } else
                 return false;
+  if (out != NULL) {
+    *out << type->symbol << "\t" << x.x[0] << "\t" << x.x[1] << "\t" << x.x[2] << "\t" << endl;
+    return true;
+  } else
+    return false;
 };
 ostream & operator << (ostream &ost, atom &a)
+ostream & operator << (ostream &ost, const atom &a)
+{
         ost << "[" << a.Name << "|" << &a << "]";
         return ost;
+  ost << "[" << a.Name << "|" << &a << "]";
+  return ost;
 };
 …
 bool atom::Compare(atom &ptr)
+{
         if (nr < ptr.nr)
                 return true;
         else
                 return false;
+  if (nr < ptr.nr)
+    return true;
+  else
+    return false;
 };
 bool operator < (atom &a, atom &b)
+{
         return a.Compare(b);
+  return a.Compare(b);
 };

src/bond.cpp

-              r375b458
+              r51c910
 bond::bond()
+{
         leftatom = NULL;
         rightatom = NULL;
         previous = NULL;
         next = NULL;
         nr = -1;
         HydrogenBond = 0;
         BondDegree = 0;
         Used = white;
         Cyclic = false;
         Type = Undetermined;
+  leftatom = NULL;
+  rightatom = NULL;
+  previous = NULL;
+  next = NULL;
+  nr = -1;
+  HydrogenBond = 0;
+  BondDegree = 0;
+  Used = white;
+  Cyclic = false;
+  Type = Undetermined;
 };
 …
 bond::bond(atom *left, atom *right, int degree=1, int number=0)
+{
         leftatom = left;
         rightatom = right;
         previous = NULL;
         next = NULL;
         HydrogenBond = 0;
         if ((left != NULL) && (right != NULL)) {
                 if ((left->type != NULL) && (left->type->Z == 1))
                         HydrogenBond++;
                 if ((right->type != NULL) && (right->type->Z == 1))
                         HydrogenBond++;
+        }
         BondDegree = degree;
         nr = number;
         Used = white;
         Cyclic = false;
+  leftatom = left;
+  rightatom = right;
+  previous = NULL;
+  next = NULL;
+  HydrogenBond = 0;
+  if ((left != NULL) && (right != NULL)) {
+    if ((left->type != NULL) && (left->type->Z == 1))
+      HydrogenBond++;
+    if ((right->type != NULL) && (right->type->Z == 1))
+      HydrogenBond++;
+  }
+  BondDegree = degree;
+  nr = number;
+  Used = white;
+  Cyclic = false;
 };
 bond::bond(atom *left, atom *right)
+{
         leftatom = left;
         rightatom = right;
         previous = NULL;
         next = NULL;
         HydrogenBond = 0;
         if ((left != NULL) && (right != NULL)) {
                 if ((left->type != NULL) && (left->type->Z == 1))
                         HydrogenBond++;
                 if ((right->type != NULL) && (right->type->Z == 1))
                         HydrogenBond++;
+        }
         BondDegree = 1;
         nr = 0;
         Used = white;
         Cyclic = false;
+  leftatom = left;
+  rightatom = right;
+  previous = NULL;
+  next = NULL;
+  HydrogenBond = 0;
+  if ((left != NULL) && (right != NULL)) {
+    if ((left->type != NULL) && (left->type->Z == 1))
+      HydrogenBond++;
+    if ((right->type != NULL) && (right->type->Z == 1))
+      HydrogenBond++;
+  }
+  BondDegree = 1;
+  nr = 0;
+  Used = white;
+  Cyclic = false;
 };
 …
 bond::~bond()
+{
         // remove this node from the list structure
         if (previous != NULL) {
                 previous->next = next;
+        }
         if (next != NULL) {
                 next->previous = previous;
+        }
+  // remove this node from the list structure
+  if (previous != NULL) {
+    previous->next = next;
+  }
+  if (next != NULL) {
+    next->previous = previous;
+  }
 };
 ostream & operator << (ostream &ost, bond &b)
+ostream & operator << (ostream &ost, const bond &b)
+{
         ost << "[" << b.leftatom->Name << " <" << b.BondDegree << "(H" << b.HydrogenBond << ")>" << b.rightatom->Name << "]";
         return ost;
+  ost << "[" << b.leftatom->Name << " <" << b.BondDegree << "(H" << b.HydrogenBond << ")>" << b.rightatom->Name << "]";
+  return ost;
 };
 …
 atom * bond::GetOtherAtom(atom *Atom) const
+{
+        if(leftatom == Atom)
+                return rightatom;
+        if(rightatom == Atom)
+                return leftatom;
+        return NULL;
+  if(leftatom == Atom)
+    return rightatom;
+  if(rightatom == Atom)
+    return leftatom;
+  cerr << "Bond " << *this << " does not contain atom " << *Atom << "!" << endl;
+  return NULL;
 };
 …
 bond * bond::GetFirstBond()
+{
         return GetFirst(this);
+  return GetFirst(this);
 };
 …
 bond * bond::GetLastBond()
+{
         return GetLast(this);
+  return GetLast(this);
 };
 …
 enum Shading bond::IsUsed()
+{
         return Used;
+  return Used;
 };
 …
 bool bond::Contains(const atom *ptr)
+{
         return ((leftatom == ptr) || (rightatom == ptr));
+  return ((leftatom == ptr) || (rightatom == ptr));
 };
 …
 bool bond::Contains(const int number)
+{
         return ((leftatom->nr == number) || (rightatom->nr == number));
+  return ((leftatom->nr == number) || (rightatom->nr == number));
 };
 …
  */
 bool bond::MarkUsed(enum Shading color) {
         if (Used == black) {
                 cerr << "ERROR: Bond " << this << " was already marked black!." << endl;
                 return false;
         } else {
                 Used = color;
                 return true;
+        }
+  if (Used == black) {
+    cerr << "ERROR: Bond " << this << " was already marked black!." << endl;
+    return false;
+  } else {
+    Used = color;
+    return true;
+  }
 };
 …
  */
 void bond::ResetUsed() {
         Used = white;
+  Used = white;
 };

src/boundary.cpp

-              r375b458
+              r51c910
 BoundaryPointSet::BoundaryPointSet()
+{
         LinesCount = 0;
         Nr = -1;
+  LinesCount = 0;
+  Nr = -1;
+}
+;
 …
 BoundaryPointSet::BoundaryPointSet(atom *Walker)
+{
         node = Walker;
         LinesCount = 0;
         Nr = Walker->nr;
+  node = Walker;
+  LinesCount = 0;
+  Nr = Walker->nr;
+}
+;
 …
 BoundaryPointSet::~BoundaryPointSet()
+{
+        cout << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
+        if (!lines.empty())
+                cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some lines." << endl;
+        node = NULL;
+  cout << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
+  if (!lines.empty())
+    cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some lines." << endl;
+  node = NULL;
+  lines.clear();
+}
+;
 …
 void BoundaryPointSet::AddLine(class BoundaryLineSet *line)
+{
         cout << Verbose(6) << "Adding " << *this << " to line " << *line << "."
                         << endl;
         if (line->endpoints[0] == this)
+                {
                         lines.insert(LinePair(line->endpoints[1]->Nr, line));
+                }
         else
+                {
                         lines.insert(LinePair(line->endpoints[0]->Nr, line));
+                }
         LinesCount++;
+  cout << Verbose(6) << "Adding " << *this << " to line " << *line << "."
+      << endl;
+  if (line->endpoints[0] == this)
+    {
+      lines.insert(LinePair(line->endpoints[1]->Nr, line));
+    }
+  else
+    {
+      lines.insert(LinePair(line->endpoints[0]->Nr, line));
+    }
+  LinesCount++;
+}
+;
 …
 operator <<(ostream &ost, BoundaryPointSet &a)
+{
         ost << "[" << a.Nr << "|" << a.node->Name << "]";
         return ost;
+  ost << "[" << a.Nr << "|" << a.node->Name << "]";
+  return ost;
+}
+;
 …
 BoundaryLineSet::BoundaryLineSet()
+{
         for (int i = 0; i < 2; i++)
                 endpoints[i] = NULL;
         TrianglesCount = 0;
         Nr = -1;
+  for (int i = 0; i < 2; i++)
+    endpoints[i] = NULL;
+  TrianglesCount = 0;
+  Nr = -1;
+}
+;
 …
 BoundaryLineSet::BoundaryLineSet(class BoundaryPointSet *Point[2], int number)
+{
         // set number
         Nr = number;
         // set endpoints in ascending order
         SetEndpointsOrdered(endpoints, Point[0], Point[1]);
         // add this line to the hash maps of both endpoints
         Point[0]->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
         Point[1]->AddLine(this); //
         // clear triangles list
         TrianglesCount = 0;
         cout << Verbose(5) << "New Line with endpoints " << *this << "." << endl;
+  // set number
+  Nr = number;
+  // set endpoints in ascending order
+  SetEndpointsOrdered(endpoints, Point[0], Point[1]);
+  // add this line to the hash maps of both endpoints
+  Point[0]->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
+  Point[1]->AddLine(this); //
+  // clear triangles list
+  TrianglesCount = 0;
+  cout << Verbose(5) << "New Line with endpoints " << *this << "." << endl;
+}
+;
 …
 BoundaryLineSet::~BoundaryLineSet()
+{
+        int Numbers[2];
+        Numbers[0] = endpoints[1]->Nr;
+        Numbers[1] = endpoints[0]->Nr;
+        for (int i = 0; i < 2; i++) {
+                cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
+                endpoints[i]->lines.erase(Numbers[i]);
+                if (endpoints[i]->lines.empty()) {
+                        cout << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
+                        if (endpoints[i] != NULL) {
+                                delete(endpoints[i]);
+                                endpoints[i] = NULL;
+                        } else
+                                cerr << "ERROR: Endpoint " << i << " has already been free'd." << endl;
+                } else
+                        cout << Verbose(5) << *endpoints[i] << " has still lines it's attached to." << endl;
+        }
+        if (!triangles.empty())
+                cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some triangles." << endl;
+  for (int i = 0; i < 2; i++) {
+    cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
+    endpoints[i]->lines.erase(Nr);
+    LineMap::iterator tester = endpoints[i]->lines.begin();
+    tester++;
+    if (tester == endpoints[i]->lines.end()) {
+      cout << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
+      if (endpoints[i] != NULL) {
+        delete(endpoints[i]);
+        endpoints[i] = NULL;
+      } else
+        cerr << "ERROR: Endpoint " << i << " has already been free'd." << endl;
+    } else
+      cout << Verbose(5) << *endpoints[i] << " has still lines it's attached to." << endl;
+  }
+  if (!triangles.empty())
+    cerr << "WARNING: Memory Leak! I " << *this << " am still connected to some triangles." << endl;
+}
+;
 …
 BoundaryLineSet::AddTriangle(class BoundaryTriangleSet *triangle)
+{
         cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
                         << endl;
         triangles.insert(TrianglePair(triangle->Nr, triangle));
         TrianglesCount++;
+  cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
+      << endl;
+  triangles.insert(TrianglePair(triangle->Nr, triangle));
+  TrianglesCount++;
+}
+;
 …
 operator <<(ostream &ost, BoundaryLineSet &a)
+{
         ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
                         << a.endpoints[1]->node->Name << "]";
         return ost;
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
+      << a.endpoints[1]->node->Name << "]";
+  return ost;
+}
+;
 …
 BoundaryTriangleSet::BoundaryTriangleSet()
+{
         for (int i = 0; i < 3; i++)
+                {
                         endpoints[i] = NULL;
                         lines[i] = NULL;
+                }
         Nr = -1;
+  for (int i = 0; i < 3; i++)
+    {
+      endpoints[i] = NULL;
+      lines[i] = NULL;
+    }
+  Nr = -1;
+}
+;
 BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3],
                 int number)
+{
         // set number
         Nr = number;
         // set lines
         cout << Verbose(5) << "New triangle " << Nr << ":" << endl;
         for (int i = 0; i < 3; i++)
+                {
                         lines[i] = line[i];
                         lines[i]->AddTriangle(this);
+                }
         // get ascending order of endpoints
         map<int, class BoundaryPointSet *> OrderMap;
         for (int i = 0; i < 3; i++)
                 // for all three lines
                 for (int j = 0; j < 2; j++)
                         { // for both endpoints
                                 OrderMap.insert(pair<int, class BoundaryPointSet *> (
                                                 line[i]->endpoints[j]->Nr, line[i]->endpoints[j]));
                                 // and we don't care whether insertion fails
+                        }
         // set endpoints
         int Counter = 0;
         cout << Verbose(6) << " with end points ";
         for (map<int, class BoundaryPointSet *>::iterator runner = OrderMap.begin(); runner
                         != OrderMap.end(); runner++)
+                {
                         endpoints[Counter] = runner->second;
                         cout << " " << *endpoints[Counter];
                         Counter++;
+                }
         if (Counter < 3)
+                {
                         cerr << "ERROR! We have a triangle with only two distinct endpoints!"
                                         << endl;
                         //exit(1);
+                }
         cout << "." << endl;
+    int number)
+{
+  // set number
+  Nr = number;
+  // set lines
+  cout << Verbose(5) << "New triangle " << Nr << ":" << endl;
+  for (int i = 0; i < 3; i++)
+    {
+      lines[i] = line[i];
+      lines[i]->AddTriangle(this);
+    }
+  // get ascending order of endpoints
+  map<int, class BoundaryPointSet *> OrderMap;
+  for (int i = 0; i < 3; i++)
+    // for all three lines
+    for (int j = 0; j < 2; j++)
+      { // for both endpoints
+        OrderMap.insert(pair<int, class BoundaryPointSet *> (
+            line[i]->endpoints[j]->Nr, line[i]->endpoints[j]));
+        // and we don't care whether insertion fails
+      }
+  // set endpoints
+  int Counter = 0;
+  cout << Verbose(6) << " with end points ";
+  for (map<int, class BoundaryPointSet *>::iterator runner = OrderMap.begin(); runner
+      != OrderMap.end(); runner++)
+    {
+      endpoints[Counter] = runner->second;
+      cout << " " << *endpoints[Counter];
+      Counter++;
+    }
+  if (Counter < 3)
+    {
+      cerr << "ERROR! We have a triangle with only two distinct endpoints!"
+          << endl;
+      //exit(1);
+    }
+  cout << "." << endl;
+}
+;
 …
 BoundaryTriangleSet::~BoundaryTriangleSet()
+{
         for (int i = 0; i < 3; i++) {
                 cout << Verbose(5) << "Erasing triangle Nr." << Nr << endl;
                 lines[i]->triangles.erase(Nr);
                 if (lines[i]->triangles.empty()) {
                         cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
                         if (lines[i] != NULL) {
                                 delete (lines[i]);
                                 lines[i] = NULL;
                         } else
                                 cerr << "ERROR: This line " << i << " has already been free'd." << endl;
                 } else
                         cout << Verbose(5) << *lines[i] << " is still attached to a triangle." << endl;
+        }
+  for (int i = 0; i < 3; i++) {
+    cout << Verbose(5) << "Erasing triangle Nr." << Nr << endl;
+    lines[i]->triangles.erase(Nr);
+    if (lines[i]->triangles.empty()) {
+      cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
+      if (lines[i] != NULL) {
+        delete (lines[i]);
+        lines[i] = NULL;
+      } else
+        cerr << "ERROR: This line " << i << " has already been free'd." << endl;
+    } else
+      cout << Verbose(5) << *lines[i] << " is still attached to a triangle." << endl;
+  }
+}
+;
 …
 BoundaryTriangleSet::GetNormalVector(Vector &OtherVector)
+{
         // get normal vector
         NormalVector.MakeNormalVector(&endpoints[0]->node->x, &endpoints[1]->node->x,
                         &endpoints[2]->node->x);
         // make it always point inward (any offset vector onto plane projected onto normal vector suffices)
         if (NormalVector.Projection(&OtherVector) > 0)
                 NormalVector.Scale(-1.);
+  // get normal vector
+  NormalVector.MakeNormalVector(&endpoints[0]->node->x, &endpoints[1]->node->x,
+      &endpoints[2]->node->x);
+  // make it always point inward (any offset vector onto plane projected onto normal vector suffices)
+  if (NormalVector.Projection(&OtherVector) > 0)
+    NormalVector.Scale(-1.);
+}
+;
 …
 operator <<(ostream &ost, BoundaryTriangleSet &a)
+{
         ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
                         << a.endpoints[1]->node->Name << "," << a.endpoints[2]->node->Name << "]";
         return ost;
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
+      << a.endpoints[1]->node->Name << "," << a.endpoints[2]->node->Name << "]";
+  return ost;
+}
+;
 …
 GetCommonEndpoint(class BoundaryLineSet * line1, class BoundaryLineSet * line2)
+{
         class BoundaryLineSet * lines[2] =
                 { line1, line2 };
         class BoundaryPointSet *node = NULL;
         map<int, class BoundaryPointSet *> OrderMap;
         pair<map<int, class BoundaryPointSet *>::iterator, bool> OrderTest;
         for (int i = 0; i < 2; i++)
                 // for both lines
                 for (int j = 0; j < 2; j++)
                         { // for both endpoints
                                 OrderTest = OrderMap.insert(pair<int, class BoundaryPointSet *> (
                                                 lines[i]->endpoints[j]->Nr, lines[i]->endpoints[j]));
                                 if (!OrderTest.second)
                                         { // if insertion fails, we have common endpoint
                                                 node = OrderTest.first->second;
                                                 cout << Verbose(5) << "Common endpoint of lines " << *line1
                                                                 << " and " << *line2 << " is: " << *node << "." << endl;
                                                 j = 2;
                                                 i = 2;
                                                 break;
+                                        }
+                        }
         return node;
+  class BoundaryLineSet * lines[2] =
+    { line1, line2 };
+  class BoundaryPointSet *node = NULL;
+  map<int, class BoundaryPointSet *> OrderMap;
+  pair<map<int, class BoundaryPointSet *>::iterator, bool> OrderTest;
+  for (int i = 0; i < 2; i++)
+    // for both lines
+    for (int j = 0; j < 2; j++)
+      { // for both endpoints
+        OrderTest = OrderMap.insert(pair<int, class BoundaryPointSet *> (
+            lines[i]->endpoints[j]->Nr, lines[i]->endpoints[j]));
+        if (!OrderTest.second)
+          { // if insertion fails, we have common endpoint
+            node = OrderTest.first->second;
+            cout << Verbose(5) << "Common endpoint of lines " << *line1
+                << " and " << *line2 << " is: " << *node << "." << endl;
+            j = 2;
+            i = 2;
+            break;
+          }
+      }
+  return node;
+}
+;
 …
 GetBoundaryPoints(ofstream *out, molecule *mol)
+{
         atom *Walker = NULL;
         PointMap PointsOnBoundary;
         LineMap LinesOnBoundary;
         TriangleMap TrianglesOnBoundary;
         *out << Verbose(1) << "Finding all boundary points." << endl;
         Boundaries *BoundaryPoints = new Boundaries[NDIM]; // first is alpha, second is (r, nr)
         BoundariesTestPair BoundaryTestPair;
         Vector AxisVector, AngleReferenceVector, AngleReferenceNormalVector;
         double radius, angle;
         // 3a. Go through every axis
         for (int axis = 0; axis < NDIM; axis++)
+                {
                         AxisVector.Zero();
                         AngleReferenceVector.Zero();
                         AngleReferenceNormalVector.Zero();
                         AxisVector.x[axis] = 1.;
                         AngleReferenceVector.x[(axis + 1) % NDIM] = 1.;
                         AngleReferenceNormalVector.x[(axis + 2) % NDIM] = 1.;
                         //              *out << Verbose(1) << "Axisvector is ";
                         //              AxisVector.Output(out);
                         //              *out << " and AngleReferenceVector is ";
                         //              AngleReferenceVector.Output(out);
                         //              *out << "." << endl;
                         //              *out << " and AngleReferenceNormalVector is ";
                         //              AngleReferenceNormalVector.Output(out);
                         //              *out << "." << endl;
                         // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
                         Walker = mol->start;
                         while (Walker->next != mol->end)
+                                {
                                         Walker = Walker->next;
                                         Vector ProjectedVector;
                                         ProjectedVector.CopyVector(&Walker->x);
                                         ProjectedVector.ProjectOntoPlane(&AxisVector);
                                         // correct for negative side
                                         //if (Projection(y) < 0)
                                         //angle = 2.*M_PI - angle;
                                         radius = ProjectedVector.Norm();
                                         if (fabs(radius) > MYEPSILON)
                                                 angle = ProjectedVector.Angle(&AngleReferenceVector);
                                         else
                                                 angle = 0.; // otherwise it's a vector in Axis Direction and unimportant for boundary issues
                                         //*out << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
                                         if (ProjectedVector.Projection(&AngleReferenceNormalVector) > 0)
+                                                {
                                                         angle = 2. * M_PI - angle;
+                                                }
                                         //*out << Verbose(2) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): ";
                                         //ProjectedVector.Output(out);
                                         //*out << endl;
                                         BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle,
                                                         DistancePair (radius, Walker)));
                                         if (BoundaryTestPair.second)
                                                 { // successfully inserted
+                                                }
                                         else
                                                 { // same point exists, check first r, then distance of original vectors to center of gravity
                                                         *out << Verbose(2)
                                                                         << "Encountered two vectors whose projection onto axis "
                                                                         << axis << " is equal: " << endl;
                                                         *out << Verbose(2) << "Present vector: ";
                                                         BoundaryTestPair.first->second.second->x.Output(out);
                                                         *out << endl;
                                                         *out << Verbose(2) << "New vector: ";
                                                         Walker->x.Output(out);
                                                         *out << endl;
                                                         double tmp = ProjectedVector.Norm();
                                                         if (tmp > BoundaryTestPair.first->second.first)
+                                                                {
                                                                         BoundaryTestPair.first->second.first = tmp;
                                                                         BoundaryTestPair.first->second.second = Walker;
                                                                         *out << Verbose(2) << "Keeping new vector." << endl;
+                                                                }
                                                         else if (tmp == BoundaryTestPair.first->second.first)
+                                                                {
                                                                         if (BoundaryTestPair.first->second.second->x.ScalarProduct(
                                                                                         &BoundaryTestPair.first->second.second->x)
                                                                                         < Walker->x.ScalarProduct(&Walker->x))
                                                                                 { // Norm() does a sqrt, which makes it a lot slower
                                                                                         BoundaryTestPair.first->second.second = Walker;
                                                                                         *out << Verbose(2) << "Keeping new vector." << endl;
+                                                                                }
                                                                         else
+                                                                                {
                                                                                         *out << Verbose(2) << "Keeping present vector." << endl;
+                                                                                }
+                                                                }
                                                         else
+                                                                {
                                                                         *out << Verbose(2) << "Keeping present vector." << endl;
+                                                                }
+                                                }
+                                }
                         // printing all inserted for debugging
                         //              {
                         //                      *out << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
                         //                      int i=0;
                         //                      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
                         //                              if (runner != BoundaryPoints[axis].begin())
                         //                                      *out << ", " << i << ": " << *runner->second.second;
                         //                              else
                         //                                      *out << i << ": " << *runner->second.second;
                         //                              i++;
                         //                      }
                         //                      *out << endl;
                         //              }
                         // 3c. throw out points whose distance is less than the mean of left and right neighbours
                         bool flag = false;
                         do
                                 { // do as long as we still throw one out per round
                                         *out << Verbose(1)
                                                         << "Looking for candidates to kick out by convex condition ... "
                                                         << endl;
                                         flag = false;
                                         Boundaries::iterator left = BoundaryPoints[axis].end();
                                         Boundaries::iterator right = BoundaryPoints[axis].end();
                                         for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
                                                         != BoundaryPoints[axis].end(); runner++)
+                                                {
                                                         // set neighbours correctly
                                                         if (runner == BoundaryPoints[axis].begin())
+                                                                {
                                                                         left = BoundaryPoints[axis].end();
+                                                                }
                                                         else
+                                                                {
                                                                         left = runner;
+                                                                }
                                                         left--;
                                                         right = runner;
                                                         right++;
                                                         if (right == BoundaryPoints[axis].end())
+                                                                {
                                                                         right = BoundaryPoints[axis].begin();
+                                                                }
                                                         // check distance
                                                         // construct the vector of each side of the triangle on the projected plane (defined by normal vector AxisVector)
+                                                                {
                                                                         Vector SideA, SideB, SideC, SideH;
                                                                         SideA.CopyVector(&left->second.second->x);
                                                                         SideA.ProjectOntoPlane(&AxisVector);
                                                                         //                                      *out << "SideA: ";
                                                                         //                                      SideA.Output(out);
                                                                         //                                      *out << endl;
                                                                         SideB.CopyVector(&right->second.second->x);
                                                                         SideB.ProjectOntoPlane(&AxisVector);
                                                                         //                                      *out << "SideB: ";
                                                                         //                                      SideB.Output(out);
                                                                         //                                      *out << endl;
                                                                         SideC.CopyVector(&left->second.second->x);
                                                                         SideC.SubtractVector(&right->second.second->x);
                                                                         SideC.ProjectOntoPlane(&AxisVector);
                                                                         //                                      *out << "SideC: ";
                                                                         //                                      SideC.Output(out);
                                                                         //                                      *out << endl;
                                                                         SideH.CopyVector(&runner->second.second->x);
                                                                         SideH.ProjectOntoPlane(&AxisVector);
                                                                         //                                      *out << "SideH: ";
                                                                         //                                      SideH.Output(out);
                                                                         //                                      *out << endl;
                                                                         // calculate each length
                                                                         double a = SideA.Norm();
                                                                         //double b = SideB.Norm();
                                                                         //double c = SideC.Norm();
                                                                         double h = SideH.Norm();
                                                                         // calculate the angles
                                                                         double alpha = SideA.Angle(&SideH);
                                                                         double beta = SideA.Angle(&SideC);
                                                                         double gamma = SideB.Angle(&SideH);
                                                                         double delta = SideC.Angle(&SideH);
                                                                         double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha
                                                                                         < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
                                                                         //                                      *out << Verbose(2) << " I calculated: a = " << a << ", h = " << h << ", beta(" << left->second.second->Name << "," << left->second.second->Name << "-" << right->second.second->Name << ") = " << beta << ", delta(" << left->second.second->Name << "," << runner->second.second->Name << ") = " << delta << ", Min = " << MinDistance << "." << endl;
                                                                         //*out << Verbose(1) << "Checking CoG distance of runner " << *runner->second.second << " " << h << " against triangle's side length spanned by (" << *left->second.second << "," << *right->second.second << ") of " << MinDistance << "." << endl;
                                                                         if ((fabs(h / fabs(h) - MinDistance / fabs(MinDistance))
                                                                                         < MYEPSILON) && (h < MinDistance))
+                                                                                {
                                                                                         // throw out point
                                                                                         //*out << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl;
                                                                                         BoundaryPoints[axis].erase(runner);
                                                                                         flag = true;
+                                                                                }
+                                                                }
+                                                }
+                                }
                         while (flag);
+                }
         return BoundaryPoints;
+  atom *Walker = NULL;
+  PointMap PointsOnBoundary;
+  LineMap LinesOnBoundary;
+  TriangleMap TrianglesOnBoundary;
+  *out << Verbose(1) << "Finding all boundary points." << endl;
+  Boundaries *BoundaryPoints = new Boundaries[NDIM]; // first is alpha, second is (r, nr)
+  BoundariesTestPair BoundaryTestPair;
+  Vector AxisVector, AngleReferenceVector, AngleReferenceNormalVector;
+  double radius, angle;
+  // 3a. Go through every axis
+  for (int axis = 0; axis < NDIM; axis++)
+    {
+      AxisVector.Zero();
+      AngleReferenceVector.Zero();
+      AngleReferenceNormalVector.Zero();
+      AxisVector.x[axis] = 1.;
+      AngleReferenceVector.x[(axis + 1) % NDIM] = 1.;
+      AngleReferenceNormalVector.x[(axis + 2) % NDIM] = 1.;
+      //    *out << Verbose(1) << "Axisvector is ";
+      //    AxisVector.Output(out);
+      //    *out << " and AngleReferenceVector is ";
+      //    AngleReferenceVector.Output(out);
+      //    *out << "." << endl;
+      //    *out << " and AngleReferenceNormalVector is ";
+      //    AngleReferenceNormalVector.Output(out);
+      //    *out << "." << endl;
+      // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
+      Walker = mol->start;
+      while (Walker->next != mol->end)
+        {
+          Walker = Walker->next;
+          Vector ProjectedVector;
+          ProjectedVector.CopyVector(&Walker->x);
+          ProjectedVector.ProjectOntoPlane(&AxisVector);
+          // correct for negative side
+          //if (Projection(y) < 0)
+          //angle = 2.*M_PI - angle;
+          radius = ProjectedVector.Norm();
+          if (fabs(radius) > MYEPSILON)
+            angle = ProjectedVector.Angle(&AngleReferenceVector);
+          else
+            angle = 0.; // otherwise it's a vector in Axis Direction and unimportant for boundary issues
+          //*out << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
+          if (ProjectedVector.Projection(&AngleReferenceNormalVector) > 0)
+            {
+              angle = 2. * M_PI - angle;
+            }
+          //*out << Verbose(2) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): ";
+          //ProjectedVector.Output(out);
+          //*out << endl;
+          BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle,
+              DistancePair (radius, Walker)));
+          if (BoundaryTestPair.second)
+            { // successfully inserted
+            }
+          else
+            { // same point exists, check first r, then distance of original vectors to center of gravity
+              *out << Verbose(2)
+                  << "Encountered two vectors whose projection onto axis "
+                  << axis << " is equal: " << endl;
+              *out << Verbose(2) << "Present vector: ";
+              BoundaryTestPair.first->second.second->x.Output(out);
+              *out << endl;
+              *out << Verbose(2) << "New vector: ";
+              Walker->x.Output(out);
+              *out << endl;
+              double tmp = ProjectedVector.Norm();
+              if (tmp > BoundaryTestPair.first->second.first)
+                {
+                  BoundaryTestPair.first->second.first = tmp;
+                  BoundaryTestPair.first->second.second = Walker;
+                  *out << Verbose(2) << "Keeping new vector." << endl;
+                }
+              else if (tmp == BoundaryTestPair.first->second.first)
+                {
+                  if (BoundaryTestPair.first->second.second->x.ScalarProduct(
+                      &BoundaryTestPair.first->second.second->x)
+                      < Walker->x.ScalarProduct(&Walker->x))
+                    { // Norm() does a sqrt, which makes it a lot slower
+                      BoundaryTestPair.first->second.second = Walker;
+                      *out << Verbose(2) << "Keeping new vector." << endl;
+                    }
+                  else
+                    {
+                      *out << Verbose(2) << "Keeping present vector." << endl;
+                    }
+                }
+              else
+                {
+                  *out << Verbose(2) << "Keeping present vector." << endl;
+                }
+            }
+        }
+      // printing all inserted for debugging
+      //    {
+      //      *out << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
+      //      int i=0;
+      //      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+      //        if (runner != BoundaryPoints[axis].begin())
+      //          *out << ", " << i << ": " << *runner->second.second;
+      //        else
+      //          *out << i << ": " << *runner->second.second;
+      //        i++;
+      //      }
+      //      *out << endl;
+      //    }
+      // 3c. throw out points whose distance is less than the mean of left and right neighbours
+      bool flag = false;
+      do
+        { // do as long as we still throw one out per round
+          *out << Verbose(1)
+              << "Looking for candidates to kick out by convex condition ... "
+              << endl;
+          flag = false;
+          Boundaries::iterator left = BoundaryPoints[axis].end();
+          Boundaries::iterator right = BoundaryPoints[axis].end();
+          for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
+              != BoundaryPoints[axis].end(); runner++)
+            {
+              // set neighbours correctly
+              if (runner == BoundaryPoints[axis].begin())
+                {
+                  left = BoundaryPoints[axis].end();
+                }
+              else
+                {
+                  left = runner;
+                }
+              left--;
+              right = runner;
+              right++;
+              if (right == BoundaryPoints[axis].end())
+                {
+                  right = BoundaryPoints[axis].begin();
+                }
+              // check distance
+              // construct the vector of each side of the triangle on the projected plane (defined by normal vector AxisVector)
+                {
+                  Vector SideA, SideB, SideC, SideH;
+                  SideA.CopyVector(&left->second.second->x);
+                  SideA.ProjectOntoPlane(&AxisVector);
+                  //          *out << "SideA: ";
+                  //          SideA.Output(out);
+                  //          *out << endl;
+                  SideB.CopyVector(&right->second.second->x);
+                  SideB.ProjectOntoPlane(&AxisVector);
+                  //          *out << "SideB: ";
+                  //          SideB.Output(out);
+                  //          *out << endl;
+                  SideC.CopyVector(&left->second.second->x);
+                  SideC.SubtractVector(&right->second.second->x);
+                  SideC.ProjectOntoPlane(&AxisVector);
+                  //          *out << "SideC: ";
+                  //          SideC.Output(out);
+                  //          *out << endl;
+                  SideH.CopyVector(&runner->second.second->x);
+                  SideH.ProjectOntoPlane(&AxisVector);
+                  //          *out << "SideH: ";
+                  //          SideH.Output(out);
+                  //          *out << endl;
+                  // calculate each length
+                  double a = SideA.Norm();
+                  //double b = SideB.Norm();
+                  //double c = SideC.Norm();
+                  double h = SideH.Norm();
+                  // calculate the angles
+                  double alpha = SideA.Angle(&SideH);
+                  double beta = SideA.Angle(&SideC);
+                  double gamma = SideB.Angle(&SideH);
+                  double delta = SideC.Angle(&SideH);
+                  double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha
+                      < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
+                  //          *out << Verbose(2) << " I calculated: a = " << a << ", h = " << h << ", beta(" << left->second.second->Name << "," << left->second.second->Name << "-" << right->second.second->Name << ") = " << beta << ", delta(" << left->second.second->Name << "," << runner->second.second->Name << ") = " << delta << ", Min = " << MinDistance << "." << endl;
+                  //*out << Verbose(1) << "Checking CoG distance of runner " << *runner->second.second << " " << h << " against triangle's side length spanned by (" << *left->second.second << "," << *right->second.second << ") of " << MinDistance << "." << endl;
+                  if ((fabs(h / fabs(h) - MinDistance / fabs(MinDistance))
+                      < MYEPSILON) && (h < MinDistance))
+                    {
+                      // throw out point
+                      //*out << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl;
+                      BoundaryPoints[axis].erase(runner);
+                      flag = true;
+                    }
+                }
+            }
+        }
+      while (flag);
+    }
+  return BoundaryPoints;
+}
+;
 …
 double *
 GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol,
                 bool IsAngstroem)
+{
         // get points on boundary of NULL was given as parameter
         bool BoundaryFreeFlag = false;
         Boundaries *BoundaryPoints = BoundaryPtr;
         if (BoundaryPoints == NULL)
+                {
                         BoundaryFreeFlag = true;
                         BoundaryPoints = GetBoundaryPoints(out, mol);
+                }
         else
+                {
                         *out << Verbose(1) << "Using given boundary points set." << endl;
+                }
         // determine biggest "diameter" of cluster for each axis
         Boundaries::iterator Neighbour, OtherNeighbour;
         double *GreatestDiameter = new double[NDIM];
         for (int i = 0; i < NDIM; i++)
                 GreatestDiameter[i] = 0.;
         double OldComponent, tmp, w1, w2;
         Vector DistanceVector, OtherVector;
         int component, Othercomponent;
         for (int axis = 0; axis < NDIM; axis++)
                 { // regard each projected plane
                         //*out << Verbose(1) << "Current axis is " << axis << "." << endl;
                         for (int j = 0; j < 2; j++)
                                 { // and for both axis on the current plane
                                         component = (axis + j + 1) % NDIM;
                                         Othercomponent = (axis + 1 + ((j + 1) & 1)) % NDIM;
                                         //*out << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
                                         for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
                                                         != BoundaryPoints[axis].end(); runner++)
+                                                {
                                                         //*out << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
                                                         // seek for the neighbours pair where the Othercomponent sign flips
                                                         Neighbour = runner;
                                                         Neighbour++;
                                                         if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
                                                                 Neighbour = BoundaryPoints[axis].begin();
                                                         DistanceVector.CopyVector(&runner->second.second->x);
                                                         DistanceVector.SubtractVector(&Neighbour->second.second->x);
                                                         do
                                                                 { // seek for neighbour pair where it flips
                                                                         OldComponent = DistanceVector.x[Othercomponent];
                                                                         Neighbour++;
                                                                         if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
                                                                                 Neighbour = BoundaryPoints[axis].begin();
                                                                         DistanceVector.CopyVector(&runner->second.second->x);
                                                                         DistanceVector.SubtractVector(&Neighbour->second.second->x);
                                                                         //*out << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
+                                                                }
                                                         while ((runner != Neighbour) && (fabs(OldComponent / fabs(
                                                                         OldComponent) - DistanceVector.x[Othercomponent] / fabs(
                                                                         DistanceVector.x[Othercomponent])) < MYEPSILON)); // as long as sign does not flip
                                                         if (runner != Neighbour)
+                                                                {
                                                                         OtherNeighbour = Neighbour;
                                                                         if (OtherNeighbour == BoundaryPoints[axis].begin()) // make it wrap around
                                                                                 OtherNeighbour = BoundaryPoints[axis].end();
                                                                         OtherNeighbour--;
                                                                         //*out << Verbose(2) << "The pair, where the sign of OtherComponent flips, is: " << *(Neighbour->second.second) << " and " << *(OtherNeighbour->second.second) << "." << endl;
                                                                         // now we have found the pair: Neighbour and OtherNeighbour
                                                                         OtherVector.CopyVector(&runner->second.second->x);
                                                                         OtherVector.SubtractVector(&OtherNeighbour->second.second->x);
                                                                         //*out << Verbose(2) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
                                                                         //*out << Verbose(2) << "OtherComponents to Neighbour and OtherNeighbour are " << DistanceVector.x[Othercomponent] << " and " << OtherVector.x[Othercomponent] << "." << endl;
                                                                         // do linear interpolation between points (is exact) to extract exact intersection between Neighbour and OtherNeighbour
                                                                         w1 = fabs(OtherVector.x[Othercomponent]);
                                                                         w2 = fabs(DistanceVector.x[Othercomponent]);
                                                                         tmp = fabs((w1 * DistanceVector.x[component] + w2
                                                                                         * OtherVector.x[component]) / (w1 + w2));
                                                                         // mark if it has greater diameter
                                                                         //*out << Verbose(2) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
                                                                         GreatestDiameter[component] = (GreatestDiameter[component]
                                                                                         > tmp) ? GreatestDiameter[component] : tmp;
                                                                 } //else
                                                         //*out << Verbose(2) << "Saw no sign flip, probably top or bottom node." << endl;
+                                                }
+                                }
+                }
         *out << Verbose(0) << "RESULT: The biggest diameters are "
                         << GreatestDiameter[0] << " and " << GreatestDiameter[1] << " and "
                         << GreatestDiameter[2] << " " << (IsAngstroem ? "angstrom"
                         : "atomiclength") << "." << endl;
         // free reference lists
         if (BoundaryFreeFlag)
                 delete[] (BoundaryPoints);
         return GreatestDiameter;
+    bool IsAngstroem)
+{
+  // get points on boundary of NULL was given as parameter
+  bool BoundaryFreeFlag = false;
+  Boundaries *BoundaryPoints = BoundaryPtr;
+  if (BoundaryPoints == NULL)
+    {
+      BoundaryFreeFlag = true;
+      BoundaryPoints = GetBoundaryPoints(out, mol);
+    }
+  else
+    {
+      *out << Verbose(1) << "Using given boundary points set." << endl;
+    }
+  // determine biggest "diameter" of cluster for each axis
+  Boundaries::iterator Neighbour, OtherNeighbour;
+  double *GreatestDiameter = new double[NDIM];
+  for (int i = 0; i < NDIM; i++)
+    GreatestDiameter[i] = 0.;
+  double OldComponent, tmp, w1, w2;
+  Vector DistanceVector, OtherVector;
+  int component, Othercomponent;
+  for (int axis = 0; axis < NDIM; axis++)
+    { // regard each projected plane
+      //*out << Verbose(1) << "Current axis is " << axis << "." << endl;
+      for (int j = 0; j < 2; j++)
+        { // and for both axis on the current plane
+          component = (axis + j + 1) % NDIM;
+          Othercomponent = (axis + 1 + ((j + 1) & 1)) % NDIM;
+          //*out << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
+          for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
+              != BoundaryPoints[axis].end(); runner++)
+            {
+              //*out << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
+              // seek for the neighbours pair where the Othercomponent sign flips
+              Neighbour = runner;
+              Neighbour++;
+              if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
+                Neighbour = BoundaryPoints[axis].begin();
+              DistanceVector.CopyVector(&runner->second.second->x);
+              DistanceVector.SubtractVector(&Neighbour->second.second->x);
+              do
+                { // seek for neighbour pair where it flips
+                  OldComponent = DistanceVector.x[Othercomponent];
+                  Neighbour++;
+                  if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
+                    Neighbour = BoundaryPoints[axis].begin();
+                  DistanceVector.CopyVector(&runner->second.second->x);
+                  DistanceVector.SubtractVector(&Neighbour->second.second->x);
+                  //*out << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
+                }
+              while ((runner != Neighbour) && (fabs(OldComponent / fabs(
+                  OldComponent) - DistanceVector.x[Othercomponent] / fabs(
+                  DistanceVector.x[Othercomponent])) < MYEPSILON)); // as long as sign does not flip
+              if (runner != Neighbour)
+                {
+                  OtherNeighbour = Neighbour;
+                  if (OtherNeighbour == BoundaryPoints[axis].begin()) // make it wrap around
+                    OtherNeighbour = BoundaryPoints[axis].end();
+                  OtherNeighbour--;
+                  //*out << Verbose(2) << "The pair, where the sign of OtherComponent flips, is: " << *(Neighbour->second.second) << " and " << *(OtherNeighbour->second.second) << "." << endl;
+                  // now we have found the pair: Neighbour and OtherNeighbour
+                  OtherVector.CopyVector(&runner->second.second->x);
+                  OtherVector.SubtractVector(&OtherNeighbour->second.second->x);
+                  //*out << Verbose(2) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
+                  //*out << Verbose(2) << "OtherComponents to Neighbour and OtherNeighbour are " << DistanceVector.x[Othercomponent] << " and " << OtherVector.x[Othercomponent] << "." << endl;
+                  // do linear interpolation between points (is exact) to extract exact intersection between Neighbour and OtherNeighbour
+                  w1 = fabs(OtherVector.x[Othercomponent]);
+                  w2 = fabs(DistanceVector.x[Othercomponent]);
+                  tmp = fabs((w1 * DistanceVector.x[component] + w2
+                      * OtherVector.x[component]) / (w1 + w2));
+                  // mark if it has greater diameter
+                  //*out << Verbose(2) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
+                  GreatestDiameter[component] = (GreatestDiameter[component]
+                      > tmp) ? GreatestDiameter[component] : tmp;
+                } //else
+              //*out << Verbose(2) << "Saw no sign flip, probably top or bottom node." << endl;
+            }
+        }
+    }
+  *out << Verbose(0) << "RESULT: The biggest diameters are "
+      << GreatestDiameter[0] << " and " << GreatestDiameter[1] << " and "
+      << GreatestDiameter[2] << " " << (IsAngstroem ? "angstrom"
+      : "atomiclength") << "." << endl;
+  // free reference lists
+  if (BoundaryFreeFlag)
+    delete[] (BoundaryPoints);
+  return GreatestDiameter;
+}
+;
 …
 void write_vrml_file(ofstream *out, ofstream *vrmlfile, class Tesselation *Tess, class molecule *mol)
+{
         atom *Walker = mol->start;
         bond *Binder = mol->first;
         int i;
         Vector *center = mol->DetermineCenterOfAll(out);
         if (vrmlfile != NULL) {
                 //cout << Verbose(1) << "Writing Raster3D file ... ";
                 *vrmlfile << "#VRML V2.0 utf8" << endl;
                 *vrmlfile << "#Created by molecuilder" << endl;
                 *vrmlfile << "#All atoms as spheres" << endl;
                 while (Walker->next != mol->end) {
                         Walker = Walker->next;
                         *vrmlfile << "Sphere {" << endl << "    "; // 2 is sphere type
                         for (i=0;i<NDIM;i++)
                                 *vrmlfile << Walker->x.x[i]+center->x[i] << " ";
                         *vrmlfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
+                }
                 *vrmlfile << "# All bonds as vertices" << endl;
                 while (Binder->next != mol->last) {
                         Binder = Binder->next;
                         *vrmlfile << "3" << endl << "   "; // 2 is round-ended cylinder type
                         for (i=0;i<NDIM;i++)
                                 *vrmlfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
                         *vrmlfile << "\t0.03\t";
                         for (i=0;i<NDIM;i++)
                                 *vrmlfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
                         *vrmlfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
+                }
                 *vrmlfile << "# All tesselation triangles" << endl;
                 for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
                         *vrmlfile << "1" << endl << "   "; // 1 is triangle type
                         for (i=0;i<3;i++) { // print each node
                                 for (int j=0;j<NDIM;j++)        // and for each node all NDIM coordinates
                                         *vrmlfile << TriangleRunner->second->endpoints[i]->node->x.x[j]+center->x[j] << " ";
                                 *vrmlfile << "\t";
+                        }
                         *vrmlfile << "1. 0. 0." << endl;        // red as colour
                         *vrmlfile << "18" << endl << "  0.5 0.5 0.5" << endl; // 18 is transparency type for previous object
+                }
         } else {
                 cerr << "ERROR: Given vrmlfile is " << vrmlfile << "." << endl;
+        }
         delete(center);
+  atom *Walker = mol->start;
+  bond *Binder = mol->first;
+  int i;
+  Vector *center = mol->DetermineCenterOfAll(out);
+  if (vrmlfile != NULL) {
+    //cout << Verbose(1) << "Writing Raster3D file ... ";
+    *vrmlfile << "#VRML V2.0 utf8" << endl;
+    *vrmlfile << "#Created by molecuilder" << endl;
+    *vrmlfile << "#All atoms as spheres" << endl;
+    while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      *vrmlfile << "Sphere {" << endl << "  "; // 2 is sphere type
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Walker->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
+    }
+    *vrmlfile << "# All bonds as vertices" << endl;
+    while (Binder->next != mol->last) {
+      Binder = Binder->next;
+      *vrmlfile << "3" << endl << "  "; // 2 is round-ended cylinder type
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.03\t";
+      for (i=0;i<NDIM;i++)
+        *vrmlfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
+      *vrmlfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
+    }
+    *vrmlfile << "# All tesselation triangles" << endl;
+    for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
+      *vrmlfile << "1" << endl << "  "; // 1 is triangle type
+      for (i=0;i<3;i++) { // print each node
+        for (int j=0;j<NDIM;j++)  // and for each node all NDIM coordinates
+          *vrmlfile << TriangleRunner->second->endpoints[i]->node->x.x[j]+center->x[j] << " ";
+        *vrmlfile << "\t";
+      }
+      *vrmlfile << "1. 0. 0." << endl;  // red as colour
+      *vrmlfile << "18" << endl << "  0.5 0.5 0.5" << endl; // 18 is transparency type for previous object
+    }
+  } else {
+    cerr << "ERROR: Given vrmlfile is " << vrmlfile << "." << endl;
+  }
+  delete(center);
 };
 …
 void write_raster3d_file(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, class molecule *mol)
+{
         atom *Walker = mol->start;
         bond *Binder = mol->first;
         int i;
         Vector *center = mol->DetermineCenterOfAll(out);
         if (rasterfile != NULL) {
                 //cout << Verbose(1) << "Writing Raster3D file ... ";
                 *rasterfile << "# Raster3D object description, created by MoleCuilder" << endl;
                 *rasterfile << "@header.r3d" << endl;
                 *rasterfile << "# All atoms as spheres" << endl;
                 while (Walker->next != mol->end) {
                         Walker = Walker->next;
                         *rasterfile << "2" << endl << " ";      // 2 is sphere type
                         for (i=0;i<NDIM;i++)
                                 *rasterfile << Walker->x.x[i]+center->x[i] << " ";
                         *rasterfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
+                }
                 *rasterfile << "# All bonds as vertices" << endl;
                 while (Binder->next != mol->last) {
                         Binder = Binder->next;
                         *rasterfile << "3" << endl << " ";      // 2 is round-ended cylinder type
                         for (i=0;i<NDIM;i++)
                                 *rasterfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
                         *rasterfile << "\t0.03\t";
                         for (i=0;i<NDIM;i++)
                                 *rasterfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
                         *rasterfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
+                }
                 *rasterfile << "# All tesselation triangles" << endl;
                 *rasterfile << "8\n     25. -1.  1. 1. 1.        0.0            0 0 0 2\n       SOLID            1.0 0.0 0.0\n  BACKFACE        0.3 0.3 1.0      0 0\n";
                 for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
                         *rasterfile << "1" << endl << " ";      // 1 is triangle type
                         for (i=0;i<3;i++) {     // print each node
                                 for (int j=0;j<NDIM;j++)        // and for each node all NDIM coordinates
                                         *rasterfile << TriangleRunner->second->endpoints[i]->node->x.x[j]+center->x[j] << " ";
                                 *rasterfile << "\t";
+                        }
                         *rasterfile << "1. 0. 0." << endl;      // red as colour
                         //*rasterfile << "18" << endl << "      0.5 0.5 0.5" << endl;   // 18 is transparency type for previous object
+                }
                 *rasterfile << "9\n     terminating special property\n";
         } else {
                 cerr << "ERROR: Given rasterfile is " << rasterfile << "." << endl;
+        }
         delete(center);
+  atom *Walker = mol->start;
+  bond *Binder = mol->first;
+  int i;
+  Vector *center = mol->DetermineCenterOfAll(out);
+  if (rasterfile != NULL) {
+    //cout << Verbose(1) << "Writing Raster3D file ... ";
+    *rasterfile << "# Raster3D object description, created by MoleCuilder" << endl;
+    *rasterfile << "@header.r3d" << endl;
+    *rasterfile << "# All atoms as spheres" << endl;
+    while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      *rasterfile << "2" << endl << "  ";  // 2 is sphere type
+      for (i=0;i<NDIM;i++)
+        *rasterfile << Walker->x.x[i]+center->x[i] << " ";
+      *rasterfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
+    }
+    *rasterfile << "# All bonds as vertices" << endl;
+    while (Binder->next != mol->last) {
+      Binder = Binder->next;
+      *rasterfile << "3" << endl << "  ";  // 2 is round-ended cylinder type
+      for (i=0;i<NDIM;i++)
+        *rasterfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
+      *rasterfile << "\t0.03\t";
+      for (i=0;i<NDIM;i++)
+        *rasterfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
+      *rasterfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
+    }
+    *rasterfile << "# All tesselation triangles" << endl;
+    *rasterfile << "8\n  25. -1.   1. 1. 1.   0.0    0 0 0 2\n  SOLID     1.0 0.0 0.0\n  BACKFACE  0.3 0.3 1.0   0 0\n";
+    for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
+      *rasterfile << "1" << endl << "  ";  // 1 is triangle type
+      for (i=0;i<3;i++) {  // print each node
+        for (int j=0;j<NDIM;j++)  // and for each node all NDIM coordinates
+          *rasterfile << TriangleRunner->second->endpoints[i]->node->x.x[j]+center->x[j] << " ";
+        *rasterfile << "\t";
+      }
+      *rasterfile << "1. 0. 0." << endl;  // red as colour
+      *rasterfile << "18" << endl << "  0.5 0.5 0.5" << endl;  // 18 is transparency type for previous object
+    }
+    *rasterfile << "9\n  terminating special property\n";
+  } else {
+    cerr << "ERROR: Given rasterfile is " << rasterfile << "." << endl;
+  }
+  delete(center);
 };
 …
 void
 write_tecplot_file(ofstream *out, ofstream *tecplot,
                 class Tesselation *TesselStruct, class molecule *mol, int N)
+{
         if (tecplot != NULL)
+                {
                         *tecplot << "TITLE = \"3D CONVEX SHELL\"" << endl;
                         *tecplot << "VARIABLES = \"X\" \"Y\" \"Z\"" << endl;
                         *tecplot << "ZONE T=\"TRIANGLES" << N << "\", N="
                                         << TesselStruct->PointsOnBoundaryCount << ", E="
                                         << TesselStruct->TrianglesOnBoundaryCount
                                         << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
                         int *LookupList = new int[mol->AtomCount];
                         for (int i = 0; i < mol->AtomCount; i++)
                                 LookupList[i] = -1;
                         // print atom coordinates
                         *out << Verbose(2) << "The following triangles were created:";
                         int Counter = 1;
                         atom *Walker = NULL;
                         for (PointMap::iterator target = TesselStruct->PointsOnBoundary.begin(); target
                                         != TesselStruct->PointsOnBoundary.end(); target++)
+                                {
                                         Walker = target->second->node;
                                         LookupList[Walker->nr] = Counter++;
                                         *tecplot << Walker->x.x[0] << " " << Walker->x.x[1] << " "
                                                         << Walker->x.x[2] << " " << endl;
+                                }
                         *tecplot << endl;
                         // print connectivity
                         for (TriangleMap::iterator runner =
                                         TesselStruct->TrianglesOnBoundary.begin(); runner
                                         != TesselStruct->TrianglesOnBoundary.end(); runner++)
+                                {
                                         *out << " " << runner->second->endpoints[0]->node->Name << "<->"
                                                         << runner->second->endpoints[1]->node->Name << "<->"
                                                         << runner->second->endpoints[2]->node->Name;
                                         *tecplot << LookupList[runner->second->endpoints[0]->node->nr] << " "
                                                         << LookupList[runner->second->endpoints[1]->node->nr] << " "
                                                         << LookupList[runner->second->endpoints[2]->node->nr] << endl;
+                                }
                         delete[] (LookupList);
                         *out << endl;
+                }
+    class Tesselation *TesselStruct, class molecule *mol, int N)
+{
+  if (tecplot != NULL)
+    {
+      *tecplot << "TITLE = \"3D CONVEX SHELL\"" << endl;
+      *tecplot << "VARIABLES = \"X\" \"Y\" \"Z\"" << endl;
+      *tecplot << "ZONE T=\"TRIANGLES" << N << "\", N="
+          << TesselStruct->PointsOnBoundaryCount << ", E="
+          << TesselStruct->TrianglesOnBoundaryCount
+          << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
+      int *LookupList = new int[mol->AtomCount];
+      for (int i = 0; i < mol->AtomCount; i++)
+        LookupList[i] = -1;
+      // print atom coordinates
+      *out << Verbose(2) << "The following triangles were created:";
+      int Counter = 1;
+      atom *Walker = NULL;
+      for (PointMap::iterator target = TesselStruct->PointsOnBoundary.begin(); target
+          != TesselStruct->PointsOnBoundary.end(); target++)
+        {
+          Walker = target->second->node;
+          LookupList[Walker->nr] = Counter++;
+          *tecplot << Walker->x.x[0] << " " << Walker->x.x[1] << " "
+              << Walker->x.x[2] << " " << endl;
+        }
+      *tecplot << endl;
+      // print connectivity
+      for (TriangleMap::iterator runner =
+          TesselStruct->TrianglesOnBoundary.begin(); runner
+          != TesselStruct->TrianglesOnBoundary.end(); runner++)
+        {
+          *out << " " << runner->second->endpoints[0]->node->Name << "<->"
+              << runner->second->endpoints[1]->node->Name << "<->"
+              << runner->second->endpoints[2]->node->Name;
+          *tecplot << LookupList[runner->second->endpoints[0]->node->nr] << " "
+              << LookupList[runner->second->endpoints[1]->node->nr] << " "
+              << LookupList[runner->second->endpoints[2]->node->nr] << endl;
+        }
+      delete[] (LookupList);
+      *out << endl;
+    }
+}
 …
 double
 VolumeOfConvexEnvelope(ofstream *out, const char *filename, config *configuration,
                 Boundaries *BoundaryPtr, molecule *mol)
+{
         bool IsAngstroem = configuration->GetIsAngstroem();
         atom *Walker = NULL;
         struct Tesselation *TesselStruct = new Tesselation;
         bool BoundaryFreeFlag = false;
         Boundaries *BoundaryPoints = BoundaryPtr;
         double volume = 0.;
         double PyramidVolume = 0.;
         double G, h;
         Vector x, y;
         double a, b, c;
         //Find_non_convex_border(out, tecplot, *TesselStruct, mol); // Is now called from command line.
         // 1. calculate center of gravity
         *out << endl;
         Vector *CenterOfGravity = mol->DetermineCenterOfGravity(out);
         // 2. translate all points into CoG
         *out << Verbose(1) << "Translating system to Center of Gravity." << endl;
         Walker = mol->start;
         while (Walker->next != mol->end)
+                {
                         Walker = Walker->next;
                         Walker->x.Translate(CenterOfGravity);
+                }
         // 3. Find all points on the boundary
         if (BoundaryPoints == NULL)
+                {
                         BoundaryFreeFlag = true;
                         BoundaryPoints = GetBoundaryPoints(out, mol);
+                }
         else
+                {
                         *out << Verbose(1) << "Using given boundary points set." << endl;
+                }
         // 4. fill the boundary point list
         for (int axis = 0; axis < NDIM; axis++)
                 for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
                                 != BoundaryPoints[axis].end(); runner++)
+                        {
                                 TesselStruct->AddPoint(runner->second.second);
+                        }
         *out << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount
                         << " points on the convex boundary." << endl;
         // now we have the whole set of edge points in the BoundaryList
         // listing for debugging
         //      *out << Verbose(1) << "Listing PointsOnBoundary:";
         //      for(PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
         //              *out << " " << *runner->second;
         //      }
         //      *out << endl;
         // 5a. guess starting triangle
         TesselStruct->GuessStartingTriangle(out);
         // 5b. go through all lines, that are not yet part of two triangles (only of one so far)
         TesselStruct->TesselateOnBoundary(out, configuration, mol);
         *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundaryCount
                         << " triangles with " << TesselStruct->LinesOnBoundaryCount
                         << " lines and " << TesselStruct->PointsOnBoundaryCount << " points."
                         << endl;
         // 6a. Every triangle forms a pyramid with the center of gravity as its peak, sum up the volumes
         *out << Verbose(1)
                         << "Calculating the volume of the pyramids formed out of triangles and center of gravity."
                         << endl;
         for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner
                         != TesselStruct->TrianglesOnBoundary.end(); runner++)
                 { // go through every triangle, calculate volume of its pyramid with CoG as peak
                         x.CopyVector(&runner->second->endpoints[0]->node->x);
                         x.SubtractVector(&runner->second->endpoints[1]->node->x);
                         y.CopyVector(&runner->second->endpoints[0]->node->x);
                         y.SubtractVector(&runner->second->endpoints[2]->node->x);
                         a = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
                                         &runner->second->endpoints[1]->node->x));
                         b = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
                                         &runner->second->endpoints[2]->node->x));
                         c = sqrt(runner->second->endpoints[2]->node->x.DistanceSquared(
                                         &runner->second->endpoints[1]->node->x));
                         G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
                         x.MakeNormalVector(&runner->second->endpoints[0]->node->x,
                                         &runner->second->endpoints[1]->node->x,
                                         &runner->second->endpoints[2]->node->x);
                         x.Scale(runner->second->endpoints[1]->node->x.Projection(&x));
                         h = x.Norm(); // distance of CoG to triangle
                         PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
                         *out << Verbose(2) << "Area of triangle is " << G << " "
                                         << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is "
                                         << h << " and the volume is " << PyramidVolume << " "
                                         << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
                         volume += PyramidVolume;
+                }
         *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(10)
                         << volume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3."
                         << endl;
         // 7. translate all points back from CoG
         *out << Verbose(1) << "Translating system back from Center of Gravity."
                         << endl;
         CenterOfGravity->Scale(-1);
         Walker = mol->start;
         while (Walker->next != mol->end)
+                {
                         Walker = Walker->next;
                         Walker->x.Translate(CenterOfGravity);
+                }
         // 8. Store triangles in tecplot file
         string OutputName(filename);
         OutputName.append(TecplotSuffix);
         ofstream *tecplot = new ofstream(OutputName.c_str());
         write_tecplot_file(out, tecplot, TesselStruct, mol, 0);
         tecplot->close();
         delete(tecplot);
         // free reference lists
         if (BoundaryFreeFlag)
                 delete[] (BoundaryPoints);
         return volume;
+    Boundaries *BoundaryPtr, molecule *mol)
+{
+  bool IsAngstroem = configuration->GetIsAngstroem();
+  atom *Walker = NULL;
+  struct Tesselation *TesselStruct = new Tesselation;
+  bool BoundaryFreeFlag = false;
+  Boundaries *BoundaryPoints = BoundaryPtr;
+  double volume = 0.;
+  double PyramidVolume = 0.;
+  double G, h;
+  Vector x, y;
+  double a, b, c;
+  //Find_non_convex_border(out, tecplot, *TesselStruct, mol); // Is now called from command line.
+  // 1. calculate center of gravity
+  *out << endl;
+  Vector *CenterOfGravity = mol->DetermineCenterOfGravity(out);
+  // 2. translate all points into CoG
+  *out << Verbose(1) << "Translating system to Center of Gravity." << endl;
+  Walker = mol->start;
+  while (Walker->next != mol->end)
+    {
+      Walker = Walker->next;
+      Walker->x.Translate(CenterOfGravity);
+    }
+  // 3. Find all points on the boundary
+  if (BoundaryPoints == NULL)
+    {
+      BoundaryFreeFlag = true;
+      BoundaryPoints = GetBoundaryPoints(out, mol);
+    }
+  else
+    {
+      *out << Verbose(1) << "Using given boundary points set." << endl;
+    }
+  // 4. fill the boundary point list
+  for (int axis = 0; axis < NDIM; axis++)
+    for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
+        != BoundaryPoints[axis].end(); runner++)
+      {
+        TesselStruct->AddPoint(runner->second.second);
+      }
+  *out << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount
+      << " points on the convex boundary." << endl;
+  // now we have the whole set of edge points in the BoundaryList
+  // listing for debugging
+  //  *out << Verbose(1) << "Listing PointsOnBoundary:";
+  //  for(PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
+  //    *out << " " << *runner->second;
+  //  }
+  //  *out << endl;
+  // 5a. guess starting triangle
+  TesselStruct->GuessStartingTriangle(out);
+  // 5b. go through all lines, that are not yet part of two triangles (only of one so far)
+  TesselStruct->TesselateOnBoundary(out, configuration, mol);
+  *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundaryCount
+      << " triangles with " << TesselStruct->LinesOnBoundaryCount
+      << " lines and " << TesselStruct->PointsOnBoundaryCount << " points."
+      << endl;
+  // 6a. Every triangle forms a pyramid with the center of gravity as its peak, sum up the volumes
+  *out << Verbose(1)
+      << "Calculating the volume of the pyramids formed out of triangles and center of gravity."
+      << endl;
+  for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner
+      != TesselStruct->TrianglesOnBoundary.end(); runner++)
+    { // go through every triangle, calculate volume of its pyramid with CoG as peak
+      x.CopyVector(&runner->second->endpoints[0]->node->x);
+      x.SubtractVector(&runner->second->endpoints[1]->node->x);
+      y.CopyVector(&runner->second->endpoints[0]->node->x);
+      y.SubtractVector(&runner->second->endpoints[2]->node->x);
+      a = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
+          &runner->second->endpoints[1]->node->x));
+      b = sqrt(runner->second->endpoints[0]->node->x.DistanceSquared(
+          &runner->second->endpoints[2]->node->x));
+      c = sqrt(runner->second->endpoints[2]->node->x.DistanceSquared(
+          &runner->second->endpoints[1]->node->x));
+      G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
+      x.MakeNormalVector(&runner->second->endpoints[0]->node->x,
+          &runner->second->endpoints[1]->node->x,
+          &runner->second->endpoints[2]->node->x);
+      x.Scale(runner->second->endpoints[1]->node->x.Projection(&x));
+      h = x.Norm(); // distance of CoG to triangle
+      PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
+      *out << Verbose(2) << "Area of triangle is " << G << " "
+          << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is "
+          << h << " and the volume is " << PyramidVolume << " "
+          << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+      volume += PyramidVolume;
+    }
+  *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(10)
+      << volume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3."
+      << endl;
+  // 7. translate all points back from CoG
+  *out << Verbose(1) << "Translating system back from Center of Gravity."
+      << endl;
+  CenterOfGravity->Scale(-1);
+  Walker = mol->start;
+  while (Walker->next != mol->end)
+    {
+      Walker = Walker->next;
+      Walker->x.Translate(CenterOfGravity);
+    }
+  // 8. Store triangles in tecplot file
+  string OutputName(filename);
+  OutputName.append(TecplotSuffix);
+  ofstream *tecplot = new ofstream(OutputName.c_str());
+  write_tecplot_file(out, tecplot, TesselStruct, mol, 0);
+  tecplot->close();
+  delete(tecplot);
+  // free reference lists
+  if (BoundaryFreeFlag)
+    delete[] (BoundaryPoints);
+  return volume;
+}
+;
 …
 void
 PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol,
                 double ClusterVolume, double celldensity)
+{
         // transform to PAS
         mol->PrincipalAxisSystem(out, true);
         // some preparations beforehand
         bool IsAngstroem = configuration->GetIsAngstroem();
         Boundaries *BoundaryPoints = GetBoundaryPoints(out, mol);
         double clustervolume;
         if (ClusterVolume == 0)
                 clustervolume = VolumeOfConvexEnvelope(out, NULL, configuration,
                                 BoundaryPoints, mol);
         else
                 clustervolume = ClusterVolume;
         double *GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol,
                         IsAngstroem);
         Vector BoxLengths;
         int repetition[NDIM] =
                 { 1, 1, 1 };
         int TotalNoClusters = 1;
         for (int i = 0; i < NDIM; i++)
                 TotalNoClusters *= repetition[i];
         // sum up the atomic masses
         double totalmass = 0.;
         atom *Walker = mol->start;
         while (Walker->next != mol->end)
+                {
                         Walker = Walker->next;
                         totalmass += Walker->type->mass;
+                }
         *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10)
                         << totalmass << " atomicmassunit." << endl;
         *out << Verbose(0) << "RESULT: The average density is " << setprecision(10)
                         << totalmass / clustervolume << " atomicmassunit/"
                         << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
         // solve cubic polynomial
         *out << Verbose(1) << "Solving equidistant suspension in water problem ..."
                         << endl;
         double cellvolume;
         if (IsAngstroem)
                 cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_A - (totalmass
                                 / clustervolume)) / (celldensity - 1);
         else
                 cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_a0 - (totalmass
                                 / clustervolume)) / (celldensity - 1);
         *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity
                         << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom"
                         : "atomiclength") << "^3." << endl;
         double minimumvolume = TotalNoClusters * (GreatestDiameter[0]
                         * GreatestDiameter[1] * GreatestDiameter[2]);
         *out << Verbose(1)
                         << "Minimum volume of the convex envelope contained in a rectangular box is "
                         << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom"
                         : "atomiclength") << "^3." << endl;
         if (minimumvolume > cellvolume)
+                {
                         cerr << Verbose(0)
                                         << "ERROR: the containing box already has a greater volume than the envisaged cell volume!"
                                         << endl;
                         cout << Verbose(0)
                                         << "Setting Box dimensions to minimum possible, the greatest diameters."
                                         << endl;
                         for (int i = 0; i < NDIM; i++)
                                 BoxLengths.x[i] = GreatestDiameter[i];
                         mol->CenterEdge(out, &BoxLengths);
+                }
         else
+                {
                         BoxLengths.x[0] = (repetition[0] * GreatestDiameter[0] + repetition[1]
                                         * GreatestDiameter[1] + repetition[2] * GreatestDiameter[2]);
                         BoxLengths.x[1] = (repetition[0] * repetition[1] * GreatestDiameter[0]
                                         * GreatestDiameter[1] + repetition[0] * repetition[2]
                                         * GreatestDiameter[0] * GreatestDiameter[2] + repetition[1]
                                         * repetition[2] * GreatestDiameter[1] * GreatestDiameter[2]);
                         BoxLengths.x[2] = minimumvolume - cellvolume;
                         double x0 = 0., x1 = 0., x2 = 0.;
                         if (gsl_poly_solve_cubic(BoxLengths.x[0], BoxLengths.x[1],
                                         BoxLengths.x[2], &x0, &x1, &x2) == 1) // either 1 or 3 on return
                                 *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0
                                                 << " ." << endl;
                         else
+                                {
                                         *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0
                                                         << " and " << x1 << " and " << x2 << " ." << endl;
                                         x0 = x2; // sorted in ascending order
+                                }
                         cellvolume = 1;
                         for (int i = 0; i < NDIM; i++)
+                                {
                                         BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
                                         cellvolume *= BoxLengths.x[i];
+                                }
                         // set new box dimensions
                         *out << Verbose(0) << "Translating to box with these boundaries." << endl;
                         mol->CenterInBox((ofstream *) &cout, &BoxLengths);
+                }
         // update Box of atoms by boundary
         mol->SetBoxDimension(&BoxLengths);
         *out << Verbose(0) << "RESULT: The resulting cell dimensions are: "
                         << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and "
                         << BoxLengths.x[2] << " with total volume of " << cellvolume << " "
                         << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+    double ClusterVolume, double celldensity)
+{
+  // transform to PAS
+  mol->PrincipalAxisSystem(out, true);
+  // some preparations beforehand
+  bool IsAngstroem = configuration->GetIsAngstroem();
+  Boundaries *BoundaryPoints = GetBoundaryPoints(out, mol);
+  double clustervolume;
+  if (ClusterVolume == 0)
+    clustervolume = VolumeOfConvexEnvelope(out, NULL, configuration,
+        BoundaryPoints, mol);
+  else
+    clustervolume = ClusterVolume;
+  double *GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol,
+      IsAngstroem);
+  Vector BoxLengths;
+  int repetition[NDIM] =
+    { 1, 1, 1 };
+  int TotalNoClusters = 1;
+  for (int i = 0; i < NDIM; i++)
+    TotalNoClusters *= repetition[i];
+  // sum up the atomic masses
+  double totalmass = 0.;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end)
+    {
+      Walker = Walker->next;
+      totalmass += Walker->type->mass;
+    }
+  *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10)
+      << totalmass << " atomicmassunit." << endl;
+  *out << Verbose(0) << "RESULT: The average density is " << setprecision(10)
+      << totalmass / clustervolume << " atomicmassunit/"
+      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  // solve cubic polynomial
+  *out << Verbose(1) << "Solving equidistant suspension in water problem ..."
+      << endl;
+  double cellvolume;
+  if (IsAngstroem)
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_A - (totalmass
+        / clustervolume)) / (celldensity - 1);
+  else
+    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_a0 - (totalmass
+        / clustervolume)) / (celldensity - 1);
+  *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity
+      << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom"
+      : "atomiclength") << "^3." << endl;
+  double minimumvolume = TotalNoClusters * (GreatestDiameter[0]
+      * GreatestDiameter[1] * GreatestDiameter[2]);
+  *out << Verbose(1)
+      << "Minimum volume of the convex envelope contained in a rectangular box is "
+      << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom"
+      : "atomiclength") << "^3." << endl;
+  if (minimumvolume > cellvolume)
+    {
+      cerr << Verbose(0)
+          << "ERROR: the containing box already has a greater volume than the envisaged cell volume!"
+          << endl;
+      cout << Verbose(0)
+          << "Setting Box dimensions to minimum possible, the greatest diameters."
+          << endl;
+      for (int i = 0; i < NDIM; i++)
+        BoxLengths.x[i] = GreatestDiameter[i];
+      mol->CenterEdge(out, &BoxLengths);
+    }
+  else
+    {
+      BoxLengths.x[0] = (repetition[0] * GreatestDiameter[0] + repetition[1]
+          * GreatestDiameter[1] + repetition[2] * GreatestDiameter[2]);
+      BoxLengths.x[1] = (repetition[0] * repetition[1] * GreatestDiameter[0]
+          * GreatestDiameter[1] + repetition[0] * repetition[2]
+          * GreatestDiameter[0] * GreatestDiameter[2] + repetition[1]
+          * repetition[2] * GreatestDiameter[1] * GreatestDiameter[2]);
+      BoxLengths.x[2] = minimumvolume - cellvolume;
+      double x0 = 0., x1 = 0., x2 = 0.;
+      if (gsl_poly_solve_cubic(BoxLengths.x[0], BoxLengths.x[1],
+          BoxLengths.x[2], &x0, &x1, &x2) == 1) // either 1 or 3 on return
+        *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0
+            << " ." << endl;
+      else
+        {
+          *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0
+              << " and " << x1 << " and " << x2 << " ." << endl;
+          x0 = x2; // sorted in ascending order
+        }
+      cellvolume = 1;
+      for (int i = 0; i < NDIM; i++)
+        {
+          BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
+          cellvolume *= BoxLengths.x[i];
+        }
+      // set new box dimensions
+      *out << Verbose(0) << "Translating to box with these boundaries." << endl;
+      mol->CenterInBox((ofstream *) &cout, &BoxLengths);
+    }
+  // update Box of atoms by boundary
+  mol->SetBoxDimension(&BoxLengths);
+  *out << Verbose(0) << "RESULT: The resulting cell dimensions are: "
+      << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and "
+      << BoxLengths.x[2] << " with total volume of " << cellvolume << " "
+      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+}
+;
 …
 Tesselation::Tesselation()
+{
         PointsOnBoundaryCount = 0;
         LinesOnBoundaryCount = 0;
         TrianglesOnBoundaryCount = 0;
         TriangleFilesWritten = 0;
+  PointsOnBoundaryCount = 0;
+  LinesOnBoundaryCount = 0;
+  TrianglesOnBoundaryCount = 0;
+  TriangleFilesWritten = 0;
+}
+;
 …
 Tesselation::~Tesselation()
+{
+        cout << Verbose(1) << "Free'ing TesselStruct ... " << endl;
+        for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
+                if (runner->second != NULL) {
+                        delete (runner->second);
+                        runner->second = NULL;
+                } else
+                        cerr << "ERROR: The triangle " << runner->first << " has already been free'd." << endl;
+        }
+  cout << Verbose(1) << "Free'ing TesselStruct ... " << endl;
+  for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
+    if (runner->second != NULL) {
+      delete (runner->second);
+      runner->second = NULL;
+    } else
+      cerr << "ERROR: The triangle " << runner->first << " has already been free'd." << endl;
+  }
+  for (LineMap::iterator runner = LinesOnBoundary.begin(); runner != LinesOnBoundary.end(); runner++) {
+    if (runner->second != NULL) {
+      delete (runner->second);
+      runner->second = NULL;
+    } else
+      cerr << "ERROR: The line " << runner->first << " has already been free'd." << endl;
+  }
+  for (PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
+    if (runner->second != NULL) {
+      delete (runner->second);
+      runner->second = NULL;
+    } else
+      cerr << "ERROR: The point " << runner->first << " has already been free'd." << endl;
+  }
+}
+;
 …
 Tesselation::GuessStartingTriangle(ofstream *out)
+{
         // 4b. create a starting triangle
         // 4b1. create all distances
         DistanceMultiMap DistanceMMap;
         double distance, tmp;
         Vector PlaneVector, TrialVector;
         PointMap::iterator A, B, C; // three nodes of the first triangle
         A = PointsOnBoundary.begin(); // the first may be chosen arbitrarily
         // with A chosen, take each pair B,C and sort
         if (A != PointsOnBoundary.end())
+                {
                         B = A;
                         B++;
                         for (; B != PointsOnBoundary.end(); B++)
+                                {
                                         C = B;
                                         C++;
                                         for (; C != PointsOnBoundary.end(); C++)
+                                                {
                                                         tmp = A->second->node->x.DistanceSquared(&B->second->node->x);
                                                         distance = tmp * tmp;
                                                         tmp = A->second->node->x.DistanceSquared(&C->second->node->x);
                                                         distance += tmp * tmp;
                                                         tmp = B->second->node->x.DistanceSquared(&C->second->node->x);
                                                         distance += tmp * tmp;
                                                         DistanceMMap.insert(DistanceMultiMapPair(distance, pair<
                                                                         PointMap::iterator, PointMap::iterator> (B, C)));
+                                                }
+                                }
+                }
         //              // listing distances
         //              *out << Verbose(1) << "Listing DistanceMMap:";
         //              for(DistanceMultiMap::iterator runner = DistanceMMap.begin(); runner != DistanceMMap.end(); runner++) {
         //                      *out << " " << runner->first << "(" << *runner->second.first->second << ", " << *runner->second.second->second << ")";
         //              }
         //              *out << endl;
         // 4b2. pick three baselines forming a triangle
         // 1. we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
         DistanceMultiMap::iterator baseline = DistanceMMap.begin();
         for (; baseline != DistanceMMap.end(); baseline++)
+                {
                         // we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
                         // 2. next, we have to check whether all points reside on only one side of the triangle
                         // 3. construct plane vector
                         PlaneVector.MakeNormalVector(&A->second->node->x,
                                         &baseline->second.first->second->node->x,
                                         &baseline->second.second->second->node->x);
                         *out << Verbose(2) << "Plane vector of candidate triangle is ";
                         PlaneVector.Output(out);
                         *out << endl;
                         // 4. loop over all points
                         double sign = 0.;
                         PointMap::iterator checker = PointsOnBoundary.begin();
                         for (; checker != PointsOnBoundary.end(); checker++)
+                                {
                                         // (neglecting A,B,C)
                                         if ((checker == A) || (checker == baseline->second.first) || (checker
                                                         == baseline->second.second))
                                                 continue;
                                         // 4a. project onto plane vector
                                         TrialVector.CopyVector(&checker->second->node->x);
                                         TrialVector.SubtractVector(&A->second->node->x);
                                         distance = TrialVector.Projection(&PlaneVector);
                                         if (fabs(distance) < 1e-4) // we need to have a small epsilon around 0 which is still ok
                                                 continue;
                                         *out << Verbose(3) << "Projection of " << checker->second->node->Name
                                                         << " yields distance of " << distance << "." << endl;
                                         tmp = distance / fabs(distance);
                                         // 4b. Any have different sign to than before? (i.e. would lie outside convex hull with this starting triangle)
                                         if ((sign != 0) && (tmp != sign))
+                                                {
                                                         // 4c. If so, break 4. loop and continue with next candidate in 1. loop
                                                         *out << Verbose(2) << "Current candidates: "
                                                                         << A->second->node->Name << ","
                                                                         << baseline->second.first->second->node->Name << ","
                                                                         << baseline->second.second->second->node->Name << " leave "
                                                                         << checker->second->node->Name << " outside the convex hull."
                                                                         << endl;
                                                         break;
+                                                }
                                         else
                                                 { // note the sign for later
                                                         *out << Verbose(2) << "Current candidates: "
                                                                         << A->second->node->Name << ","
                                                                         << baseline->second.first->second->node->Name << ","
                                                                         << baseline->second.second->second->node->Name << " leave "
                                                                         << checker->second->node->Name << " inside the convex hull."
                                                                         << endl;
                                                         sign = tmp;
+                                                }
                                         // 4d. Check whether the point is inside the triangle (check distance to each node
                                         tmp = checker->second->node->x.DistanceSquared(&A->second->node->x);
                                         int innerpoint = 0;
                                         if ((tmp < A->second->node->x.DistanceSquared(
                                                         &baseline->second.first->second->node->x)) && (tmp
                                                         < A->second->node->x.DistanceSquared(
                                                                         &baseline->second.second->second->node->x)))
                                                 innerpoint++;
                                         tmp = checker->second->node->x.DistanceSquared(
                                                         &baseline->second.first->second->node->x);
                                         if ((tmp < baseline->second.first->second->node->x.DistanceSquared(
                                                         &A->second->node->x)) && (tmp
                                                         < baseline->second.first->second->node->x.DistanceSquared(
                                                                         &baseline->second.second->second->node->x)))
                                                 innerpoint++;
                                         tmp = checker->second->node->x.DistanceSquared(
                                                         &baseline->second.second->second->node->x);
                                         if ((tmp < baseline->second.second->second->node->x.DistanceSquared(
                                                         &baseline->second.first->second->node->x)) && (tmp
                                                         < baseline->second.second->second->node->x.DistanceSquared(
                                                                         &A->second->node->x)))
                                                 innerpoint++;
                                         // 4e. If so, break 4. loop and continue with next candidate in 1. loop
                                         if (innerpoint == 3)
                                                 break;
+                                }
                         // 5. come this far, all on same side? Then break 1. loop and construct triangle
                         if (checker == PointsOnBoundary.end())
+                                {
                                         *out << "Looks like we have a candidate!" << endl;
                                         break;
+                                }
+                }
         if (baseline != DistanceMMap.end())
+                {
                         BPS[0] = baseline->second.first->second;
                         BPS[1] = baseline->second.second->second;
                         BLS[0] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
                         BPS[0] = A->second;
                         BPS[1] = baseline->second.second->second;
                         BLS[1] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
                         BPS[0] = baseline->second.first->second;
                         BPS[1] = A->second;
                         BLS[2] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
                         // 4b3. insert created triangle
                         BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
                         TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
                         TrianglesOnBoundaryCount++;
                         for (int i = 0; i < NDIM; i++)
+                                {
                                         LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BTS->lines[i]));
                                         LinesOnBoundaryCount++;
+                                }
                         *out << Verbose(1) << "Starting triangle is " << *BTS << "." << endl;
+                }
         else
+                {
                         *out << Verbose(1) << "No starting triangle found." << endl;
                         exit(255);
+                }
+  // 4b. create a starting triangle
+  // 4b1. create all distances
+  DistanceMultiMap DistanceMMap;
+  double distance, tmp;
+  Vector PlaneVector, TrialVector;
+  PointMap::iterator A, B, C; // three nodes of the first triangle
+  A = PointsOnBoundary.begin(); // the first may be chosen arbitrarily
+  // with A chosen, take each pair B,C and sort
+  if (A != PointsOnBoundary.end())
+    {
+      B = A;
+      B++;
+      for (; B != PointsOnBoundary.end(); B++)
+        {
+          C = B;
+          C++;
+          for (; C != PointsOnBoundary.end(); C++)
+            {
+              tmp = A->second->node->x.DistanceSquared(&B->second->node->x);
+              distance = tmp * tmp;
+              tmp = A->second->node->x.DistanceSquared(&C->second->node->x);
+              distance += tmp * tmp;
+              tmp = B->second->node->x.DistanceSquared(&C->second->node->x);
+              distance += tmp * tmp;
+              DistanceMMap.insert(DistanceMultiMapPair(distance, pair<
+                  PointMap::iterator, PointMap::iterator> (B, C)));
+            }
+        }
+    }
+  //    // listing distances
+  //    *out << Verbose(1) << "Listing DistanceMMap:";
+  //    for(DistanceMultiMap::iterator runner = DistanceMMap.begin(); runner != DistanceMMap.end(); runner++) {
+  //      *out << " " << runner->first << "(" << *runner->second.first->second << ", " << *runner->second.second->second << ")";
+  //    }
+  //    *out << endl;
+  // 4b2. pick three baselines forming a triangle
+  // 1. we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
+  DistanceMultiMap::iterator baseline = DistanceMMap.begin();
+  for (; baseline != DistanceMMap.end(); baseline++)
+    {
+      // we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
+      // 2. next, we have to check whether all points reside on only one side of the triangle
+      // 3. construct plane vector
+      PlaneVector.MakeNormalVector(&A->second->node->x,
+          &baseline->second.first->second->node->x,
+          &baseline->second.second->second->node->x);
+      *out << Verbose(2) << "Plane vector of candidate triangle is ";
+      PlaneVector.Output(out);
+      *out << endl;
+      // 4. loop over all points
+      double sign = 0.;
+      PointMap::iterator checker = PointsOnBoundary.begin();
+      for (; checker != PointsOnBoundary.end(); checker++)
+        {
+          // (neglecting A,B,C)
+          if ((checker == A) || (checker == baseline->second.first) || (checker
+              == baseline->second.second))
+            continue;
+          // 4a. project onto plane vector
+          TrialVector.CopyVector(&checker->second->node->x);
+          TrialVector.SubtractVector(&A->second->node->x);
+          distance = TrialVector.Projection(&PlaneVector);
+          if (fabs(distance) < 1e-4) // we need to have a small epsilon around 0 which is still ok
+            continue;
+          *out << Verbose(3) << "Projection of " << checker->second->node->Name
+              << " yields distance of " << distance << "." << endl;
+          tmp = distance / fabs(distance);
+          // 4b. Any have different sign to than before? (i.e. would lie outside convex hull with this starting triangle)
+          if ((sign != 0) && (tmp != sign))
+            {
+              // 4c. If so, break 4. loop and continue with next candidate in 1. loop
+              *out << Verbose(2) << "Current candidates: "
+                  << A->second->node->Name << ","
+                  << baseline->second.first->second->node->Name << ","
+                  << baseline->second.second->second->node->Name << " leave "
+                  << checker->second->node->Name << " outside the convex hull."
+                  << endl;
+              break;
+            }
+          else
+            { // note the sign for later
+              *out << Verbose(2) << "Current candidates: "
+                  << A->second->node->Name << ","
+                  << baseline->second.first->second->node->Name << ","
+                  << baseline->second.second->second->node->Name << " leave "
+                  << checker->second->node->Name << " inside the convex hull."
+                  << endl;
+              sign = tmp;
+            }
+          // 4d. Check whether the point is inside the triangle (check distance to each node
+          tmp = checker->second->node->x.DistanceSquared(&A->second->node->x);
+          int innerpoint = 0;
+          if ((tmp < A->second->node->x.DistanceSquared(
+              &baseline->second.first->second->node->x)) && (tmp
+              < A->second->node->x.DistanceSquared(
+                  &baseline->second.second->second->node->x)))
+            innerpoint++;
+          tmp = checker->second->node->x.DistanceSquared(
+              &baseline->second.first->second->node->x);
+          if ((tmp < baseline->second.first->second->node->x.DistanceSquared(
+              &A->second->node->x)) && (tmp
+              < baseline->second.first->second->node->x.DistanceSquared(
+                  &baseline->second.second->second->node->x)))
+            innerpoint++;
+          tmp = checker->second->node->x.DistanceSquared(
+              &baseline->second.second->second->node->x);
+          if ((tmp < baseline->second.second->second->node->x.DistanceSquared(
+              &baseline->second.first->second->node->x)) && (tmp
+              < baseline->second.second->second->node->x.DistanceSquared(
+                  &A->second->node->x)))
+            innerpoint++;
+          // 4e. If so, break 4. loop and continue with next candidate in 1. loop
+          if (innerpoint == 3)
+            break;
+        }
+      // 5. come this far, all on same side? Then break 1. loop and construct triangle
+      if (checker == PointsOnBoundary.end())
+        {
+          *out << "Looks like we have a candidate!" << endl;
+          break;
+        }
+    }
+  if (baseline != DistanceMMap.end())
+    {
+      BPS[0] = baseline->second.first->second;
+      BPS[1] = baseline->second.second->second;
+      BLS[0] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+      BPS[0] = A->second;
+      BPS[1] = baseline->second.second->second;
+      BLS[1] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+      BPS[0] = baseline->second.first->second;
+      BPS[1] = A->second;
+      BLS[2] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+      // 4b3. insert created triangle
+      BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+      TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
+      TrianglesOnBoundaryCount++;
+      for (int i = 0; i < NDIM; i++)
+        {
+          LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BTS->lines[i]));
+          LinesOnBoundaryCount++;
+        }
+      *out << Verbose(1) << "Starting triangle is " << *BTS << "." << endl;
+    }
+  else
+    {
+      *out << Verbose(1) << "No starting triangle found." << endl;
+      exit(255);
+    }
+}
+;
 …
  * -# if the lines contains to only one triangle
  * -# We search all points in the boundary
  *              -# if the triangle with the baseline and the current point has the smallest of angles (comparison between normal vectors
  *              -# if the triangle is in forward direction of the baseline (at most 90 degrees angle between vector orthogonal to
  *                       baseline in triangle plane pointing out of the triangle and normal vector of new triangle)
  *              -# then we have a new triangle, whose baselines we again add (or increase their TriangleCount)
+ *    -# if the triangle with the baseline and the current point has the smallest of angles (comparison between normal vectors
+ *    -# if the triangle is in forward direction of the baseline (at most 90 degrees angle between vector orthogonal to
+ *       baseline in triangle plane pointing out of the triangle and normal vector of new triangle)
+ *    -# then we have a new triangle, whose baselines we again add (or increase their TriangleCount)
  * \param *out output stream for debugging
  * \param *configuration for IsAngstroem
 …
 void
 Tesselation::TesselateOnBoundary(ofstream *out, config *configuration,
                 molecule *mol)
+{
         bool flag;
         PointMap::iterator winner;
         class BoundaryPointSet *peak = NULL;
         double SmallestAngle, TempAngle;
         Vector NormalVector, VirtualNormalVector, CenterVector, TempVector,
                         PropagationVector;
         LineMap::iterator LineChecker[2];
         do
+                {
                         flag = false;
                         for (LineMap::iterator baseline = LinesOnBoundary.begin(); baseline
                                         != LinesOnBoundary.end(); baseline++)
                                 if (baseline->second->TrianglesCount == 1)
+                                        {
                                                 *out << Verbose(2) << "Current baseline is between "
                                                                 << *(baseline->second) << "." << endl;
                                                 // 5a. go through each boundary point if not _both_ edges between either endpoint of the current line and this point exist (and belong to 2 triangles)
                                                 SmallestAngle = M_PI;
                                                 BTS = baseline->second->triangles.begin()->second; // there is only one triangle so far
                                                 // get peak point with respect to this base line's only triangle
                                                 for (int i = 0; i < 3; i++)
                                                         if ((BTS->endpoints[i] != baseline->second->endpoints[0])
                                                                         && (BTS->endpoints[i] != baseline->second->endpoints[1]))
                                                                 peak = BTS->endpoints[i];
                                                 *out << Verbose(3) << " and has peak " << *peak << "." << endl;
                                                 // normal vector of triangle
                                                 BTS->GetNormalVector(NormalVector);
                                                 *out << Verbose(4) << "NormalVector of base triangle is ";
                                                 NormalVector.Output(out);
                                                 *out << endl;
                                                 // offset to center of triangle
                                                 CenterVector.Zero();
                                                 for (int i = 0; i < 3; i++)
                                                         CenterVector.AddVector(&BTS->endpoints[i]->node->x);
                                                 CenterVector.Scale(1. / 3.);
                                                 *out << Verbose(4) << "CenterVector of base triangle is ";
                                                 CenterVector.Output(out);
                                                 *out << endl;
                                                 // vector in propagation direction (out of triangle)
                                                 // project center vector onto triangle plane (points from intersection plane-NormalVector to plane-CenterVector intersection)
                                                 TempVector.CopyVector(&baseline->second->endpoints[0]->node->x);
                                                 TempVector.SubtractVector(&baseline->second->endpoints[1]->node->x);
                                                 PropagationVector.MakeNormalVector(&TempVector, &NormalVector);
                                                 TempVector.CopyVector(&CenterVector);
                                                 TempVector.SubtractVector(&baseline->second->endpoints[0]->node->x); // TempVector is vector on triangle plane pointing from one baseline egde towards center!
                                                 //*out << Verbose(2) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl;
                                                 if (PropagationVector.Projection(&TempVector) > 0) // make sure normal propagation vector points outward from baseline
                                                         PropagationVector.Scale(-1.);
                                                 *out << Verbose(4) << "PropagationVector of base triangle is ";
                                                 PropagationVector.Output(out);
                                                 *out << endl;
                                                 winner = PointsOnBoundary.end();
                                                 for (PointMap::iterator target = PointsOnBoundary.begin(); target
                                                                 != PointsOnBoundary.end(); target++)
                                                         if ((target->second != baseline->second->endpoints[0])
                                                                         && (target->second != baseline->second->endpoints[1]))
                                                                 { // don't take the same endpoints
                                                                         *out << Verbose(3) << "Target point is " << *(target->second)
                                                                                         << ":";
                                                                         bool continueflag = true;
                                                                         VirtualNormalVector.CopyVector(
                                                                                         &baseline->second->endpoints[0]->node->x);
                                                                         VirtualNormalVector.AddVector(
                                                                                         &baseline->second->endpoints[0]->node->x);
                                                                         VirtualNormalVector.Scale(-1. / 2.); // points now to center of base line
                                                                         VirtualNormalVector.AddVector(&target->second->node->x); // points from center of base line to target
                                                                         TempAngle = VirtualNormalVector.Angle(&PropagationVector);
                                                                         continueflag = continueflag && (TempAngle < (M_PI/2.)); // no bends bigger than Pi/2 (90 degrees)
                                                                         if (!continueflag)
+                                                                                {
                                                                                         *out << Verbose(4)
                                                                                                         << "Angle between propagation direction and base line to "
                                                                                                         << *(target->second) << " is " << TempAngle
                                                                                                         << ", bad direction!" << endl;
                                                                                         continue;
+                                                                                }
                                                                         else
                                                                                 *out << Verbose(4)
                                                                                                 << "Angle between propagation direction and base line to "
                                                                                                 << *(target->second) << " is " << TempAngle
                                                                                                 << ", good direction!" << endl;
                                                                         LineChecker[0] = baseline->second->endpoints[0]->lines.find(
                                                                                         target->first);
                                                                         LineChecker[1] = baseline->second->endpoints[1]->lines.find(
                                                                                         target->first);
                                                                         //                                              if (LineChecker[0] != baseline->second->endpoints[0]->lines.end())
                                                                         //                                                      *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->TrianglesCount << " triangles." << endl;
                                                                         //                                              else
                                                                         //                                                      *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has no line to " << *(target->second) << " as endpoint." << endl;
                                                                         //                                              if (LineChecker[1] != baseline->second->endpoints[1]->lines.end())
                                                                         //                                                      *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->TrianglesCount << " triangles." << endl;
                                                                         //                                              else
                                                                         //                                                      *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has no line to " << *(target->second) << " as endpoint." << endl;
                                                                         // check first endpoint (if any connecting line goes to target or at least not more than 1)
                                                                         continueflag = continueflag && (((LineChecker[0]
                                                                                         == baseline->second->endpoints[0]->lines.end())
                                                                                         || (LineChecker[0]->second->TrianglesCount == 1)));
                                                                         if (!continueflag)
+                                                                                {
                                                                                         *out << Verbose(4) << *(baseline->second->endpoints[0])
                                                                                                         << " has line " << *(LineChecker[0]->second)
                                                                                                         << " to " << *(target->second)
                                                                                                         << " as endpoint with "
                                                                                                         << LineChecker[0]->second->TrianglesCount
                                                                                                         << " triangles." << endl;
                                                                                         continue;
+                                                                                }
                                                                         // check second endpoint (if any connecting line goes to target or at least not more than 1)
                                                                         continueflag = continueflag && (((LineChecker[1]
                                                                                         == baseline->second->endpoints[1]->lines.end())
                                                                                         || (LineChecker[1]->second->TrianglesCount == 1)));
                                                                         if (!continueflag)
+                                                                                {
                                                                                         *out << Verbose(4) << *(baseline->second->endpoints[1])
                                                                                                         << " has line " << *(LineChecker[1]->second)
                                                                                                         << " to " << *(target->second)
                                                                                                         << " as endpoint with "
                                                                                                         << LineChecker[1]->second->TrianglesCount
                                                                                                         << " triangles." << endl;
                                                                                         continue;
+                                                                                }
                                                                         // check whether the envisaged triangle does not already exist (if both lines exist and have same endpoint)
                                                                         continueflag = continueflag && (!(((LineChecker[0]
                                                                                         != baseline->second->endpoints[0]->lines.end())
                                                                                         && (LineChecker[1]
                                                                                                         != baseline->second->endpoints[1]->lines.end())
                                                                                         && (GetCommonEndpoint(LineChecker[0]->second,
                                                                                                         LineChecker[1]->second) == peak))));
                                                                         if (!continueflag)
+                                                                                {
                                                                                         *out << Verbose(4) << "Current target is peak!" << endl;
                                                                                         continue;
+                                                                                }
                                                                         // in case NOT both were found
                                                                         if (continueflag)
                                                                                 { // create virtually this triangle, get its normal vector, calculate angle
                                                                                         flag = true;
                                                                                         VirtualNormalVector.MakeNormalVector(
                                                                                                         &baseline->second->endpoints[0]->node->x,
                                                                                                         &baseline->second->endpoints[1]->node->x,
                                                                                                         &target->second->node->x);
                                                                                         // make it always point inward
                                                                                         if (baseline->second->endpoints[0]->node->x.Projection(
                                                                                                         &VirtualNormalVector) > 0)
                                                                                                 VirtualNormalVector.Scale(-1.);
                                                                                         // calculate angle
                                                                                         TempAngle = NormalVector.Angle(&VirtualNormalVector);
                                                                                         *out << Verbose(4) << "NormalVector is ";
                                                                                         VirtualNormalVector.Output(out);
                                                                                         *out << " and the angle is " << TempAngle << "." << endl;
                                                                                         if (SmallestAngle > TempAngle)
                                                                                                 { // set to new possible winner
                                                                                                         SmallestAngle = TempAngle;
                                                                                                         winner = target;
+                                                                                                }
+                                                                                }
+                                                                }
                                                 // 5b. The point of the above whose triangle has the greatest angle with the triangle the current line belongs to (it only belongs to one, remember!): New triangle
                                                 if (winner != PointsOnBoundary.end())
+                                                        {
                                                                 *out << Verbose(2) << "Winning target point is "
                                                                                 << *(winner->second) << " with angle " << SmallestAngle
                                                                                 << "." << endl;
                                                                 // create the lins of not yet present
                                                                 BLS[0] = baseline->second;
                                                                 // 5c. add lines to the line set if those were new (not yet part of a triangle), delete lines that belong to two triangles)
                                                                 LineChecker[0] = baseline->second->endpoints[0]->lines.find(
                                                                                 winner->first);
                                                                 LineChecker[1] = baseline->second->endpoints[1]->lines.find(
                                                                                 winner->first);
                                                                 if (LineChecker[0]
                                                                                 == baseline->second->endpoints[0]->lines.end())
                                                                         { // create
                                                                                 BPS[0] = baseline->second->endpoints[0];
                                                                                 BPS[1] = winner->second;
                                                                                 BLS[1] = new class BoundaryLineSet(BPS,
                                                                                                 LinesOnBoundaryCount);
                                                                                 LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
                                                                                                 BLS[1]));
                                                                                 LinesOnBoundaryCount++;
+                                                                        }
                                                                 else
                                                                         BLS[1] = LineChecker[0]->second;
                                                                 if (LineChecker[1]
                                                                                 == baseline->second->endpoints[1]->lines.end())
                                                                         { // create
                                                                                 BPS[0] = baseline->second->endpoints[1];
                                                                                 BPS[1] = winner->second;
                                                                                 BLS[2] = new class BoundaryLineSet(BPS,
                                                                                                 LinesOnBoundaryCount);
                                                                                 LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
                                                                                                 BLS[2]));
                                                                                 LinesOnBoundaryCount++;
+                                                                        }
                                                                 else
                                                                         BLS[2] = LineChecker[1]->second;
                                                                 BTS = new class BoundaryTriangleSet(BLS,
                                                                                 TrianglesOnBoundaryCount);
                                                                 TrianglesOnBoundary.insert(TrianglePair(
                                                                                 TrianglesOnBoundaryCount, BTS));
                                                                 TrianglesOnBoundaryCount++;
+                                                        }
                                                 else
+                                                        {
                                                                 *out << Verbose(1)
                                                                                 << "I could not determine a winner for this baseline "
                                                                                 << *(baseline->second) << "." << endl;
+                                                        }
                                                 // 5d. If the set of lines is not yet empty, go to 5. and continue
+                                        }
                                 else
                                         *out << Verbose(2) << "Baseline candidate " << *(baseline->second)
                                                         << " has a triangle count of "
                                                         << baseline->second->TrianglesCount << "." << endl;
+                }
         while (flag);
+    molecule *mol)
+{
+  bool flag;
+  PointMap::iterator winner;
+  class BoundaryPointSet *peak = NULL;
+  double SmallestAngle, TempAngle;
+  Vector NormalVector, VirtualNormalVector, CenterVector, TempVector,
+      PropagationVector;
+  LineMap::iterator LineChecker[2];
+  do
+    {
+      flag = false;
+      for (LineMap::iterator baseline = LinesOnBoundary.begin(); baseline
+          != LinesOnBoundary.end(); baseline++)
+        if (baseline->second->TrianglesCount == 1)
+          {
+            *out << Verbose(2) << "Current baseline is between "
+                << *(baseline->second) << "." << endl;
+            // 5a. go through each boundary point if not _both_ edges between either endpoint of the current line and this point exist (and belong to 2 triangles)
+            SmallestAngle = M_PI;
+            BTS = baseline->second->triangles.begin()->second; // there is only one triangle so far
+            // get peak point with respect to this base line's only triangle
+            for (int i = 0; i < 3; i++)
+              if ((BTS->endpoints[i] != baseline->second->endpoints[0])
+                  && (BTS->endpoints[i] != baseline->second->endpoints[1]))
+                peak = BTS->endpoints[i];
+            *out << Verbose(3) << " and has peak " << *peak << "." << endl;
+            // normal vector of triangle
+            BTS->GetNormalVector(NormalVector);
+            *out << Verbose(4) << "NormalVector of base triangle is ";
+            NormalVector.Output(out);
+            *out << endl;
+            // offset to center of triangle
+            CenterVector.Zero();
+            for (int i = 0; i < 3; i++)
+              CenterVector.AddVector(&BTS->endpoints[i]->node->x);
+            CenterVector.Scale(1. / 3.);
+            *out << Verbose(4) << "CenterVector of base triangle is ";
+            CenterVector.Output(out);
+            *out << endl;
+            // vector in propagation direction (out of triangle)
+            // project center vector onto triangle plane (points from intersection plane-NormalVector to plane-CenterVector intersection)
+            TempVector.CopyVector(&baseline->second->endpoints[0]->node->x);
+            TempVector.SubtractVector(&baseline->second->endpoints[1]->node->x);
+            PropagationVector.MakeNormalVector(&TempVector, &NormalVector);
+            TempVector.CopyVector(&CenterVector);
+            TempVector.SubtractVector(&baseline->second->endpoints[0]->node->x); // TempVector is vector on triangle plane pointing from one baseline egde towards center!
+            //*out << Verbose(2) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl;
+            if (PropagationVector.Projection(&TempVector) > 0) // make sure normal propagation vector points outward from baseline
+              PropagationVector.Scale(-1.);
+            *out << Verbose(4) << "PropagationVector of base triangle is ";
+            PropagationVector.Output(out);
+            *out << endl;
+            winner = PointsOnBoundary.end();
+            for (PointMap::iterator target = PointsOnBoundary.begin(); target
+                != PointsOnBoundary.end(); target++)
+              if ((target->second != baseline->second->endpoints[0])
+                  && (target->second != baseline->second->endpoints[1]))
+                { // don't take the same endpoints
+                  *out << Verbose(3) << "Target point is " << *(target->second)
+                      << ":";
+                  bool continueflag = true;
+                  VirtualNormalVector.CopyVector(
+                      &baseline->second->endpoints[0]->node->x);
+                  VirtualNormalVector.AddVector(
+                      &baseline->second->endpoints[0]->node->x);
+                  VirtualNormalVector.Scale(-1. / 2.); // points now to center of base line
+                  VirtualNormalVector.AddVector(&target->second->node->x); // points from center of base line to target
+                  TempAngle = VirtualNormalVector.Angle(&PropagationVector);
+                  continueflag = continueflag && (TempAngle < (M_PI/2.)); // no bends bigger than Pi/2 (90 degrees)
+                  if (!continueflag)
+                    {
+                      *out << Verbose(4)
+                          << "Angle between propagation direction and base line to "
+                          << *(target->second) << " is " << TempAngle
+                          << ", bad direction!" << endl;
+                      continue;
+                    }
+                  else
+                    *out << Verbose(4)
+                        << "Angle between propagation direction and base line to "
+                        << *(target->second) << " is " << TempAngle
+                        << ", good direction!" << endl;
+                  LineChecker[0] = baseline->second->endpoints[0]->lines.find(
+                      target->first);
+                  LineChecker[1] = baseline->second->endpoints[1]->lines.find(
+                      target->first);
+                  //            if (LineChecker[0] != baseline->second->endpoints[0]->lines.end())
+                  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->TrianglesCount << " triangles." << endl;
+                  //            else
+                  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has no line to " << *(target->second) << " as endpoint." << endl;
+                  //            if (LineChecker[1] != baseline->second->endpoints[1]->lines.end())
+                  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->TrianglesCount << " triangles." << endl;
+                  //            else
+                  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has no line to " << *(target->second) << " as endpoint." << endl;
+                  // check first endpoint (if any connecting line goes to target or at least not more than 1)
+                  continueflag = continueflag && (((LineChecker[0]
+                      == baseline->second->endpoints[0]->lines.end())
+                      || (LineChecker[0]->second->TrianglesCount == 1)));
+                  if (!continueflag)
+                    {
+                      *out << Verbose(4) << *(baseline->second->endpoints[0])
+                          << " has line " << *(LineChecker[0]->second)
+                          << " to " << *(target->second)
+                          << " as endpoint with "
+                          << LineChecker[0]->second->TrianglesCount
+                          << " triangles." << endl;
+                      continue;
+                    }
+                  // check second endpoint (if any connecting line goes to target or at least not more than 1)
+                  continueflag = continueflag && (((LineChecker[1]
+                      == baseline->second->endpoints[1]->lines.end())
+                      || (LineChecker[1]->second->TrianglesCount == 1)));
+                  if (!continueflag)
+                    {
+                      *out << Verbose(4) << *(baseline->second->endpoints[1])
+                          << " has line " << *(LineChecker[1]->second)
+                          << " to " << *(target->second)
+                          << " as endpoint with "
+                          << LineChecker[1]->second->TrianglesCount
+                          << " triangles." << endl;
+                      continue;
+                    }
+                  // check whether the envisaged triangle does not already exist (if both lines exist and have same endpoint)
+                  continueflag = continueflag && (!(((LineChecker[0]
+                      != baseline->second->endpoints[0]->lines.end())
+                      && (LineChecker[1]
+                          != baseline->second->endpoints[1]->lines.end())
+                      && (GetCommonEndpoint(LineChecker[0]->second,
+                          LineChecker[1]->second) == peak))));
+                  if (!continueflag)
+                    {
+                      *out << Verbose(4) << "Current target is peak!" << endl;
+                      continue;
+                    }
+                  // in case NOT both were found
+                  if (continueflag)
+                    { // create virtually this triangle, get its normal vector, calculate angle
+                      flag = true;
+                      VirtualNormalVector.MakeNormalVector(
+                          &baseline->second->endpoints[0]->node->x,
+                          &baseline->second->endpoints[1]->node->x,
+                          &target->second->node->x);
+                      // make it always point inward
+                      if (baseline->second->endpoints[0]->node->x.Projection(
+                          &VirtualNormalVector) > 0)
+                        VirtualNormalVector.Scale(-1.);
+                      // calculate angle
+                      TempAngle = NormalVector.Angle(&VirtualNormalVector);
+                      *out << Verbose(4) << "NormalVector is ";
+                      VirtualNormalVector.Output(out);
+                      *out << " and the angle is " << TempAngle << "." << endl;
+                      if (SmallestAngle > TempAngle)
+                        { // set to new possible winner
+                          SmallestAngle = TempAngle;
+                          winner = target;
+                        }
+                    }
+                }
+            // 5b. The point of the above whose triangle has the greatest angle with the triangle the current line belongs to (it only belongs to one, remember!): New triangle
+            if (winner != PointsOnBoundary.end())
+              {
+                *out << Verbose(2) << "Winning target point is "
+                    << *(winner->second) << " with angle " << SmallestAngle
+                    << "." << endl;
+                // create the lins of not yet present
+                BLS[0] = baseline->second;
+                // 5c. add lines to the line set if those were new (not yet part of a triangle), delete lines that belong to two triangles)
+                LineChecker[0] = baseline->second->endpoints[0]->lines.find(
+                    winner->first);
+                LineChecker[1] = baseline->second->endpoints[1]->lines.find(
+                    winner->first);
+                if (LineChecker[0]
+                    == baseline->second->endpoints[0]->lines.end())
+                  { // create
+                    BPS[0] = baseline->second->endpoints[0];
+                    BPS[1] = winner->second;
+                    BLS[1] = new class BoundaryLineSet(BPS,
+                        LinesOnBoundaryCount);
+                    LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
+                        BLS[1]));
+                    LinesOnBoundaryCount++;
+                  }
+                else
+                  BLS[1] = LineChecker[0]->second;
+                if (LineChecker[1]
+                    == baseline->second->endpoints[1]->lines.end())
+                  { // create
+                    BPS[0] = baseline->second->endpoints[1];
+                    BPS[1] = winner->second;
+                    BLS[2] = new class BoundaryLineSet(BPS,
+                        LinesOnBoundaryCount);
+                    LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
+                        BLS[2]));
+                    LinesOnBoundaryCount++;
+                  }
+                else
+                  BLS[2] = LineChecker[1]->second;
+                BTS = new class BoundaryTriangleSet(BLS,
+                    TrianglesOnBoundaryCount);
+                TrianglesOnBoundary.insert(TrianglePair(
+                    TrianglesOnBoundaryCount, BTS));
+                TrianglesOnBoundaryCount++;
+              }
+            else
+              {
+                *out << Verbose(1)
+                    << "I could not determine a winner for this baseline "
+                    << *(baseline->second) << "." << endl;
+              }
+            // 5d. If the set of lines is not yet empty, go to 5. and continue
+          }
+        else
+          *out << Verbose(2) << "Baseline candidate " << *(baseline->second)
+              << " has a triangle count of "
+              << baseline->second->TrianglesCount << "." << endl;
+    }
+  while (flag);
+}
 …
 Tesselation::AddPoint(atom *Walker)
+{
         PointTestPair InsertUnique;
         BPS[0] = new class BoundaryPointSet(Walker);
         InsertUnique = PointsOnBoundary.insert(PointPair(Walker->nr, BPS[0]));
         if (InsertUnique.second) // if new point was not present before, increase counter
                 PointsOnBoundaryCount++;
+  PointTestPair InsertUnique;
+  BPS[0] = new class BoundaryPointSet(Walker);
+  InsertUnique = PointsOnBoundary.insert(PointPair(Walker->nr, BPS[0]));
+  if (InsertUnique.second) // if new point was not present before, increase counter
+    PointsOnBoundaryCount++;
+}
+;
 …
 Tesselation::AddTrianglePoint(atom* Candidate, int n)
+{
         PointTestPair InsertUnique;
         TPS[n] = new class BoundaryPointSet(Candidate);
         InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->nr, TPS[n]));
         if (InsertUnique.second) // if new point was not present before, increase counter
+                {
                         PointsOnBoundaryCount++;
+                }
         else
+                {
                         delete TPS[n];
                         cout << Verbose(2) << "Atom " << *((InsertUnique.first)->second->node)
                                         << " gibt's schon in der PointMap." << endl;
                         TPS[n] = (InsertUnique.first)->second;
+                }
+  PointTestPair InsertUnique;
+  TPS[n] = new class BoundaryPointSet(Candidate);
+  InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->nr, TPS[n]));
+  if (InsertUnique.second) // if new point was not present before, increase counter
+    {
+      PointsOnBoundaryCount++;
+    }
+  else
+    {
+      delete TPS[n];
+      cout << Verbose(2) << "Atom " << *((InsertUnique.first)->second->node)
+          << " gibt's schon in der PointMap." << endl;
+      TPS[n] = (InsertUnique.first)->second;
+    }
+}
+;
 …
 void
 Tesselation::AddTriangleLine(class BoundaryPointSet *a,
                 class BoundaryPointSet *b, int n)
+{
         LineMap::iterator LineWalker;
         //cout << "Manually checking endpoints for line." << endl;
         if ((a->lines.find(b->node->nr)) != a->lines.end()) // ->first == b->node->nr)
         //If a line is there, how do I recognize that beyond a shadow of a doubt?
+                {
                         //cout << Verbose(2) << "Line exists already, retrieving it from LinesOnBoundarySet" << endl;
                         LineWalker = LinesOnBoundary.end();
                         LineWalker--;
                         while (LineWalker->second->endpoints[0]->node->nr != min(a->node->nr,
                                         b->node->nr) or LineWalker->second->endpoints[1]->node->nr != max(
                                         a->node->nr, b->node->nr))
+                                {
                                         //cout << Verbose(1) << "Looking for line which already exists"<< endl;
                                         LineWalker--;
+                                }
                         BPS[0] = LineWalker->second->endpoints[0];
                         BPS[1] = LineWalker->second->endpoints[1];
                         BLS[n] = LineWalker->second;
+                }
         else
+                {
                         cout << Verbose(2)
                                         << "Adding line which has not been used before between "
                                         << *(a->node) << " and " << *(b->node) << "." << endl;
                         BPS[0] = a;
                         BPS[1] = b;
                         BLS[n] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
                         LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BLS[n]));
                         LinesOnBoundaryCount++;
+                }
+    class BoundaryPointSet *b, int n)
+{
+  LineMap::iterator LineWalker;
+  //cout << "Manually checking endpoints for line." << endl;
+  if ((a->lines.find(b->node->nr)) != a->lines.end()) // ->first == b->node->nr)
+  //If a line is there, how do I recognize that beyond a shadow of a doubt?
+    {
+      //cout << Verbose(2) << "Line exists already, retrieving it from LinesOnBoundarySet" << endl;
+      LineWalker = LinesOnBoundary.end();
+      LineWalker--;
+      while (LineWalker->second->endpoints[0]->node->nr != min(a->node->nr,
+          b->node->nr) or LineWalker->second->endpoints[1]->node->nr != max(
+          a->node->nr, b->node->nr))
+        {
+          //cout << Verbose(1) << "Looking for line which already exists"<< endl;
+          LineWalker--;
+        }
+      BPS[0] = LineWalker->second->endpoints[0];
+      BPS[1] = LineWalker->second->endpoints[1];
+      BLS[n] = LineWalker->second;
+    }
+  else
+    {
+      cout << Verbose(2)
+          << "Adding line which has not been used before between "
+          << *(a->node) << " and " << *(b->node) << "." << endl;
+      BPS[0] = a;
+      BPS[1] = b;
+      BLS[n] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+      LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BLS[n]));
+      LinesOnBoundaryCount++;
+    }
+}
+;
 …
+{
+        cout << Verbose(1) << "Adding triangle to its lines" << endl;
+        int i = 0;
+        TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
+        TrianglesOnBoundaryCount++;
+        /*
+         * this is apparently done when constructing triangle
+         for (i=0; i<3; i++)
+         {
+         BLS[i]->AddTriangle(BTS);
+         }
+         */
+  cout << Verbose(1) << "Adding triangle to its lines" << endl;
+  TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
+  TrianglesOnBoundaryCount++;
+  /*
+   * this is apparently done when constructing triangle
+   for (int i=0; i<3; i++)
+   {
+   BLS[i]->AddTriangle(BTS);
+   }
+   */
+}
+;
 …
 double det_get(gsl_matrix *A, int inPlace) {
         /*
         inPlace = 1 => A is replaced with the LU decomposed copy.
         inPlace = 0 => A is retained, and a copy is used for LU.
         */
         double det;
         int signum;
         gsl_permutation *p = gsl_permutation_alloc(A->size1);
         gsl_matrix *tmpA;
         if (inPlace)
         tmpA = A;
         else {
         gsl_matrix *tmpA = gsl_matrix_alloc(A->size1, A->size2);
         gsl_matrix_memcpy(tmpA , A);
+        }
         gsl_linalg_LU_decomp(tmpA , p , &signum);
         det = gsl_linalg_LU_det(tmpA , signum);
         gsl_permutation_free(p);
         if (! inPlace)
         gsl_matrix_free(tmpA);
         return det;
+  /*
+  inPlace = 1 => A is replaced with the LU decomposed copy.
+  inPlace = 0 => A is retained, and a copy is used for LU.
+  */
+  double det;
+  int signum;
+  gsl_permutation *p = gsl_permutation_alloc(A->size1);
+  gsl_matrix *tmpA;
+  if (inPlace)
+  tmpA = A;
+  else {
+  gsl_matrix *tmpA = gsl_matrix_alloc(A->size1, A->size2);
+  gsl_matrix_memcpy(tmpA , A);
+  }
+  gsl_linalg_LU_decomp(tmpA , p , &signum);
+  det = gsl_linalg_LU_det(tmpA , signum);
+  gsl_permutation_free(p);
+  if (! inPlace)
+  gsl_matrix_free(tmpA);
+  return det;
 };
 void get_sphere(Vector *center, Vector &a, Vector &b, Vector &c, double RADIUS)
+{
         gsl_matrix *A = gsl_matrix_calloc(3,3);
         double m11, m12, m13, m14;
         for(int i=0;i<3;i++) {
                 gsl_matrix_set(A, i, 0, a.x[i]);
                 gsl_matrix_set(A, i, 1, b.x[i]);
                 gsl_matrix_set(A, i, 2, c.x[i]);
+        }
         m11 = det_get(A, 1);
         for(int i=0;i<3;i++) {
                 gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
                 gsl_matrix_set(A, i, 1, b.x[i]);
                 gsl_matrix_set(A, i, 2, c.x[i]);
+        }
         m12 = det_get(A, 1);
         for(int i=0;i<3;i++) {
                 gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
                 gsl_matrix_set(A, i, 1, a.x[i]);
                 gsl_matrix_set(A, i, 2, c.x[i]);
+        }
         m13 = det_get(A, 1);
         for(int i=0;i<3;i++) {
                 gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
                 gsl_matrix_set(A, i, 1, a.x[i]);
                 gsl_matrix_set(A, i, 2, b.x[i]);
+        }
         m14 = det_get(A, 1);
         if (fabs(m11) < MYEPSILON)
                 cerr << "ERROR: three points are colinear." << endl;
         center->x[0] =  0.5 * m12/ m11;
         center->x[1] = -0.5 * m13/ m11;
         center->x[2] =  0.5 * m14/ m11;
         if (fabs(a.Distance(center) - RADIUS) > MYEPSILON)
                 cerr << "ERROR: The given center is further way by " << fabs(a.Distance(center) - RADIUS) << " from a than RADIUS." << endl;
         gsl_matrix_free(A);
+  gsl_matrix *A = gsl_matrix_calloc(3,3);
+  double m11, m12, m13, m14;
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]);
+    gsl_matrix_set(A, i, 1, b.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m11 = det_get(A, 1);
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, b.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m12 = det_get(A, 1);
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, a.x[i]);
+    gsl_matrix_set(A, i, 2, c.x[i]);
+  }
+  m13 = det_get(A, 1);
+  for(int i=0;i<3;i++) {
+    gsl_matrix_set(A, i, 0, a.x[i]*a.x[i] + b.x[i]*b.x[i] + c.x[i]*c.x[i]);
+    gsl_matrix_set(A, i, 1, a.x[i]);
+    gsl_matrix_set(A, i, 2, b.x[i]);
+  }
+  m14 = det_get(A, 1);
+  if (fabs(m11) < MYEPSILON)
+    cerr << "ERROR: three points are colinear." << endl;
+  center->x[0] =  0.5 * m12/ m11;
+  center->x[1] = -0.5 * m13/ m11;
+  center->x[2] =  0.5 * m14/ m11;
+  if (fabs(a.Distance(center) - RADIUS) > MYEPSILON)
+    cerr << "ERROR: The given center is further way by " << fabs(a.Distance(center) - RADIUS) << " from a than RADIUS." << endl;
+  gsl_matrix_free(A);
 };
 …
  */
 void Get_center_of_sphere(Vector* Center, Vector a, Vector b, Vector c, Vector *NewUmkreismittelpunkt, Vector* Direction, Vector* AlternativeDirection,
+                double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
+{
+        Vector TempNormal, helper;
+        double Restradius;
+        Vector OtherCenter;
+        cout << Verbose(3) << "Begin of Get_center_of_sphere.\n";
+        Center->Zero();
+        helper.CopyVector(&a);
+        helper.Scale(sin(2.*alpha));
+        Center->AddVector(&helper);
+        helper.CopyVector(&b);
+        helper.Scale(sin(2.*beta));
+        Center->AddVector(&helper);
+        helper.CopyVector(&c);
+        helper.Scale(sin(2.*gamma));
+        Center->AddVector(&helper);
+        //*Center = a * sin(2.*alpha) + b * sin(2.*beta) + c * sin(2.*gamma) ;
+        Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+        NewUmkreismittelpunkt->CopyVector(Center);
+        cout << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
+        // Here we calculated center of circumscribing circle, using barycentric coordinates
+        cout << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
+        TempNormal.CopyVector(&a);
+        TempNormal.SubtractVector(&b);
+        helper.CopyVector(&a);
+        helper.SubtractVector(&c);
+        TempNormal.VectorProduct(&helper);
+        if (fabs(HalfplaneIndicator) < MYEPSILON)
+                {
+                        if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
+                                {
+                                        TempNormal.Scale(-1);
+                                }
+                }
+        else
+                {
+                        if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
+                                {
+                                        TempNormal.Scale(-1);
+                                }
+                }
+        TempNormal.Normalize();
+        Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
+        cout << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
+        TempNormal.Scale(Restradius);
+        cout << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
+        Center->AddVector(&TempNormal);
+        cout << Verbose(0) << "Center of sphere of circumference is " << *Center << ".\n";
+        get_sphere(&OtherCenter, a, b, c, RADIUS);
+        cout << Verbose(0) << "OtherCenter of sphere of circumference is " << OtherCenter << ".\n";
+        cout << Verbose(3) << "End of Get_center_of_sphere.\n";
+    double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
+{
+  Vector TempNormal, helper;
+  double Restradius;
+  Vector OtherCenter;
+  cout << Verbose(3) << "Begin of Get_center_of_sphere.\n";
+  Center->Zero();
+  helper.CopyVector(&a);
+  helper.Scale(sin(2.*alpha));
+  Center->AddVector(&helper);
+  helper.CopyVector(&b);
+  helper.Scale(sin(2.*beta));
+  Center->AddVector(&helper);
+  helper.CopyVector(&c);
+  helper.Scale(sin(2.*gamma));
+  Center->AddVector(&helper);
+  //*Center = a * sin(2.*alpha) + b * sin(2.*beta) + c * sin(2.*gamma) ;
+  Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+  NewUmkreismittelpunkt->CopyVector(Center);
+  cout << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
+  // Here we calculated center of circumscribing circle, using barycentric coordinates
+  cout << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
+  TempNormal.CopyVector(&a);
+  TempNormal.SubtractVector(&b);
+  helper.CopyVector(&a);
+  helper.SubtractVector(&c);
+  TempNormal.VectorProduct(&helper);
+  if (fabs(HalfplaneIndicator) < MYEPSILON)
+    {
+      if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
+        {
+          TempNormal.Scale(-1);
+        }
+    }
+  else
+    {
+      if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
+        {
+          TempNormal.Scale(-1);
+        }
+    }
+  TempNormal.Normalize();
+  Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
+  cout << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
+  TempNormal.Scale(Restradius);
+  cout << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
+  Center->AddVector(&TempNormal);
+  cout << Verbose(0) << "Center of sphere of circumference is " << *Center << ".\n";
+  get_sphere(&OtherCenter, a, b, c, RADIUS);
+  cout << Verbose(0) << "OtherCenter of sphere of circumference is " << OtherCenter << ".\n";
+  cout << Verbose(3) << "End of Get_center_of_sphere.\n";
 };
 /** This recursive function finds a third point, to form a triangle with two given ones.
  * Two atoms are fixed, a candidate is supplied, additionally two vectors for direction distinction, a Storage area to \
  *      supply results to the calling function, the radius of the sphere which the triangle shall support and the molecule \
  *      upon which we operate.
  *      If the candidate is more fitting to support the sphere than the already stored atom is, then we write its general \
  *      direction and angle into Storage.
  *      We the determine the recursive level we have reached and if this is not on the threshold yet, call this function again, \
  *      with all neighbours of the candidate.
+ *  supply results to the calling function, the radius of the sphere which the triangle shall support and the molecule \
+ *  upon which we operate.
+ *  If the candidate is more fitting to support the sphere than the already stored atom is, then we write its general \
+ *  direction and angle into Storage.
+ *  We the determine the recursive level we have reached and if this is not on the threshold yet, call this function again, \
+ *  with all neighbours of the candidate.
  * @param a first point
  * @param b second point
 …
  */
 void Tesselation::Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent,
+                int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint,
+                atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol)
+{
+        cout << Verbose(2) << "Begin of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+        cout << Verbose(3) << "Candidate is "<< *Candidate << endl;
+        cout << Verbose(4) << "Baseline vector is " << *Chord << "." << endl;
+        cout << Verbose(4) << "ReferencePoint is " << ReferencePoint << "." << endl;
+        cout << Verbose(4) << "Normal of base triangle is " << *OldNormal << "." << endl;
+        cout << Verbose(4) << "Search direction is " << *direction1 << "." << endl;
+        /* OldNormal is normal vector on the old triangle
+         * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
+         * Chord points from b to a!!!
+         */
+        Vector dif_a; //Vector from a to candidate
+        Vector dif_b; //Vector from b to candidate
+        Vector AngleCheck;
+        Vector TempNormal, Umkreismittelpunkt;
+        Vector Mittelpunkt;
+        double CurrentEpsilon = 0.1;
+        double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius, Distance;
+        double BallAngle, AlternativeSign;
+        atom *Walker; // variable atom point
+        Vector NewUmkreismittelpunkt;
+        if (a != Candidate and b != Candidate and c != Candidate) {
+                cout << Verbose(3) << "We have a unique candidate!" << endl;
+                dif_a.CopyVector(&(a->x));
+                dif_a.SubtractVector(&(Candidate->x));
+                dif_b.CopyVector(&(b->x));
+                dif_b.SubtractVector(&(Candidate->x));
+                AngleCheck.CopyVector(&(Candidate->x));
+                AngleCheck.SubtractVector(&(a->x));
+                AngleCheck.ProjectOntoPlane(Chord);
+                SideA = dif_b.Norm();
+                SideB = dif_a.Norm();
+                SideC = Chord->Norm();
+                //Chord->Scale(-1);
+                alpha = Chord->Angle(&dif_a);
+                beta = M_PI - Chord->Angle(&dif_b);
+                gamma = dif_a.Angle(&dif_b);
+                cout << Verbose(2) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+                if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON) {
+                        cerr << Verbose(0) << "WARNING: sum of angles for base triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
+                        cout << Verbose(1) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+                }
+                if ((M_PI*179./180. > alpha) && (M_PI*179./180. > beta) && (M_PI*179./180. > gamma)) {
+                        Umkreisradius = SideA / 2.0 / sin(alpha);
+                        //cout << Umkreisradius << endl;
+                        //cout << SideB / 2.0 / sin(beta) << endl;
+                        //cout << SideC / 2.0 / sin(gamma) << endl;
+                        if (Umkreisradius < RADIUS) { //Checking whether ball will at least rest on points.
+                                cout << Verbose(3) << "Circle of circumference would fit: " << Umkreisradius << " < " << RADIUS << "." << endl;
+                                cout << Verbose(2) << "Candidate is "<< *Candidate << endl;
+                                sign = AngleCheck.ScalarProduct(direction1);
+                                if (fabs(sign)<MYEPSILON) {
+                                        if (AngleCheck.ScalarProduct(OldNormal)<0) {
+                                                sign =0;
+                                                AlternativeSign=1;
+                                        } else {
+                                                sign =0;
+                                                AlternativeSign=-1;
+                                        }
+                                } else {
+                                        sign /= fabs(sign);
+                                }
+                                if (sign >= 0) {
+                                        cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
+                                        Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), &NewUmkreismittelpunkt, OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
+                                        Mittelpunkt.SubtractVector(&ReferencePoint);
+                                        cout << Verbose(3) << "Reference vector to sphere's center is " << Mittelpunkt << "." << endl;
+                                        BallAngle = Mittelpunkt.Angle(OldNormal);
+                                        cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
+                                        //cout << "direction1 is " << *direction1 << "." << endl;
+                                        //cout << "Mittelpunkt is " << Mittelpunkt << "."<< endl;
+                                        //cout << Verbose(3) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
+                                        NewUmkreismittelpunkt.SubtractVector(&ReferencePoint);
+                                        if ((Mittelpunkt.ScalarProduct(direction1) >=0) || (fabs(NewUmkreismittelpunkt.Norm()) < MYEPSILON)) {
+                                                if (Storage[0]< -1.5) { // first Candidate at all
+                                                        if (1) {//if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                                                                cout << Verbose(2) << "First good candidate is " << *Candidate << " with ";
+                                                                Opt_Candidate = Candidate;
+                                                                Storage[0] = sign;
+                                                                Storage[1] = AlternativeSign;
+                                                                Storage[2] = BallAngle;
+                                                                cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+                                                        } else
+                                                                cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+                                                } else {
+                                                        if ( Storage[2] > BallAngle) {
+                                                                if (1) { //if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                                                                        cout << Verbose(2) << "Next better candidate is " << *Candidate << " with ";
+                                                                        Opt_Candidate = Candidate;
+                                                                        Storage[0] = sign;
+                                                                        Storage[1] = AlternativeSign;
+                                                                        Storage[2] = BallAngle;
+                                                                        cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+                                                                } else
+                                                                        cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+                                                        } else {
+                                                                if (DEBUG) {
+                                                                        cout << Verbose(3) << *Candidate << " looses against better candidate " << *Opt_Candidate << "." << endl;
+                                                                }
+                                                        }
+                                                }
+                                        } else {
+                                                if (DEBUG) {
+                                                        cout << Verbose(3) << *Candidate << " refused due to Up/Down sign which is " << sign << endl;
+                                                }
+                                        }
+                                } else {
+                                        if (DEBUG) {
+                                                cout << Verbose(3) << *Candidate << " is not in search direction." << endl;
+                                        }
+                                }
+                        } else {
+                                if (DEBUG) {
+                                        cout << Verbose(3) << *Candidate << " would have circumference of " << Umkreisradius << " bigger than ball's radius " << RADIUS << "." << endl;
+                                }
+                        }
+                } else {
+                        if (DEBUG) {
+                                cout << Verbose(0) << "Triangle consisting of " << *Candidate << ", " << *a << " and " << *b << " has an angle >150!" << endl;
+                        }
+                }
+        } else {
+                if (DEBUG) {
+                        cout << Verbose(3) << *Candidate << " is either " << *a << " or " << *b << "." << endl;
+                }
+        }
+        if (RecursionLevel < 5) { // Seven is the recursion level threshold.
+                for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
+                        Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
+                        if (Walker == Parent) { // don't go back the same bond
+                                continue;
+                        } else {
+                                Find_next_suitable_point_via_Angle_of_Sphere(a, b, c, Walker, Candidate, RecursionLevel+1, Chord, direction1, OldNormal, ReferencePoint, Opt_Candidate, Storage, RADIUS, mol); //call function again
+                        }
+                }
+        }
+        cout << Verbose(2) << "End of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+    int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint,
+    atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol)
+{
+  cout << Verbose(2) << "Begin of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+  cout << Verbose(3) << "Candidate is "<< *Candidate << endl;
+  cout << Verbose(4) << "Baseline vector is " << *Chord << "." << endl;
+  cout << Verbose(4) << "ReferencePoint is " << ReferencePoint << "." << endl;
+  cout << Verbose(4) << "Normal of base triangle is " << *OldNormal << "." << endl;
+  cout << Verbose(4) << "Search direction is " << *direction1 << "." << endl;
+  /* OldNormal is normal vector on the old triangle
+   * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
+   * Chord points from b to a!!!
+   */
+  Vector dif_a; //Vector from a to candidate
+  Vector dif_b; //Vector from b to candidate
+  Vector AngleCheck;
+  Vector TempNormal, Umkreismittelpunkt;
+  Vector Mittelpunkt;
+  double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius;
+  double BallAngle, AlternativeSign;
+  atom *Walker; // variable atom point
+  Vector NewUmkreismittelpunkt;
+  if (a != Candidate and b != Candidate and c != Candidate) {
+    cout << Verbose(3) << "We have a unique candidate!" << endl;
+    dif_a.CopyVector(&(a->x));
+    dif_a.SubtractVector(&(Candidate->x));
+    dif_b.CopyVector(&(b->x));
+    dif_b.SubtractVector(&(Candidate->x));
+    AngleCheck.CopyVector(&(Candidate->x));
+    AngleCheck.SubtractVector(&(a->x));
+    AngleCheck.ProjectOntoPlane(Chord);
+    SideA = dif_b.Norm();
+    SideB = dif_a.Norm();
+    SideC = Chord->Norm();
+    //Chord->Scale(-1);
+    alpha = Chord->Angle(&dif_a);
+    beta = M_PI - Chord->Angle(&dif_b);
+    gamma = dif_a.Angle(&dif_b);
+    cout << Verbose(2) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+    if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON) {
+      cerr << Verbose(0) << "WARNING: sum of angles for base triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
+      cout << Verbose(1) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+    }
+    if ((M_PI*179./180. > alpha) && (M_PI*179./180. > beta) && (M_PI*179./180. > gamma)) {
+      Umkreisradius = SideA / 2.0 / sin(alpha);
+      //cout << Umkreisradius << endl;
+      //cout << SideB / 2.0 / sin(beta) << endl;
+      //cout << SideC / 2.0 / sin(gamma) << endl;
+      if (Umkreisradius < RADIUS) { //Checking whether ball will at least rest on points.
+        cout << Verbose(3) << "Circle of circumference would fit: " << Umkreisradius << " < " << RADIUS << "." << endl;
+        cout << Verbose(2) << "Candidate is "<< *Candidate << endl;
+        sign = AngleCheck.ScalarProduct(direction1);
+        if (fabs(sign)<MYEPSILON) {
+          if (AngleCheck.ScalarProduct(OldNormal)<0) {
+            sign =0;
+            AlternativeSign=1;
+          } else {
+            sign =0;
+            AlternativeSign=-1;
+          }
+        } else {
+          sign /= fabs(sign);
+          cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
+        }
+        if (sign >= 0) {
+          cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
+          Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), &NewUmkreismittelpunkt, OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
+          Mittelpunkt.SubtractVector(&ReferencePoint);
+          cout << Verbose(3) << "Reference vector to sphere's center is " << Mittelpunkt << "." << endl;
+          BallAngle = Mittelpunkt.Angle(OldNormal);
+          cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
+        cout << Verbose(3) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
+          if ((Mittelpunkt.ScalarProduct(direction1) >=0) || (fabs(NewUmkreismittelpunkt.Norm()) < MYEPSILON)) {
+            if (Storage[0]< -1.5) { // first Candidate at all
+              if (1) {//if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                cout << Verbose(2) << "First good candidate is " << *Candidate << " with ";
+                Opt_Candidate = Candidate;
+                Storage[0] = sign;
+                Storage[1] = AlternativeSign;
+                Storage[2] = BallAngle;
+                cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+              } else
+                cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+            } else {
+              if ( Storage[2] > BallAngle) {
+                if (1) { //if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                  cout << Verbose(2) << "Next better candidate is " << *Candidate << " with ";
+                  Opt_Candidate = Candidate;
+                  Storage[0] = sign;
+                  Storage[1] = AlternativeSign;
+                  Storage[2] = BallAngle;
+                  cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+                } else
+                  cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+              } else {
+                if (DEBUG) {
+                  cout << Verbose(3) << *Candidate << " looses against better candidate " << *Opt_Candidate << "." << endl;
+                }
+              }
+            }
+          } else {
+            if (DEBUG) {
+              cout << Verbose(3) << *Candidate << " refused due to Up/Down sign which is " << sign << endl;
+            }
+          }
+        } else {
+          if (DEBUG) {
+            cout << Verbose(3) << *Candidate << " is not in search direction." << endl;
+          }
+        }
+      } else {
+        if (DEBUG) {
+          cout << Verbose(3) << *Candidate << " would have circumference of " << Umkreisradius << " bigger than ball's radius " << RADIUS << "." << endl;
+        }
+      }
+    } else {
+      if (DEBUG) {
+        cout << Verbose(0) << "Triangle consisting of " << *Candidate << ", " << *a << " and " << *b << " has an angle >150!" << endl;
+      }
+    }
+  } else {
+    if (DEBUG) {
+      cout << Verbose(3) << *Candidate << " is either " << *a << " or " << *b << "." << endl;
+    }
+  }
+  if (RecursionLevel < 5) { // Seven is the recursion level threshold.
+    for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
+      Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
+      if (Walker == Parent) { // don't go back the same bond
+        continue;
+      } else {
+        Find_next_suitable_point_via_Angle_of_Sphere(a, b, c, Walker, Candidate, RecursionLevel+1, Chord, direction1, OldNormal, ReferencePoint, Opt_Candidate, Storage, RADIUS, mol); //call function again
+      }
+    }
+  }
+  cout << Verbose(2) << "End of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+}
+;
 …
 void GetCenterofCircumcircle(Vector *Center, Vector *a, Vector *b, Vector *c)
+{
         Vector helper;
         double alpha, beta, gamma;
         Vector SideA, SideB, SideC;
         SideA.CopyVector(b);
         SideA.SubtractVector(c);
         SideB.CopyVector(c);
         SideB.SubtractVector(a);
         SideC.CopyVector(a);
         SideC.SubtractVector(b);
         alpha = M_PI - SideB.Angle(&SideC);
         beta = M_PI - SideC.Angle(&SideA);
         gamma = M_PI - SideA.Angle(&SideB);
         cout << Verbose(3) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
         if (fabs(M_PI - alpha - beta - gamma) > HULLEPSILON)
                 cerr << "Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl;
         Center->Zero();
         helper.CopyVector(a);
         helper.Scale(sin(2.*alpha));
         Center->AddVector(&helper);
         helper.CopyVector(b);
         helper.Scale(sin(2.*beta));
         Center->AddVector(&helper);
         helper.CopyVector(c);
         helper.Scale(sin(2.*gamma));
         Center->AddVector(&helper);
         Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+  Vector helper;
+  double alpha, beta, gamma;
+  Vector SideA, SideB, SideC;
+  SideA.CopyVector(b);
+  SideA.SubtractVector(c);
+  SideB.CopyVector(c);
+  SideB.SubtractVector(a);
+  SideC.CopyVector(a);
+  SideC.SubtractVector(b);
+  alpha = M_PI - SideB.Angle(&SideC);
+  beta = M_PI - SideC.Angle(&SideA);
+  gamma = M_PI - SideA.Angle(&SideB);
+  cout << Verbose(3) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
+  if (fabs(M_PI - alpha - beta - gamma) > HULLEPSILON)
+    cerr << "Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl;
+  Center->Zero();
+  helper.CopyVector(a);
+  helper.Scale(sin(2.*alpha));
+  Center->AddVector(&helper);
+  helper.CopyVector(b);
+  helper.Scale(sin(2.*beta));
+  Center->AddVector(&helper);
+  helper.CopyVector(c);
+  helper.Scale(sin(2.*gamma));
+  Center->AddVector(&helper);
+  Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
 };
 …
 double GetPathLengthonCircumCircle(Vector &CircleCenter, Vector &CirclePlaneNormal, double CircleRadius, Vector &NewSphereCenter, Vector &OldSphereCenter, Vector &NormalVector, Vector &SearchDirection)
+{
         Vector helper;
         double radius, alpha;
         helper.CopyVector(&NewSphereCenter);
         // test whether new center is on the parameter circle's plane
         if (fabs(helper.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
                 cerr << "ERROR: Something's very wrong here: NewSphereCenter is not on the band's plane as desired by " <<fabs(helper.ScalarProduct(&CirclePlaneNormal))        << "!" << endl;
                 helper.ProjectOntoPlane(&CirclePlaneNormal);
+        }
         radius = helper.ScalarProduct(&helper);
         // test whether the new center vector has length of CircleRadius
         if (fabs(radius - CircleRadius) > HULLEPSILON)
                 cerr << Verbose(1) << "ERROR: The projected center of the new sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
         alpha = helper.Angle(&OldSphereCenter);
         // make the angle unique by checking the halfplanes/search direction
         if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)      // acos is not unique on [0, 2.*M_PI), hence extra check to decide between two half intervals
                 alpha = 2.*M_PI - alpha;
         cout << Verbose(2) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << OldSphereCenter << " and resulting angle is " << alpha << "." << endl;
         radius = helper.Distance(&OldSphereCenter);
         helper.ProjectOntoPlane(&NormalVector);
         // check whether new center is somewhat away or at least right over the current baseline to prevent intersecting triangles
         if ((radius > HULLEPSILON) || (helper.Norm() < HULLEPSILON)) {
                 cout << Verbose(2) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
                 return alpha;
         } else {
                 cout << Verbose(1) << "ERROR: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
                 return 2.*M_PI;
+        }
+  Vector helper;
+  double radius, alpha;
+  helper.CopyVector(&NewSphereCenter);
+  // test whether new center is on the parameter circle's plane
+  if (fabs(helper.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+    cerr << "ERROR: Something's very wrong here: NewSphereCenter is not on the band's plane as desired by " <<fabs(helper.ScalarProduct(&CirclePlaneNormal))  << "!" << endl;
+    helper.ProjectOntoPlane(&CirclePlaneNormal);
+  }
+  radius = helper.ScalarProduct(&helper);
+  // test whether the new center vector has length of CircleRadius
+  if (fabs(radius - CircleRadius) > HULLEPSILON)
+    cerr << Verbose(1) << "ERROR: The projected center of the new sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+  alpha = helper.Angle(&OldSphereCenter);
+  // make the angle unique by checking the halfplanes/search direction
+  if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // acos is not unique on [0, 2.*M_PI), hence extra check to decide between two half intervals
+    alpha = 2.*M_PI - alpha;
+  cout << Verbose(2) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << OldSphereCenter << " and resulting angle is " << alpha << "." << endl;
+  radius = helper.Distance(&OldSphereCenter);
+  helper.ProjectOntoPlane(&NormalVector);
+  // check whether new center is somewhat away or at least right over the current baseline to prevent intersecting triangles
+  if ((radius > HULLEPSILON) || (helper.Norm() < HULLEPSILON)) {
+    cout << Verbose(2) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
+    return alpha;
+  } else {
+    cout << Verbose(1) << "ERROR: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
+    return 2.*M_PI;
+  }
 };
 …
 // void Find_next_suitable_point(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
 // {
 //       atom *Walker = NULL;
 //       Vector CircleCenter;   // center of the circle, i.e. of the band of sphere's centers
 //       Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
 //       Vector OldSphereCenter;         // center of the sphere defined by the three points of BaseTriangle
 //       Vector NewSphereCenter;         // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
 //       Vector OtherNewSphereCenter;    // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
 //       Vector NewNormalVector;         // normal vector of the Candidate's triangle
 //       Vector SearchDirection;         // vector that points out of BaseTriangle and is orthonormal to its NormalVector (i.e. the desired direction for the best Candidate)
 //       Vector helper;
 //       LinkedAtoms *List = NULL;
 //       double CircleRadius; // radius of this circle
 //       double radius;
 //       double alpha, Otheralpha; // angles (i.e. parameter for the circle).
 //       double Nullalpha; // angle between OldSphereCenter and NormalVector of base triangle
 //       int N[NDIM], Nlower[NDIM], Nupper[NDIM];
 //       atom *Candidate = NULL;
+//   atom *Walker = NULL;
+//   Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
+//   Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+//   Vector OldSphereCenter;   // center of the sphere defined by the three points of BaseTriangle
+//   Vector NewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
+//   Vector OtherNewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
+//   Vector NewNormalVector;   // normal vector of the Candidate's triangle
+//   Vector SearchDirection;   // vector that points out of BaseTriangle and is orthonormal to its NormalVector (i.e. the desired direction for the best Candidate)
+//   Vector helper;
+//   LinkedAtoms *List = NULL;
+//   double CircleRadius; // radius of this circle
+//   double radius;
+//   double alpha, Otheralpha; // angles (i.e. parameter for the circle).
+//   double Nullalpha; // angle between OldSphereCenter and NormalVector of base triangle
+//   int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+//   atom *Candidate = NULL;
 //
 //       cout << Verbose(1) << "Begin of Find_next_suitable_point" << endl;
+//   cout << Verbose(1) << "Begin of Find_next_suitable_point" << endl;
 //
 //       cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << BaseTriangle->NormalVector << "." << endl;
+//   cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << BaseTriangle->NormalVector << "." << endl;
 //
 //       // construct center of circle
 //       CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
 //       CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
 //       CircleCenter.Scale(0.5);
+//   // construct center of circle
+//   CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
+//   CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
+//   CircleCenter.Scale(0.5);
 //
 //       // construct normal vector of circle
 //       CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
 //       CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
+//   // construct normal vector of circle
+//   CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
+//   CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
 //
 //       // calculate squared radius of circle
 //       radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
 //       if (radius/4. < RADIUS*RADIUS) {
 //               CircleRadius = RADIUS*RADIUS - radius/4.;
 //               CirclePlaneNormal.Normalize();
 //               cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+//   // calculate squared radius of circle
+//   radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+//   if (radius/4. < RADIUS*RADIUS) {
+//     CircleRadius = RADIUS*RADIUS - radius/4.;
+//     CirclePlaneNormal.Normalize();
+//     cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
 //
 //               // construct old center
 //               GetCenterofCircumcircle(&OldSphereCenter, &(BaseTriangle->endpoints[0]->node->x), &(BaseTriangle->endpoints[1]->node->x), &(BaseTriangle->endpoints[2]->node->x));
 //               helper.CopyVector(&BaseTriangle->NormalVector);        // normal vector ensures that this is correct center of the two possible ones
 //               radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
 //               helper.Scale(sqrt(RADIUS*RADIUS - radius));
 //               OldSphereCenter.AddVector(&helper);
 //               OldSphereCenter.SubtractVector(&CircleCenter);
 //               cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+//     // construct old center
+//     GetCenterofCircumcircle(&OldSphereCenter, &(BaseTriangle->endpoints[0]->node->x), &(BaseTriangle->endpoints[1]->node->x), &(BaseTriangle->endpoints[2]->node->x));
+//     helper.CopyVector(&BaseTriangle->NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+//     radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
+//     helper.Scale(sqrt(RADIUS*RADIUS - radius));
+//     OldSphereCenter.AddVector(&helper);
+//     OldSphereCenter.SubtractVector(&CircleCenter);
+//     cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
 //
 //               // test whether old center is on the band's plane
 //               if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
 //                       cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
 //                       OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
 //               }
 //               radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
 //               if (fabs(radius - CircleRadius) < HULLEPSILON) {
+//     // test whether old center is on the band's plane
+//     if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+//       cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
+//       OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+//     }
+//     radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
+//     if (fabs(radius - CircleRadius) < HULLEPSILON) {
 //
 //                       // construct SearchDirection
 //                       SearchDirection.MakeNormalVector(&BaseTriangle->NormalVector, &CirclePlaneNormal);
 //                       helper.CopyVector(&BaseLine->endpoints[0]->node->x);
 //                       for(int i=0;i<3;i++)   // just take next different endpoint
 //                               if ((BaseTriangle->endpoints[i]->node != BaseLine->endpoints[0]->node) && (BaseTriangle->endpoints[i]->node != BaseLine->endpoints[1]->node)) {
 //                                       helper.SubtractVector(&BaseTriangle->endpoints[i]->node->x);
 //                               }
 //                       if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)     // ohoh, SearchDirection points inwards!
 //                               SearchDirection.Scale(-1.);
 //                       SearchDirection.ProjectOntoPlane(&OldSphereCenter);
 //                       SearchDirection.Normalize();
 //                       cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
 //                       if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {     // rotated the wrong way!
 //                               cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
 //                       }
+//       // construct SearchDirection
+//       SearchDirection.MakeNormalVector(&BaseTriangle->NormalVector, &CirclePlaneNormal);
+//       helper.CopyVector(&BaseLine->endpoints[0]->node->x);
+//       for(int i=0;i<3;i++)  // just take next different endpoint
+//         if ((BaseTriangle->endpoints[i]->node != BaseLine->endpoints[0]->node) && (BaseTriangle->endpoints[i]->node != BaseLine->endpoints[1]->node)) {
+//           helper.SubtractVector(&BaseTriangle->endpoints[i]->node->x);
+//         }
+//       if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // ohoh, SearchDirection points inwards!
+//         SearchDirection.Scale(-1.);
+//       SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+//       SearchDirection.Normalize();
+//       cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+//       if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
+//         cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+//       }
 //
 //                       if (LC->SetIndexToVector(&CircleCenter)) {     // get cell for the starting atom
 //                               for(int i=0;i<NDIM;i++) // store indices of this cell
 //                                       N[i] = LC->n[i];
 //                               cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
 //                       } else {
 //                               cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
 //                               return;
 //                       }
 //                       // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
 //                       cout << Verbose(2) << "LC Intervals:";
 //                       for (int i=0;i<NDIM;i++) {
 //                               Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
 //                               Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
 //                               cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
 //                       }
 //                       cout << endl;
 //                       for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
 //                               for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
 //                                       for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
 //                                               List = LC->GetCurrentCell();
 //                                               cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
 //                                               if (List != NULL) {
 //                                                       for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
 //                                                               Candidate = (*Runner);
+//       if (LC->SetIndexToVector(&CircleCenter)) {  // get cell for the starting atom
+//         for(int i=0;i<NDIM;i++) // store indices of this cell
+//           N[i] = LC->n[i];
+//         cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+//       } else {
+//         cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
+//         return;
+//       }
+//       // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+//       cout << Verbose(2) << "LC Intervals:";
+//       for (int i=0;i<NDIM;i++) {
+//         Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+//         Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+//         cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+//       }
+//       cout << endl;
+//       for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+//         for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+//           for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+//             List = LC->GetCurrentCell();
+//             cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+//             if (List != NULL) {
+//               for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+//                 Candidate = (*Runner);
 //
 //                                                               // check for three unique points
 //                                                               if ((Candidate != BaseTriangle->endpoints[0]->node) && (Candidate != BaseTriangle->endpoints[1]->node) && (Candidate != BaseTriangle->endpoints[2]->node)) {
 //                                                                       cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+//                 // check for three unique points
+//                 if ((Candidate != BaseTriangle->endpoints[0]->node) && (Candidate != BaseTriangle->endpoints[1]->node) && (Candidate != BaseTriangle->endpoints[2]->node)) {
+//                   cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
 //
 //                                                                       // construct both new centers
 //                                                                       GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
 //                                                                       OtherNewSphereCenter.CopyVector(&NewSphereCenter);
+//                   // construct both new centers
+//                   GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
+//                   OtherNewSphereCenter.CopyVector(&NewSphereCenter);
 //
 //                                                                       if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
 //                                                                               helper.CopyVector(&NewNormalVector);
 //                                                                               cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
 //                                                                               radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
 //                                                                               if (radius < RADIUS*RADIUS) {
 //                                                                                       helper.Scale(sqrt(RADIUS*RADIUS - radius));
 //                                                                                       cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
 //                                                                                       NewSphereCenter.AddVector(&helper);
 //                                                                                       NewSphereCenter.SubtractVector(&CircleCenter);
 //                                                                                       cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+//                   if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
+//                     helper.CopyVector(&NewNormalVector);
+//                     cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+//                     radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
+//                     if (radius < RADIUS*RADIUS) {
+//                       helper.Scale(sqrt(RADIUS*RADIUS - radius));
+//                       cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
+//                       NewSphereCenter.AddVector(&helper);
+//                       NewSphereCenter.SubtractVector(&CircleCenter);
+//                       cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
 //
 //                                                                                       helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
 //                                                                                       OtherNewSphereCenter.AddVector(&helper);
 //                                                                                       OtherNewSphereCenter.SubtractVector(&CircleCenter);
 //                                                                                       cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+//                       helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
+//                       OtherNewSphereCenter.AddVector(&helper);
+//                       OtherNewSphereCenter.SubtractVector(&CircleCenter);
+//                       cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
 //
 //                                                                                       // check both possible centers
 //                                                                                       alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
 //                                                                                       Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
 //                                                                                       alpha = min(alpha, Otheralpha);
 //                                                                                       if (*ShortestAngle > alpha) {
 //                                                                                                       OptCandidate = Candidate;
 //                                                                                                       *ShortestAngle = alpha;
 //                                                                                                       if (alpha != Otheralpha)
 //                                                                                                               OptCandidateCenter->CopyVector(&NewSphereCenter);
 //                                                                                                       else
 //                                                                                                               OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
 //                                                                                                       cout << Verbose(1) << "We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
 //                                                                                       } else {
 //                                                                                               if (OptCandidate != NULL)
 //                                                                                                       cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
 //                                                                                               else
 //                                                                                                       cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
 //                                                                                       }
+//                       // check both possible centers
+//                       alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
+//                       Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, BaseTriangle->NormalVector, SearchDirection);
+//                       alpha = min(alpha, Otheralpha);
+//                       if (*ShortestAngle > alpha) {
+//                           OptCandidate = Candidate;
+//                           *ShortestAngle = alpha;
+//                           if (alpha != Otheralpha)
+//                             OptCandidateCenter->CopyVector(&NewSphereCenter);
+//                           else
+//                             OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
+//                           cout << Verbose(1) << "We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
+//                       } else {
+//                         if (OptCandidate != NULL)
+//                           cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
+//                         else
+//                           cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+//                       }
 //
 //                                                                               } else {
 //                                                                                       cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
 //                                                                               }
 //                                                                       } else {
 //                                                                               cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
 //                                                                       }
 //                                                               } else {
 //                                                                       cout << Verbose(1) << "REJECT: Base triangle " << *BaseTriangle << " contains Candidate " << *Candidate << "." << endl;
 //                                                               }
 //                                                       }
 //                                               }
 //                                       }
 //               } else {
 //                       cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
 //               }
 //       } else {
 //               cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and base triangle " << *BaseTriangle << " is too big!" << endl;
 //       }
+//                     } else {
+//                       cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
+//                     }
+//                   } else {
+//                     cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+//                   }
+//                 } else {
+//                   cout << Verbose(1) << "REJECT: Base triangle " << *BaseTriangle << " contains Candidate " << *Candidate << "." << endl;
+//                 }
+//               }
+//             }
+//           }
+//     } else {
+//       cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+//     }
+//   } else {
+//     cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and base triangle " << *BaseTriangle << " is too big!" << endl;
+//   }
 //
 //       cout << Verbose(1) << "End of Find_next_suitable_point" << endl;
+//   cout << Verbose(1) << "End of Find_next_suitable_point" << endl;
 // };
-/** Checks whether the triangle consisting of the three atoms is already present.
- * Searches for the points in Tesselation::PointsOnBoundary and checks their
- * lines. If any of the three edges already has two triangles attached, false is
- * returned.
- * \param *out output stream for debugging
- * \param *Candidates endpoints of the triangle candidate
- * \return false - triangle invalid due to edge criteria, true - triangle may be added.
- */
-bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]) {
-        LineMap::iterator FindLine;
-        PointMap::iterator FindPoint;
-        bool Present[3];
-        *out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
-        for (int i=0;i<3;i++) { // check through all endpoints
-                FindPoint = PointsOnBoundary.find(Candidates[i]->nr);
-                if (FindPoint != PointsOnBoundary.end())
-                        TPS[i] = FindPoint->second;
-                else
-                        TPS[i] = NULL;
+        }
-        // check lines
-        for (int i=0;i<3;i++)
-                if (TPS[i] != NULL)
-                        for (int j=i;j<3;j++)
-                                if (TPS[j] != NULL) {
-                                        FindLine = TPS[i]->lines.find(TPS[j]->node->nr);
-                                        if ((FindLine != TPS[i]->lines.end()) && (FindLine->second->TrianglesCount > 1)) {
-                                                *out << "WARNING: Line " << *FindLine->second << " already present with " << FindLine->second->TrianglesCount << " triangles attached." << endl;
-                                                *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-                                                return false;
+                                        }
+                                }
-        *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-        return true;
-};
 /** This recursive function finds a third point, to form a triangle with two given ones.
 …
 void Find_third_point_for_Tesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, atom *ThirdNode, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
+{
+        atom *Walker = NULL;
+        Vector CircleCenter;    // center of the circle, i.e. of the band of sphere's centers
+        Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+        Vector NewSphereCenter;  // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
+        Vector OtherNewSphereCenter;     // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
+        Vector NewNormalVector;  // normal vector of the Candidate's triangle
+        Vector helper;
+        LinkedAtoms *List = NULL;
+        double CircleRadius; // radius of this circle
+        double radius;
+        double alpha, Otheralpha; // angles (i.e. parameter for the circle).
+        double Nullalpha; // angle between OldSphereCenter and NormalVector of base triangle
+        int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+        atom *Candidate = NULL;
+        cout << Verbose(1) << "Begin of Find_third_point_for_Tesselation" << endl;
+        cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
+        // construct center of circle
+        CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
+        CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
+        CircleCenter.Scale(0.5);
+        // construct normal vector of circle
+        CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
+        CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
+        // calculate squared radius of circle
+        radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+        if (radius/4. < RADIUS*RADIUS) {
+                CircleRadius = RADIUS*RADIUS - radius/4.;
+                CirclePlaneNormal.Normalize();
+                cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+                // test whether old center is on the band's plane
+                if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+                        cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
+                        OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+                }
+                radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
+                if (fabs(radius - CircleRadius) < HULLEPSILON) {
+                        // check SearchDirection
+                        cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+                        if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {      // rotated the wrong way!
+                                cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are not orthogonal!" << endl;
+                        }
+                        // get cell for the starting atom
+                        if (LC->SetIndexToVector(&CircleCenter)) {
+                                        for(int i=0;i<NDIM;i++) // store indices of this cell
+                                        N[i] = LC->n[i];
+                                cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+                        } else {
+                                cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
+                                return;
+                        }
+                        // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+                        cout << Verbose(2) << "LC Intervals:";
+                        for (int i=0;i<NDIM;i++) {
+                                Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+                                Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+                                cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+                        }
+                        cout << endl;
+                        for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+                                for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+                                        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+                                                List = LC->GetCurrentCell();
+                                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                                if (List != NULL) {
+                                                        for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+                                                                Candidate = (*Runner);
+                                                                // check for three unique points
+                                                                if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) && (Candidate != ThirdNode)) {
+                                                                        cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+                                                                        // construct both new centers
+                                                                        GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
+                                                                        OtherNewSphereCenter.CopyVector(&NewSphereCenter);
+                                                                        if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
+                                                                                helper.CopyVector(&NewNormalVector);
+                                                                                cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                                                                                radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
+                                                                                if (radius < RADIUS*RADIUS) {
+                                                                                        helper.Scale(sqrt(RADIUS*RADIUS - radius));
+                                                                                        cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
+                                                                                        NewSphereCenter.AddVector(&helper);
+                                                                                        NewSphereCenter.SubtractVector(&CircleCenter);
+                                                                                        cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+                                                                                        helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
+                                                                                        OtherNewSphereCenter.AddVector(&helper);
+                                                                                        OtherNewSphereCenter.SubtractVector(&CircleCenter);
+                                                                                        cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+                                                                                        // check both possible centers
+                                                                                        alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                                                                                        Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                                                                                        alpha = min(alpha, Otheralpha);
+                                                                                        if (*ShortestAngle > alpha) {
+                                                                                                        OptCandidate = Candidate;
+                                                                                                        *ShortestAngle = alpha;
+                                                                                                        if (alpha != Otheralpha)
+                                                                                                                OptCandidateCenter->CopyVector(&NewSphereCenter);
+                                                                                                        else
+                                                                                                                OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
+                                                                                                        cout << Verbose(1) << "ACCEPT: We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
+                                                                                        } else {
+                                                                                                if (OptCandidate != NULL)
+                                                                                                        cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
+                                                                                                else
+                                                                                                        cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                                                                                        }
+                                                                                } else {
+                                                                                        cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
+                                                                                }
+                                                                        } else {
+                                                                                cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                                                                        }
+                                                                } else {
+                                                                        if (ThirdNode != NULL)
+                                                                                cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
+                                                                        else
+                                                                                cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                                                                }
+                                                        }
+                                                }
+                                        }
+                } else {
+                        cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+                }
+        } else {
+                if (ThirdNode != NULL)
+                        cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
+                else
+                        cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
+        }
+        cout << Verbose(1) << "End of Find_third_point_for_Tesselation" << endl;
+  Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
+  Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+  Vector NewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
+  Vector OtherNewSphereCenter;   // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
+  Vector NewNormalVector;   // normal vector of the Candidate's triangle
+  Vector helper;
+  LinkedAtoms *List = NULL;
+  double CircleRadius; // radius of this circle
+  double radius;
+  double alpha, Otheralpha; // angles (i.e. parameter for the circle).
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+  atom *Candidate = NULL;
+  cout << Verbose(1) << "Begin of Find_third_point_for_Tesselation" << endl;
+  cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
+  // construct center of circle
+  CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
+  CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
+  CircleCenter.Scale(0.5);
+  // construct normal vector of circle
+  CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
+  CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
+  // calculate squared radius of circle
+  radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+  if (radius/4. < RADIUS*RADIUS) {
+    CircleRadius = RADIUS*RADIUS - radius/4.;
+    CirclePlaneNormal.Normalize();
+    cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    // test whether old center is on the band's plane
+    if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+      cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
+      OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+    }
+    radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
+    if (fabs(radius - CircleRadius) < HULLEPSILON) {
+      // check SearchDirection
+      cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+      if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
+        cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are not orthogonal!" << endl;
+      }
+      // get cell for the starting atom
+      if (LC->SetIndexToVector(&CircleCenter)) {
+          for(int i=0;i<NDIM;i++) // store indices of this cell
+          N[i] = LC->n[i];
+        cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+      } else {
+        cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
+        return;
+      }
+      // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+      cout << Verbose(2) << "LC Intervals:";
+      for (int i=0;i<NDIM;i++) {
+        Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+        Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+        cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+      }
+      cout << endl;
+      for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+        for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+          for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+            List = LC->GetCurrentCell();
+            //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+            if (List != NULL) {
+              for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+                Candidate = (*Runner);
+                // check for three unique points
+                if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) && (Candidate != ThirdNode)) {
+                  cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+                  // construct both new centers
+                  GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
+                  OtherNewSphereCenter.CopyVector(&NewSphereCenter);
+                  if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
+                    helper.CopyVector(&NewNormalVector);
+                    cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                    radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
+                    if (radius < RADIUS*RADIUS) {
+                      helper.Scale(sqrt(RADIUS*RADIUS - radius));
+                      cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
+                      NewSphereCenter.AddVector(&helper);
+                      NewSphereCenter.SubtractVector(&CircleCenter);
+                      cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+                      helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
+                      OtherNewSphereCenter.AddVector(&helper);
+                      OtherNewSphereCenter.SubtractVector(&CircleCenter);
+                      cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+                      // check both possible centers
+                      alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                      Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                      alpha = min(alpha, Otheralpha);
+                      if (*ShortestAngle > alpha) {
+                          OptCandidate = Candidate;
+                          *ShortestAngle = alpha;
+                          if (alpha != Otheralpha)
+                            OptCandidateCenter->CopyVector(&NewSphereCenter);
+                          else
+                            OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
+                          cout << Verbose(1) << "ACCEPT: We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
+                      } else {
+                        if (OptCandidate != NULL)
+                          cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
+                        else
+                          cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                      }
+                    } else {
+                      cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
+                    }
+                  } else {
+                    cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                  }
+                } else {
+                  if (ThirdNode != NULL)
+                    cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
+                  else
+                    cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                }
+              }
+            }
+          }
+    } else {
+      cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+    }
+  } else {
+    if (ThirdNode != NULL)
+      cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
+    else
+      cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
+  }
+  cout << Verbose(1) << "End of Find_third_point_for_Tesselation" << endl;
 };
+/** Checks whether the triangle consisting of the three atoms is already present.
+ * Searches for the points in Tesselation::PointsOnBoundary and checks their
+ * lines. If any of the three edges already has two triangles attached, false is
+ * returned.
+ * \param *out output stream for debugging
+ * \param *a first endpoint
+ * \param *b second endpoint
+ * \param *c third endpoint
+ * \return false - triangle invalid due to edge criteria, true - triangle may be added.
+ */
+bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c) {
+  LineMap::iterator TryAndError;
+  PointTestPair InsertPoint;
+  bool Present[3];
+  *out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
+  TPS[0] = new class BoundaryPointSet(a);
+  TPS[1] = new class BoundaryPointSet(b);
+  TPS[2] = new class BoundaryPointSet(c);
+  for (int i=0;i<3;i++) { // check through all endpoints
+    InsertPoint = PointsOnBoundary.insert(PointPair(TPS[i]->node->nr, TPS[i]));
+    Present[i] = !InsertPoint.second;
+    if (Present[i]) { // if new point was not present before, increase counter
+      delete TPS[i];
+      *out << Verbose(2) << "Atom " << *((InsertPoint.first)->second->node) << " gibt's schon in der PointMap." << endl;
+      TPS[i] = (InsertPoint.first)->second;
+    }
+  }
+  // check lines
+  for (int i=0;i<3;i++)
+    if (Present[i])
+      for (int j=i;j<3;j++)
+        if (Present[j]) {
+          TryAndError = TPS[i]->lines.find(TPS[j]->node->nr);
+          if ((TryAndError != TPS[i]->lines.end()) && (TryAndError->second->TrianglesCount > 1)) {
+            *out << "WARNING: Line " << *TryAndError->second << " already present with " << TryAndError->second->TrianglesCount << " triangles attached." << endl;
+            *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
+            return false;
+          }
+        }
+  *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
+  return true;
+};
 /** Finds the second point of starting triangle.
 …
 void Find_second_point_for_Tesselation(atom* a, atom* Candidate, Vector Oben, atom*& Opt_Candidate, double Storage[3], double RADIUS, LinkedCell *LC)
+{
+        cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation" << endl;
+        int i;
+        Vector AngleCheck;
+        atom* Walker;
+        double norm = -1., angle;
+        LinkedAtoms *List = NULL;
+        int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+        if (LC->SetIndexToAtom(a)) {    // get cell for the starting atom
+                for(int i=0;i<NDIM;i++) // store indices of this cell
+                        N[i] = LC->n[i];
+        } else {
+                cerr << "ERROR: Atom " << *a << " is not found in cell " << LC->index << "." << endl;
+                return;
+        }
+        // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+        cout << Verbose(2) << "LC Intervals:";
+        for (int i=0;i<NDIM;i++) {
+                Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+                Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+                cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+        }
+        cout << endl;
+        for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+                for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+                        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+                                List = LC->GetCurrentCell();
+                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                if (List != NULL) {
+                                        for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+                                                Candidate = (*Runner);
+                                                                // check if we only have one unique point yet ...
+                                                                if (a != Candidate) {
+                        cout << Verbose(3) << "Current candidate is " << *Candidate << ": ";
+                        AngleCheck.CopyVector(&(Candidate->x));
+                        AngleCheck.SubtractVector(&(a->x));
+                        norm = AngleCheck.Norm();
+                                                        // second point shall have smallest angle with respect to Oben vector
+                                                        if (norm < RADIUS) {
+                                                                angle = AngleCheck.Angle(&Oben);
+                                                                if (angle < Storage[0]) {
+                                                                        //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
+                                                                        cout << "Is a better candidate with distance " << norm << " and " << angle << ".\n";
+                                                                        Opt_Candidate = Candidate;
+                                                                        Storage[0] = AngleCheck.Angle(&Oben);
+                                                                        //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                                                                } else {
+                                                                        cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+                                                                }
+                                                        } else {
+                                                                cout << "Refused due to Radius " << norm << endl;
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+        cout << Verbose(2) << "End of Find_second_point_for_Tesselation" << endl;
+  cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation" << endl;
+  Vector AngleCheck;
+  double norm = -1., angle;
+  LinkedAtoms *List = NULL;
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+  if (LC->SetIndexToAtom(a)) {  // get cell for the starting atom
+    for(int i=0;i<NDIM;i++) // store indices of this cell
+      N[i] = LC->n[i];
+  } else {
+    cerr << "ERROR: Atom " << *a << " is not found in cell " << LC->index << "." << endl;
+    return;
+  }
+  // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+  cout << Verbose(2) << "LC Intervals:";
+  for (int i=0;i<NDIM;i++) {
+    Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+    Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+    cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+  }
+  cout << endl;
+  for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+    for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+      for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+        List = LC->GetCurrentCell();
+        //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+        if (List != NULL) {
+          for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+            Candidate = (*Runner);
+                // check if we only have one unique point yet ...
+                if (a != Candidate) {
+      cout << Verbose(3) << "Current candidate is " << *Candidate << ": ";
+      AngleCheck.CopyVector(&(Candidate->x));
+      AngleCheck.SubtractVector(&(a->x));
+      norm = AngleCheck.Norm();
+              // second point shall have smallest angle with respect to Oben vector
+              if (norm < RADIUS) {
+                angle = AngleCheck.Angle(&Oben);
+                if (angle < Storage[0]) {
+                  //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
+                  cout << "Is a better candidate with distance " << norm << " and " << angle << ".\n";
+                  Opt_Candidate = Candidate;
+                  Storage[0] = AngleCheck.Angle(&Oben);
+                  //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                } else {
+                  cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+                }
+              } else {
+                cout << "Refused due to Radius " << norm << endl;
+              }
+            }
+          }
+        }
+      }
+  cout << Verbose(2) << "End of Find_second_point_for_Tesselation" << endl;
 };
 …
 void Tesselation::Find_starting_triangle(ofstream *out, molecule *mol, const double RADIUS, LinkedCell *LC)
+{
+        cout << Verbose(1) << "Begin of Find_starting_triangle\n";
+        int i = 0;
+        LinkedAtoms *List = NULL;
+        atom* Walker;
+        atom* FirstPoint;
+        atom* SecondPoint;
+        atom* MaxAtom[NDIM];
+        double max_coordinate[NDIM];
+        Vector Oben;
+        Vector helper;
+        Vector Chord;
+        Vector SearchDirection;
+        Vector OptCandidateCenter;
+        Oben.Zero();
+        for (i = 0; i < 3; i++) {
+                MaxAtom[i] = NULL;
+                max_coordinate[i] = -1;
+        }
+        // 1. searching topmost atom with respect to each axis
+        for (int i=0;i<NDIM;i++) { // each axis
+                LC->n[i] = LC->N[i]-1; // current axis is topmost cell
+                for (LC->n[(i+1)%NDIM]=0;LC->n[(i+1)%NDIM]<LC->N[(i+1)%NDIM];LC->n[(i+1)%NDIM]++)
+                        for (LC->n[(i+2)%NDIM]=0;LC->n[(i+2)%NDIM]<LC->N[(i+2)%NDIM];LC->n[(i+2)%NDIM]++) {
+                                List = LC->GetCurrentCell();
+                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                if (List != NULL) {
+                                        for (LinkedAtoms::iterator Runner = List->begin();Runner != List->end();Runner++) {
+                                                cout << Verbose(2) << "Current atom is " << *(*Runner) << "." << endl;
+                                                if ((*Runner)->x.x[i] > max_coordinate[i]) {
+                                                        max_coordinate[i] = (*Runner)->x.x[i];
+                                                        MaxAtom[i] = (*Runner);
+                                                }
+                                        }
+                                } else {
+                                        cerr << "ERROR: The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl;
+                                }
+                        }
+        }
+        cout << Verbose(2) << "Found maximum coordinates: ";
+        for (int i=0;i<NDIM;i++)
+                cout << i << ": " << *MaxAtom[i] << "\t";
+        cout << endl;
+        const int k = 1;                // arbitrary choice
+        Oben.x[k] = 1.;
+        FirstPoint = MaxAtom[k];
+        cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << "." << endl;
+        // add first point
+        AddTrianglePoint(FirstPoint, 0);
+        double ShortestAngle;
+        atom* Opt_Candidate = NULL;
+        ShortestAngle = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
+        Find_second_point_for_Tesselation(FirstPoint, NULL, Oben, Opt_Candidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+        SecondPoint = Opt_Candidate;
+        cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
+        // add second point and first baseline
+        AddTrianglePoint(SecondPoint, 1);
+        AddTriangleLine(TPS[0], TPS[1], 0);
+        helper.CopyVector(&(FirstPoint->x));
+        helper.SubtractVector(&(SecondPoint->x));
+        helper.Normalize();
+        Oben.ProjectOntoPlane(&helper);
+        Oben.Normalize();
+        helper.VectorProduct(&Oben);
+        ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+        Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
+        Chord.SubtractVector(&(SecondPoint->x));
+        double radius = Chord.ScalarProduct(&Chord);
+        double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+        helper.CopyVector(&Oben);
+        helper.Scale(CircleRadius);
+        // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
+        cout << Verbose(2) << "Looking for third point candidates \n";
+        // look in one direction of baseline for initial candidate
+        Opt_Candidate = NULL;
+        SearchDirection.MakeNormalVector(&Chord, &Oben);        // whether we look "left" first or "right" first is not important ...
+        cout << Verbose(1) << "Looking for third point candidates ...\n";
+        Find_third_point_for_Tesselation(Oben, SearchDirection, helper, BLS[0], NULL, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+        cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
+        // add third point
+        AddTrianglePoint(Opt_Candidate, 2);
+        // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
+        // Finally, we only have to add the found further lines
+        AddTriangleLine(TPS[1], TPS[2], 1);
+        AddTriangleLine(TPS[0], TPS[2], 2);
+        // ... and triangles to the Maps of the Tesselation class
+        BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+        AddTriangleToLines();
+        // ... and calculate its normal vector (with correct orientation)
+        OptCandidateCenter.Scale(-1.);
+        cout << Verbose(2) << "Oben is currently " << OptCandidateCenter << "." << endl;
+        BTS->GetNormalVector(OptCandidateCenter);
+        cout << Verbose(0) << "==> The found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate << " with normal vector " << BTS->NormalVector << ".\n";
+        cout << Verbose(2) << "Projection is " << BTS->NormalVector.Projection(&Oben) << "." << endl;
+        cout << Verbose(1) << "End of Find_starting_triangle\n";
+  cout << Verbose(1) << "Begin of Find_starting_triangle\n";
+  int i = 0;
+  LinkedAtoms *List = NULL;
+  atom* FirstPoint;
+  atom* SecondPoint;
+  atom* MaxAtom[NDIM];
+  double max_coordinate[NDIM];
+  Vector Oben;
+  Vector helper;
+  Vector Chord;
+  Vector SearchDirection;
+  Vector OptCandidateCenter;
+  Oben.Zero();
+  for (i = 0; i < 3; i++) {
+    MaxAtom[i] = NULL;
+    max_coordinate[i] = -1;
+  }
+  // 1. searching topmost atom with respect to each axis
+  for (int i=0;i<NDIM;i++) { // each axis
+    LC->n[i] = LC->N[i]-1; // current axis is topmost cell
+    for (LC->n[(i+1)%NDIM]=0;LC->n[(i+1)%NDIM]<LC->N[(i+1)%NDIM];LC->n[(i+1)%NDIM]++)
+      for (LC->n[(i+2)%NDIM]=0;LC->n[(i+2)%NDIM]<LC->N[(i+2)%NDIM];LC->n[(i+2)%NDIM]++) {
+        List = LC->GetCurrentCell();
+        //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+        if (List != NULL) {
+          for (LinkedAtoms::iterator Runner = List->begin();Runner != List->end();Runner++) {
+            cout << Verbose(2) << "Current atom is " << *(*Runner) << "." << endl;
+            if ((*Runner)->x.x[i] > max_coordinate[i]) {
+              max_coordinate[i] = (*Runner)->x.x[i];
+              MaxAtom[i] = (*Runner);
+            }
+          }
+        } else {
+          cerr << "ERROR: The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl;
+        }
+      }
+  }
+  cout << Verbose(2) << "Found maximum coordinates: ";
+  for (int i=0;i<NDIM;i++)
+    cout << i << ": " << *MaxAtom[i] << "\t";
+  cout << endl;
+  const int k = 1;    // arbitrary choice
+  Oben.x[k] = 1.;
+  FirstPoint = MaxAtom[k];
+  cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << "." << endl;
+  // add first point
+  AddTrianglePoint(FirstPoint, 0);
+  double ShortestAngle;
+  atom* Opt_Candidate = NULL;
+  ShortestAngle = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
+  Find_second_point_for_Tesselation(FirstPoint, NULL, Oben, Opt_Candidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+  SecondPoint = Opt_Candidate;
+  cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
+  // add second point and first baseline
+  AddTrianglePoint(SecondPoint, 1);
+  AddTriangleLine(TPS[0], TPS[1], 0);
+  helper.CopyVector(&(FirstPoint->x));
+  helper.SubtractVector(&(SecondPoint->x));
+  helper.Normalize();
+  Oben.ProjectOntoPlane(&helper);
+  Oben.Normalize();
+  helper.VectorProduct(&Oben);
+  ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+  Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
+  Chord.SubtractVector(&(SecondPoint->x));
+  double radius = Chord.ScalarProduct(&Chord);
+  double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+  helper.CopyVector(&Oben);
+  helper.Scale(CircleRadius);
+  // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
+  cout << Verbose(2) << "Looking for third point candidates \n";
+  // look in one direction of baseline for initial candidate
+  Opt_Candidate = NULL;
+  SearchDirection.MakeNormalVector(&Chord, &Oben);  // whether we look "left" first or "right" first is not important ...
+  cout << Verbose(1) << "Looking for third point candidates ...\n";
+  Find_third_point_for_Tesselation(Oben, SearchDirection, helper, BLS[0], NULL, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+  cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
+  // add third point
+  AddTrianglePoint(Opt_Candidate, 2);
+  // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
+  // Finally, we only have to add the found further lines
+  AddTriangleLine(TPS[1], TPS[2], 1);
+  AddTriangleLine(TPS[0], TPS[2], 2);
+  // ... and triangles to the Maps of the Tesselation class
+  BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+  AddTriangleToLines();
+  // ... and calculate its normal vector (with correct orientation)
+  OptCandidateCenter.Scale(-1.);
+  cout << Verbose(2) << "Oben is currently " << OptCandidateCenter << "." << endl;
+  BTS->GetNormalVector(OptCandidateCenter);
+  cout << Verbose(0) << "==> The found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate << " with normal vector " << BTS->NormalVector << ".\n";
+  cout << Verbose(2) << "Projection is " << BTS->NormalVector.Projection(&Oben) << "." << endl;
+  cout << Verbose(1) << "End of Find_starting_triangle\n";
 };
 …
  */
 bool Tesselation::Find_next_suitable_triangle(ofstream *out,
+                molecule *mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
+                const double& RADIUS, int N, const char *tempbasename, LinkedCell *LC)
+{
+        cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
+        ofstream *tempstream = NULL;
+        char NumberName[255];
+        double tmp;
+        atom* Opt_Candidate = NULL;
+        Vector OptCandidateCenter;
+        Vector CircleCenter;
+        Vector CirclePlaneNormal;
+        Vector OldSphereCenter;
+        Vector SearchDirection;
+        Vector helper;
+        atom *ThirdNode = NULL;
+        double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+        double radius, CircleRadius;
+        cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
+        for (int i=0;i<3;i++)
+                if ((T.endpoints[i]->node != Line.endpoints[0]->node) && (T.endpoints[i]->node != Line.endpoints[1]->node))
+                        ThirdNode = T.endpoints[i]->node;
+        // construct center of circle
+        CircleCenter.CopyVector(&Line.endpoints[0]->node->x);
+        CircleCenter.AddVector(&Line.endpoints[1]->node->x);
+        CircleCenter.Scale(0.5);
+        // construct normal vector of circle
+        CirclePlaneNormal.CopyVector(&Line.endpoints[0]->node->x);
+        CirclePlaneNormal.SubtractVector(&Line.endpoints[1]->node->x);
+        // calculate squared radius of circle
+        radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+        if (radius/4. < RADIUS*RADIUS) {
+                CircleRadius = RADIUS*RADIUS - radius/4.;
+                CirclePlaneNormal.Normalize();
+                cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+                // construct old center
+                GetCenterofCircumcircle(&OldSphereCenter, &(T.endpoints[0]->node->x), &(T.endpoints[1]->node->x), &(T.endpoints[2]->node->x));
+                helper.CopyVector(&T.NormalVector);     // normal vector ensures that this is correct center of the two possible ones
+                radius = Line.endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
+                helper.Scale(sqrt(RADIUS*RADIUS - radius));
+                OldSphereCenter.AddVector(&helper);
+                OldSphereCenter.SubtractVector(&CircleCenter);
+                cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+                // construct SearchDirection
+                SearchDirection.MakeNormalVector(&T.NormalVector, &CirclePlaneNormal);
+                helper.CopyVector(&Line.endpoints[0]->node->x);
+                helper.SubtractVector(&ThirdNode->x);
+                if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)      // ohoh, SearchDirection points inwards!
+                        SearchDirection.Scale(-1.);
+                SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+                SearchDirection.Normalize();
+                cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+                if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {      // rotated the wrong way!
+                        cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+                }
+                // add third point
+                cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
+                Find_third_point_for_Tesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+        } else {
+                cout << Verbose(1) << "Circumcircle for base line " << Line << " and base triangle " << T << " is too big!" << endl;
+        }
+        if (Opt_Candidate == NULL) {
+                cerr << "WARNING: Could not find a suitable candidate." << endl;
+                return false;
+        }
+        cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << " with circumsphere's center at " << OptCandidateCenter << "." << endl;
+        // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+        atom *AtomCandidates[3];
+        AtomCandidates[0] = Opt_Candidate;
+        AtomCandidates[1] = Line.endpoints[0]->node;
+        AtomCandidates[2] = Line.endpoints[1]->node;
+        bool flag = CheckPresenceOfTriangle(out, AtomCandidates);
+        if (flag) { // if so, add
+                AddTrianglePoint(Opt_Candidate, 0);
+                AddTrianglePoint(Line.endpoints[0]->node, 1);
+                AddTrianglePoint(Line.endpoints[1]->node, 2);
+                AddTriangleLine(TPS[0], TPS[1], 0);
+                AddTriangleLine(TPS[0], TPS[2], 1);
+                AddTriangleLine(TPS[1], TPS[2], 2);
+                BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+                AddTriangleToLines();
+                OptCandidateCenter.Scale(-1.);
+                BTS->GetNormalVector(OptCandidateCenter);
+                OptCandidateCenter.Scale(-1.);
+                cout << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
+                cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << Line << "." << endl;
+        } else { // else, yell and do nothing
+                cout << Verbose(1) << "This triangle consisting of ";
+                cout << *Opt_Candidate << ", ";
+                cout << *Line.endpoints[0]->node << " and ";
+                cout << *Line.endpoints[1]->node << " ";
+                cout << "is invalid!" << endl;
+                return false;
+        }
+        if (flag && (DoSingleStepOutput && (TrianglesOnBoundaryCount % 10 == 0))) { // if we have a new triangle and want to output each new triangle configuration
+                sprintf(NumberName, "-%04d-%s_%s_%s", TriangleFilesWritten, BTS->endpoints[0]->node->Name, BTS->endpoints[1]->node->Name, BTS->endpoints[2]->node->Name);
+                if (DoTecplotOutput) {
+                        string NameofTempFile(tempbasename);
+                        NameofTempFile.append(NumberName);
+                        for(size_t npos = NameofTempFile.find_first_of(' '); npos != -1; npos = NameofTempFile.find(' ', npos))
+                                NameofTempFile.erase(npos, 1);
+                        NameofTempFile.append(TecplotSuffix);
+                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+                        write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
+                        tempstream->close();
+                        tempstream->flush();
+                        delete(tempstream);
+                }
+                if (DoRaster3DOutput) {
+                        string NameofTempFile(tempbasename);
+                        NameofTempFile.append(NumberName);
+                        for(size_t npos = NameofTempFile.find_first_of(' '); npos != -1; npos = NameofTempFile.find(' ', npos))
+                                NameofTempFile.erase(npos, 1);
+                        NameofTempFile.append(Raster3DSuffix);
+                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+                        write_raster3d_file(out, tempstream, this, mol);
+                        // include the current position of the virtual sphere in the temporary raster3d file
+                        // make the circumsphere's center absolute again
+                        helper.CopyVector(&Line.endpoints[0]->node->x);
+                        helper.AddVector(&Line.endpoints[1]->node->x);
+                        helper.Scale(0.5);
+                        OptCandidateCenter.AddVector(&helper);
+                        Vector *center = mol->DetermineCenterOfAll(out);
+                        OptCandidateCenter.AddVector(center);
+                        delete(center);
+                        // and add to file plus translucency object
+                        *tempstream << "# current virtual sphere\n";
+                        *tempstream << "8\n     25.0            0.6              -1.0 -1.0 -1.0          0.2                            0 0 0 0\n";
+                        *tempstream << "2\n     " << OptCandidateCenter.x[0] << " " << OptCandidateCenter.x[1] << " " << OptCandidateCenter.x[2] << "\t" << RADIUS << "\t1 0 0\n";
+                        *tempstream << "9\n     terminating special property\n";
+                        tempstream->close();
+                        tempstream->flush();
+                        delete(tempstream);
+                }
+                if (DoTecplotOutput || DoRaster3DOutput)
+                        TriangleFilesWritten++;
+        }
+        cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
+        return true;
+    molecule *mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
+    const double& RADIUS, int N, const char *tempbasename, LinkedCell *LC)
+{
+  cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
+  ofstream *tempstream = NULL;
+  char NumberName[255];
+  atom* Opt_Candidate = NULL;
+  Vector OptCandidateCenter;
+  Vector CircleCenter;
+  Vector CirclePlaneNormal;
+  Vector OldSphereCenter;
+  Vector SearchDirection;
+  Vector helper;
+  atom *ThirdNode = NULL;
+  double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+  double radius, CircleRadius;
+  cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
+  for (int i=0;i<3;i++)
+    if ((T.endpoints[i]->node != Line.endpoints[0]->node) && (T.endpoints[i]->node != Line.endpoints[1]->node))
+      ThirdNode = T.endpoints[i]->node;
+  // construct center of circle
+  CircleCenter.CopyVector(&Line.endpoints[0]->node->x);
+  CircleCenter.AddVector(&Line.endpoints[1]->node->x);
+  CircleCenter.Scale(0.5);
+  // construct normal vector of circle
+  CirclePlaneNormal.CopyVector(&Line.endpoints[0]->node->x);
+  CirclePlaneNormal.SubtractVector(&Line.endpoints[1]->node->x);
+  // calculate squared radius of circle
+  radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+  if (radius/4. < RADIUS*RADIUS) {
+    CircleRadius = RADIUS*RADIUS - radius/4.;
+    CirclePlaneNormal.Normalize();
+    cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    // construct old center
+    GetCenterofCircumcircle(&OldSphereCenter, &(T.endpoints[0]->node->x), &(T.endpoints[1]->node->x), &(T.endpoints[2]->node->x));
+    helper.CopyVector(&T.NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+    radius = Line.endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
+    helper.Scale(sqrt(RADIUS*RADIUS - radius));
+    OldSphereCenter.AddVector(&helper);
+    OldSphereCenter.SubtractVector(&CircleCenter);
+    cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+    // construct SearchDirection
+    SearchDirection.MakeNormalVector(&T.NormalVector, &CirclePlaneNormal);
+    helper.CopyVector(&Line.endpoints[0]->node->x);
+    helper.SubtractVector(&ThirdNode->x);
+    if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // ohoh, SearchDirection points inwards!
+      SearchDirection.Scale(-1.);
+    SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+    SearchDirection.Normalize();
+    cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+    if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
+      cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+    }
+    // add third point
+    cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
+    Find_third_point_for_Tesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+  } else {
+    cout << Verbose(1) << "Circumcircle for base line " << Line << " and base triangle " << T << " is too big!" << endl;
+  }
+  if (Opt_Candidate == NULL) {
+    cerr << "WARNING: Could not find a suitable candidate." << endl;
+    return false;
+  }
+  cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << " with circumsphere's center at " << OptCandidateCenter << "." << endl;
+  // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+  bool flag = CheckPresenceOfTriangle(out, Opt_Candidate, Line.endpoints[0]->node, Line.endpoints[1]->node);
+  if (flag) { // if so, add
+    AddTrianglePoint(Opt_Candidate, 0);
+    AddTrianglePoint(Line.endpoints[0]->node, 1);
+    AddTrianglePoint(Line.endpoints[1]->node, 2);
+    AddTriangleLine(TPS[0], TPS[1], 0);
+    AddTriangleLine(TPS[0], TPS[2], 1);
+    AddTriangleLine(TPS[1], TPS[2], 2);
+    BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+    AddTriangleToLines();
+    OptCandidateCenter.Scale(-1.);
+    BTS->GetNormalVector(OptCandidateCenter);
+    OptCandidateCenter.Scale(-1.);
+    cout << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
+    cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << Line << "." << endl;
+  } else { // else, yell and do nothing
+    cout << Verbose(1) << "This triangle consisting of ";
+    cout << *Opt_Candidate << ", ";
+    cout << *Line.endpoints[0]->node << " and ";
+    cout << *Line.endpoints[1]->node << " ";
+    cout << "is invalid!" << endl;
+    return false;
+  }
+  if (flag && (DoSingleStepOutput && (TrianglesOnBoundaryCount % 10 == 0))) { // if we have a new triangle and want to output each new triangle configuration
+    sprintf(NumberName, "-%04d-%s_%s_%s", TriangleFilesWritten, BTS->endpoints[0]->node->Name, BTS->endpoints[1]->node->Name, BTS->endpoints[2]->node->Name);
+    if (DoTecplotOutput) {
+      string NameofTempFile(tempbasename);
+      NameofTempFile.append(NumberName);
+      for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
+        NameofTempFile.erase(npos, 1);
+      NameofTempFile.append(TecplotSuffix);
+      cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+      tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+      write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
+      tempstream->close();
+      tempstream->flush();
+      delete(tempstream);
+    }
+    if (DoRaster3DOutput) {
+      string NameofTempFile(tempbasename);
+      NameofTempFile.append(NumberName);
+      for(size_t npos = NameofTempFile.find_first_of(' '); npos != string::npos; npos = NameofTempFile.find(' ', npos))
+        NameofTempFile.erase(npos, 1);
+      NameofTempFile.append(Raster3DSuffix);
+      cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+      tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+      write_raster3d_file(out, tempstream, this, mol);
+      // include the current position of the virtual sphere in the temporary raster3d file
+      // make the circumsphere's center absolute again
+      helper.CopyVector(&Line.endpoints[0]->node->x);
+      helper.AddVector(&Line.endpoints[1]->node->x);
+      helper.Scale(0.5);
+      OptCandidateCenter.AddVector(&helper);
+      Vector *center = mol->DetermineCenterOfAll(out);
+      OptCandidateCenter.AddVector(center);
+      delete(center);
+      // and add to file plus translucency object
+      *tempstream << "# current virtual sphere\n";
+      *tempstream << "8\n  25.0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0\n";
+      *tempstream << "2\n  " << OptCandidateCenter.x[0] << " " << OptCandidateCenter.x[1] << " " << OptCandidateCenter.x[2] << "\t" << RADIUS << "\t1 0 0\n";
+      *tempstream << "9\n  terminating special property\n";
+      tempstream->close();
+      tempstream->flush();
+      delete(tempstream);
+    }
+    if (DoTecplotOutput || DoRaster3DOutput)
+      TriangleFilesWritten++;
+  }
+  cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
+  return true;
 };
 …
 void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *Tess, class LinkedCell *LCList, const char *filename, const double RADIUS)
+{
         int N = 0;
         bool freeTess = false;
         *out << Verbose(1) << "Entering search for non convex hull. " << endl;
         if (Tess == NULL) {
                 *out << Verbose(1) << "Allocating Tesselation struct ..." << endl;
                 Tess = new Tesselation;
                 freeTess = true;
+        }
         bool freeLC = false;
         LineMap::iterator baseline;
         *out << Verbose(0) << "Begin of Find_non_convex_border\n";
         bool flag = false;      // marks whether we went once through all baselines without finding any without two triangles
         bool failflag = false;
         if (LCList == NULL) {
                 LCList = new LinkedCell(mol, 2.*RADIUS);
                 freeLC = true;
+        }
         Tess->Find_starting_triangle(out, mol, RADIUS, LCList);
         baseline = Tess->LinesOnBoundary.begin();
         while ((baseline != Tess->LinesOnBoundary.end()) || (flag)) {
                 if (baseline->second->TrianglesCount == 1) {
                         failflag = Tess->Find_next_suitable_triangle(out, mol, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename, LCList); //the line is there, so there is a triangle, but only one.
                         flag = flag || failflag;
                         if (!failflag)
                                 cerr << "WARNING: Find_next_suitable_triangle failed." << endl;
                 } else {
                         cout << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->TrianglesCount << " triangles adjacent" << endl;
+                }
                 N++;
                 baseline++;
                 if ((baseline == Tess->LinesOnBoundary.end()) && (flag)) {
                         baseline = Tess->LinesOnBoundary.begin();        // restart if we reach end due to newly inserted lines
                         flag = false;
+                }
+        }
         if (1) { //failflag) {
                 *out << Verbose(1) << "Writing final tecplot file\n";
                 if (DoTecplotOutput) {
                         string OutputName(filename);
                         OutputName.append(TecplotSuffix);
                         ofstream *tecplot = new ofstream(OutputName.c_str());
                         write_tecplot_file(out, tecplot, Tess, mol, -1);
                         tecplot->close();
                         delete(tecplot);
+                }
                 if (DoRaster3DOutput) {
                         string OutputName(filename);
                         OutputName.append(Raster3DSuffix);
                         ofstream *raster = new ofstream(OutputName.c_str());
                         write_raster3d_file(out, raster, Tess, mol);
                         raster->close();
                         delete(raster);
+                }
         } else {
                 cerr << "ERROR: Could definately not find all necessary triangles!" << endl;
+        }
         if (freeTess)
                 delete(Tess);
         if (freeLC)
                 delete(LCList);
         *out << Verbose(0) << "End of Find_non_convex_border\n";
+  int N = 0;
+  bool freeTess = false;
+  *out << Verbose(1) << "Entering search for non convex hull. " << endl;
+  if (Tess == NULL) {
+    *out << Verbose(1) << "Allocating Tesselation struct ..." << endl;
+    Tess = new Tesselation;
+    freeTess = true;
+  }
+  bool freeLC = false;
+  LineMap::iterator baseline;
+  *out << Verbose(0) << "Begin of Find_non_convex_border\n";
+  bool flag = false;  // marks whether we went once through all baselines without finding any without two triangles
+  bool failflag = false;
+  if (LCList == NULL) {
+    LCList = new LinkedCell(mol, 2.*RADIUS);
+    freeLC = true;
+  }
+  Tess->Find_starting_triangle(out, mol, RADIUS, LCList);
+  baseline = Tess->LinesOnBoundary.begin();
+  while ((baseline != Tess->LinesOnBoundary.end()) || (flag)) {
+    if (baseline->second->TrianglesCount == 1) {
+      failflag = Tess->Find_next_suitable_triangle(out, mol, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename, LCList); //the line is there, so there is a triangle, but only one.
+      flag = flag || failflag;
+      if (!failflag)
+        cerr << "WARNING: Find_next_suitable_triangle failed." << endl;
+    } else {
+      cout << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->TrianglesCount << " triangles adjacent" << endl;
+    }
+    N++;
+    baseline++;
+    if ((baseline == Tess->LinesOnBoundary.end()) && (flag)) {
+      baseline = Tess->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
+      flag = false;
+    }
+  }
+  if (1) { //failflag) {
+    *out << Verbose(1) << "Writing final tecplot file\n";
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
+      write_tecplot_file(out, tecplot, Tess, mol, -1);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append(Raster3DSuffix);
+      ofstream *raster = new ofstream(OutputName.c_str());
+      write_raster3d_file(out, raster, Tess, mol);
+      raster->close();
+      delete(raster);
+    }
+  } else {
+    cerr << "ERROR: Could definately not find all necessary triangles!" << endl;
+  }
+  if (freeTess)
+    delete(Tess);
+  if (freeLC)
+    delete(LCList);
+  *out << Verbose(0) << "End of Find_non_convex_border\n";
 };

src/boundary.hpp

-              r375b458
+              r51c910
 template <typename T> void SetEndpointsOrdered(T endpoints[2], T endpoint1, T endpoint2)
+{
         if (endpoint1->Nr < endpoint2->Nr) {
                 endpoints[0] = endpoint1;
                 endpoints[1] = endpoint2;
         } else {
                 endpoints[0] = endpoint2;
                 endpoints[1] = endpoint1;
+        }
+  if (endpoint1->Nr < endpoint2->Nr) {
+    endpoints[0] = endpoint1;
+    endpoints[1] = endpoint2;
+  } else {
+    endpoints[0] = endpoint2;
+    endpoints[1] = endpoint1;
+  }
 };
 class BoundaryPointSet {
         public:
                 BoundaryPointSet();
                 BoundaryPointSet(atom *Walker);
                 ~BoundaryPointSet();
+  public:
+    BoundaryPointSet();
+    BoundaryPointSet(atom *Walker);
+    ~BoundaryPointSet();
                 void AddLine(class BoundaryLineSet *line);
+    void AddLine(class BoundaryLineSet *line);
                 LineMap lines;
                 int LinesCount;
                 atom *node;
                 int Nr;
+    LineMap lines;
+    int LinesCount;
+    atom *node;
+    int Nr;
 };
 class BoundaryLineSet {
         public:
                 BoundaryLineSet();
                 BoundaryLineSet(class BoundaryPointSet *Point[2], int number);
                 ~BoundaryLineSet();
+  public:
+    BoundaryLineSet();
+    BoundaryLineSet(class BoundaryPointSet *Point[2], int number);
+    ~BoundaryLineSet();
                 void AddTriangle(class BoundaryTriangleSet *triangle);
+    void AddTriangle(class BoundaryTriangleSet *triangle);
                 class BoundaryPointSet *endpoints[2];
                 TriangleMap triangles;
                 int TrianglesCount;
                 int Nr;
+    class BoundaryPointSet *endpoints[2];
+    TriangleMap triangles;
+    int TrianglesCount;
+    int Nr;
 };
 class BoundaryTriangleSet {
         public:
                 BoundaryTriangleSet();
                 BoundaryTriangleSet(class BoundaryLineSet *line[3], int number);
                 ~BoundaryTriangleSet();
+  public:
+    BoundaryTriangleSet();
+    BoundaryTriangleSet(class BoundaryLineSet *line[3], int number);
+    ~BoundaryTriangleSet();
                 void GetNormalVector(Vector &NormalVector);
+    void GetNormalVector(Vector &NormalVector);
                 class BoundaryPointSet *endpoints[3];
                 class BoundaryLineSet *lines[3];
                 Vector NormalVector;
                 int Nr;
+    class BoundaryPointSet *endpoints[3];
+    class BoundaryLineSet *lines[3];
+    Vector NormalVector;
+    int Nr;
 };
 class Tesselation {
         public:
+  public:
                 Tesselation();
                 ~Tesselation();
+    Tesselation();
+    ~Tesselation();
                 void TesselateOnBoundary(ofstream *out, config *configuration, molecule *mol);
                 void GuessStartingTriangle(ofstream *out);
                 void AddPoint(atom * Walker);
                 void AddTrianglePoint(atom* Candidate, int n);
                 void AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
                 void AddTriangleToLines();
                 void Find_starting_triangle(ofstream *out, molecule* mol, const double RADIUS, LinkedCell *LC);
                 bool Find_next_suitable_triangle(ofstream *out, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *filename, LinkedCell *LC);
                 bool CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]);
                 void Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent, int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol);
+    void TesselateOnBoundary(ofstream *out, config *configuration, molecule *mol);
+    void GuessStartingTriangle(ofstream *out);
+    void AddPoint(atom * Walker);
+    void AddTrianglePoint(atom* Candidate, int n);
+    void AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
+    void AddTriangleToLines();
+    void Find_starting_triangle(ofstream *out, molecule* mol, const double RADIUS, LinkedCell *LC);
+    bool Find_next_suitable_triangle(ofstream *out, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *filename, LinkedCell *LC);
+    bool CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c);
+    void Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent, int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol);
                 PointMap PointsOnBoundary;
                 LineMap LinesOnBoundary;
                 TriangleMap TrianglesOnBoundary;
                 class BoundaryPointSet *TPS[3]; //this is a Storage for pointers to triangle points, this and BPS[2] needed due to AddLine restrictions
                 class BoundaryPointSet *BPS[2];
                 class BoundaryLineSet *BLS[3];
                 class BoundaryTriangleSet *BTS;
                 int PointsOnBoundaryCount;
                 int LinesOnBoundaryCount;
                 int TrianglesOnBoundaryCount;
                 int TriangleFilesWritten;
+    PointMap PointsOnBoundary;
+    LineMap LinesOnBoundary;
+    TriangleMap TrianglesOnBoundary;
+    class BoundaryPointSet *TPS[3]; //this is a Storage for pointers to triangle points, this and BPS[2] needed due to AddLine restrictions
+    class BoundaryPointSet *BPS[2];
+    class BoundaryLineSet *BLS[3];
+    class BoundaryTriangleSet *BTS;
+    int PointsOnBoundaryCount;
+    int LinesOnBoundaryCount;
+    int TrianglesOnBoundaryCount;
+    int TriangleFilesWritten;
 };
 …
 void Find_next_suitable_point(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
 #endif /*BOUNDARY_HPP_*/

src/builder.cpp

-              r375b458
+              r51c910
     case 'a':
       cout << Verbose(0) << "Centering atoms in config file on origin." << endl;
       mol->CenterOrigin((ofstream *)&cout, &x);
+      mol->CenterOrigin((ofstream *)&cout);
       break;
     case 'b':
       cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
       mol->CenterGravity((ofstream *)&cout, &x);
+      mol->CenterPeriodic((ofstream *)&cout);
       break;
     case 'c':
 …
+      }
       mol->CenterEdge((ofstream *)&cout, &x);  // make every coordinate positive
       mol->Translate(&y); // translate by boundary
+      mol->Center.AddVector(&y); // translate by boundary
       helper.CopyVector(&y);
       helper.Scale(2.);
 …
 static void RemoveAtoms(molecule *mol)
+{
   atom *first, *second, *third;
+  atom *first, *second;
   int axis;
   double tmp1, tmp2;
 …
       break;
     case 'b':
       third = mol->AskAtom("Enter number of atom as reference point: ");
+      second = mol->AskAtom("Enter number of atom as reference point: ");
       cout << Verbose(0) << "Enter radius: ";
       cin >> tmp1;
 …
         first = second;
         second = first->next;
         if (first->x.DistanceSquared((const Vector *)&third->x) > tmp1*tmp1) // distance to first above radius ...
+        if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
           mol->RemoveAtom(first);
+      }
 …
 static void ManipulateAtoms(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first, *second, *third, *fourth;
+  Vector **atoms;
+  atom *first, *second;
   molecule *mol = NULL;
   Vector x,y,z,n; // coordinates for absolute point in cell volume
   double *factor; // unit factor if desired
-  double a,b,c;
   double bond, min_bond;
   char choice;  // menu choice char
 …
   cout << Verbose(0) << "all else - go back" << endl;
   cout << Verbose(0) << "===============================================" << endl;
   if (molecules->NumberOfActiveMolecules() > 0)
+  if (molecules->NumberOfActiveMolecules() > 1)
     cout << Verbose(0) << "WARNING: There is more than one molecule active! Atoms will be added to each." << endl;
   cout << Verbose(0) << "INPUT: ";
 …
     case 'a': // add atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'b': // scale a bond
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'c': // unit scaling of the metric
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'l': // measure distances or angles
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'r': // remove atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'u': // change an atom's element
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         int Z;
         mol = *ListRunner;
 …
 static void ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first, *second, *third, *fourth;
+  Vector **atoms;
+  atom *first;
   Vector x,y,z,n; // coordinates for absolute point in cell volume
-  double a,b,c;
   int j, axis, count, faktor;
   char choice;  // menu choice char
-  bool valid;
   molecule *mol = NULL;
   element **Elements;
 …
   cout << Verbose(0) << "all else - go back" << endl;
   cout << Verbose(0) << "===============================================" << endl;
   if (molecules->NumberOfActiveMolecules() > 0)
+  if (molecules->NumberOfActiveMolecules() > 1)
     cout << Verbose(0) << "WARNING: There is more than one molecule active! Atoms will be added to each." << endl;
   cout << Verbose(0) << "INPUT: ";
 …
     case 'd': // duplicate the periodic cell along a given axis, given times
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'g': // center the atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'i': // align all atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'm': // mirror atoms along a given axis
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
 …
     case 'o': // create the connection matrix
+      {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         double bonddistance;
         clock_t start,end;
 …
     case 't': // translate all atoms
+     for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
         mol = *ListRunner;
         cout << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
         cout << Verbose(0) << "Enter translation vector." << endl;
         x.AskPosition(mol->cell_size,0);
         mol->Translate((const Vector *)&x);
+        mol->Center.AddVector((const Vector *)&x);
+     }
      break;
 …
+{
   char choice;  // menu choice char
+  bool valid;
+  Vector Center;
+  Vector center;
   int nr, count;
   molecule *mol = NULL;
+  char *molname = NULL;
+  int length;
+  char filename[MAXSTRINGSIZE];
+  cout << Verbose(0) << "==========Edit MOLECULES=====================" << endl;
+  cout << Verbose(0) << "==========EDIT MOLECULES=====================" << endl;
   cout << Verbose(0) << "c - create new molecule" << endl;
   cout << Verbose(0) << "l - load molecule from xyz file" << endl;
   cout << Verbose(0) << "n - change molecule's name" << endl;
   cout << Verbose(0) << "N - give molecules filename" << endl;
   cout << Verbose(0) << "p - parse xyz file into molecule" << endl;
+  cout << Verbose(0) << "p - parse atoms in xyz file into molecule" << endl;
   cout << Verbose(0) << "r - remove a molecule" << endl;
   cout << Verbose(0) << "all else - go back" << endl;
 …
       break;
+    case 'l': // laod from XYZ file
+      cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+      mol = new molecule(periode);
+      do {
+        cout << Verbose(0) << "Enter file name: ";
+    case 'l': // load from XYZ file
+      {
+        char filename[MAXSTRINGSIZE];
+        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        mol = new molecule(periode);
+        do {
+          cout << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+        // center at set box dimensions
+        mol->CenterEdge((ofstream *)&cout, &center);
+        mol->cell_size[0] = center.x[0];
+        mol->cell_size[1] = 0;
+        mol->cell_size[2] = center.x[1];
+        mol->cell_size[3] = 0;
+        mol->cell_size[4] = 0;
+        mol->cell_size[5] = center.x[2];
+        molecules->insert(mol);
+      }
+      break;
+    case 'n':
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Enter name: ";
         cin >> filename;
+      } while (!mol->AddXYZFile(filename));
+      mol->SetNameFromFilename(filename);
+      // center at set box dimensions
+      mol->CenterEdge((ofstream *)&cout, &Center);
+      mol->cell_size[0] = Center.x[0];
+      mol->cell_size[1] = 0;
+      mol->cell_size[2] = Center.x[1];
+      mol->cell_size[3] = 0;
+      mol->cell_size[4] = 0;
+      mol->cell_size[5] = Center.x[2];
+      molecules->insert(mol);
+      break;
+    case 'n':
+      do {
+        cout << Verbose(0) << "Enter index of molecule: ";
+        cin >> nr;
+        mol = molecules->ReturnIndex(nr);
+      } while (mol != NULL);
+      cout << Verbose(0) << "Enter name: ";
+      cin >> filename;
+      strcpy(mol->name, filename);
+        strcpy(mol->name, filename);
+      }
       break;
     case 'N':
+      do {
+        cout << Verbose(0) << "Enter index of molecule: ";
+        cin >> nr;
+        mol = molecules->ReturnIndex(nr);
+      } while (mol != NULL);
+      cout << Verbose(0) << "Enter name: ";
+      cin >> filename;
+      mol->SetNameFromFilename(filename);
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Enter name: ";
+        cin >> filename;
+        mol->SetNameFromFilename(filename);
+      }
       break;
     case 'p': // parse XYZ file
+      mol = NULL;
+      do {
+        cout << Verbose(0) << "Enter index of molecule: ";
+        cin >> nr;
+        mol = molecules->ReturnIndex(nr);
+      } while (mol == NULL);
+      cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+      do {
+        cout << Verbose(0) << "Enter file name: ";
+        cin >> filename;
+      } while (!mol->AddXYZFile(filename));
+      mol->SetNameFromFilename(filename);
+      {
+        char filename[MAXSTRINGSIZE];
+        mol = NULL;
+        do {
+          cout << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        do {
+          cout << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+      }
       break;
 …
       cin >> nr;
       count = 1;
+      MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin();
+      for(; ((ListRunner != molecules->ListOfMolecules.end()) && (count < nr)); ListRunner++);
+      mol = *ListRunner;
+      if (count == nr) {
+        molecules->ListOfMolecules.erase(ListRunner);
+        delete(mol);
+      }
+      for( MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if (nr == (*ListRunner)->IndexNr) {
+          mol = *ListRunner;
+          molecules->ListOfMolecules.erase(ListRunner);
+          delete(mol);
+        }
       break;
+  }
 …
+{
   char choice;  // menu choice char
-  bool valid;
   cout << Verbose(0) << "===========MERGE MOLECULES=====================" << endl;
+  cout << Verbose(0) << "a - simple add of one molecule to another" << endl;
   cout << Verbose(0) << "e - embedding merge of two molecules" << endl;
   cout << Verbose(0) << "m - multi-merge of all molecules" << endl;
 …
       break;
+    case 'a':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            cout << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            cout << Verbose(0) << "Enter index of source molecule to add from: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleAdd(srcmol, destmol);
+        }
+      }
+      break;
     case 'e':
+      cout << Verbose(0) << "Not implemented yet." << endl;
       break;
     case 'm':
+      {
+        int nr;
+        molecule *mol = NULL;
+        do {
+          cout << Verbose(0) << "Enter index of molecule to merge into: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while ((mol == NULL) && (nr != -1));
+        if (nr != -1) {
+          int N = molecules->ListOfMolecules.size()-1;
+          int *src = new int(N);
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr != nr)
+              src[N++] = (*ListRunner)->IndexNr;
+          molecules->SimpleMultiMerge(mol, src, N);
+          delete[](src);
+        }
+      }
       break;
     case 's':
+      cout << Verbose(0) << "Not implemented yet." << endl;
       break;
     case 't':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            cout << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            cout << Verbose(0) << "Enter index of source molecule to merge into: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleMerge(srcmol, destmol);
+        }
+      }
       break;
+  }
 …
   molecule *mol = new molecule(periode);
   // merge all molecules in MoleculeListClass into this molecule
+  // translate each to its center and merge all molecules in MoleculeListClass into this molecule
   int N = molecules->ListOfMolecules.size();
   int *src = new int(N);
   N=0;
   for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
     src[N++] = (*ListRunner)->IndexNr;
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+  }
   molecules->SimpleMultiAdd(mol, src, N);
+  delete[](src);
+  // ... and translate back
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    (*ListRunner)->Center.Scale(-1.);
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+    (*ListRunner)->Center.Scale(-1.);
+  }
   cout << Verbose(0) << "Storing configuration ... " << endl;
 …
   mol->CalculateOrbitals(*configuration);
   configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  strcpy(filename, ConfigFileName);
   if (ConfigFileName != NULL) { // test the file name
+    output.open(ConfigFileName, ios::trunc);
+    strcpy(filename, ConfigFileName);
+    output.open(filename, ios::trunc);
   } else if (strlen(configuration->configname) != 0) {
     strcpy(filename, configuration->configname);
 …
  * \return exit code (0 - successful, all else - something's wrong)
  */
 static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode, config& configuration, char *&ConfigFileName, char *&PathToDatabases)
+static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode, config& configuration, char *ConfigFileName, char *&PathToDatabases)
+{
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
 …
   // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
   molecule *mol = new molecule(periode);
+  mol->ActiveFlag = true;
   molecules->insert(mol);
 …
             cout << "\t-p <file>\tParse given xyz file and create raw config file from it." << endl;
             cout << "\t-P <file>\tParse given forces file and append as an MD step to config file via Verlet." << endl;
+            cout << "\t-L <step0> <step1> <prefix>\tStore a linear interpolation between two configurations <step0> and <step1> into single config files with prefix <prefix> and as Trajectories into the current config file." << endl;
             cout << "\t-r\t\tConvert file from an old pcp syntax." << endl;
             cout << "\t-R\t\tRemove all atoms out of sphere around a given one." << endl;
 …
         } else {
           cout << "Empty configuration file." << endl;
           ConfigFileName = argv[1];
+          strcpy(ConfigFileName, argv[1]);
           config_present = empty;
           output.close();
 …
       } else {
         test.close();
         ConfigFileName = argv[1];
+        strcpy(ConfigFileName, argv[1]);
         cout << Verbose(1) << "Specified config file found, parsing ... ";
         switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
 …
                 LinkedCell LCList(mol, atof(argv[argptr]));    // \NOTE not twice the radius??
                 Find_non_convex_border((ofstream *)&cout, mol, &T, &LCList, argv[argptr+1], atof(argv[argptr]));
                 //FindDistributionOfEllipsoids((ofstream *)&cout, &T, &LCList, N, number, filename.c_str());
+                FindDistributionOfEllipsoids((ofstream *)&cout, &T, &LCList, N, number, filename.c_str());
                 argptr+=2;
+              }
 …
+              }
               break;
+            case 'L':
+              ExitFlag = 1;
+              SaveFlag = true;
+              cout << Verbose(1) << "Linear interpolation between configuration " << argv[argptr] << " and " << argv[argptr+1] << "." << endl;
+              if (!mol->LinearInterpolationBetweenConfiguration((ofstream *)&cout, atoi(argv[argptr]), atoi(argv[argptr+1]), argv[argptr+2], configuration))
+                cout << Verbose(2) << "Could not store " << argv[argptr+2] << " files." << endl;
+              else
+                cout << Verbose(2) << "Steps created and " << argv[argptr+2] << " files stored." << endl;
+              argptr+=3;
+              break;
             case 'P':
               ExitFlag = 1;
 …
                 SaveFlag = true;
                 cout << Verbose(1) << "Parsing forces file and Verlet integrating." << endl;
                 if (!mol->VerletForceIntegration(argv[argptr], configuration.Deltat, configuration.GetIsAngstroem()))
+                if (!mol->VerletForceIntegration((ofstream *)&cout, argv[argptr], configuration))
                   cout << Verbose(2) << "File not found." << endl;
                 else
 …
               ExitFlag = 1;
               SaveFlag = true;
               cout << Verbose(1) << "Centering atoms in origin." << endl;
               mol->CenterOrigin((ofstream *)&cout, &x);
+              cout << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl;
+              mol->CenterEdge((ofstream *)&cout, &x);
               mol->SetBoxDimension(&x);
               break;
 …
   molecule *mol = NULL;
   config configuration;
-  double tmp1;
-  atom *first, *second;
   char choice;  // menu choice char
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
-  bool valid; // flag if input was valid or not
   ifstream test;
   ofstream output;
   string line;
   char *ConfigFileName = NULL;
+  char ConfigFileName[MAXSTRINGSIZE];
   char *ElementsFileName = NULL;
+  int Z;
+  int j, axis, count, faktor;
+  int j;
   // =========================== PARSE COMMAND LINE OPTIONS ====================================
+  ConfigFileName[0] = '\0';
   j = ParseCommandLineOptions(argc, argv, molecules, periode, configuration, ConfigFileName, ElementsFileName);
   if (j == 1) return 0; // just for -v and -h options
 …
     molecules->insert(mol);
+  }
+  if (strlen(ConfigFileName) == 0)
+    strcpy(ConfigFileName, DEFAULTCONFIG);
   // =========================== START INTERACTIVE SESSION ====================================
 …
     cout << Verbose(0) << "============Menu===============================" << endl;
     cout << Verbose(0) << "a - set molecule (in)active" << endl;
     cout << Verbose(0) << "e - edit new molecules" << endl;
+    cout << Verbose(0) << "e - edit molecules (load, parse, save)" << endl;
     cout << Verbose(0) << "g - globally manipulate atoms in molecule" << endl;
     cout << Verbose(0) << "M - Merge molecules" << endl;
 …
           cout << "Enter index of molecule: ";
           cin >> j;
+          count = 1;
+          MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin();
+          for(; ((ListRunner != molecules->ListOfMolecules.end()) && (count < j)); ListRunner++);
+          if (count == j)
+            (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr == j)
+              (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
+        }
         break;

src/config.cpp

-              r375b458
+              r51c910
 config::config()
+{
+        mainname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+        defaultpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+        pseudopotpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+        configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+        configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+        strcpy(mainname,"pcp");
+        strcpy(defaultpath,"not specified");
+        strcpy(pseudopotpath,"not specified");
+        configpath[0]='\0';
+        configname[0]='\0';
+        basis = "3-21G";
+        FastParsing = false;
+        ProcPEGamma=8;
+        ProcPEPsi=1;
+        DoOutVis=0;
+        DoOutMes=1;
+        DoOutNICS=0;
+        DoOutOrbitals=0;
+        DoOutCurrent=0;
+        DoPerturbation=0;
+        DoFullCurrent=0;
+        DoWannier=0;
+        CommonWannier=0;
+        SawtoothStart=0.01;
+        VectorPlane=0;
+        VectorCut=0;
+        UseAddGramSch=1;
+        Seed=1;
+        MaxOuterStep=0;
+        Deltat=1;
+        OutVisStep=10;
+        OutSrcStep=5;
+        TargetTemp=0.00095004455;
+        ScaleTempStep=25;
+        MaxPsiStep=0;
+        EpsWannier=1e-7;
+        MaxMinStep=100;
+        RelEpsTotalEnergy=1e-7;
+        RelEpsKineticEnergy=1e-5;
+        MaxMinStopStep=1;
+        MaxMinGapStopStep=0;
+        MaxInitMinStep=100;
+        InitRelEpsTotalEnergy=1e-5;
+        InitRelEpsKineticEnergy=1e-4;
+        InitMaxMinStopStep=1;
+        InitMaxMinGapStopStep=0;
+        //BoxLength[NDIM*NDIM];
+        ECut=128.;
+        MaxLevel=5;
+        RiemannTensor=0;
+        LevRFactor=0;
+        RiemannLevel=0;
+        Lev0Factor=2;
+        RTActualUse=0;
+        PsiType=0;
+        MaxPsiDouble=0;
+        PsiMaxNoUp=0;
+        PsiMaxNoDown=0;
+        AddPsis=0;
+        RCut=20.;
+        StructOpt=0;
+        IsAngstroem=1;
+        RelativeCoord=0;
+        MaxTypes=0;
+  mainname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+  defaultpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+  pseudopotpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+  configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+  configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
+  ThermostatImplemented = (int *) Malloc((MaxThermostats)*(sizeof(int)), "IonsInitRead: *ThermostatImplemented");
+  ThermostatNames = (char **) Malloc((MaxThermostats)*(sizeof(char *)), "IonsInitRead: *ThermostatNames");
+  for (int j=0;j<MaxThermostats;j++)
+    ThermostatNames[j] = (char *) MallocString(12*(sizeof(char)), "IonsInitRead: ThermostatNames[]");
+  Thermostat = 4;
+  alpha = 0.;
+  ScaleTempStep = 25;
+  TempFrequency = 2.5;
+  strcpy(mainname,"pcp");
+  strcpy(defaultpath,"not specified");
+  strcpy(pseudopotpath,"not specified");
+  configpath[0]='\0';
+  configname[0]='\0';
+  basis="3-21G";
+  strcpy(ThermostatNames[0],"None");
+  ThermostatImplemented[0] = 1;
+  strcpy(ThermostatNames[1],"Woodcock");
+  ThermostatImplemented[1] = 1;
+  strcpy(ThermostatNames[2],"Gaussian");
+  ThermostatImplemented[2] = 1;
+  strcpy(ThermostatNames[3],"Langevin");
+  ThermostatImplemented[3] = 1;
+  strcpy(ThermostatNames[4],"Berendsen");
+  ThermostatImplemented[4] = 1;
+  strcpy(ThermostatNames[5],"NoseHoover");
+  ThermostatImplemented[5] = 1;
+  FastParsing = false;
+  ProcPEGamma=8;
+  ProcPEPsi=1;
+  DoOutVis=0;
+  DoOutMes=1;
+  DoOutNICS=0;
+  DoOutOrbitals=0;
+  DoOutCurrent=0;
+  DoPerturbation=0;
+  DoFullCurrent=0;
+  DoWannier=0;
+  DoConstrainedMD=0;
+  CommonWannier=0;
+  SawtoothStart=0.01;
+  VectorPlane=0;
+  VectorCut=0;
+  UseAddGramSch=1;
+  Seed=1;
+  MaxOuterStep=0;
+  Deltat=0.01;
+  OutVisStep=10;
+  OutSrcStep=5;
+  TargetTemp=0.00095004455;
+  ScaleTempStep=25;
+  MaxPsiStep=0;
+  EpsWannier=1e-7;
+  MaxMinStep=100;
+  RelEpsTotalEnergy=1e-7;
+  RelEpsKineticEnergy=1e-5;
+  MaxMinStopStep=1;
+  MaxMinGapStopStep=0;
+  MaxInitMinStep=100;
+  InitRelEpsTotalEnergy=1e-5;
+  InitRelEpsKineticEnergy=1e-4;
+  InitMaxMinStopStep=1;
+  InitMaxMinGapStopStep=0;
+  //BoxLength[NDIM*NDIM];
+  ECut=128.;
+  MaxLevel=5;
+  RiemannTensor=0;
+  LevRFactor=0;
+  RiemannLevel=0;
+  Lev0Factor=2;
+  RTActualUse=0;
+  PsiType=0;
+  MaxPsiDouble=0;
+  PsiMaxNoUp=0;
+  PsiMaxNoDown=0;
+  AddPsis=0;
+  RCut=20.;
+  StructOpt=0;
+  IsAngstroem=1;
+  RelativeCoord=0;
+  MaxTypes=0;
 };
 …
 config::~config()
+{
         Free((void **)&mainname, "config::~config: *mainname");
         Free((void **)&defaultpath, "config::~config: *defaultpath");
         Free((void **)&pseudopotpath, "config::~config: *pseudopotpath");
         Free((void **)&configpath, "config::~config: *configpath");
         Free((void **)&configname, "config::~config: *configname");
+  Free((void **)&mainname, "config::~config: *mainname");
+  Free((void **)&defaultpath, "config::~config: *defaultpath");
+  Free((void **)&pseudopotpath, "config::~config: *pseudopotpath");
+  Free((void **)&configpath, "config::~config: *configpath");
+  Free((void **)&configname, "config::~config: *configname");
 };
+/** Readin of Thermostat related values from parameter file.
+ * \param *source parameter file
+ */
+void config::InitThermostats(ifstream *source)
+{
+  char *thermo = MallocString(12, "IonsInitRead: thermo");
+  int verbose = 0;
+  // read desired Thermostat from file along with needed additional parameters
+  if (ParseForParameter(verbose,source,"Thermostat", 0, 1, 1, string_type, thermo, 1, optional)) {
+    if (strcmp(thermo, ThermostatNames[0]) == 0) { // None
+      if (ThermostatImplemented[0] == 1) {
+        Thermostat = None;
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else if (strcmp(thermo, ThermostatNames[1]) == 0) { // Woodcock
+      if (ThermostatImplemented[1] == 1) {
+        Thermostat = Woodcock;
+        ParseForParameter(verbose,source,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read scaling frequency
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else if (strcmp(thermo, ThermostatNames[2]) == 0) { // Gaussian
+      if (ThermostatImplemented[2] == 1) {
+        Thermostat = Gaussian;
+        ParseForParameter(verbose,source,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read collision rate
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else if (strcmp(thermo, ThermostatNames[3]) == 0) { // Langevin
+      if (ThermostatImplemented[3] == 1) {
+        Thermostat = Langevin;
+        ParseForParameter(verbose,source,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read gamma
+        if (ParseForParameter(verbose,source,"Thermostat", 0, 3, 1, double_type, &alpha, 1, optional)) {
+          cout << Verbose(2) << "Extended Stochastic Thermostat detected with interpolation coefficient " << alpha << "." << endl;
+        } else {
+          alpha = 1.;
+        }
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else if (strcmp(thermo, ThermostatNames[4]) == 0) { // Berendsen
+      if (ThermostatImplemented[4] == 1) {
+        Thermostat = Berendsen;
+        ParseForParameter(verbose,source,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read \tau_T
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else if (strcmp(thermo, ThermostatNames[5]) == 0) { // Nose-Hoover
+      if (ThermostatImplemented[5] == 1) {
+        Thermostat = NoseHoover;
+        ParseForParameter(verbose,source,"Thermostat", 0, 2, 1, double_type, &HooverMass, 1, critical); // read Hoovermass
+        alpha = 0.;
+      } else {
+        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
+        Thermostat = None;
+      }
+    } else {
+      cout << Verbose(1) << " Warning: thermostat name was not understood!" << endl;
+      Thermostat = None;
+    }
+  } else {
+    if ((MaxOuterStep > 0) && (TargetTemp != 0))
+      cout << Verbose(2) <<  "No thermostat chosen despite finite temperature MD, falling back to None." << endl;
+    Thermostat = None;
+  }
+  Free((void **)&thermo, "InitThermostats: thermo");
+};
 /** Displays menu for editing each entry of the config file.
 …
 void config::Edit()
+{
         char choice;
         do {
                 cout << Verbose(0) << "===========EDIT CONFIGURATION============================" << endl;
                 cout << Verbose(0) << " A - mainname (prefix for all runtime files)" << endl;
                 cout << Verbose(0) << " B - Default path (for runtime files)" << endl;
                 cout << Verbose(0) << " C - Path of pseudopotential files" << endl;
                 cout << Verbose(0) << " D - Number of coefficient sharing processes" << endl;
                 cout << Verbose(0) << " E - Number of wave function sharing processes" << endl;
                 cout << Verbose(0) << " F - 0: Don't output density for OpenDX, 1: do" << endl;
                 cout << Verbose(0) << " G - 0: Don't output physical data, 1: do" << endl;
                 cout << Verbose(0) << " H - 0: Don't output densities of each unperturbed orbital for OpenDX, 1: do" << endl;
                 cout << Verbose(0) << " I - 0: Don't output current density for OpenDX, 1: do" << endl;
                 cout << Verbose(0) << " J - 0: Don't do the full current calculation, 1: do" << endl;
                 cout << Verbose(0) << " K - 0: Don't do perturbation calculation to obtain susceptibility and shielding, 1: do" << endl;
                 cout << Verbose(0) << " L - 0: Wannier centres as calculated, 1: common centre for all, 2: unite centres according to spread, 3: cell centre, 4: shifted to nearest grid point" << endl;
                 cout << Verbose(0) << " M - Absolute begin of unphysical sawtooth transfer for position operator within cell" << endl;
                 cout << Verbose(0) << " N - (0,1,2) x,y,z-plane to do two-dimensional current vector cut" << endl;
                 cout << Verbose(0) << " O - Absolute position along vector cut axis for cut plane" << endl;
                 cout << Verbose(0) << " P - Additional Gram-Schmidt-Orthonormalization to stabilize numerics" << endl;
                 cout << Verbose(0) << " Q - Initial integer value of random number generator" << endl;
                 cout << Verbose(0) << " R - for perturbation 0, for structure optimization defines upper limit of iterations" << endl;
                 cout << Verbose(0) << " T - Output visual after ...th step" << endl;
                 cout << Verbose(0) << " U - Output source densities of wave functions after ...th step" << endl;
                 cout << Verbose(0) << " X - minimization iterations per wave function, if unsure leave at default value 0" << endl;
                 cout << Verbose(0) << " Y - tolerance value for total spread in iterative Jacobi diagonalization" << endl;
                 cout << Verbose(0) << " Z - Maximum number of minimization iterations" << endl;
                 cout << Verbose(0) << " a - Relative change in total energy to stop min. iteration" << endl;
                 cout << Verbose(0) << " b - Relative change in kinetic energy to stop min. iteration" << endl;
                 cout << Verbose(0) << " c - Check stop conditions every ..th step during min. iteration" << endl;
                 cout << Verbose(0) << " e - Maximum number of minimization iterations during initial level" << endl;
                 cout << Verbose(0) << " f - Relative change in total energy to stop min. iteration during initial level" << endl;
                 cout << Verbose(0) << " g - Relative change in kinetic energy to stop min. iteration during initial level" << endl;
                 cout << Verbose(0) << " h - Check stop conditions every ..th step during min. iteration during initial level" << endl;
 //              cout << Verbose(0) << " j - six lower diagonal entries of matrix, defining the unit cell" << endl;
                 cout << Verbose(0) << " k - Energy cutoff of plane wave basis in Hartree" << endl;
                 cout << Verbose(0) << " l - Maximum number of levels in multi-level-ansatz" << endl;
                 cout << Verbose(0) << " m - Factor by which grid nodes increase between standard and upper level" << endl;
                 cout << Verbose(0) << " n - 0: Don't use RiemannTensor, 1: Do" << endl;
                 cout << Verbose(0) << " o - Factor by which grid nodes increase between Riemann and standard(?) level" << endl;
                 cout << Verbose(0) << " p - Number of Riemann levels" << endl;
                 cout << Verbose(0) << " r - 0: Don't Use RiemannTensor, 1: Do" << endl;
                 cout << Verbose(0) << " s - 0: Doubly occupied orbitals, 1: Up-/Down-Orbitals" << endl;
                 cout << Verbose(0) << " t - Number of orbitals (depends pn SpinType)" << endl;
                 cout << Verbose(0) << " u - Number of SpinUp orbitals (depends on SpinType)" << endl;
                 cout << Verbose(0) << " v - Number of SpinDown orbitals (depends on SpinType)" << endl;
                 cout << Verbose(0) << " w - Number of additional, unoccupied orbitals" << endl;
                 cout << Verbose(0) << " x - radial cutoff for ewald summation in Bohrradii" << endl;
                 cout << Verbose(0) << " y - 0: Don't do structure optimization beforehand, 1: Do" << endl;
                 cout << Verbose(0) << " z - 0: Units are in Bohr radii, 1: units are in Aengstrom" << endl;
                 cout << Verbose(0) << " i - 0: Coordinates given in file are absolute, 1: ... are relative to unit cell" << endl;
                 cout << Verbose(0) << "=========================================================" << endl;
                 cout << Verbose(0) << "INPUT: ";
                 cin >> choice;
                 switch (choice) {
                                 case 'A': // mainname
                                         cout << Verbose(0) << "Old: " << config::mainname << "\t new: ";
                                         cin >> config::mainname;
                                         break;
                                 case 'B': // defaultpath
                                         cout << Verbose(0) << "Old: " << config::defaultpath << "\t new: ";
                                         cin >> config::defaultpath;
                                         break;
                                 case 'C': // pseudopotpath
                                         cout << Verbose(0) << "Old: " << config::pseudopotpath << "\t new: ";
                                         cin >> config::pseudopotpath;
                                         break;
                                 case 'D': // ProcPEGamma
                                         cout << Verbose(0) << "Old: " << config::ProcPEGamma << "\t new: ";
                                         cin >> config::ProcPEGamma;
                                         break;
                                 case 'E': // ProcPEPsi
                                         cout << Verbose(0) << "Old: " << config::ProcPEPsi << "\t new: ";
                                         cin >> config::ProcPEPsi;
                                         break;
                                 case 'F': // DoOutVis
                                         cout << Verbose(0) << "Old: " << config::DoOutVis << "\t new: ";
                                         cin >> config::DoOutVis;
                                         break;
                                 case 'G': // DoOutMes
                                         cout << Verbose(0) << "Old: " << config::DoOutMes << "\t new: ";
                                         cin >> config::DoOutMes;
                                         break;
                                 case 'H': // DoOutOrbitals
                                         cout << Verbose(0) << "Old: " << config::DoOutOrbitals << "\t new: ";
                                         cin >> config::DoOutOrbitals;
                                         break;
                                 case 'I': // DoOutCurrent
                                         cout << Verbose(0) << "Old: " << config::DoOutCurrent << "\t new: ";
                                         cin >> config::DoOutCurrent;
                                         break;
                                 case 'J': // DoFullCurrent
                                         cout << Verbose(0) << "Old: " << config::DoFullCurrent << "\t new: ";
                                         cin >> config::DoFullCurrent;
                                         break;
                                 case 'K': // DoPerturbation
                                         cout << Verbose(0) << "Old: " << config::DoPerturbation << "\t new: ";
                                         cin >> config::DoPerturbation;
                                         break;
                                 case 'L': // CommonWannier
                                         cout << Verbose(0) << "Old: " << config::CommonWannier << "\t new: ";
                                         cin >> config::CommonWannier;
                                         break;
                                 case 'M': // SawtoothStart
                                         cout << Verbose(0) << "Old: " << config::SawtoothStart << "\t new: ";
                                         cin >> config::SawtoothStart;
                                         break;
                                 case 'N': // VectorPlane
                                         cout << Verbose(0) << "Old: " << config::VectorPlane << "\t new: ";
                                         cin >> config::VectorPlane;
                                         break;
                                 case 'O': // VectorCut
                                         cout << Verbose(0) << "Old: " << config::VectorCut << "\t new: ";
                                         cin >> config::VectorCut;
                                         break;
                                 case 'P': // UseAddGramSch
                                         cout << Verbose(0) << "Old: " << config::UseAddGramSch << "\t new: ";
                                         cin >> config::UseAddGramSch;
                                         break;
                                 case 'Q': // Seed
                                         cout << Verbose(0) << "Old: " << config::Seed << "\t new: ";
                                         cin >> config::Seed;
                                         break;
                                 case 'R': // MaxOuterStep
                                         cout << Verbose(0) << "Old: " << config::MaxOuterStep << "\t new: ";
                                         cin >> config::MaxOuterStep;
                                         break;
                                 case 'T': // OutVisStep
                                         cout << Verbose(0) << "Old: " << config::OutVisStep << "\t new: ";
                                         cin >> config::OutVisStep;
                                         break;
                                 case 'U': // OutSrcStep
                                         cout << Verbose(0) << "Old: " << config::OutSrcStep << "\t new: ";
                                         cin >> config::OutSrcStep;
                                         break;
                                 case 'X': // MaxPsiStep
                                         cout << Verbose(0) << "Old: " << config::MaxPsiStep << "\t new: ";
                                         cin >> config::MaxPsiStep;
                                         break;
                                 case 'Y': // EpsWannier
                                         cout << Verbose(0) << "Old: " << config::EpsWannier << "\t new: ";
                                         cin >> config::EpsWannier;
                                         break;
                                 case 'Z': // MaxMinStep
                                         cout << Verbose(0) << "Old: " << config::MaxMinStep << "\t new: ";
                                         cin >> config::MaxMinStep;
                                         break;
                                 case 'a': // RelEpsTotalEnergy
                                         cout << Verbose(0) << "Old: " << config::RelEpsTotalEnergy << "\t new: ";
                                         cin >> config::RelEpsTotalEnergy;
                                         break;
                                 case 'b': // RelEpsKineticEnergy
                                         cout << Verbose(0) << "Old: " << config::RelEpsKineticEnergy << "\t new: ";
                                         cin >> config::RelEpsKineticEnergy;
                                         break;
                                 case 'c': // MaxMinStopStep
                                         cout << Verbose(0) << "Old: " << config::MaxMinStopStep << "\t new: ";
                                         cin >> config::MaxMinStopStep;
                                         break;
                                 case 'e': // MaxInitMinStep
                                         cout << Verbose(0) << "Old: " << config::MaxInitMinStep << "\t new: ";
                                         cin >> config::MaxInitMinStep;
                                         break;
                                 case 'f': // InitRelEpsTotalEnergy
                                         cout << Verbose(0) << "Old: " << config::InitRelEpsTotalEnergy << "\t new: ";
                                         cin >> config::InitRelEpsTotalEnergy;
                                         break;
                                 case 'g': // InitRelEpsKineticEnergy
                                         cout << Verbose(0) << "Old: " << config::InitRelEpsKineticEnergy << "\t new: ";
                                         cin >> config::InitRelEpsKineticEnergy;
                                         break;
                                 case 'h': // InitMaxMinStopStep
                                         cout << Verbose(0) << "Old: " << config::InitMaxMinStopStep << "\t new: ";
                                         cin >> config::InitMaxMinStopStep;
                                         break;
 //                              case 'j': // BoxLength
 //                                      cout << Verbose(0) << "enter lower triadiagonalo form of basis matrix" << endl << endl;
 //                                      for (int i=0;i<6;i++) {
 //                                              cout << Verbose(0) << "Cell size" << i << ": ";
 //                                              cin >> mol->cell_size[i];
 //                                      }
 //                                      break;
                                 case 'k': // ECut
                                         cout << Verbose(0) << "Old: " << config::ECut << "\t new: ";
                                         cin >> config::ECut;
                                         break;
                                 case 'l': // MaxLevel
                                         cout << Verbose(0) << "Old: " << config::MaxLevel << "\t new: ";
                                         cin >> config::MaxLevel;
                                         break;
                                 case 'm': // RiemannTensor
                                         cout << Verbose(0) << "Old: " << config::RiemannTensor << "\t new: ";
                                         cin >> config::RiemannTensor;
                                         break;
                                 case 'n': // LevRFactor
                                         cout << Verbose(0) << "Old: " << config::LevRFactor << "\t new: ";
                                         cin >> config::LevRFactor;
                                         break;
                                 case 'o': // RiemannLevel
                                         cout << Verbose(0) << "Old: " << config::RiemannLevel << "\t new: ";
                                         cin >> config::RiemannLevel;
                                         break;
                                 case 'p': // Lev0Factor
                                         cout << Verbose(0) << "Old: " << config::Lev0Factor << "\t new: ";
                                         cin >> config::Lev0Factor;
                                         break;
                                 case 'r': // RTActualUse
                                         cout << Verbose(0) << "Old: " << config::RTActualUse << "\t new: ";
                                         cin >> config::RTActualUse;
                                         break;
                                 case 's': // PsiType
                                         cout << Verbose(0) << "Old: " << config::PsiType << "\t new: ";
                                         cin >> config::PsiType;
                                         break;
                                 case 't': // MaxPsiDouble
                                         cout << Verbose(0) << "Old: " << config::MaxPsiDouble << "\t new: ";
                                         cin >> config::MaxPsiDouble;
                                         break;
                                 case 'u': // PsiMaxNoUp
                                         cout << Verbose(0) << "Old: " << config::PsiMaxNoUp << "\t new: ";
                                         cin >> config::PsiMaxNoUp;
                                         break;
                                 case 'v': // PsiMaxNoDown
                                         cout << Verbose(0) << "Old: " << config::PsiMaxNoDown << "\t new: ";
                                         cin >> config::PsiMaxNoDown;
                                         break;
                                 case 'w': // AddPsis
                                         cout << Verbose(0) << "Old: " << config::AddPsis << "\t new: ";
                                         cin >> config::AddPsis;
                                         break;
                                 case 'x': // RCut
                                         cout << Verbose(0) << "Old: " << config::RCut << "\t new: ";
                                         cin >> config::RCut;
                                         break;
                                 case 'y': // StructOpt
                                         cout << Verbose(0) << "Old: " << config::StructOpt << "\t new: ";
                                         cin >> config::StructOpt;
                                         break;
                                 case 'z': // IsAngstroem
                                         cout << Verbose(0) << "Old: " << config::IsAngstroem << "\t new: ";
                                         cin >> config::IsAngstroem;
                                         break;
                                 case 'i': // RelativeCoord
                                         cout << Verbose(0) << "Old: " << config::RelativeCoord << "\t new: ";
                                         cin >> config::RelativeCoord;
                                         break;
                 };
         } while (choice != 'q');
+  char choice;
+  do {
+    cout << Verbose(0) << "===========EDIT CONFIGURATION============================" << endl;
+    cout << Verbose(0) << " A - mainname (prefix for all runtime files)" << endl;
+    cout << Verbose(0) << " B - Default path (for runtime files)" << endl;
+    cout << Verbose(0) << " C - Path of pseudopotential files" << endl;
+    cout << Verbose(0) << " D - Number of coefficient sharing processes" << endl;
+    cout << Verbose(0) << " E - Number of wave function sharing processes" << endl;
+    cout << Verbose(0) << " F - 0: Don't output density for OpenDX, 1: do" << endl;
+    cout << Verbose(0) << " G - 0: Don't output physical data, 1: do" << endl;
+    cout << Verbose(0) << " H - 0: Don't output densities of each unperturbed orbital for OpenDX, 1: do" << endl;
+    cout << Verbose(0) << " I - 0: Don't output current density for OpenDX, 1: do" << endl;
+    cout << Verbose(0) << " J - 0: Don't do the full current calculation, 1: do" << endl;
+    cout << Verbose(0) << " K - 0: Don't do perturbation calculation to obtain susceptibility and shielding, 1: do" << endl;
+    cout << Verbose(0) << " L - 0: Wannier centres as calculated, 1: common centre for all, 2: unite centres according to spread, 3: cell centre, 4: shifted to nearest grid point" << endl;
+    cout << Verbose(0) << " M - Absolute begin of unphysical sawtooth transfer for position operator within cell" << endl;
+    cout << Verbose(0) << " N - (0,1,2) x,y,z-plane to do two-dimensional current vector cut" << endl;
+    cout << Verbose(0) << " O - Absolute position along vector cut axis for cut plane" << endl;
+    cout << Verbose(0) << " P - Additional Gram-Schmidt-Orthonormalization to stabilize numerics" << endl;
+    cout << Verbose(0) << " Q - Initial integer value of random number generator" << endl;
+    cout << Verbose(0) << " R - for perturbation 0, for structure optimization defines upper limit of iterations" << endl;
+    cout << Verbose(0) << " T - Output visual after ...th step" << endl;
+    cout << Verbose(0) << " U - Output source densities of wave functions after ...th step" << endl;
+    cout << Verbose(0) << " X - minimization iterations per wave function, if unsure leave at default value 0" << endl;
+    cout << Verbose(0) << " Y - tolerance value for total spread in iterative Jacobi diagonalization" << endl;
+    cout << Verbose(0) << " Z - Maximum number of minimization iterations" << endl;
+    cout << Verbose(0) << " a - Relative change in total energy to stop min. iteration" << endl;
+    cout << Verbose(0) << " b - Relative change in kinetic energy to stop min. iteration" << endl;
+    cout << Verbose(0) << " c - Check stop conditions every ..th step during min. iteration" << endl;
+    cout << Verbose(0) << " e - Maximum number of minimization iterations during initial level" << endl;
+    cout << Verbose(0) << " f - Relative change in total energy to stop min. iteration during initial level" << endl;
+    cout << Verbose(0) << " g - Relative change in kinetic energy to stop min. iteration during initial level" << endl;
+    cout << Verbose(0) << " h - Check stop conditions every ..th step during min. iteration during initial level" << endl;
+//    cout << Verbose(0) << " j - six lower diagonal entries of matrix, defining the unit cell" << endl;
+    cout << Verbose(0) << " k - Energy cutoff of plane wave basis in Hartree" << endl;
+    cout << Verbose(0) << " l - Maximum number of levels in multi-level-ansatz" << endl;
+    cout << Verbose(0) << " m - Factor by which grid nodes increase between standard and upper level" << endl;
+    cout << Verbose(0) << " n - 0: Don't use RiemannTensor, 1: Do" << endl;
+    cout << Verbose(0) << " o - Factor by which grid nodes increase between Riemann and standard(?) level" << endl;
+    cout << Verbose(0) << " p - Number of Riemann levels" << endl;
+    cout << Verbose(0) << " r - 0: Don't Use RiemannTensor, 1: Do" << endl;
+    cout << Verbose(0) << " s - 0: Doubly occupied orbitals, 1: Up-/Down-Orbitals" << endl;
+    cout << Verbose(0) << " t - Number of orbitals (depends pn SpinType)" << endl;
+    cout << Verbose(0) << " u - Number of SpinUp orbitals (depends on SpinType)" << endl;
+    cout << Verbose(0) << " v - Number of SpinDown orbitals (depends on SpinType)" << endl;
+    cout << Verbose(0) << " w - Number of additional, unoccupied orbitals" << endl;
+    cout << Verbose(0) << " x - radial cutoff for ewald summation in Bohrradii" << endl;
+    cout << Verbose(0) << " y - 0: Don't do structure optimization beforehand, 1: Do" << endl;
+    cout << Verbose(0) << " z - 0: Units are in Bohr radii, 1: units are in Aengstrom" << endl;
+    cout << Verbose(0) << " i - 0: Coordinates given in file are absolute, 1: ... are relative to unit cell" << endl;
+    cout << Verbose(0) << "=========================================================" << endl;
+    cout << Verbose(0) << "INPUT: ";
+    cin >> choice;
+    switch (choice) {
+        case 'A': // mainname
+          cout << Verbose(0) << "Old: " << config::mainname << "\t new: ";
+          cin >> config::mainname;
+          break;
+        case 'B': // defaultpath
+          cout << Verbose(0) << "Old: " << config::defaultpath << "\t new: ";
+          cin >> config::defaultpath;
+          break;
+        case 'C': // pseudopotpath
+          cout << Verbose(0) << "Old: " << config::pseudopotpath << "\t new: ";
+          cin >> config::pseudopotpath;
+          break;
+        case 'D': // ProcPEGamma
+          cout << Verbose(0) << "Old: " << config::ProcPEGamma << "\t new: ";
+          cin >> config::ProcPEGamma;
+          break;
+        case 'E': // ProcPEPsi
+          cout << Verbose(0) << "Old: " << config::ProcPEPsi << "\t new: ";
+          cin >> config::ProcPEPsi;
+          break;
+        case 'F': // DoOutVis
+          cout << Verbose(0) << "Old: " << config::DoOutVis << "\t new: ";
+          cin >> config::DoOutVis;
+          break;
+        case 'G': // DoOutMes
+          cout << Verbose(0) << "Old: " << config::DoOutMes << "\t new: ";
+          cin >> config::DoOutMes;
+          break;
+        case 'H': // DoOutOrbitals
+          cout << Verbose(0) << "Old: " << config::DoOutOrbitals << "\t new: ";
+          cin >> config::DoOutOrbitals;
+          break;
+        case 'I': // DoOutCurrent
+          cout << Verbose(0) << "Old: " << config::DoOutCurrent << "\t new: ";
+          cin >> config::DoOutCurrent;
+          break;
+        case 'J': // DoFullCurrent
+          cout << Verbose(0) << "Old: " << config::DoFullCurrent << "\t new: ";
+          cin >> config::DoFullCurrent;
+          break;
+        case 'K': // DoPerturbation
+          cout << Verbose(0) << "Old: " << config::DoPerturbation << "\t new: ";
+          cin >> config::DoPerturbation;
+          break;
+        case 'L': // CommonWannier
+          cout << Verbose(0) << "Old: " << config::CommonWannier << "\t new: ";
+          cin >> config::CommonWannier;
+          break;
+        case 'M': // SawtoothStart
+          cout << Verbose(0) << "Old: " << config::SawtoothStart << "\t new: ";
+          cin >> config::SawtoothStart;
+          break;
+        case 'N': // VectorPlane
+          cout << Verbose(0) << "Old: " << config::VectorPlane << "\t new: ";
+          cin >> config::VectorPlane;
+          break;
+        case 'O': // VectorCut
+          cout << Verbose(0) << "Old: " << config::VectorCut << "\t new: ";
+          cin >> config::VectorCut;
+          break;
+        case 'P': // UseAddGramSch
+          cout << Verbose(0) << "Old: " << config::UseAddGramSch << "\t new: ";
+          cin >> config::UseAddGramSch;
+          break;
+        case 'Q': // Seed
+          cout << Verbose(0) << "Old: " << config::Seed << "\t new: ";
+          cin >> config::Seed;
+          break;
+        case 'R': // MaxOuterStep
+          cout << Verbose(0) << "Old: " << config::MaxOuterStep << "\t new: ";
+          cin >> config::MaxOuterStep;
+          break;
+        case 'T': // OutVisStep
+          cout << Verbose(0) << "Old: " << config::OutVisStep << "\t new: ";
+          cin >> config::OutVisStep;
+          break;
+        case 'U': // OutSrcStep
+          cout << Verbose(0) << "Old: " << config::OutSrcStep << "\t new: ";
+          cin >> config::OutSrcStep;
+          break;
+        case 'X': // MaxPsiStep
+          cout << Verbose(0) << "Old: " << config::MaxPsiStep << "\t new: ";
+          cin >> config::MaxPsiStep;
+          break;
+        case 'Y': // EpsWannier
+          cout << Verbose(0) << "Old: " << config::EpsWannier << "\t new: ";
+          cin >> config::EpsWannier;
+          break;
+        case 'Z': // MaxMinStep
+          cout << Verbose(0) << "Old: " << config::MaxMinStep << "\t new: ";
+          cin >> config::MaxMinStep;
+          break;
+        case 'a': // RelEpsTotalEnergy
+          cout << Verbose(0) << "Old: " << config::RelEpsTotalEnergy << "\t new: ";
+          cin >> config::RelEpsTotalEnergy;
+          break;
+        case 'b': // RelEpsKineticEnergy
+          cout << Verbose(0) << "Old: " << config::RelEpsKineticEnergy << "\t new: ";
+          cin >> config::RelEpsKineticEnergy;
+          break;
+        case 'c': // MaxMinStopStep
+          cout << Verbose(0) << "Old: " << config::MaxMinStopStep << "\t new: ";
+          cin >> config::MaxMinStopStep;
+          break;
+        case 'e': // MaxInitMinStep
+          cout << Verbose(0) << "Old: " << config::MaxInitMinStep << "\t new: ";
+          cin >> config::MaxInitMinStep;
+          break;
+        case 'f': // InitRelEpsTotalEnergy
+          cout << Verbose(0) << "Old: " << config::InitRelEpsTotalEnergy << "\t new: ";
+          cin >> config::InitRelEpsTotalEnergy;
+          break;
+        case 'g': // InitRelEpsKineticEnergy
+          cout << Verbose(0) << "Old: " << config::InitRelEpsKineticEnergy << "\t new: ";
+          cin >> config::InitRelEpsKineticEnergy;
+          break;
+        case 'h': // InitMaxMinStopStep
+          cout << Verbose(0) << "Old: " << config::InitMaxMinStopStep << "\t new: ";
+          cin >> config::InitMaxMinStopStep;
+          break;
+//        case 'j': // BoxLength
+//          cout << Verbose(0) << "enter lower triadiagonalo form of basis matrix" << endl << endl;
+//          for (int i=0;i<6;i++) {
+//            cout << Verbose(0) << "Cell size" << i << ": ";
+//            cin >> mol->cell_size[i];
+//          }
+//          break;
+        case 'k': // ECut
+          cout << Verbose(0) << "Old: " << config::ECut << "\t new: ";
+          cin >> config::ECut;
+          break;
+        case 'l': // MaxLevel
+          cout << Verbose(0) << "Old: " << config::MaxLevel << "\t new: ";
+          cin >> config::MaxLevel;
+          break;
+        case 'm': // RiemannTensor
+          cout << Verbose(0) << "Old: " << config::RiemannTensor << "\t new: ";
+          cin >> config::RiemannTensor;
+          break;
+        case 'n': // LevRFactor
+          cout << Verbose(0) << "Old: " << config::LevRFactor << "\t new: ";
+          cin >> config::LevRFactor;
+          break;
+        case 'o': // RiemannLevel
+          cout << Verbose(0) << "Old: " << config::RiemannLevel << "\t new: ";
+          cin >> config::RiemannLevel;
+          break;
+        case 'p': // Lev0Factor
+          cout << Verbose(0) << "Old: " << config::Lev0Factor << "\t new: ";
+          cin >> config::Lev0Factor;
+          break;
+        case 'r': // RTActualUse
+          cout << Verbose(0) << "Old: " << config::RTActualUse << "\t new: ";
+          cin >> config::RTActualUse;
+          break;
+        case 's': // PsiType
+          cout << Verbose(0) << "Old: " << config::PsiType << "\t new: ";
+          cin >> config::PsiType;
+          break;
+        case 't': // MaxPsiDouble
+          cout << Verbose(0) << "Old: " << config::MaxPsiDouble << "\t new: ";
+          cin >> config::MaxPsiDouble;
+          break;
+        case 'u': // PsiMaxNoUp
+          cout << Verbose(0) << "Old: " << config::PsiMaxNoUp << "\t new: ";
+          cin >> config::PsiMaxNoUp;
+          break;
+        case 'v': // PsiMaxNoDown
+          cout << Verbose(0) << "Old: " << config::PsiMaxNoDown << "\t new: ";
+          cin >> config::PsiMaxNoDown;
+          break;
+        case 'w': // AddPsis
+          cout << Verbose(0) << "Old: " << config::AddPsis << "\t new: ";
+          cin >> config::AddPsis;
+          break;
+        case 'x': // RCut
+          cout << Verbose(0) << "Old: " << config::RCut << "\t new: ";
+          cin >> config::RCut;
+          break;
+        case 'y': // StructOpt
+          cout << Verbose(0) << "Old: " << config::StructOpt << "\t new: ";
+          cin >> config::StructOpt;
+          break;
+        case 'z': // IsAngstroem
+          cout << Verbose(0) << "Old: " << config::IsAngstroem << "\t new: ";
+          cin >> config::IsAngstroem;
+          break;
+        case 'i': // RelativeCoord
+          cout << Verbose(0) << "Old: " << config::RelativeCoord << "\t new: ";
+          cin >> config::RelativeCoord;
+          break;
+    };
+  } while (choice != 'q');
 };
 …
 int config::TestSyntax(char *filename, periodentafel *periode, molecule *mol)
+{
         int test;
         ifstream file(filename);
         // search file for keyword: ProcPEGamma (new syntax)
         if (ParseForParameter(1,&file,"ProcPEGamma", 0, 1, 1, int_type, &test, 1, optional)) {
                 file.close();
                 return 1;
+        }
         // search file for keyword: ProcsGammaPsi (old syntax)
         if (ParseForParameter(1,&file,"ProcsGammaPsi", 0, 1, 1, int_type, &test, 1, optional)) {
                 file.close();
                 return 0;
+        }
         file.close();
         return -1;
+  int test;
+  ifstream file(filename);
+  // search file for keyword: ProcPEGamma (new syntax)
+  if (ParseForParameter(1,&file,"ProcPEGamma", 0, 1, 1, int_type, &test, 1, optional)) {
+    file.close();
+    return 1;
+  }
+  // search file for keyword: ProcsGammaPsi (old syntax)
+  if (ParseForParameter(1,&file,"ProcsGammaPsi", 0, 1, 1, int_type, &test, 1, optional)) {
+    file.close();
+    return 0;
+  }
+  file.close();
+  return -1;
+}
 …
 bool config::GetIsAngstroem() const
+{
         return (IsAngstroem == 1);
+  return (IsAngstroem == 1);
 };
 …
 char * config::GetDefaultPath() const
+{
         return defaultpath;
+  return defaultpath;
 };
 …
 void config::SetDefaultPath(const char *path)
+{
         strcpy(defaultpath, path);
+  strcpy(defaultpath, path);
 };
 …
 void config::RetrieveConfigPathAndName(string filename)
+{
         char *ptr = NULL;
         char *buffer = new char[MAXSTRINGSIZE];
         strncpy(buffer, filename.c_str(), MAXSTRINGSIZE);
         int last = -1;
         for(last=MAXSTRINGSIZE;last--;) {
                 if (buffer[last] == '/')
                         break;
+        }
         if (last == -1) { // no path in front, set to local directory.
                 strcpy(configpath, "./");
                 ptr = buffer;
         } else {
                 strncpy(configpath, buffer, last+1);
                 ptr = &buffer[last+1];
                 if (last < 254)
                         configpath[last+1]='\0';
+        }
         strcpy(configname, ptr);
         cout << "Found configpath: " << configpath << ", dir slash was found at " << last << ", config name is " << configname << "." << endl;
         delete[](buffer);
+  char *ptr = NULL;
+  char *buffer = new char[MAXSTRINGSIZE];
+  strncpy(buffer, filename.c_str(), MAXSTRINGSIZE);
+  int last = -1;
+  for(last=MAXSTRINGSIZE;last--;) {
+    if (buffer[last] == '/')
+      break;
+  }
+  if (last == -1) { // no path in front, set to local directory.
+    strcpy(configpath, "./");
+    ptr = buffer;
+  } else {
+    strncpy(configpath, buffer, last+1);
+    ptr = &buffer[last+1];
+    if (last < 254)
+      configpath[last+1]='\0';
+  }
+  strcpy(configname, ptr);
+  cout << "Found configpath: " << configpath << ", dir slash was found at " << last << ", config name is " << configname << "." << endl;
+  delete[](buffer);
 };
 …
 void config::Load(char *filename, periodentafel *periode, molecule *mol)
+{
+        ifstream *file = new ifstream(filename);
+        if (file == NULL) {
+                cerr << "ERROR: config file " << filename << " missing!" << endl;
+                return;
+        }
+        RetrieveConfigPathAndName(filename);
+        // ParseParameters
+        /* Oeffne Hauptparameterdatei */
+        int di;
+        double BoxLength[9];
+        string zeile;
+        string dummy;
+        element *elementhash[MAX_ELEMENTS];
+        char name[MAX_ELEMENTS];
+        char keyword[MAX_ELEMENTS];
+        int Z, No[MAX_ELEMENTS];
+        int verbose = 0;
+        double value[3];
+        /* Namen einlesen */
+        ParseForParameter(verbose,file, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+        ParseForParameter(verbose,file, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+        ParseForParameter(verbose,file, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+        ParseForParameter(verbose,file,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+        ParseForParameter(verbose,file,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
+        if (!ParseForParameter(verbose,file,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
+                config::Seed = 1;
+        if(!ParseForParameter(verbose,file,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
+                config::DoOutOrbitals = 0;
+        } else {
+                if (config::DoOutOrbitals < 0) config::DoOutOrbitals = 0;
+                if (config::DoOutOrbitals > 1) config::DoOutOrbitals = 1;
+        }
+        ParseForParameter(verbose,file,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+        if (config::DoOutVis < 0) config::DoOutVis = 0;
+        if (config::DoOutVis > 1) config::DoOutVis = 1;
+        if (!ParseForParameter(verbose,file,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
+                config::VectorPlane = -1;
+        if (!ParseForParameter(verbose,file,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
+                config::VectorCut = 0.;
+        ParseForParameter(verbose,file,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+        if (config::DoOutMes < 0) config::DoOutMes = 0;
+        if (config::DoOutMes > 1) config::DoOutMes = 1;
+        if (!ParseForParameter(verbose,file,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
+                config::DoOutCurrent = 0;
+        if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
+        if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
+        ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+        if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
+        if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
+        if(!ParseForParameter(verbose,file,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
+                config::DoWannier = 0;
+        } else {
+                if (config::DoWannier < 0) config::DoWannier = 0;
+                if (config::DoWannier > 1) config::DoWannier = 1;
+        }
+        if(!ParseForParameter(verbose,file,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
+                config::CommonWannier = 0;
+        } else {
+                if (config::CommonWannier < 0) config::CommonWannier = 0;
+                if (config::CommonWannier > 4) config::CommonWannier = 4;
+        }
+        if(!ParseForParameter(verbose,file,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
+                config::SawtoothStart = 0.01;
+        } else {
+                if (config::SawtoothStart < 0.) config::SawtoothStart = 0.;
+                if (config::SawtoothStart > 1.) config::SawtoothStart = 1.;
+        }
+        ParseForParameter(verbose,file,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
+        if (!ParseForParameter(verbose,file,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
+                config::Deltat = 1;
+        ParseForParameter(verbose,file,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+        ParseForParameter(verbose,file,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+        ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+        //ParseForParameter(verbose,file,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+        if (!ParseForParameter(verbose,file,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
+                config::EpsWannier = 1e-8;
+        // stop conditions
+        //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
+        ParseForParameter(verbose,file,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+        if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
+        ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+        ParseForParameter(verbose,file,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+        ParseForParameter(verbose,file,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+        ParseForParameter(verbose,file,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+        ParseForParameter(verbose,file,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
+        if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
+        if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
+        if (config::MaxMinGapStopStep < 1) config::MaxMinGapStopStep = 1;
+        ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+        ParseForParameter(verbose,file,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+        ParseForParameter(verbose,file,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+        ParseForParameter(verbose,file,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+        ParseForParameter(verbose,file,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
+        if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
+        if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
+        if (config::InitMaxMinGapStopStep < 1) config::InitMaxMinGapStopStep = 1;
+        // Unit cell and magnetic field
+        ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+        mol->cell_size[0] = BoxLength[0];
+        mol->cell_size[1] = BoxLength[3];
+        mol->cell_size[2] = BoxLength[4];
+        mol->cell_size[3] = BoxLength[6];
+        mol->cell_size[4] = BoxLength[7];
+        mol->cell_size[5] = BoxLength[8];
+        if (1) fprintf(stderr,"\n");
+        ParseForParameter(verbose,file,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
+        ParseForParameter(verbose,file,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
+        if (!ParseForParameter(verbose,file,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
+                config::DoFullCurrent = 0;
+        if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
+        if (config::DoFullCurrent > 2) config::DoFullCurrent = 2;
+        if (config::DoOutNICS < 0) config::DoOutNICS = 0;
+        if (config::DoOutNICS > 2) config::DoOutNICS = 2;
+        if (config::DoPerturbation == 0) {
+                config::DoFullCurrent = 0;
+                config::DoOutNICS = 0;
+        }
+        ParseForParameter(verbose,file,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+        ParseForParameter(verbose,file,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+        ParseForParameter(verbose,file,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+        if (config::Lev0Factor < 2) {
+                config::Lev0Factor = 2;
+        }
+        ParseForParameter(verbose,file,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+        if (di >= 0 && di < 2) {
+                config::RiemannTensor = di;
+        } else {
+                fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
+                exit(1);
+        }
+        switch (config::RiemannTensor) {
+                case 0: //UseNoRT
+                        if (config::MaxLevel < 2) {
+                                config::MaxLevel = 2;
+                        }
+                        config::LevRFactor = 2;
+                        config::RTActualUse = 0;
+                        break;
+                case 1: // UseRT
+                        if (config::MaxLevel < 3) {
+                                config::MaxLevel = 3;
+                        }
+                        ParseForParameter(verbose,file,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+                        if (config::RiemannLevel < 2) {
+                                config::RiemannLevel = 2;
+                        }
+                        if (config::RiemannLevel > config::MaxLevel-1) {
+                                config::RiemannLevel = config::MaxLevel-1;
+                        }
+                        ParseForParameter(verbose,file,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+                        if (config::LevRFactor < 2) {
+                                config::LevRFactor = 2;
+                        }
+                        config::Lev0Factor = 2;
+                        config::RTActualUse = 2;
+                        break;
+        }
+        ParseForParameter(verbose,file,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+        if (di >= 0 && di < 2) {
+                config::PsiType = di;
+        } else {
+                fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
+                exit(1);
+        }
+        switch (config::PsiType) {
+        case 0: // SpinDouble
+                ParseForParameter(verbose,file,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+                ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+                break;
+        case 1: // SpinUpDown
+                if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
+                ParseForParameter(verbose,file,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+                ParseForParameter(verbose,file,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+                ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+                break;
+        }
+        // IonsInitRead
+        ParseForParameter(verbose,file,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+        ParseForParameter(verbose,file,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+        ParseForParameter(verbose,file,"MaxTypes", 0, 1, 1, int_type, &(config::MaxTypes), 1, critical);
+        if (!ParseForParameter(verbose,file,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
+                config::RelativeCoord = 0;
+        if (!ParseForParameter(verbose,file,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
+                config::StructOpt = 0;
+        if (MaxTypes == 0) {
+                cerr << "There are no atoms according to MaxTypes in this config file." << endl;
+        } else {
+                // prescan number of ions per type
+                cout << Verbose(0) << "Prescanning ions per type: " << endl;
+                for (int i=0; i < config::MaxTypes; i++) {
+                        sprintf(name,"Ion_Type%i",i+1);
+                        ParseForParameter(verbose,file, (const char*)name, 0, 1, 1, int_type, &No[i], 1, critical);
+                        ParseForParameter(verbose,file, name, 0, 2, 1, int_type, &Z, 1, critical);
+                        elementhash[i] = periode->FindElement(Z);
+                        cout << Verbose(1) << i << ". Z = " << elementhash[i]->Z << " with " << No[i] << " ions." << endl;
+                }
+                int repetition = 0; // which repeated keyword shall be read
+                map<int, atom *> AtomList[config::MaxTypes];
+                if (!FastParsing) {
+                        // parse in trajectories
+                        bool status = true;
+                        atom *neues = NULL;
+                        while (status) {
+                                cout << "Currently parsing MD step " << repetition << "." << endl;
+                                for (int i=0; i < config::MaxTypes; i++) {
+                                        sprintf(name,"Ion_Type%i",i+1);
+                                        for(int j=0;j<No[i];j++) {
+                                                sprintf(keyword,"%s_%i",name, j+1);
+                                                if (repetition == 0) {
+                                                        neues = new atom();
+                                                        AtomList[i][j] = neues;
+                                                        neues->type = elementhash[i]; // find element type
+                                                        mol->AddAtom(neues);
+                                                } else
+                                                        neues = AtomList[i][j];
+                                                status = (status &&
+                                                                                ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], 1, (repetition == 0) ? critical : optional) &&
+                                                                                ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], 1, (repetition == 0) ? critical : optional) &&
+                                                                                ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], 1, (repetition == 0) ? critical : optional) &&
+                                                                                ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, 1, (repetition == 0) ? critical : optional));
+                                                if (!status) break;
+                                                // check size of vectors
+                                                if (mol->Trajectories[neues].R.size() <= (unsigned int)(repetition)) {
+                                                        //cout << "Increasing size for trajectory array of " << keyword << " to " << (repetition+10) << "." << endl;
+                                                        mol->Trajectories[neues].R.resize(repetition+10);
+                                                        mol->Trajectories[neues].U.resize(repetition+10);
+                                                        mol->Trajectories[neues].F.resize(repetition+10);
+                                                }
+                                                // put into trajectories list
+                                                for (int d=0;d<NDIM;d++)
+                                                        mol->Trajectories[neues].R.at(repetition).x[d] = neues->x.x[d];
+                                                // parse velocities if present
+                                                if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], 1,optional))
+                                                        neues->v.x[0] = 0.;
+                                                if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], 1,optional))
+                                                        neues->v.x[1] = 0.;
+                                                if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], 1,optional))
+                                                        neues->v.x[2] = 0.;
+                                                for (int d=0;d<NDIM;d++)
+                                                        mol->Trajectories[neues].U.at(repetition).x[d] = neues->v.x[d];
+                                                // parse forces if present
+                                                if(!ParseForParameter(verbose,file, keyword, 0, 8, 1, double_type, &value[0], 1,optional))
+                                                        value[0] = 0.;
+                                                if(!ParseForParameter(verbose,file, keyword, 0, 9, 1, double_type, &value[1], 1,optional))
+                                                        value[1] = 0.;
+                                                if(!ParseForParameter(verbose,file, keyword, 1, 10, 1, double_type, &value[2], 1,optional))
+                                                        value[2] = 0.;
+                                                for (int d=0;d<NDIM;d++)
+                                                        mol->Trajectories[neues].F.at(repetition).x[d] = value[d];
+        //                                              cout << "Parsed position of step " << (repetition) << ": (";
+        //                                              for (int d=0;d<NDIM;d++)
+        //                                                      cout << mol->Trajectories[neues].R.at(repetition).x[d] << " ";                                  // next step
+        //                                              cout << ")\t(";
+        //                                              for (int d=0;d<NDIM;d++)
+        //                                                      cout << mol->Trajectories[neues].U.at(repetition).x[d] << " ";                                  // next step
+        //                                              cout << ")\t(";
+        //                                              for (int d=0;d<NDIM;d++)
+        //                                                      cout << mol->Trajectories[neues].F.at(repetition).x[d] << " ";                                  // next step
+        //                                              cout << ")" << endl;
+                                        }
+                                }
+                                repetition++;
+                        }
+                        repetition--;
+                        cout << "Found " << repetition << " trajectory steps." << endl;
+                        mol->MDSteps = repetition;
+                } else {
+                        // find the maximum number of MD steps so that we may parse last one (Ion_Type1_1 must always be present, because is the first atom)
+                        repetition = 0;
+                        while ( ParseForParameter(verbose,file, "Ion_Type1_1", 0, 1, 1, double_type, &value[0], repetition, (repetition == 0) ? critical : optional) &&
+                                                        ParseForParameter(verbose,file, "Ion_Type1_1", 0, 2, 1, double_type, &value[1], repetition, (repetition == 0) ? critical : optional) &&
+                                                        ParseForParameter(verbose,file, "Ion_Type1_1", 0, 3, 1, double_type, &value[2], repetition, (repetition == 0) ? critical : optional))
+                                repetition++;
+                        cout << "I found " << repetition << " times the keyword Ion_Type1_1." << endl;
+                        // parse in molecule coordinates
+                        for (int i=0; i < config::MaxTypes; i++) {
+                                sprintf(name,"Ion_Type%i",i+1);
+                                for(int j=0;j<No[i];j++) {
+                                        sprintf(keyword,"%s_%i",name, j+1);
+                                        atom *neues = new atom();
+                                        // then parse for each atom the coordinates as often as present
+                                        ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], repetition,critical);
+                                        ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], repetition,critical);
+                                        ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], repetition,critical);
+                                        ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, repetition,critical);
+                                        if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], repetition,optional))
+                                                neues->v.x[0] = 0.;
+                                        if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], repetition,optional))
+                                                neues->v.x[1] = 0.;
+                                        if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], repetition,optional))
+                                                neues->v.x[2] = 0.;
+                                        // here we don't care if forces are present (last in trajectories is always equal to current position)
+                                        neues->type = elementhash[i]; // find element type
+                                        mol->AddAtom(neues);
+                                }
+                        }
+                }
+        }
+        file->close();
+        delete(file);
+  ifstream *file = new ifstream(filename);
+  if (file == NULL) {
+    cerr << "ERROR: config file " << filename << " missing!" << endl;
+    return;
+  }
+  RetrieveConfigPathAndName(filename);
+  // ParseParameters
+  /* Oeffne Hauptparameterdatei */
+  int di;
+  double BoxLength[9];
+  string zeile;
+  string dummy;
+  element *elementhash[MAX_ELEMENTS];
+  char name[MAX_ELEMENTS];
+  char keyword[MAX_ELEMENTS];
+  int Z, No[MAX_ELEMENTS];
+  int verbose = 0;
+  double value[3];
+  InitThermostats(file);
+  /* Namen einlesen */
+  ParseForParameter(verbose,file, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+  ParseForParameter(verbose,file, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+  ParseForParameter(verbose,file, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+  ParseForParameter(verbose,file,"ProcPEGamma", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+  ParseForParameter(verbose,file,"ProcPEPsi", 0, 1, 1, int_type, &(config::ProcPEPsi), 1, critical);
+  if (!ParseForParameter(verbose,file,"Seed", 0, 1, 1, int_type, &(config::Seed), 1, optional))
+    config::Seed = 1;
+  if(!ParseForParameter(verbose,file,"DoOutOrbitals", 0, 1, 1, int_type, &(config::DoOutOrbitals), 1, optional)) {
+    config::DoOutOrbitals = 0;
+  } else {
+    if (config::DoOutOrbitals < 0) config::DoOutOrbitals = 0;
+    if (config::DoOutOrbitals > 1) config::DoOutOrbitals = 1;
+  }
+  ParseForParameter(verbose,file,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+  if (config::DoOutVis < 0) config::DoOutVis = 0;
+  if (config::DoOutVis > 1) config::DoOutVis = 1;
+  if (!ParseForParameter(verbose,file,"VectorPlane", 0, 1, 1, int_type, &(config::VectorPlane), 1, optional))
+    config::VectorPlane = -1;
+  if (!ParseForParameter(verbose,file,"VectorCut", 0, 1, 1, double_type, &(config::VectorCut), 1, optional))
+    config::VectorCut = 0.;
+  ParseForParameter(verbose,file,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+  if (config::DoOutMes < 0) config::DoOutMes = 0;
+  if (config::DoOutMes > 1) config::DoOutMes = 1;
+  if (!ParseForParameter(verbose,file,"DoOutCurr", 0, 1, 1, int_type, &(config::DoOutCurrent), 1, optional))
+    config::DoOutCurrent = 0;
+  if (config::DoOutCurrent < 0) config::DoOutCurrent = 0;
+  if (config::DoOutCurrent > 1) config::DoOutCurrent = 1;
+  ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+  if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
+  if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
+  if(!ParseForParameter(verbose,file,"DoWannier", 0, 1, 1, int_type, &(config::DoWannier), 1, optional)) {
+    config::DoWannier = 0;
+  } else {
+    if (config::DoWannier < 0) config::DoWannier = 0;
+    if (config::DoWannier > 1) config::DoWannier = 1;
+  }
+  if(!ParseForParameter(verbose,file,"CommonWannier", 0, 1, 1, int_type, &(config::CommonWannier), 1, optional)) {
+    config::CommonWannier = 0;
+  } else {
+    if (config::CommonWannier < 0) config::CommonWannier = 0;
+    if (config::CommonWannier > 4) config::CommonWannier = 4;
+  }
+  if(!ParseForParameter(verbose,file,"SawtoothStart", 0, 1, 1, double_type, &(config::SawtoothStart), 1, optional)) {
+    config::SawtoothStart = 0.01;
+  } else {
+    if (config::SawtoothStart < 0.) config::SawtoothStart = 0.;
+    if (config::SawtoothStart > 1.) config::SawtoothStart = 1.;
+  }
+  if (ParseForParameter(verbose,file,"DoConstrainedMD", 0, 1, 1, int_type, &(config::DoConstrainedMD), 1, optional))
+    if (config::DoConstrainedMD < 0)
+      config::DoConstrainedMD = 0;
+  ParseForParameter(verbose,file,"MaxOuterStep", 0, 1, 1, int_type, &(config::MaxOuterStep), 1, critical);
+  if (!ParseForParameter(verbose,file,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional))
+    config::Deltat = 1;
+  ParseForParameter(verbose,file,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+  ParseForParameter(verbose,file,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+  ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  //ParseForParameter(verbose,file,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  if (!ParseForParameter(verbose,file,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
+    config::EpsWannier = 1e-8;
+  // stop conditions
+  //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
+  ParseForParameter(verbose,file,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+  if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
+  ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+  ParseForParameter(verbose,file,"RelEpsTotalE", 0, 1, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,file,"RelEpsKineticE", 0, 1, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,file,"MaxMinStopStep", 0, 1, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,file,"MaxMinGapStopStep", 0, 1, 1, int_type, &(config::MaxMinGapStopStep), 1, critical);
+  if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
+  if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
+  if (config::MaxMinGapStopStep < 1) config::MaxMinGapStopStep = 1;
+  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+  ParseForParameter(verbose,file,"InitRelEpsTotalE", 0, 1, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,file,"InitRelEpsKineticE", 0, 1, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,file,"InitMaxMinStopStep", 0, 1, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+  ParseForParameter(verbose,file,"InitMaxMinGapStopStep", 0, 1, 1, int_type, &(config::InitMaxMinGapStopStep), 1, critical);
+  if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
+  if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
+  if (config::InitMaxMinGapStopStep < 1) config::InitMaxMinGapStopStep = 1;
+  // Unit cell and magnetic field
+  ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+  mol->cell_size[0] = BoxLength[0];
+  mol->cell_size[1] = BoxLength[3];
+  mol->cell_size[2] = BoxLength[4];
+  mol->cell_size[3] = BoxLength[6];
+  mol->cell_size[4] = BoxLength[7];
+  mol->cell_size[5] = BoxLength[8];
+  if (1) fprintf(stderr,"\n");
+  ParseForParameter(verbose,file,"DoPerturbation", 0, 1, 1, int_type, &(config::DoPerturbation), 1, optional);
+  ParseForParameter(verbose,file,"DoOutNICS", 0, 1, 1, int_type, &(config::DoOutNICS), 1, optional);
+  if (!ParseForParameter(verbose,file,"DoFullCurrent", 0, 1, 1, int_type, &(config::DoFullCurrent), 1, optional))
+    config::DoFullCurrent = 0;
+  if (config::DoFullCurrent < 0) config::DoFullCurrent = 0;
+  if (config::DoFullCurrent > 2) config::DoFullCurrent = 2;
+  if (config::DoOutNICS < 0) config::DoOutNICS = 0;
+  if (config::DoOutNICS > 2) config::DoOutNICS = 2;
+  if (config::DoPerturbation == 0) {
+    config::DoFullCurrent = 0;
+    config::DoOutNICS = 0;
+  }
+  ParseForParameter(verbose,file,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+  ParseForParameter(verbose,file,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+  ParseForParameter(verbose,file,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+  if (config::Lev0Factor < 2) {
+    config::Lev0Factor = 2;
+  }
+  ParseForParameter(verbose,file,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::RiemannTensor = di;
+  } else {
+    fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
+    exit(1);
+  }
+  switch (config::RiemannTensor) {
+    case 0: //UseNoRT
+      if (config::MaxLevel < 2) {
+        config::MaxLevel = 2;
+      }
+      config::LevRFactor = 2;
+      config::RTActualUse = 0;
+      break;
+    case 1: // UseRT
+      if (config::MaxLevel < 3) {
+        config::MaxLevel = 3;
+      }
+      ParseForParameter(verbose,file,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+      if (config::RiemannLevel < 2) {
+        config::RiemannLevel = 2;
+      }
+      if (config::RiemannLevel > config::MaxLevel-1) {
+        config::RiemannLevel = config::MaxLevel-1;
+      }
+      ParseForParameter(verbose,file,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+      if (config::LevRFactor < 2) {
+        config::LevRFactor = 2;
+      }
+      config::Lev0Factor = 2;
+      config::RTActualUse = 2;
+      break;
+  }
+  ParseForParameter(verbose,file,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::PsiType = di;
+  } else {
+    fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
+    exit(1);
+  }
+  switch (config::PsiType) {
+  case 0: // SpinDouble
+    ParseForParameter(verbose,file,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+    ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  case 1: // SpinUpDown
+    if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
+    ParseForParameter(verbose,file,"PsiMaxNoUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+    ParseForParameter(verbose,file,"PsiMaxNoDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+    ParseForParameter(verbose,file,"AddPsis", 0, 1, 1, int_type, &(config::AddPsis), 1, optional);
+    break;
+  }
+  // IonsInitRead
+  ParseForParameter(verbose,file,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+  ParseForParameter(verbose,file,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+  ParseForParameter(verbose,file,"MaxTypes", 0, 1, 1, int_type, &(config::MaxTypes), 1, critical);
+  if (!ParseForParameter(verbose,file,"RelativeCoord", 0, 1, 1, int_type, &(config::RelativeCoord) , 1, optional))
+    config::RelativeCoord = 0;
+  if (!ParseForParameter(verbose,file,"StructOpt", 0, 1, 1, int_type, &(config::StructOpt), 1, optional))
+    config::StructOpt = 0;
+  if (MaxTypes == 0) {
+    cerr << "There are no atoms according to MaxTypes in this config file." << endl;
+  } else {
+    // prescan number of ions per type
+    cout << Verbose(0) << "Prescanning ions per type: " << endl;
+    for (int i=0; i < config::MaxTypes; i++) {
+      sprintf(name,"Ion_Type%i",i+1);
+      ParseForParameter(verbose,file, (const char*)name, 0, 1, 1, int_type, &No[i], 1, critical);
+      ParseForParameter(verbose,file, name, 0, 2, 1, int_type, &Z, 1, critical);
+      elementhash[i] = periode->FindElement(Z);
+      cout << Verbose(1) << i << ". Z = " << elementhash[i]->Z << " with " << No[i] << " ions." << endl;
+    }
+    int repetition = 0; // which repeated keyword shall be read
+    map<int, atom *> AtomList[config::MaxTypes];
+    if (!FastParsing) {
+      // parse in trajectories
+      bool status = true;
+      atom *neues = NULL;
+      while (status) {
+        cout << "Currently parsing MD step " << repetition << "." << endl;
+        for (int i=0; i < config::MaxTypes; i++) {
+          sprintf(name,"Ion_Type%i",i+1);
+          for(int j=0;j<No[i];j++) {
+            sprintf(keyword,"%s_%i",name, j+1);
+            if (repetition == 0) {
+              neues = new atom();
+              AtomList[i][j] = neues;
+              neues->type = elementhash[i]; // find element type
+              mol->AddAtom(neues);
+            } else
+              neues = AtomList[i][j];
+            status = (status &&
+                    ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], 1, (repetition == 0) ? critical : optional) &&
+                    ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, 1, (repetition == 0) ? critical : optional));
+            if (!status) break;
+            // check size of vectors
+            if (mol->Trajectories[neues].R.size() <= (unsigned int)(repetition)) {
+              //cout << "Increasing size for trajectory array of " << keyword << " to " << (repetition+10) << "." << endl;
+              mol->Trajectories[neues].R.resize(repetition+10);
+              mol->Trajectories[neues].U.resize(repetition+10);
+              mol->Trajectories[neues].F.resize(repetition+10);
+            }
+            // put into trajectories list
+            for (int d=0;d<NDIM;d++)
+              mol->Trajectories[neues].R.at(repetition).x[d] = neues->x.x[d];
+            // parse velocities if present
+            if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], 1,optional))
+              neues->v.x[0] = 0.;
+            if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], 1,optional))
+              neues->v.x[1] = 0.;
+            if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], 1,optional))
+              neues->v.x[2] = 0.;
+            for (int d=0;d<NDIM;d++)
+              mol->Trajectories[neues].U.at(repetition).x[d] = neues->v.x[d];
+            // parse forces if present
+            if(!ParseForParameter(verbose,file, keyword, 0, 8, 1, double_type, &value[0], 1,optional))
+              value[0] = 0.;
+            if(!ParseForParameter(verbose,file, keyword, 0, 9, 1, double_type, &value[1], 1,optional))
+              value[1] = 0.;
+            if(!ParseForParameter(verbose,file, keyword, 1, 10, 1, double_type, &value[2], 1,optional))
+              value[2] = 0.;
+            for (int d=0;d<NDIM;d++)
+              mol->Trajectories[neues].F.at(repetition).x[d] = value[d];
+  //            cout << "Parsed position of step " << (repetition) << ": (";
+  //            for (int d=0;d<NDIM;d++)
+  //              cout << mol->Trajectories[neues].R.at(repetition).x[d] << " ";          // next step
+  //            cout << ")\t(";
+  //            for (int d=0;d<NDIM;d++)
+  //              cout << mol->Trajectories[neues].U.at(repetition).x[d] << " ";          // next step
+  //            cout << ")\t(";
+  //            for (int d=0;d<NDIM;d++)
+  //              cout << mol->Trajectories[neues].F.at(repetition).x[d] << " ";          // next step
+  //            cout << ")" << endl;
+          }
+        }
+        repetition++;
+      }
+      repetition--;
+      cout << "Found " << repetition << " trajectory steps." << endl;
+      mol->MDSteps = repetition;
+    } else {
+      // find the maximum number of MD steps so that we may parse last one (Ion_Type1_1 must always be present, because is the first atom)
+      repetition = 0;
+      while ( ParseForParameter(verbose,file, "Ion_Type1_1", 0, 1, 1, double_type, &value[0], repetition, (repetition == 0) ? critical : optional) &&
+              ParseForParameter(verbose,file, "Ion_Type1_1", 0, 2, 1, double_type, &value[1], repetition, (repetition == 0) ? critical : optional) &&
+              ParseForParameter(verbose,file, "Ion_Type1_1", 0, 3, 1, double_type, &value[2], repetition, (repetition == 0) ? critical : optional))
+        repetition++;
+      cout << "I found " << repetition << " times the keyword Ion_Type1_1." << endl;
+      // parse in molecule coordinates
+      for (int i=0; i < config::MaxTypes; i++) {
+        sprintf(name,"Ion_Type%i",i+1);
+        for(int j=0;j<No[i];j++) {
+          sprintf(keyword,"%s_%i",name, j+1);
+          atom *neues = new atom();
+          // then parse for each atom the coordinates as often as present
+          ParseForParameter(verbose,file, keyword, 0, 1, 1, double_type, &neues->x.x[0], repetition,critical);
+          ParseForParameter(verbose,file, keyword, 0, 2, 1, double_type, &neues->x.x[1], repetition,critical);
+          ParseForParameter(verbose,file, keyword, 0, 3, 1, double_type, &neues->x.x[2], repetition,critical);
+          ParseForParameter(verbose,file, keyword, 0, 4, 1, int_type, &neues->FixedIon, repetition,critical);
+          if(!ParseForParameter(verbose,file, keyword, 0, 5, 1, double_type, &neues->v.x[0], repetition,optional))
+            neues->v.x[0] = 0.;
+          if(!ParseForParameter(verbose,file, keyword, 0, 6, 1, double_type, &neues->v.x[1], repetition,optional))
+            neues->v.x[1] = 0.;
+          if(!ParseForParameter(verbose,file, keyword, 0, 7, 1, double_type, &neues->v.x[2], repetition,optional))
+            neues->v.x[2] = 0.;
+          // here we don't care if forces are present (last in trajectories is always equal to current position)
+          neues->type = elementhash[i]; // find element type
+          mol->AddAtom(neues);
+        }
+      }
+    }
+  }
+  file->close();
+  delete(file);
 };
 …
 void config::LoadOld(char *filename, periodentafel *periode, molecule *mol)
+{
         ifstream *file = new ifstream(filename);
         if (file == NULL) {
                 cerr << "ERROR: config file " << filename << " missing!" << endl;
                 return;
+        }
         RetrieveConfigPathAndName(filename);
         // ParseParameters
         /* Oeffne Hauptparameterdatei */
         int l, i, di;
         double a,b;
         double BoxLength[9];
         string zeile;
         string dummy;
         element *elementhash[128];
         int Z, No, AtomNo, found;
         int verbose = 0;
         /* Namen einlesen */
         ParseForParameter(verbose,file, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
         ParseForParameter(verbose,file, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
         ParseForParameter(verbose,file, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
         ParseForParameter(verbose,file, "ProcsGammaPsi", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
         ParseForParameter(verbose,file, "ProcsGammaPsi", 0, 2, 1, int_type, &(config::ProcPEPsi), 1, critical);
         config::Seed = 1;
         config::DoOutOrbitals = 0;
         ParseForParameter(verbose,file,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
         if (config::DoOutVis < 0) config::DoOutVis = 0;
         if (config::DoOutVis > 1) config::DoOutVis = 1;
         config::VectorPlane = -1;
         config::VectorCut = 0.;
         ParseForParameter(verbose,file,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
         if (config::DoOutMes < 0) config::DoOutMes = 0;
         if (config::DoOutMes > 1) config::DoOutMes = 1;
         config::DoOutCurrent = 0;
         ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
         if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
         if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
         config::CommonWannier = 0;
         config::SawtoothStart = 0.01;
         ParseForParameter(verbose,file,"MaxOuterStep", 0, 1, 1, double_type, &(config::MaxOuterStep), 1, critical);
         ParseForParameter(verbose,file,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional);
         ParseForParameter(verbose,file,"VisOuterStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
         ParseForParameter(verbose,file,"VisSrcOuterStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
         ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
         ParseForParameter(verbose,file,"ScaleTempStep", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
         config::EpsWannier = 1e-8;
         // stop conditions
         //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
         ParseForParameter(verbose,file,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
         if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
         ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
         ParseForParameter(verbose,file,"MaxMinStep", 0, 2, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
         ParseForParameter(verbose,file,"MaxMinStep", 0, 3, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
         ParseForParameter(verbose,file,"MaxMinStep", 0, 4, 1, int_type, &(config::MaxMinStopStep), 1, critical);
         if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
         if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
         config::MaxMinGapStopStep = 1;
         ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
         ParseForParameter(verbose,file,"MaxInitMinStep", 0, 2, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
         ParseForParameter(verbose,file,"MaxInitMinStep", 0, 3, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
         ParseForParameter(verbose,file,"MaxInitMinStep", 0, 4, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
         if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
         if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
         config::InitMaxMinGapStopStep = 1;
         ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
         mol->cell_size[0] = BoxLength[0];
         mol->cell_size[1] = BoxLength[3];
         mol->cell_size[2] = BoxLength[4];
         mol->cell_size[3] = BoxLength[6];
         mol->cell_size[4] = BoxLength[7];
         mol->cell_size[5] = BoxLength[8];
         if (1) fprintf(stderr,"\n");
         config::DoPerturbation = 0;
         config::DoFullCurrent = 0;
         ParseForParameter(verbose,file,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
         ParseForParameter(verbose,file,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
         ParseForParameter(verbose,file,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
         if (config::Lev0Factor < 2) {
                 config::Lev0Factor = 2;
+        }
         ParseForParameter(verbose,file,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
         if (di >= 0 && di < 2) {
                 config::RiemannTensor = di;
         } else {
                 fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
                 exit(1);
+        }
         switch (config::RiemannTensor) {
                 case 0: //UseNoRT
                         if (config::MaxLevel < 2) {
                                 config::MaxLevel = 2;
+                        }
                         config::LevRFactor = 2;
                         config::RTActualUse = 0;
                         break;
                 case 1: // UseRT
                         if (config::MaxLevel < 3) {
                                 config::MaxLevel = 3;
+                        }
                         ParseForParameter(verbose,file,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
                         if (config::RiemannLevel < 2) {
                                 config::RiemannLevel = 2;
+                        }
                         if (config::RiemannLevel > config::MaxLevel-1) {
                                 config::RiemannLevel = config::MaxLevel-1;
+                        }
                         ParseForParameter(verbose,file,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
                         if (config::LevRFactor < 2) {
                                 config::LevRFactor = 2;
+                        }
                         config::Lev0Factor = 2;
                         config::RTActualUse = 2;
                         break;
+        }
         ParseForParameter(verbose,file,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
         if (di >= 0 && di < 2) {
                 config::PsiType = di;
         } else {
                 fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
                 exit(1);
+        }
         switch (config::PsiType) {
         case 0: // SpinDouble
                 ParseForParameter(verbose,file,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
                 config::AddPsis = 0;
                 break;
         case 1: // SpinUpDown
                 if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
                 ParseForParameter(verbose,file,"MaxPsiUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
                 ParseForParameter(verbose,file,"MaxPsiDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
                 config::AddPsis = 0;
                 break;
+        }
         // IonsInitRead
         ParseForParameter(verbose,file,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
         ParseForParameter(verbose,file,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
         config::RelativeCoord = 0;
         config::StructOpt = 0;
         // Routine from builder.cpp
         for (i=MAX_ELEMENTS;i--;)
                 elementhash[i] = NULL;
         cout << Verbose(0) << "Parsing Ions ..." << endl;
         No=0;
         found = 0;
         while (getline(*file,zeile,'\n')) {
                 if (zeile.find("Ions_Data") == 0) {
                         cout << Verbose(1) << "found Ions_Data...begin parsing" << endl;
                         found ++;
+                }
                 if (found > 0) {
                         if (zeile.find("Ions_Data") == 0)
                                 getline(*file,zeile,'\n'); // read next line and parse this one
                         istringstream input(zeile);
                         input >> AtomNo;        // number of atoms
                         input >> Z;                      // atomic number
                         input >> a;
                         input >> l;
                         input >> l;
                         input >> b;              // element mass
                         elementhash[No] = periode->FindElement(Z);
                         cout << Verbose(1) << "AtomNo: " << AtomNo << "\tZ: " << Z << "\ta:" << a << "\tl:"     << l << "\b:" << b << "\tElement:" << elementhash[No] << "\t:" << endl;
                         for(i=0;i<AtomNo;i++) {
                                 if (!getline(*file,zeile,'\n')) {// parse on and on
                                         cout << Verbose(2) << "Error: Too few items in ionic list of element" << elementhash[No] << "." << endl << "Exiting." << endl;
                                         // return 1;
                                 } else {
                                         //cout << Verbose(2) << "Reading line: " << zeile << endl;
+                                }
                                 istringstream input2(zeile);
                                 atom *neues = new atom();
                                 input2 >> neues->x.x[0]; // x
                                 input2 >> neues->x.x[1]; // y
                                 input2 >> neues->x.x[2]; // z
                                 input2 >> l;
                                 neues->type = elementhash[No]; // find element type
                                 mol->AddAtom(neues);
+                        }
                         No++;
+                }
+        }
         file->close();
         delete(file);
+  ifstream *file = new ifstream(filename);
+  if (file == NULL) {
+    cerr << "ERROR: config file " << filename << " missing!" << endl;
+    return;
+  }
+  RetrieveConfigPathAndName(filename);
+  // ParseParameters
+  /* Oeffne Hauptparameterdatei */
+  int l, i, di;
+  double a,b;
+  double BoxLength[9];
+  string zeile;
+  string dummy;
+  element *elementhash[128];
+  int Z, No, AtomNo, found;
+  int verbose = 0;
+  /* Namen einlesen */
+  ParseForParameter(verbose,file, "mainname", 0, 1, 1, string_type, (config::mainname), 1, critical);
+  ParseForParameter(verbose,file, "defaultpath", 0, 1, 1, string_type, (config::defaultpath), 1, critical);
+  ParseForParameter(verbose,file, "pseudopotpath", 0, 1, 1, string_type, (config::pseudopotpath), 1, critical);
+  ParseForParameter(verbose,file, "ProcsGammaPsi", 0, 1, 1, int_type, &(config::ProcPEGamma), 1, critical);
+  ParseForParameter(verbose,file, "ProcsGammaPsi", 0, 2, 1, int_type, &(config::ProcPEPsi), 1, critical);
+  config::Seed = 1;
+  config::DoOutOrbitals = 0;
+  ParseForParameter(verbose,file,"DoOutVis", 0, 1, 1, int_type, &(config::DoOutVis), 1, critical);
+  if (config::DoOutVis < 0) config::DoOutVis = 0;
+  if (config::DoOutVis > 1) config::DoOutVis = 1;
+  config::VectorPlane = -1;
+  config::VectorCut = 0.;
+  ParseForParameter(verbose,file,"DoOutMes", 0, 1, 1, int_type, &(config::DoOutMes), 1, critical);
+  if (config::DoOutMes < 0) config::DoOutMes = 0;
+  if (config::DoOutMes > 1) config::DoOutMes = 1;
+  config::DoOutCurrent = 0;
+  ParseForParameter(verbose,file,"AddGramSch", 0, 1, 1, int_type, &(config::UseAddGramSch), 1, critical);
+  if (config::UseAddGramSch < 0) config::UseAddGramSch = 0;
+  if (config::UseAddGramSch > 2) config::UseAddGramSch = 2;
+  config::CommonWannier = 0;
+  config::SawtoothStart = 0.01;
+  ParseForParameter(verbose,file,"MaxOuterStep", 0, 1, 1, double_type, &(config::MaxOuterStep), 1, critical);
+  ParseForParameter(verbose,file,"Deltat", 0, 1, 1, double_type, &(config::Deltat), 1, optional);
+  ParseForParameter(verbose,file,"VisOuterStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
+  ParseForParameter(verbose,file,"VisSrcOuterStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
+  ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  ParseForParameter(verbose,file,"ScaleTempStep", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  config::EpsWannier = 1e-8;
+  // stop conditions
+  //if (config::MaxOuterStep <= 0) config::MaxOuterStep = 1;
+  ParseForParameter(verbose,file,"MaxPsiStep", 0, 1, 1, int_type, &(config::MaxPsiStep), 1, critical);
+  if (config::MaxPsiStep <= 0) config::MaxPsiStep = 3;
+  ParseForParameter(verbose,file,"MaxMinStep", 0, 1, 1, int_type, &(config::MaxMinStep), 1, critical);
+  ParseForParameter(verbose,file,"MaxMinStep", 0, 2, 1, double_type, &(config::RelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,file,"MaxMinStep", 0, 3, 1, double_type, &(config::RelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,file,"MaxMinStep", 0, 4, 1, int_type, &(config::MaxMinStopStep), 1, critical);
+  if (config::MaxMinStep <= 0) config::MaxMinStep = config::MaxPsiStep;
+  if (config::MaxMinStopStep < 1) config::MaxMinStopStep = 1;
+  config::MaxMinGapStopStep = 1;
+  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 1, 1, int_type, &(config::MaxInitMinStep), 1, critical);
+  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 2, 1, double_type, &(config::InitRelEpsTotalEnergy), 1, critical);
+  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 3, 1, double_type, &(config::InitRelEpsKineticEnergy), 1, critical);
+  ParseForParameter(verbose,file,"MaxInitMinStep", 0, 4, 1, int_type, &(config::InitMaxMinStopStep), 1, critical);
+  if (config::MaxInitMinStep <= 0) config::MaxInitMinStep = config::MaxPsiStep;
+  if (config::InitMaxMinStopStep < 1) config::InitMaxMinStopStep = 1;
+  config::InitMaxMinGapStopStep = 1;
+  ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
+  mol->cell_size[0] = BoxLength[0];
+  mol->cell_size[1] = BoxLength[3];
+  mol->cell_size[2] = BoxLength[4];
+  mol->cell_size[3] = BoxLength[6];
+  mol->cell_size[4] = BoxLength[7];
+  mol->cell_size[5] = BoxLength[8];
+  if (1) fprintf(stderr,"\n");
+  config::DoPerturbation = 0;
+  config::DoFullCurrent = 0;
+  ParseForParameter(verbose,file,"ECut", 0, 1, 1, double_type, &(config::ECut), 1, critical);
+  ParseForParameter(verbose,file,"MaxLevel", 0, 1, 1, int_type, &(config::MaxLevel), 1, critical);
+  ParseForParameter(verbose,file,"Level0Factor", 0, 1, 1, int_type, &(config::Lev0Factor), 1, critical);
+  if (config::Lev0Factor < 2) {
+    config::Lev0Factor = 2;
+  }
+  ParseForParameter(verbose,file,"RiemannTensor", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::RiemannTensor = di;
+  } else {
+    fprintf(stderr, "0 <= RiemanTensor < 2: 0 UseNotRT, 1 UseRT");
+    exit(1);
+  }
+  switch (config::RiemannTensor) {
+    case 0: //UseNoRT
+      if (config::MaxLevel < 2) {
+        config::MaxLevel = 2;
+      }
+      config::LevRFactor = 2;
+      config::RTActualUse = 0;
+      break;
+    case 1: // UseRT
+      if (config::MaxLevel < 3) {
+        config::MaxLevel = 3;
+      }
+      ParseForParameter(verbose,file,"RiemannLevel", 0, 1, 1, int_type, &(config::RiemannLevel), 1, critical);
+      if (config::RiemannLevel < 2) {
+        config::RiemannLevel = 2;
+      }
+      if (config::RiemannLevel > config::MaxLevel-1) {
+        config::RiemannLevel = config::MaxLevel-1;
+      }
+      ParseForParameter(verbose,file,"LevRFactor", 0, 1, 1, int_type, &(config::LevRFactor), 1, critical);
+      if (config::LevRFactor < 2) {
+        config::LevRFactor = 2;
+      }
+      config::Lev0Factor = 2;
+      config::RTActualUse = 2;
+      break;
+  }
+  ParseForParameter(verbose,file,"PsiType", 0, 1, 1, int_type, &di, 1, critical);
+  if (di >= 0 && di < 2) {
+    config::PsiType = di;
+  } else {
+    fprintf(stderr, "0 <= PsiType < 2: 0 UseSpinDouble, 1 UseSpinUpDown");
+    exit(1);
+  }
+  switch (config::PsiType) {
+  case 0: // SpinDouble
+    ParseForParameter(verbose,file,"MaxPsiDouble", 0, 1, 1, int_type, &(config::MaxPsiDouble), 1, critical);
+    config::AddPsis = 0;
+    break;
+  case 1: // SpinUpDown
+    if (config::ProcPEGamma % 2) config::ProcPEGamma*=2;
+    ParseForParameter(verbose,file,"MaxPsiUp", 0, 1, 1, int_type, &(config::PsiMaxNoUp), 1, critical);
+    ParseForParameter(verbose,file,"MaxPsiDown", 0, 1, 1, int_type, &(config::PsiMaxNoDown), 1, critical);
+    config::AddPsis = 0;
+    break;
+  }
+  // IonsInitRead
+  ParseForParameter(verbose,file,"RCut", 0, 1, 1, double_type, &(config::RCut), 1, critical);
+  ParseForParameter(verbose,file,"IsAngstroem", 0, 1, 1, int_type, &(config::IsAngstroem), 1, critical);
+  config::RelativeCoord = 0;
+  config::StructOpt = 0;
+  // Routine from builder.cpp
+  for (i=MAX_ELEMENTS;i--;)
+    elementhash[i] = NULL;
+  cout << Verbose(0) << "Parsing Ions ..." << endl;
+  No=0;
+  found = 0;
+  while (getline(*file,zeile,'\n')) {
+    if (zeile.find("Ions_Data") == 0) {
+      cout << Verbose(1) << "found Ions_Data...begin parsing" << endl;
+      found ++;
+    }
+    if (found > 0) {
+      if (zeile.find("Ions_Data") == 0)
+        getline(*file,zeile,'\n'); // read next line and parse this one
+      istringstream input(zeile);
+      input >> AtomNo;  // number of atoms
+      input >> Z;       // atomic number
+      input >> a;
+      input >> l;
+      input >> l;
+      input >> b;     // element mass
+      elementhash[No] = periode->FindElement(Z);
+      cout << Verbose(1) << "AtomNo: " << AtomNo << "\tZ: " << Z << "\ta:" << a << "\tl:"  << l << "\b:" << b << "\tElement:" << elementhash[No] << "\t:" << endl;
+      for(i=0;i<AtomNo;i++) {
+        if (!getline(*file,zeile,'\n')) {// parse on and on
+          cout << Verbose(2) << "Error: Too few items in ionic list of element" << elementhash[No] << "." << endl << "Exiting." << endl;
+          // return 1;
+        } else {
+          //cout << Verbose(2) << "Reading line: " << zeile << endl;
+        }
+        istringstream input2(zeile);
+        atom *neues = new atom();
+        input2 >> neues->x.x[0]; // x
+        input2 >> neues->x.x[1]; // y
+        input2 >> neues->x.x[2]; // z
+        input2 >> l;
+        neues->type = elementhash[No]; // find element type
+        mol->AddAtom(neues);
+      }
+      No++;
+    }
+  }
+  file->close();
+  delete(file);
 };
 …
 bool config::Save(const char *filename, periodentafel *periode, molecule *mol) const
+{
+        bool result = true;
+        // bring MaxTypes up to date
+        mol->CountElements();
+        ofstream *output = NULL;
+        output = new ofstream(filename, ios::out);
+        if (output != NULL) {
+                *output << "# ParallelCarParinello - main configuration file - created with molecuilder" << endl;
+                *output << endl;
+                *output << "mainname\t" << config::mainname << "\t# programm name (for runtime files)" << endl;
+                *output << "defaultpath\t" << config::defaultpath << "\t# where to put files during runtime" << endl;
+                *output << "pseudopotpath\t" << config::pseudopotpath << "\t# where to find pseudopotentials" << endl;
+                *output << endl;
+                *output << "ProcPEGamma\t" << config::ProcPEGamma << "\t# for parallel computing: share constants" << endl;
+                *output << "ProcPEPsi\t" << config::ProcPEPsi << "\t# for parallel computing: share wave functions" << endl;
+                *output << "DoOutVis\t" << config::DoOutVis << "\t# Output data for OpenDX" << endl;
+                *output << "DoOutMes\t" << config::DoOutMes << "\t# Output data for measurements" << endl;
+                *output << "DoOutOrbitals\t" << config::DoOutOrbitals << "\t# Output all Orbitals" << endl;
+                *output << "DoOutCurr\t" << config::DoOutCurrent << "\t# Ouput current density for OpenDx" << endl;
+                *output << "DoOutNICS\t" << config::DoOutNICS << "\t# Output Nucleus independent current shieldings" << endl;
+                *output << "DoPerturbation\t" << config::DoPerturbation << "\t# Do perturbation calculate and determine susceptibility and shielding" << endl;
+                *output << "DoFullCurrent\t" << config::DoFullCurrent << "\t# Do full perturbation" << endl;
+                *output << "CommonWannier\t" << config::CommonWannier << "\t# Put virtual centers at indivual orbits, all common, merged by variance, to grid point, to cell center" << endl;
+                *output << "SawtoothStart\t" << config::SawtoothStart << "\t# Absolute value for smooth transition at cell border " << endl;
+                *output << "VectorPlane\t" << config::VectorPlane << "\t# Cut plane axis (x, y or z: 0,1,2) for two-dim current vector plot" << endl;
+                *output << "VectorCut\t" << config::VectorCut << "\t# Cut plane axis value" << endl;
+                *output << "AddGramSch\t" << config::UseAddGramSch << "\t# Additional GramSchmidtOrtogonalization to be safe" << endl;
+                *output << "Seed\t\t" << config::Seed << "\t# initial value for random seed for Psi coefficients" << endl;
+                *output << endl;
+                *output << "MaxOuterStep\t" << config::MaxOuterStep << "\t# number of MolecularDynamics/Structure optimization steps" << endl;
+                *output << "Deltat\t" << config::Deltat << "\t# time per MD step" << endl;
+                *output << "OutVisStep\t" << config::OutVisStep << "\t# Output visual data every ...th step" << endl;
+                *output << "OutSrcStep\t" << config::OutSrcStep << "\t# Output \"restart\" data every ..th step" << endl;
+                *output << "TargetTemp\t" << config::TargetTemp << "\t# Target temperature" << endl;
+                *output << "MaxPsiStep\t" << config::MaxPsiStep << "\t# number of Minimisation steps per state (0 - default)" << endl;
+                *output << "EpsWannier\t" << config::EpsWannier << "\t# tolerance value for spread minimisation of orbitals" << endl;
+                *output << endl;
+                *output << "# Values specifying when to stop" << endl;
+                *output << "MaxMinStep\t" << config::MaxMinStep << "\t# Maximum number of steps" << endl;
+                *output << "RelEpsTotalE\t" << config::RelEpsTotalEnergy << "\t# relative change in total energy" << endl;
+                *output << "RelEpsKineticE\t" << config::RelEpsKineticEnergy << "\t# relative change in kinetic energy" << endl;
+                *output << "MaxMinStopStep\t" << config::MaxMinStopStep << "\t# check every ..th steps" << endl;
+                *output << "MaxMinGapStopStep\t" << config::MaxMinGapStopStep << "\t# check every ..th steps" << endl;
+                *output << endl;
+                *output << "# Values specifying when to stop for INIT, otherwise same as above" << endl;
+                *output << "MaxInitMinStep\t" << config::MaxInitMinStep << "\t# Maximum number of steps" << endl;
+                *output << "InitRelEpsTotalE\t" << config::InitRelEpsTotalEnergy << "\t# relative change in total energy" << endl;
+                *output << "InitRelEpsKineticE\t" << config::InitRelEpsKineticEnergy << "\t# relative change in kinetic energy" << endl;
+                *output << "InitMaxMinStopStep\t" << config::InitMaxMinStopStep << "\t# check every ..th steps" << endl;
+                *output << "InitMaxMinGapStopStep\t" << config::InitMaxMinGapStopStep << "\t# check every ..th steps" << endl;
+                *output << endl;
+                *output << "BoxLength\t\t\t# (Length of a unit cell)" << endl;
+                *output << mol->cell_size[0] << "\t" << endl;
+                *output << mol->cell_size[1] << "\t" << mol->cell_size[2] << "\t" << endl;
+                *output << mol->cell_size[3] << "\t" << mol->cell_size[4] << "\t" << mol->cell_size[5] << "\t" << endl;
+                // FIXME
+                *output << endl;
+                *output << "ECut\t\t" << config::ECut << "\t# energy cutoff for discretization in Hartrees" << endl;
+                *output << "MaxLevel\t" << config::MaxLevel << "\t# number of different levels in the code, >=2" << endl;
+                *output << "Level0Factor\t" << config::Lev0Factor << "\t# factor by which node number increases from S to 0 level" << endl;
+                *output << "RiemannTensor\t" << config::RiemannTensor << "\t# (Use metric)" << endl;
+                switch (config::RiemannTensor) {
+                        case 0: //UseNoRT
+                                break;
+                        case 1: // UseRT
+                                *output << "RiemannLevel\t" << config::RiemannLevel << "\t# Number of Riemann Levels" << endl;
+                                *output << "LevRFactor\t" << config::LevRFactor << "\t# factor by which node number increases from 0 to R level from" << endl;
+                                break;
+                }
+                *output << "PsiType\t\t" << config::PsiType << "\t# 0 - doubly occupied, 1 - SpinUp,SpinDown" << endl;
+                // write out both types for easier changing afterwards
+        //      switch (PsiType) {
+        //              case 0:
+                                *output << "MaxPsiDouble\t" << config::MaxPsiDouble << "\t# here: specifying both maximum number of SpinUp- and -Down-states" << endl;
+        //                      break;
+        //              case 1:
+                                *output << "PsiMaxNoUp\t" << config::PsiMaxNoUp << "\t# here: specifying maximum number of SpinUp-states" << endl;
+                                *output << "PsiMaxNoDown\t" << config::PsiMaxNoDown << "\t# here: specifying maximum number of SpinDown-states" << endl;
+        //                      break;
+        //      }
+                *output << "AddPsis\t\t" << config::AddPsis << "\t# Additional unoccupied Psis for bandgap determination" << endl;
+                *output << endl;
+                *output << "RCut\t\t" << config::RCut << "\t# R-cut for the ewald summation" << endl;
+                *output << "StructOpt\t" << config::StructOpt << "\t# Do structure optimization beforehand" << endl;
+                *output << "IsAngstroem\t" << config::IsAngstroem << "\t# 0 - Bohr, 1 - Angstroem" << endl;
+                *output << "RelativeCoord\t" << config::RelativeCoord << "\t# whether ion coordinates are relative (1) or absolute (0)" << endl;
+                *output << "MaxTypes\t" << mol->ElementCount << "\t# maximum number of different ion types" << endl;
+                *output << endl;
+                result = result && mol->Checkout(output);
+                if (mol->MDSteps <=1 )
+                        result = result && mol->Output(output);
+                else
+                        result = result && mol->OutputTrajectories(output);
+                output->close();
+                output->clear();
+                delete(output);
+                return result;
+        } else
+                return false;
+  bool result = true;
+  // bring MaxTypes up to date
+  mol->CountElements();
+  ofstream *output = NULL;
+  output = new ofstream(filename, ios::out);
+  if (output != NULL) {
+    *output << "# ParallelCarParinello - main configuration file - created with molecuilder" << endl;
+    *output << endl;
+    *output << "mainname\t" << config::mainname << "\t# programm name (for runtime files)" << endl;
+    *output << "defaultpath\t" << config::defaultpath << "\t# where to put files during runtime" << endl;
+    *output << "pseudopotpath\t" << config::pseudopotpath << "\t# where to find pseudopotentials" << endl;
+    *output << endl;
+    *output << "ProcPEGamma\t" << config::ProcPEGamma << "\t# for parallel computing: share constants" << endl;
+    *output << "ProcPEPsi\t" << config::ProcPEPsi << "\t# for parallel computing: share wave functions" << endl;
+    *output << "DoOutVis\t" << config::DoOutVis << "\t# Output data for OpenDX" << endl;
+    *output << "DoOutMes\t" << config::DoOutMes << "\t# Output data for measurements" << endl;
+    *output << "DoOutOrbitals\t" << config::DoOutOrbitals << "\t# Output all Orbitals" << endl;
+    *output << "DoOutCurr\t" << config::DoOutCurrent << "\t# Ouput current density for OpenDx" << endl;
+    *output << "DoOutNICS\t" << config::DoOutNICS << "\t# Output Nucleus independent current shieldings" << endl;
+    *output << "DoPerturbation\t" << config::DoPerturbation << "\t# Do perturbation calculate and determine susceptibility and shielding" << endl;
+    *output << "DoFullCurrent\t" << config::DoFullCurrent << "\t# Do full perturbation" << endl;
+    *output << "DoConstrainedMD\t" << config::DoConstrainedMD << "\t# Do perform a constrained (>0, relating to current MD step) instead of unconstrained (0) MD" << endl;
+    *output << "Thermostat\t" << ThermostatNames[Thermostat] << "\t";
+    switch(Thermostat) {
+      default:
+      case None:
+        break;
+      case Woodcock:
+        *output << ScaleTempStep;
+        break;
+      case Gaussian:
+        *output << ScaleTempStep;
+        break;
+      case Langevin:
+        *output << TempFrequency << "\t" << alpha;
+        break;
+      case Berendsen:
+        *output << TempFrequency;
+        break;
+      case NoseHoover:
+        *output << HooverMass;
+        break;
+    };
+    *output << "\t# Which Thermostat and its parameters to use in MD case." << endl;
+    *output << "CommonWannier\t" << config::CommonWannier << "\t# Put virtual centers at indivual orbits, all common, merged by variance, to grid point, to cell center" << endl;
+    *output << "SawtoothStart\t" << config::SawtoothStart << "\t# Absolute value for smooth transition at cell border " << endl;
+    *output << "VectorPlane\t" << config::VectorPlane << "\t# Cut plane axis (x, y or z: 0,1,2) for two-dim current vector plot" << endl;
+    *output << "VectorCut\t" << config::VectorCut << "\t# Cut plane axis value" << endl;
+    *output << "AddGramSch\t" << config::UseAddGramSch << "\t# Additional GramSchmidtOrtogonalization to be safe" << endl;
+    *output << "Seed\t\t" << config::Seed << "\t# initial value for random seed for Psi coefficients" << endl;
+    *output << endl;
+    *output << "MaxOuterStep\t" << config::MaxOuterStep << "\t# number of MolecularDynamics/Structure optimization steps" << endl;
+    *output << "Deltat\t" << config::Deltat << "\t# time per MD step" << endl;
+    *output << "OutVisStep\t" << config::OutVisStep << "\t# Output visual data every ...th step" << endl;
+    *output << "OutSrcStep\t" << config::OutSrcStep << "\t# Output \"restart\" data every ..th step" << endl;
+    *output << "TargetTemp\t" << config::TargetTemp << "\t# Target temperature" << endl;
+    *output << "MaxPsiStep\t" << config::MaxPsiStep << "\t# number of Minimisation steps per state (0 - default)" << endl;
+    *output << "EpsWannier\t" << config::EpsWannier << "\t# tolerance value for spread minimisation of orbitals" << endl;
+    *output << endl;
+    *output << "# Values specifying when to stop" << endl;
+    *output << "MaxMinStep\t" << config::MaxMinStep << "\t# Maximum number of steps" << endl;
+    *output << "RelEpsTotalE\t" << config::RelEpsTotalEnergy << "\t# relative change in total energy" << endl;
+    *output << "RelEpsKineticE\t" << config::RelEpsKineticEnergy << "\t# relative change in kinetic energy" << endl;
+    *output << "MaxMinStopStep\t" << config::MaxMinStopStep << "\t# check every ..th steps" << endl;
+    *output << "MaxMinGapStopStep\t" << config::MaxMinGapStopStep << "\t# check every ..th steps" << endl;
+    *output << endl;
+    *output << "# Values specifying when to stop for INIT, otherwise same as above" << endl;
+    *output << "MaxInitMinStep\t" << config::MaxInitMinStep << "\t# Maximum number of steps" << endl;
+    *output << "InitRelEpsTotalE\t" << config::InitRelEpsTotalEnergy << "\t# relative change in total energy" << endl;
+    *output << "InitRelEpsKineticE\t" << config::InitRelEpsKineticEnergy << "\t# relative change in kinetic energy" << endl;
+    *output << "InitMaxMinStopStep\t" << config::InitMaxMinStopStep << "\t# check every ..th steps" << endl;
+    *output << "InitMaxMinGapStopStep\t" << config::InitMaxMinGapStopStep << "\t# check every ..th steps" << endl;
+    *output << endl;
+    *output << "BoxLength\t\t\t# (Length of a unit cell)" << endl;
+    *output << mol->cell_size[0] << "\t" << endl;
+    *output << mol->cell_size[1] << "\t" << mol->cell_size[2] << "\t" << endl;
+    *output << mol->cell_size[3] << "\t" << mol->cell_size[4] << "\t" << mol->cell_size[5] << "\t" << endl;
+    // FIXME
+    *output << endl;
+    *output << "ECut\t\t" << config::ECut << "\t# energy cutoff for discretization in Hartrees" << endl;
+    *output << "MaxLevel\t" << config::MaxLevel << "\t# number of different levels in the code, >=2" << endl;
+    *output << "Level0Factor\t" << config::Lev0Factor << "\t# factor by which node number increases from S to 0 level" << endl;
+    *output << "RiemannTensor\t" << config::RiemannTensor << "\t# (Use metric)" << endl;
+    switch (config::RiemannTensor) {
+      case 0: //UseNoRT
+        break;
+      case 1: // UseRT
+        *output << "RiemannLevel\t" << config::RiemannLevel << "\t# Number of Riemann Levels" << endl;
+        *output << "LevRFactor\t" << config::LevRFactor << "\t# factor by which node number increases from 0 to R level from" << endl;
+        break;
+    }
+    *output << "PsiType\t\t" << config::PsiType << "\t# 0 - doubly occupied, 1 - SpinUp,SpinDown" << endl;
+    // write out both types for easier changing afterwards
+  //  switch (PsiType) {
+  //    case 0:
+        *output << "MaxPsiDouble\t" << config::MaxPsiDouble << "\t# here: specifying both maximum number of SpinUp- and -Down-states" << endl;
+  //      break;
+  //    case 1:
+        *output << "PsiMaxNoUp\t" << config::PsiMaxNoUp << "\t# here: specifying maximum number of SpinUp-states" << endl;
+        *output << "PsiMaxNoDown\t" << config::PsiMaxNoDown << "\t# here: specifying maximum number of SpinDown-states" << endl;
+  //      break;
+  //  }
+    *output << "AddPsis\t\t" << config::AddPsis << "\t# Additional unoccupied Psis for bandgap determination" << endl;
+    *output << endl;
+    *output << "RCut\t\t" << config::RCut << "\t# R-cut for the ewald summation" << endl;
+    *output << "StructOpt\t" << config::StructOpt << "\t# Do structure optimization beforehand" << endl;
+    *output << "IsAngstroem\t" << config::IsAngstroem << "\t# 0 - Bohr, 1 - Angstroem" << endl;
+    *output << "RelativeCoord\t" << config::RelativeCoord << "\t# whether ion coordinates are relative (1) or absolute (0)" << endl;
+    *output << "MaxTypes\t" << mol->ElementCount <<  "\t# maximum number of different ion types" << endl;
+    *output << endl;
+    result = result && mol->Checkout(output);
+    if (mol->MDSteps <=1 )
+      result = result && mol->Output(output);
+    else
+      result = result && mol->OutputTrajectories(output);
+    output->close();
+    output->clear();
+    delete(output);
+    return result;
+  } else
+    return false;
 };
 …
 bool config::SaveMPQC(const char *filename, molecule *mol) const
+{
         int ElementNo = 0;
         int AtomNo;
         atom *Walker = NULL;
         element *runner = NULL;
         Vector *center = NULL;
         ofstream *output = NULL;
         stringstream *fname = NULL;
         // first without hessian
         fname = new stringstream;
         *fname << filename << ".in";
         output = new ofstream(fname->str().c_str(), ios::out);
         *output << "% Created by MoleCuilder" << endl;
         *output << "mpqc: (" << endl;
         *output << "\tsavestate = no" << endl;
         *output << "\tdo_gradient = yes" << endl;
         *output << "\tmole<MBPT2>: (" << endl;
         *output << "\t\tmaxiter = 200" << endl;
         *output << "\t\tbasis = $:basis" << endl;
         *output << "\t\tmolecule = $:molecule" << endl;
         *output << "\t\treference<CLHF>: (" << endl;
         *output << "\t\t\tbasis = $:basis" << endl;
         *output << "\t\t\tmolecule = $:molecule" << endl;
         *output << "\t\t)" << endl;
         *output << "\t)" << endl;
         *output << ")" << endl;
         *output << "molecule<Molecule>: (" << endl;
         *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
         *output << "\t{ atoms geometry } = {" << endl;
         center = mol->DetermineCenterOfAll(output);
         // output of atoms
         runner = mol->elemente->start;
         while (runner->next != mol->elemente->end) { // go through every element
                 runner = runner->next;
                 if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
                         ElementNo++;
                         AtomNo = 0;
                         Walker = mol->start;
                         while (Walker->next != mol->end) { // go through every atom of this element
                                 Walker = Walker->next;
                                 if (Walker->type == runner) { // if this atom fits to element
                                         AtomNo++;
                                         *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+                                }
+                        }
+                }
+        }
         delete(center);
         *output << "\t}" << endl;
         *output << ")" << endl;
         *output << "basis<GaussianBasisSet>: (" << endl;
         *output << "\tname = \""<< basis << "\"" << endl;
         *output << "\tmolecule = $:molecule" << endl;
         *output << ")" << endl;
         output->close();
         delete(output);
         delete(fname);
         // second with hessian
         fname = new stringstream;
         *fname << filename << ".hess.in";
         output = new ofstream(fname->str().c_str(), ios::out);
         *output << "% Created by MoleCuilder" << endl;
         *output << "mpqc: (" << endl;
         *output << "\tsavestate = no" << endl;
         *output << "\tdo_gradient = yes" << endl;
         *output << "\tmole<CLHF>: (" << endl;
         *output << "\t\tmaxiter = 200" << endl;
         *output << "\t\tbasis = $:basis" << endl;
         *output << "\t\tmolecule = $:molecule" << endl;
         *output << "\t)" << endl;
         *output << "\tfreq<MolecularFrequencies>: (" << endl;
         *output << "\t\tmolecule=$:molecule" << endl;
         *output << "\t)" << endl;
         *output << ")" << endl;
         *output << "molecule<Molecule>: (" << endl;
         *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
         *output << "\t{ atoms geometry } = {" << endl;
         center = mol->DetermineCenterOfAll(output);
         // output of atoms
         runner = mol->elemente->start;
         while (runner->next != mol->elemente->end) { // go through every element
                 runner = runner->next;
                 if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
                         ElementNo++;
                         AtomNo = 0;
                         Walker = mol->start;
                         while (Walker->next != mol->end) { // go through every atom of this element
                                 Walker = Walker->next;
                                 if (Walker->type == runner) { // if this atom fits to element
                                         AtomNo++;
                                         *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+                                }
+                        }
+                }
+        }
         delete(center);
         *output << "\t}" << endl;
         *output << ")" << endl;
         *output << "basis<GaussianBasisSet>: (" << endl;
         *output << "\tname = \"3-21G\"" << endl;
         *output << "\tmolecule = $:molecule" << endl;
         *output << ")" << endl;
         output->close();
         delete(output);
         delete(fname);
         return true;
+  int ElementNo = 0;
+  int AtomNo;
+  atom *Walker = NULL;
+  element *runner = NULL;
+  Vector *center = NULL;
+  ofstream *output = NULL;
+  stringstream *fname = NULL;
+  // first without hessian
+  fname = new stringstream;
+  *fname << filename << ".in";
+  output = new ofstream(fname->str().c_str(), ios::out);
+  *output << "% Created by MoleCuilder" << endl;
+  *output << "mpqc: (" << endl;
+  *output << "\tsavestate = no" << endl;
+  *output << "\tdo_gradient = yes" << endl;
+  *output << "\tmole<MBPT2>: (" << endl;
+  *output << "\t\tmaxiter = 200" << endl;
+  *output << "\t\tbasis = $:basis" << endl;
+  *output << "\t\tmolecule = $:molecule" << endl;
+  *output << "\t\treference<CLHF>: (" << endl;
+  *output << "\t\t\tbasis = $:basis" << endl;
+  *output << "\t\t\tmolecule = $:molecule" << endl;
+  *output << "\t\t)" << endl;
+  *output << "\t)" << endl;
+  *output << ")" << endl;
+  *output << "molecule<Molecule>: (" << endl;
+  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+  *output << "\t{ atoms geometry } = {" << endl;
+  center = mol->DetermineCenterOfAll(output);
+  // output of atoms
+  runner = mol->elemente->start;
+  while (runner->next != mol->elemente->end) { // go through every element
+    runner = runner->next;
+    if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      ElementNo++;
+      AtomNo = 0;
+      Walker = mol->start;
+      while (Walker->next != mol->end) { // go through every atom of this element
+        Walker = Walker->next;
+        if (Walker->type == runner) { // if this atom fits to element
+          AtomNo++;
+          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+        }
+      }
+    }
+  }
+  delete(center);
+  *output << "\t}" << endl;
+  *output << ")" << endl;
+  *output << "basis<GaussianBasisSet>: (" << endl;
+  *output << "\tname = \"" << basis << "\"" << endl;
+  *output << "\tmolecule = $:molecule" << endl;
+  *output << ")" << endl;
+  output->close();
+  delete(output);
+  delete(fname);
+  // second with hessian
+  fname = new stringstream;
+  *fname << filename << ".hess.in";
+  output = new ofstream(fname->str().c_str(), ios::out);
+  *output << "% Created by MoleCuilder" << endl;
+  *output << "mpqc: (" << endl;
+  *output << "\tsavestate = no" << endl;
+  *output << "\tdo_gradient = yes" << endl;
+  *output << "\tmole<CLHF>: (" << endl;
+  *output << "\t\tmaxiter = 200" << endl;
+  *output << "\t\tbasis = $:basis" << endl;
+  *output << "\t\tmolecule = $:molecule" << endl;
+  *output << "\t)" << endl;
+  *output << "\tfreq<MolecularFrequencies>: (" << endl;
+  *output << "\t\tmolecule=$:molecule" << endl;
+  *output << "\t)" << endl;
+  *output << ")" << endl;
+  *output << "molecule<Molecule>: (" << endl;
+  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+  *output << "\t{ atoms geometry } = {" << endl;
+  center = mol->DetermineCenterOfAll(output);
+  // output of atoms
+  runner = mol->elemente->start;
+  while (runner->next != mol->elemente->end) { // go through every element
+    runner = runner->next;
+    if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      ElementNo++;
+      AtomNo = 0;
+      Walker = mol->start;
+      while (Walker->next != mol->end) { // go through every atom of this element
+        Walker = Walker->next;
+        if (Walker->type == runner) { // if this atom fits to element
+          AtomNo++;
+          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+        }
+      }
+    }
+  }
+  delete(center);
+  *output << "\t}" << endl;
+  *output << ")" << endl;
+  *output << "basis<GaussianBasisSet>: (" << endl;
+  *output << "\tname = \"3-21G\"" << endl;
+  *output << "\tmolecule = $:molecule" << endl;
+  *output << ")" << endl;
+  output->close();
+  delete(output);
+  delete(fname);
+  return true;
 };
 …
  * \param name Name of value in file (at least 3 chars!)
  * \param sequential 1 - do not reset file pointer to begin of file, 0 - set to beginning
  *                              (if file is sequentially parsed this can be way faster! However, beware of multiple values per line, as whole line is read -
  *                               best approach: 0 0 0 1 (not resetted only on last value of line) - and of yth, which is now
  *                               counted from this unresetted position!)
+ *        (if file is sequentially parsed this can be way faster! However, beware of multiple values per line, as whole line is read -
+ *         best approach: 0 0 0 1 (not resetted only on last value of line) - and of yth, which is now
+ *         counted from this unresetted position!)
  * \param xth Which among a number of parameters it is (in grid case it's row number as grid is read as a whole!)
  * \param yth In grid case specifying column number, otherwise the yth \a name matching line
 …
  */
 int config::ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical) {
         int i,j;        // loop variables
         int length = 0, maxlength = -1;
         long file_position = file->tellg(); // mark current position
         char *dummy1, *dummy, *free_dummy;              // pointers in the line that is read in per step
         dummy1 = free_dummy = (char *) Malloc(256 * sizeof(char), "config::ParseForParameter: *free_dummy");
         //fprintf(stderr,"Parsing for %s\n",name);
         if (repetition == 0)
                 //Error(SomeError, "ParseForParameter(): argument repetition must not be 0!");
                 return 0;
         int line = 0; // marks line where parameter was found
         int found = (type >= grid) ? 0 : (-yth + 1);    // marks if yth parameter name was found
         while((found != repetition)) {
                 dummy1 = dummy = free_dummy;
                 do {
                         file->getline(dummy1, 256); // Read the whole line
                         if (file->eof()) {
                                 if ((critical) && (found == 0)) {
                                         Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                         //Error(InitReading, name);
                                         fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
                                         exit(255);
                                 } else {
                                         //if (!sequential)
                                         file->clear();
                                         file->seekg(file_position, ios::beg);   // rewind to start position
                                         Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                         return 0;
+                                }
+                        }
                         line++;
                 } while (dummy != NULL && dummy1 != NULL && ((dummy1[0] == '#') || (dummy1[0] == '\0'))); // skip commentary and empty lines
                 // C++ getline removes newline at end, thus re-add
                 if ((dummy1 != NULL) && (strchr(dummy1,'\n') == NULL)) {
                         i = strlen(dummy1);
                         dummy1[i] = '\n';
                         dummy1[i+1] = '\0';
+                }
                 //fprintf(stderr,"line %i ends at %i, newline at %i\n", line, strlen(dummy1), strchr(dummy1,'\n')-free_dummy);
                 if (dummy1 == NULL) {
                         if (verbose) fprintf(stderr,"Error reading line %i\n",line);
                 } else {
                         //fprintf(stderr,"Now parsing the line %i: %s\n", line, dummy1);
+                }
                 // Seek for possible end of keyword on line if given ...
                 if (name != NULL) {
                         dummy = strchr(dummy1,'\t');    // set dummy on first tab or space which ever's nearer
                         if (dummy == NULL) {
                                 dummy = strchr(dummy1, ' ');    // if not found seek for space
                                 while ((dummy != NULL) && ((*dummy == '\t') || (*dummy == ' ')))                // skip some more tabs and spaces if necessary
                                         dummy++;
+                        }
                         if (dummy == NULL) {
                                 dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
                                 //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
                                 //Free((void **)&free_dummy);
                                 //Error(FileOpenParams, NULL);
                         } else {
                                 //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)dummy1);
+                        }
                 } else dummy = dummy1;
                 // ... and check if it is the keyword!
                 //fprintf(stderr,"name %p, dummy %i/%c, dummy1 %i/%c, strlen(name) %i\n", &name, dummy, *dummy, dummy1, *dummy1, strlen(name));
                 if ((name == NULL) || (((dummy-dummy1 >= 3) && (strncmp(dummy1, name, strlen(name)) == 0)) && ((unsigned int)(dummy-dummy1) == strlen(name)))) {
                         found++; // found the parameter!
                         //fprintf(stderr,"found %s at line %i between %i and %i\n", name, line, dummy1, dummy);
                         if (found == repetition) {
                                 for (i=0;i<xth;i++) { // i = rows
                                         if (type >= grid) {
                                                 // grid structure means that grid starts on the next line, not right after keyword
                                                 dummy1 = dummy = free_dummy;
                                                 do {
                                                         file->getline(dummy1, 256); // Read the whole line, skip commentary and empty ones
                                                         if (file->eof()) {
                                                                 if ((critical) && (found == 0)) {
                                                                         Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                                                         //Error(InitReading, name);
                                                                         fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
                                                                         exit(255);
                                                                 } else {
                                                                         //if (!sequential)
                                                                         file->clear();
                                                                         file->seekg(file_position, ios::beg);   // rewind to start position
                                                                         Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                                                         return 0;
+                                                                }
+                                                        }
                                                         line++;
                                                 } while ((dummy1[0] == '#') || (dummy1[0] == '\n'));
                                                 if (dummy1 == NULL){
                                                         if (verbose) fprintf(stderr,"Error reading line %i\n", line);
                                                 } else {
                                                         //fprintf(stderr,"Reading next line %i: %s\n", line, dummy1);
+                                                }
                                         } else { // simple int, strings or doubles start in the same line
                                                 while ((*dummy == '\t') || (*dummy == ' '))      // skip interjacent tabs and spaces
                                                         dummy++;
+                                        }
                                         // C++ getline removes newline at end, thus re-add
                                         if ((dummy1 != NULL) && (strchr(dummy1,'\n') == NULL)) {
                                                 j = strlen(dummy1);
                                                 dummy1[j] = '\n';
                                                 dummy1[j+1] = '\0';
+                                        }
                                         int start = (type >= grid) ? 0 : yth-1 ;
                                         for (j=start;j<yth;j++) { // j = columns
                                                 // check for lower triangular area and upper triangular area
                                                 if ( ((i > j) && (type == upper_trigrid)) || ((j > i) && (type == lower_trigrid))) {
                                                         *((double *)value) = 0.0;
                                                         fprintf(stderr,"%f\t",*((double *)value));
                                                         value = (void *)((long)value + sizeof(double));
                                                         //value += sizeof(double);
                                                 } else {
                                                         // otherwise we must skip all interjacent tabs and spaces and find next value
                                                         dummy1 = dummy;
                                                         dummy = strchr(dummy1, '\t'); // seek for tab or space
                                                         if (dummy == NULL)
                                                                 dummy = strchr(dummy1, ' ');    // if not found seek for space
                                                         if (dummy == NULL) { // if still zero returned ...
                                                                 dummy = strchr(dummy1, '\n');   // ... at line end then
                                                                 if ((j < yth-1) && (type < 4)) {        // check if xth value or not yet
                                                                         if (critical) {
                                                                                 if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
                                                                                 Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                                                                 //return 0;
                                                                                 exit(255);
                                                                                 //Error(FileOpenParams, NULL);
                                                                         } else {
                                                                                 //if (!sequential)
                                                                                 file->clear();
                                                                                 file->seekg(file_position, ios::beg);   // rewind to start position
                                                                                 Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                                                                 return 0;
+                                                                        }
+                                                                }
                                                         } else {
                                                                 //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)free_dummy);
+                                                        }
                                                         if (*dummy1 == '#') {
                                                                 // found comment, skipping rest of line
                                                                 //if (verbose) fprintf(stderr,"Error: '#' at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
                                                                 if (!sequential) { // here we need it!
                                                                         file->seekg(file_position, ios::beg);   // rewind to start position
+                                                                }
                                                                 Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
                                                                 return 0;
+                                                        }
                                                         //fprintf(stderr,"value from %i to %i\n",(char *)dummy1-(char *)free_dummy,(char *)dummy-(char *)free_dummy);
                                                         switch(type) {
                                                                 case (row_int):
                                                                         *((int *)value) = atoi(dummy1);
                                                                         if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
                                                                         if (verbose) fprintf(stderr,"%i\t",*((int *)value));
                                                                                 value = (void *)((long)value + sizeof(int));
                                                                                 //value += sizeof(int);
                                                                         break;
                                                                 case(row_double):
                                                                 case(grid):
                                                                 case(lower_trigrid):
                                                                 case(upper_trigrid):
                                                                         *((double *)value) = atof(dummy1);
                                                                         if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
                                                                         if (verbose) fprintf(stderr,"%lg\t",*((double *)value));
                                                                         value = (void *)((long)value + sizeof(double));
                                                                         //value += sizeof(double);
                                                                         break;
                                                                 case(double_type):
                                                                         *((double *)value) = atof(dummy1);
                                                                         if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %lg\n", name, *((double *) value));
                                                                         //value += sizeof(double);
                                                                         break;
                                                                 case(int_type):
                                                                         *((int *)value) = atoi(dummy1);
                                                                         if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %i\n", name, *((int *) value));
                                                                         //value += sizeof(int);
                                                                         break;
                                                                 default:
                                                                 case(string_type):
                                                                         if (value != NULL) {
                                                                                 //if (maxlength == -1) maxlength = strlen((char *)value); // get maximum size of string array
                                                                                 maxlength = MAXSTRINGSIZE;
                                                                                 length = maxlength > (dummy-dummy1) ? (dummy-dummy1) : maxlength; // cap at maximum
                                                                                 strncpy((char *)value, dummy1, length); // copy as much
                                                                                 ((char *)value)[length] = '\0'; // and set end marker
                                                                                 if ((verbose) && (i == xth-1)) fprintf(stderr,"%s is '%s' (%i chars)\n",name,((char *) value), length);
                                                                                 //value += sizeof(char);
                                                                         } else {
+                                                                        }
                                                                 break;
+                                                        }
+                                                }
                                                 while (*dummy == '\t')
                                                         dummy++;
+                                        }
+                                }
+                        }
+                }
+        }
         if ((type >= row_int) && (verbose)) fprintf(stderr,"\n");
         Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
         if (!sequential) {
                 file->clear();
                 file->seekg(file_position, ios::beg);   // rewind to start position
+        }
         //fprintf(stderr, "End of Parsing\n\n");
         return (found); // true if found, false if not
+  int i,j;  // loop variables
+  int length = 0, maxlength = -1;
+  long file_position = file->tellg(); // mark current position
+  char *dummy1, *dummy, *free_dummy;    // pointers in the line that is read in per step
+  dummy1 = free_dummy = (char *) Malloc(256 * sizeof(char), "config::ParseForParameter: *free_dummy");
+  //fprintf(stderr,"Parsing for %s\n",name);
+  if (repetition == 0)
+    //Error(SomeError, "ParseForParameter(): argument repetition must not be 0!");
+    return 0;
+  int line = 0; // marks line where parameter was found
+  int found = (type >= grid) ? 0 : (-yth + 1);  // marks if yth parameter name was found
+  while((found != repetition)) {
+    dummy1 = dummy = free_dummy;
+    do {
+      file->getline(dummy1, 256); // Read the whole line
+      if (file->eof()) {
+        if ((critical) && (found == 0)) {
+          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+          //Error(InitReading, name);
+          fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
+          exit(255);
+        } else {
+          //if (!sequential)
+          file->clear();
+          file->seekg(file_position, ios::beg);  // rewind to start position
+          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+          return 0;
+        }
+      }
+      line++;
+    } while (dummy != NULL && dummy1 != NULL && ((dummy1[0] == '#') || (dummy1[0] == '\0'))); // skip commentary and empty lines
+    // C++ getline removes newline at end, thus re-add
+    if ((dummy1 != NULL) && (strchr(dummy1,'\n') == NULL)) {
+      i = strlen(dummy1);
+      dummy1[i] = '\n';
+      dummy1[i+1] = '\0';
+    }
+    //fprintf(stderr,"line %i ends at %i, newline at %i\n", line, strlen(dummy1), strchr(dummy1,'\n')-free_dummy);
+    if (dummy1 == NULL) {
+      if (verbose) fprintf(stderr,"Error reading line %i\n",line);
+    } else {
+      //fprintf(stderr,"Now parsing the line %i: %s\n", line, dummy1);
+    }
+    // Seek for possible end of keyword on line if given ...
+    if (name != NULL) {
+      dummy = strchr(dummy1,'\t');  // set dummy on first tab or space which ever's nearer
+      if (dummy == NULL) {
+        dummy = strchr(dummy1, ' ');  // if not found seek for space
+        while ((dummy != NULL) && ((*dummy == '\t') || (*dummy == ' ')))    // skip some more tabs and spaces if necessary
+          dummy++;
+      }
+      if (dummy == NULL) {
+        dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
+        //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
+        //Free((void **)&free_dummy);
+        //Error(FileOpenParams, NULL);
+      } else {
+        //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)dummy1);
+      }
+    } else dummy = dummy1;
+    // ... and check if it is the keyword!
+    //fprintf(stderr,"name %p, dummy %i/%c, dummy1 %i/%c, strlen(name) %i\n", &name, dummy, *dummy, dummy1, *dummy1, strlen(name));
+    if ((name == NULL) || (((dummy-dummy1 >= 3) && (strncmp(dummy1, name, strlen(name)) == 0)) && ((unsigned int)(dummy-dummy1) == strlen(name)))) {
+      found++; // found the parameter!
+      //fprintf(stderr,"found %s at line %i between %i and %i\n", name, line, dummy1, dummy);
+      if (found == repetition) {
+        for (i=0;i<xth;i++) { // i = rows
+          if (type >= grid) {
+            // grid structure means that grid starts on the next line, not right after keyword
+            dummy1 = dummy = free_dummy;
+            do {
+              file->getline(dummy1, 256); // Read the whole line, skip commentary and empty ones
+              if (file->eof()) {
+                if ((critical) && (found == 0)) {
+                  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                  //Error(InitReading, name);
+                  fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
+                  exit(255);
+                } else {
+                  //if (!sequential)
+                  file->clear();
+                  file->seekg(file_position, ios::beg);  // rewind to start position
+                  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                  return 0;
+                }
+              }
+              line++;
+            } while ((dummy1[0] == '#') || (dummy1[0] == '\n'));
+            if (dummy1 == NULL){
+              if (verbose) fprintf(stderr,"Error reading line %i\n", line);
+            } else {
+              //fprintf(stderr,"Reading next line %i: %s\n", line, dummy1);
+            }
+          } else { // simple int, strings or doubles start in the same line
+            while ((*dummy == '\t') || (*dummy == ' '))   // skip interjacent tabs and spaces
+              dummy++;
+          }
+          // C++ getline removes newline at end, thus re-add
+          if ((dummy1 != NULL) && (strchr(dummy1,'\n') == NULL)) {
+            j = strlen(dummy1);
+            dummy1[j] = '\n';
+            dummy1[j+1] = '\0';
+          }
+          int start = (type >= grid) ? 0 : yth-1 ;
+          for (j=start;j<yth;j++) { // j = columns
+            // check for lower triangular area and upper triangular area
+            if ( ((i > j) && (type == upper_trigrid)) || ((j > i) && (type == lower_trigrid))) {
+              *((double *)value) = 0.0;
+              fprintf(stderr,"%f\t",*((double *)value));
+              value = (void *)((long)value + sizeof(double));
+              //value += sizeof(double);
+            } else {
+              // otherwise we must skip all interjacent tabs and spaces and find next value
+              dummy1 = dummy;
+              dummy = strchr(dummy1, '\t'); // seek for tab or space
+              if (dummy == NULL)
+                dummy = strchr(dummy1, ' ');  // if not found seek for space
+              if (dummy == NULL) { // if still zero returned ...
+                dummy = strchr(dummy1, '\n');  // ... at line end then
+                if ((j < yth-1) && (type < 4)) {  // check if xth value or not yet
+                  if (critical) {
+                    if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
+                    Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                    //return 0;
+                    exit(255);
+                    //Error(FileOpenParams, NULL);
+                  } else {
+                    //if (!sequential)
+                    file->clear();
+                    file->seekg(file_position, ios::beg);  // rewind to start position
+                    Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                    return 0;
+                  }
+                }
+              } else {
+                //fprintf(stderr,"found tab at %i\n",(char *)dummy-(char *)free_dummy);
+              }
+              if (*dummy1 == '#') {
+                // found comment, skipping rest of line
+                //if (verbose) fprintf(stderr,"Error: '#' at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
+                if (!sequential) { // here we need it!
+                  file->seekg(file_position, ios::beg);  // rewind to start position
+                }
+                Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                return 0;
+              }
+              //fprintf(stderr,"value from %i to %i\n",(char *)dummy1-(char *)free_dummy,(char *)dummy-(char *)free_dummy);
+              switch(type) {
+                case (row_int):
+                  *((int *)value) = atoi(dummy1);
+                  if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
+                  if (verbose) fprintf(stderr,"%i\t",*((int *)value));
+                    value = (void *)((long)value + sizeof(int));
+                    //value += sizeof(int);
+                  break;
+                case(row_double):
+                case(grid):
+                case(lower_trigrid):
+                case(upper_trigrid):
+                  *((double *)value) = atof(dummy1);
+                  if ((verbose) && (i==0) && (j==0)) fprintf(stderr,"%s = ", name);
+                  if (verbose) fprintf(stderr,"%lg\t",*((double *)value));
+                  value = (void *)((long)value + sizeof(double));
+                  //value += sizeof(double);
+                  break;
+                case(double_type):
+                  *((double *)value) = atof(dummy1);
+                  if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %lg\n", name, *((double *) value));
+                  //value += sizeof(double);
+                  break;
+                case(int_type):
+                  *((int *)value) = atoi(dummy1);
+                  if ((verbose) && (i == xth-1)) fprintf(stderr,"%s = %i\n", name, *((int *) value));
+                  //value += sizeof(int);
+                  break;
+                default:
+                case(string_type):
+                  if (value != NULL) {
+                    //if (maxlength == -1) maxlength = strlen((char *)value); // get maximum size of string array
+                    maxlength = MAXSTRINGSIZE;
+                    length = maxlength > (dummy-dummy1) ? (dummy-dummy1) : maxlength; // cap at maximum
+                    strncpy((char *)value, dummy1, length);  // copy as much
+                    ((char *)value)[length] = '\0';  // and set end marker
+                    if ((verbose) && (i == xth-1)) fprintf(stderr,"%s is '%s' (%i chars)\n",name,((char *) value), length);
+                    //value += sizeof(char);
+                  } else {
+                  }
+                break;
+              }
+            }
+            while (*dummy == '\t')
+              dummy++;
+          }
+        }
+      }
+    }
+  }
+  if ((type >= row_int) && (verbose)) fprintf(stderr,"\n");
+  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+  if (!sequential) {
+    file->clear();
+    file->seekg(file_position, ios::beg);  // rewind to start position
+  }
+  //fprintf(stderr, "End of Parsing\n\n");
+  return (found); // true if found, false if not
+}

src/datacreator.cpp

-              r375b458
+              r51c910
 bool OpenOutputFile(ofstream &output, const char *dir, const char *filename)
+{
         stringstream name;
         name << dir << "/" << filename;
         output.open(name.str().c_str(), ios::out);
         if (output == NULL) {
                 cout << "Unable to open " << name.str() << " for writing, is directory correct?" << endl;
                 return false;
+        }
         return true;
+  stringstream name;
+  name << dir << "/" << filename;
+  output.open(name.str().c_str(), ios::out);
+  if (output == NULL) {
+    cout << "Unable to open " << name.str() << " for writing, is directory correct?" << endl;
+    return false;
+  }
+  return true;
 };
 …
 bool AppendOutputFile(ofstream &output, const char *dir, const char *filename)
+{
         stringstream name;
         name << dir << "/" << filename;
         output.open(name.str().c_str(), ios::app);
         if (output == NULL) {
                 cout << "Unable to open " << name.str() << " for writing, is directory correct?" << endl;
                 return false;
+        }
         return true;
+  stringstream name;
+  name << dir << "/" << filename;
+  output.open(name.str().c_str(), ios::app);
+  if (output == NULL) {
+    cout << "Unable to open " << name.str() << " for writing, is directory correct?" << endl;
+    return false;
+  }
+  return true;
 };
 …
 bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
                         for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
                                 for(int k=Fragments.ColumnCounter;k--;)
                                         Fragments.Matrix[Fragments.MatrixCounter][j][k] += Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+                }
                 output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
                 for (int l=0;l<Fragments.ColumnCounter;l++)
                         output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
+      for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
+        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
+          Fragments.Matrix[Fragments.MatrixCounter][j][k] += Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+    }
+    output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+      output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
         Fragments.SetLastMatrix(Energy.Matrix[Energy.MatrixCounter],0);
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
                         for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
                                 for(int k=Fragments.ColumnCounter;k--;)
                                         Fragments.Matrix[Fragments.MatrixCounter][j][k] -= Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+                }
                 output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
                 for (int l=0;l<Fragments.ColumnCounter;l++)
                         if (fabs(Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]) < MYEPSILON)
                                 output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
                         else
                                 output << scientific << "\t" << (Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l] / Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]);
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  Fragments.SetLastMatrix(Energy.Matrix[Energy.MatrixCounter],0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
+      for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
+        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
+          Fragments.Matrix[Fragments.MatrixCounter][j][k] -= Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+    }
+    output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
+    for (int l=0;l<Fragments.ColumnCounter[Energy.MatrixCounter];l++)
+      if (fabs(Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]) < MYEPSILON)
+        output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
+      else
+        output << scientific << "\t" << (Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l] / Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]);
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int))
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
         Fragments.SetLastMatrix(0.,0);
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
                 output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
                 CreateForce(Fragments, Fragments.MatrixCounter);
                 for (int l=0;l<Fragments.ColumnCounter;l++)
                          output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  Fragments.SetLastMatrix(0.,0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
+    output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
+    CreateForce(Fragments, Fragments.MatrixCounter);
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+       output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int))
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
         Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter],0);
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
                 output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
                 CreateForce(Fragments, Fragments.MatrixCounter);
                 for (int l=0;l<Fragments.ColumnCounter;l++)
                          output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter],0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
+    output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
+    CreateForce(Fragments, Fragments.MatrixCounter);
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+       output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
         stringstream filename;
         ofstream output;
         double norm = 0.;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "# AtomNo\t" << Fragments.Header << endl;
         Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 //cout << "Current order is " << BondOrder << "." << endl;
                 Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
                 // errors per atom
                 output << endl << "#Order\t" << BondOrder+1 << endl;
                 for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
                         output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
                         for (int l=0;l<Fragments.ColumnCounter;l++) {
                                 if (((l+1) % 3) == 0) {
                                         norm = 0.;
                                         for (int m=0;m<NDIM;m++)
                                                 norm += Force.Matrix[Force.MatrixCounter][ j ][l+m]*Force.Matrix[Force.MatrixCounter][ j ][l+m];
                                         norm = sqrt(norm);
+                                }
 //                              if (norm < MYEPSILON)
                                         output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
 //                              else
 //                                      output << scientific << (Fragments.Matrix[Fragments.MatrixCounter][ j ][l] / norm) << "\t";
+                        }
                         output << endl;
+                }
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  double norm = 0.;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    //cout << "Current order is " << BondOrder << "." << endl;
+    Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
+    // errors per atom
+    output << endl << "#Order\t" << BondOrder+1 << endl;
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
+        if (((l+1) % 3) == 0) {
+          norm = 0.;
+          for (int m=0;m<NDIM;m++)
+            norm += Force.Matrix[Force.MatrixCounter][ j ][l+m]*Force.Matrix[Force.MatrixCounter][ j ][l+m];
+          norm = sqrt(norm);
+        }
+//        if (norm < MYEPSILON)
+          output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
+//        else
+//          output << scientific << (Fragments.Matrix[Fragments.MatrixCounter][ j ][l] / norm) << "\t";
+      }
+      output << endl;
+    }
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+        stringstream filename;
+        ofstream output;
+        filename << prefix << ".dat";
+        if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+        cout << msg << endl;
+        output << "# " << msg << ", created on " << datum;
+        output << "# AtomNo\t" << Fragments.Header << endl;
+        for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+                //cout << "Current order is " << BondOrder << "." << endl;
+                Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
+                // errors per atom
+                output << endl << "#Order\t" << BondOrder+1 << endl;
+                for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+                        output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
+                        for (int l=0;l<Fragments.ColumnCounter;l++)
+                                output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
+                        output << endl;
+                }
+                output << endl;
+        }
+        output.close();
+        return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    //cout << "Current order is " << BondOrder << "." << endl;
+    Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
+    // errors per atom
+    output << endl << "#Order\t" << BondOrder+1 << endl;
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
+        output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
+      output << endl;
+    }
+    output << endl;
+  }
+  output.close();
+  return true;
+};
+/** Plot hessian error vs. vs atom vs. order.
+ * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
+ * \param &Fragments HessianMatrix class containing matrix values
+ * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
+ * \param *prefix prefix in filename (without ending)
+ * \param *msg message to be place in first line as a comment
+ * \param *datum current date and time
+ * \return true if file was written successfully
+ */
+bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    //cout << "Current order is " << BondOrder << "." << endl;
+    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
+    // errors per atom
+    output << endl << "#Order\t" << BondOrder+1 << endl;
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
+        output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
+      }
+      output << endl;
+    }
+    output << endl;
+  }
+  output.close();
+  return true;
+};
+/** Plot hessian error vs. vs atom vs. order in the frobenius norm.
+ * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
+ * \param &Fragments HessianMatrix class containing matrix values
+ * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
+ * \param *prefix prefix in filename (without ending)
+ * \param *msg message to be place in first line as a comment
+ * \param *datum current date and time
+ * \return true if file was written successfully
+ */
+bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+  double norm = 0;
+  double tmp;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# AtomNo\t";
+  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    output << "Order" << BondOrder+1 << "\t";
+  }
+  output << endl;
+  output << Fragments.RowCounter[ Fragments.MatrixCounter ] << "\t";
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    //cout << "Current order is " << BondOrder << "." << endl;
+    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
+    // frobenius norm of errors per atom
+    norm = 0.;
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
+        tmp = Fragments.Matrix[Fragments.MatrixCounter][ j ][l];
+        norm += tmp*tmp;
+      }
+    }
+    output << scientific << sqrt(norm)/(Fragments.RowCounter[ Fragments.MatrixCounter ]*Fragments.ColumnCounter[ Fragments.MatrixCounter] ) << "\t";
+  }
+  output << endl;
+  output.close();
+  return true;
+};
+/** Plot hessian error vs. vs atom vs. order.
+ * \param &Fragments HessianMatrix class containing matrix values
+ * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
+ * \param *prefix prefix in filename (without ending)
+ * \param *msg message to be place in first line as a comment
+ * \param *datum current date and time
+ * \return true if file was written successfully
+ */
+bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum)
+{
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "# AtomNo\t" << Fragments.Header[ Fragments.MatrixCounter ] << endl;
+  Fragments.SetLastMatrix(0., 0);
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    //cout << "Current order is " << BondOrder << "." << endl;
+    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, 1.);
+    // errors per atom
+    output << endl << "#Order\t" << BondOrder+1 << endl;
+    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
+        output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
+      output << endl;
+    }
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool CreateDataFragment(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragment)(class MatrixContainer &, int))
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum << endl;
         output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 for(int i=0;i<KeySet.FragmentsPerOrder[BondOrder];i++) {
                         output << BondOrder+1 << "\t" << KeySet.OrderSet[BondOrder][i]+1;
                         CreateFragment(Fragment, KeySet.OrderSet[BondOrder][i]);
                         for (int l=0;l<Fragment.ColumnCounter;l++)
                                 output << scientific << "\t" << Fragment.Matrix[ KeySet.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySet.OrderSet[BondOrder][i] ] ][l];
                         output << endl;
+                }
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum << endl;
+  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    for(int i=0;i<KeySet.FragmentsPerOrder[BondOrder];i++) {
+      output << BondOrder+1 << "\t" << KeySet.OrderSet[BondOrder][i]+1;
+      CreateFragment(Fragment, KeySet.OrderSet[BondOrder][i]);
+      for (int l=0;l<Fragment.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];l++)
+        output << scientific << "\t" << Fragment.Matrix[ KeySet.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySet.OrderSet[BondOrder][i] ] ][l];
+      output << endl;
+    }
+  }
+  output.close();
+  return true;
 };
 …
 void CreateMaxFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
+{
         for(int j=Fragments.RowCounter[ Fragments.MatrixCounter ];j--;) {
                 for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
                         if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
                                 for (int k=Fragments.ColumnCounter;k--;)
                                         Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+                        }
+                }
+        }
+  for(int j=Fragments.RowCounter[ Fragments.MatrixCounter ];j--;) {
+    for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
+      if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
+        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+          Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+      }
+    }
+  }
 };
 …
 void CreateMinFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
+{
         for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
                 int i=0;
                 do {    // first get a minimum value unequal to 0
                         for (int k=Fragments.ColumnCounter;k--;)
                                 Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
                         i++;
                 } while ((fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < MYEPSILON) && (i<KeySet.FragmentsPerOrder[BondOrder]));
                 for(;i<KeySet.FragmentsPerOrder[BondOrder];i++) { // then find lowest
                         if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) > fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
                                 for (int k=Fragments.ColumnCounter;k--;)
                                         Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+                        }
+                }
+        }
+  for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
+    int i=0;
+    do {  // first get a minimum value unequal to 0
+      for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+        Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+      i++;
+    } while ((fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < MYEPSILON) && (i<KeySet.FragmentsPerOrder[BondOrder]));
+    for(;i<KeySet.FragmentsPerOrder[BondOrder];i++) { // then find lowest
+      if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) > fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
+        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+          Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+      }
+    }
+  }
 };
 …
 bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int))
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".dat";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         cout << msg << endl;
         output << "# " << msg << ", created on " << datum;
         output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
         // max
         for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
                 Fragment.SetLastMatrix(0.,0);
                 CreateFragmentOrder(Fragment, KeySet, BondOrder);
                 output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
                 for (int l=0;l<Fragment.ColumnCounter;l++)
                         output << scientific << "\t" << Fragment.Matrix[ Fragment.MatrixCounter ][ Fragment.RowCounter[ Fragment.MatrixCounter ]-1 ][l];
                 output << endl;
+        }
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".dat";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  cout << msg << endl;
+  output << "# " << msg << ", created on " << datum;
+  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
+  // max
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    Fragment.SetLastMatrix(0.,0);
+    CreateFragmentOrder(Fragment, KeySet, BondOrder);
+    output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
+    for (int l=0;l<Fragment.ColumnCounter[ Fragment.MatrixCounter ];l++)
+      output << scientific << "\t" << Fragment.Matrix[ Fragment.MatrixCounter ][ Fragment.RowCounter[ Fragment.MatrixCounter ]-1 ][l];
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 void CreateEnergy(class MatrixContainer &Energy, int MatrixNumber)
+{
         for(int k=0;k<Energy.ColumnCounter;k++)
                 Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber] ] [k] =    Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber]-1 ] [k];
+  for(int k=0;k<Energy.ColumnCounter[MatrixNumber];k++)
+    Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber] ] [k] =  Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber]-1 ] [k];
 };
 …
 void CreateMinimumForce(class MatrixContainer &Force, int MatrixNumber)
+{
         for (int l=Force.ColumnCounter;l--;)
                 Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
         for (int l=5;l<Force.ColumnCounter;l+=3) {
                 double stored = 0;
                 int k=0;
                 do {
                         for (int m=NDIM;m--;) {
                                 stored += Force.Matrix[MatrixNumber][ k ][l+m]
                                                         * Force.Matrix[MatrixNumber][ k ][l+m];
                                 Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]       = Force.Matrix[MatrixNumber][ k ][l+m];
+                        }
                         k++;
                 } while ((fabs(stored) < MYEPSILON) && (k<Force.RowCounter[MatrixNumber]));
                 for (;k<Force.RowCounter[MatrixNumber];k++) {
                         double tmp = 0;
                         for (int m=NDIM;m--;)
                                 tmp += Force.Matrix[MatrixNumber][ k ][l+m]
                                                         * Force.Matrix[MatrixNumber][ k ][l+m];
                         if ((fabs(tmp) > MYEPSILON) && (tmp < stored)) {        // current force is greater than stored
                                 for (int m=NDIM;m--;)
                                         Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]       = Force.Matrix[MatrixNumber][ k ][l+m];
                                 stored = tmp;
+                        }
+                }
+        }
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+    Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+    double stored = 0;
+    int k=0;
+    do {
+      for (int m=NDIM;m--;) {
+        stored += Force.Matrix[MatrixNumber][ k ][l+m]
+              * Force.Matrix[MatrixNumber][ k ][l+m];
+        Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
+      }
+      k++;
+    } while ((fabs(stored) < MYEPSILON) && (k<Force.RowCounter[MatrixNumber]));
+    for (;k<Force.RowCounter[MatrixNumber];k++) {
+      double tmp = 0;
+      for (int m=NDIM;m--;)
+        tmp += Force.Matrix[MatrixNumber][ k ][l+m]
+              * Force.Matrix[MatrixNumber][ k ][l+m];
+      if ((fabs(tmp) > MYEPSILON) && (tmp < stored)) {  // current force is greater than stored
+        for (int m=NDIM;m--;)
+          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
+        stored = tmp;
+      }
+    }
+  }
 };
 …
  * Results are stored in the matrix ForceMatrix::MatrixCounter of \a Force.
  * \param Force ForceMatrix class containing matrix values
         * \param MatrixNumber the index for the ForceMatrix::matrix array
+  * \param MatrixNumber the index for the ForceMatrix::matrix array
  */
 void CreateMeanForce(class MatrixContainer &Force, int MatrixNumber)
+{
         int divisor = 0;
         for (int l=Force.ColumnCounter;l--;)
                 Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
         for (int l=5;l<Force.ColumnCounter;l+=3) {
                 double tmp = 0;
                 for (int k=Force.RowCounter[MatrixNumber];k--;) {
                         double norm = 0.;
                         for (int m=NDIM;m--;)
                                 norm += Force.Matrix[MatrixNumber][ k ][l+m]
                                                         * Force.Matrix[MatrixNumber][ k ][l+m];
                         tmp += sqrt(norm);
                         if (fabs(norm) > MYEPSILON) divisor++;
+                }
                 tmp /= (double)divisor;
                 Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = tmp;
+        }
+  int divisor = 0;
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+    Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+    double tmp = 0;
+    for (int k=Force.RowCounter[MatrixNumber];k--;) {
+      double norm = 0.;
+      for (int m=NDIM;m--;)
+        norm += Force.Matrix[MatrixNumber][ k ][l+m]
+              * Force.Matrix[MatrixNumber][ k ][l+m];
+      tmp += sqrt(norm);
+      if (fabs(norm) > MYEPSILON) divisor++;
+    }
+    tmp /= (double)divisor;
+    Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = tmp;
+  }
 };
 …
 void CreateMaximumForce(class MatrixContainer &Force, int MatrixNumber)
+{
         for (int l=5;l<Force.ColumnCounter;l+=3) {
                 double stored = 0;
                 for (int k=Force.RowCounter[MatrixNumber];k--;) {
                         double tmp = 0;
                         for (int m=NDIM;m--;)
                                 tmp += Force.Matrix[MatrixNumber][ k ][l+m]
                                                         * Force.Matrix[MatrixNumber][ k ][l+m];
                         if (tmp > stored) {     // current force is greater than stored
                                 for (int m=NDIM;m--;)
                                         Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]       = Force.Matrix[MatrixNumber][ k ][l+m];
                                 stored = tmp;
+                        }
+                }
+        }
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+    double stored = 0;
+    for (int k=Force.RowCounter[MatrixNumber];k--;) {
+      double tmp = 0;
+      for (int m=NDIM;m--;)
+        tmp += Force.Matrix[MatrixNumber][ k ][l+m]
+              * Force.Matrix[MatrixNumber][ k ][l+m];
+      if (tmp > stored) {  // current force is greater than stored
+        for (int m=NDIM;m--;)
+          Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l+m]  = Force.Matrix[MatrixNumber][ k ][l+m];
+        stored = tmp;
+      }
+    }
+  }
 };
 …
 void CreateSameForce(class MatrixContainer &Force, int MatrixNumber)
+{
         // does nothing
+  // does nothing
 };
 …
 void CreateVectorSumForce(class MatrixContainer &Force, int MatrixNumber)
+{
         for (int l=Force.ColumnCounter;l--;)
                 Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
         for (int l=0;l<Force.ColumnCounter;l++) {
                 for (int k=Force.RowCounter[MatrixNumber];k--;)
                         Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] += Force.Matrix[MatrixNumber][k][l];
+        }
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+    Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
+  for (int l=0;l<Force.ColumnCounter[MatrixNumber];l++) {
+    for (int k=Force.RowCounter[MatrixNumber];k--;)
+      Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] += Force.Matrix[MatrixNumber][k][l];
+  }
 };
 …
 void CreatePlotHeader(ofstream &output, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel)
+{
         //output << "#!/home/heber/build/pyxplot/pyxplot" << endl << endl;
         output << "reset" << endl;
         output << "set keycolumns "<< keycolumns << endl;
         output << "set key " << key << endl;
         output << "set mxtics "<< mxtics << endl;
         output << "set xtics "<< xtics << endl;
         if (logscale != NULL)
                 output << "set logscale " << logscale << endl;
         if (extraline != NULL)
                 output << extraline << endl;
         output << "set xlabel '" << xlabel << "'" << endl;
         output << "set ylabel '" << ylabel << "'" << endl;
         output << "set terminal eps color" << endl;
         output << "set output '"<< prefix << ".eps'" << endl;
+  //output << "#!/home/heber/build/pyxplot/pyxplot" << endl << endl;
+  output << "reset" << endl;
+  output << "set keycolumns "<< keycolumns << endl;
+  output << "set key " << key << endl;
+  output << "set mxtics "<< mxtics << endl;
+  output << "set xtics "<< xtics << endl;
+  if (logscale != NULL)
+    output << "set logscale " << logscale << endl;
+  if (extraline != NULL)
+    output << extraline << endl;
+  output << "set xlabel '" << xlabel << "'" << endl;
+  output << "set ylabel '" << ylabel << "'" << endl;
+  output << "set terminal eps color" << endl;
+  output << "set output '"<< prefix << ".eps'" << endl;
 };
 …
 bool CreatePlotOrder(class MatrixContainer &Matrix, const class KeySetsContainer &KeySet, const char *dir, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel, const char *xrange, const char *yrange, const char *xargument, const char *uses, void (*CreatePlotLines)(ofstream &, class MatrixContainer &, const char *, const char *, const char *))
+{
         stringstream filename;
         ofstream output;
         filename << prefix << ".pyx";
         if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
         CreatePlotHeader(output, prefix, keycolumns, key, logscale, extraline, mxtics, xtics, xlabel, ylabel);
         output << "plot " << xrange << " " << yrange << " \\" << endl;
         CreatePlotLines(output, Matrix, prefix, xargument, uses);
         output.close();
         return true;
+  stringstream filename;
+  ofstream output;
+  filename << prefix << ".pyx";
+  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false;
+  CreatePlotHeader(output, prefix, keycolumns, key, logscale, extraline, mxtics, xtics, xlabel, ylabel);
+  output << "plot " << xrange << " " << yrange << " \\" << endl;
+  CreatePlotLines(output, Matrix, prefix, xargument, uses);
+  output.close();
+  return true;
 };
 …
 void AbsEnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Energy.Header);
         string token;
         getline(line, token, '\t');
         for (int i=2; i<= Energy.ColumnCounter;i++) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+2 << ")) " << uses;
                 if (i != (Energy.ColumnCounter))
                         output << ", \\";
                 output << endl;
+        }
+  stringstream line(Energy.Header[ Energy.MatrixCounter ]);
+  string token;
+  getline(line, token, '\t');
+  for (int i=2; i<= Energy.ColumnCounter[Energy.MatrixCounter];i++) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+2 << ")) " << uses;
+    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
+      output << ", \\";
+    output << endl;
+  }
 };
 …
 void EnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Energy.Header);
         string token;
         getline(line, token, '\t');
         for (int i=1; i<= Energy.ColumnCounter;i++) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":" << i+2 << " " << uses;
                 if (i != (Energy.ColumnCounter))
                         output << ", \\";
                 output << endl;
+        }
+  stringstream line(Energy.Header[Energy.MatrixCounter]);
+  string token;
+  getline(line, token, '\t');
+  for (int i=1; i<= Energy.ColumnCounter[Energy.MatrixCounter];i++) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":" << i+2 << " " << uses;
+    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
+      output << ", \\";
+    output << endl;
+  }
 };
 …
 void ForceMagnitudePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Force.Header);
         string token;
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 token.erase(token.length(), 1); // kill residual index char (the '0')
                 output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses;
                 if (i != (Force.ColumnCounter-1))
                         output << ", \\";
                 output << endl;
                 getline(line, token, '\t');
                 getline(line, token, '\t');
+        }
+  stringstream line(Force.Header[Force.MatrixCounter]);
+  string token;
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    token.erase(token.length(), 1);  // kill residual index char (the '0')
+    output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses;
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+      output << ", \\";
+    output << endl;
+    getline(line, token, '\t');
+    getline(line, token, '\t');
+  }
 };
 …
 void AbsFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Force.Header);
         string token;
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 token.erase(token.length(), 1); // kill residual index char (the '0')
                 output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+1 << ")) " << uses;
                 if (i != (Force.ColumnCounter-1))
                         output << ", \\";
                 output << endl;
                 getline(line, token, '\t');
                 getline(line, token, '\t');
+        }
+  stringstream line(Force.Header[Force.MatrixCounter]);
+  string token;
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    token.erase(token.length(), 1);  // kill residual index char (the '0')
+    output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+1 << ")) " << uses;
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+      output << ", \\";
+    output << endl;
+    getline(line, token, '\t');
+    getline(line, token, '\t');
+  }
 };
 …
 void BoxesForcePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Force.Header);
         char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
         string token;
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 token.erase(token.length(), 1); // kill residual index char (the '0')
                 output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses << " " << fillcolor[(i-7)/3];
                 if (i != (Force.ColumnCounter-1))
                         output << ", \\";
                 output << endl;
                 getline(line, token, '\t');
                 getline(line, token, '\t');
+        }
+  stringstream line(Force.Header[Force.MatrixCounter]);
+  char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  string token;
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    token.erase(token.length(), 1);  // kill residual index char (the '0')
+    output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses << " " << fillcolor[(i-7)/3];
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+      output << ", \\";
+    output << endl;
+    getline(line, token, '\t');
+    getline(line, token, '\t');
+  }
 };
 …
 void BoxesFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
+{
         stringstream line(Force.Header);
         char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
         string token;
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         getline(line, token, '\t');
         for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
                 getline(line, token, '\t');
                 while (token[0] == ' ') // remove leading white spaces
                         token.erase(0,1);
                 token.erase(token.length(), 1); // kill residual index char (the '0')
                 output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):" << i+1 << " " << uses << " " << fillcolor[(i-7)/3];
                 if (i != (Force.ColumnCounter-1))
                         output << ", \\";
                 output << endl;
                 getline(line, token, '\t');
                 getline(line, token, '\t');
+        }
 };
+  stringstream line(Force.Header[Force.MatrixCounter]);
+  char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  string token;
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  getline(line, token, '\t');
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+    getline(line, token, '\t');
+    while (token[0] == ' ') // remove leading white spaces
+      token.erase(0,1);
+    token.erase(token.length(), 1);  // kill residual index char (the '0')
+    output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):" << i+1 << " " << uses << " " << fillcolor[(i-7)/3];
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+      output << ", \\";
+    output << endl;
+    getline(line, token, '\t');
+    getline(line, token, '\t');
+  }
+};

src/datacreator.hpp

-              r375b458
+              r51c910
 bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
 bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
+bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
+bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
+bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
+bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
+bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
 bool CreateDataFragment(class MatrixContainer &ForceFragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
 bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int));

src/defs.hpp

-              r375b458
+              r51c910
 using namespace std;
+#define MYEPSILON 1e-13  //!< machine epsilon precision
+#define NDIM    3        //!< number of spatial dimensions
+#define MAX_ELEMENTS 128        //!< maximum number of elements for certain lookup tables
+#define AtomicLengthToAngstroem 0.52917721 //!< conversion factor from atomic length/bohrradius to angstroem
+#define BONDTHRESHOLD 0.5        //!< CSD threshold in bond check which is the width of the interval whose center is the sum of the covalent radii
+#define AtomicEnergyToKelvin 315774.67  //!< conversion factor from atomic energy to kelvin via boltzmann factor
+#define MYEPSILON 1e-13   //!< machine epsilon precision
+#define NDIM  3   //!< number of spatial dimensions
+#define MAX_ELEMENTS 128  //!< maximum number of elements for certain lookup tables
+#define AtomicLengthToAngstroem  0.52917721 //!< conversion factor from atomic length/bohrradius to angstroem
+#define BONDTHRESHOLD 0.5   //!< CSD threshold in bond check which is the width of the interval whose center is the sum of the covalent radii
+#define AtomicEnergyToKelvin 315774.67  //!< conversion factor from atomic energy to kelvin via boltzmann factor
+#define KelvinToAtomicTemperature 3.1668152e-06    //!< conversion factor for Kelvin to atomic temperature (Hartree over k_B)
+#define KelvinToeV 8.6173422e-05                   //!< conversion factor for Kelvin to Ht (k_B * T = energy), thus Boltzmann constant in eV/K
+#define AtomicMassUnitsToeV 931494088.        //!< conversion factor for atomic weight in units to mass in eV
+#define AtomicMassUnitsToHt 34480864.        //!< conversion factor for atomic weight in units to mass in Ht (protonmass/electronmass * electron_mass_in_Ht
+#define ElectronMass_Ht 18778.865            //!< electron mass in Ht
+#define ElectronMass_eV 510998.903           //!< electron mass in eV
+#define Units2Electronmass (AtomicMassUnitsToeV/ElectronMass_eV) //!< atomic mass unit in eV/ electron mass in eV = 1 822.88863
+#define Atomictime2Femtoseconds 0.024188843     //!< Atomictime in fs
 #define VERSIONSTRING "v1.0"
 …
 enum EdgeType { Undetermined, TreeEdge, BackEdge }; //!< edge type in a graph after Depth-First-Search analysis.
 enum Shading { white, lightgray, darkgray, black };     //!< color in Breadth-First-Search analysis
+enum Shading { white, lightgray, darkgray, black };  //!< color in Breadth-First-Search analysis
 //enum CutCyclicBond { KeepBond,        SaturateBond }; //!< Saturation scheme either atom- or bondwise
+//enum CutCyclicBond { KeepBond,  SaturateBond }; //!< Saturation scheme either atom- or bondwise
 // Specifting whether a value in the parameter file must be specified or is optional
 enum necessity { optional,              //!< parameter is optional, if not given sensible value is chosen
                                                                  critical                //!< parameter must be given or programme won't initiate
                                                          };
+enum necessity { optional,    //!< parameter is optional, if not given sensible value is chosen
+                 critical     //!< parameter must be given or programme won't initiate
+               };
 // Specifying the status of the on command line given config file
 …
 // various standard filenames
 #define DEFAULTCONFIG "main_pcp_linux"          //!< default filename of config file
 #define CONVEXENVELOPE "ConvexEnvelope.dat"             //!< default filename of convex envelope tecplot data file
 #define KEYSETFILE "KeySets.dat"                //!< default filename of BOSSANOVA key sets file
 #define ADJACENCYFILE "Adjacency.dat"           //!< default filename of BOSSANOVA adjacancy file
 #define TEFACTORSFILE "TE-Factors.dat"          //!< default filename of BOSSANOVA total energy factors file
 #define FORCESFILE "Forces-Factors.dat"         //!< default filename of BOSSANOVA force factors file
 #define HCORRECTIONSUFFIX "Hcorrection.dat"             //!< default filename of BOSSANOVA H correction file (unwanted saturation interaction)
 #define FITCONSTANTSUFFIX "FitConstant.dat"      //!< suffix of default filename of BOSSANOVA fit constants file (unwanted saturation interaction)
 #define SHIELDINGSUFFIX "sigma_all.csv"                                                         //!< default filename of BOSSANOVA shieldings file
 #define SHIELDINGPASSUFFIX "sigma_all_PAS.csv"                                                           //!< default filename of BOSSANOVA shieldings PAS file
 #define ORDERATSITEFILE "OrderAtSite.dat"               //!< default filename of BOSSANOVA Bond Order at each atom file
 #define ENERGYPERFRAGMENT "EnergyPerFragment"           //!< default filename of BOSSANOVA Energy contribution Per Fragment file
 #define FRAGMENTPREFIX "BondFragment"           //!< default filename prefix of BOSSANOVA fragment config and directories
 #define STANDARDCONFIG "unknown.conf"           //!< default filename of standard config file
 #define STANDARDELEMENTSDB "elements.db"                //!< default filename of elements data base with masses, Z, VanDerWaals radii, ...
 #define STANDARDVALENCEDB "valence.db"          //!< default filename of valence number per element database
 #define STANDARDORBITALDB "orbitals.db"         //!< default filename of orbitals per element database
 #define STANDARDHBONDDISTANCEDB "Hbonddistance.db"              //!< default filename of typial bond distance to hydrogen database
 #define STANDARDHBONDANGLEDB "Hbondangle.db"            //!< default filename of typial bond angle to hydrogen database
+#define DEFAULTCONFIG "main_pcp_linux"    //!< default filename of config file
+#define CONVEXENVELOPE "ConvexEnvelope.dat"    //!< default filename of convex envelope tecplot data file
+#define KEYSETFILE "KeySets.dat"    //!< default filename of BOSSANOVA key sets file
+#define ADJACENCYFILE "Adjacency.dat"    //!< default filename of BOSSANOVA adjacancy file
+#define TEFACTORSFILE "TE-Factors.dat"    //!< default filename of BOSSANOVA total energy factors file
+#define FORCESFILE "Forces-Factors.dat"    //!< default filename of BOSSANOVA force factors file
+#define HCORRECTIONSUFFIX "Hcorrection.dat"    //!< default filename of BOSSANOVA H correction file (unwanted saturation interaction)
+#define FITCONSTANTSUFFIX "FitConstant.dat"   //!< suffix of default filename of BOSSANOVA fit constants file (unwanted saturation interaction)
+#define SHIELDINGSUFFIX "sigma_all.csv"                //!< default filename of BOSSANOVA shieldings file
+#define SHIELDINGPASSUFFIX "sigma_all_PAS.csv"                 //!< default filename of BOSSANOVA shieldings PAS file
+#define ORDERATSITEFILE "OrderAtSite.dat"    //!< default filename of BOSSANOVA Bond Order at each atom file
+#define ENERGYPERFRAGMENT "EnergyPerFragment"    //!< default filename of BOSSANOVA Energy contribution Per Fragment file
+#define FRAGMENTPREFIX "BondFragment"    //!< default filename prefix of BOSSANOVA fragment config and directories
+#define STANDARDCONFIG "unknown.conf"    //!< default filename of standard config file
+#define STANDARDELEMENTSDB "elements.db"    //!< default filename of elements data base with masses, Z, VanDerWaals radii, ...
+#define STANDARDVALENCEDB "valence.db"    //!< default filename of valence number per element database
+#define STANDARDORBITALDB "orbitals.db"    //!< default filename of orbitals per element database
+#define STANDARDHBONDDISTANCEDB "Hbonddistance.db"    //!< default filename of typial bond distance to hydrogen database
+#define STANDARDHBONDANGLEDB "Hbondangle.db"    //!< default filename of typial bond angle to hydrogen database
 // some values
 …
 #define UPDATECOUNT 10  //!< update ten sites per BOSSANOVA interval
+#define UPDATECOUNT 10  //!< update ten sites per BOSSANOVA interval
 #endif /*DEFS_HPP_*/

src/ellipsoid.cpp

-              r375b458
+              r51c910
         int PointsLeft = 0;
         int PointsPicked = 0;
-        double value, threshold;
         int Nlower[NDIM], Nupper[NDIM];
         set<int> PickedAtomNrs;  // ordered list of picked atoms
 …
                                 PickedAtomNrs.insert(index);
+                        }
                 } while (PickedAtomNrs.size() < PointsToPick);
+                } while (PickedAtomNrs.size() < (size_t) PointsToPick);
                 index = 0; // now go through all and pick those whose from PickedAtomsNr

src/graph.cpp

-              r375b458
+              r51c910
 using namespace std;
+#include "graph.hpp"
+#include <iostream>
+#include <list>
+#include <vector>
+/***************************************** Implementations for graph classes ********************************/
+/***************************************** Functions for class graph ********************************/
+/** Constructor of class Graph.
+ */
+Graph::Graph()
+{
+};
+/** Destructor of class Graph.
+ * Destructor does release memory for nodes and edges contained in its lists as well.
+ */
+Graph::~Graph()
+{
+};
+/** Constructor of class SubGraph.
+ */
+SubGraph::SubGraph()
+{
+};
+/** Destructor of class SubGraph.
+ * Note that destructor does not deallocate either nodes or edges! (this is done by its subgraph!)
+ */
+SubGraph::~SubGraph()
+{
+};
+/** Constructor of class Node.
+ */
+Node::Node()
+{
+};
+/** Destructor of class Node.
+ */
+Node::~Node()
+{
+};
+/** Constructor of class Edge.
+ */
+Edge::Edge()
+{
+};
+/** Destructor of class Edge.
+ */
+Edge::~Edge()
+{
+};

src/helpers.cpp

-              r375b458
+              r51c910
 void * ReAlloc(void * OldPointer, size_t size, const char* output)
+{
         void *buffer = NULL;
         if (OldPointer == NULL)
                 //cout << Verbose(0) << "ReAlloc impossible - old is NULL: " << output << endl;
                 buffer = (void *)malloc(size); // malloc
         else
                 buffer = (void *)realloc(OldPointer, size); // realloc
         if (buffer == NULL)
                 cout << Verbose(0) << "ReAlloc failed - new is NULL: " << output << endl;
         return(buffer);
+  void *buffer = NULL;
+  if (OldPointer == NULL)
+    //cout << Verbose(0) << "ReAlloc impossible - old is NULL: " << output << endl;
+    buffer = (void *)malloc(size); // malloc
+  else
+    buffer = (void *)realloc(OldPointer, size); // realloc
+  if (buffer == NULL)
+    cout << Verbose(0) << "ReAlloc failed - new is NULL: " << output << endl;
+  return(buffer);
 };

src/joiner.cpp

-              r375b458
+              r51c910
 int main(int argc, char **argv)
+{
+        periodentafel *periode = NULL; // and a period table of all elements
+        EnergyMatrix Energy;
+        EnergyMatrix Hcorrection;
+        ForceMatrix Force;
+        EnergyMatrix EnergyFragments;
+        EnergyMatrix HcorrectionFragments;
+        ForceMatrix ForceFragments;
+        ForceMatrix Shielding;
+        ForceMatrix ShieldingPAS;
+        ForceMatrix ShieldingFragments;
+        ForceMatrix ShieldingPASFragments;
+        KeySetsContainer KeySet;
+        stringstream prefix;
+        char *dir = NULL;
+        bool Hcorrected = true;
+        cout << "Joiner" << endl;
+        cout << "======" << endl;
+        // Get the command line options
+        if (argc < 3) {
+                cout << "Usage: " << argv[0] << " <inputdir> <prefix> [elementsdb]" << endl;
+                cout << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl;
+                cout << "<prefix>\tprefix of energy and forces file." << endl;
+                cout << "[elementsdb]\tpath to elements database, needed for shieldings." << endl;
+                return 1;
+        } else {
+                dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+                strcpy(dir, "/");
+                strcat(dir, argv[2]);
+        }
+        if (argc > 3) {
+                periode = new periodentafel;
+                periode->LoadPeriodentafel(argv[3]);
+        }
+        // Test the given directory
+        if (!TestParams(argc, argv))
+                return 1;
+        // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
+        // ------------- Parse through all Fragment subdirs --------
+        if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
+        Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0);
+        if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix, 0,0)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
+                if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
+        }
+        // ---------- Parse the TE Factors into an array -----------------
+        if (!Energy.ParseIndices()) return 1;
+        if (Hcorrected) Hcorrection.ParseIndices();
+        // ---------- Parse the Force indices into an array ---------------
+        if (!Force.ParseIndices(argv[1])) return 1;
+        // ---------- Parse the shielding indices into an array ---------------
+        if (periode != NULL) { // also look for PAS values
+                if(!Shielding.ParseIndices(argv[1])) return 1;
+                if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
+        }
+        // ---------- Parse the KeySets into an array ---------------
+        if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+        if (!KeySet.ParseManyBodyTerms()) return 1;
+        if (!EnergyFragments.AllocateMatrix(Energy.Header, Energy.MatrixCounter, Energy.RowCounter, Energy.ColumnCounter)) return 1;
+        if (Hcorrected) HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
+        if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
+                if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
+        }
+        // ----------- Resetting last matrices (where full QM values are stored right now)
+        if(!Energy.SetLastMatrix(0., 0)) return 1;
+        if(!Force.SetLastMatrix(0., 2)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if(!Shielding.SetLastMatrix(0., 2)) return 1;
+                if(!ShieldingPAS.SetLastMatrix(0., 2)) return 1;
+        }
+        // +++++++++++++++++ SUMMING +++++++++++++++++++++++++++++++
+        // --------- sum up and write for each order----------------
+        for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+                // --------- sum up energy --------------------
+                cout << "Summing energy of order " << BondOrder+1 << " ..." << endl;
+                if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
+                if (Hcorrected) {
+                        HcorrectionFragments.SumSubManyBodyTerms(Hcorrection, KeySet, BondOrder);
+                        if (!Energy.SumSubEnergy(EnergyFragments, &HcorrectionFragments, KeySet, BondOrder, 1.)) return 1;
+                        if (Hcorrected) Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
+                } else
+                        if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
+                // --------- sum up Forces --------------------
+                cout << "Summing forces of order " << BondOrder+1 << " ..." << endl;
+                if (!ForceFragments.SumSubManyBodyTerms(Force, KeySet, BondOrder)) return 1;
+                if (!Force.SumSubForces(ForceFragments, KeySet, BondOrder, 1.)) return 1;
+                if (periode != NULL) { // also look for PAS values
+                        cout << "Summing shieldings of order " << BondOrder+1 << " ..." << endl;
+                        if (!ShieldingFragments.SumSubManyBodyTerms(Shielding, KeySet, BondOrder)) return 1;
+                        if (!Shielding.SumSubForces(ShieldingFragments, KeySet, BondOrder, 1.)) return 1;
+                        if (!ShieldingPASFragments.SumSubManyBodyTerms(ShieldingPAS, KeySet, BondOrder)) return 1;
+                        if (!ShieldingPAS.SumSubForces(ShieldingPASFragments, KeySet, BondOrder, 1.)) return 1;
+                }
+                // --------- write the energy and forces file --------------------
+                prefix.str(" ");
+                prefix << dir << OrderSuffix << (BondOrder+1);
+                cout << "Writing files " << argv[1] << prefix.str() << ". ..." << endl;
+                // energy
+                if (!Energy.WriteLastMatrix(argv[1], (prefix.str()).c_str(), EnergySuffix)) return 1;
+                // forces
+                if (!Force.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ForcesSuffix)) return 1;
+                // shieldings
+                if (periode != NULL) { // also look for PAS values
+                        if (!Shielding.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingSuffix)) return 1;
+                        if (!ShieldingPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingPASSuffix)) return 1;
+                }
+        }
+        // fragments
+        prefix.str(" ");
+        prefix << dir << EnergyFragmentSuffix;
+        if (!EnergyFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        if (Hcorrected) {
+                prefix.str(" ");
+                prefix << dir << HcorrectionFragmentSuffix;
+                if (!HcorrectionFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        }
+        prefix.str(" ");
+        prefix << dir << ForceFragmentSuffix;
+        if (!ForceFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        if (!CreateDataFragment(EnergyFragments, KeySet, argv[1], FRAGMENTPREFIX ENERGYPERFRAGMENT, "fragment energy versus the Fragment No", "today", CreateEnergy)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                prefix.str(" ");
+                prefix << dir << ShieldingFragmentSuffix;
+                if (!ShieldingFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+                prefix.str(" ");
+                prefix << dir << ShieldingPASFragmentSuffix;
+                if (!ShieldingPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        }
+        // write last matrices as fragments into central dir (not subdir as above), for analyzer to know index bounds
+        if (!Energy.WriteLastMatrix(argv[1], dir, EnergyFragmentSuffix)) return 1;
+        if (Hcorrected) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
+        if (!Force.WriteLastMatrix(argv[1], dir, ForceFragmentSuffix)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!Shielding.WriteLastMatrix(argv[1], dir, ShieldingFragmentSuffix)) return 1;
+                if (!ShieldingPAS.WriteLastMatrix(argv[1], dir, ShieldingPASFragmentSuffix)) return 1;
+        }
+        // exit
+        delete(periode);
+        Free((void **)&dir, "main: *dir");
+        cout << "done." << endl;
+        return 0;
+  periodentafel *periode = NULL; // and a period table of all elements
+  EnergyMatrix Energy;
+  EnergyMatrix EnergyFragments;
+  EnergyMatrix Hcorrection;
+  EnergyMatrix HcorrectionFragments;
+  ForceMatrix Force;
+  ForceMatrix ForceFragments;
+  HessianMatrix Hessian;
+  HessianMatrix HessianFragments;
+  ForceMatrix Shielding;
+  ForceMatrix ShieldingPAS;
+  ForceMatrix ShieldingFragments;
+  ForceMatrix ShieldingPASFragments;
+  ForceMatrix Chi;
+  ForceMatrix ChiPAS;
+  ForceMatrix ChiFragments;
+  ForceMatrix ChiPASFragments;
+  KeySetsContainer KeySet;
+  stringstream prefix;
+  char *dir = NULL;
+  bool NoHCorrection = false;
+  bool NoHessian = false;
+  cout << "Joiner" << endl;
+  cout << "======" << endl;
+  // Get the command line options
+  if (argc < 3) {
+    cout << "Usage: " << argv[0] << " <inputdir> <prefix> [elementsdb]" << endl;
+    cout << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl;
+    cout << "<prefix>\tprefix of energy and forces file." << endl;
+    cout << "[elementsdb]\tpath to elements database, needed for shieldings." << endl;
+    return 1;
+  } else {
+    dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+    strcpy(dir, "/");
+    strcat(dir, argv[2]);
+  }
+  if (argc > 3) {
+    periode = new periodentafel;
+    periode->LoadPeriodentafel(argv[3]);
+  }
+  // Test the given directory
+  if (!TestParams(argc, argv))
+    return 1;
+  // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
+  // ------------- Parse through all Fragment subdirs --------
+  if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
+  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0)) {
+    NoHCorrection = true;
+    cout << "No HCorrection matrices found, skipping these." << endl;
+  }
+  if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix, 0,0)) return 1;
+  if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix, 0,0)) {
+    NoHessian = true;
+    cout << "No hessian matrices found, skipping these." << endl;
+  }
+  if (periode != NULL) { // also look for PAS values
+    if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
+    if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
+    if (!Chi.ParseFragmentMatrix(argv[1], dir, ChiSuffix, 1, 0)) return 1;
+    if (!ChiPAS.ParseFragmentMatrix(argv[1], dir, ChiPASSuffix, 1, 0)) return 1;
+  }
+  // ---------- Parse the TE Factors into an array -----------------
+  if (!Energy.InitialiseIndices()) return 1;
+  if (!NoHCorrection)
+    Hcorrection.InitialiseIndices();
+  // ---------- Parse the Force indices into an array ---------------
+  if (!Force.ParseIndices(argv[1])) return 1;
+  // ---------- Parse the Hessian (=force) indices into an array ---------------
+  if (!NoHessian)
+    if (!Hessian.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
+  // ---------- Parse the shielding indices into an array ---------------
+  if (periode != NULL) { // also look for PAS values
+    if(!Shielding.ParseIndices(argv[1])) return 1;
+    if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
+    if(!Chi.ParseIndices(argv[1])) return 1;
+    if(!ChiPAS.ParseIndices(argv[1])) return 1;
+  }
+  // ---------- Parse the KeySets into an array ---------------
+  if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+  if (!KeySet.ParseManyBodyTerms()) return 1;
+  if (!EnergyFragments.AllocateMatrix(Energy.Header, Energy.MatrixCounter, Energy.RowCounter, Energy.ColumnCounter)) return 1;
+  if (!NoHCorrection)
+    HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
+  if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
+  if (!NoHessian)
+    if (!HessianFragments.AllocateMatrix(Hessian.Header, Hessian.MatrixCounter, Hessian.RowCounter, Hessian.ColumnCounter)) return 1;
+  if (periode != NULL) { // also look for PAS values
+    if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
+    if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
+    if (!ChiFragments.AllocateMatrix(Chi.Header, Chi.MatrixCounter, Chi.RowCounter, Chi.ColumnCounter)) return 1;
+    if (!ChiPASFragments.AllocateMatrix(ChiPAS.Header, ChiPAS.MatrixCounter, ChiPAS.RowCounter, ChiPAS.ColumnCounter)) return 1;
+  }
+  // ----------- Resetting last matrices (where full QM values are stored right now)
+  if(!Energy.SetLastMatrix(0., 0)) return 1;
+  if(!Force.SetLastMatrix(0., 2)) return 1;
+  if (!NoHessian)
+    if (!Hessian.SetLastMatrix(0., 0)) return 1;
+  if (periode != NULL) { // also look for PAS values
+    if(!Shielding.SetLastMatrix(0., 2)) return 1;
+    if(!ShieldingPAS.SetLastMatrix(0., 2)) return 1;
+    if(!Chi.SetLastMatrix(0., 2)) return 1;
+    if(!ChiPAS.SetLastMatrix(0., 2)) return 1;
+  }
+  // +++++++++++++++++ SUMMING +++++++++++++++++++++++++++++++
+  // --------- sum up and write for each order----------------
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    // --------- sum up energy --------------------
+    cout << "Summing energy of order " << BondOrder+1 << " ..." << endl;
+    if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
+    if (!NoHCorrection) {
+      HcorrectionFragments.SumSubManyBodyTerms(Hcorrection, KeySet, BondOrder);
+      if (!Energy.SumSubEnergy(EnergyFragments, &HcorrectionFragments, KeySet, BondOrder, 1.)) return 1;
+      Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
+    } else
+      if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
+    // --------- sum up Forces --------------------
+    cout << "Summing forces of order " << BondOrder+1 << " ..." << endl;
+    if (!ForceFragments.SumSubManyBodyTerms(Force, KeySet, BondOrder)) return 1;
+    if (!Force.SumSubForces(ForceFragments, KeySet, BondOrder, 1.)) return 1;
+    // --------- sum up Hessian --------------------
+    if (!NoHessian) {
+      cout << "Summing Hessian of order " << BondOrder+1 << " ..." << endl;
+      if (!HessianFragments.SumSubManyBodyTerms(Hessian, KeySet, BondOrder)) return 1;
+      if (!Hessian.SumSubHessians(HessianFragments, KeySet, BondOrder, 1.)) return 1;
+    }
+    if (periode != NULL) { // also look for PAS values
+      cout << "Summing shieldings and susceptibilities of order " << BondOrder+1 << " ..." << endl;
+      if (!ShieldingFragments.SumSubManyBodyTerms(Shielding, KeySet, BondOrder)) return 1;
+      if (!Shielding.SumSubForces(ShieldingFragments, KeySet, BondOrder, 1.)) return 1;
+      if (!ShieldingPASFragments.SumSubManyBodyTerms(ShieldingPAS, KeySet, BondOrder)) return 1;
+      if (!ShieldingPAS.SumSubForces(ShieldingPASFragments, KeySet, BondOrder, 1.)) return 1;
+      if (!ChiFragments.SumSubManyBodyTerms(Chi, KeySet, BondOrder)) return 1;
+      if (!Chi.SumSubForces(ChiFragments, KeySet, BondOrder, 1.)) return 1;
+      if (!ChiPASFragments.SumSubManyBodyTerms(ChiPAS, KeySet, BondOrder)) return 1;
+      if (!ChiPAS.SumSubForces(ChiPASFragments, KeySet, BondOrder, 1.)) return 1;
+    }
+    // --------- write the energy and forces file --------------------
+    prefix.str(" ");
+    prefix << dir << OrderSuffix << (BondOrder+1);
+    cout << "Writing files " << argv[1] << prefix.str() << ". ..." << endl;
+    // energy
+    if (!Energy.WriteLastMatrix(argv[1], (prefix.str()).c_str(), EnergySuffix)) return 1;
+    // forces
+    if (!Force.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ForcesSuffix)) return 1;
+    // hessian
+    if (!NoHessian)
+      if (!Hessian.WriteLastMatrix(argv[1], (prefix.str()).c_str(), HessianSuffix)) return 1;
+    // shieldings
+    if (periode != NULL) { // also look for PAS values
+      if (!Shielding.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingSuffix)) return 1;
+      if (!ShieldingPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingPASSuffix)) return 1;
+      if (!Chi.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ChiSuffix)) return 1;
+      if (!ChiPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ChiPASSuffix)) return 1;
+    }
+  }
+  // fragments
+  prefix.str(" ");
+  prefix << dir << EnergyFragmentSuffix;
+  if (!EnergyFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+  if (!NoHCorrection) {
+    prefix.str(" ");
+    prefix << dir << HcorrectionFragmentSuffix;
+    if (!HcorrectionFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+  }
+  prefix.str(" ");
+  prefix << dir << ForceFragmentSuffix;
+  if (!ForceFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+  if (!CreateDataFragment(EnergyFragments, KeySet, argv[1], FRAGMENTPREFIX ENERGYPERFRAGMENT, "fragment energy versus the Fragment No", "today", CreateEnergy)) return 1;
+  if (!NoHessian) {
+    prefix.str(" ");
+    prefix << dir << HessianFragmentSuffix;
+    if (!HessianFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+  }
+  if (periode != NULL) { // also look for PAS values
+    prefix.str(" ");
+    prefix << dir << ShieldingFragmentSuffix;
+    if (!ShieldingFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+    prefix.str(" ");
+    prefix << dir << ShieldingPASFragmentSuffix;
+    if (!ShieldingPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+    prefix.str(" ");
+    prefix << dir << ChiFragmentSuffix;
+    if (!ChiFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+    prefix.str(" ");
+    prefix << dir << ChiPASFragmentSuffix;
+    if (!ChiPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+  }
+  // write last matrices as fragments into central dir (not subdir as above), for analyzer to know index bounds
+  if (!Energy.WriteLastMatrix(argv[1], dir, EnergyFragmentSuffix)) return 1;
+  if (!NoHCorrection) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
+  if (!Force.WriteLastMatrix(argv[1], dir, ForceFragmentSuffix)) return 1;
+  if (!NoHessian)
+    if (!Hessian.WriteLastMatrix(argv[1], dir, HessianFragmentSuffix)) return 1;
+  if (periode != NULL) { // also look for PAS values
+    if (!Shielding.WriteLastMatrix(argv[1], dir, ShieldingFragmentSuffix)) return 1;
+    if (!ShieldingPAS.WriteLastMatrix(argv[1], dir, ShieldingPASFragmentSuffix)) return 1;
+    if (!Chi.WriteLastMatrix(argv[1], dir, ChiFragmentSuffix)) return 1;
+    if (!ChiPAS.WriteLastMatrix(argv[1], dir, ChiPASFragmentSuffix)) return 1;
+  }
+  // exit
+  delete(periode);
+  Free((void **)&dir, "main: *dir");
+  cout << "done." << endl;
+  return 0;
 };

src/moleculelist.cpp

-              r375b458
+              r51c910
  * \return true - add successful
  */
 bool MoleculeListClass::insert(molecule *mol)
+void MoleculeListClass::insert(molecule *mol)
+{
   mol->IndexNr = MaxIndex++;
 …
 void MoleculeListClass::Enumerate(ofstream *out)
+{
-  int i=1;
   element* Elemental = NULL;
   atom *Walker = NULL;
   int Counts[MAX_ELEMENTS];
+  double size=0;
+  Vector Origin;
   // header
   *out << "Index\tName\tNo.Atoms\tformula" << endl;
+  *out << "Index\tName\t\tAtoms\tFormula\tCenter\tSize" << endl;
   cout << Verbose(0) << "-----------------------------------------------" << endl;
   if (ListOfMolecules.size() == 0)
     *out << "\tNone" << endl;
   else {
+    Origin.Zero();
     for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
       // reset element counts
       for (int j = 0; j<MAX_ELEMENTS;j++)
         Counts[j] = 0;
+      // count atoms per element
+      // count atoms per element and determine size of bounding sphere
+      size=0.;
       Walker = (*ListRunner)->start;
       while (Walker->next != (*ListRunner)->end) {
         Walker = Walker->next;
         Counts[Walker->type->Z]++;
+        if (Walker->x.DistanceSquared(&Origin) > size)
+          size = Walker->x.DistanceSquared(&Origin);
+      }
       // output Index, Name, number of atoms, chemical formula
       *out << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
       Elemental = (*ListRunner)->elemente->end;
       while(Elemental != (*ListRunner)->elemente->start) {
+      while(Elemental->previous != (*ListRunner)->elemente->start) {
         Elemental = Elemental->previous;
         if (Counts[Elemental->Z] != 0)
           *out << Elemental->symbol << Counts[Elemental->Z];
+      }
+      *out << endl;
+      // Center and size
+      *out << "\t" << (*ListRunner)->Center << "\t" << sqrt(size) << endl;
+    }
+  }
 …
 molecule * MoleculeListClass::ReturnIndex(int index)
+{
+  int count = 1;
+  MoleculeList::iterator ListRunner = ListOfMolecules.begin();
+  for(; ((ListRunner != ListOfMolecules.end()) && (count < index)); ListRunner++);
+  if (count == index)
+    return (*ListRunner);
+  else
+    return NULL;
+  for(MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    if ((*ListRunner)->IndexNr == index)
+      return (*ListRunner);
+  return NULL;
 };
 …
   // open file for the force factors
   *out << Verbose(1) << "Saving force factors ... ";
+  *out << Verbose(1) << "Saving  force factors ... ";
   line << path << "/" << FRAGMENTPREFIX << FORCESFILE;
   ForcesFile.open(line.str().c_str(), ios::out);
 …
  * \param *configuration standard configuration to attach atoms in fragment molecule to.
  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
+ * \param DoPeriodic true - call ScanForPeriodicCorrection, false - don't
+ * \param DoCentering true - call molecule::CenterEdge(), false - don't
  * \return true - success (each file was written), false - something went wrong.
  */
+bool MoleculeListClass::OutputConfigForListOfFragments(ofstream *out,
+    config *configuration, int *SortIndex)
+bool MoleculeListClass::OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex)
+{
   ofstream outputFragment;
 …
 MoleculeLeafClass::MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf = NULL)
+{
   //    if (Up != NULL)
   //            if (Up->DownLeaf == NULL) // are we the first down leaf for the upper leaf?
   //                    Up->DownLeaf = this;
   //    UpLeaf = Up;
   //    DownLeaf = NULL;
+  //  if (Up != NULL)
+  //    if (Up->DownLeaf == NULL) // are we the first down leaf for the upper leaf?
+  //      Up->DownLeaf = this;
+  //  UpLeaf = Up;
+  //  DownLeaf = NULL;
   Leaf = NULL;
   previous = PreviousLeaf;
 …
 MoleculeLeafClass::~MoleculeLeafClass()
+{
   //    if (DownLeaf != NULL) {// drop leaves further down
   //            MoleculeLeafClass *Walker = DownLeaf;
   //            MoleculeLeafClass *Next;
   //            do {
   //                    Next = Walker->NextLeaf;
   //                    delete(Walker);
   //                    Walker = Next;
   //            } while (Walker != NULL);
   //            // Last Walker sets DownLeaf automatically to NULL
   //    }
+  //  if (DownLeaf != NULL) {// drop leaves further down
+  //    MoleculeLeafClass *Walker = DownLeaf;
+  //    MoleculeLeafClass *Next;
+  //    do {
+  //      Next = Walker->NextLeaf;
+  //      delete(Walker);
+  //      Walker = Next;
+  //    } while (Walker != NULL);
+  //    // Last Walker sets DownLeaf automatically to NULL
+  //  }
   // remove the leaf itself
   if (Leaf != NULL) {
 …
   if (previous != NULL)
     previous->next = next;
   //    } else { // we are first in list (connects to UpLeaf->DownLeaf)
   //            if ((NextLeaf != NULL) && (NextLeaf->UpLeaf == NULL))
   //                    NextLeaf->UpLeaf = UpLeaf;      // either null as we are top level or the upleaf of the first node
   //            if (UpLeaf != NULL)
   //                    UpLeaf->DownLeaf = NextLeaf;    // either null as we are only leaf or NextLeaf if we are just the first
   //    }
   //    UpLeaf = NULL;
+  //  } else { // we are first in list (connects to UpLeaf->DownLeaf)
+  //    if ((NextLeaf != NULL) && (NextLeaf->UpLeaf == NULL))
+  //      NextLeaf->UpLeaf = UpLeaf;  // either null as we are top level or the upleaf of the first node
+  //    if (UpLeaf != NULL)
+  //      UpLeaf->DownLeaf = NextLeaf;  // either null as we are only leaf or NextLeaf if we are just the first
+  //  }
+  //  UpLeaf = NULL;
   if (next != NULL) // are we last in list
     next->previous = previous;

src/molecules.cpp

-              r375b458
+              r51c910
   cell_size[1] = cell_size[3] = cell_size[4]= 0.;
   strcpy(name,"none");
+  IndexNr  = -1;
+  ActiveFlag = false;
 };
 …
  * \param *filename filename
  */
 void molecule::SetNameFromFilename(char *filename)
+void molecule::SetNameFromFilename(const char *filename)
+{
   int length = 0;
   char *molname = strrchr(filename, '/')+sizeof(char);  // search for filename without dirs
   char *endname = strrchr(filename, '.');
+  char *endname = strchr(molname, '.');
   if ((endname == NULL) || (endname < molname))
     length = strlen(molname);
 …
     length = strlen(molname) - strlen(endname);
   strncpy(name, molname, length);
+  name[length]='\0';
 };
 …
     max->Scale(0.5);
     Translate(max);
+    Center.Zero();
+  }
 …
     max->AddVector(min);
     Translate(min);
+    Center.Zero();
+  }
   delete(min);
 …
  * \param *center return vector for translation vector
  */
 void molecule::CenterOrigin(ofstream *out, Vector *center)
+void molecule::CenterOrigin(ofstream *out)
+{
   int Num = 0;
   atom *ptr = start->next;  // start at first in list
+  for(int i=NDIM;i--;) // zero center vector
+    center->x[i] = 0.;
+  Center.Zero();
   if (ptr != end) {   //list not empty?
 …
       ptr = ptr->next;
       Num++;
+      center->AddVector(&ptr->x);
+    }
+    center->Scale(-1./Num); // divide through total number (and sign for direction)
+    Translate(center);
+      Center.AddVector(&ptr->x);
+    }
+    Center.Scale(-1./Num); // divide through total number (and sign for direction)
+    Translate(&Center);
+    Center.Zero();
+  }
 };
 …
  * \param *center return vector for translation vector
  */
+void molecule::CenterGravity(ofstream *out, Vector *center)
+{
+  if (center == NULL) {
+    DetermineCenter(*center);
+    Translate(center);
+    delete(center);
+  } else {
+    Translate(center);
+  }
+void molecule::CenterPeriodic(ofstream *out)
+{
+  DeterminePeriodicCenter(Center);
+};
+/** Centers the center of gravity of the atoms at (0,0,0).
+ * \param *out output stream for debugging
+ * \param *center return vector for translation vector
+ */
+void molecule::CenterAtVector(ofstream *out, Vector *newcenter)
+{
+  Center.CopyVector(newcenter);
 };
 …
 /** Determines center of molecule (yet not considering atom masses).
  * \param Center reference to return vector
  */
 void molecule::DetermineCenter(Vector &Center)
+ * \param center reference to return vector
+ */
+void molecule::DeterminePeriodicCenter(Vector &center)
+{
   atom *Walker = start;
 …
   do {
     Center.Zero();
+    center.Zero();
     flag = true;
     while (Walker->next != end) {
 …
         Testvector.AddVector(&Translationvector);
         Testvector.MatrixMultiplication(matrix);
         Center.AddVector(&Testvector);
+        center.AddVector(&Testvector);
         cout << Verbose(1) << "vector is: ";
         Testvector.Output((ofstream *)&cout);
 …
             Testvector.AddVector(&Translationvector);
             Testvector.MatrixMultiplication(matrix);
             Center.AddVector(&Testvector);
+            center.AddVector(&Testvector);
             cout << Verbose(1) << "Hydrogen vector is: ";
             Testvector.Output((ofstream *)&cout);
 …
   } while (!flag);
   Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
   Center.Scale(1./(double)AtomCount);
+  center.Scale(1./(double)AtomCount);
 };
 …
   Vector *CenterOfGravity = DetermineCenterOfGravity(out);
   CenterGravity(out, CenterOfGravity);
+  CenterAtVector(out, CenterOfGravity);
   // reset inertia tensor
 …
 };
+/** Evaluates the potential energy used for constrained molecular dynamics.
+ * \f$V_i^{con} = c^{bond} \cdot | r_{P(i)} - R_i | + sum_{i \neq j} C^{min} \cdot \frac{1}{C_{ij}} + C^{inj} \Bigl (1 - \theta \bigl (\prod_{i \neq j} (P(i) - P(j)) \bigr ) \Bigr )\f$
+ *     where the first term points to the target in minimum distance, the second is a penalty for trajectories lying too close to each other (\f$C_{ij}$ is minimum distance between
+ *     trajectories i and j) and the third term is a penalty for two atoms trying to each the same target point.
+ * Note that for the second term we have to solve the following linear system:
+ * \f$-c_1 \cdot n_1 + c_2 \cdot n_2 + C \cdot n_3 = - p_2 + p_1\f$, where \f$c_1\f$, \f$c_2\f$ and \f$C\f$ are constants,
+ * offset vector \f$p_1\f$ in direction \f$n_1\f$, offset vector \f$p_2\f$ in direction \f$n_2\f$,
+ * \f$n_3\f$ is the normal vector to both directions. \f$C\f$ would be the minimum distance between the two lines.
+ * \sa molecule::MinimiseConstrainedPotential(), molecule::VerletForceIntegration()
+ * \param *out output stream for debugging
+ * \param *PermutationMap gives target ptr for each atom, array of size molecule::AtomCount (this is "x" in \f$ V^{con}(x) \f$ )
+ * \param startstep start configuration (MDStep in molecule::trajectories)
+ * \param endstep end configuration (MDStep in molecule::trajectories)
+ * \param *constants constant in front of each term
+ * \param IsAngstroem whether coordinates are in angstroem (true) or bohrradius (false)
+ * \return potential energy
+ * \note This routine is scaling quadratically which is not optimal.
+ * \todo There's a bit double counting going on for the first time, bu nothing to worry really about.
+ */
+double molecule::ConstrainedPotential(ofstream *out, atom **PermutationMap, int startstep, int endstep, double *constants, bool IsAngstroem)
+{
+  double result = 0., tmp, Norm1, Norm2;
+  atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
+  Vector trajectory1, trajectory2, normal, TestVector;
+  gsl_matrix *A = gsl_matrix_alloc(NDIM,NDIM);
+  gsl_vector *x = gsl_vector_alloc(NDIM);
+  // go through every atom
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    // first term: distance to target
+    Runner = PermutationMap[Walker->nr];   // find target point
+    tmp = (Trajectories[Walker].R.at(startstep).Distance(&Trajectories[Runner].R.at(endstep)));
+    tmp *= IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
+    result += constants[0] * tmp;
+    //*out << Verbose(4) << "Adding " << tmp*constants[0] << "." << endl;
+    // second term: sum of distances to other trajectories
+    Runner = start;
+    while (Runner->next != end) {
+      Runner = Runner->next;
+      if (Runner == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
+        break;
+      // determine normalized trajectories direction vector (n1, n2)
+      Sprinter = PermutationMap[Walker->nr];   // find first target point
+      trajectory1.CopyVector(&Trajectories[Sprinter].R.at(endstep));
+      trajectory1.SubtractVector(&Trajectories[Walker].R.at(startstep));
+      trajectory1.Normalize();
+      Norm1 = trajectory1.Norm();
+      Sprinter = PermutationMap[Runner->nr];   // find second target point
+      trajectory2.CopyVector(&Trajectories[Sprinter].R.at(endstep));
+      trajectory2.SubtractVector(&Trajectories[Runner].R.at(startstep));
+      trajectory2.Normalize();
+      Norm2 = trajectory1.Norm();
+      // check whether either is zero()
+      if ((Norm1 < MYEPSILON) && (Norm2 < MYEPSILON)) {
+        tmp = Trajectories[Walker].R.at(startstep).Distance(&Trajectories[Runner].R.at(startstep));
+      } else if (Norm1 < MYEPSILON) {
+        Sprinter = PermutationMap[Walker->nr];   // find first target point
+        trajectory1.CopyVector(&Trajectories[Sprinter].R.at(endstep));  // copy first offset
+        trajectory1.SubtractVector(&Trajectories[Runner].R.at(startstep));  // subtract second offset
+        trajectory2.Scale( trajectory1.ScalarProduct(&trajectory2) ); // trajectory2 is scaled to unity, hence we don't need to divide by anything
+        trajectory1.SubtractVector(&trajectory2);   // project the part in norm direction away
+        tmp = trajectory1.Norm();  // remaining norm is distance
+      } else if (Norm2 < MYEPSILON) {
+        Sprinter = PermutationMap[Runner->nr];   // find second target point
+        trajectory2.CopyVector(&Trajectories[Sprinter].R.at(endstep));  // copy second offset
+        trajectory2.SubtractVector(&Trajectories[Walker].R.at(startstep));  // subtract first offset
+        trajectory1.Scale( trajectory2.ScalarProduct(&trajectory1) ); // trajectory1 is scaled to unity, hence we don't need to divide by anything
+        trajectory2.SubtractVector(&trajectory1);   // project the part in norm direction away
+        tmp = trajectory2.Norm();  // remaining norm is distance
+      } else if ((fabs(trajectory1.ScalarProduct(&trajectory2)/Norm1/Norm2) - 1.) < MYEPSILON) { // check whether they're linear dependent
+//        *out << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear dependent: ";
+//        *out << trajectory1;
+//        *out << " and ";
+//        *out << trajectory2;
+        tmp = Trajectories[Walker].R.at(startstep).Distance(&Trajectories[Runner].R.at(startstep));
+//        *out << " with distance " << tmp << "." << endl;
+      } else { // determine distance by finding minimum distance
+//        *out << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
+//        *out << endl;
+//        *out << "First Trajectory: ";
+//        *out << trajectory1 << endl;
+//        *out << "Second Trajectory: ";
+//        *out << trajectory2 << endl;
+        // determine normal vector for both
+        normal.MakeNormalVector(&trajectory1, &trajectory2);
+        // print all vectors for debugging
+//        *out << "Normal vector in between: ";
+//        *out << normal << endl;
+        // setup matrix
+        for (int i=NDIM;i--;) {
+          gsl_matrix_set(A, 0, i, trajectory1.x[i]);
+          gsl_matrix_set(A, 1, i, trajectory2.x[i]);
+          gsl_matrix_set(A, 2, i, normal.x[i]);
+          gsl_vector_set(x,i, (Trajectories[Walker].R.at(startstep).x[i] - Trajectories[Runner].R.at(startstep).x[i]));
+        }
+        // solve the linear system by Householder transformations
+        gsl_linalg_HH_svx(A, x);
+        // distance from last component
+        tmp = gsl_vector_get(x,2);
+//        *out << " with distance " << tmp << "." << endl;
+        // test whether we really have the intersection (by checking on c_1 and c_2)
+        TestVector.CopyVector(&Trajectories[Runner].R.at(startstep));
+        trajectory2.Scale(gsl_vector_get(x,1));
+        TestVector.AddVector(&trajectory2);
+        normal.Scale(gsl_vector_get(x,2));
+        TestVector.AddVector(&normal);
+        TestVector.SubtractVector(&Trajectories[Walker].R.at(startstep));
+        trajectory1.Scale(gsl_vector_get(x,0));
+        TestVector.SubtractVector(&trajectory1);
+        if (TestVector.Norm() < MYEPSILON) {
+//          *out << Verbose(2) << "Test: ok.\tDistance of " << tmp << " is correct." << endl;
+        } else {
+//          *out << Verbose(2) << "Test: failed.\tIntersection is off by ";
+//          *out << TestVector;
+//          *out << "." << endl;
+        }
+      }
+      // add up
+      tmp *= IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
+      if (fabs(tmp) > MYEPSILON) {
+        result += constants[1] * 1./tmp;
+        //*out << Verbose(4) << "Adding " << 1./tmp*constants[1] << "." << endl;
+      }
+    }
+    // third term: penalty for equal targets
+    Runner = start;
+    while (Runner->next != end) {
+      Runner = Runner->next;
+      if ((PermutationMap[Walker->nr] == PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
+        Sprinter = PermutationMap[Walker->nr];
+//        *out << *Walker << " and " << *Runner << " are heading to the same target at ";
+//        *out << Trajectories[Sprinter].R.at(endstep);
+//        *out << ", penalting." << endl;
+        result += constants[2];
+        //*out << Verbose(4) << "Adding " << constants[2] << "." << endl;
+      }
+    }
+  }
+  return result;
+};
+void PrintPermutationMap(ofstream *out, atom **PermutationMap, int Nr)
+{
+  stringstream zeile1, zeile2;
+  int *DoubleList = (int *) Malloc(Nr*sizeof(int), "PrintPermutationMap: *DoubleList");
+  int doubles = 0;
+  for (int i=0;i<Nr;i++)
+    DoubleList[i] = 0;
+  zeile1 << "PermutationMap: ";
+  zeile2 << "                ";
+  for (int i=0;i<Nr;i++) {
+    DoubleList[PermutationMap[i]->nr]++;
+    zeile1 << i << " ";
+    zeile2 << PermutationMap[i]->nr << " ";
+  }
+  for (int i=0;i<Nr;i++)
+    if (DoubleList[i] > 1)
+    doubles++;
+ // *out << "Found " << doubles << " Doubles." << endl;
+  Free((void **)&DoubleList, "PrintPermutationMap: *DoubleList");
+//  *out << zeile1.str() << endl << zeile2.str() << endl;
+};
+/** Minimises the extra potential for constrained molecular dynamics and gives forces and the constrained potential energy.
+ * We do the following:
+ *  -# Generate a distance list from all source to all target points
+ *  -# Sort this per source point
+ *  -# Take for each source point the target point with minimum distance, use this as initial permutation
+ *  -# check whether molecule::ConstrainedPotential() is greater than injective penalty
+ *     -# If so, we go through each source point, stepping down in the sorted target point distance list and re-checking potential.
+ *  -# Next, we only apply transformations that keep the injectivity of the permutations list.
+ *  -# Hence, for one source point we step down the ladder and seek the corresponding owner of this new target
+ *     point and try to change it for one with lesser distance, or for the next one with greater distance, but only
+ *     if this decreases the conditional potential.
+ *  -# finished.
+ *  -# Then, we calculate the forces by taking the spatial derivative, where we scale the potential to such a degree,
+ *     that the total force is always pointing in direction of the constraint force (ensuring that we move in the
+ *     right direction).
+ *  -# Finally, we calculate the potential energy and return.
+ * \param *out output stream for debugging
+ * \param **PermutationMap on return: mapping between the atom label of the initial and the final configuration
+ * \param startstep current MD step giving initial position between which and \a endstep we perform the constrained MD (as further steps are always concatenated)
+ * \param endstep step giving final position in constrained MD
+ * \param IsAngstroem whether coordinates are in angstroem (true) or bohrradius (false)
+ * \sa molecule::VerletForceIntegration()
+ * \return potential energy (and allocated **PermutationMap (array of molecule::AtomCount ^2)
+ * \todo The constrained potential's constants are set to fixed values right now, but they should scale based on checks of the system in order
+ *       to ensure they're properties (e.g. constants[2] always greater than the energy of the system).
+ * \bug this all is not O(N log N) but O(N^2)
+ */
+double molecule::MinimiseConstrainedPotential(ofstream *out, atom **&PermutationMap, int startstep, int endstep, bool IsAngstroem)
+{
+  double Potential, OldPotential, OlderPotential;
+  PermutationMap = (atom **) Malloc(AtomCount*sizeof(atom *), "molecule::MinimiseConstrainedPotential: **PermutationMap");
+  DistanceMap **DistanceList = (DistanceMap **) Malloc(AtomCount*sizeof(DistanceMap *), "molecule::MinimiseConstrainedPotential: **DistanceList");
+  DistanceMap::iterator *DistanceIterators = (DistanceMap::iterator *) Malloc(AtomCount*sizeof(DistanceMap::iterator), "molecule::MinimiseConstrainedPotential: *DistanceIterators");
+  int *DoubleList = (int *) Malloc(AtomCount*sizeof(int), "molecule::MinimiseConstrainedPotential: *DoubleList");
+  DistanceMap::iterator *StepList = (DistanceMap::iterator *) Malloc(AtomCount*sizeof(DistanceMap::iterator), "molecule::MinimiseConstrainedPotential: *StepList");
+  double constants[3];
+  int round;
+  atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
+  DistanceMap::iterator Rider, Strider;
+  /// Minimise the potential
+  // set Lagrange multiplier constants
+  constants[0] = 10.;
+  constants[1] = 1.;
+  constants[2] = 1e+7;    // just a huge penalty
+  // generate the distance list
+  *out << Verbose(1) << "Creating the distance list ... " << endl;
+  for (int i=AtomCount; i--;) {
+    DoubleList[i] = 0;  // stores for how many atoms in startstep this atom is a target in endstep
+    DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
+    DistanceList[i]->clear();
+  }
+  *out << Verbose(1) << "Filling the distance list ... " << endl;
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Runner = start;
+    while(Runner->next != end) {
+      Runner = Runner->next;
+      DistanceList[Walker->nr]->insert( DistancePair(Trajectories[Walker].R.at(startstep).Distance(&Trajectories[Runner].R.at(endstep)), Runner) );
+    }
+  }
+  // create the initial PermutationMap (source -> target)
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    StepList[Walker->nr] = DistanceList[Walker->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    PermutationMap[Walker->nr] = DistanceList[Walker->nr]->begin()->second;   // always pick target with the smallest distance
+    DoubleList[DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    DistanceIterators[Walker->nr] = DistanceList[Walker->nr]->begin();    // and remember which one we picked
+    *out << *Walker << " starts with distance " << DistanceList[Walker->nr]->begin()->first << "." << endl;
+  }
+  *out << Verbose(1) << "done." << endl;
+  // make the PermutationMap injective by checking whether we have a non-zero constants[2] term in it
+  *out << Verbose(1) << "Making the PermutationMap injective ... " << endl;
+  Walker = start;
+  DistanceMap::iterator NewBase;
+  OldPotential = fabs(ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem));
+  while ((OldPotential) > constants[2]) {
+    PrintPermutationMap(out, PermutationMap, AtomCount);
+    Walker = Walker->next;
+    if (Walker == end) // round-robin at the end
+      Walker = start->next;
+    if (DoubleList[DistanceIterators[Walker->nr]->second->nr] <= 1)  // no need to make those injective that aren't
+      continue;
+    // now, try finding a new one
+    NewBase = DistanceIterators[Walker->nr];  // store old base
+    do {
+      NewBase++;  // take next further distance in distance to targets list that's a target of no one
+    } while ((DoubleList[NewBase->second->nr] != 0) && (NewBase != DistanceList[Walker->nr]->end()));
+    if (NewBase != DistanceList[Walker->nr]->end()) {
+      PermutationMap[Walker->nr] = NewBase->second;
+      Potential = fabs(ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem));
+      if (Potential > OldPotential) { // undo
+        PermutationMap[Walker->nr] = DistanceIterators[Walker->nr]->second;
+      } else {  // do
+        DoubleList[DistanceIterators[Walker->nr]->second->nr]--;  // decrease the old entry in the doubles list
+        DoubleList[NewBase->second->nr]++;    // increase the old entry in the doubles list
+        DistanceIterators[Walker->nr] = NewBase;
+        OldPotential = Potential;
+        *out << Verbose(3) << "Found a new permutation, new potential is " << OldPotential << "." << endl;
+      }
+    }
+  }
+  for (int i=AtomCount; i--;) // now each single entry in the DoubleList should be <=1
+    if (DoubleList[i] > 1) {
+      cerr << "Failed to create an injective PermutationMap!" << endl;
+      exit(1);
+    }
+  *out << Verbose(1) << "done." << endl;
+  Free((void **)&DoubleList, "molecule::MinimiseConstrainedPotential: *DoubleList");
+  // argument minimise the constrained potential in this injective PermutationMap
+  *out << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
+  OldPotential = 1e+10;
+  round = 0;
+  do {
+    *out << "Starting round " << ++round << " ... " << endl;
+    OlderPotential = OldPotential;
+    do {
+      Walker = start;
+      while (Walker->next != end) { // pick one
+        Walker = Walker->next;
+        PrintPermutationMap(out, PermutationMap, AtomCount);
+        Sprinter = DistanceIterators[Walker->nr]->second;   // store initial partner
+        Strider = DistanceIterators[Walker->nr];  //remember old iterator
+        DistanceIterators[Walker->nr] = StepList[Walker->nr];
+        if (DistanceIterators[Walker->nr] == DistanceList[Walker->nr]->end()) {// stop, before we run through the list and still on
+          DistanceIterators[Walker->nr] == DistanceList[Walker->nr]->begin();
+          break;
+        }
+        //*out << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
+        // find source of the new target
+        Runner = start->next;
+        while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
+          if (PermutationMap[Runner->nr] == DistanceIterators[Walker->nr]->second) {
+            //*out << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
+            break;
+          }
+          Runner = Runner->next;
+        }
+        if (Runner != end) { // we found the other source
+          // then look in its distance list for Sprinter
+          Rider = DistanceList[Runner->nr]->begin();
+          for (; Rider != DistanceList[Runner->nr]->end(); Rider++)
+            if (Rider->second == Sprinter)
+              break;
+          if (Rider != DistanceList[Runner->nr]->end()) { // if we have found one
+            //*out << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
+            // exchange both
+            PermutationMap[Walker->nr] = DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
+            PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
+            PrintPermutationMap(out, PermutationMap, AtomCount);
+            // calculate the new potential
+            //*out << Verbose(2) << "Checking new potential ..." << endl;
+            Potential = ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem);
+            if (Potential > OldPotential) { // we made everything worse! Undo ...
+              //*out << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
+              //*out << Verbose(3) << "Setting " << *Runner << "'s source to " << *DistanceIterators[Runner->nr]->second << "." << endl;
+              // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
+              PermutationMap[Runner->nr] = DistanceIterators[Runner->nr]->second;
+              // Undo for Walker
+              DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
+              //*out << Verbose(3) << "Setting " << *Walker << "'s source to " << *DistanceIterators[Walker->nr]->second << "." << endl;
+              PermutationMap[Walker->nr] = DistanceIterators[Walker->nr]->second;
+            } else {
+              DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
+              *out << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl;
+              OldPotential = Potential;
+            }
+            if (Potential > constants[2]) {
+              cerr << "ERROR: The two-step permutation procedure did not maintain injectivity!" << endl;
+              exit(255);
+            }
+            //*out << endl;
+          } else {
+            cerr << "ERROR: " << *Runner << " was not the owner of " << *Sprinter << "!" << endl;
+            exit(255);
+          }
+        } else {
+          PermutationMap[Walker->nr] = DistanceIterators[Walker->nr]->second; // new target has no source!
+        }
+        StepList[Walker->nr]++; // take next farther distance target
+      }
+    } while (Walker->next != end);
+  } while ((OlderPotential - OldPotential) > 1e-3);
+  *out << Verbose(1) << "done." << endl;
+  /// free memory and return with evaluated potential
+  for (int i=AtomCount; i--;)
+    DistanceList[i]->clear();
+  Free((void **)&DistanceList, "molecule::MinimiseConstrainedPotential: **DistanceList");
+  Free((void **)&DistanceIterators, "molecule::MinimiseConstrainedPotential: *DistanceIterators");
+  return ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem);
+};
+/** Evaluates the (distance-related part) of the constrained potential for the constrained forces.
+ * \param *out output stream for debugging
+ * \param startstep current MD step giving initial position between which and \a endstep we perform the constrained MD (as further steps are always concatenated)
+ * \param endstep step giving final position in constrained MD
+ * \param **PermutationMap mapping between the atom label of the initial and the final configuration
+ * \param *Force ForceMatrix containing force vectors from the external energy functional minimisation.
+ * \todo the constant for the constrained potential distance part is hard-coded independently of the hard-coded value in MinimiseConstrainedPotential()
+ */
+void molecule::EvaluateConstrainedForces(ofstream *out, int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force)
+{
+  double constant = 10.;
+  atom *Walker = NULL, *Sprinter = NULL;
+  /// evaluate forces (only the distance to target dependent part) with the final PermutationMap
+  *out << Verbose(1) << "Calculating forces and adding onto ForceMatrix ... " << endl;
+  Walker = start;
+  while (Walker->next != NULL) {
+    Walker = Walker->next;
+    Sprinter = PermutationMap[Walker->nr];
+    // set forces
+    for (int i=NDIM;i++;)
+      Force->Matrix[0][Walker->nr][5+i] += 2.*constant*sqrt(Trajectories[Walker].R.at(startstep).Distance(&Trajectories[Sprinter].R.at(endstep)));
+  }
+  *out << Verbose(1) << "done." << endl;
+};
+/** Performs a linear interpolation between two desired atomic configurations with a given number of steps.
+ * Note, step number is config::MaxOuterStep
+ * \param *out output stream for debugging
+ * \param startstep stating initial configuration in molecule::Trajectories
+ * \param endstep stating final configuration in molecule::Trajectories
+ * \param &config configuration structure
+ * \return true - success in writing step files, false - error writing files or only one step in molecule::Trajectories
+ */
+bool molecule::LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration)
+{
+  molecule *mol = NULL;
+  bool status = true;
+  int MaxSteps = configuration.MaxOuterStep;
+  MoleculeListClass *MoleculePerStep = new MoleculeListClass();
+  // Get the Permutation Map by MinimiseConstrainedPotential
+  atom **PermutationMap = NULL;
+  atom *Walker = NULL, *Sprinter = NULL;
+  MinimiseConstrainedPotential(out, PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
+  // check whether we have sufficient space in Trajectories for each atom
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if (Trajectories[Walker].R.size() <= (unsigned int)(MaxSteps)) {
+      //cout << "Increasing size for trajectory array of " << keyword << " to " << (MaxSteps+1) << "." << endl;
+      Trajectories[Walker].R.resize(MaxSteps+1);
+      Trajectories[Walker].U.resize(MaxSteps+1);
+      Trajectories[Walker].F.resize(MaxSteps+1);
+    }
+  }
+  // push endstep to last one
+  Walker = start;
+  while (Walker->next != end) { // remove the endstep (is now the very last one)
+    Walker = Walker->next;
+    for (int n=NDIM;n--;) {
+      Trajectories[Walker].R.at(MaxSteps).x[n] = Trajectories[Walker].R.at(endstep).x[n];
+      Trajectories[Walker].U.at(MaxSteps).x[n] = Trajectories[Walker].U.at(endstep).x[n];
+      Trajectories[Walker].F.at(MaxSteps).x[n] = Trajectories[Walker].F.at(endstep).x[n];
+    }
+  }
+  endstep = MaxSteps;
+  // go through all steps and add the molecular configuration to the list and to the Trajectories of \a this molecule
+  *out << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
+  for (int step = 0; step <= MaxSteps; step++) {
+    mol = new molecule(elemente);
+    MoleculePerStep->insert(mol);
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      // add to molecule list
+      Sprinter = mol->AddCopyAtom(Walker);
+      for (int n=NDIM;n--;) {
+        Sprinter->x.x[n] = Trajectories[Walker].R.at(startstep).x[n] + (Trajectories[PermutationMap[Walker->nr]].R.at(endstep).x[n] - Trajectories[Walker].R.at(startstep).x[n])*((double)step/(double)MaxSteps);
+        // add to Trajectories
+        //*out << Verbose(3) << step << ">=" << MDSteps-1 << endl;
+        if (step < MaxSteps) {
+          Trajectories[Walker].R.at(step).x[n] = Trajectories[Walker].R.at(startstep).x[n] + (Trajectories[PermutationMap[Walker->nr]].R.at(endstep).x[n] - Trajectories[Walker].R.at(startstep).x[n])*((double)step/(double)MaxSteps);
+          Trajectories[Walker].U.at(step).x[n] = 0.;
+          Trajectories[Walker].F.at(step).x[n] = 0.;
+        }
+      }
+    }
+  }
+  MDSteps = MaxSteps+1;   // otherwise new Trajectories' points aren't stored on save&exit
+  // store the list to single step files
+  int *SortIndex = (int *) Malloc(AtomCount*sizeof(int), "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
+  for (int i=AtomCount; i--; )
+    SortIndex[i] = i;
+  status = MoleculePerStep->OutputConfigForListOfFragments(out, &configuration, SortIndex);
+  // free and return
+  Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
+  delete(MoleculePerStep);
+  return status;
+};
 /** Parses nuclear forces from file and performs Verlet integration.
  * Note that we assume the parsed forces to be in atomic units (hence, if coordinates are in angstroem, we
  * have to transform them).
  * This adds a new MD step to the config file.
+ * \param *out output stream for debugging
  * \param *file filename
+ * \param config structure with config::Deltat, config::IsAngstroem, config::DoConstrained
  * \param delta_t time step width in atomic units
  * \param IsAngstroem whether coordinates are in angstroem (true) or bohrradius (false)
+ * \param DoConstrained whether we perform a constrained (>0, target step in molecule::trajectories) or unconstrained (0) molecular dynamics, \sa molecule::MinimiseConstrainedPotential()
  * \return true - file found and parsed, false - file not found or imparsable
  */
+bool molecule::VerletForceIntegration(char *file, double delta_t, bool IsAngstroem)
+{
+  element *runner = elemente->start;
+ * \todo This is not yet checked if it is correctly working with DoConstrained set to true.
+ */
+bool molecule::VerletForceIntegration(ofstream *out, char *file, config &configuration)
+{
   atom *walker = NULL;
-  int AtomNo;
   ifstream input(file);
   string token;
   stringstream item;
   double a, IonMass;
+  double IonMass, Vector[NDIM], ConstrainedPotentialEnergy, ActualTemp;
   ForceMatrix Force;
-  Vector tmpvector;
   CountElements();  // make sure ElementsInMolecule is up to date
 …
+    }
     // correct Forces
+//    for(int d=0;d<NDIM;d++)
+//      tmpvector.x[d] = 0.;
+//    for(int i=0;i<AtomCount;i++)
+//      for(int d=0;d<NDIM;d++) {
+//        tmpvector.x[d] += Force.Matrix[0][i][d+5];
+//      }
+//    for(int i=0;i<AtomCount;i++)
+//      for(int d=0;d<NDIM;d++) {
+//        Force.Matrix[0][i][d+5] -= tmpvector.x[d]/(double)AtomCount;
+//      }
+    for(int d=0;d<NDIM;d++)
+      Vector[d] = 0.;
+    for(int i=0;i<AtomCount;i++)
+      for(int d=0;d<NDIM;d++) {
+        Vector[d] += Force.Matrix[0][i][d+5];
+      }
+    for(int i=0;i<AtomCount;i++)
+      for(int d=0;d<NDIM;d++) {
+        Force.Matrix[0][i][d+5] -= Vector[d]/(double)AtomCount;
+      }
+    // solve a constrained potential if we are meant to
+    if (configuration.DoConstrainedMD) {
+      // calculate forces and potential
+      atom **PermutationMap = NULL;
+      ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
+      EvaluateConstrainedForces(out, configuration.DoConstrainedMD, 0, PermutationMap, &Force);
+      Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
+    }
     // and perform Verlet integration for each atom with position, velocity and force vector
+    runner = elemente->start;
+    while (runner->next != elemente->end) { // go through every element
+      runner = runner->next;
+      IonMass = runner->mass;
+      a = delta_t*0.5/IonMass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
+      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+        AtomNo = 0;
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      //a = configuration.Deltat*0.5/walker->type->mass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
+      // check size of vectors
+      if (Trajectories[walker].R.size() <= (unsigned int)(MDSteps)) {
+        //out << "Increasing size for trajectory array of " << *walker << " to " << (size+10) << "." << endl;
+        Trajectories[walker].R.resize(MDSteps+10);
+        Trajectories[walker].U.resize(MDSteps+10);
+        Trajectories[walker].F.resize(MDSteps+10);
+      }
+      // Update R (and F)
+      for (int d=0; d<NDIM; d++) {
+        Trajectories[walker].F.at(MDSteps).x[d] = -Force.Matrix[0][walker->nr][d+5]*(configuration.GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
+        Trajectories[walker].R.at(MDSteps).x[d] = Trajectories[walker].R.at(MDSteps-1).x[d];
+        Trajectories[walker].R.at(MDSteps).x[d] += configuration.Deltat*(Trajectories[walker].U.at(MDSteps-1).x[d]);     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2
+        Trajectories[walker].R.at(MDSteps).x[d] += 0.5*configuration.Deltat*configuration.Deltat*(Trajectories[walker].F.at(MDSteps).x[d]/walker->type->mass);     // F = m * a and s = 0.5 * F/m * t^2 = F * a * t
+      }
+      // Update U
+      for (int d=0; d<NDIM; d++) {
+        Trajectories[walker].U.at(MDSteps).x[d] = Trajectories[walker].U.at(MDSteps-1).x[d];
+        Trajectories[walker].U.at(MDSteps).x[d] += configuration.Deltat * (Trajectories[walker].F.at(MDSteps).x[d]+Trajectories[walker].F.at(MDSteps-1).x[d]/walker->type->mass); // v = F/m * t
+      }
+//      out << "Integrated position&velocity of step " << (MDSteps) << ": (";
+//      for (int d=0;d<NDIM;d++)
+//        out << Trajectories[walker].R.at(MDSteps).x[d] << " ";          // next step
+//      out << ")\t(";
+//      for (int d=0;d<NDIM;d++)
+//        cout << Trajectories[walker].U.at(MDSteps).x[d] << " ";          // next step
+//      out << ")" << endl;
+            // next atom
+    }
+  }
+  // correct velocities (rather momenta) so that center of mass remains motionless
+  for(int d=0;d<NDIM;d++)
+    Vector[d] = 0.;
+  IonMass = 0.;
+  walker = start;
+  while (walker->next != end) { // go through every atom
+    walker = walker->next;
+    IonMass += walker->type->mass;  // sum up total mass
+    for(int d=0;d<NDIM;d++) {
+      Vector[d] += Trajectories[walker].U.at(MDSteps).x[d]*walker->type->mass;
+    }
+  }
+  // correct velocities (rather momenta) so that center of mass remains motionless
+  for(int d=0;d<NDIM;d++)
+    Vector[d] /= IonMass;
+  ActualTemp = 0.;
+  walker = start;
+  while (walker->next != end) { // go through every atom of this element
+    walker = walker->next;
+    for(int d=0;d<NDIM;d++) {
+      Trajectories[walker].U.at(MDSteps).x[d] -= Vector[d];
+      ActualTemp += 0.5 * walker->type->mass * Trajectories[walker].U.at(MDSteps).x[d] * Trajectories[walker].U.at(MDSteps).x[d];
+    }
+  }
+  Thermostats(configuration, ActualTemp, Berendsen);
+  MDSteps++;
+  // exit
+  return true;
+};
+/** Implementation of various thermostats.
+ * All these thermostats apply an additional force which has the following forms:
+ * -# Woodcock
+ *  \f$p_i \rightarrow \sqrt{\frac{T_0}{T}} \cdot p_i\f$
+ * -# Gaussian
+ *  \f$ \frac{ \sum_i \frac{p_i}{m_i} \frac{\partial V}{\partial q_i}} {\sum_i \frac{p^2_i}{m_i}} \cdot p_i\f$
+ * -# Langevin
+ *  \f$p_{i,n} \rightarrow \sqrt{1-\alpha^2} p_{i,0} + \alpha p_r\f$
+ * -# Berendsen
+ *  \f$p_i \rightarrow \left [ 1+ \frac{\delta t}{\tau_T} \left ( \frac{T_0}{T} \right ) \right ]^{\frac{1}{2}} \cdot p_i\f$
+ * -# Nose-Hoover
+ *  \f$\zeta p_i \f$ with \f$\frac{\partial \zeta}{\partial t} = \frac{1}{M_s} \left ( \sum^N_{i=1} \frac{p_i^2}{m_i} - g k_B T \right )\f$
+ * These Thermostats either simply rescale the velocities, thus this function should be called after ion velocities have been updated, and/or
+ * have a constraint force acting additionally on the ions. In the latter case, the ion speeds have to be modified
+ * belatedly and the constraint force set.
+ * \param *P Problem at hand
+ * \param i which of the thermostats to take: 0 - none, 1 - Woodcock, 2 - Gaussian, 3 - Langevin, 4 - Berendsen, 5 - Nose-Hoover
+ * \sa InitThermostat()
+ */
+void molecule::Thermostats(config &configuration, double ActualTemp, int Thermostat)
+{
+  double ekin = 0.;
+  double E = 0., G = 0.;
+  double delta_alpha = 0.;
+  double ScaleTempFactor;
+  double sigma;
+  double IonMass;
+  int d;
+  gsl_rng * r;
+  const gsl_rng_type * T;
+  double *U = NULL, *F = NULL, FConstraint[NDIM];
+  atom *walker = NULL;
+  // calculate scale configuration
+  ScaleTempFactor = configuration.TargetTemp/ActualTemp;
+  // differentating between the various thermostats
+  switch(Thermostat) {
+     case None:
+      cout << Verbose(2) <<  "Applying no thermostat..." << endl;
+      break;
+     case Woodcock:
+      if ((configuration.ScaleTempStep > 0) && ((MDSteps-1) % configuration.ScaleTempStep == 0)) {
+        cout << Verbose(2) <<  "Applying Woodcock thermostat..." << endl;
         walker = start;
         while (walker->next != end) { // go through every atom of this element
           walker = walker->next;
+          if (walker->type == runner) { // if this atom fits to element
+            // check size of vectors
+            if (Trajectories[walker].R.size() <= (unsigned int)(MDSteps)) {
+              //cout << "Increasing size for trajectory array of " << *walker << " to " << (size+10) << "." << endl;
+              Trajectories[walker].R.resize(MDSteps+10);
+              Trajectories[walker].U.resize(MDSteps+10);
+              Trajectories[walker].F.resize(MDSteps+10);
+          IonMass = walker->type->mass;
+          U = Trajectories[walker].U.at(MDSteps).x;
+          if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
+            for (d=0; d<NDIM; d++) {
+              U[d] *= sqrt(ScaleTempFactor);
+              ekin += 0.5*IonMass * U[d]*U[d];
+            }
+            // 1. calculate x(t+\delta t)
+            for (int d=0; d<NDIM; d++) {
+              Trajectories[walker].F.at(MDSteps).x[d] = -Force.Matrix[0][AtomNo][d+5];
+              Trajectories[walker].R.at(MDSteps).x[d] = Trajectories[walker].R.at(MDSteps-1).x[d];
+              Trajectories[walker].R.at(MDSteps).x[d] += delta_t*(Trajectories[walker].U.at(MDSteps-1).x[d]);
+              Trajectories[walker].R.at(MDSteps).x[d] += 0.5*delta_t*delta_t*(Trajectories[walker].F.at(MDSteps-1).x[d])/IonMass;    // F = m * a and s = 0.5 * F/m * t^2 = F * a * t
+        }
+      }
+      break;
+     case Gaussian:
+      cout << Verbose(2) <<  "Applying Gaussian thermostat..." << endl;
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        U = Trajectories[walker].U.at(MDSteps).x;
+        F = Trajectories[walker].F.at(MDSteps).x;
+        if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
+          for (d=0; d<NDIM; d++) {
+            G += U[d] * F[d];
+            E += U[d]*U[d]*IonMass;
+          }
+      }
+      cout << Verbose(1) << "Gaussian Least Constraint constant is " << G/E << "." << endl;
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        U = Trajectories[walker].U.at(MDSteps).x;
+        F = Trajectories[walker].F.at(MDSteps).x;
+        if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
+          for (d=0; d<NDIM; d++) {
+            FConstraint[d] = (G/E) * (U[d]*IonMass);
+            U[d] += configuration.Deltat/IonMass * (FConstraint[d]);
+            ekin += IonMass * U[d]*U[d];
+          }
+      }
+      break;
+     case Langevin:
+      cout << Verbose(2) <<  "Applying Langevin thermostat..." << endl;
+      // init random number generator
+      gsl_rng_env_setup();
+      T = gsl_rng_default;
+      r = gsl_rng_alloc (T);
+      // Go through each ion
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        sigma  = sqrt(configuration.TargetTemp/IonMass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
+        U = Trajectories[walker].U.at(MDSteps).x;
+        F = Trajectories[walker].F.at(MDSteps).x;
+        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
+          // throw a dice to determine whether it gets hit by a heat bath particle
+          if (((((rand()/(double)RAND_MAX))*configuration.TempFrequency) < 1.)) {
+            cout << Verbose(3) << "Particle " << *walker << " was hit (sigma " << sigma << "): " << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << " -> ";
+            // pick three random numbers from a Boltzmann distribution around the desired temperature T for each momenta axis
+            for (d=0; d<NDIM; d++) {
+              U[d] = gsl_ran_gaussian (r, sigma);
+            }
+            // 2. Calculate v(t+\delta t)
+            for (int d=0; d<NDIM; d++) {
+              Trajectories[walker].U.at(MDSteps).x[d] = Trajectories[walker].U.at(MDSteps-1).x[d];
+              Trajectories[walker].U.at(MDSteps).x[d] += 0.5*delta_t*(Trajectories[walker].F.at(MDSteps-1).x[d]+Trajectories[walker].F.at(MDSteps).x[d])/IonMass;
+            }
+//            cout << "Integrated position&velocity of step " << (MDSteps) << ": (";
+//            for (int d=0;d<NDIM;d++)
+//              cout << Trajectories[walker].R.at(MDSteps).x[d] << " ";          // next step
+//            cout << ")\t(";
+//            for (int d=0;d<NDIM;d++)
+//              cout << Trajectories[walker].U.at(MDSteps).x[d] << " ";          // next step
+//            cout << ")" << endl;
+            // next atom
+            AtomNo++;
+            cout << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << endl;
+          }
+          for (d=0; d<NDIM; d++)
+            ekin += 0.5*IonMass * U[d]*U[d];
+        }
+      }
+      break;
+     case Berendsen:
+      cout << Verbose(2) <<  "Applying Berendsen-VanGunsteren thermostat..." << endl;
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        U = Trajectories[walker].U.at(MDSteps).x;
+        F = Trajectories[walker].F.at(MDSteps).x;
+        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
+          for (d=0; d<NDIM; d++) {
+            U[d] *= sqrt(1+(configuration.Deltat/configuration.TempFrequency)*(ScaleTempFactor-1));
+            ekin += 0.5*IonMass * U[d]*U[d];
+          }
+        }
+      }
+    }
+  }
+//  // correct velocities (rather momenta) so that center of mass remains motionless
+//  tmpvector.zero()
+//  IonMass = 0.;
+//  walker = start;
+//  while (walker->next != end) { // go through every atom
+//    walker = walker->next;
+//    IonMass += walker->type->mass;  // sum up total mass
+//    for(int d=0;d<NDIM;d++) {
+//      tmpvector.x[d] += Trajectories[walker].U.at(MDSteps).x[d]*walker->type->mass;
+//    }
+//  }
+//  walker = start;
+//  while (walker->next != end) { // go through every atom of this element
+//    walker = walker->next;
+//    for(int d=0;d<NDIM;d++) {
+//      Trajectories[walker].U.at(MDSteps).x[d] -= tmpvector.x[d]*walker->type->mass/IonMass;
+//    }
+//  }
+  MDSteps++;
+  // exit
+  return true;
+};
+/** Align all atoms in such a manner that given vector \a *n is along z axis.
+      break;
+     case NoseHoover:
+      cout << Verbose(2) <<  "Applying Nose-Hoover thermostat..." << endl;
+      // dynamically evolve alpha (the additional degree of freedom)
+      delta_alpha = 0.;
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        U = Trajectories[walker].U.at(MDSteps).x;
+        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
+          for (d=0; d<NDIM; d++) {
+            delta_alpha += U[d]*U[d]*IonMass;
+          }
+        }
+      }
+      delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
+      configuration.alpha += delta_alpha*configuration.Deltat;
+      cout << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl;
+      // apply updated alpha as additional force
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        IonMass = walker->type->mass;
+        U = Trajectories[walker].U.at(MDSteps).x;
+        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
+          for (d=0; d<NDIM; d++) {
+              FConstraint[d] = - configuration.alpha * (U[d] * IonMass);
+              U[d] += configuration.Deltat/IonMass * (FConstraint[d]);
+              ekin += (0.5*IonMass) * U[d]*U[d];
+            }
+        }
+      }
+      break;
+  }
+  cout << Verbose(1) << "Kinetic energy is " << ekin << "." << endl;
+};
+/** Align all atoms in such a manner that given vector \a *n is along z axis.
  * \param n[] alignment vector.
  */
 …
   Vector x;
   int FalseBondDegree = 0;
   BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
   *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
 …
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
+    *out << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
     LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
 //    // check the list of local atoms for debugging
 …
     delete(LocalBackEdgeStack);
+  }
   // ===== 3. if structure still valid, parse key set file and others =====
   FragmentationToDo = FragmentationToDo && ParseKeySetFile(out, configuration->configpath, ParsedFragmentList);
 …
   // ===== 4. check globally whether there's something to do actually (first adaptivity check)
   FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(out, configuration->configpath);
   // =================================== Begin of FRAGMENTATION ===============================
   // ===== 6a. assign each keyset to its respective subgraph =====
+  // =================================== Begin of FRAGMENTATION ===============================
+  // ===== 6a. assign each keyset to its respective subgraph =====
   Subgraphs->next->AssignKeySetsToFragment(out, this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, (FragmentCounter = 0), true);
 …
   delete(ParsedFragmentList);
   delete[](MinimumRingSize);
   // ==================================== End of FRAGMENTATION ============================================
 …
   atom *Walker = NULL, *OtherAtom = NULL;
   ReferenceStack->Push(Binder);
   do {  // go through all bonds and push local ones
     Walker = ListOfLocalAtoms[Binder->leftatom->nr];  // get one atom in the reference molecule
 …
 };
+/** Creates \a MoleculeListClass of all unique fragments of the \a molecule containing \a Order atoms or vertices.
+ * The picture to have in mind is that of a DFS "snake" of a certain length \a Order, i.e. as in the infamous
+ * computer game, that winds through the connected graph representing the molecule. Color (white,
+ * lightgray, darkgray, black) indicates whether a vertex has been discovered so far or not. Labels will help in
+ * creating only unique fragments and not additional ones with vertices simply in different sequence.
+ * The Predecessor is always the one that came before in discovering, needed on backstepping. And
+ * finally, the ShortestPath is needed for removing vertices from the snake stack during the back-
+ * stepping.
+ * \param *out output stream for debugging
+ * \param Order number of atoms in each fragment
+ * \param *configuration configuration for writing config files for each fragment
+ * \return List of all unique fragments with \a Order atoms
+ */
+/*
+MoleculeListClass * molecule::CreateListOfUniqueFragmentsOfOrder(ofstream *out, int Order, config *configuration)
+{
+  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+  int *Labels = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+  enum Shading *ColorVertexList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+  enum Shading *ColorEdgeList = (enum Shading *) Malloc(sizeof(enum Shading)*BondCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorBondList");
+  StackClass<atom *> *RootStack = new StackClass<atom *>(AtomCount);
+  StackClass<atom *> *TouchedStack = new StackClass<atom *>((int)pow(4,Order)+2); // number of atoms reached from one with maximal 4 bonds plus Root itself
+  StackClass<atom *> *SnakeStack = new StackClass<atom *>(Order+1); // equal to Order is not possible, as then the StackClass<atom *> cannot discern between full and empty stack!
+  MoleculeLeafClass *Leaflet = NULL, *TempLeaf = NULL;
+  MoleculeListClass *FragmentList = NULL;
+  atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL, *Removal = NULL;
+  bond *Binder = NULL;
+  int RunningIndex = 0, FragmentCounter = 0;
+  *out << Verbose(1) << "Begin of CreateListOfUniqueFragmentsOfOrder." << endl;
+  // reset parent list
+  *out << Verbose(3) << "Resetting labels, parent, predecessor, color and shortest path lists." << endl;
+  for (int i=0;i<AtomCount;i++) { // reset all atom labels
+    // initialise each vertex as white with no predecessor, empty queue, color lightgray, not labelled, no sons
+    Labels[i] = -1;
+    SonList[i] = NULL;
+    PredecessorList[i] = NULL;
+    ColorVertexList[i] = white;
+    ShortestPathList[i] = -1;
+  }
+  for (int i=0;i<BondCount;i++)
+    ColorEdgeList[i] = white;
+  RootStack->ClearStack();  // clearstack and push first atom if exists
+  TouchedStack->ClearStack();
+  Walker = start->next;
+  while ((Walker != end)
+#ifdef ADDHYDROGEN
+   && (Walker->type->Z == 1)
+        }
+      }
+      *out << ", SP of " << ShortestPathList[Walker->nr]  << " and its color is " << GetColor(ColorVertexList[Walker->nr]) << "." << endl;
+      // then check the stack for a newly stumbled upon fragment
+      if (SnakeStack->ItemCount() == Order) { // is stack full?
+        // store the fragment if it is one and get a removal candidate
+        Removal = StoreFragmentFromStack(out, Root, Walker, Leaflet, SnakeStack, ShortestPathList, SonList, Labels, &FragmentCounter, configuration);
+        // remove the candidate if one was found
+        if (Removal != NULL) {
+          *out << Verbose(2) << "Removing item " << Removal->Name << " with SP of " << ShortestPathList[Removal->nr] << " from snake stack." << endl;
+          SnakeStack->RemoveItem(Removal);
+          ColorVertexList[Removal->nr] = lightgray; // return back to not on snake stack but explored marking
+          if (Walker == Removal) { // if the current atom is to be removed, we also have to take a step back
+            Walker = PredecessorList[Removal->nr];
+            *out << Verbose(2) << "Stepping back to " << Walker->Name << "." << endl;
+          }
+        }
+      } else
+        Removal = NULL;
+      // finally, look for a white neighbour as the next Walker
+      Binder = NULL;
+      if ((Removal == NULL) || (Walker != PredecessorList[Removal->nr])) {  // don't look, if a new walker has been set above
+        *out << Verbose(2) << "Snake has currently " << SnakeStack->ItemCount() << " item(s)." << endl;
+        OtherAtom = NULL; // this is actually not needed, every atom has at least one neighbour
+        if (ShortestPathList[Walker->nr] < Order) {
+          for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+            Binder = ListOfBondsPerAtom[Walker->nr][i];
+            *out << Verbose(2) << "Current bond is " << *Binder << ": ";
+            OtherAtom = Binder->GetOtherAtom(Walker);
+            if ((Labels[OtherAtom->nr] != -1) && (Labels[OtherAtom->nr] < Labels[Root->nr])) { // we don't step up to labels bigger than us
+              *out << "Label " << Labels[OtherAtom->nr] << " is smaller than Root's " << Labels[Root->nr] << "." << endl;
+              //ColorVertexList[OtherAtom->nr] = lightgray;    // mark as explored
+            } else { // otherwise check its colour and element
+              if (
+              (OtherAtom->type->Z != 1) &&
+#endif
+                    (ColorEdgeList[Binder->nr] == white)) {  // skip hydrogen, look for unexplored vertices
+                *out << "Moving along " << GetColor(ColorEdgeList[Binder->nr]) << " bond " << Binder << " to " << ((ColorVertexList[OtherAtom->nr] == white) ? "unexplored" : "explored") << " item: " << OtherAtom->Name << "." << endl;
+                // i find it currently rather sensible to always set the predecessor in order to find one's way back
+                //if (PredecessorList[OtherAtom->nr] == NULL) {
+                PredecessorList[OtherAtom->nr] = Walker;
+                *out << Verbose(3) << "Setting Predecessor of " << OtherAtom->Name << " to " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
+                //} else {
+                //  *out << Verbose(3) << "Predecessor of " << OtherAtom->Name << " is " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
+                //}
+                Walker = OtherAtom;
+                break;
+              } else {
+                if (OtherAtom->type->Z == 1)
+                  *out << "Links to a hydrogen atom." << endl;
+                else
+                  *out << "Bond has not white but " << GetColor(ColorEdgeList[Binder->nr]) << " color." << endl;
+              }
+            }
+          }
+        } else {  // means we have stepped beyond the horizon: Return!
+          Walker = PredecessorList[Walker->nr];
+          OtherAtom = Walker;
+          *out << Verbose(3) << "We have gone too far, stepping back to " << Walker->Name << "." << endl;
+        }
+        if (Walker != OtherAtom) {  // if no white neighbours anymore, color it black
+          *out << Verbose(2) << "Coloring " << Walker->Name << " black." << endl;
+          ColorVertexList[Walker->nr] = black;
+          Walker = PredecessorList[Walker->nr];
+        }
+      }
+    } while ((Walker != Root) || (ColorVertexList[Root->nr] != black));
+    *out << Verbose(2) << "Inner Looping is finished." << endl;
+    // if we reset all AtomCount atoms, we have again technically O(N^2) ...
+    *out << Verbose(2) << "Resetting lists." << endl;
+    Walker = NULL;
+    Binder = NULL;
+    while (!TouchedStack->IsEmpty()) {
+      Walker = TouchedStack->PopLast();
+      *out << Verbose(3) << "Re-initialising entries of " << *Walker << "." << endl;
+      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
+        ColorEdgeList[ListOfBondsPerAtom[Walker->nr][i]->nr] = white;
+      PredecessorList[Walker->nr] = NULL;
+      ColorVertexList[Walker->nr] = white;
+      ShortestPathList[Walker->nr] = -1;
+    }
+  }
+  *out << Verbose(1) << "Outer Looping over all vertices is done." << endl;
+  // copy together
+  *out << Verbose(1) << "Copying all fragments into MoleculeList structure." << endl;
+  FragmentList = new MoleculeListClass(FragmentCounter, AtomCount);
+  RunningIndex = 0;
+  while ((Leaflet != NULL) && (RunningIndex < FragmentCounter))  {
+    FragmentList->ListOfMolecules[RunningIndex++] = Leaflet->Leaf;
+    Leaflet->Leaf = NULL; // prevent molecule from being removed
+    TempLeaf = Leaflet;
+    Leaflet = Leaflet->previous;
+    delete(TempLeaf);
+  };
+  // free memory and exit
+  Free((void **)&PredecessorList, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+  Free((void **)&Labels, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+  Free((void **)&ColorVertexList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+  delete(RootStack);
+  delete(TouchedStack);
+  delete(SnakeStack);
+  *out << Verbose(1) << "End of CreateListOfUniqueFragmentsOfOrder." << endl;
+  return FragmentList;
+};
+*/
 /** Structure containing all values in power set combination generation.
  */
 …
   if (result) {
     *out << Verbose(5) << "Calculating Centers of Gravity" << endl;
     DetermineCenter(CenterOfGravity);
     OtherMolecule->DetermineCenter(OtherCenterOfGravity);
+    DeterminePeriodicCenter(CenterOfGravity);
+    OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
     *out << Verbose(5) << "Center of Gravity: ";
     CenterOfGravity.Output(out);

src/molecules.hpp

-              r375b458
+              r51c910
 // GSL headers
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_heapsort.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_matrix.h>
 #include <gsl/gsl_multimin.h>
 #include <gsl/gsl_vector.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_heapsort.h>
+#include <gsl/gsl_randist.h>
 // STL headers
 …
 struct KeyCompare
+{
         bool operator() (const KeySet SubgraphA, const KeySet SubgraphB) const;
+  bool operator() (const KeySet SubgraphA, const KeySet SubgraphB) const;
 };
 struct Trajectory
+{
         vector<Vector> R;       //!< position vector
         vector<Vector> U;       //!< velocity vector
         vector<Vector> F;       //!< last force vector
         atom *ptr;                               //!< pointer to atom whose trajectory we contain
 };
 //bool operator < (KeySet SubgraphA, KeySet SubgraphB);  //note: this declaration is important, otherwise normal < is used (producing wrong order)
+  vector<Vector> R;  //!< position vector
+  vector<Vector> U;  //!< velocity vector
+  vector<Vector> F;  //!< last force vector
+  atom *ptr;         //!< pointer to atom whose trajectory we contain
+};
+//bool operator < (KeySet SubgraphA, KeySet SubgraphB);   //note: this declaration is important, otherwise normal < is used (producing wrong order)
 inline void InsertFragmentIntoGraph(ofstream *out, struct UniqueFragments *Fragment); // Insert a KeySet into a Graph
 inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter);    // Insert all KeySet's in a Graph into another Graph
+inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter);  // Insert all KeySet's in a Graph into another Graph
 int CompareDoubles (const void * a, const void * b);
 …
 // some algebraic matrix stuff
 #define RDET3(a) ((a)[0]*(a)[4]*(a)[8] + (a)[3]*(a)[7]*(a)[2] + (a)[6]*(a)[1]*(a)[5] - (a)[2]*(a)[4]*(a)[6] - (a)[5]*(a)[7]*(a)[0] - (a)[8]*(a)[1]*(a)[3])      //!< hard-coded determinant of a 3x3 matrix
 #define RDET2(a0,a1,a2,a3) ((a0)*(a3)-(a1)*(a2))                                                                                        //!< hard-coded determinant of a 2x2 matrix
+#define RDET3(a) ((a)[0]*(a)[4]*(a)[8] + (a)[3]*(a)[7]*(a)[2] + (a)[6]*(a)[1]*(a)[5] - (a)[2]*(a)[4]*(a)[6] - (a)[5]*(a)[7]*(a)[0] - (a)[8]*(a)[1]*(a)[3])  //!< hard-coded determinant of a 3x3 matrix
+#define RDET2(a0,a1,a2,a3) ((a0)*(a3)-(a1)*(a2))                      //!< hard-coded determinant of a 2x2 matrix
 …
  */
 struct LSQ_params {
         Vector **vectors;
         int num;
+  Vector **vectors;
+  int num;
 };
 …
  */
 struct lsq_params {
         gsl_vector *x;
         const molecule *mol;
         element *type;
+  gsl_vector *x;
+  const molecule *mol;
+  element *type;
 };
 …
  */
 class atom {
         public:
                 Vector x;                        //!< coordinate array of atom, giving position within cell
                 Vector v;                        //!< velocity array of atom
                 element *type;  //!< pointing to element
                 atom *previous; //!< previous atom in molecule list
                 atom *next;              //!< next atom in molecule list
                 atom *father;    //!< In many-body bond order fragmentations points to originating atom
                 atom *Ancestor; //!< "Father" in Depth-First-Search
                 char *Name;                     //!< unique name used during many-body bond-order fragmentation
                 int FixedIon;    //!< config variable that states whether forces act on the ion or not
                 int *sort;                      //!< sort criteria
                 int nr;                          //!< continuous, unique number
                 int GraphNr;                    //!< unique number, given in DepthFirstSearchAnalysis()
                 int *ComponentNr;//!< belongs to this nonseparable components, given in DepthFirstSearchAnalysis() (if more than one, then is SeparationVertex)
                 int LowpointNr; //!< needed in DepthFirstSearchAnalysis() to detect nonseparable components, is the lowest possible number of an atom to reach via tree edges only followed by at most one back edge.
                 bool SeparationVertex; //!< whether this atom separates off subsets of atoms or not, determined in DepthFirstSearchAnalysis()
                 bool IsCyclic;                          //!< whether atom belong to as cycle or not, determined in DepthFirstSearchAnalysis()
                 unsigned char AdaptiveOrder;    //!< current present bond order at site (0 means "not set")
                 bool MaxOrder;  //!< whether this atom as a root in fragmentation still creates more fragments on higher orders or not
         atom();
         ~atom();
         bool Output(int ElementNo, int AtomNo, ofstream *out, const char *comment = NULL) const;
         bool OutputXYZLine(ofstream *out) const;
         atom *GetTrueFather();
         bool Compare(atom &ptr);
         private:
 };
 ostream & operator << (ostream &ost, atom &a);
+  public:
+    Vector x;       //!< coordinate array of atom, giving position within cell
+    Vector v;       //!< velocity array of atom
+    element *type;  //!< pointing to element
+    atom *previous; //!< previous atom in molecule list
+    atom *next;     //!< next atom in molecule list
+    atom *father;   //!< In many-body bond order fragmentations points to originating atom
+    atom *Ancestor; //!< "Father" in Depth-First-Search
+    char *Name;      //!< unique name used during many-body bond-order fragmentation
+    int FixedIon;   //!< config variable that states whether forces act on the ion or not
+    int *sort;      //!< sort criteria
+    int nr;         //!< continuous, unique number
+    int GraphNr;      //!< unique number, given in DepthFirstSearchAnalysis()
+    int *ComponentNr;//!< belongs to this nonseparable components, given in DepthFirstSearchAnalysis() (if more than one, then is SeparationVertex)
+    int LowpointNr; //!< needed in DepthFirstSearchAnalysis() to detect nonseparable components, is the lowest possible number of an atom to reach via tree edges only followed by at most one back edge.
+    bool SeparationVertex; //!< whether this atom separates off subsets of atoms or not, determined in DepthFirstSearchAnalysis()
+    bool IsCyclic;        //!< whether atom belong to as cycle or not, determined in DepthFirstSearchAnalysis()
+    unsigned char AdaptiveOrder;  //!< current present bond order at site (0 means "not set")
+    bool MaxOrder;  //!< whether this atom as a root in fragmentation still creates more fragments on higher orders or not
+  atom();
+  ~atom();
+  bool Output(int ElementNo, int AtomNo, ofstream *out, const char *comment = NULL) const;
+  bool OutputXYZLine(ofstream *out) const;
+  atom *GetTrueFather();
+  bool Compare(atom &ptr);
+  private:
+};
+ostream & operator << (ostream &ost, const atom &a);
 /** Bonds between atoms.
 …
  */
 class bond {
+        public:
+                atom *leftatom;         //!< first bond partner
+                atom *rightatom;        //!< second bond partner
+                bond *previous; //!< previous atom in molecule list
+                bond *next;              //!< next atom in molecule list
+                int HydrogenBond;       //!< Number of hydrogen atoms in the bond
+                int BondDegree;         //!< single, double, triple, ... bond
+                int nr;                                  //!< unique number in a molecule, updated by molecule::CreateAdjacencyList()
+                bool Cyclic;                    //!< flag whether bond is part of a cycle or not, given in DepthFirstSearchAnalysis()
+                enum EdgeType Type;//!< whether this is a tree or back edge
+        atom * GetOtherAtom(atom *Atom) const;
+        bond * GetFirstBond();
+        bond * GetLastBond();
+        bool MarkUsed(enum Shading color);
+        enum Shading IsUsed();
+        void ResetUsed();
+        bool Contains(const atom *ptr);
+        bool Contains(const int nr);
+        bond();
+        bond(atom *left, atom *right);
+        bond(atom *left, atom *right, int degree);
+        bond(atom *left, atom *right, int degree, int number);
+        ~bond();
+        private:
+                enum Shading Used;                              //!< marker in depth-first search, DepthFirstSearchAnalysis()
+};
+ostream & operator << (ostream &ost, bond &b);
+  public:
+    atom *leftatom;    //!< first bond partner
+    atom *rightatom;  //!< second bond partner
+    bond *previous; //!< previous atom in molecule list
+    bond *next;     //!< next atom in molecule list
+    int HydrogenBond;  //!< Number of hydrogen atoms in the bond
+    int BondDegree;    //!< single, double, triple, ... bond
+    int nr;           //!< unique number in a molecule, updated by molecule::CreateAdjacencyList()
+    bool Cyclic;      //!< flag whether bond is part of a cycle or not, given in DepthFirstSearchAnalysis()
+    enum EdgeType Type;//!< whether this is a tree or back edge
+  atom * GetOtherAtom(atom *Atom) const;
+  bond * GetFirstBond();
+  bond * GetLastBond();
+  bool MarkUsed(enum Shading color);
+  enum Shading IsUsed();
+  void ResetUsed();
+  bool Contains(const atom *ptr);
+  bool Contains(const int nr);
+  bond();
+  bond(atom *left, atom *right);
+  bond(atom *left, atom *right, int degree);
+  bond(atom *left, atom *right, int degree, int number);
+  ~bond();
+  private:
+    enum Shading Used;        //!< marker in depth-first search, DepthFirstSearchAnalysis()
+};
+ostream & operator << (ostream &ost, const bond &b);
 class MoleculeLeafClass;
+#define MaxThermostats 6      //!< maximum number of thermostat entries in Ions#ThermostatNames and Ions#ThermostatImplemented
+enum thermostats { None, Woodcock, Gaussian, Langevin, Berendsen, NoseHoover };   //!< Thermostat names for output
 /** The complete molecule.
 …
  */
 class molecule {
+        public:
+                double cell_size[6];//!< cell size
+                periodentafel *elemente; //!< periodic table with each element
+                atom *start;                            //!< start of atom list
+                atom *end;                                      //!< end of atom list
+                bond *first;                            //!< start of bond list
+                bond *last;                              //!< end of bond list
+                bond ***ListOfBondsPerAtom; //!< pointer list for each atom and each bond it has
+                map<atom *, struct Trajectory> Trajectories; //!< contains old trajectory points
+                int MDSteps;                            //!< The number of MD steps in Trajectories
+                int *NumberOfBondsPerAtom;      //!< Number of Bonds each atom has
+                int AtomCount;                                  //!< number of atoms, brought up-to-date by CountAtoms()
+                int BondCount;                                  //!< number of atoms, brought up-to-date by CountBonds()
+                int ElementCount;                        //!< how many unique elements are therein
+                int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
+                int NoNonHydrogen;      //!< number of non-hydrogen atoms in molecule
+                int NoNonBonds;          //!< number of non-hydrogen bonds in molecule
+                int NoCyclicBonds;      //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
+                double BondDistance;    //!< typical bond distance used in CreateAdjacencyList() and furtheron
+                bool ActiveFlag;    //!< in a MoleculeListClass used to discern active from inactive molecules
+                Vector Center;      //!< Center of molecule in a global box
+                char name[MAXSTRINGSIZE];         //!< arbitrary name
+                int IndexNr;        //!< index of molecule in a MoleculeListClass
+        molecule(periodentafel *teil);
+        ~molecule();
+        /// remove atoms from molecule.
+        bool AddAtom(atom *pointer);
+        bool RemoveAtom(atom *pointer);
+        bool UnlinkAtom(atom *pointer);
+        bool CleanupMolecule();
+        /// Add/remove atoms to/from molecule.
+        atom * AddCopyAtom(atom *pointer);
+        bool AddXYZFile(string filename);
+        bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
+        bond * AddBond(atom *first, atom *second, int degree);
+        bool RemoveBond(bond *pointer);
+        bool RemoveBonds(atom *BondPartner);
+        /// Find atoms.
+        atom * FindAtom(int Nr) const;
+        atom * AskAtom(string text);
+        /// Count and change present atoms' coordination.
+        void CountAtoms(ofstream *out);
+        void CountElements();
+        void CalculateOrbitals(class config &configuration);
+        bool CenterInBox(ofstream *out, Vector *BoxLengths);
+        void CenterEdge(ofstream *out, Vector *max);
+        void CenterOrigin(ofstream *out, Vector *max);
+        void CenterGravity(ofstream *out, Vector *max);
+        void Translate(const Vector *x);
+        void Mirror(const Vector *x);
+        void Align(Vector *n);
+        void Scale(double **factor);
+        void DetermineCenter(Vector &center);
+        Vector * DetermineCenterOfGravity(ofstream *out);
+        Vector * DetermineCenterOfAll(ofstream *out);
+        void SetNameFromFilename(char *filename);
+        void SetBoxDimension(Vector *dim);
+        double * ReturnFullMatrixforSymmetric(double *cell_size);
+        void ScanForPeriodicCorrection(ofstream *out);
+        void PrincipalAxisSystem(ofstream *out, bool DoRotate);
+        double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
+        Vector* FindEmbeddingHole(ofstream *out, molecule *srcmol);
+        bool VerletForceIntegration(char *file, double delta_t, bool IsAngstroem);
+        bool CheckBounds(const Vector *x) const;
+        void GetAlignvector(struct lsq_params * par) const;
+        /// Initialising routines in fragmentation
+        void CreateAdjacencyList2(ofstream *out, ifstream *output);
+        void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem);
+        void CreateListOfBondsPerAtom(ofstream *out);
+        // Graph analysis
+        MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack);
+        void CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize);
+        bool PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack);
+        bond * FindNextUnused(atom *vertex);
+        void SetNextComponentNumber(atom *vertex, int nr);
+        void InitComponentNumbers();
+        void OutputComponentNumber(ofstream *out, atom *vertex);
+        void ResetAllBondsToUnused();
+        void ResetAllAtomNumbers();
+        int CountCyclicBonds(ofstream *out);
+        bool CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment);
+        string GetColor(enum Shading color);
+        molecule *CopyMolecule();
+        /// Fragment molecule by two different approaches:
+        int FragmentMolecule(ofstream *out, int Order, config *configuration);
+        bool CheckOrderAtSite(ofstream *out, bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path = NULL);
+        bool StoreAdjacencyToFile(ofstream *out, char *path);
+        bool CheckAdjacencyFileAgainstMolecule(ofstream *out, char *path, atom **ListOfAtoms);
+        bool ParseOrderAtSiteFromFile(ofstream *out, char *path);
+        bool StoreOrderAtSiteFile(ofstream *out, char *path);
+        bool ParseKeySetFile(ofstream *out, char *filename, Graph *&FragmentList);
+        bool StoreKeySetFile(ofstream *out, Graph &KeySetList, char *path);
+        bool StoreForcesFile(ofstream *out, MoleculeListClass *BondFragments, char *path, int *SortIndex);
+        bool CreateMappingLabelsToConfigSequence(ofstream *out, int *&SortIndex);
+        bool ScanBufferIntoKeySet(ofstream *out, char *buffer, KeySet &CurrentSet);
+        void BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
+        /// -# BOSSANOVA
+        void FragmentBOSSANOVA(ofstream *out, Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
+        int PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
+        bool BuildInducedSubgraph(ofstream *out, const molecule *Father);
+        molecule * StoreFragmentFromKeySet(ofstream *out, KeySet &Leaflet, bool IsAngstroem);
+        void SPFragmentGenerator(ofstream *out, struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder);
+        int LookForRemovalCandidate(ofstream *&out, KeySet *&Leaf, int *&ShortestPathList);
+        int GuesstimateFragmentCount(ofstream *out, int order);
+        // Recognize doubly appearing molecules in a list of them
+        int * IsEqualToWithinThreshold(ofstream *out, molecule *OtherMolecule, double threshold);
+        int * GetFatherSonAtomicMap(ofstream *out, molecule *OtherMolecule);
+        // Output routines.
+        bool Output(ofstream *out);
+        bool OutputTrajectories(ofstream *out);
+        void OutputListOfBonds(ofstream *out) const;
+        bool OutputXYZ(ofstream *out) const;
+        bool OutputTrajectoriesXYZ(ofstream *out);
+        bool Checkout(ofstream *out) const;
+        bool OutputTemperatureFromTrajectories(ofstream *out, int startstep, int endstep, ofstream *output);
+        private:
+        int last_atom;                  //!< number given to last atom
+  public:
+    double cell_size[6];//!< cell size
+    periodentafel *elemente; //!< periodic table with each element
+    atom *start;        //!< start of atom list
+    atom *end;          //!< end of atom list
+    bond *first;        //!< start of bond list
+    bond *last;         //!< end of bond list
+    bond ***ListOfBondsPerAtom; //!< pointer list for each atom and each bond it has
+    map<atom *, struct Trajectory> Trajectories; //!< contains old trajectory points
+    int MDSteps;        //!< The number of MD steps in Trajectories
+    int *NumberOfBondsPerAtom;  //!< Number of Bonds each atom has
+    int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
+    int BondCount;          //!< number of atoms, brought up-to-date by CountBonds()
+    int ElementCount;       //!< how many unique elements are therein
+    int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
+    int NoNonHydrogen;  //!< number of non-hydrogen atoms in molecule
+    int NoNonBonds;     //!< number of non-hydrogen bonds in molecule
+    int NoCyclicBonds;  //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
+    double BondDistance;  //!< typical bond distance used in CreateAdjacencyList() and furtheron
+    bool ActiveFlag;    //!< in a MoleculeListClass used to discern active from inactive molecules
+    Vector Center;      //!< Center of molecule in a global box
+    char name[MAXSTRINGSIZE];         //!< arbitrary name
+    int IndexNr;        //!< index of molecule in a MoleculeListClass
+  molecule(periodentafel *teil);
+  ~molecule();
+  /// remove atoms from molecule.
+  bool AddAtom(atom *pointer);
+  bool RemoveAtom(atom *pointer);
+  bool UnlinkAtom(atom *pointer);
+  bool CleanupMolecule();
+  /// Add/remove atoms to/from molecule.
+  atom * AddCopyAtom(atom *pointer);
+  bool AddXYZFile(string filename);
+  bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
+  bond * AddBond(atom *first, atom *second, int degree);
+  bool RemoveBond(bond *pointer);
+  bool RemoveBonds(atom *BondPartner);
+  /// Find atoms.
+  atom * FindAtom(int Nr) const;
+  atom * AskAtom(string text);
+  /// Count and change present atoms' coordination.
+  void CountAtoms(ofstream *out);
+  void CountElements();
+  void CalculateOrbitals(class config &configuration);
+  bool CenterInBox(ofstream *out, Vector *BoxLengths);
+  void CenterEdge(ofstream *out, Vector *max);
+  void CenterOrigin(ofstream *out);
+  void CenterPeriodic(ofstream *out);
+  void CenterAtVector(ofstream *out, Vector *newcenter);
+  void Translate(const Vector *x);
+  void Mirror(const Vector *x);
+  void Align(Vector *n);
+  void Scale(double **factor);
+  void DeterminePeriodicCenter(Vector &center);
+  Vector * DetermineCenterOfGravity(ofstream *out);
+  Vector * DetermineCenterOfAll(ofstream *out);
+  void SetNameFromFilename(const char *filename);
+  void SetBoxDimension(Vector *dim);
+  double * ReturnFullMatrixforSymmetric(double *cell_size);
+  void ScanForPeriodicCorrection(ofstream *out);
+  bool VerletForceIntegration(ofstream *out, char *file, config &configuration);
+  void Thermostats(config &configuration, double ActualTemp, int Thermostat);
+  void PrincipalAxisSystem(ofstream *out, bool DoRotate);
+  double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
+  Vector* FindEmbeddingHole(ofstream *out, molecule *srcmol);
+  double ConstrainedPotential(ofstream *out, atom **permutation, int start, int end, double *constants, bool IsAngstroem);
+  double MinimiseConstrainedPotential(ofstream *out, atom **&permutation, int startstep, int endstep, bool IsAngstroem);
+  void EvaluateConstrainedForces(ofstream *out, int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
+  bool LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration);
+  bool CheckBounds(const Vector *x) const;
+  void GetAlignvector(struct lsq_params * par) const;
+  /// Initialising routines in fragmentation
+  void CreateAdjacencyList2(ofstream *out, ifstream *output);
+  void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem);
+  void CreateListOfBondsPerAtom(ofstream *out);
+  // Graph analysis
+  MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack);
+  void CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize);
+  bool PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack);
+  bond * FindNextUnused(atom *vertex);
+  void SetNextComponentNumber(atom *vertex, int nr);
+  void InitComponentNumbers();
+  void OutputComponentNumber(ofstream *out, atom *vertex);
+  void ResetAllBondsToUnused();
+  void ResetAllAtomNumbers();
+  int CountCyclicBonds(ofstream *out);
+  bool CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment);
+  string GetColor(enum Shading color);
+  molecule *CopyMolecule();
+  /// Fragment molecule by two different approaches:
+  int FragmentMolecule(ofstream *out, int Order, config *configuration);
+  bool CheckOrderAtSite(ofstream *out, bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path = NULL);
+  bool StoreAdjacencyToFile(ofstream *out, char *path);
+  bool CheckAdjacencyFileAgainstMolecule(ofstream *out, char *path, atom **ListOfAtoms);
+  bool ParseOrderAtSiteFromFile(ofstream *out, char *path);
+  bool StoreOrderAtSiteFile(ofstream *out, char *path);
+  bool ParseKeySetFile(ofstream *out, char *filename, Graph *&FragmentList);
+  bool StoreKeySetFile(ofstream *out, Graph &KeySetList, char *path);
+  bool StoreForcesFile(ofstream *out, MoleculeListClass *BondFragments, char *path, int *SortIndex);
+  bool CreateMappingLabelsToConfigSequence(ofstream *out, int *&SortIndex);
+  bool ScanBufferIntoKeySet(ofstream *out, char *buffer, KeySet &CurrentSet);
+  void BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
+  /// -# BOSSANOVA
+  void FragmentBOSSANOVA(ofstream *out, Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
+  int PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
+  bool BuildInducedSubgraph(ofstream *out, const molecule *Father);
+  molecule * StoreFragmentFromKeySet(ofstream *out, KeySet &Leaflet, bool IsAngstroem);
+  void SPFragmentGenerator(ofstream *out, struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder);
+  int LookForRemovalCandidate(ofstream *&out, KeySet *&Leaf, int *&ShortestPathList);
+  int GuesstimateFragmentCount(ofstream *out, int order);
+  // Recognize doubly appearing molecules in a list of them
+  int * IsEqualToWithinThreshold(ofstream *out, molecule *OtherMolecule, double threshold);
+  int * GetFatherSonAtomicMap(ofstream *out, molecule *OtherMolecule);
+  // Output routines.
+  bool Output(ofstream *out);
+  bool OutputTrajectories(ofstream *out);
+  void OutputListOfBonds(ofstream *out) const;
+  bool OutputXYZ(ofstream *out) const;
+  bool OutputTrajectoriesXYZ(ofstream *out);
+  bool Checkout(ofstream *out) const;
+  bool OutputTemperatureFromTrajectories(ofstream *out, int startstep, int endstep, ofstream *output);
+  private:
+  int last_atom;      //!< number given to last atom
 };
 …
  */
 class MoleculeListClass {
         public:
           MoleculeList ListOfMolecules; //!< List of the contained molecules
           int MaxIndex;
         MoleculeListClass();
         ~MoleculeListClass();
         bool AddHydrogenCorrection(ofstream *out, char *path);
         bool StoreForcesFile(ofstream *out, char *path, int *SortIndex);
         bool insert(molecule *mol);
         molecule * ReturnIndex(int index);
         bool OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex);
         int NumberOfActiveMolecules();
         void Enumerate(ofstream *out);
         void Output(ofstream *out);
         // merging of molecules
+  public:
+    MoleculeList ListOfMolecules; //!< List of the contained molecules
+    int MaxIndex;
+  MoleculeListClass();
+  ~MoleculeListClass();
+  bool AddHydrogenCorrection(ofstream *out, char *path);
+  bool StoreForcesFile(ofstream *out, char *path, int *SortIndex);
+  void insert(molecule *mol);
+  molecule * ReturnIndex(int index);
+  bool OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex);
+  int NumberOfActiveMolecules();
+  void Enumerate(ofstream *out);
+  void Output(ofstream *out);
+  // merging of molecules
   bool SimpleMerge(molecule *mol, molecule *srcmol);
   bool SimpleAdd(molecule *mol, molecule *srcmol);
 …
   bool EmbedMerge(molecule *mol, molecule *srcmol);
         private:
+  private:
 };
 …
  */
 class MoleculeLeafClass {
         public:
                 molecule *Leaf;                                                                  //!< molecule of this leaf
                 //MoleculeLeafClass *UpLeaf;                            //!< Leaf one level up
                 //MoleculeLeafClass *DownLeaf;                  //!< First leaf one level down
                 MoleculeLeafClass *previous;    //!< Previous leaf on this level
                 MoleculeLeafClass *next;                        //!< Next leaf on this level
         //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
         MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
         ~MoleculeLeafClass();
         bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
         bool FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
         bool FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
         bool AssignKeySetsToFragment(ofstream *out, molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
         bool FillListOfLocalAtoms(ofstream *out, atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList);
         void TranslateIndicesToGlobalIDs(ofstream *out, Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
         int Count() const;
+  public:
+    molecule *Leaf;                   //!< molecule of this leaf
+    //MoleculeLeafClass *UpLeaf;        //!< Leaf one level up
+    //MoleculeLeafClass *DownLeaf;      //!< First leaf one level down
+    MoleculeLeafClass *previous;  //!< Previous leaf on this level
+    MoleculeLeafClass *next;      //!< Next leaf on this level
+  //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
+  MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
+  ~MoleculeLeafClass();
+  bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
+  bool FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
+  bool FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
+  bool AssignKeySetsToFragment(ofstream *out, molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
+  bool FillListOfLocalAtoms(ofstream *out, atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList);
+  void TranslateIndicesToGlobalIDs(ofstream *out, Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
+  int Count() const;
 };
 …
  */
 class config {
+        public:
+                int PsiType;
+                int MaxPsiDouble;
+                int PsiMaxNoUp;
+                int PsiMaxNoDown;
+                int MaxMinStopStep;
+                int InitMaxMinStopStep;
+                int ProcPEGamma;
+                int ProcPEPsi;
+                char *configpath;
+                char *configname;
+                bool FastParsing;
+                double Deltat;
+                string basis;
+                private:
+                char *mainname;
+                char *defaultpath;
+                char *pseudopotpath;
+                int DoOutVis;
+                int DoOutMes;
+                int DoOutNICS;
+                int DoOutOrbitals;
+                int DoOutCurrent;
+                int DoFullCurrent;
+                int DoPerturbation;
+                int DoWannier;
+                int CommonWannier;
+                double SawtoothStart;
+                int VectorPlane;
+                double VectorCut;
+                int UseAddGramSch;
+                int Seed;
+                int MaxOuterStep;
+                int OutVisStep;
+                int OutSrcStep;
+                double TargetTemp;
+                int ScaleTempStep;
+                int MaxPsiStep;
+                double EpsWannier;
+                int MaxMinStep;
+                double RelEpsTotalEnergy;
+                double RelEpsKineticEnergy;
+                int MaxMinGapStopStep;
+                int MaxInitMinStep;
+                double InitRelEpsTotalEnergy;
+                double InitRelEpsKineticEnergy;
+                int InitMaxMinGapStopStep;
+                //double BoxLength[NDIM*NDIM];
+                double ECut;
+                int MaxLevel;
+                int RiemannTensor;
+                int LevRFactor;
+                int RiemannLevel;
+                int Lev0Factor;
+                int RTActualUse;
+                int AddPsis;
+                double RCut;
+                int StructOpt;
+                int IsAngstroem;
+                int RelativeCoord;
+                int MaxTypes;
+        int ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
+        public:
+        config();
+        ~config();
+        int TestSyntax(char *filename, periodentafel *periode, molecule *mol);
+        void Load(char *filename, periodentafel *periode, molecule *mol);
+        void LoadOld(char *filename, periodentafel *periode, molecule *mol);
+        void RetrieveConfigPathAndName(string filename);
+        bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
+        bool SaveMPQC(const char *filename, molecule *mol) const;
+        void Edit();
+        bool GetIsAngstroem() const;
+        char *GetDefaultPath() const;
+        void SetDefaultPath(const char *path);
+  public:
+    int PsiType;
+    int MaxPsiDouble;
+    int PsiMaxNoUp;
+    int PsiMaxNoDown;
+    int MaxMinStopStep;
+    int InitMaxMinStopStep;
+    int ProcPEGamma;
+    int ProcPEPsi;
+    char *configpath;
+    char *configname;
+    bool FastParsing;
+    double Deltat;
+    string basis;
+    int DoConstrainedMD;
+    int MaxOuterStep;
+    int Thermostat;
+    int *ThermostatImplemented;
+    char **ThermostatNames;
+    double TempFrequency;
+    double alpha;
+    double HooverMass;
+    double TargetTemp;
+    int ScaleTempStep;
+    private:
+    char *mainname;
+    char *defaultpath;
+    char *pseudopotpath;
+    int DoOutVis;
+    int DoOutMes;
+    int DoOutNICS;
+    int DoOutOrbitals;
+    int DoOutCurrent;
+    int DoFullCurrent;
+    int DoPerturbation;
+    int DoWannier;
+    int CommonWannier;
+    double SawtoothStart;
+    int VectorPlane;
+    double VectorCut;
+    int UseAddGramSch;
+    int Seed;
+    int OutVisStep;
+    int OutSrcStep;
+    int MaxPsiStep;
+    double EpsWannier;
+    int MaxMinStep;
+    double RelEpsTotalEnergy;
+    double RelEpsKineticEnergy;
+    int MaxMinGapStopStep;
+    int MaxInitMinStep;
+    double InitRelEpsTotalEnergy;
+    double InitRelEpsKineticEnergy;
+    int InitMaxMinGapStopStep;
+    //double BoxLength[NDIM*NDIM];
+    double ECut;
+    int MaxLevel;
+    int RiemannTensor;
+    int LevRFactor;
+    int RiemannLevel;
+    int Lev0Factor;
+    int RTActualUse;
+    int AddPsis;
+    double RCut;
+    int StructOpt;
+    int IsAngstroem;
+    int RelativeCoord;
+    int MaxTypes;
+  int ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
+  public:
+  config();
+  ~config();
+  int TestSyntax(char *filename, periodentafel *periode, molecule *mol);
+  void Load(char *filename, periodentafel *periode, molecule *mol);
+  void LoadOld(char *filename, periodentafel *periode, molecule *mol);
+  void RetrieveConfigPathAndName(string filename);
+  bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
+  bool SaveMPQC(const char *filename, molecule *mol) const;
+  void Edit();
+  bool GetIsAngstroem() const;
+  char *GetDefaultPath() const;
+  void SetDefaultPath(const char *path);
+  void InitThermostats(ifstream *source);
 };

src/parser.cpp

-              r375b458
+              r51c910
 bool FilePresent(const char *filename, bool test)
+{
         ifstream input;
         input.open(filename, ios::in);
         if (input == NULL) {
                 if (!test)
                         cout << endl << "Unable to open " << filename << ", is the directory correct?" << endl;
                 return false;
+        }
         input.close();
         return true;
+  ifstream input;
+  input.open(filename, ios::in);
+  if (input == NULL) {
+    if (!test)
+      cout << endl << "Unable to open " << filename << ", is the directory correct?" << endl;
+    return false;
+  }
+  input.close();
+  return true;
 };
 …
 bool TestParams(int argc, char **argv)
+{
         ifstream input;
         stringstream line;
         line << argv[1] << FRAGMENTPREFIX << KEYSETFILE;
         return FilePresent(line.str().c_str(), false);
+  ifstream input;
+  stringstream line;
+  line << argv[1] << FRAGMENTPREFIX << KEYSETFILE;
+  return FilePresent(line.str().c_str(), false);
 };
 …
  */
 MatrixContainer::MatrixContainer() {
+        Indices = NULL;
+        Header = (char *) Malloc(sizeof(char)*1023, "MatrixContainer::MatrixContainer: *Header");
+        Matrix = (double ***) Malloc(sizeof(double **)*(1), "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
+        RowCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *RowCounter");
+        Matrix[0] = NULL;
+        RowCounter[0] = -1;
+        MatrixCounter = 0;
+        ColumnCounter = 0;
+  Indices = NULL;
+  Header = (char **) Malloc(sizeof(char)*1, "MatrixContainer::MatrixContainer: **Header");
+  Matrix = (double ***) Malloc(sizeof(double **)*(1), "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
+  RowCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *RowCounter");
+  ColumnCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *ColumnCounter");
+  Header[0] = NULL;
+  Matrix[0] = NULL;
+  RowCounter[0] = -1;
+  MatrixCounter = 0;
+  ColumnCounter[0] = -1;
 };
 …
  */
 MatrixContainer::~MatrixContainer() {
+        if (Matrix != NULL) {
+                for(int i=MatrixCounter;i--;) {
+                        if (RowCounter != NULL) {
+                                        for(int j=RowCounter[i]+1;j--;)
+                                                Free((void **)&Matrix[i][j], "MatrixContainer::~MatrixContainer: *Matrix[][]");
+                                Free((void **)&Matrix[i], "MatrixContainer::~MatrixContainer: **Matrix[]");
+                        }
+                }
+                if ((RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
+                        for(int j=RowCounter[MatrixCounter]+1;j--;)
+                                Free((void **)&Matrix[MatrixCounter][j], "MatrixContainer::~MatrixContainer: *Matrix[MatrixCounter][]");
+                if (MatrixCounter != 0)
+                        Free((void **)&Matrix[MatrixCounter], "MatrixContainer::~MatrixContainer: **Matrix[MatrixCounter]");
+                Free((void **)&Matrix, "MatrixContainer::~MatrixContainer: ***Matrix");
+        }
+        if (Indices != NULL)
+                for(int i=MatrixCounter+1;i--;) {
+                        Free((void **)&Indices[i], "MatrixContainer::~MatrixContainer: *Indices[]");
+                }
+        Free((void **)&Indices, "MatrixContainer::~MatrixContainer: **Indices");
+        Free((void **)&Header, "MatrixContainer::~MatrixContainer: *Header");
+        Free((void **)&RowCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
+};
+  if (Matrix != NULL) {
+    for(int i=MatrixCounter;i--;) {
+      if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
+          for(int j=RowCounter[i]+1;j--;)
+            Free((void **)&Matrix[i][j], "MatrixContainer::~MatrixContainer: *Matrix[][]");
+        Free((void **)&Matrix[i], "MatrixContainer::~MatrixContainer: **Matrix[]");
+      }
+    }
+    if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
+      for(int j=RowCounter[MatrixCounter]+1;j--;)
+        Free((void **)&Matrix[MatrixCounter][j], "MatrixContainer::~MatrixContainer: *Matrix[MatrixCounter][]");
+    if (MatrixCounter != 0)
+      Free((void **)&Matrix[MatrixCounter], "MatrixContainer::~MatrixContainer: **Matrix[MatrixCounter]");
+    Free((void **)&Matrix, "MatrixContainer::~MatrixContainer: ***Matrix");
+  }
+  if (Indices != NULL)
+    for(int i=MatrixCounter+1;i--;) {
+      Free((void **)&Indices[i], "MatrixContainer::~MatrixContainer: *Indices[]");
+    }
+  Free((void **)&Indices, "MatrixContainer::~MatrixContainer: **Indices");
+  if (Header != NULL)
+    for(int i=MatrixCounter+1;i--;)
+      Free((void **)&Header[i], "MatrixContainer::~MatrixContainer: *Header[]");
+  Free((void **)&Header, "MatrixContainer::~MatrixContainer: **Header");
+  Free((void **)&RowCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
+  Free((void **)&ColumnCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
+};
+/** Either copies index matrix from another MatrixContainer or initialises with trivial mapping if NULL.
+ * This either copies the index matrix or just maps 1 to 1, 2 to 2 and so on for all fragments.
+ * \param *Matrix pointer to other MatrixContainer
+ * \return true - copy/initialisation sucessful, false - dimension false for copying
+ */
+bool MatrixContainer::InitialiseIndices(class MatrixContainer *Matrix)
+{
+  cout << "Initialising indices";
+  if (Matrix == NULL) {
+    cout << " with trivial mapping." << endl;
+    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
+    for(int i=MatrixCounter+1;i--;) {
+      Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      for(int j=RowCounter[i];j--;)
+        Indices[i][j] = j;
+    }
+  } else {
+    cout << " from other MatrixContainer." << endl;
+    if (MatrixCounter != Matrix->MatrixCounter)
+      return false;
+    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
+    for(int i=MatrixCounter+1;i--;) {
+      if (RowCounter[i] != Matrix->RowCounter[i])
+        return false;
+      Indices[i] = (int *) Malloc(sizeof(int)*Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      for(int j=Matrix->RowCounter[i];j--;) {
+        Indices[i][j] = Matrix->Indices[i][j];
+        //cout << Indices[i][j] << "\t";
+      }
+      //cout << endl;
+    }
+  }
+  return true;
+};
 /** Parsing a number of matrices.
  *              -# open the matrix file
  *              -# skip some lines (\a skiplines)
  *              -# scan header lines for number of columns
  *              -# scan lines for number of rows
  *              -# allocate matrix
  *              -# loop over found column and row counts and parse in each entry
+ *    -# open the matrix file
+ *    -# skip some lines (\a skiplines)
+ *    -# scan header lines for number of columns
+ *    -# scan lines for number of rows
+ *    -# allocate matrix
+ *    -# loop over found column and row counts and parse in each entry
  * \param *name directory with files
  * \param skiplines number of inital lines to skip
 …
 bool MatrixContainer::ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr)
+{
+        ifstream input;
+        stringstream line;
+        string token;
+        char filename[1023];
+        input.open(name, ios::in);
+        //cout << "Opening " << name << " ... " << input << endl;
+        if (input == NULL) {
+                cerr << endl << "Unable to open " << name << ", is the directory correct?" << endl;
+                return false;
+        }
+        // skip some initial lines
+        for (int m=skiplines+1;m--;)
+                input.getline(Header, 1023);
+        // scan header for number of columns
+        line.str(Header);
+        for(int k=skipcolumns;k--;)
+                line >> Header;
+        //cout << line.str() << endl;
+        ColumnCounter=0;
+        while ( getline(line,token, '\t') ) {
+                if (token.length() > 0)
+                        ColumnCounter++;
+        }
+        //cout << line.str() << endl;
+        //cout << "ColumnCounter: " << ColumnCounter << "." << endl;
+        if (ColumnCounter == 0)
+                cerr << "ColumnCounter: " << ColumnCounter << " from file " << name << ", this is probably an error!" << endl;
+        // scan rest for number of rows/lines
+        RowCounter[MatrixNr]=-1;                // counts one line too much
+        while (!input.eof()) {
+                input.getline(filename, 1023);
+                //cout << "Comparing: " << strncmp(filename,"MeanForce",9) << endl;
+                RowCounter[MatrixNr]++; // then line was not last MeanForce
+                if (strncmp(filename,"MeanForce", 9) == 0) {
+                        break;
+                }
+        }
+        //cout << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << "." << endl;
+        if (RowCounter[MatrixNr] == 0)
+                cerr << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
+        // allocate matrix if it's not zero dimension in one direction
+        if ((ColumnCounter > 0) && (RowCounter[MatrixNr] > -1)) {
+                Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+                // parse in each entry for this matrix
+                input.clear();
+                input.seekg(ios::beg);
+                for (int m=skiplines+1;m--;)
+                        input.getline(Header, 1023);            // skip header
+                line.str(Header);
+                for(int k=skipcolumns;k--;)     // skip columns in header too
+                        line >> filename;
+                strncpy(Header, line.str().c_str(), 1023);
+                for(int j=0;j<RowCounter[MatrixNr];j++) {
+                        Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+                        input.getline(filename, 1023);
+                        stringstream lines(filename);
+                        //cout << "Matrix at level " << j << ":";// << filename << endl;
+                        for(int k=skipcolumns;k--;)
+                                lines >> filename;
+                        for(int k=0;(k<ColumnCounter) && (!lines.eof());k++) {
+                                lines >> Matrix[MatrixNr][j][k];
+                                //cout << " " << setprecision(2) << Matrix[MatrixNr][j][k];;
+                        }
+                        //cout << endl;
+                        Matrix[MatrixNr][ RowCounter[MatrixNr] ] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[RowCounter[MatrixNr]][]");
+                        for(int j=ColumnCounter;j--;)
+                                Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
+                }
+        } else {
+                cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl;
+        }
+        input.close();
+        return true;
+  ifstream input;
+  stringstream line;
+  string token;
+  char filename[1023];
+  input.open(name, ios::in);
+  //cout << "Opening " << name << " ... "  << input << endl;
+  if (input == NULL) {
+    cerr << endl << "Unable to open " << name << ", is the directory correct?" << endl;
+    return false;
+  }
+  // parse header
+  Header[MatrixNr] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseMatrix: *Header[]");
+  for (int m=skiplines+1;m--;)
+    input.getline(Header[MatrixNr], 1023);
+  // scan header for number of columns
+  line.str(Header[MatrixNr]);
+  for(int k=skipcolumns;k--;)
+    line >> Header[MatrixNr];
+  //cout << line.str() << endl;
+  ColumnCounter[MatrixNr]=0;
+  while ( getline(line,token, '\t') ) {
+    if (token.length() > 0)
+      ColumnCounter[MatrixNr]++;
+  }
+  //cout << line.str() << endl;
+  //cout << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << "." << endl;
+  if (ColumnCounter[MatrixNr] == 0)
+    cerr << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
+  // scan rest for number of rows/lines
+  RowCounter[MatrixNr]=-1;    // counts one line too much
+  while (!input.eof()) {
+    input.getline(filename, 1023);
+    //cout << "Comparing: " << strncmp(filename,"MeanForce",9) << endl;
+    RowCounter[MatrixNr]++; // then line was not last MeanForce
+    if (strncmp(filename,"MeanForce", 9) == 0) {
+      break;
+    }
+  }
+  //cout << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << "." << endl;
+  if (RowCounter[MatrixNr] == 0)
+    cerr << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
+  // allocate matrix if it's not zero dimension in one direction
+  if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
+    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseMatrix: **Matrix[]");
+    // parse in each entry for this matrix
+    input.clear();
+    input.seekg(ios::beg);
+    for (int m=skiplines+1;m--;)
+      input.getline(Header[MatrixNr], 1023);    // skip header
+    line.str(Header[MatrixNr]);
+    for(int k=skipcolumns;k--;)  // skip columns in header too
+      line >> filename;
+    strncpy(Header[MatrixNr], line.str().c_str(), 1023);
+    for(int j=0;j<RowCounter[MatrixNr];j++) {
+      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
+      input.getline(filename, 1023);
+      stringstream lines(filename);
+      //cout << "Matrix at level " << j << ":";// << filename << endl;
+      for(int k=skipcolumns;k--;)
+        lines >> filename;
+      for(int k=0;(k<ColumnCounter[MatrixNr]) && (!lines.eof());k++) {
+        lines >> Matrix[MatrixNr][j][k];
+        //cout << " " << setprecision(2) << Matrix[MatrixNr][j][k];;
+      }
+      //cout << endl;
+      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
+      for(int j=ColumnCounter[MatrixNr];j--;)
+        Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
+    }
+  } else {
+    cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter[MatrixNr] << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl;
+  }
+  input.close();
+  return true;
 };
 …
  * -# First, count the number of matrices by counting lines in KEYSETFILE
  * -# Then,
  *              -# construct the fragment number
  *              -# open the matrix file
  *              -# skip some lines (\a skiplines)
  *              -# scan header lines for number of columns
  *              -# scan lines for number of rows
  *              -# allocate matrix
  *              -# loop over found column and row counts and parse in each entry
+ *    -# construct the fragment number
+ *    -# open the matrix file
+ *    -# skip some lines (\a skiplines)
+ *    -# scan header lines for number of columns
+ *    -# scan lines for number of rows
+ *    -# allocate matrix
+ *    -# loop over found column and row counts and parse in each entry
  * -# Finally, allocate one additional matrix (\a MatrixCounter) containing combined or temporary values
  * \param *name directory with files
 …
 bool MatrixContainer::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+{
+        char filename[1023];
+        ifstream input;
+        char *FragmentNumber = NULL;
+        stringstream file;
+        string token;
+        // count the number of matrices
+        MatrixCounter = -1; // we count one too much
+        file << name << FRAGMENTPREFIX << KEYSETFILE;
+        input.open(file.str().c_str(), ios::in);
+        if (input == NULL) {
+                cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+                return false;
+        }
+        while (!input.eof()) {
+                input.getline(filename, 1023);
+                stringstream zeile(filename);
+                MatrixCounter++;
+        }
+        input.close();
+        cout << "Determined " << MatrixCounter << " fragments." << endl;
+        cout << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl;
+        Matrix = (double ***) ReAlloc(Matrix, sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+        RowCounter = (int *) ReAlloc(RowCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+        for(int i=MatrixCounter+1;i--;) {
+                Matrix[i] = NULL;
+                RowCounter[i] = -1;
+        }
+        for(int i=0; i < MatrixCounter;i++) {
+                // open matrix file
+                FragmentNumber = FixedDigitNumber(MatrixCounter, i);
+                file.str(" ");
+                file << name << FRAGMENTPREFIX << FragmentNumber << prefix << suffix;
+                if (!ParseMatrix(file.str().c_str(), skiplines, skipcolumns, i))
+                        return false;
+                Free((void **)&FragmentNumber, "MatrixContainer::ParseFragmentMatrix: *FragmentNumber");
+        }
+        return true;
+  char filename[1023];
+  ifstream input;
+  char *FragmentNumber = NULL;
+  stringstream file;
+  string token;
+  // count the number of matrices
+  MatrixCounter = -1; // we count one too much
+  file << name << FRAGMENTPREFIX << KEYSETFILE;
+  input.open(file.str().c_str(), ios::in);
+  if (input == NULL) {
+    cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+    return false;
+  }
+  while (!input.eof()) {
+    input.getline(filename, 1023);
+    stringstream zeile(filename);
+    MatrixCounter++;
+  }
+  input.close();
+  cout << "Determined " << MatrixCounter << " fragments." << endl;
+  cout << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl;
+  Header = (char **) ReAlloc(Header, sizeof(char *)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
+  Matrix = (double ***) ReAlloc(Matrix, sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = (int *) ReAlloc(RowCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+  ColumnCounter = (int *) ReAlloc(ColumnCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
+  for(int i=MatrixCounter+1;i--;) {
+    Matrix[i] = NULL;
+    Header[i] = NULL;
+    RowCounter[i] = -1;
+    ColumnCounter[i] = -1;
+  }
+  for(int i=0; i < MatrixCounter;i++) {
+    // open matrix file
+    FragmentNumber = FixedDigitNumber(MatrixCounter, i);
+    file.str(" ");
+    file << name << FRAGMENTPREFIX << FragmentNumber << prefix << suffix;
+    if (!ParseMatrix(file.str().c_str(), skiplines, skipcolumns, i))
+      return false;
+    Free((void **)&FragmentNumber, "MatrixContainer::ParseFragmentMatrix: *FragmentNumber");
+  }
+  return true;
 };
 /** Allocates and resets the memory for a number \a MCounter of matrices.
  * \param *GivenHeader Header line
+ * \param **GivenHeader Header line for each matrix
  * \param MCounter number of matrices
  * \param *RCounter number of rows for each matrix
+ * \param CCounter number of columns for all matrices
+ * \return Allocation successful
+ */
+bool MatrixContainer::AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter)
+{
+        Header = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseFragmentMatrix: *EnergyHeader");
+        strncpy(Header, GivenHeader, 1023);
+        MatrixCounter = MCounter;
+        ColumnCounter = CCounter;
+        Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+        RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+        for(int i=MatrixCounter+1;i--;) {
+                RowCounter[i] = RCounter[i];
+                Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+                for(int j=RowCounter[i]+1;j--;) {
+                        Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+                        for(int k=ColumnCounter;k--;)
+                                Matrix[i][j][k] = 0.;
+                }
+        }
+        return true;
+ * \param *CCounter number of columns for each matrix
+ * \return Allocation successful
+ */
+bool MatrixContainer::AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter)
+{
+  MatrixCounter = MCounter;
+  Header = (char **) Malloc(sizeof(char *)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *Header");
+  Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *RowCounter");
+  ColumnCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *ColumnCounter");
+  for(int i=MatrixCounter+1;i--;) {
+    Header[i] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::AllocateMatrix: *Header[i]");
+    strncpy(Header[i], GivenHeader[i], 1023);
+    RowCounter[i] = RCounter[i];
+    ColumnCounter[i] = CCounter[i];
+    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::AllocateMatrix: **Matrix[]");
+    for(int j=RowCounter[i]+1;j--;) {
+      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
+      for(int k=ColumnCounter[i];k--;)
+        Matrix[i][j][k] = 0.;
+    }
+  }
+  return true;
 };
 …
 bool MatrixContainer::ResetMatrix()
+{
         for(int i=MatrixCounter+1;i--;)
                 for(int j=RowCounter[i]+1;j--;)
                         for(int k=ColumnCounter;k--;)
                                 Matrix[i][j][k] = 0.;
          return true;
+  for(int i=MatrixCounter+1;i--;)
+    for(int j=RowCounter[i]+1;j--;)
+      for(int k=ColumnCounter[i];k--;)
+        Matrix[i][j][k] = 0.;
+   return true;
 };
 …
 double MatrixContainer::FindMaxValue()
+{
         double max = Matrix[0][0][0];
         for(int i=MatrixCounter+1;i--;)
                 for(int j=RowCounter[i]+1;j--;)
                         for(int k=ColumnCounter;k--;)
                                 if (fabs(Matrix[i][j][k]) > max)
                                         max = fabs(Matrix[i][j][k]);
         if (fabs(max) < MYEPSILON)
                 max += MYEPSILON;
+  double max = Matrix[0][0][0];
+  for(int i=MatrixCounter+1;i--;)
+    for(int j=RowCounter[i]+1;j--;)
+      for(int k=ColumnCounter[i];k--;)
+        if (fabs(Matrix[i][j][k]) > max)
+          max = fabs(Matrix[i][j][k]);
+  if (fabs(max) < MYEPSILON)
+    max += MYEPSILON;
  return max;
 };
 …
 double MatrixContainer::FindMinValue()
+{
         double min = Matrix[0][0][0];
         for(int i=MatrixCounter+1;i--;)
                 for(int j=RowCounter[i]+1;j--;)
                         for(int k=ColumnCounter;k--;)
                                 if (fabs(Matrix[i][j][k]) < min)
                                         min = fabs(Matrix[i][j][k]);
         if (fabs(min) < MYEPSILON)
                 min += MYEPSILON;
         return min;
+  double min = Matrix[0][0][0];
+  for(int i=MatrixCounter+1;i--;)
+    for(int j=RowCounter[i]+1;j--;)
+      for(int k=ColumnCounter[i];k--;)
+        if (fabs(Matrix[i][j][k]) < min)
+          min = fabs(Matrix[i][j][k]);
+  if (fabs(min) < MYEPSILON)
+    min += MYEPSILON;
+  return min;
 };
 …
 bool MatrixContainer::SetLastMatrix(double value, int skipcolumns)
+{
         for(int j=RowCounter[MatrixCounter]+1;j--;)
                 for(int k=skipcolumns;k<ColumnCounter;k++)
                         Matrix[MatrixCounter][j][k] = value;
          return true;
+  for(int j=RowCounter[MatrixCounter]+1;j--;)
+    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
+      Matrix[MatrixCounter][j][k] = value;
+   return true;
 };
 …
 bool MatrixContainer::SetLastMatrix(double **values, int skipcolumns)
+{
         for(int j=RowCounter[MatrixCounter]+1;j--;)
                 for(int k=skipcolumns;k<ColumnCounter;k++)
                         Matrix[MatrixCounter][j][k] = values[j][k];
          return true;
 };
 /** Sums the energy with each factor and put into last element of \a ***Energies.
+  for(int j=RowCounter[MatrixCounter]+1;j--;)
+    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
+      Matrix[MatrixCounter][j][k] = values[j][k];
+   return true;
+};
+/** Sums the entries with each factor and put into last element of \a ***Matrix.
  * Sums over "E"-terms to create the "F"-terms
  * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
  * \param Order bond order
 …
 bool MatrixContainer::SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order)
+{
         // go through each order
         for (int CurrentFragment=0;CurrentFragment<KeySet.FragmentsPerOrder[Order];CurrentFragment++) {
                 //cout << "Current Fragment is " << CurrentFragment << "/" << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
                 // then go per order through each suborder and pick together all the terms that contain this fragment
                 for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
                         for (int j=0;j<KeySet.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
                                 if (KeySet.Contains(KeySet.OrderSet[Order][CurrentFragment], KeySet.OrderSet[SubOrder][j])) {
                                         //cout << "Current other fragment is " << j << "/" << KeySet.OrderSet[SubOrder][j] << "." << endl;
                                         // if the fragment's indices are all in the current fragment
                                         for(int k=0;k<RowCounter[ KeySet.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
                                                 int m = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][k];
                                                 //cout << "Current index is " << k << "/" << m << "." << endl;
                                                 if (m != -1) { // if it's not an added hydrogen
                                                         for (int l=0;l<RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
                                                                 //cout << "Comparing " << m << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
                                                                 if (m == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l]) {
                                                                         m = l;
                                                                         break;
+                                                                }
+                                                        }
                                                         //cout << "Corresponding index in CurrentFragment is " << m << "." << endl;
                                                         if (m > RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
                                                                 cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]    << " current force index " << m << " is greater than " << RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
                                                                 return false;
+                                                        }
                                                         if (Order == SubOrder) { // equal order is always copy from Energies
+                                                                for(int l=ColumnCounter;l--;) // then adds/subtract each column
                                                                         Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] += MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
                                                         } else {
                                                                 for(int l=ColumnCounter;l--;)
                                                                         Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
+                                                        }
+                                                }
                                                 //if ((ColumnCounter>1) && (RowCounter[0]-1 >= 1))
                                                  //cout << "Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<   Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
+                                        }
                                 } else {
                                         //cout << "Fragment " << KeySet.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
+                                }
+                        }
+                }
          //cout << "Final Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << KeySet.AtomCounter[0]-1 << "][" << 1 << "] = " <<     Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][KeySet.AtomCounter[0]-1][1] << endl;
+        }
         return true;
+  // go through each order
+  for (int CurrentFragment=0;CurrentFragment<KeySet.FragmentsPerOrder[Order];CurrentFragment++) {
+    //cout << "Current Fragment is " << CurrentFragment << "/" << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
+    // then go per order through each suborder and pick together all the terms that contain this fragment
+    for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
+      for (int j=0;j<KeySet.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
+        if (KeySet.Contains(KeySet.OrderSet[Order][CurrentFragment], KeySet.OrderSet[SubOrder][j])) {
+          //cout << "Current other fragment is " << j << "/" << KeySet.OrderSet[SubOrder][j] << "." << endl;
+          // if the fragment's indices are all in the current fragment
+          for(int k=0;k<RowCounter[ KeySet.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
+            int m = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][k];
+            //cout << "Current index is " << k << "/" << m << "." << endl;
+            if (m != -1) { // if it's not an added hydrogen
+              for (int l=0;l<RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
+                //cout << "Comparing " << m << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
+                if (m == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l]) {
+                  m = l;
+                  break;
+                }
+              }
+              //cout << "Corresponding index in CurrentFragment is " << m << "." << endl;
+              if (m > RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
+                cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]   << " current force index " << m << " is greater than " << RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
+                return false;
+              }
+              if (Order == SubOrder) { // equal order is always copy from Energies
+                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l--;) // then adds/subtract each column
+                  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] += MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
+              } else {
+                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l--;)
+                  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
+              }
+            }
+            //if ((ColumnCounter[ KeySet.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
+             //cout << "Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
+          }
+        } else {
+          //cout << "Fragment " << KeySet.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
+        }
+      }
+    }
+   //cout << "Final Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << KeySet.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][KeySet.AtomCounter[0]-1][1] << endl;
+  }
+  return true;
 };
 …
 bool MatrixContainer::WriteTotalFragments(const char *name, const char *prefix)
+{
         ofstream output;
         char *FragmentNumber = NULL;
         cout << "Writing fragment files." << endl;
         for(int i=0;i<MatrixCounter;i++) {
                 stringstream line;
                 FragmentNumber = FixedDigitNumber(MatrixCounter, i);
                 line << name << FRAGMENTPREFIX << FragmentNumber << "/" << prefix;
                 Free((void **)&FragmentNumber, "*FragmentNumber");
                 output.open(line.str().c_str(), ios::out);
                 if (output == NULL) {
                         cerr << "Unable to open output energy file " << line.str() << "!" << endl;
                         return false;
+                }
                 output << Header << endl;
                 for(int j=0;j<RowCounter[i];j++) {
                         for(int k=0;k<ColumnCounter;k++)
                                 output << scientific << Matrix[i][j][k] << "\t";
                         output << endl;
+                }
                 output.close();
+        }
         return true;
+  ofstream output;
+  char *FragmentNumber = NULL;
+  cout << "Writing fragment files." << endl;
+  for(int i=0;i<MatrixCounter;i++) {
+    stringstream line;
+    FragmentNumber = FixedDigitNumber(MatrixCounter, i);
+    line << name << FRAGMENTPREFIX << FragmentNumber << "/" << prefix;
+    Free((void **)&FragmentNumber, "*FragmentNumber");
+    output.open(line.str().c_str(), ios::out);
+    if (output == NULL) {
+      cerr << "Unable to open output energy file " << line.str() << "!" << endl;
+      return false;
+    }
+    output << Header[i] << endl;
+    for(int j=0;j<RowCounter[i];j++) {
+      for(int k=0;k<ColumnCounter[i];k++)
+        output << scientific << Matrix[i][j][k] << "\t";
+      output << endl;
+    }
+    output.close();
+  }
+  return true;
 };
 …
 bool MatrixContainer::WriteLastMatrix(const char *name, const char *prefix, const char *suffix)
+{
         ofstream output;
         stringstream line;
         cout << "Writing matrix values of " << suffix << "." << endl;
         line << name << prefix << suffix;
         output.open(line.str().c_str(), ios::out);
         if (output == NULL) {
                 cerr << "Unable to open output matrix file " << line.str() << "!" << endl;
                 return false;
+        }
         output << Header << endl;
         for(int j=0;j<RowCounter[MatrixCounter];j++) {
                 for(int k=0;k<ColumnCounter;k++)
                         output << scientific << Matrix[MatrixCounter][j][k] << "\t";
                 output << endl;
+        }
         output.close();
         return true;
+  ofstream output;
+  stringstream line;
+  cout << "Writing matrix values of " << suffix << "." << endl;
+  line << name << prefix << suffix;
+  output.open(line.str().c_str(), ios::out);
+  if (output == NULL) {
+    cerr << "Unable to open output matrix file " << line.str() << "!" << endl;
+    return false;
+  }
+  output << Header[MatrixCounter] << endl;
+  for(int j=0;j<RowCounter[MatrixCounter];j++) {
+    for(int k=0;k<ColumnCounter[MatrixCounter];k++)
+      output << scientific << Matrix[MatrixCounter][j][k] << "\t";
+    output << endl;
+  }
+  output.close();
+  return true;
 };
 …
 bool EnergyMatrix::ParseIndices()
+{
         cout << "Parsing energy indices." << endl;
         Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "EnergyMatrix::ParseIndices: **Indices");
         for(int i=MatrixCounter+1;i--;) {
                 Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
                 for(int j=RowCounter[i];j--;)
                         Indices[i][j] = j;
+        }
         return true;
+  cout << "Parsing energy indices." << endl;
+  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "EnergyMatrix::ParseIndices: **Indices");
+  for(int i=MatrixCounter+1;i--;) {
+    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    for(int j=RowCounter[i];j--;)
+      Indices[i][j] = j;
+  }
+  return true;
 };
 /** Sums the energy with each factor and put into last element of \a EnergyMatrix::Matrix.
  * Sums over the "F"-terms in ANOVA decomposition.
  * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
  * \param CorrectionFragments MatrixContainer with hydrogen saturation correction per fragments
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
 …
 bool EnergyMatrix::SumSubEnergy(class EnergyMatrix &Fragments, class EnergyMatrix *CorrectionFragments, class KeySetsContainer &KeySet, int Order, double sign)
+{
         // sum energy
         if (CorrectionFragments == NULL)
                 for(int i=KeySet.FragmentsPerOrder[Order];i--;)
                         for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
                                 for(int k=ColumnCounter;k--;)
                                         Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k];
         else
                 for(int i=KeySet.FragmentsPerOrder[Order];i--;)
                         for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
                                 for(int k=ColumnCounter;k--;)
                                         Matrix[MatrixCounter][j][k] += sign*(Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k] + CorrectionFragments->Matrix[ KeySet.OrderSet[Order][i] ][j][k]);
         return true;
+  // sum energy
+  if (CorrectionFragments == NULL)
+    for(int i=KeySet.FragmentsPerOrder[Order];i--;)
+      for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
+        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];k--;)
+          Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k];
+  else
+    for(int i=KeySet.FragmentsPerOrder[Order];i--;)
+      for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
+        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];k--;)
+          Matrix[MatrixCounter][j][k] += sign*(Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k] + CorrectionFragments->Matrix[ KeySet.OrderSet[Order][i] ][j][k]);
+  return true;
 };
 …
 bool EnergyMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+{
+        char filename[1024];
+        bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
+        if (status) {
+                // count maximum of columns
+                RowCounter[MatrixCounter] = 0;
+                for(int j=0; j < MatrixCounter;j++) // (energy matrix might be bigger than number of atoms in terms of rows)
+                        if (RowCounter[j] > RowCounter[MatrixCounter])
+                                RowCounter[MatrixCounter] = RowCounter[j];
+                // allocate last plus one matrix
+                cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter << " columns." << endl;
+                Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+                for(int j=0;j<=RowCounter[MatrixCounter];j++)
+                        Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+                // try independently to parse global energysuffix file if present
+                strncpy(filename, name, 1023);
+                strncat(filename, prefix, 1023-strlen(filename));
+                strncat(filename, suffix.c_str(), 1023-strlen(filename));
+                ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
+        }
+        return status;
+  char filename[1024];
+  bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
+  if (status) {
+    // count maximum of columns
+    RowCounter[MatrixCounter] = 0;
+    ColumnCounter[MatrixCounter] = 0;
+    for(int j=0; j < MatrixCounter;j++) { // (energy matrix might be bigger than number of atoms in terms of rows)
+      if (RowCounter[j] > RowCounter[MatrixCounter])
+        RowCounter[MatrixCounter] = RowCounter[j];
+      if (ColumnCounter[j] > ColumnCounter[MatrixCounter])  // take maximum of all for last matrix
+        ColumnCounter[MatrixCounter] = ColumnCounter[j];
+    }
+    // allocate last plus one matrix
+    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
+    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    for(int j=0;j<=RowCounter[MatrixCounter];j++)
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+    // try independently to parse global energysuffix file if present
+    strncpy(filename, name, 1023);
+    strncat(filename, prefix, 1023-strlen(filename));
+    strncat(filename, suffix.c_str(), 1023-strlen(filename));
+    ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
+  }
+  return status;
 };
 …
 bool ForceMatrix::ParseIndices(char *name)
+{
         ifstream input;
         char *FragmentNumber = NULL;
         char filename[1023];
         stringstream line;
         cout << "Parsing force indices for " << MatrixCounter << " matrices." << endl;
         Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "ForceMatrix::ParseIndices: **Indices");
         line << name << FRAGMENTPREFIX << FORCESFILE;
         input.open(line.str().c_str(), ios::in);
         //cout << "Opening " << line.str() << " ... "   << input << endl;
         if (input == NULL) {
                 cout << endl << "Unable to open " << line.str() << ", is the directory correct?" << endl;
                 return false;
+        }
         for (int i=0;(i<MatrixCounter) && (!input.eof());i++) {
                 // get the number of atoms for this fragment
                 input.getline(filename, 1023);
                 line.str(filename);
                 // parse the values
                 Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
                 FragmentNumber = FixedDigitNumber(MatrixCounter, i);
                 //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
                 Free((void **)&FragmentNumber, "ForceMatrix::ParseIndices: *FragmentNumber");
                 for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
                         line >> Indices[i][j];
                         //cout << " " << Indices[i][j];
+                }
                 //cout << endl;
+        }
         Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
         for(int j=RowCounter[MatrixCounter];j--;) {
                 Indices[MatrixCounter][j] = j;
+        }
         input.close();
         return true;
+  ifstream input;
+  char *FragmentNumber = NULL;
+  char filename[1023];
+  stringstream line;
+  cout << "Parsing force indices for " << MatrixCounter << " matrices." << endl;
+  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "ForceMatrix::ParseIndices: **Indices");
+  line << name << FRAGMENTPREFIX << FORCESFILE;
+  input.open(line.str().c_str(), ios::in);
+  //cout << "Opening " << line.str() << " ... "  << input << endl;
+  if (input == NULL) {
+    cout << endl << "Unable to open " << line.str() << ", is the directory correct?" << endl;
+    return false;
+  }
+  for (int i=0;(i<MatrixCounter) && (!input.eof());i++) {
+    // get the number of atoms for this fragment
+    input.getline(filename, 1023);
+    line.str(filename);
+    // parse the values
+    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
+    FragmentNumber = FixedDigitNumber(MatrixCounter, i);
+    //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
+    Free((void **)&FragmentNumber, "ForceMatrix::ParseIndices: *FragmentNumber");
+    for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
+      line >> Indices[i][j];
+      //cout << " " << Indices[i][j];
+    }
+    //cout << endl;
+  }
+  Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
+  for(int j=RowCounter[MatrixCounter];j--;) {
+    Indices[MatrixCounter][j] = j;
+  }
+  input.close();
+  return true;
 };
 /** Sums the forces and puts into last element of \a ForceMatrix::Matrix.
  * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
  * \param Order bond order
  *      \param sign +1 or -1
+ *  \param sign +1 or -1
  * \return true if summing was successful
  */
 bool ForceMatrix::SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign)
+{
         int FragmentNr;
         // sum forces
         for(int i=0;i<KeySet.FragmentsPerOrder[Order];i++) {
                 FragmentNr = KeySet.OrderSet[Order][i];
                 for(int l=0;l<RowCounter[ FragmentNr ];l++) {
                         int j = Indices[ FragmentNr ][l];
                         if (j > RowCounter[MatrixCounter]) {
                                 cerr << "Current force index " << j << " is greater than " << RowCounter[MatrixCounter] << "!" << endl;
                                 return false;
+                        }
                         if (j != -1) {
                                 //if (j == 0) cout << "Summing onto ion 0, type 0 from fragment " << FragmentNr << ", ion " << l << "." << endl;
                                 for(int k=2;k<ColumnCounter;k++)
                                         Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][k];
+                        }
+                }
+        }
         return true;
+  int FragmentNr;
+  // sum forces
+  for(int i=0;i<KeySet.FragmentsPerOrder[Order];i++) {
+    FragmentNr = KeySet.OrderSet[Order][i];
+    for(int l=0;l<RowCounter[ FragmentNr ];l++) {
+      int j = Indices[ FragmentNr ][l];
+      if (j > RowCounter[MatrixCounter]) {
+        cerr << "Current force index " << j << " is greater than " << RowCounter[MatrixCounter] << "!" << endl;
+        return false;
+      }
+      if (j != -1) {
+        //if (j == 0) cout << "Summing onto ion 0, type 0 from fragment " << FragmentNr << ", ion " << l << "." << endl;
+        for(int k=2;k<ColumnCounter[MatrixCounter];k++)
+          Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][k];
+      }
+    }
+  }
+  return true;
 };
 …
 bool ForceMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+{
+        char filename[1023];
+        ifstream input;
+        stringstream file;
+        int nr;
+        bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
+        if (status) {
+                // count number of atoms for last plus one matrix
+                file << name << FRAGMENTPREFIX << KEYSETFILE;
+                input.open(file.str().c_str(), ios::in);
+                if (input == NULL) {
+                        cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+                        return false;
+                }
+                RowCounter[MatrixCounter] = 0;
+                while (!input.eof()) {
+                        input.getline(filename, 1023);
+                        stringstream zeile(filename);
+                        while (!zeile.eof()) {
+                                zeile >> nr;
+                                //cout << "Current index: " << nr << "." << endl;
+                                if (nr > RowCounter[MatrixCounter])
+                                        RowCounter[MatrixCounter] = nr;
+                        }
+                }
+                RowCounter[MatrixCounter]++;            // nr start at 0, count starts at 1
+                input.close();
+                // allocate last plus one matrix
+                cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter << " columns." << endl;
+                Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+                for(int j=0;j<=RowCounter[MatrixCounter];j++)
+                        Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+                // try independently to parse global forcesuffix file if present
+                strncpy(filename, name, 1023);
+                strncat(filename, prefix, 1023-strlen(filename));
+                strncat(filename, suffix.c_str(), 1023-strlen(filename));
+                ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
+        }
+        return status;
+  char filename[1023];
+  ifstream input;
+  stringstream file;
+  int nr;
+  bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
+  if (status) {
+    // count number of atoms for last plus one matrix
+    file << name << FRAGMENTPREFIX << KEYSETFILE;
+    input.open(file.str().c_str(), ios::in);
+    if (input == NULL) {
+      cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+      return false;
+    }
+    RowCounter[MatrixCounter] = 0;
+    while (!input.eof()) {
+      input.getline(filename, 1023);
+      stringstream zeile(filename);
+      while (!zeile.eof()) {
+        zeile >> nr;
+        //cout << "Current index: " << nr << "." << endl;
+        if (nr > RowCounter[MatrixCounter])
+          RowCounter[MatrixCounter] = nr;
+      }
+    }
+    RowCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
+    input.close();
+    ColumnCounter[MatrixCounter] = 0;
+    for(int j=0; j < MatrixCounter;j++) { // (energy matrix might be bigger than number of atoms in terms of rows)
+      if (ColumnCounter[j] > ColumnCounter[MatrixCounter])  // take maximum of all for last matrix
+        ColumnCounter[MatrixCounter] = ColumnCounter[j];
+    }
+    // allocate last plus one matrix
+    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
+    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    for(int j=0;j<=RowCounter[MatrixCounter];j++)
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+    // try independently to parse global forcesuffix file if present
+    strncpy(filename, name, 1023);
+    strncat(filename, prefix, 1023-strlen(filename));
+    strncat(filename, suffix.c_str(), 1023-strlen(filename));
+    ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
+  }
+  return status;
+};
+// ======================================= CLASS HessianMatrix =============================
+/** Parsing force Indices of each fragment
+ * \param *name directory with \a ForcesFile
+ * \return parsing successful
+ */
+bool HessianMatrix::ParseIndices(char *name)
+{
+  ifstream input;
+  char *FragmentNumber = NULL;
+  char filename[1023];
+  stringstream line;
+  cout << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl;
+  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "HessianMatrix::ParseIndices: **Indices");
+  line << name << FRAGMENTPREFIX << FORCESFILE;
+  input.open(line.str().c_str(), ios::in);
+  //cout << "Opening " << line.str() << " ... "  << input << endl;
+  if (input == NULL) {
+    cout << endl << "Unable to open " << line.str() << ", is the directory correct?" << endl;
+    return false;
+  }
+  for (int i=0;(i<MatrixCounter) && (!input.eof());i++) {
+    // get the number of atoms for this fragment
+    input.getline(filename, 1023);
+    line.str(filename);
+    // parse the values
+    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
+    FragmentNumber = FixedDigitNumber(MatrixCounter, i);
+    //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
+    Free((void **)&FragmentNumber, "HessianMatrix::ParseIndices: *FragmentNumber");
+    for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
+      line >> Indices[i][j];
+      //cout << " " << Indices[i][j];
+    }
+    //cout << endl;
+  }
+  Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
+  for(int j=RowCounter[MatrixCounter];j--;) {
+    Indices[MatrixCounter][j] = j;
+  }
+  input.close();
+  return true;
+};
+/** Sums the hessian entries and puts into last element of \a HessianMatrix::Matrix.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
+ * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
+ * \param Order bond order
+ *  \param sign +1 or -1
+ * \return true if summing was successful
+ */
+bool HessianMatrix::SumSubHessians(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign)
+{
+  int FragmentNr;
+  // sum forces
+  for(int i=0;i<KeySet.FragmentsPerOrder[Order];i++) {
+    FragmentNr = KeySet.OrderSet[Order][i];
+    for(int l=0;l<RowCounter[ FragmentNr ];l++) {
+      int j = Indices[ FragmentNr ][l];
+      if (j > RowCounter[MatrixCounter]) {
+        cerr << "Current hessian index " << j << " is greater than " << RowCounter[MatrixCounter] << ", where i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl;
+        return false;
+      }
+      if (j != -1) {
+        for(int m=0;m<ColumnCounter[ FragmentNr ];m++) {
+          int k = Indices[ FragmentNr ][m];
+          if (k > ColumnCounter[MatrixCounter]) {
+            cerr << "Current hessian index " << k << " is greater than " << ColumnCounter[MatrixCounter] << ", where m=" << m << ", j=" << j << ", i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl;
+            return false;
+          }
+          if (k != -1) {
+            //cout << "Adding " << sign*Fragments.Matrix[ FragmentNr ][l][m] << " from [" << l << "][" << m << "] onto [" << j << "][" << k << "]." << endl;
+            Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][m];
+          }
+        }
+      }
+    }
+  }
+  return true;
+};
+/** Constructor for class HessianMatrix.
+ */
+HessianMatrix::HessianMatrix() : MatrixContainer()
+{
+   IsSymmetric = true;
+}
+/** Sums the hessian entries with each factor and put into last element of \a ***Matrix.
+ * Sums over "E"-terms to create the "F"-terms
+ * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
+ * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
+ * \param Order bond order
+ * \return true if summing was successful
+ */
+bool HessianMatrix::SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order)
+{
+  // go through each order
+  for (int CurrentFragment=0;CurrentFragment<KeySet.FragmentsPerOrder[Order];CurrentFragment++) {
+    //cout << "Current Fragment is " << CurrentFragment << "/" << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
+    // then go per order through each suborder and pick together all the terms that contain this fragment
+    for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
+      for (int j=0;j<KeySet.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
+        if (KeySet.Contains(KeySet.OrderSet[Order][CurrentFragment], KeySet.OrderSet[SubOrder][j])) {
+          //cout << "Current other fragment is " << j << "/" << KeySet.OrderSet[SubOrder][j] << "." << endl;
+          // if the fragment's indices are all in the current fragment
+          for(int k=0;k<RowCounter[ KeySet.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
+            int m = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][k];
+            //cout << "Current row index is " << k << "/" << m << "." << endl;
+            if (m != -1) { // if it's not an added hydrogen
+              for (int l=0;l<RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
+                //cout << "Comparing " << m << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
+                if (m == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l]) {
+                  m = l;
+                  break;
+                }
+              }
+              //cout << "Corresponding row index for " << k << " in CurrentFragment is " << m << "." << endl;
+              if (m > RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
+                cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]   << " current row index " << m << " is greater than " << RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
+                return false;
+              }
+              for(int l=0;l<ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l++) {
+                int n = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][l];
+                //cout << "Current column index is " << l << "/" << n << "." << endl;
+                if (n != -1) { // if it's not an added hydrogen
+                  for (int p=0;p<ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ];p++) { // look for the corresponding index in the current fragment
+                    //cout << "Comparing " << n << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][p] << "." << endl;
+                    if (n == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][p]) {
+                      n = p;
+                      break;
+                    }
+                  }
+                  //cout << "Corresponding column index for " << l << " in CurrentFragment is " << n << "." << endl;
+                  if (n > ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
+                    cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]   << " current column index " << n << " is greater than " << ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
+                    return false;
+                  }
+                  if (Order == SubOrder) { // equal order is always copy from Energies
+                    //cout << "Adding " << MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
+                    Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][n] += MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
+                  } else {
+                    //cout << "Subtracting " << Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
+                    Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][n] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
+                  }
+                }
+              }
+            }
+            //if ((ColumnCounter[ KeySet.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
+             //cout << "Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
+          }
+        } else {
+          //cout << "Fragment " << KeySet.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
+        }
+      }
+    }
+   //cout << "Final Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << KeySet.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][KeySet.AtomCounter[0]-1][1] << endl;
+  }
+  return true;
+};
+/** Calls MatrixContainer::ParseFragmentMatrix() and additionally allocates last plus one matrix.
+ * \param *name directory with files
+ * \param *prefix prefix of each matrix file
+ * \param *suffix suffix of each matrix file
+ * \param skiplines number of inital lines to skip
+ * \param skiplines number of inital columns to skip
+ * \return parsing successful
+ */
+bool HessianMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
+{
+  char filename[1023];
+  ifstream input;
+  stringstream file;
+  int nr;
+  bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
+  if (status) {
+    // count number of atoms for last plus one matrix
+    file << name << FRAGMENTPREFIX << KEYSETFILE;
+    input.open(file.str().c_str(), ios::in);
+    if (input == NULL) {
+      cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+      return false;
+    }
+    RowCounter[MatrixCounter] = 0;
+    ColumnCounter[MatrixCounter] = 0;
+    while (!input.eof()) {
+      input.getline(filename, 1023);
+      stringstream zeile(filename);
+      while (!zeile.eof()) {
+        zeile >> nr;
+        //cout << "Current index: " << nr << "." << endl;
+        if (nr > RowCounter[MatrixCounter]) {
+          RowCounter[MatrixCounter] = nr;
+          ColumnCounter[MatrixCounter] = nr;
+        }
+      }
+    }
+    RowCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
+    ColumnCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
+    input.close();
+    // allocate last plus one matrix
+    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
+    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    for(int j=0;j<=RowCounter[MatrixCounter];j++)
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+    // try independently to parse global forcesuffix file if present
+    strncpy(filename, name, 1023);
+    strncat(filename, prefix, 1023-strlen(filename));
+    strncat(filename, suffix.c_str(), 1023-strlen(filename));
+    ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
+  }
+  return status;
 };
 …
  */
 KeySetsContainer::KeySetsContainer() {
         KeySets = NULL;
         AtomCounter = NULL;
         FragmentCounter = 0;
         Order = 0;
         FragmentsPerOrder = 0;
         OrderSet = NULL;
+  KeySets = NULL;
+  AtomCounter = NULL;
+  FragmentCounter = 0;
+  Order = 0;
+  FragmentsPerOrder = 0;
+  OrderSet = NULL;
 };
 …
  */
 KeySetsContainer::~KeySetsContainer() {
         for(int i=FragmentCounter;i--;)
                 Free((void **)&KeySets[i], "KeySetsContainer::~KeySetsContainer: *KeySets[]");
         for(int i=Order;i--;)
                 Free((void **)&OrderSet[i], "KeySetsContainer::~KeySetsContainer: *OrderSet[]");
         Free((void **)&KeySets, "KeySetsContainer::~KeySetsContainer: **KeySets");
         Free((void **)&OrderSet, "KeySetsContainer::~KeySetsContainer: **OrderSet");
         Free((void **)&AtomCounter, "KeySetsContainer::~KeySetsContainer: *AtomCounter");
         Free((void **)&FragmentsPerOrder, "KeySetsContainer::~KeySetsContainer: *FragmentsPerOrder");
+  for(int i=FragmentCounter;i--;)
+    Free((void **)&KeySets[i], "KeySetsContainer::~KeySetsContainer: *KeySets[]");
+  for(int i=Order;i--;)
+    Free((void **)&OrderSet[i], "KeySetsContainer::~KeySetsContainer: *OrderSet[]");
+  Free((void **)&KeySets, "KeySetsContainer::~KeySetsContainer: **KeySets");
+  Free((void **)&OrderSet, "KeySetsContainer::~KeySetsContainer: **OrderSet");
+  Free((void **)&AtomCounter, "KeySetsContainer::~KeySetsContainer: *AtomCounter");
+  Free((void **)&FragmentsPerOrder, "KeySetsContainer::~KeySetsContainer: *FragmentsPerOrder");
 };
 …
  */
 bool KeySetsContainer::ParseKeySets(const char *name, const int *ACounter, const int FCounter) {
         ifstream input;
         char *FragmentNumber = NULL;
         stringstream file;
         char filename[1023];
         FragmentCounter = FCounter;
         cout << "Parsing key sets." << endl;
         KeySets = (int **) Malloc(sizeof(int *)*FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
         for(int i=FragmentCounter;i--;)
                 KeySets[i] = NULL;
         file << name << FRAGMENTPREFIX << KEYSETFILE;
         input.open(file.str().c_str(), ios::in);
         if (input == NULL) {
                 cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
                 return false;
+        }
         AtomCounter = (int *) Malloc(sizeof(int)*FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
         for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
                 stringstream line;
                 AtomCounter[i] = ACounter[i];
                 // parse the values
                 KeySets[i] = (int *) Malloc(sizeof(int)*AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
                 for(int j=AtomCounter[i];j--;)
                         KeySets[i][j] = -1;
                 FragmentNumber = FixedDigitNumber(FragmentCounter, i);
                 //cout << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
                 Free((void **)&FragmentNumber, "KeySetsContainer::ParseKeySets: *FragmentNumber");
                 input.getline(filename, 1023);
                 line.str(filename);
                 for(int j=0;(j<AtomCounter[i]) && (!line.eof());j++) {
                         line >> KeySets[i][j];
                         //cout << " " << KeySets[i][j];
+                }
                 //cout << endl;
+        }
         input.close();
         return true;
+  ifstream input;
+  char *FragmentNumber = NULL;
+  stringstream file;
+  char filename[1023];
+  FragmentCounter = FCounter;
+  cout << "Parsing key sets." << endl;
+  KeySets = (int **) Malloc(sizeof(int *)*FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
+  for(int i=FragmentCounter;i--;)
+    KeySets[i] = NULL;
+  file << name << FRAGMENTPREFIX << KEYSETFILE;
+  input.open(file.str().c_str(), ios::in);
+  if (input == NULL) {
+    cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
+    return false;
+  }
+  AtomCounter = (int *) Malloc(sizeof(int)*FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
+  for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
+    stringstream line;
+    AtomCounter[i] = ACounter[i];
+    // parse the values
+    KeySets[i] = (int *) Malloc(sizeof(int)*AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
+    for(int j=AtomCounter[i];j--;)
+      KeySets[i][j] = -1;
+    FragmentNumber = FixedDigitNumber(FragmentCounter, i);
+    //cout << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
+    Free((void **)&FragmentNumber, "KeySetsContainer::ParseKeySets: *FragmentNumber");
+    input.getline(filename, 1023);
+    line.str(filename);
+    for(int j=0;(j<AtomCounter[i]) && (!line.eof());j++) {
+      line >> KeySets[i][j];
+      //cout << " " << KeySets[i][j];
+    }
+    //cout << endl;
+  }
+  input.close();
+  return true;
 };
 …
 bool KeySetsContainer::ParseManyBodyTerms()
+{
         int Counter;
         cout << "Creating Fragment terms." << endl;
         // scan through all to determine maximum order
         Order=0;
         for(int i=FragmentCounter;i--;) {
                 Counter=0;
                 for(int j=AtomCounter[i];j--;)
                         if (KeySets[i][j] != -1)
                                 Counter++;
                 if (Counter > Order)
                         Order = Counter;
+        }
         cout << "Found Order is " << Order << "." << endl;
         // scan through all to determine fragments per order
         FragmentsPerOrder = (int *) Malloc(sizeof(int)*Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
         for(int i=Order;i--;)
                 FragmentsPerOrder[i] = 0;
         for(int i=FragmentCounter;i--;) {
                 Counter=0;
                 for(int j=AtomCounter[i];j--;)
                         if (KeySets[i][j] != -1)
                                 Counter++;
                 FragmentsPerOrder[Counter-1]++;
+        }
         for(int i=0;i<Order;i++)
                 cout << "Found No. of Fragments of Order " << i+1 << " is " << FragmentsPerOrder[i] << "." << endl;
         // scan through all to gather indices to each order set
         OrderSet = (int **) Malloc(sizeof(int *)*Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
         for(int i=Order;i--;)
                 OrderSet[i] = (int *) Malloc(sizeof(int)*FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
         for(int i=Order;i--;)
                 FragmentsPerOrder[i] = 0;
         for(int i=FragmentCounter;i--;) {
                 Counter=0;
                 for(int j=AtomCounter[i];j--;)
                         if (KeySets[i][j] != -1)
                                 Counter++;
                 OrderSet[Counter-1][FragmentsPerOrder[Counter-1]] = i;
                 FragmentsPerOrder[Counter-1]++;
+        }
         cout << "Printing OrderSet." << endl;
         for(int i=0;i<Order;i++) {
                 for (int j=0;j<FragmentsPerOrder[i];j++) {
                         cout << " " << OrderSet[i][j];
+                }
                 cout << endl;
+        }
         cout << endl;
         return true;
+  int Counter;
+  cout << "Creating Fragment terms." << endl;
+  // scan through all to determine maximum order
+  Order=0;
+  for(int i=FragmentCounter;i--;) {
+    Counter=0;
+    for(int j=AtomCounter[i];j--;)
+      if (KeySets[i][j] != -1)
+        Counter++;
+    if (Counter > Order)
+      Order = Counter;
+  }
+  cout << "Found Order is " << Order << "." << endl;
+  // scan through all to determine fragments per order
+  FragmentsPerOrder = (int *) Malloc(sizeof(int)*Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
+  for(int i=Order;i--;)
+    FragmentsPerOrder[i] = 0;
+  for(int i=FragmentCounter;i--;) {
+    Counter=0;
+    for(int j=AtomCounter[i];j--;)
+      if (KeySets[i][j] != -1)
+        Counter++;
+    FragmentsPerOrder[Counter-1]++;
+  }
+  for(int i=0;i<Order;i++)
+    cout << "Found No. of Fragments of Order " << i+1 << " is " << FragmentsPerOrder[i] << "." << endl;
+  // scan through all to gather indices to each order set
+  OrderSet = (int **) Malloc(sizeof(int *)*Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
+  for(int i=Order;i--;)
+    OrderSet[i] = (int *) Malloc(sizeof(int)*FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
+  for(int i=Order;i--;)
+    FragmentsPerOrder[i] = 0;
+  for(int i=FragmentCounter;i--;) {
+    Counter=0;
+    for(int j=AtomCounter[i];j--;)
+      if (KeySets[i][j] != -1)
+        Counter++;
+    OrderSet[Counter-1][FragmentsPerOrder[Counter-1]] = i;
+    FragmentsPerOrder[Counter-1]++;
+  }
+  cout << "Printing OrderSet." << endl;
+  for(int i=0;i<Order;i++) {
+    for (int j=0;j<FragmentsPerOrder[i];j++) {
+      cout << " " << OrderSet[i][j];
+    }
+    cout << endl;
+  }
+  cout << endl;
+  return true;
 };
 …
 bool KeySetsContainer::Contains(const int GreaterSet, const int SmallerSet)
+{
         bool result = true;
         bool intermediate;
         if ((GreaterSet < 0) || (SmallerSet < 0) || (GreaterSet > FragmentCounter) || (SmallerSet > FragmentCounter)) // index out of bounds
                 return false;
         for(int i=AtomCounter[SmallerSet];i--;) {
                 intermediate = false;
                 for (int j=AtomCounter[GreaterSet];j--;)
                         intermediate = (intermediate || ((KeySets[SmallerSet][i] == KeySets[GreaterSet][j]) || (KeySets[SmallerSet][i] == -1)));
                 result = result && intermediate;
+        }
         return result;
+  bool result = true;
+  bool intermediate;
+  if ((GreaterSet < 0) || (SmallerSet < 0) || (GreaterSet > FragmentCounter) || (SmallerSet > FragmentCounter)) // index out of bounds
+    return false;
+  for(int i=AtomCounter[SmallerSet];i--;) {
+    intermediate = false;
+    for (int j=AtomCounter[GreaterSet];j--;)
+      intermediate = (intermediate || ((KeySets[SmallerSet][i] == KeySets[GreaterSet][j]) || (KeySets[SmallerSet][i] == -1)));
+    result = result && intermediate;
+  }
+  return result;
 };

src/parser.hpp

-              r375b458
+              r51c910
 #define EnergySuffix ".energy.all"
+#define EnergyFragmentSuffix ".energyfragment.all"
+#define ForcesSuffix ".forces.all"
+#define ForceFragmentSuffix ".forcefragment.all"
 #define HcorrectionSuffix ".Hcorrection.all"
+#define ForcesSuffix ".forces.all"
+#define HcorrectionFragmentSuffix ".Hcorrectionfragment.all"
+#define HessianSuffix ".hessian_xx.all"
+#define HessianFragmentSuffix ".hessianfragment_xx.all"
+#define OrderSuffix ".Order"
 #define ShieldingSuffix ".sigma_all.csv"
 #define ShieldingPASSuffix ".sigma_all_PAS.csv"
 #define ShieldingFragmentSuffix ".sigma_all_fragment.all"
 #define ShieldingPASFragmentSuffix ".sigma_all_PAS_fragment.all"
+#define ChiSuffix ".chi_all.csv"
+#define ChiPASSuffix ".chi_all_PAS.csv"
+#define ChiFragmentSuffix ".chi_all_fragment.all"
+#define ChiPASFragmentSuffix ".chi_all_PAS_fragment.all"
 #define TimeSuffix ".speed"
-#define EnergyFragmentSuffix ".energyfragment.all"
-#define HcorrectionFragmentSuffix ".Hcorrectionfragment.all"
-#define ForceFragmentSuffix ".forcefragment.all"
-#define OrderSuffix ".Order"
 // ======================================= FUNCTIONS ==========================================
 …
 class MatrixContainer {
+        public:
+                double ***Matrix;
+                int **Indices;
+                char *Header;
+                int MatrixCounter;
+                int *RowCounter;
+                int ColumnCounter;
+        MatrixContainer();
+        virtual ~MatrixContainer();
+        bool ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr);
+        virtual bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+        bool AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter);
+        bool ResetMatrix();
+        double FindMinValue();
+        double FindMaxValue();
+        bool SetLastMatrix(double value, int skipcolumns);
+        bool SetLastMatrix(double **values, int skipcolumns);
+        //bool ParseIndices();
+        //bool SumSubValues();
+        bool SumSubManyBodyTerms(class MatrixContainer &Matrix, class KeySetsContainer &KeySet, int Order);
+        bool WriteTotalFragments(const char *name, const char *prefix);
+        bool WriteLastMatrix(const char *name, const char *prefix, const char *suffix);
+  public:
+    double ***Matrix;
+    int **Indices;
+    char **Header;
+    int MatrixCounter;
+    int *RowCounter;
+    int *ColumnCounter;
+  MatrixContainer();
+  ~MatrixContainer();
+  bool InitialiseIndices(class MatrixContainer *Matrix = NULL);
+  bool ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr);
+  virtual bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+  bool AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter);
+  bool ResetMatrix();
+  double FindMinValue();
+  double FindMaxValue();
+  bool SetLastMatrix(double value, int skipcolumns);
+  bool SetLastMatrix(double **values, int skipcolumns);
+  //bool ParseIndices();
+  //bool SumSubValues();
+  bool SumSubManyBodyTerms(class MatrixContainer &Matrix, class KeySetsContainer &KeySet, int Order);
+  bool WriteTotalFragments(const char *name, const char *prefix);
+  bool WriteLastMatrix(const char *name, const char *prefix, const char *suffix);
 };
 …
 class EnergyMatrix : public MatrixContainer {
         public:
                 bool ParseIndices();
                 bool SumSubEnergy(class EnergyMatrix &Fragments, class EnergyMatrix *CorrectionFragments, class KeySetsContainer &KeySet, int Order, double sign);
                 bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+  public:
+    bool ParseIndices();
+    bool SumSubEnergy(class EnergyMatrix &Fragments, class EnergyMatrix *CorrectionFragments, class KeySetsContainer &KeySet, int Order, double sign);
+    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
 };
 …
 class ForceMatrix : public MatrixContainer {
+        public:
+                bool ParseIndices(char *name);
+                bool SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
+                bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+  public:
+    bool ParseIndices(char *name);
+    bool SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
+    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+};
+// ======================================= CLASS HessianMatrix =============================
+class HessianMatrix : public MatrixContainer {
+  public:
+    HessianMatrix();
+    //~HessianMatrix();
+    bool ParseIndices(char *name);
+    bool SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order);
+    bool SumSubHessians(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
+    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
+  private:
+    bool IsSymmetric;
 };
 …
 class KeySetsContainer {
         public:
                 int **KeySets;
                 int *AtomCounter;
                 int FragmentCounter;
                 int Order;
                 int *FragmentsPerOrder;
                 int **OrderSet;
+  public:
+    int **KeySets;
+    int *AtomCounter;
+    int FragmentCounter;
+    int Order;
+    int *FragmentsPerOrder;
+    int **OrderSet;
         KeySetsContainer();
         ~KeySetsContainer();
+  KeySetsContainer();
+  ~KeySetsContainer();
         bool ParseKeySets(const char *name, const int *ACounter, const int FCounter);
         bool ParseManyBodyTerms();
         bool Contains(const int GreaterSet, const int SmallerSet);
+  bool ParseKeySets(const char *name, const int *ACounter, const int FCounter);
+  bool ParseManyBodyTerms();
+  bool Contains(const int GreaterSet, const int SmallerSet);
 };

src/periodentafel.cpp

-              r375b458
+              r51c910
 periodentafel::periodentafel()
+{
         start = new element;
         end = new element;
         start->previous = NULL;
         start->next = end;
         end->previous = start;
         end->next = NULL;
+  start = new element;
+  end = new element;
+  start->previous = NULL;
+  start->next = end;
+  end->previous = start;
+  end->next = NULL;
 };
 …
 periodentafel::~periodentafel()
+{
         CleanupPeriodtable();
         delete(end);
         delete(start);
+  CleanupPeriodtable();
+  delete(end);
+  delete(start);
 };
 …
 bool periodentafel::AddElement(element *pointer)
+{
         pointer->sort = &pointer->Z;
         if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
                 cout << Verbose(0) << "Invalid Z number!\n";
         return add(pointer, end);
+  pointer->sort = &pointer->Z;
+  if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
+    cout << Verbose(0) << "Invalid Z number!\n";
+  return add(pointer, end);
 };
 …
 bool periodentafel::RemoveElement(element *pointer)
+{
         return remove(pointer, start, end);
+  return remove(pointer, start, end);
 };
 …
 bool periodentafel::CleanupPeriodtable()
+{
         return cleanup(start,end);
+  return cleanup(start,end);
 };
 …
 element * periodentafel::FindElement(int Z)
+{
         element *walker = find(&Z, start,end);
         if (walker == NULL) { // not found: enter and put into db
                 cout << Verbose(0) << "Element not found in database, please enter." << endl;
                 walker = new element;
                 cout << Verbose(0) << "Mass: " << endl;
                 cin >> walker->mass;
                 walker->Z = Z;
                 cout << Verbose(0) << "Atomic number: " << walker->Z << endl;
                 cout << Verbose(0) << "Name [max 64 chars]: " << endl;
                 cin >> walker->name;
                 cout << Verbose(0) << "Short form [max 3 chars]: " << endl;
                 cin >> walker->symbol;
                 periodentafel::AddElement(walker);
+        }
         return(walker);
+  element *walker = find(&Z, start,end);
+  if (walker == NULL) { // not found: enter and put into db
+    cout << Verbose(0) << "Element not found in database, please enter." << endl;
+    walker = new element;
+    cout << Verbose(0) << "Mass: " << endl;
+    cin >> walker->mass;
+    walker->Z = Z;
+    cout << Verbose(0) << "Atomic number: " << walker->Z << endl;
+    cout << Verbose(0) << "Name [max 64 chars]: " << endl;
+    cin >> walker->name;
+    cout << Verbose(0) << "Short form [max 3 chars]: " << endl;
+    cin >> walker->symbol;
+    periodentafel::AddElement(walker);
+  }
+  return(walker);
 };
 …
 element * periodentafel::FindElement(char *shorthand) const
+{
         element *walker =       periodentafel::start;
         while (walker->next != periodentafel::end) {
                 walker = walker->next;
                 if (strncmp(walker->symbol, shorthand, 3) == 0)
                         return(walker);
+        }
         return (NULL);
+  element *walker =  periodentafel::start;
+  while (walker->next != periodentafel::end) {
+    walker = walker->next;
+    if (strncmp(walker->symbol, shorthand, 3) == 0)
+      return(walker);
+  }
+  return (NULL);
 };
 …
 element * periodentafel::AskElement()
+{
         element *walker = NULL;
         int Z;
         do {
                 cout << Verbose(0) << "Atomic number Z: ";
                 cin >> Z;
                 walker = this->FindElement(Z);  // give type
         } while (walker == NULL);
         return walker;
+  element *walker = NULL;
+  int Z;
+  do {
+    cout << Verbose(0) << "Atomic number Z: ";
+    cin >> Z;
+    walker = this->FindElement(Z);  // give type
+  } while (walker == NULL);
+  return walker;
 };
 …
 bool periodentafel::Output(ofstream *output) const
+{
         bool result = true;
         element *walker = start;
         if (output != NULL) {
                 while (walker->next != end) {
                         walker = walker->next;
                         result = result && walker->Output(output);
+                }
                 return result;
         } else
                 return false;
+  bool result = true;
+  element *walker = start;
+  if (output != NULL) {
+    while (walker->next != end) {
+      walker = walker->next;
+      result = result && walker->Output(output);
+    }
+    return result;
+  } else
+    return false;
 };
 …
 bool periodentafel::Checkout(ofstream *output, const int *checkliste) const
+{
         element *walker = start;
         bool result = true;
         int No = 1;
         if (output != NULL) {
                 *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
                 *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
                 while (walker->next != end) {
                         walker = walker->next;
                         if ((walker != NULL) && (walker->Z > 0) && (walker->Z < MAX_ELEMENTS) && (checkliste[walker->Z])) {
                                 walker->No = No;
                                 result = result && walker->Checkout(output, No++, checkliste[walker->Z]);
+                        }
+                }
                 return result;
         } else
                 return false;
+  element *walker = start;
+  bool result = true;
+  int No = 1;
+  if (output != NULL) {
+    *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
+    *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
+    while (walker->next != end) {
+      walker = walker->next;
+      if ((walker != NULL) && (walker->Z > 0) && (walker->Z < MAX_ELEMENTS) && (checkliste[walker->Z])) {
+        walker->No = No;
+        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);
+      }
+    }
+    return result;
+  } else
+    return false;
 };
 …
 bool periodentafel::LoadPeriodentafel(char *path)
+{
         ifstream infile;
         double tmp;
         element *ptr;
         bool status = true;
         bool otherstatus = true;
         char filename[255];
         // fill elements DB
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
         infile.open(filename);
         if (infile != NULL) {
                 infile.getline(header1, MAXSTRINGSIZE);
                 infile.getline(header2, MAXSTRINGSIZE); // skip first two header lines
                 cout << "Parsed elements:";
                 while (!infile.eof()) {
                         element *neues = new element;
                         infile >> neues->name;
                         //infile >> ws;
                         infile >> neues->symbol;
                         //infile >> ws;
                         infile >> neues->period;
                         //infile >> ws;
                         infile >> neues->group;
                         //infile >> ws;
                         infile >> neues->block;
                         //infile >> ws;
                         infile >> neues->Z;
                         //infile >> ws;
                         infile >> neues->mass;
                         //infile >> ws;
                         infile >> neues->CovalentRadius;
                         //infile >> ws;
                         infile >> neues->VanDerWaalsRadius;
                         //infile >> ws;
                         infile >> ws;
                         cout << " " << neues->symbol;
                         //neues->Output((ofstream *)&cout);
                         if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
                                 periodentafel::AddElement(neues);
                         else {
                                 cout << "Could not parse element: ";
                                 neues->Output((ofstream *)&cout);
+                        }
+                }
                 cout << endl;
                 infile.close();
                 infile.clear();
         } else
                 status = false;
         // fill valence DB per element
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDVALENCEDB, MAXSTRINGSIZE-strlen(filename));
         infile.open(filename);
         if (infile != NULL) {
                 while (!infile.eof()) {
                         infile >> tmp;
                         infile >> ws;
                         infile >> FindElement((int)tmp)->Valence;
                         infile >> ws;
                         //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
+                }
                 infile.close();
                 infile.clear();
         } else
                 otherstatus = false;
         // fill valence DB per element
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
         infile.open(filename);
         if (infile != NULL) {
                 while (!infile.eof()) {
                         infile >> tmp;
                         infile >> ws;
                         infile >> FindElement((int)tmp)->NoValenceOrbitals;
                         infile >> ws;
                         //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+                }
                 infile.close();
                 infile.clear();
         } else
                 otherstatus = false;
         // fill H-BondDistance DB per element
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDHBONDDISTANCEDB, MAXSTRINGSIZE-strlen(filename));
         infile.open(filename);
         if (infile != NULL) {
                 while (!infile.eof()) {
                         infile >> tmp;
                         ptr = FindElement((int)tmp);
                         infile >> ws;
                         infile >> ptr->HBondDistance[0];
                         infile >> ptr->HBondDistance[1];
                         infile >> ptr->HBondDistance[2];
                         infile >> ws;
                         //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondDistance[0] << " Angstrom typical distance to hydrogen." << endl;
+                }
                 infile.close();
                 infile.clear();
         } else
                 otherstatus = false;
         // fill H-BondAngle DB per element
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDHBONDANGLEDB, MAXSTRINGSIZE-strlen(filename));
         infile.open(filename);
         if (infile != NULL) {
                 while (!infile.eof()) {
                         infile >> tmp;
                         ptr = FindElement((int)tmp);
                         infile >> ws;
                         infile >> ptr->HBondAngle[0];
                         infile >> ptr->HBondAngle[1];
                         infile >> ptr->HBondAngle[2];
                         infile >> ws;
                         //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondAngle[0] << ", " << FindElement((int)tmp)->HBondAngle[1] << ", " << FindElement((int)tmp)->HBondAngle[2] << " degrees bond angle for one, two, three connected hydrogens." << endl;
+                }
                 infile.close();
         } else
                 otherstatus = false;
         if (!otherstatus)
                 cerr << "WARNING: Something went wrong while parsing the other databases!" << endl;
         return status;
+  ifstream infile;
+  double tmp;
+  element *ptr;
+  bool status = true;
+  bool otherstatus = true;
+  char filename[255];
+  // fill elements DB
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    infile.getline(header1, MAXSTRINGSIZE);
+    infile.getline(header2, MAXSTRINGSIZE); // skip first two header lines
+    cout <<  "Parsed elements:";
+    while (!infile.eof()) {
+      element *neues = new element;
+      infile >> neues->name;
+      //infile >> ws;
+      infile >> neues->symbol;
+      //infile >> ws;
+      infile >> neues->period;
+      //infile >> ws;
+      infile >> neues->group;
+      //infile >> ws;
+      infile >> neues->block;
+      //infile >> ws;
+      infile >> neues->Z;
+      //infile >> ws;
+      infile >> neues->mass;
+      //infile >> ws;
+      infile >> neues->CovalentRadius;
+      //infile >> ws;
+      infile >> neues->VanDerWaalsRadius;
+      //infile >> ws;
+      infile >> ws;
+      cout << " " << neues->symbol;
+      //neues->Output((ofstream *)&cout);
+      if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
+        periodentafel::AddElement(neues);
+      else {
+        cout << "Could not parse element: ";
+        neues->Output((ofstream *)&cout);
+      }
+    }
+    cout << endl;
+    infile.close();
+    infile.clear();
+  } else
+    status = false;
+  // fill valence DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDVALENCEDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->Valence;
+      infile >> ws;
+      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill valence DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->NoValenceOrbitals;
+      infile >> ws;
+      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill H-BondDistance DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDDISTANCEDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      infile >> ws;
+      infile >> ptr->HBondDistance[0];
+      infile >> ptr->HBondDistance[1];
+      infile >> ptr->HBondDistance[2];
+      infile >> ws;
+      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondDistance[0] << " Angstrom typical distance to hydrogen." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill H-BondAngle DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDANGLEDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      infile >> ws;
+      infile >> ptr->HBondAngle[0];
+      infile >> ptr->HBondAngle[1];
+      infile >> ptr->HBondAngle[2];
+      infile >> ws;
+      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondAngle[0] << ", " << FindElement((int)tmp)->HBondAngle[1] << ", " << FindElement((int)tmp)->HBondAngle[2] << " degrees bond angle for one, two, three connected hydrogens." << endl;
+    }
+    infile.close();
+  } else
+    otherstatus = false;
+  if (!otherstatus)
+    cerr << "WARNING: Something went wrong while parsing the other databases!" << endl;
+  return status;
 };
 …
 bool periodentafel::StorePeriodentafel(char *path) const
+{
         bool result = true;
         ofstream f;
         char filename[MAXSTRINGSIZE];
         strncpy(filename, path, MAXSTRINGSIZE);
         strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
         strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
         f.open(filename);
         if (f != NULL) {
                 f << header1 << endl;
                 f << header2 << endl;
                 element *walker = periodentafel::start;
                 while (walker->next != periodentafel::end) {
                         walker = walker->next;
                         result = result && walker->Output(&f);
+                }
                 f.close();
         } else
                 result = false;
         return result;
 };
+  bool result = true;
+  ofstream f;
+  char filename[MAXSTRINGSIZE];
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
+  f.open(filename);
+  if (f != NULL) {
+    f << header1 << endl;
+    f << header2 << endl;
+    element *walker = periodentafel::start;
+    while (walker->next != periodentafel::end) {
+      walker = walker->next;
+      result = result && walker->Output(&f);
+    }
+    f.close();
+  } else
+    result = false;
+  return result;
+};

src/verbose.cpp

-              r375b458
+              r51c910
 ostream& operator<<(ostream& ost,const Verbose& m)
+{
         return m.print(ost);
+  return m.print(ost);
 };
 …
 ostream& Binary::print (ostream &ost) const
+{
         int bits = 1, counter = 1;
         while ((bits = 1 << counter) < BinaryNumber)
                 counter++;
         for (int i=0;i<counter-1;i++) {
                 if ((BinaryNumber & (1 << i)) == 0)
                         ost.put('0');
                 else
                         ost.put('1');
+        }
         ost.put('b');
         //cout << "Binary(.) called." << endl;
         return ost;
+  int bits = 1, counter = 1;
+  while ((bits = 1 << counter) < BinaryNumber)
+    counter++;
+  for (int i=0;i<counter-1;i++) {
+    if ((BinaryNumber & (1 << i)) == 0)
+      ost.put('0');
+     else
+      ost.put('1');
+  }
+  ost.put('b');
+  //cout << "Binary(.) called." << endl;
+  return ost;
 };
 …
 ostream& operator<<(ostream& ost,const Binary& m)
+{
         return m.print(ost);
+  return m.print(ost);
 };

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changes in / [375b458:51c910]

Legend:

Download in other formats: