Context Navigation

-              r178f92
+              r437922
 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;
         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 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;
+  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;
 };

src/atom.cpp

-              r178f92
+              r437922
 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)
+{
         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

-              r178f92
+              r437922
 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)
+{
         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;
+  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

-              r178f92
+              r437922
 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;
+}
+;
 …
 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;
+  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;
+}
+;
 …
 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;
+  }
+}
+;
 …
 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;
         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 (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 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);
+                                }
                                 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);
+        }
+        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";
+}
+;
 …
 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;
 // };
 …
  */
 bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]) {
         LineMap::iterator FindLine;
         PointMap::iterator FindPoint;
         *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;
+  LineMap::iterator FindLine;
+  PointMap::iterator FindPoint;
+  *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;
 };
 …
 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)
+{
         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;
+  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;
 };
 …
 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;
         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;
+  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* 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];
         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 != 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;
+    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)
+  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 != 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

-              r178f92
+              r437922
 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 *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);
                 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;
 };

src/builder.cpp

-              r178f92
+              r437922
  * \section about About the Program
+ *
  *      Molecuilder is a short program, written in C++, that enables the construction of a coordinate set for the
  *      atoms making up an molecule by the successive statement of binding angles and distances and referencing to
  *      already constructed atoms.
+ *  Molecuilder is a short program, written in C++, that enables the construction of a coordinate set for the
+ *  atoms making up an molecule by the successive statement of binding angles and distances and referencing to
+ *  already constructed atoms.
+ *
  *      A configuration file may be written that is compatible to the format used by PCP - a parallel Car-Parrinello
  *      molecular dynamics implementation.
+ *  A configuration file may be written that is compatible to the format used by PCP - a parallel Car-Parrinello
+ *  molecular dynamics implementation.
+ *
  * \section install Installation
+ *
  *      Installation should without problems succeed as follows:
  *      -# ./configure (or: mkdir build;mkdir run;cd build; ../configure --bindir=../run)
  *      -# make
  *      -# make install
+ *  Installation should without problems succeed as follows:
+ *  -# ./configure (or: mkdir build;mkdir run;cd build; ../configure --bindir=../run)
+ *  -# make
+ *  -# make install
+ *
  *      Further useful commands are
  *      -# make clean uninstall: deletes .o-files and removes executable from the given binary directory\n
  *      -# make doxygen-doc: Creates these html pages out of the documented source
+ *  Further useful commands are
+ *  -# make clean uninstall: deletes .o-files and removes executable from the given binary directory\n
+ *  -# make doxygen-doc: Creates these html pages out of the documented source
+ *
  * \section run Running
+ *
  *      The program can be executed by running: ./molecuilder
+ *  The program can be executed by running: ./molecuilder
+ *
  *      Note, that it uses a database, called "elements.db", in the executable's directory. If the file is not found,
  *      it is created and any given data on elements of the periodic table will be stored therein and re-used on
  *      later re-execution.
+ *  Note, that it uses a database, called "elements.db", in the executable's directory. If the file is not found,
+ *  it is created and any given data on elements of the periodic table will be stored therein and re-used on
+ *  later re-execution.
+ *
  * \section ref References
+ *
  *      For the special configuration file format, see the documentation of pcp.
+ *  For the special configuration file format, see the documentation of pcp.
+ *
  */
 …
 static void AddAtoms(periodentafel *periode, molecule *mol)
+{
         atom *first, *second, *third, *fourth;
         Vector **atoms;
         Vector x,y,z,n; // coordinates for absolute point in cell volume
         double a,b,c;
         char choice;    // menu choice char
         bool valid;
         cout << Verbose(0) << "===========ADD ATOM============================" << endl;
         cout << Verbose(0) << " a - state absolute coordinates of atom" << endl;
         cout << Verbose(0) << " b - state relative coordinates of atom wrt to reference point" << endl;
         cout << Verbose(0) << " c - state relative coordinates of atom wrt to already placed atom" << endl;
         cout << Verbose(0) << " d - state two atoms, two angles and a distance" << endl;
         cout << Verbose(0) << " e - least square distance position to a set of atoms" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "Note: Specifiy angles in degrees not multiples of Pi!" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch (choice) {
+  atom *first, *second, *third, *fourth;
+  Vector **atoms;
+  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+  double a,b,c;
+  char choice;  // menu choice char
+  bool valid;
+  cout << Verbose(0) << "===========ADD ATOM============================" << endl;
+  cout << Verbose(0) << " a - state absolute coordinates of atom" << endl;
+  cout << Verbose(0) << " b - state relative coordinates of atom wrt to reference point" << endl;
+  cout << Verbose(0) << " c - state relative coordinates of atom wrt to already placed atom" << endl;
+  cout << Verbose(0) << " d - state two atoms, two angles and a distance" << endl;
+  cout << Verbose(0) << " e - least square distance position to a set of atoms" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "Note: Specifiy angles in degrees not multiples of Pi!" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
     default:
       cout << Verbose(0) << "Not a valid choice." << endl;
       break;
                         case 'a': // absolute coordinates of atom
+      case 'a': // absolute coordinates of atom
         cout << Verbose(0) << "Enter absolute coordinates." << endl;
         first = new atom;
         first->x.AskPosition(mol->cell_size, false);
         first->type = periode->AskElement();    // give type
         mol->AddAtom(first);    // add to molecule
                                 break;
                         case 'b': // relative coordinates of atom wrt to reference point
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'b': // relative coordinates of atom wrt to reference point
         first = new atom;
         valid = true;
 …
           cout << Verbose(0) << "\n";
         } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
         first->type = periode->AskElement();    // give type
         mol->AddAtom(first);    // add to molecule
                                 break;
                         case 'c': // relative coordinates of atom wrt to already placed atom
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'c': // relative coordinates of atom wrt to already placed atom
         first = new atom;
         valid = true;
 …
+          }
         } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
         first->type = periode->AskElement();    // give type
         mol->AddAtom(first);    // add to molecule
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
         break;
 …
           cout << Verbose(0) << endl;
         } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
         first->type = periode->AskElement();    // give type
         mol->AddAtom(first);    // add to molecule
                                 break;
                         case 'e': // least square distance position to a set of atoms
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'e': // least square distance position to a set of atoms
         first = new atom;
         atoms = new (Vector*[128]);
 …
           first->x.Output((ofstream *)&cout);
           first->type = periode->AskElement();  // give type
           mol->AddAtom(first);  // add to molecule
+          first->type = periode->AskElement();  // give type
+          mol->AddAtom(first);  // add to molecule
         } else {
           delete first;
           cout << Verbose(0) << "Please enter at least two vectors!\n";
+        }
                                 break;
         };
+        break;
+  };
 };
 …
 static void CenterAtoms(molecule *mol)
+{
         Vector x, y, helper;
         char choice;    // menu choice char
         cout << Verbose(0) << "===========CENTER ATOMS=========================" << endl;
         cout << Verbose(0) << " a - on origin" << endl;
         cout << Verbose(0) << " b - on center of gravity" << endl;
         cout << Verbose(0) << " c - within box with additional boundary" << endl;
         cout << Verbose(0) << " d - within given simulation box" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch (choice) {
                 default:
                         cout << Verbose(0) << "Not a valid choice." << endl;
                         break;
                 case 'a':
                         cout << Verbose(0) << "Centering atoms in config file on origin." << endl;
                         mol->CenterOrigin((ofstream *)&cout);
                         break;
                 case 'b':
                         cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
                         mol->CenterPeriodic((ofstream *)&cout);
                         break;
                 case 'c':
                         cout << Verbose(0) << "Centering atoms in config file within given additional boundary." << endl;
                         for (int i=0;i<NDIM;i++) {
                                 cout << Verbose(0) << "Enter axis " << i << " boundary: ";
                                 cin >> y.x[i];
+                        }
                         mol->CenterEdge((ofstream *)&cout, &x); // make every coordinate positive
                         mol->Center.AddVector(&y); // translate by boundary
                         helper.CopyVector(&y);
                         helper.Scale(2.);
                         helper.AddVector(&x);
                         mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
                         break;
                 case 'd':
                         cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
                         for (int i=0;i<NDIM;i++) {
                                 cout << Verbose(0) << "Enter axis " << i << " boundary: ";
                                 cin >> x.x[i];
+                        }
                         // center
                         mol->CenterInBox((ofstream *)&cout, &x);
                         // update Box of atoms by boundary
                         mol->SetBoxDimension(&x);
                         break;
+        }
+  Vector x, y, helper;
+  char choice;  // menu choice char
+  cout << Verbose(0) << "===========CENTER ATOMS=========================" << endl;
+  cout << Verbose(0) << " a - on origin" << endl;
+  cout << Verbose(0) << " b - on center of gravity" << endl;
+  cout << Verbose(0) << " c - within box with additional boundary" << endl;
+  cout << Verbose(0) << " d - within given simulation box" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      cout << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'a':
+      cout << Verbose(0) << "Centering atoms in config file on origin." << endl;
+      mol->CenterOrigin((ofstream *)&cout);
+      break;
+    case 'b':
+      cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
+      mol->CenterPeriodic((ofstream *)&cout);
+      break;
+    case 'c':
+      cout << Verbose(0) << "Centering atoms in config file within given additional boundary." << endl;
+      for (int i=0;i<NDIM;i++) {
+        cout << Verbose(0) << "Enter axis " << i << " boundary: ";
+        cin >> y.x[i];
+      }
+      mol->CenterEdge((ofstream *)&cout, &x);  // make every coordinate positive
+      mol->Center.AddVector(&y); // translate by boundary
+      helper.CopyVector(&y);
+      helper.Scale(2.);
+      helper.AddVector(&x);
+      mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
+      break;
+    case 'd':
+      cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
+      for (int i=0;i<NDIM;i++) {
+        cout << Verbose(0) << "Enter axis " << i << " boundary: ";
+        cin >> x.x[i];
+      }
+      // center
+      mol->CenterInBox((ofstream *)&cout, &x);
+      // update Box of atoms by boundary
+      mol->SetBoxDimension(&x);
+      break;
+  }
 };
 …
 static void AlignAtoms(periodentafel *periode, molecule *mol)
+{
         atom *first, *second, *third;
         Vector x,n;
         char choice;    // menu choice char
         cout << Verbose(0) << "===========ALIGN ATOMS=========================" << endl;
         cout << Verbose(0) << " a - state three atoms defining align plane" << endl;
         cout << Verbose(0) << " b - state alignment vector" << endl;
         cout << Verbose(0) << " c - state two atoms in alignment direction" << endl;
         cout << Verbose(0) << " d - align automatically by least square fit" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch (choice) {
                 default:
                 case 'a': // three atoms defining mirror plane
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter second atom: ");
                         third = mol->AskAtom("Enter third atom: ");
                         n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
                         break;
                 case 'b': // normal vector of mirror plane
                         cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
                         n.AskPosition(mol->cell_size,0);
                         n.Normalize();
                         break;
                 case 'c': // three atoms defining mirror plane
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter second atom: ");
                         n.CopyVector((const Vector *)&first->x);
                         n.SubtractVector((const Vector *)&second->x);
                         n.Normalize();
                         break;
                 case 'd':
                         char shorthand[4];
                         Vector a;
                         struct lsq_params param;
                         do {
                                 fprintf(stdout, "Enter the element of atoms to be chosen: ");
                                 fscanf(stdin, "%3s", shorthand);
                         } while ((param.type = periode->FindElement(shorthand)) == NULL);
                         cout << Verbose(0) << "Element is " << param.type->name << endl;
                         mol->GetAlignvector(&param);
                         for (int i=NDIM;i--;) {
                                 x.x[i] = gsl_vector_get(param.x,i);
                                 n.x[i] = gsl_vector_get(param.x,i+NDIM);
+                        }
                         gsl_vector_free(param.x);
                         cout << Verbose(0) << "Offset vector: ";
                         x.Output((ofstream *)&cout);
                         cout << Verbose(0) << endl;
                         n.Normalize();
                         break;
         };
         cout << Verbose(0) << "Alignment vector: ";
         n.Output((ofstream *)&cout);
         cout << Verbose(0) << endl;
         mol->Align(&n);
+  atom *first, *second, *third;
+  Vector x,n;
+  char choice;  // menu choice char
+  cout << Verbose(0) << "===========ALIGN ATOMS=========================" << endl;
+  cout << Verbose(0) << " a - state three atoms defining align plane" << endl;
+  cout << Verbose(0) << " b - state alignment vector" << endl;
+  cout << Verbose(0) << " c - state two atoms in alignment direction" << endl;
+  cout << Verbose(0) << " d - align automatically by least square fit" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      third = mol->AskAtom("Enter third atom: ");
+      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
+      break;
+    case 'b': // normal vector of mirror plane
+      cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
+      n.AskPosition(mol->cell_size,0);
+      n.Normalize();
+      break;
+    case 'c': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      n.CopyVector((const Vector *)&first->x);
+      n.SubtractVector((const Vector *)&second->x);
+      n.Normalize();
+      break;
+    case 'd':
+      char shorthand[4];
+      Vector a;
+      struct lsq_params param;
+      do {
+        fprintf(stdout, "Enter the element of atoms to be chosen: ");
+        fscanf(stdin, "%3s", shorthand);
+      } while ((param.type = periode->FindElement(shorthand)) == NULL);
+      cout << Verbose(0) << "Element is " << param.type->name << endl;
+      mol->GetAlignvector(&param);
+      for (int i=NDIM;i--;) {
+        x.x[i] = gsl_vector_get(param.x,i);
+        n.x[i] = gsl_vector_get(param.x,i+NDIM);
+      }
+      gsl_vector_free(param.x);
+      cout << Verbose(0) << "Offset vector: ";
+      x.Output((ofstream *)&cout);
+      cout << Verbose(0) << endl;
+      n.Normalize();
+      break;
+  };
+  cout << Verbose(0) << "Alignment vector: ";
+  n.Output((ofstream *)&cout);
+  cout << Verbose(0) << endl;
+  mol->Align(&n);
 };
 …
 static void MirrorAtoms(molecule *mol)
+{
         atom *first, *second, *third;
         Vector n;
         char choice;    // menu choice char
         cout << Verbose(0) << "===========MIRROR ATOMS=========================" << endl;
         cout << Verbose(0) << " a - state three atoms defining mirror plane" << endl;
         cout << Verbose(0) << " b - state normal vector of mirror plane" << endl;
         cout << Verbose(0) << " c - state two atoms in normal direction" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch (choice) {
                 default:
                 case 'a': // three atoms defining mirror plane
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter second atom: ");
                         third = mol->AskAtom("Enter third atom: ");
                         n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
                         break;
                 case 'b': // normal vector of mirror plane
                         cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
                         n.AskPosition(mol->cell_size,0);
                         n.Normalize();
                         break;
                 case 'c': // three atoms defining mirror plane
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter second atom: ");
                         n.CopyVector((const Vector *)&first->x);
                         n.SubtractVector((const Vector *)&second->x);
                         n.Normalize();
                         break;
         };
         cout << Verbose(0) << "Normal vector: ";
         n.Output((ofstream *)&cout);
         cout << Verbose(0) << endl;
         mol->Mirror((const Vector *)&n);
+  atom *first, *second, *third;
+  Vector n;
+  char choice;  // menu choice char
+  cout << Verbose(0) << "===========MIRROR ATOMS=========================" << endl;
+  cout << Verbose(0) << " a - state three atoms defining mirror plane" << endl;
+  cout << Verbose(0) << " b - state normal vector of mirror plane" << endl;
+  cout << Verbose(0) << " c - state two atoms in normal direction" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      third = mol->AskAtom("Enter third atom: ");
+      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
+      break;
+    case 'b': // normal vector of mirror plane
+      cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
+      n.AskPosition(mol->cell_size,0);
+      n.Normalize();
+      break;
+    case 'c': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      n.CopyVector((const Vector *)&first->x);
+      n.SubtractVector((const Vector *)&second->x);
+      n.Normalize();
+      break;
+  };
+  cout << Verbose(0) << "Normal vector: ";
+  n.Output((ofstream *)&cout);
+  cout << Verbose(0) << endl;
+  mol->Mirror((const Vector *)&n);
 };
 …
 static void RemoveAtoms(molecule *mol)
+{
         atom *first, *second;
         int axis;
         double tmp1, tmp2;
         char choice;    // menu choice char
         cout << Verbose(0) << "===========REMOVE ATOMS=========================" << endl;
         cout << Verbose(0) << " a - state atom for removal by number" << endl;
         cout << Verbose(0) << " b - keep only in radius around atom" << endl;
         cout << Verbose(0) << " c - remove this with one axis greater value" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch (choice) {
                 default:
                 case 'a':
                         if (mol->RemoveAtom(mol->AskAtom("Enter number of atom within molecule: ")))
                                 cout << Verbose(1) << "Atom removed." << endl;
                         else
                                 cout << Verbose(1) << "Atom not found." << endl;
                         break;
                 case 'b':
                         second = mol->AskAtom("Enter number of atom as reference point: ");
                         cout << Verbose(0) << "Enter radius: ";
                         cin >> tmp1;
                         first = mol->start;
                         while(first->next != mol->end) {
                                 first = first->next;
                                 if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
                                         mol->RemoveAtom(first);
+                        }
                         break;
                 case 'c':
                         cout << Verbose(0) << "Which axis is it: ";
                         cin >> axis;
                         cout << Verbose(0) << "Left inward boundary: ";
                         cin >> tmp1;
                         cout << Verbose(0) << "Right inward boundary: ";
                         cin >> tmp2;
                         first = mol->start;
                         while(first->next != mol->end) {
                                 first = first->next;
                                 if ((first->x.x[axis] > tmp2) || (first->x.x[axis] < tmp1)) // out of boundary ...
                                         mol->RemoveAtom(first);
+                        }
                         break;
         };
         //mol->Output((ofstream *)&cout);
         choice = 'r';
+  atom *first, *second;
+  int axis;
+  double tmp1, tmp2;
+  char choice;  // menu choice char
+  cout << Verbose(0) << "===========REMOVE ATOMS=========================" << endl;
+  cout << Verbose(0) << " a - state atom for removal by number" << endl;
+  cout << Verbose(0) << " b - keep only in radius around atom" << endl;
+  cout << Verbose(0) << " c - remove this with one axis greater value" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a':
+      if (mol->RemoveAtom(mol->AskAtom("Enter number of atom within molecule: ")))
+        cout << Verbose(1) << "Atom removed." << endl;
+      else
+        cout << Verbose(1) << "Atom not found." << endl;
+      break;
+    case 'b':
+      second = mol->AskAtom("Enter number of atom as reference point: ");
+      cout << Verbose(0) << "Enter radius: ";
+      cin >> tmp1;
+      first = mol->start;
+      while(first->next != mol->end) {
+        first = first->next;
+        if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
+          mol->RemoveAtom(first);
+      }
+      break;
+    case 'c':
+      cout << Verbose(0) << "Which axis is it: ";
+      cin >> axis;
+      cout << Verbose(0) << "Left inward boundary: ";
+      cin >> tmp1;
+      cout << Verbose(0) << "Right inward boundary: ";
+      cin >> tmp2;
+      first = mol->start;
+      while(first->next != mol->end) {
+        first = first->next;
+        if ((first->x.x[axis] > tmp2) || (first->x.x[axis] < tmp1)) // out of boundary ...
+          mol->RemoveAtom(first);
+      }
+      break;
+  };
+  //mol->Output((ofstream *)&cout);
+  choice = 'r';
 };
 …
 static void MeasureAtoms(periodentafel *periode, molecule *mol, config *configuration)
+{
         atom *first, *second, *third;
         Vector x,y;
         double min[256], tmp1, tmp2, tmp3;
         int Z;
         char choice;    // menu choice char
         cout << Verbose(0) << "===========MEASURE ATOMS=========================" << endl;
         cout << Verbose(0) << " a - calculate bond length between one atom and all others" << endl;
         cout << Verbose(0) << " b - calculate bond length between two atoms" << endl;
         cout << Verbose(0) << " c - calculate bond angle" << endl;
         cout << Verbose(0) << " d - calculate principal axis of the system" << endl;
         cout << Verbose(0) << " e - calculate volume of the convex envelope" << endl;
         cout << Verbose(0) << " f - calculate temperature from current velocity" << endl;
         cout << Verbose(0) << " g - output all temperatures per step from velocities" << endl;
         cout << Verbose(0) << "all else - go back" << endl;
         cout << Verbose(0) << "===============================================" << endl;
         cout << Verbose(0) << "INPUT: ";
         cin >> choice;
         switch(choice) {
                 default:
                         cout << Verbose(1) << "Not a valid choice." << endl;
                         break;
                 case 'a':
                         first = mol->AskAtom("Enter first atom: ");
                         for (int i=MAX_ELEMENTS;i--;)
                                 min[i] = 0.;
                         second = mol->start;
                         while ((second->next != mol->end)) {
                                 second = second->next; // advance
                                 Z = second->type->Z;
                                 tmp1 = 0.;
                                 if (first != second) {
                                         x.CopyVector((const Vector *)&first->x);
                                         x.SubtractVector((const Vector *)&second->x);
                                         tmp1 = x.Norm();
+                                }
                                 if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
                                 //cout << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+                        }
                         for (int i=MAX_ELEMENTS;i--;)
                                 if (min[i] != 0.) cout << Verbose(0) << "Minimum Bond length between " << first->type->name << " Atom " << first->nr << " and next Ion of type " << (periode->FindElement(i))->name << ": " << min[i] << " a.u." << endl;
                         break;
                 case 'b':
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter second atom: ");
                         for (int i=NDIM;i--;)
                                 min[i] = 0.;
                         x.CopyVector((const Vector *)&first->x);
                         x.SubtractVector((const Vector *)&second->x);
                         tmp1 = x.Norm();
                         cout << Verbose(1) << "Distance vector is ";
                         x.Output((ofstream *)&cout);
                         cout << "." << endl << "Norm of distance is " << tmp1 << "." << endl;
                         break;
                 case 'c':
                         cout << Verbose(0) << "Evaluating bond angle between three - first, central, last - atoms." << endl;
                         first = mol->AskAtom("Enter first atom: ");
                         second = mol->AskAtom("Enter central atom: ");
                         third   = mol->AskAtom("Enter last atom: ");
                         tmp1 = tmp2 = tmp3 = 0.;
                         x.CopyVector((const Vector *)&first->x);
                         x.SubtractVector((const Vector *)&second->x);
                         y.CopyVector((const Vector *)&third->x);
                         y.SubtractVector((const Vector *)&second->x);
                         cout << Verbose(0) << "Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ";
                         cout << Verbose(0) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl;
                         break;
                 case 'd':
                         cout << Verbose(0) << "Evaluating prinicipal axis." << endl;
                         cout << Verbose(0) << "Shall we rotate? [0/1]: ";
                         cin >> Z;
                         if ((Z >=0) && (Z <=1))
                                 mol->PrincipalAxisSystem((ofstream *)&cout, (bool)Z);
                         else
                                 mol->PrincipalAxisSystem((ofstream *)&cout, false);
                         break;
                 case 'e':
                         cout << Verbose(0) << "Evaluating volume of the convex envelope.";
                         VolumeOfConvexEnvelope((ofstream *)&cout, NULL, configuration, NULL, mol);
                         break;
                 case 'f':
                         mol->OutputTemperatureFromTrajectories((ofstream *)&cout, mol->MDSteps-1, mol->MDSteps, (ofstream *)&cout);
                         break;
                 case 'g':
+                        {
                                 char filename[255];
                                 cout << "Please enter filename: " << endl;
                                 cin >> filename;
                                 cout << Verbose(1) << "Storing temperatures in " << filename << "." << endl;
                                 ofstream *output = new ofstream(filename, ios::trunc);
                                 if (!mol->OutputTemperatureFromTrajectories((ofstream *)&cout, 0, mol->MDSteps, output))
                                         cout << Verbose(2) << "File could not be written." << endl;
                                 else
                                         cout << Verbose(2) << "File stored." << endl;
                                 output->close();
                                 delete(output);
+                        }
                         break;
+        }
+  atom *first, *second, *third;
+  Vector x,y;
+  double min[256], tmp1, tmp2, tmp3;
+  int Z;
+  char choice;  // menu choice char
+  cout << Verbose(0) << "===========MEASURE ATOMS=========================" << endl;
+  cout << Verbose(0) << " a - calculate bond length between one atom and all others" << endl;
+  cout << Verbose(0) << " b - calculate bond length between two atoms" << endl;
+  cout << Verbose(0) << " c - calculate bond angle" << endl;
+  cout << Verbose(0) << " d - calculate principal axis of the system" << endl;
+  cout << Verbose(0) << " e - calculate volume of the convex envelope" << endl;
+  cout << Verbose(0) << " f - calculate temperature from current velocity" << endl;
+  cout << Verbose(0) << " g - output all temperatures per step from velocities" << endl;
+  cout << Verbose(0) << "all else - go back" << endl;
+  cout << Verbose(0) << "===============================================" << endl;
+  cout << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch(choice) {
+    default:
+      cout << Verbose(1) << "Not a valid choice." << endl;
+      break;
+    case 'a':
+      first = mol->AskAtom("Enter first atom: ");
+      for (int i=MAX_ELEMENTS;i--;)
+        min[i] = 0.;
+      second = mol->start;
+      while ((second->next != mol->end)) {
+        second = second->next; // advance
+        Z = second->type->Z;
+        tmp1 = 0.;
+        if (first != second) {
+          x.CopyVector((const Vector *)&first->x);
+          x.SubtractVector((const Vector *)&second->x);
+          tmp1 = x.Norm();
+        }
+        if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
+        //cout << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+      }
+      for (int i=MAX_ELEMENTS;i--;)
+        if (min[i] != 0.) cout << Verbose(0) << "Minimum Bond length between " << first->type->name << " Atom " << first->nr << " and next Ion of type " << (periode->FindElement(i))->name << ": " << min[i] << " a.u." << endl;
+      break;
+    case 'b':
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      for (int i=NDIM;i--;)
+        min[i] = 0.;
+      x.CopyVector((const Vector *)&first->x);
+      x.SubtractVector((const Vector *)&second->x);
+      tmp1 = x.Norm();
+      cout << Verbose(1) << "Distance vector is ";
+      x.Output((ofstream *)&cout);
+      cout << "." << endl << "Norm of distance is " << tmp1 << "." << endl;
+      break;
+    case 'c':
+      cout << Verbose(0) << "Evaluating bond angle between three - first, central, last - atoms." << endl;
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter central atom: ");
+      third  = mol->AskAtom("Enter last atom: ");
+      tmp1 = tmp2 = tmp3 = 0.;
+      x.CopyVector((const Vector *)&first->x);
+      x.SubtractVector((const Vector *)&second->x);
+      y.CopyVector((const Vector *)&third->x);
+      y.SubtractVector((const Vector *)&second->x);
+      cout << Verbose(0) << "Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ";
+      cout << Verbose(0) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl;
+      break;
+    case 'd':
+      cout << Verbose(0) << "Evaluating prinicipal axis." << endl;
+      cout << Verbose(0) << "Shall we rotate? [0/1]: ";
+      cin >> Z;
+      if ((Z >=0) && (Z <=1))
+        mol->PrincipalAxisSystem((ofstream *)&cout, (bool)Z);
+      else
+        mol->PrincipalAxisSystem((ofstream *)&cout, false);
+      break;
+    case 'e':
+      cout << Verbose(0) << "Evaluating volume of the convex envelope.";
+      VolumeOfConvexEnvelope((ofstream *)&cout, NULL, configuration, NULL, mol);
+      break;
+    case 'f':
+      mol->OutputTemperatureFromTrajectories((ofstream *)&cout, mol->MDSteps-1, mol->MDSteps, (ofstream *)&cout);
+      break;
+    case 'g':
+      {
+        char filename[255];
+        cout << "Please enter filename: " << endl;
+        cin >> filename;
+        cout << Verbose(1) << "Storing temperatures in " << filename << "." << endl;
+        ofstream *output = new ofstream(filename, ios::trunc);
+        if (!mol->OutputTemperatureFromTrajectories((ofstream *)&cout, 0, mol->MDSteps, output))
+          cout << Verbose(2) << "File could not be written." << endl;
+        else
+          cout << Verbose(2) << "File stored." << endl;
+        output->close();
+        delete(output);
+      }
+      break;
+  }
 };
 …
 static void FragmentAtoms(molecule *mol, config *configuration)
+{
         int Order1;
         clock_t start, end;
         cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
         cout << Verbose(0) << "What's the desired bond order: ";
         cin >> Order1;
         if (mol->first->next != mol->last) {    // there are bonds
                 start = clock();
                 mol->FragmentMolecule((ofstream *)&cout, Order1, configuration);
                 end = clock();
                 cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
         } else
                 cout << Verbose(0) << "Connection matrix has not yet been generated!" << endl;
+  int Order1;
+  clock_t start, end;
+  cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
+  cout << Verbose(0) << "What's the desired bond order: ";
+  cin >> Order1;
+  if (mol->first->next != mol->last) {  // there are bonds
+    start = clock();
+    mol->FragmentMolecule((ofstream *)&cout, Order1, configuration);
+    end = clock();
+    cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+  } else
+    cout << Verbose(0) << "Connection matrix has not yet been generated!" << endl;
 };
 …
 static void testroutine(MoleculeListClass *molecules)
+{
         // the current test routine checks the functionality of the KeySet&Graph concept:
         // We want to have a multiindex (the KeySet) describing a unique subgraph
+  // the current test routine checks the functionality of the KeySet&Graph concept:
+  // We want to have a multiindex (the KeySet) describing a unique subgraph
   int i, comp, counter=0;
 …
   atom *Walker = mol->start;
         // generate some KeySets
         cout << "Generating KeySets." << endl;
         KeySet TestSets[mol->AtomCount+1];
         i=1;
         while (Walker->next != mol->end) {
                 Walker = Walker->next;
                 for (int j=0;j<i;j++) {
                         TestSets[j].insert(Walker->nr);
+                }
                 i++;
+        }
         cout << "Testing insertion of already present item in KeySets." << endl;
         KeySetTestPair test;
         test = TestSets[mol->AtomCount-1].insert(Walker->nr);
         if (test.second) {
                 cout << Verbose(1) << "Insertion worked?!" << endl;
         } else {
                 cout << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+        }
         TestSets[mol->AtomCount].insert(mol->end->previous->nr);
         TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
         // constructing Graph structure
         cout << "Generating Subgraph class." << endl;
         Graph Subgraphs;
         // insert KeySets into Subgraphs
         cout << "Inserting KeySets into Subgraph class." << endl;
         for (int j=0;j<mol->AtomCount;j++) {
                 Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+        }
         cout << "Testing insertion of already present item in Subgraph." << endl;
         GraphTestPair test2;
         test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
         if (test2.second) {
                 cout << Verbose(1) << "Insertion worked?!" << endl;
         } else {
                 cout << Verbose(1) << "Insertion rejected: Present object is " << (*(test2.first)).second.first << "." << endl;
+        }
         // show graphs
         cout << "Showing Subgraph's contents, checking that it's sorted." << endl;
         Graph::iterator A = Subgraphs.begin();
         while (A !=     Subgraphs.end()) {
                 cout << (*A).second.first << ": ";
                 KeySet::iterator key = (*A).first.begin();
                 comp = -1;
                 while (key != (*A).first.end()) {
                         if ((*key) > comp)
                                 cout << (*key) << " ";
                         else
                                 cout << (*key) << "! ";
                         comp = (*key);
                         key++;
+                }
                 cout << endl;
                 A++;
+        }
         delete(mol);
+  // generate some KeySets
+  cout << "Generating KeySets." << endl;
+  KeySet TestSets[mol->AtomCount+1];
+  i=1;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    for (int j=0;j<i;j++) {
+      TestSets[j].insert(Walker->nr);
+    }
+    i++;
+  }
+  cout << "Testing insertion of already present item in KeySets." << endl;
+  KeySetTestPair test;
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  if (test.second) {
+    cout << Verbose(1) << "Insertion worked?!" << endl;
+  } else {
+    cout << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+  }
+  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
+  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
+  // constructing Graph structure
+  cout << "Generating Subgraph class." << endl;
+  Graph Subgraphs;
+  // insert KeySets into Subgraphs
+  cout << "Inserting KeySets into Subgraph class." << endl;
+  for (int j=0;j<mol->AtomCount;j++) {
+    Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
+  cout << "Testing insertion of already present item in Subgraph." << endl;
+  GraphTestPair test2;
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  if (test2.second) {
+    cout << Verbose(1) << "Insertion worked?!" << endl;
+  } else {
+    cout << Verbose(1) << "Insertion rejected: Present object is " << (*(test2.first)).second.first << "." << endl;
+  }
+  // show graphs
+  cout << "Showing Subgraph's contents, checking that it's sorted." << endl;
+  Graph::iterator A = Subgraphs.begin();
+  while (A !=  Subgraphs.end()) {
+    cout << (*A).second.first << ": ";
+    KeySet::iterator key = (*A).first.begin();
+    comp = -1;
+    while (key != (*A).first.end()) {
+      if ((*key) > comp)
+        cout << (*key) << " ";
+      else
+        cout << (*key) << "! ";
+      comp = (*key);
+      key++;
+    }
+    cout << endl;
+    A++;
+  }
+  delete(mol);
 };
 …
 static void SaveConfig(char *ConfigFileName, config *configuration, periodentafel *periode, MoleculeListClass *molecules)
+{
         char filename[MAXSTRINGSIZE];
         ofstream output;
         molecule *mol = new molecule(periode);
         // 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++) {
           src[N++] = (*ListRunner)->IndexNr;
           (*ListRunner)->Translate(&(*ListRunner)->Center);
+        }
         molecules->SimpleMultiAdd(mol, src, N);
         delete[](src);
         // ... and translate back
+  char filename[MAXSTRINGSIZE];
+  ofstream output;
+  molecule *mol = new molecule(periode);
+  // 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++) {
+    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.);
 …
+  }
         cout << Verbose(0) << "Storing configuration ... " << endl;
         // get correct valence orbitals
         mol->CalculateOrbitals(*configuration);
         configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
         if (ConfigFileName != NULL) { // test the file name
           strcpy(filename, ConfigFileName);
                 output.open(filename, ios::trunc);
         } else if (strlen(configuration->configname) != 0) {
                 strcpy(filename, configuration->configname);
                 output.open(configuration->configname, ios::trunc);
                 } else {
                         strcpy(filename, DEFAULTCONFIG);
                         output.open(DEFAULTCONFIG, ios::trunc);
+                }
         output.close();
         output.clear();
         cout << Verbose(0) << "Saving of config file ";
         if (configuration->Save(filename, periode, mol))
                 cout << "successful." << endl;
         else
                 cout << "failed." << endl;
         // and save to xyz file
         if (ConfigFileName != NULL) {
                 strcpy(filename, ConfigFileName);
                 strcat(filename, ".xyz");
                 output.open(filename, ios::trunc);
+        }
         if (output == NULL) {
                 strcpy(filename,"main_pcp_linux");
                 strcat(filename, ".xyz");
                 output.open(filename, ios::trunc);
+        }
         cout << Verbose(0) << "Saving of XYZ file ";
         if (mol->MDSteps <= 1) {
                 if (mol->OutputXYZ(&output))
                         cout << "successful." << endl;
                 else
                         cout << "failed." << endl;
         } else {
                 if (mol->OutputTrajectoriesXYZ(&output))
                         cout << "successful." << endl;
                 else
                         cout << "failed." << endl;
+        }
         output.close();
         output.clear();
         // and save as MPQC configuration
         if (ConfigFileName != NULL)
                 strcpy(filename, ConfigFileName);
         if (output == NULL)
                 strcpy(filename,"main_pcp_linux");
         cout << Verbose(0) << "Saving as mpqc input ";
         if (configuration->SaveMPQC(filename, mol))
                 cout << "done." << endl;
         else
                 cout << "failed." << endl;
         if (!strcmp(configuration->configpath, configuration->GetDefaultPath())) {
                 cerr << "WARNING: config is found under different path then stated in config file::defaultpath!" << endl;
+        }
         delete(mol);
+  cout << Verbose(0) << "Storing configuration ... " << endl;
+  // get correct valence orbitals
+  mol->CalculateOrbitals(*configuration);
+  configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
+  if (ConfigFileName != NULL) { // test the file name
+    strcpy(filename, ConfigFileName);
+    output.open(filename, ios::trunc);
+  } else if (strlen(configuration->configname) != 0) {
+    strcpy(filename, configuration->configname);
+    output.open(configuration->configname, ios::trunc);
+    } else {
+      strcpy(filename, DEFAULTCONFIG);
+      output.open(DEFAULTCONFIG, ios::trunc);
+    }
+  output.close();
+  output.clear();
+  cout << Verbose(0) << "Saving of config file ";
+  if (configuration->Save(filename, periode, mol))
+    cout << "successful." << endl;
+  else
+    cout << "failed." << endl;
+  // and save to xyz file
+  if (ConfigFileName != NULL) {
+    strcpy(filename, ConfigFileName);
+    strcat(filename, ".xyz");
+    output.open(filename, ios::trunc);
+  }
+  if (output == NULL) {
+    strcpy(filename,"main_pcp_linux");
+    strcat(filename, ".xyz");
+    output.open(filename, ios::trunc);
+  }
+  cout << Verbose(0) << "Saving of XYZ file ";
+  if (mol->MDSteps <= 1) {
+    if (mol->OutputXYZ(&output))
+      cout << "successful." << endl;
+    else
+      cout << "failed." << endl;
+  } else {
+    if (mol->OutputTrajectoriesXYZ(&output))
+      cout << "successful." << endl;
+    else
+      cout << "failed." << endl;
+  }
+  output.close();
+  output.clear();
+  // and save as MPQC configuration
+  if (ConfigFileName != NULL)
+    strcpy(filename, ConfigFileName);
+  if (output == NULL)
+    strcpy(filename,"main_pcp_linux");
+  cout << Verbose(0) << "Saving as mpqc input ";
+  if (configuration->SaveMPQC(filename, mol))
+    cout << "done." << endl;
+  else
+    cout << "failed." << endl;
+  if (!strcmp(configuration->configpath, configuration->GetDefaultPath())) {
+    cerr << "WARNING: config is found under different path then stated in config file::defaultpath!" << endl;
+  }
+  delete(mol);
 };
 …
 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
         double *factor; // unit factor if desired
         ifstream test;
         ofstream output;
         string line;
         atom *first;
         bool SaveFlag = false;
         int ExitFlag = 0;
         int j;
         double volume = 0.;
         enum ConfigStatus config_present = absent;
         clock_t start,end;
         int argptr;
         PathToDatabases = LocalPath;
         // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
         molecule *mol = new molecule(periode);
+  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+  double *factor; // unit factor if desired
+  ifstream test;
+  ofstream output;
+  string line;
+  atom *first;
+  bool SaveFlag = false;
+  int ExitFlag = 0;
+  int j;
+  double volume = 0.;
+  enum ConfigStatus config_present = absent;
+  clock_t start,end;
+  int argptr;
+  PathToDatabases = LocalPath;
+  // 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);
         if (argc > 1) { // config file specified as option
                 // 1. : Parse options that just set variables or print help
                 argptr = 1;
                 do {
                         if (argv[argptr][0] == '-') {
                                 cout << Verbose(0) << "Recognized command line argument: " << argv[argptr][1] << ".\n";
                                 argptr++;
                                 switch(argv[argptr-1][1]) {
                                         case 'h':
                                         case 'H':
                                         case '?':
                                                 cout << "MoleCuilder suite" << endl << "==================" << endl << endl;
                                                 cout << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl;
                                                 cout << "or simply " << argv[0] << " without arguments for interactive session." << endl;
                                                 cout << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl;
                                                 cout << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl;
                                                 cout << "\t-b x1 x2 x3\tCenter atoms in domain with given edge lengths of (x1,x2,x3)." << endl;
                                                 cout << "\t-B <basis>\tSetting basis to store to MPQC config files." << endl;
                                                 cout << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
                                                 cout << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
                                                 cout << "\t-O\tCenter atoms in origin." << endl;
                                                 cout << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl;
                                                 cout << "\t-e <file>\tSets the databases path to be parsed (default: ./)." << endl;
                                                 cout << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl;
                                                 cout << "\t-f/F <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl;
                                                 cout << "\t-h/-H/-?\tGive this help screen." << endl;
                                                 cout << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl;
                                                 cout << "\t-n\tFast parsing (i.e. no trajectories are looked for)." << endl;
                                                 cout << "\t-N\tGet non-convex-envelope." << endl;
                                                 cout << "\t-o <out>\tGet volume of the convex envelope (and store to tecplot file)." << endl;
                                                 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-r\t\tConvert file from an old pcp syntax." << endl;
                                                 cout << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl;
                                                 cout << "\t-T <file> Store temperatures from the config file in <file>." << endl;
                                                 cout << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl;
                                                 cout << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl;
                                                 cout << "\t-v/-V\t\tGives version information." << endl;
                                                 cout << "Note: config files must not begin with '-' !" << endl;
                                                 delete(mol);
                                                 delete(periode);
                                                 return (1);
                                                 break;
                                         case 'v':
                                         case 'V':
                                                 cout << argv[0] << " " << VERSIONSTRING << endl;
                                                 cout << "Build your own molecule position set." << endl;
                                                 delete(mol);
                                                 delete(periode);
                                                 return (1);
                                                 break;
                                         case 'e':
                                                 if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                         cerr << "Not enough or invalid arguments for specifying element db: -e <db file>" << endl;
                                                 } else {
                                                         cout << "Using " << argv[argptr] << " as elements database." << endl;
                                                         PathToDatabases = argv[argptr];
                                                         argptr+=1;
+                                                }
                                                 break;
                                         case 'n':
                                                 cout << "I won't parse trajectories." << endl;
                                                 configuration.FastParsing = true;
                                                 break;
                                         default:         // no match? Step on
                                                 argptr++;
                                                 break;
+                                }
                         } else
                                 argptr++;
                 } while (argptr < argc);
                 // 2. Parse the element database
                 if (periode->LoadPeriodentafel(PathToDatabases)) {
                         cout << Verbose(0) << "Element list loaded successfully." << endl;
                         //periode->Output((ofstream *)&cout);
                 } else {
                         cout << Verbose(0) << "Element list loading failed." << endl;
                         return 1;
+                }
                 // 3. Find config file name and parse if possible
                 if (argv[1][0] != '-') {
                         cout << Verbose(0) << "Config file given." << endl;
                         test.open(argv[1], ios::in);
                         if (test == NULL) {
                                 //return (1);
                                 output.open(argv[1], ios::out);
                                 if (output == NULL) {
                                         cout << Verbose(1) << "Specified config file " << argv[1] << " not found." << endl;
                                         config_present = absent;
                                 } else {
                                         cout << "Empty configuration file." << endl;
                                         strcpy(ConfigFileName, argv[1]);
                                         config_present = empty;
                                         output.close();
+                                }
                         } else {
                                 test.close();
                                 strcpy(ConfigFileName, argv[1]);
                                 cout << Verbose(1) << "Specified config file found, parsing ... ";
                                 switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
                                         case 1:
                                                 cout << "new syntax." << endl;
                                                 configuration.Load(ConfigFileName, periode, mol);
                                                 config_present = present;
                                                 break;
                                         case 0:
                                                 cout << "old syntax." << endl;
                                                 configuration.LoadOld(ConfigFileName, periode, mol);
                                                 config_present = present;
                                                 break;
                                         default:
                                                 cout << "Unknown syntax or empty, yet present file." << endl;
                                                 config_present = empty;
+                         }
+                        }
                 } else
                         config_present = absent;
                 // 4. parse again through options, now for those depending on elements db and config presence
                 argptr = 1;
                 do {
                         cout << "Current Command line argument: " << argv[argptr] << "." << endl;
                         if (argv[argptr][0] == '-') {
                                 argptr++;
                                 if ((config_present == present) || (config_present == empty)) {
                                         switch(argv[argptr-1][1]) {
                                                 case 'p':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough arguments for parsing: -p <xyz file>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 cout << Verbose(1) << "Parsing xyz file for new atoms." << endl;
                                                                 if (!mol->AddXYZFile(argv[argptr]))
                                                                         cout << Verbose(2) << "File not found." << endl;
                                                                 else {
                                                                         cout << Verbose(2) << "File found and parsed." << endl;
                                                                         config_present = present;
+                                                                }
+                                                        }
                                                         break;
                                                 case 'a':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1]))) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 cout << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
                                                                 first = new atom;
                                                                 first->type = periode->FindElement(atoi(argv[argptr]));
                                                                 if (first->type != NULL)
                                                                         cout << Verbose(2) << "found element " << first->type->name << endl;
                                                                 for (int i=NDIM;i--;)
                                                                         first->x.x[i] = atof(argv[argptr+1+i]);
                                                                 if (first->type != NULL) {
                                                                         mol->AddAtom(first);    // add to molecule
                                                                         if ((config_present == empty) && (mol->AtomCount != 0))
                                                                                 config_present = present;
                                                                 } else
                                                                         cerr << Verbose(1) << "Could not find the specified element." << endl;
                                                                 argptr+=4;
+                                                        }
                                                         break;
                                                 default:         // no match? Don't step on (this is done in next switch's default)
                                                         break;
+                                        }
+                                }
                                 if (config_present == present) {
                                         switch(argv[argptr-1][1]) {
                                                 case 'B':
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for setting MPQC basis: -B <basis name>" << endl;
                                                         } else {
                                                                 configuration.basis = argv[argptr];
                                                                 cout << Verbose(1) << "Setting MPQC basis to " << configuration.basis << "." << endl;
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 'D':
                                                         ExitFlag = 1;
+                                                        {
                                                                 cout << Verbose(1) << "Depth-First-Search Analysis." << endl;
                                                                 MoleculeLeafClass *Subgraphs = NULL;                    // list of subgraphs from DFS analysis
                                                                 int *MinimumRingSize = new int[mol->AtomCount];
                                                                 atom ***ListOfLocalAtoms = NULL;
                                                                 int FragmentCounter = 0;
                                                                 class StackClass<bond *> *BackEdgeStack = NULL;
                                                                 class StackClass<bond *> *LocalBackEdgeStack = NULL;
                                                                 mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr]), configuration.GetIsAngstroem());
                                                                 mol->CreateListOfBondsPerAtom((ofstream *)&cout);
                                                                 Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
                                                                 if (Subgraphs != NULL) {
                                                                         Subgraphs->next->FillBondStructureFromReference((ofstream *)&cout, mol, (FragmentCounter = 0), ListOfLocalAtoms, false);        // we want to keep the created ListOfLocalAtoms
                                                                         while (Subgraphs->next != NULL) {
                                                                                 Subgraphs = Subgraphs->next;
                                                                                 LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
                                                                                 Subgraphs->Leaf->PickLocalBackEdges((ofstream *)&cout, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
                                                                                 Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
                                                                                 delete(LocalBackEdgeStack);
                                                                                 delete(Subgraphs->previous);
+                                                                        }
                                                                         delete(Subgraphs);
                                                                         for (int i=0;i<FragmentCounter;i++)
                                                                                 Free((void **)&ListOfLocalAtoms[FragmentCounter], "ParseCommandLineOptions: **ListOfLocalAtoms[]");
                                                                         Free((void **)&ListOfLocalAtoms, "ParseCommandLineOptions: ***ListOfLocalAtoms");
+                                                                }
                                                                 delete(BackEdgeStack);
                                                                 delete[](MinimumRingSize);
+                                                        }
                                                         //argptr+=1;
                                                         break;
                                                 case 'E':
                                                         ExitFlag = 1;
                                                         if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr+1][0] == '-')) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for changing element: -E <atom nr.> <element>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 cout << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl;
                                                                 first = mol->FindAtom(atoi(argv[argptr]));
                                                                 first->type = periode->FindElement(atoi(argv[argptr+1]));
                                                                 argptr+=2;
+                                                        }
                                                         break;
                                                 case 'A':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                                 ExitFlag =255;
                                                                 cerr << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl;
                                                         } else {
                                                                 cout << "Parsing bonds from " << argv[argptr] << "." << endl;
                                                                 ifstream *input = new ifstream(argv[argptr]);
                                                                 mol->CreateAdjacencyList2((ofstream *)&cout, input);
                                                                 input->close();
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 'N':
                                                         ExitFlag = 1;
                                                         if ((argptr+1 >= argc) || (argv[argptr+1][0] == '-')){
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl;
                                                         } else {
                                                                 class Tesselation T;
                                                                 int N = 15;
                                                                 int number = 100;
                                                                 string filename(argv[argptr+1]);
                                                                 filename.append(".csv");
                                                                 cout << Verbose(0) << "Evaluating non-convex envelope.";
                                                                 cout << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl;
                                                                 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());
                                                                 argptr+=2;
+                                                        }
                                                         break;
                                                 case 'T':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for storing tempature: -T <temperature file>" << endl;
                                                         } else {
                                                                 cout << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl;
                                                                 ofstream *output = new ofstream(argv[argptr], ios::trunc);
                                                                 if (!mol->OutputTemperatureFromTrajectories((ofstream *)&cout, 0, mol->MDSteps, output))
                                                                         cout << Verbose(2) << "File could not be written." << endl;
                                                                 else
                                                                         cout << Verbose(2) << "File stored." << endl;
                                                                 output->close();
                                                                 delete(output);
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 'P':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 cout << Verbose(1) << "Parsing forces file and Verlet integrating." << endl;
                                                                 if (!mol->VerletForceIntegration(argv[argptr], configuration.Deltat, configuration.GetIsAngstroem()))
                                                                         cout << Verbose(2) << "File not found." << endl;
                                                                 else
                                                                         cout << Verbose(2) << "File found and parsed." << endl;
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 't':
                                                         ExitFlag = 1;
                                                         if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for translation: -t <x> <y> <z>" << endl;
                                                         } else {
                                                                 ExitFlag = 1;
                                                                 SaveFlag = true;
                                                                 cout << Verbose(1) << "Translating all ions to new origin." << endl;
                                                                 for (int i=NDIM;i--;)
                                                                         x.x[i] = atof(argv[argptr+i]);
                                                                 mol->Translate((const Vector *)&x);
                                                                 argptr+=3;
+                                                        }
                                                         break;
                                                 case 's':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for scaling: -s <factor/[factor_x]> [factor_y] [factor_z]" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 j = -1;
                                                                 cout << Verbose(1) << "Scaling all ion positions by factor." << endl;
                                                                 factor = new double[NDIM];
                                                                 factor[0] = atof(argv[argptr]);
                                                                 if ((argptr < argc) && (IsValidNumber(argv[argptr])))
                                                                         argptr++;
                                                                 factor[1] = atof(argv[argptr]);
                                                                 if ((argptr < argc) && (IsValidNumber(argv[argptr])))
                                                                         argptr++;
                                                                 factor[2] = atof(argv[argptr]);
                                                                 mol->Scale(&factor);
                                                                 for (int i=0;i<NDIM;i++) {
                                                                         j += i+1;
                                                                         x.x[i] = atof(argv[NDIM+i]);
                                                                         mol->cell_size[j]*=factor[i];
+                                                                }
                                                                 delete[](factor);
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 'b':
                                                         ExitFlag = 1;
                                                         if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for centering in box: -b <length_x> <length_y> <length_z>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 j = -1;
                                                                 cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
                                                                 j=-1;
                                                                 for (int i=0;i<NDIM;i++) {
                                                                         j += i+1;
                                                                         x.x[i] = atof(argv[argptr++]);
                                                                         mol->cell_size[j] += x.x[i]*2.;
+                                                                }
                                                                 // center
                                                                 mol->CenterInBox((ofstream *)&cout, &x);
                                                                 // update Box of atoms by boundary
                                                                 mol->SetBoxDimension(&x);
+                                                        }
                                                         break;
                                                 case 'c':
                                                         ExitFlag = 1;
                                                         if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for centering with boundary: -c <boundary_x> <boundary_y> <boundary_z>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 j = -1;
                                                                 cout << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl;
                                                                 // make every coordinate positive
                                                                 mol->CenterEdge((ofstream *)&cout, &x);
                                                                 // update Box of atoms by boundary
                                                                 mol->SetBoxDimension(&x);
                                                                 // translate each coordinate by boundary
                                                                 j=-1;
                                                                 for (int i=0;i<NDIM;i++) {
                                                                         j += i+1;
                                                                         x.x[i] = atof(argv[argptr++]);
                                                                         mol->cell_size[j] += x.x[i]*2.;
+                                                                }
                                                                 mol->Translate((const Vector *)&x);
+                                                        }
                                                         break;
                                                 case 'O':
                                                         ExitFlag = 1;
                                                         SaveFlag = true;
                                                         cout << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl;
                                                         mol->CenterEdge((ofstream *)&cout, &x);
                                                         mol->SetBoxDimension(&x);
                                                         break;
                                                 case 'r':
                                                         ExitFlag = 1;
                                                         SaveFlag = true;
                                                         cout << Verbose(1) << "Converting config file from supposed old to new syntax." << endl;
                                                         break;
                                                 case 'F':
                                                 case 'f':
                                                         ExitFlag = 1;
                                                         if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1]))) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments for fragmentation: -f <max. bond distance> <bond order>" << endl;
                                                         } else {
                                                                 cout << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl;
                                                                 cout << Verbose(0) << "Creating connection matrix..." << endl;
                                                                 start = clock();
                                                                 mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr++]), configuration.GetIsAngstroem());
                                                                 cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
                                                                 if (mol->first->next != mol->last) {
                                                                         ExitFlag = mol->FragmentMolecule((ofstream *)&cout, atoi(argv[argptr]), &configuration);
+                                                                }
                                                                 end = clock();
                                                                 cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
                                                                 argptr+=2;
+                                                        }
                                                         break;
                                                 case 'm':
                                                         ExitFlag = 1;
                                                         j = atoi(argv[argptr++]);
                                                         if ((j<0) || (j>1)) {
                                                                 cerr << Verbose(1) << "ERROR: Argument of '-m' should be either 0 for no-rotate or 1 for rotate." << endl;
                                                                 j = 0;
+                                                        }
                                                         if (j) {
                                                                 SaveFlag = true;
                                                                 cout << Verbose(0) << "Converting to prinicipal axis system." << endl;
                                                         } else
                                                                 cout << Verbose(0) << "Evaluating prinicipal axis." << endl;
                                                         mol->PrincipalAxisSystem((ofstream *)&cout, (bool)j);
                                                         break;
                                                 case 'o':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (argv[argptr][0] == '-')){
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for convex envelope: -o <tecplot output file>" << endl;
                                                         } else {
                                                                 cout << Verbose(0) << "Evaluating volume of the convex envelope.";
                                                                 cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
                                                                 VolumeOfConvexEnvelope((ofstream *)&cout, argv[argptr], &configuration, NULL, mol);
                                                                 argptr+=1;
+                                                        }
                                                         break;
                                                 case 'U':
                                                         ExitFlag = 1;
                                                         if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for suspension with specified volume: -U <volume> <density>" << endl;
                                                                 volume = -1; // for case 'u': don't print error again
                                                         } else {
                                                                 volume = atof(argv[argptr++]);
                                                                 cout << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl;
+                                                        }
                                                 case 'u':
                                                         ExitFlag = 1;
                                                         if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
                                                                 if (volume != -1)
                                                                         ExitFlag = 255;
                                                                         cerr << "Not enough arguments given for suspension: -u <density>" << endl;
                                                         } else {
                                                                 double density;
                                                                 SaveFlag = true;
                                                                 cout << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.";
                                                                 density = atof(argv[argptr++]);
                                                                 if (density < 1.0) {
                                                                         cerr << Verbose(0) << "Density must be greater than 1.0g/cm^3 !" << endl;
                                                                         density = 1.3;
+                                                                }
 //                                                              for(int i=0;i<NDIM;i++) {
 //                                                                      repetition[i] = atoi(argv[argptr++]);
 //                                                                      if (repetition[i] < 1)
 //                                                                              cerr << Verbose(0) << "ERROR: repetition value must be greater 1!" << endl;
 //                                                                      repetition[i] = 1;
 //                                                              }
                                                                 PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);        // if volume == 0, will calculate from ConvexEnvelope
+                                                        }
                                                         break;
                                                 case 'd':
                                                         ExitFlag = 1;
                                                         if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                                                                 ExitFlag = 255;
                                                                 cerr << "Not enough or invalid arguments given for repeating cells: -d <repeat_x> <repeat_y> <repeat_z>" << endl;
                                                         } else {
                                                                 SaveFlag = true;
                                                                 for (int axis = 1; axis <= NDIM; axis++) {
                                                                         int faktor = atoi(argv[argptr++]);
                                                                         int count;
                                                                         element ** Elements;
                                                                         Vector ** vectors;
                                                                         if (faktor < 1) {
                                                                                 cerr << Verbose(0) << "ERROR: Repetition faktor mus be greater than 1!" << endl;
                                                                                 faktor = 1;
+                                                                        }
                                                                         mol->CountAtoms((ofstream *)&cout);     // recount atoms
                                                                         if (mol->AtomCount != 0) {      // if there is more than none
                                                                                 count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
                                                                                 Elements = new element *[count];
                                                                                 vectors = new Vector *[count];
                                                                                 j = 0;
                                                                                 first = mol->start;
                                                                                 while (first->next != mol->end) {       // make a list of all atoms with coordinates and element
                                                                                         first = first->next;
                                                                                         Elements[j] = first->type;
                                                                                         vectors[j] = &first->x;
                                                                                         j++;
+                                                                                }
                                                                                 if (count != j)
                                                                                         cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
                                                                                 x.Zero();
                                                                                 y.Zero();
                                                                                 y.x[abs(axis)-1] = mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
                                                                                 for (int i=1;i<faktor;i++) {    // then add this list with respective translation factor times
                                                                                         x.AddVector(&y); // per factor one cell width further
                                                                                         for (int k=count;k--;) { // go through every atom of the original cell
                                                                                                 first = new atom(); // create a new body
                                                                                                 first->x.CopyVector(vectors[k]);        // use coordinate of original atom
                                                                                                 first->x.AddVector(&x);                 // translate the coordinates
                                                                                                 first->type = Elements[k];      // insert original element
                                                                                                 mol->AddAtom(first);                            // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+                                                                                        }
+                                                                                }
                                                                                 // free memory
                                                                                 delete[](Elements);
                                                                                 delete[](vectors);
                                                                                 // correct cell size
                                                                                 if (axis < 0) { // if sign was negative, we have to translate everything
                                                                                         x.Zero();
                                                                                         x.AddVector(&y);
                                                                                         x.Scale(-(faktor-1));
                                                                                         mol->Translate(&x);
+                                                                                }
                                                                                 mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+                                                                        }
+                                                                }
+                                                        }
                                                         break;
                                                 default:         // no match? Step on
                                                         if ((argptr < argc) && (argv[argptr][0] != '-')) // if it started with a '-' we've already made a step!
                                                                 argptr++;
                                                         break;
+                                        }
+                                }
                         } else argptr++;
                 } while (argptr < argc);
                 if (SaveFlag)
                         SaveConfig(ConfigFileName, &configuration, periode, molecules);
                 if ((ExitFlag >= 1)) {
                         delete(mol);
                         delete(periode);
                         return (ExitFlag);
+                }
         } else {        // no arguments, hence scan the elements db
                 if (periode->LoadPeriodentafel(PathToDatabases))
                         cout << Verbose(0) << "Element list loaded successfully." << endl;
                 else
                         cout << Verbose(0) << "Element list loading failed." << endl;
                 configuration.RetrieveConfigPathAndName("main_pcp_linux");
+        }
         return(0);
+  molecules->insert(mol);
+  if (argc > 1) { // config file specified as option
+    // 1. : Parse options that just set variables or print help
+    argptr = 1;
+    do {
+      if (argv[argptr][0] == '-') {
+        cout << Verbose(0) << "Recognized command line argument: " << argv[argptr][1] << ".\n";
+        argptr++;
+        switch(argv[argptr-1][1]) {
+          case 'h':
+          case 'H':
+          case '?':
+            cout << "MoleCuilder suite" << endl << "==================" << endl << endl;
+            cout << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl;
+            cout << "or simply " << argv[0] << " without arguments for interactive session." << endl;
+            cout << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl;
+            cout << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl;
+            cout << "\t-b x1 x2 x3\tCenter atoms in domain with given edge lengths of (x1,x2,x3)." << endl;
+            cout << "\t-B <basis>\tSetting basis to store to MPQC config files." << endl;
+            cout << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
+            cout << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
+            cout << "\t-O\tCenter atoms in origin." << endl;
+            cout << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl;
+            cout << "\t-e <file>\tSets the databases path to be parsed (default: ./)." << endl;
+            cout << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl;
+            cout << "\t-f/F <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl;
+            cout << "\t-h/-H/-?\tGive this help screen." << endl;
+            cout << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl;
+            cout << "\t-n\tFast parsing (i.e. no trajectories are looked for)." << endl;
+            cout << "\t-N\tGet non-convex-envelope." << endl;
+            cout << "\t-o <out>\tGet volume of the convex envelope (and store to tecplot file)." << endl;
+            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-r\t\tConvert file from an old pcp syntax." << endl;
+            cout << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl;
+            cout << "\t-T <file> Store temperatures from the config file in <file>." << endl;
+            cout << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl;
+            cout << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl;
+            cout << "\t-v/-V\t\tGives version information." << endl;
+            cout << "Note: config files must not begin with '-' !" << endl;
+            delete(mol);
+            delete(periode);
+            return (1);
+            break;
+          case 'v':
+          case 'V':
+            cout << argv[0] << " " << VERSIONSTRING << endl;
+            cout << "Build your own molecule position set." << endl;
+            delete(mol);
+            delete(periode);
+            return (1);
+            break;
+          case 'e':
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              cerr << "Not enough or invalid arguments for specifying element db: -e <db file>" << endl;
+            } else {
+              cout << "Using " << argv[argptr] << " as elements database." << endl;
+              PathToDatabases = argv[argptr];
+              argptr+=1;
+            }
+            break;
+          case 'n':
+            cout << "I won't parse trajectories." << endl;
+            configuration.FastParsing = true;
+            break;
+          default:   // no match? Step on
+            argptr++;
+            break;
+        }
+      } else
+        argptr++;
+    } while (argptr < argc);
+    // 2. Parse the element database
+    if (periode->LoadPeriodentafel(PathToDatabases)) {
+      cout << Verbose(0) << "Element list loaded successfully." << endl;
+      //periode->Output((ofstream *)&cout);
+    } else {
+      cout << Verbose(0) << "Element list loading failed." << endl;
+      return 1;
+    }
+    // 3. Find config file name and parse if possible
+    if (argv[1][0] != '-') {
+      cout << Verbose(0) << "Config file given." << endl;
+      test.open(argv[1], ios::in);
+      if (test == NULL) {
+        //return (1);
+        output.open(argv[1], ios::out);
+        if (output == NULL) {
+          cout << Verbose(1) << "Specified config file " << argv[1] << " not found." << endl;
+          config_present = absent;
+        } else {
+          cout << "Empty configuration file." << endl;
+          strcpy(ConfigFileName, argv[1]);
+          config_present = empty;
+          output.close();
+        }
+      } else {
+        test.close();
+        strcpy(ConfigFileName, argv[1]);
+        cout << Verbose(1) << "Specified config file found, parsing ... ";
+        switch (configuration.TestSyntax(ConfigFileName, periode, mol)) {
+          case 1:
+            cout << "new syntax." << endl;
+            configuration.Load(ConfigFileName, periode, mol);
+            config_present = present;
+            break;
+          case 0:
+            cout << "old syntax." << endl;
+            configuration.LoadOld(ConfigFileName, periode, mol);
+            config_present = present;
+            break;
+          default:
+            cout << "Unknown syntax or empty, yet present file." << endl;
+            config_present = empty;
+       }
+      }
+    } else
+      config_present = absent;
+    // 4. parse again through options, now for those depending on elements db and config presence
+    argptr = 1;
+    do {
+      cout << "Current Command line argument: " << argv[argptr] << "." << endl;
+      if (argv[argptr][0] == '-') {
+        argptr++;
+        if ((config_present == present) || (config_present == empty)) {
+          switch(argv[argptr-1][1]) {
+            case 'p':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough arguments for parsing: -p <xyz file>" << endl;
+              } else {
+                SaveFlag = true;
+                cout << Verbose(1) << "Parsing xyz file for new atoms." << endl;
+                if (!mol->AddXYZFile(argv[argptr]))
+                  cout << Verbose(2) << "File not found." << endl;
+                else {
+                  cout << Verbose(2) << "File found and parsed." << endl;
+                  config_present = present;
+                }
+              }
+              break;
+            case 'a':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1]))) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl;
+              } else {
+                SaveFlag = true;
+                cout << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
+                first = new atom;
+                first->type = periode->FindElement(atoi(argv[argptr]));
+                if (first->type != NULL)
+                  cout << Verbose(2) << "found element " << first->type->name << endl;
+                for (int i=NDIM;i--;)
+                  first->x.x[i] = atof(argv[argptr+1+i]);
+                if (first->type != NULL) {
+                  mol->AddAtom(first);  // add to molecule
+                  if ((config_present == empty) && (mol->AtomCount != 0))
+                    config_present = present;
+                } else
+                  cerr << Verbose(1) << "Could not find the specified element." << endl;
+                argptr+=4;
+              }
+              break;
+            default:   // no match? Don't step on (this is done in next switch's default)
+              break;
+          }
+        }
+        if (config_present == present) {
+          switch(argv[argptr-1][1]) {
+            case 'B':
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for setting MPQC basis: -B <basis name>" << endl;
+              } else {
+                configuration.basis = argv[argptr];
+                cout << Verbose(1) << "Setting MPQC basis to " << configuration.basis << "." << endl;
+                argptr+=1;
+              }
+              break;
+            case 'D':
+              ExitFlag = 1;
+              {
+                cout << Verbose(1) << "Depth-First-Search Analysis." << endl;
+                MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+                int *MinimumRingSize = new int[mol->AtomCount];
+                atom ***ListOfLocalAtoms = NULL;
+                int FragmentCounter = 0;
+                class StackClass<bond *> *BackEdgeStack = NULL;
+                class StackClass<bond *> *LocalBackEdgeStack = NULL;
+                mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr]), configuration.GetIsAngstroem());
+                mol->CreateListOfBondsPerAtom((ofstream *)&cout);
+                Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
+                if (Subgraphs != NULL) {
+                  Subgraphs->next->FillBondStructureFromReference((ofstream *)&cout, mol, (FragmentCounter = 0), ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+                  while (Subgraphs->next != NULL) {
+                    Subgraphs = Subgraphs->next;
+                    LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
+                    Subgraphs->Leaf->PickLocalBackEdges((ofstream *)&cout, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
+                    Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
+                    delete(LocalBackEdgeStack);
+                    delete(Subgraphs->previous);
+                  }
+                  delete(Subgraphs);
+                  for (int i=0;i<FragmentCounter;i++)
+                    Free((void **)&ListOfLocalAtoms[FragmentCounter], "ParseCommandLineOptions: **ListOfLocalAtoms[]");
+                  Free((void **)&ListOfLocalAtoms, "ParseCommandLineOptions: ***ListOfLocalAtoms");
+                }
+                delete(BackEdgeStack);
+                delete[](MinimumRingSize);
+              }
+              //argptr+=1;
+              break;
+            case 'E':
+              ExitFlag = 1;
+              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr+1][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for changing element: -E <atom nr.> <element>" << endl;
+              } else {
+                SaveFlag = true;
+                cout << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl;
+                first = mol->FindAtom(atoi(argv[argptr]));
+                first->type = periode->FindElement(atoi(argv[argptr+1]));
+                argptr+=2;
+              }
+              break;
+            case 'A':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag =255;
+                cerr << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl;
+              } else {
+                cout << "Parsing bonds from " << argv[argptr] << "." << endl;
+                ifstream *input = new ifstream(argv[argptr]);
+                mol->CreateAdjacencyList2((ofstream *)&cout, input);
+                input->close();
+                argptr+=1;
+              }
+              break;
+            case 'N':
+              ExitFlag = 1;
+              if ((argptr+1 >= argc) || (argv[argptr+1][0] == '-')){
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl;
+              } else {
+                class Tesselation T;
+                int N = 15;
+                int number = 100;
+                string filename(argv[argptr+1]);
+                filename.append(".csv");
+                cout << Verbose(0) << "Evaluating non-convex envelope.";
+                cout << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl;
+                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());
+                argptr+=2;
+              }
+              break;
+            case 'T':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for storing tempature: -T <temperature file>" << endl;
+              } else {
+                cout << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl;
+                ofstream *output = new ofstream(argv[argptr], ios::trunc);
+                if (!mol->OutputTemperatureFromTrajectories((ofstream *)&cout, 0, mol->MDSteps, output))
+                  cout << Verbose(2) << "File could not be written." << endl;
+                else
+                  cout << Verbose(2) << "File stored." << endl;
+                output->close();
+                delete(output);
+                argptr+=1;
+              }
+              break;
+            case 'P':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file>" << endl;
+              } else {
+                SaveFlag = true;
+                cout << Verbose(1) << "Parsing forces file and Verlet integrating." << endl;
+                if (!mol->VerletForceIntegration(argv[argptr], configuration.Deltat, configuration.GetIsAngstroem()))
+                  cout << Verbose(2) << "File not found." << endl;
+                else
+                  cout << Verbose(2) << "File found and parsed." << endl;
+                argptr+=1;
+              }
+              break;
+            case 't':
+              ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for translation: -t <x> <y> <z>" << endl;
+              } else {
+                ExitFlag = 1;
+                SaveFlag = true;
+                cout << Verbose(1) << "Translating all ions to new origin." << endl;
+                for (int i=NDIM;i--;)
+                  x.x[i] = atof(argv[argptr+i]);
+                mol->Translate((const Vector *)&x);
+                argptr+=3;
+              }
+              break;
+            case 's':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for scaling: -s <factor/[factor_x]> [factor_y] [factor_z]" << endl;
+              } else {
+                SaveFlag = true;
+                j = -1;
+                cout << Verbose(1) << "Scaling all ion positions by factor." << endl;
+                factor = new double[NDIM];
+                factor[0] = atof(argv[argptr]);
+                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
+                  argptr++;
+                factor[1] = atof(argv[argptr]);
+                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
+                  argptr++;
+                factor[2] = atof(argv[argptr]);
+                mol->Scale(&factor);
+                for (int i=0;i<NDIM;i++) {
+                  j += i+1;
+                  x.x[i] = atof(argv[NDIM+i]);
+                  mol->cell_size[j]*=factor[i];
+                }
+                delete[](factor);
+                argptr+=1;
+              }
+              break;
+            case 'b':
+              ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for centering in box: -b <length_x> <length_y> <length_z>" << endl;
+              } else {
+                SaveFlag = true;
+                j = -1;
+                cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
+                j=-1;
+                for (int i=0;i<NDIM;i++) {
+                  j += i+1;
+                  x.x[i] = atof(argv[argptr++]);
+                  mol->cell_size[j] += x.x[i]*2.;
+                }
+                // center
+                mol->CenterInBox((ofstream *)&cout, &x);
+                // update Box of atoms by boundary
+                mol->SetBoxDimension(&x);
+              }
+              break;
+            case 'c':
+              ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for centering with boundary: -c <boundary_x> <boundary_y> <boundary_z>" << endl;
+              } else {
+                SaveFlag = true;
+                j = -1;
+                cout << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl;
+                // make every coordinate positive
+                mol->CenterEdge((ofstream *)&cout, &x);
+                // update Box of atoms by boundary
+                mol->SetBoxDimension(&x);
+                // translate each coordinate by boundary
+                j=-1;
+                for (int i=0;i<NDIM;i++) {
+                  j += i+1;
+                  x.x[i] = atof(argv[argptr++]);
+                  mol->cell_size[j] += x.x[i]*2.;
+                }
+                mol->Translate((const Vector *)&x);
+              }
+              break;
+            case 'O':
+              ExitFlag = 1;
+              SaveFlag = true;
+              cout << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl;
+              mol->CenterEdge((ofstream *)&cout, &x);
+              mol->SetBoxDimension(&x);
+              break;
+            case 'r':
+              ExitFlag = 1;
+              SaveFlag = true;
+              cout << Verbose(1) << "Converting config file from supposed old to new syntax." << endl;
+              break;
+            case 'F':
+            case 'f':
+              ExitFlag = 1;
+              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1]))) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments for fragmentation: -f <max. bond distance> <bond order>" << endl;
+              } else {
+                cout << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl;
+                cout << Verbose(0) << "Creating connection matrix..." << endl;
+                start = clock();
+                mol->CreateAdjacencyList((ofstream *)&cout, atof(argv[argptr++]), configuration.GetIsAngstroem());
+                cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
+                if (mol->first->next != mol->last) {
+                  ExitFlag = mol->FragmentMolecule((ofstream *)&cout, atoi(argv[argptr]), &configuration);
+                }
+                end = clock();
+                cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+                argptr+=2;
+              }
+              break;
+            case 'm':
+              ExitFlag = 1;
+              j = atoi(argv[argptr++]);
+              if ((j<0) || (j>1)) {
+                cerr << Verbose(1) << "ERROR: Argument of '-m' should be either 0 for no-rotate or 1 for rotate." << endl;
+                j = 0;
+              }
+              if (j) {
+                SaveFlag = true;
+                cout << Verbose(0) << "Converting to prinicipal axis system." << endl;
+              } else
+                cout << Verbose(0) << "Evaluating prinicipal axis." << endl;
+              mol->PrincipalAxisSystem((ofstream *)&cout, (bool)j);
+              break;
+            case 'o':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')){
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for convex envelope: -o <tecplot output file>" << endl;
+              } else {
+                cout << Verbose(0) << "Evaluating volume of the convex envelope.";
+                cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
+                VolumeOfConvexEnvelope((ofstream *)&cout, argv[argptr], &configuration, NULL, mol);
+                argptr+=1;
+              }
+              break;
+            case 'U':
+              ExitFlag = 1;
+              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for suspension with specified volume: -U <volume> <density>" << endl;
+                volume = -1; // for case 'u': don't print error again
+              } else {
+                volume = atof(argv[argptr++]);
+                cout << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl;
+              }
+            case 'u':
+              ExitFlag = 1;
+              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
+                if (volume != -1)
+                  ExitFlag = 255;
+                  cerr << "Not enough arguments given for suspension: -u <density>" << endl;
+              } else {
+                double density;
+                SaveFlag = true;
+                cout << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.";
+                density = atof(argv[argptr++]);
+                if (density < 1.0) {
+                  cerr << Verbose(0) << "Density must be greater than 1.0g/cm^3 !" << endl;
+                  density = 1.3;
+                }
+//                for(int i=0;i<NDIM;i++) {
+//                  repetition[i] = atoi(argv[argptr++]);
+//                  if (repetition[i] < 1)
+//                    cerr << Verbose(0) << "ERROR: repetition value must be greater 1!" << endl;
+//                  repetition[i] = 1;
+//                }
+                PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
+              }
+              break;
+            case 'd':
+              ExitFlag = 1;
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
+                ExitFlag = 255;
+                cerr << "Not enough or invalid arguments given for repeating cells: -d <repeat_x> <repeat_y> <repeat_z>" << endl;
+              } else {
+                SaveFlag = true;
+                for (int axis = 1; axis <= NDIM; axis++) {
+                  int faktor = atoi(argv[argptr++]);
+                  int count;
+                  element ** Elements;
+                  Vector ** vectors;
+                  if (faktor < 1) {
+                    cerr << Verbose(0) << "ERROR: Repetition faktor mus be greater than 1!" << endl;
+                    faktor = 1;
+                  }
+                  mol->CountAtoms((ofstream *)&cout);  // recount atoms
+                  if (mol->AtomCount != 0) {  // if there is more than none
+                    count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
+                    Elements = new element *[count];
+                    vectors = new Vector *[count];
+                    j = 0;
+                    first = mol->start;
+                    while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
+                      first = first->next;
+                      Elements[j] = first->type;
+                      vectors[j] = &first->x;
+                      j++;
+                    }
+                    if (count != j)
+                      cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
+                    x.Zero();
+                    y.Zero();
+                    y.x[abs(axis)-1] = mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
+                    for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
+                      x.AddVector(&y); // per factor one cell width further
+                      for (int k=count;k--;) { // go through every atom of the original cell
+                        first = new atom(); // create a new body
+                        first->x.CopyVector(vectors[k]);  // use coordinate of original atom
+                        first->x.AddVector(&x);      // translate the coordinates
+                        first->type = Elements[k];  // insert original element
+                        mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+                      }
+                    }
+                    // free memory
+                    delete[](Elements);
+                    delete[](vectors);
+                    // correct cell size
+                    if (axis < 0) { // if sign was negative, we have to translate everything
+                      x.Zero();
+                      x.AddVector(&y);
+                      x.Scale(-(faktor-1));
+                      mol->Translate(&x);
+                    }
+                    mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+                  }
+                }
+              }
+              break;
+            default:   // no match? Step on
+              if ((argptr < argc) && (argv[argptr][0] != '-')) // if it started with a '-' we've already made a step!
+                argptr++;
+              break;
+          }
+        }
+      } else argptr++;
+    } while (argptr < argc);
+    if (SaveFlag)
+      SaveConfig(ConfigFileName, &configuration, periode, molecules);
+    if ((ExitFlag >= 1)) {
+      delete(mol);
+      delete(periode);
+      return (ExitFlag);
+    }
+  } else {  // no arguments, hence scan the elements db
+    if (periode->LoadPeriodentafel(PathToDatabases))
+      cout << Verbose(0) << "Element list loaded successfully." << endl;
+    else
+      cout << Verbose(0) << "Element list loading failed." << endl;
+    configuration.RetrieveConfigPathAndName("main_pcp_linux");
+  }
+  return(0);
 };
 …
 int main(int argc, char **argv)
+{
         periodentafel *periode = new periodentafel; // and a period table of all elements
         MoleculeListClass *molecules = new MoleculeListClass;  // list of all molecules
         molecule *mol = NULL;
         config configuration;
         char choice;    // menu choice char
         Vector x,y,z,n; // coordinates for absolute point in cell volume
         ifstream test;
         ofstream output;
         string line;
         char ConfigFileName[MAXSTRINGSIZE];
         char *ElementsFileName = NULL;
         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
         if (j) return j;        // something went wrong
         // General stuff
         if (molecules->ListOfMolecules.size() == 0) {
+  periodentafel *periode = new periodentafel; // and a period table of all elements
+  MoleculeListClass *molecules = new MoleculeListClass;  // list of all molecules
+  molecule *mol = NULL;
+  config configuration;
+  char choice;  // menu choice char
+  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+  ifstream test;
+  ofstream output;
+  string line;
+  char ConfigFileName[MAXSTRINGSIZE];
+  char *ElementsFileName = NULL;
+  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
+  if (j) return j;  // something went wrong
+  // General stuff
+  if (molecules->ListOfMolecules.size() == 0) {
     mol = new molecule(periode);
     if (mol->cell_size[0] == 0.) {
 …
+    }
     molecules->insert(mol);
+        }
         if (strlen(ConfigFileName) == 0)
           strcpy(ConfigFileName, DEFAULTCONFIG);
         // =========================== START INTERACTIVE SESSION ====================================
         // now the main construction loop
         cout << Verbose(0) << endl << "Now comes the real construction..." << endl;
         do {
                 cout << Verbose(0) << endl << endl;
                 cout << Verbose(0) << "============Molecule list=======================" << endl;
                 molecules->Enumerate((ofstream *)&cout);
                 cout << Verbose(0) << "============Menu===============================" << endl;
+  }
+  if (strlen(ConfigFileName) == 0)
+    strcpy(ConfigFileName, DEFAULTCONFIG);
+  // =========================== START INTERACTIVE SESSION ====================================
+  // now the main construction loop
+  cout << Verbose(0) << endl << "Now comes the real construction..." << endl;
+  do {
+    cout << Verbose(0) << endl << endl;
+    cout << Verbose(0) << "============Molecule list=======================" << endl;
+    molecules->Enumerate((ofstream *)&cout);
+    cout << Verbose(0) << "============Menu===============================" << endl;
     cout << Verbose(0) << "a - set molecule (in)active" << endl;
     cout << Verbose(0) << "e - edit molecules (load, parse, save)" << endl;
 …
     cin >> choice;
                 switch (choice) {
                         case 'a':  // (in)activate molecule
+    switch (choice) {
+      case 'a':  // (in)activate molecule
+        {
           cout << "Enter index of molecule: ";
 …
               (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
+        }
                           break;
                         case 'c': // edit each field of the configuration
                          configuration.Edit();
                          break;
+        break;
+      case 'c': // edit each field of the configuration
+       configuration.Edit();
+       break;
       case 'e': // create molecule
 …
         break;
                         case 'q': // quit
                                 break;
                         case 's': // save to config file
                                 SaveConfig(ConfigFileName, &configuration, periode, molecules);
                                 break;
                         case 'T':
                                 testroutine(molecules);
                                 break;
                         default:
                           break;
                 };
         } while (choice != 'q');
         // save element data base
         if (periode->StorePeriodentafel(ElementsFileName)) //ElementsFileName
                 cout << Verbose(0) << "Saving of elements.db successful." << endl;
         else
                 cout << Verbose(0) << "Saving of elements.db failed." << endl;
         delete(molecules);
         delete(periode);
         return (0);
+      case 'q': // quit
+        break;
+      case 's': // save to config file
+        SaveConfig(ConfigFileName, &configuration, periode, molecules);
+        break;
+      case 'T':
+        testroutine(molecules);
+        break;
+      default:
+        break;
+    };
+  } while (choice != 'q');
+  // save element data base
+  if (periode->StorePeriodentafel(ElementsFileName)) //ElementsFileName
+    cout << Verbose(0) << "Saving of elements.db successful." << endl;
+  else
+    cout << Verbose(0) << "Saving of elements.db failed." << endl;
+  delete(molecules);
+  delete(periode);
+  return (0);
+}

src/config.cpp

-              r178f92
+              r437922
 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");
+  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;
 };
 …
 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");
 };
 …
 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];
+  /* 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);
 };
 …
 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 << "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

-              r178f92
+              r437922
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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;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;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];
+      }
+    }
+  }
 };
 …
 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 << 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;
 };
 …
 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;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;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;
+      }
+    }
+  }
 };
 …
  * 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;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;
+  }
 };
 …
 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;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;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];
+  }
 };
 …
 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);
+  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;
+  }
 };
 …
 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);
+  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;
+  }
 };
 …
 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);
+  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');
+  }
 };
 …
 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);
+  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');
+  }
 };
 …
 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);
+  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');
+  }
 };
 …
 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);
+  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');
+  }
+};

src/defs.hpp

-              r178f92
+              r437922
 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 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/joiner.cpp

-              r178f92
+              r437922
 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;
+  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;
+  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]);
+        }
+  // 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;
+  // Test the given directory
+  if (!TestParams(argc, argv))
+    return 1;
         // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
+  // +++++++++++++++++ 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 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 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 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 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;
+  // ---------- 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;
+        }
+  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;
+        }
+  // ----------- 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 +++++++++++++++++++++++++++++++
+  // +++++++++++++++++ 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;
+                }
+  // --------- 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 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;
+        }
+  // 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;
+  // exit
+  delete(periode);
+  Free((void **)&dir, "main: *dir");
+  cout << "done." << endl;
+  return 0;
 };

src/moleculelist.cpp

-              r178f92
+              r437922
   // 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);
 …
 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

-              r178f92
+              r437922
 double LSQ (const gsl_vector * x, void * params)
+{
         double sum = 0.;
         struct LSQ_params *par = (struct LSQ_params *)params;
         Vector **vectors = par->vectors;
         int num = par->num;
         for (int i=num;i--;) {
                 for(int j=NDIM;j--;)
                         sum += (gsl_vector_get(x,j) - (vectors[i])->x[j])*(gsl_vector_get(x,j) - (vectors[i])->x[j]);
+        }
         return sum;
+  double sum = 0.;
+  struct LSQ_params *par = (struct LSQ_params *)params;
+  Vector **vectors = par->vectors;
+  int num = par->num;
+  for (int i=num;i--;) {
+    for(int j=NDIM;j--;)
+      sum += (gsl_vector_get(x,j) - (vectors[i])->x[j])*(gsl_vector_get(x,j) - (vectors[i])->x[j]);
+  }
+  return sum;
 };
 …
 molecule::molecule(periodentafel *teil)
+{
         // init atom chain list
         start = new atom;
         end = new atom;
         start->father = NULL;
         end->father = NULL;
         link(start,end);
         // init bond chain list
         first = new bond(start, end, 1, -1);
         last = new bond(start, end, 1, -1);
         link(first,last);
         // other stuff
         MDSteps = 0;
         last_atom = 0;
         elemente = teil;
         AtomCount = 0;
         BondCount = 0;
         NoNonBonds = 0;
         NoNonHydrogen = 0;
         NoCyclicBonds = 0;
         ListOfBondsPerAtom = NULL;
         NumberOfBondsPerAtom = NULL;
         ElementCount = 0;
         for(int i=MAX_ELEMENTS;i--;)
                 ElementsInMolecule[i] = 0;
         cell_size[0] = cell_size[2] = cell_size[5]= 20.;
         cell_size[1] = cell_size[3] = cell_size[4]= 0.;
         strcpy(name,"none");
         IndexNr  = -1;
         ActiveFlag = false;
+  // init atom chain list
+  start = new atom;
+  end = new atom;
+  start->father = NULL;
+  end->father = NULL;
+  link(start,end);
+  // init bond chain list
+  first = new bond(start, end, 1, -1);
+  last = new bond(start, end, 1, -1);
+  link(first,last);
+  // other stuff
+  MDSteps = 0;
+  last_atom = 0;
+  elemente = teil;
+  AtomCount = 0;
+  BondCount = 0;
+  NoNonBonds = 0;
+  NoNonHydrogen = 0;
+  NoCyclicBonds = 0;
+  ListOfBondsPerAtom = NULL;
+  NumberOfBondsPerAtom = NULL;
+  ElementCount = 0;
+  for(int i=MAX_ELEMENTS;i--;)
+    ElementsInMolecule[i] = 0;
+  cell_size[0] = cell_size[2] = cell_size[5]= 20.;
+  cell_size[1] = cell_size[3] = cell_size[4]= 0.;
+  strcpy(name,"none");
+  IndexNr  = -1;
+  ActiveFlag = false;
 };
 …
 molecule::~molecule()
+{
         if (ListOfBondsPerAtom != NULL)
                 for(int i=AtomCount;i--;)
                         Free((void **)&ListOfBondsPerAtom[i], "molecule::~molecule: ListOfBondsPerAtom[i]");
         Free((void **)&ListOfBondsPerAtom, "molecule::~molecule: ListOfBondsPerAtom");
         Free((void **)&NumberOfBondsPerAtom, "molecule::~molecule: NumberOfBondsPerAtom");
         CleanupMolecule();
         delete(first);
         delete(last);
         delete(end);
         delete(start);
+  if (ListOfBondsPerAtom != NULL)
+    for(int i=AtomCount;i--;)
+      Free((void **)&ListOfBondsPerAtom[i], "molecule::~molecule: ListOfBondsPerAtom[i]");
+  Free((void **)&ListOfBondsPerAtom, "molecule::~molecule: ListOfBondsPerAtom");
+  Free((void **)&NumberOfBondsPerAtom, "molecule::~molecule: NumberOfBondsPerAtom");
+  CleanupMolecule();
+  delete(first);
+  delete(last);
+  delete(end);
+  delete(start);
 };
 …
 bool molecule::AddAtom(atom *pointer)
+{
         if (pointer != NULL) {
                 pointer->sort = &pointer->nr;
                 pointer->nr = last_atom++;      // increase number within molecule
                 AtomCount++;
                 if (pointer->type != NULL) {
                         if (ElementsInMolecule[pointer->type->Z] == 0)
                                 ElementCount++;
                         ElementsInMolecule[pointer->type->Z]++; // increase number of elements
                         if (pointer->type->Z != 1)
                                 NoNonHydrogen++;
                         if (pointer->Name == NULL) {
                                 Free((void **)&pointer->Name, "molecule::AddAtom: *pointer->Name");
                                 pointer->Name = (char *) Malloc(sizeof(char)*6, "molecule::AddAtom: *pointer->Name");
                                 sprintf(pointer->Name, "%2s%02d", pointer->type->symbol, pointer->nr+1);
+                        }
+                }
                 return add(pointer, end);
         } else
                 return false;
+  if (pointer != NULL) {
+    pointer->sort = &pointer->nr;
+    pointer->nr = last_atom++;  // increase number within molecule
+    AtomCount++;
+    if (pointer->type != NULL) {
+      if (ElementsInMolecule[pointer->type->Z] == 0)
+        ElementCount++;
+      ElementsInMolecule[pointer->type->Z]++; // increase number of elements
+      if (pointer->type->Z != 1)
+        NoNonHydrogen++;
+      if (pointer->Name == NULL) {
+        Free((void **)&pointer->Name, "molecule::AddAtom: *pointer->Name");
+        pointer->Name = (char *) Malloc(sizeof(char)*6, "molecule::AddAtom: *pointer->Name");
+        sprintf(pointer->Name, "%2s%02d", pointer->type->symbol, pointer->nr+1);
+      }
+    }
+    return add(pointer, end);
+  } else
+    return false;
 };
 …
 atom * molecule::AddCopyAtom(atom *pointer)
+{
         if (pointer != NULL) {
                 atom *walker = new atom();
                 walker->type = pointer->type;   // copy element of atom
                 walker->x.CopyVector(&pointer->x); // copy coordination
                 walker->v.CopyVector(&pointer->v); // copy velocity
                 walker->FixedIon = pointer->FixedIon;
                 walker->sort = &walker->nr;
                 walker->nr = last_atom++;       // increase number within molecule
                 walker->father = pointer; //->GetTrueFather();
                 walker->Name = (char *) Malloc(sizeof(char)*strlen(pointer->Name)+1, "molecule::AddCopyAtom: *Name");
                 strcpy (walker->Name, pointer->Name);
                 add(walker, end);
                 if ((pointer->type != NULL) && (pointer->type->Z != 1))
                         NoNonHydrogen++;
                 AtomCount++;
                 return walker;
         } else
                 return NULL;
+  if (pointer != NULL) {
+    atom *walker = new atom();
+    walker->type = pointer->type;  // copy element of atom
+    walker->x.CopyVector(&pointer->x); // copy coordination
+    walker->v.CopyVector(&pointer->v); // copy velocity
+    walker->FixedIon = pointer->FixedIon;
+    walker->sort = &walker->nr;
+    walker->nr = last_atom++;  // increase number within molecule
+    walker->father = pointer; //->GetTrueFather();
+    walker->Name = (char *) Malloc(sizeof(char)*strlen(pointer->Name)+1, "molecule::AddCopyAtom: *Name");
+    strcpy (walker->Name, pointer->Name);
+    add(walker, end);
+    if ((pointer->type != NULL) && (pointer->type->Z != 1))
+      NoNonHydrogen++;
+    AtomCount++;
+    return walker;
+  } else
+    return NULL;
 };
 …
  * -# Single Bond: Simply add new atom with bond distance rescaled to typical hydrogen one
  * -# Double Bond: Here, we need the **BondList of the \a *origin atom, by scanning for the other bonds instead of
  *              *Bond, we use the through these connected atoms to determine the plane they lie in, vector::MakeNormalvector().
  *              The orthonormal vector to this plane along with the vector in *Bond direction determines the plane the two
  *              replacing hydrogens shall lie in. Now, all remains to do is take the usual hydrogen double bond angle for the
  *              element of *origin and form the sin/cos admixture of both plane vectors for the new coordinates of the two
  *              hydrogens forming this angle with *origin.
+ *    *Bond, we use the through these connected atoms to determine the plane they lie in, vector::MakeNormalvector().
+ *    The orthonormal vector to this plane along with the vector in *Bond direction determines the plane the two
+ *    replacing hydrogens shall lie in. Now, all remains to do is take the usual hydrogen double bond angle for the
+ *    element of *origin and form the sin/cos admixture of both plane vectors for the new coordinates of the two
+ *    hydrogens forming this angle with *origin.
  * -# Triple Bond: The idea is to set up a tetraoid (C1-H1-H2-H3) (however the lengths \f$b\f$ of the sides of the base
  *              triangle formed by the to be added hydrogens are not equal to the typical bond distance \f$l\f$ but have to be
  *              determined from the typical angle \f$\alpha\f$ for a hydrogen triple connected to the element of *origin):
  *              We have the height \f$d\f$ as the vector in *Bond direction (from triangle C1-H1-H2).
  *              \f[ h = l \cdot \cos{\left (\frac{\alpha}{2} \right )} \qquad b = 2l \cdot \sin{\left (\frac{\alpha}{2} \right)} \quad \rightarrow \quad d = l \cdot \sqrt{\cos^2{\left (\frac{\alpha}{2} \right)}-\frac{1}{3}\cdot\sin^2{\left (\frac{\alpha}{2}\right )}}
  *              \f]
  *              vector::GetNormalvector() creates one orthonormal vector from this *Bond vector and vector::MakeNormalvector creates
  *              the third one from the former two vectors. The latter ones form the plane of the base triangle mentioned above.
  *              The lengths for these are \f$f\f$ and \f$g\f$ (from triangle H1-H2-(center of H1-H2-H3)) with knowledge that
  *              the median lines in an isosceles triangle meet in the center point with a ratio 2:1.
  *              \f[ f = \frac{b}{\sqrt{3}} \qquad g = \frac{b}{2}
  *              \f]
  *              as the coordination of all three atoms in the coordinate system of these three vectors:
  *              \f$\pmatrix{d & f & 0}\f$, \f$\pmatrix{d & -0.5 \cdot f & g}\f$ and \f$\pmatrix{d & -0.5 \cdot f & -g}\f$.
+ *    triangle formed by the to be added hydrogens are not equal to the typical bond distance \f$l\f$ but have to be
+ *    determined from the typical angle \f$\alpha\f$ for a hydrogen triple connected to the element of *origin):
+ *    We have the height \f$d\f$ as the vector in *Bond direction (from triangle C1-H1-H2).
+ *    \f[ h = l \cdot \cos{\left (\frac{\alpha}{2} \right )} \qquad b = 2l \cdot \sin{\left (\frac{\alpha}{2} \right)} \quad \rightarrow \quad d = l \cdot \sqrt{\cos^2{\left (\frac{\alpha}{2} \right)}-\frac{1}{3}\cdot\sin^2{\left (\frac{\alpha}{2}\right )}}
+ *    \f]
+ *    vector::GetNormalvector() creates one orthonormal vector from this *Bond vector and vector::MakeNormalvector creates
+ *    the third one from the former two vectors. The latter ones form the plane of the base triangle mentioned above.
+ *    The lengths for these are \f$f\f$ and \f$g\f$ (from triangle H1-H2-(center of H1-H2-H3)) with knowledge that
+ *    the median lines in an isosceles triangle meet in the center point with a ratio 2:1.
+ *    \f[ f = \frac{b}{\sqrt{3}} \qquad g = \frac{b}{2}
+ *    \f]
+ *    as the coordination of all three atoms in the coordinate system of these three vectors:
+ *    \f$\pmatrix{d & f & 0}\f$, \f$\pmatrix{d & -0.5 \cdot f & g}\f$ and \f$\pmatrix{d & -0.5 \cdot f & -g}\f$.
+ *
  * \param *out output stream for debugging
 …
  * \param *replacement pointer to the atom which shall be copied as a hydrogen atom in this molecule
  * \param **BondList list of bonds \a *replacement has (necessary to determine plane for double and triple bonds)
  * \param NumBond       number of bonds in \a **BondList
+ * \param NumBond  number of bonds in \a **BondList
  * \param isAngstroem whether the coordination of the given atoms is in AtomicLength (false) or Angstrom(true)
  * \return number of atoms added, if < bond::BondDegree then something went wrong
 …
 bool molecule::AddHydrogenReplacementAtom(ofstream *out, bond *TopBond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem)
+{
         double bondlength;      // bond length of the bond to be replaced/cut
         double bondangle;       // bond angle of the bond to be replaced/cut
         double BondRescale;      // rescale value for the hydrogen bond length
         bool AllWentWell = true;                // flag gathering the boolean return value of molecule::AddAtom and other functions, as return value on exit
         bond *FirstBond = NULL, *SecondBond = NULL; // Other bonds in double bond case to determine "other" plane
         atom *FirstOtherAtom = NULL, *SecondOtherAtom = NULL, *ThirdOtherAtom = NULL; // pointer to hydrogen atoms to be added
         double b,l,d,f,g, alpha, factors[NDIM];         // hold temporary values in triple bond case for coordination determination
         Vector Orthovector1, Orthovector2;      // temporary vectors in coordination construction
         Vector InBondvector;            // vector in direction of *Bond
         bond *Binder = NULL;
         double *matrix;
 //      *out << Verbose(3) << "Begin of AddHydrogenReplacementAtom." << endl;
         // create vector in direction of bond
         InBondvector.CopyVector(&TopReplacement->x);
         InBondvector.SubtractVector(&TopOrigin->x);
         bondlength = InBondvector.Norm();
          // is greater than typical bond distance? Then we have to correct periodically
          // the problem is not the H being out of the box, but InBondvector have the wrong direction
          // due to TopReplacement or Origin being on the wrong side!
         if (bondlength > BondDistance) {
 //              *out << Verbose(4) << "InBondvector is: ";
 //              InBondvector.Output(out);
 //              *out << endl;
                 Orthovector1.Zero();
                 for (int i=NDIM;i--;) {
                         l = TopReplacement->x.x[i] - TopOrigin->x.x[i];
                         if (fabs(l) > BondDistance) { // is component greater than bond distance
                                 Orthovector1.x[i] = (l < 0) ? -1. : +1.;
                         } // (signs are correct, was tested!)
+                }
                 matrix = ReturnFullMatrixforSymmetric(cell_size);
                 Orthovector1.MatrixMultiplication(matrix);
                 InBondvector.SubtractVector(&Orthovector1); // subtract just the additional translation
                 Free((void **)&matrix, "molecule::AddHydrogenReplacementAtom: *matrix");
                 bondlength = InBondvector.Norm();
 //              *out << Verbose(4) << "Corrected InBondvector is now: ";
 //              InBondvector.Output(out);
 //              *out << endl;
         } // periodic correction finished
         InBondvector.Normalize();
         // get typical bond length and store as scale factor for later
         BondRescale = TopOrigin->type->HBondDistance[TopBond->BondDegree-1];
         if (BondRescale == -1) {
                 cerr << Verbose(3) << "ERROR: There is no typical hydrogen bond distance in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
                 return false;
                 BondRescale = bondlength;
         } else {
                 if (!IsAngstroem)
                         BondRescale /= (1.*AtomicLengthToAngstroem);
+        }
         // discern single, double and triple bonds
         switch(TopBond->BondDegree) {
                 case 1:
                         FirstOtherAtom = new atom();            // new atom
                         FirstOtherAtom->type = elemente->FindElement(1);        // element is Hydrogen
                         FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
                         if (TopReplacement->type->Z == 1) { // neither rescale nor replace if it's already hydrogen
                                 FirstOtherAtom->father = TopReplacement;
                                 BondRescale = bondlength;
                         } else {
                                 FirstOtherAtom->father = NULL;  // if we replace hydrogen, we mark it as our father, otherwise we are just an added hydrogen with no father
+                        }
                         InBondvector.Scale(&BondRescale);        // rescale the distance vector to Hydrogen bond length
                         FirstOtherAtom->x.CopyVector(&TopOrigin->x); // set coordination to origin ...
                         FirstOtherAtom->x.AddVector(&InBondvector);     // ... and add distance vector to replacement atom
                         AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
 //                      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
 //                      FirstOtherAtom->x.Output(out);
 //                      *out << endl;
                         Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         break;
                 case 2:
                         // determine two other bonds (warning if there are more than two other) plus valence sanity check
                         for (int i=0;i<NumBond;i++) {
                                 if (BondList[i] != TopBond) {
                                         if (FirstBond == NULL) {
                                                 FirstBond = BondList[i];
                                                 FirstOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
                                         } else if (SecondBond == NULL) {
                                                 SecondBond = BondList[i];
                                                 SecondOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
                                         } else {
                                                 *out << Verbose(3) << "WARNING: Detected more than four bonds for atom " << TopOrigin->Name;
+                                        }
+                                }
+                        }
                         if (SecondOtherAtom == NULL) {  // then we have an atom with valence four, but only 3 bonds: one to replace and one which is TopBond (third is FirstBond)
                                 SecondBond = TopBond;
                                 SecondOtherAtom = TopReplacement;
+                        }
                         if (FirstOtherAtom != NULL) { // then we just have this double bond and the plane does not matter at all
 //                              *out << Verbose(3) << "Regarding the double bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") to be constructed: Taking " << FirstOtherAtom->Name << " and " << SecondOtherAtom->Name << " along with " << TopOrigin->Name << " to determine orthogonal plane." << endl;
                                 // determine the plane of these two with the *origin
                                 AllWentWell = AllWentWell && Orthovector1.MakeNormalVector(&TopOrigin->x, &FirstOtherAtom->x, &SecondOtherAtom->x);
                         } else {
                                 Orthovector1.GetOneNormalVector(&InBondvector);
+                        }
                         //*out << Verbose(3)<< "Orthovector1: ";
                         //Orthovector1.Output(out);
                         //*out << endl;
                         // orthogonal vector and bond vector between origin and replacement form the new plane
                         Orthovector1.MakeNormalVector(&InBondvector);
                         Orthovector1.Normalize();
                         //*out << Verbose(3) << "ReScaleCheck: " << Orthovector1.Norm() << " and " << InBondvector.Norm() << "." << endl;
                         // create the two Hydrogens ...
                         FirstOtherAtom = new atom();
                         SecondOtherAtom = new atom();
                         FirstOtherAtom->type = elemente->FindElement(1);
                         SecondOtherAtom->type = elemente->FindElement(1);
                         FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
                         SecondOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         SecondOtherAtom->FixedIon = TopReplacement->FixedIon;
                         FirstOtherAtom->father = NULL;  // we are just an added hydrogen with no father
                         SecondOtherAtom->father = NULL; //      we are just an added hydrogen with no father
                         bondangle = TopOrigin->type->HBondAngle[1];
                         if (bondangle == -1) {
                                 *out << Verbose(3) << "ERROR: There is no typical hydrogen bond angle in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
                                 return false;
                                 bondangle = 0;
+                        }
                         bondangle *= M_PI/180./2.;
 //                      *out << Verbose(3) << "ReScaleCheck: InBondvector ";
 //                      InBondvector.Output(out);
 //                      *out << endl;
 //                      *out << Verbose(3) << "ReScaleCheck: Orthovector ";
 //                      Orthovector1.Output(out);
 //                      *out << endl;
 //                      *out << Verbose(3) << "Half the bond angle is " << bondangle << ", sin and cos of it: " << sin(bondangle) << ", " << cos(bondangle) << endl;
                         FirstOtherAtom->x.Zero();
                         SecondOtherAtom->x.Zero();
                         for(int i=NDIM;i--;) { // rotate by half the bond angle in both directions (InBondvector is bondangle = 0 direction)
                                 FirstOtherAtom->x.x[i] = InBondvector.x[i] * cos(bondangle) + Orthovector1.x[i] * (sin(bondangle));
                                 SecondOtherAtom->x.x[i] = InBondvector.x[i] * cos(bondangle) + Orthovector1.x[i] * (-sin(bondangle));
+                        }
                         FirstOtherAtom->x.Scale(&BondRescale);  // rescale by correct BondDistance
                         SecondOtherAtom->x.Scale(&BondRescale);
                         //*out << Verbose(3) << "ReScaleCheck: " << FirstOtherAtom->x.Norm() << " and " << SecondOtherAtom->x.Norm() << "." << endl;
                         for(int i=NDIM;i--;) { // and make relative to origin atom
                                 FirstOtherAtom->x.x[i] += TopOrigin->x.x[i];
                                 SecondOtherAtom->x.x[i] += TopOrigin->x.x[i];
+                        }
                         // ... and add to molecule
                         AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
                         AllWentWell = AllWentWell && AddAtom(SecondOtherAtom);
 //                      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
 //                      FirstOtherAtom->x.Output(out);
 //                      *out << endl;
 //                      *out << Verbose(4) << "Added " << *SecondOtherAtom << " at: ";
 //                      SecondOtherAtom->x.Output(out);
 //                      *out << endl;
                         Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         Binder = AddBond(BottomOrigin, SecondOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         break;
                 case 3:
                         // take the "usual" tetraoidal angle and add the three Hydrogen in direction of the bond (height of the tetraoid)
                         FirstOtherAtom = new atom();
                         SecondOtherAtom = new atom();
                         ThirdOtherAtom = new atom();
                         FirstOtherAtom->type = elemente->FindElement(1);
                         SecondOtherAtom->type = elemente->FindElement(1);
                         ThirdOtherAtom->type = elemente->FindElement(1);
                         FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
                         SecondOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         SecondOtherAtom->FixedIon = TopReplacement->FixedIon;
                         ThirdOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
                         ThirdOtherAtom->FixedIon = TopReplacement->FixedIon;
                         FirstOtherAtom->father = NULL;  //      we are just an added hydrogen with no father
                         SecondOtherAtom->father = NULL; //      we are just an added hydrogen with no father
                         ThirdOtherAtom->father = NULL;  //      we are just an added hydrogen with no father
                         // we need to vectors orthonormal the InBondvector
                         AllWentWell = AllWentWell && Orthovector1.GetOneNormalVector(&InBondvector);
 //                      *out << Verbose(3) << "Orthovector1: ";
 //                      Orthovector1.Output(out);
 //                      *out << endl;
                         AllWentWell = AllWentWell && Orthovector2.MakeNormalVector(&InBondvector, &Orthovector1);
 //                      *out << Verbose(3) << "Orthovector2: ";
 //                      Orthovector2.Output(out);
 //                      *out << endl;
                         // create correct coordination for the three atoms
                         alpha = (TopOrigin->type->HBondAngle[2])/180.*M_PI/2.;  // retrieve triple bond angle from database
                         l = BondRescale;                                // desired bond length
                         b = 2.*l*sin(alpha);            // base length of isosceles triangle
                         d = l*sqrt(cos(alpha)*cos(alpha) - sin(alpha)*sin(alpha)/3.);    // length for InBondvector
                         f = b/sqrt(3.);  // length for Orthvector1
                         g = b/2.;                                // length for Orthvector2
 //                      *out << Verbose(3) << "Bond length and half-angle: " << l << ", " << alpha << "\t (b,d,f,g) = " << b << ", " << d << ", " << f << ", " << g << ", " << endl;
 //                      *out << Verbose(3) << "The three Bond lengths: " << sqrt(d*d+f*f) << ", " << sqrt(d*d+(-0.5*f)*(-0.5*f)+g*g) << ", "    << sqrt(d*d+(-0.5*f)*(-0.5*f)+g*g) << endl;
                         factors[0] = d;
                         factors[1] = f;
                         factors[2] = 0.;
                         FirstOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
                         factors[1] = -0.5*f;
                         factors[2] = g;
                         SecondOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
                         factors[2] = -g;
                         ThirdOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
                         // rescale each to correct BondDistance
 //                      FirstOtherAtom->x.Scale(&BondRescale);
 //                      SecondOtherAtom->x.Scale(&BondRescale);
 //                      ThirdOtherAtom->x.Scale(&BondRescale);
                         // and relative to *origin atom
                         FirstOtherAtom->x.AddVector(&TopOrigin->x);
                         SecondOtherAtom->x.AddVector(&TopOrigin->x);
                         ThirdOtherAtom->x.AddVector(&TopOrigin->x);
                         // ... and add to molecule
                         AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
                         AllWentWell = AllWentWell && AddAtom(SecondOtherAtom);
                         AllWentWell = AllWentWell && AddAtom(ThirdOtherAtom);
 //                      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
 //                      FirstOtherAtom->x.Output(out);
 //                      *out << endl;
 //                      *out << Verbose(4) << "Added " << *SecondOtherAtom << " at: ";
 //                      SecondOtherAtom->x.Output(out);
 //                      *out << endl;
 //                      *out << Verbose(4) << "Added " << *ThirdOtherAtom << " at: ";
 //                      ThirdOtherAtom->x.Output(out);
 //                      *out << endl;
                         Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         Binder = AddBond(BottomOrigin, SecondOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         Binder = AddBond(BottomOrigin, ThirdOtherAtom, 1);
                         Binder->Cyclic = false;
                         Binder->Type = TreeEdge;
                         break;
                 default:
                         cerr << "ERROR: BondDegree does not state single, double or triple bond!" << endl;
                         AllWentWell = false;
                         break;
+        }
 //      *out << Verbose(3) << "End of AddHydrogenReplacementAtom." << endl;
         return AllWentWell;
+  double bondlength;  // bond length of the bond to be replaced/cut
+  double bondangle;  // bond angle of the bond to be replaced/cut
+  double BondRescale;   // rescale value for the hydrogen bond length
+  bool AllWentWell = true;    // flag gathering the boolean return value of molecule::AddAtom and other functions, as return value on exit
+  bond *FirstBond = NULL, *SecondBond = NULL; // Other bonds in double bond case to determine "other" plane
+  atom *FirstOtherAtom = NULL, *SecondOtherAtom = NULL, *ThirdOtherAtom = NULL; // pointer to hydrogen atoms to be added
+  double b,l,d,f,g, alpha, factors[NDIM];    // hold temporary values in triple bond case for coordination determination
+  Vector Orthovector1, Orthovector2;  // temporary vectors in coordination construction
+  Vector InBondvector;    // vector in direction of *Bond
+  bond *Binder = NULL;
+  double *matrix;
+//  *out << Verbose(3) << "Begin of AddHydrogenReplacementAtom." << endl;
+  // create vector in direction of bond
+  InBondvector.CopyVector(&TopReplacement->x);
+  InBondvector.SubtractVector(&TopOrigin->x);
+  bondlength = InBondvector.Norm();
+   // is greater than typical bond distance? Then we have to correct periodically
+   // the problem is not the H being out of the box, but InBondvector have the wrong direction
+   // due to TopReplacement or Origin being on the wrong side!
+  if (bondlength > BondDistance) {
+//    *out << Verbose(4) << "InBondvector is: ";
+//    InBondvector.Output(out);
+//    *out << endl;
+    Orthovector1.Zero();
+    for (int i=NDIM;i--;) {
+      l = TopReplacement->x.x[i] - TopOrigin->x.x[i];
+      if (fabs(l) > BondDistance) { // is component greater than bond distance
+        Orthovector1.x[i] = (l < 0) ? -1. : +1.;
+      } // (signs are correct, was tested!)
+    }
+    matrix = ReturnFullMatrixforSymmetric(cell_size);
+    Orthovector1.MatrixMultiplication(matrix);
+    InBondvector.SubtractVector(&Orthovector1); // subtract just the additional translation
+    Free((void **)&matrix, "molecule::AddHydrogenReplacementAtom: *matrix");
+    bondlength = InBondvector.Norm();
+//    *out << Verbose(4) << "Corrected InBondvector is now: ";
+//    InBondvector.Output(out);
+//    *out << endl;
+  } // periodic correction finished
+  InBondvector.Normalize();
+  // get typical bond length and store as scale factor for later
+  BondRescale = TopOrigin->type->HBondDistance[TopBond->BondDegree-1];
+  if (BondRescale == -1) {
+    cerr << Verbose(3) << "ERROR: There is no typical hydrogen bond distance in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
+    return false;
+    BondRescale = bondlength;
+  } else {
+    if (!IsAngstroem)
+      BondRescale /= (1.*AtomicLengthToAngstroem);
+  }
+  // discern single, double and triple bonds
+  switch(TopBond->BondDegree) {
+    case 1:
+      FirstOtherAtom = new atom();    // new atom
+      FirstOtherAtom->type = elemente->FindElement(1);  // element is Hydrogen
+      FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
+      if (TopReplacement->type->Z == 1) { // neither rescale nor replace if it's already hydrogen
+        FirstOtherAtom->father = TopReplacement;
+        BondRescale = bondlength;
+      } else {
+        FirstOtherAtom->father = NULL;  // if we replace hydrogen, we mark it as our father, otherwise we are just an added hydrogen with no father
+      }
+      InBondvector.Scale(&BondRescale);   // rescale the distance vector to Hydrogen bond length
+      FirstOtherAtom->x.CopyVector(&TopOrigin->x); // set coordination to origin ...
+      FirstOtherAtom->x.AddVector(&InBondvector);  // ... and add distance vector to replacement atom
+      AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
+//      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
+//      FirstOtherAtom->x.Output(out);
+//      *out << endl;
+      Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      break;
+    case 2:
+      // determine two other bonds (warning if there are more than two other) plus valence sanity check
+      for (int i=0;i<NumBond;i++) {
+        if (BondList[i] != TopBond) {
+          if (FirstBond == NULL) {
+            FirstBond = BondList[i];
+            FirstOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
+          } else if (SecondBond == NULL) {
+            SecondBond = BondList[i];
+            SecondOtherAtom = BondList[i]->GetOtherAtom(TopOrigin);
+          } else {
+            *out << Verbose(3) << "WARNING: Detected more than four bonds for atom " << TopOrigin->Name;
+          }
+        }
+      }
+      if (SecondOtherAtom == NULL) {  // then we have an atom with valence four, but only 3 bonds: one to replace and one which is TopBond (third is FirstBond)
+        SecondBond = TopBond;
+        SecondOtherAtom = TopReplacement;
+      }
+      if (FirstOtherAtom != NULL) { // then we just have this double bond and the plane does not matter at all
+//        *out << Verbose(3) << "Regarding the double bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") to be constructed: Taking " << FirstOtherAtom->Name << " and " << SecondOtherAtom->Name << " along with " << TopOrigin->Name << " to determine orthogonal plane." << endl;
+        // determine the plane of these two with the *origin
+        AllWentWell = AllWentWell && Orthovector1.MakeNormalVector(&TopOrigin->x, &FirstOtherAtom->x, &SecondOtherAtom->x);
+      } else {
+        Orthovector1.GetOneNormalVector(&InBondvector);
+      }
+      //*out << Verbose(3)<< "Orthovector1: ";
+      //Orthovector1.Output(out);
+      //*out << endl;
+      // orthogonal vector and bond vector between origin and replacement form the new plane
+      Orthovector1.MakeNormalVector(&InBondvector);
+      Orthovector1.Normalize();
+      //*out << Verbose(3) << "ReScaleCheck: " << Orthovector1.Norm() << " and " << InBondvector.Norm() << "." << endl;
+      // create the two Hydrogens ...
+      FirstOtherAtom = new atom();
+      SecondOtherAtom = new atom();
+      FirstOtherAtom->type = elemente->FindElement(1);
+      SecondOtherAtom->type = elemente->FindElement(1);
+      FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
+      SecondOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      SecondOtherAtom->FixedIon = TopReplacement->FixedIon;
+      FirstOtherAtom->father = NULL;  // we are just an added hydrogen with no father
+      SecondOtherAtom->father = NULL;  //  we are just an added hydrogen with no father
+      bondangle = TopOrigin->type->HBondAngle[1];
+      if (bondangle == -1) {
+        *out << Verbose(3) << "ERROR: There is no typical hydrogen bond angle in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
+        return false;
+        bondangle = 0;
+      }
+      bondangle *= M_PI/180./2.;
+//      *out << Verbose(3) << "ReScaleCheck: InBondvector ";
+//      InBondvector.Output(out);
+//      *out << endl;
+//      *out << Verbose(3) << "ReScaleCheck: Orthovector ";
+//      Orthovector1.Output(out);
+//      *out << endl;
+//      *out << Verbose(3) << "Half the bond angle is " << bondangle << ", sin and cos of it: " << sin(bondangle) << ", " << cos(bondangle) << endl;
+      FirstOtherAtom->x.Zero();
+      SecondOtherAtom->x.Zero();
+      for(int i=NDIM;i--;) { // rotate by half the bond angle in both directions (InBondvector is bondangle = 0 direction)
+        FirstOtherAtom->x.x[i] = InBondvector.x[i] * cos(bondangle) + Orthovector1.x[i] * (sin(bondangle));
+        SecondOtherAtom->x.x[i] = InBondvector.x[i] * cos(bondangle) + Orthovector1.x[i] * (-sin(bondangle));
+      }
+      FirstOtherAtom->x.Scale(&BondRescale);  // rescale by correct BondDistance
+      SecondOtherAtom->x.Scale(&BondRescale);
+      //*out << Verbose(3) << "ReScaleCheck: " << FirstOtherAtom->x.Norm() << " and " << SecondOtherAtom->x.Norm() << "." << endl;
+      for(int i=NDIM;i--;) { // and make relative to origin atom
+        FirstOtherAtom->x.x[i] += TopOrigin->x.x[i];
+        SecondOtherAtom->x.x[i] += TopOrigin->x.x[i];
+      }
+      // ... and add to molecule
+      AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
+      AllWentWell = AllWentWell && AddAtom(SecondOtherAtom);
+//      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
+//      FirstOtherAtom->x.Output(out);
+//      *out << endl;
+//      *out << Verbose(4) << "Added " << *SecondOtherAtom << " at: ";
+//      SecondOtherAtom->x.Output(out);
+//      *out << endl;
+      Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      Binder = AddBond(BottomOrigin, SecondOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      break;
+    case 3:
+      // take the "usual" tetraoidal angle and add the three Hydrogen in direction of the bond (height of the tetraoid)
+      FirstOtherAtom = new atom();
+      SecondOtherAtom = new atom();
+      ThirdOtherAtom = new atom();
+      FirstOtherAtom->type = elemente->FindElement(1);
+      SecondOtherAtom->type = elemente->FindElement(1);
+      ThirdOtherAtom->type = elemente->FindElement(1);
+      FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
+      SecondOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      SecondOtherAtom->FixedIon = TopReplacement->FixedIon;
+      ThirdOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
+      ThirdOtherAtom->FixedIon = TopReplacement->FixedIon;
+      FirstOtherAtom->father = NULL;  //  we are just an added hydrogen with no father
+      SecondOtherAtom->father = NULL;  //  we are just an added hydrogen with no father
+      ThirdOtherAtom->father = NULL;  //  we are just an added hydrogen with no father
+      // we need to vectors orthonormal the InBondvector
+      AllWentWell = AllWentWell && Orthovector1.GetOneNormalVector(&InBondvector);
+//      *out << Verbose(3) << "Orthovector1: ";
+//      Orthovector1.Output(out);
+//      *out << endl;
+      AllWentWell = AllWentWell && Orthovector2.MakeNormalVector(&InBondvector, &Orthovector1);
+//      *out << Verbose(3) << "Orthovector2: ";
+//      Orthovector2.Output(out);
+//      *out << endl;
+      // create correct coordination for the three atoms
+      alpha = (TopOrigin->type->HBondAngle[2])/180.*M_PI/2.;  // retrieve triple bond angle from database
+      l = BondRescale;        // desired bond length
+      b = 2.*l*sin(alpha);    // base length of isosceles triangle
+      d = l*sqrt(cos(alpha)*cos(alpha) - sin(alpha)*sin(alpha)/3.);   // length for InBondvector
+      f = b/sqrt(3.);   // length for Orthvector1
+      g = b/2.;         // length for Orthvector2
+//      *out << Verbose(3) << "Bond length and half-angle: " << l << ", " << alpha << "\t (b,d,f,g) = " << b << ", " << d << ", " << f << ", " << g << ", " << endl;
+//      *out << Verbose(3) << "The three Bond lengths: " << sqrt(d*d+f*f) << ", " << sqrt(d*d+(-0.5*f)*(-0.5*f)+g*g) << ", "  << sqrt(d*d+(-0.5*f)*(-0.5*f)+g*g) << endl;
+      factors[0] = d;
+      factors[1] = f;
+      factors[2] = 0.;
+      FirstOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
+      factors[1] = -0.5*f;
+      factors[2] = g;
+      SecondOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
+      factors[2] = -g;
+      ThirdOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
+      // rescale each to correct BondDistance
+//      FirstOtherAtom->x.Scale(&BondRescale);
+//      SecondOtherAtom->x.Scale(&BondRescale);
+//      ThirdOtherAtom->x.Scale(&BondRescale);
+      // and relative to *origin atom
+      FirstOtherAtom->x.AddVector(&TopOrigin->x);
+      SecondOtherAtom->x.AddVector(&TopOrigin->x);
+      ThirdOtherAtom->x.AddVector(&TopOrigin->x);
+      // ... and add to molecule
+      AllWentWell = AllWentWell && AddAtom(FirstOtherAtom);
+      AllWentWell = AllWentWell && AddAtom(SecondOtherAtom);
+      AllWentWell = AllWentWell && AddAtom(ThirdOtherAtom);
+//      *out << Verbose(4) << "Added " << *FirstOtherAtom << " at: ";
+//      FirstOtherAtom->x.Output(out);
+//      *out << endl;
+//      *out << Verbose(4) << "Added " << *SecondOtherAtom << " at: ";
+//      SecondOtherAtom->x.Output(out);
+//      *out << endl;
+//      *out << Verbose(4) << "Added " << *ThirdOtherAtom << " at: ";
+//      ThirdOtherAtom->x.Output(out);
+//      *out << endl;
+      Binder = AddBond(BottomOrigin, FirstOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      Binder = AddBond(BottomOrigin, SecondOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      Binder = AddBond(BottomOrigin, ThirdOtherAtom, 1);
+      Binder->Cyclic = false;
+      Binder->Type = TreeEdge;
+      break;
+    default:
+      cerr << "ERROR: BondDegree does not state single, double or triple bond!" << endl;
+      AllWentWell = false;
+      break;
+  }
+//  *out << Verbose(3) << "End of AddHydrogenReplacementAtom." << endl;
+  return AllWentWell;
 };
 …
 bool molecule::AddXYZFile(string filename)
+{
         istringstream *input = NULL;
         int NumberOfAtoms = 0; // atom number in xyz read
         int i, j; // loop variables
         atom *Walker = NULL;    // pointer to added atom
         char shorthand[3];      // shorthand for atom name
         ifstream xyzfile;        // xyz file
         string line;            // currently parsed line
         double x[3];            // atom coordinates
         xyzfile.open(filename.c_str());
         if (!xyzfile)
                 return false;
         getline(xyzfile,line,'\n'); // Read numer of atoms in file
         input = new istringstream(line);
         *input >> NumberOfAtoms;
         cout << Verbose(0) << "Parsing " << NumberOfAtoms << " atoms in file." << endl;
         getline(xyzfile,line,'\n'); // Read comment
         cout << Verbose(1) << "Comment: " << line << endl;
         if (MDSteps == 0) // no atoms yet present
                 MDSteps++;
         for(i=0;i<NumberOfAtoms;i++){
                 Walker = new atom;
                 getline(xyzfile,line,'\n');
                 istringstream *item = new istringstream(line);
                 //istringstream input(line);
                 //cout << Verbose(1) << "Reading: " << line << endl;
                 *item >> shorthand;
                 *item >> x[0];
                 *item >> x[1];
                 *item >> x[2];
                 Walker->type = elemente->FindElement(shorthand);
                 if (Walker->type == NULL) {
                         cerr << "Could not parse the element at line: '" << line << "', setting to H.";
                         Walker->type = elemente->FindElement(1);
+                }
                 if (Trajectories[Walker].R.size() <= (unsigned int)MDSteps) {
                         Trajectories[Walker].R.resize(MDSteps+10);
                         Trajectories[Walker].U.resize(MDSteps+10);
                         Trajectories[Walker].F.resize(MDSteps+10);
+                }
                 for(j=NDIM;j--;) {
                         Walker->x.x[j] = x[j];
                         Trajectories[Walker].R.at(MDSteps-1).x[j] = x[j];
                         Trajectories[Walker].U.at(MDSteps-1).x[j] = 0;
                         Trajectories[Walker].F.at(MDSteps-1).x[j] = 0;
+                }
                 AddAtom(Walker);        // add to molecule
                 delete(item);
+        }
         xyzfile.close();
         delete(input);
         return true;
+  istringstream *input = NULL;
+  int NumberOfAtoms = 0; // atom number in xyz read
+  int i, j; // loop variables
+  atom *Walker = NULL;  // pointer to added atom
+  char shorthand[3];  // shorthand for atom name
+  ifstream xyzfile;   // xyz file
+  string line;    // currently parsed line
+  double x[3];    // atom coordinates
+  xyzfile.open(filename.c_str());
+  if (!xyzfile)
+    return false;
+  getline(xyzfile,line,'\n'); // Read numer of atoms in file
+  input = new istringstream(line);
+  *input >> NumberOfAtoms;
+  cout << Verbose(0) << "Parsing " << NumberOfAtoms << " atoms in file." << endl;
+  getline(xyzfile,line,'\n'); // Read comment
+  cout << Verbose(1) << "Comment: " << line << endl;
+  if (MDSteps == 0) // no atoms yet present
+    MDSteps++;
+  for(i=0;i<NumberOfAtoms;i++){
+    Walker = new atom;
+    getline(xyzfile,line,'\n');
+    istringstream *item = new istringstream(line);
+    //istringstream input(line);
+    //cout << Verbose(1) << "Reading: " << line << endl;
+    *item >> shorthand;
+    *item >> x[0];
+    *item >> x[1];
+    *item >> x[2];
+    Walker->type = elemente->FindElement(shorthand);
+    if (Walker->type == NULL) {
+      cerr << "Could not parse the element at line: '" << line << "', setting to H.";
+      Walker->type = elemente->FindElement(1);
+    }
+    if (Trajectories[Walker].R.size() <= (unsigned int)MDSteps) {
+      Trajectories[Walker].R.resize(MDSteps+10);
+      Trajectories[Walker].U.resize(MDSteps+10);
+      Trajectories[Walker].F.resize(MDSteps+10);
+    }
+    for(j=NDIM;j--;) {
+      Walker->x.x[j] = x[j];
+      Trajectories[Walker].R.at(MDSteps-1).x[j] = x[j];
+      Trajectories[Walker].U.at(MDSteps-1).x[j] = 0;
+      Trajectories[Walker].F.at(MDSteps-1).x[j] = 0;
+    }
+    AddAtom(Walker);  // add to molecule
+    delete(item);
+  }
+  xyzfile.close();
+  delete(input);
+  return true;
 };
 …
 molecule *molecule::CopyMolecule()
+{
         molecule *copy = new molecule(elemente);
         atom *CurrentAtom = NULL;
         atom *LeftAtom = NULL, *RightAtom = NULL;
         atom *Walker = NULL;
         // copy all atoms
         Walker = start;
         while(Walker->next != end) {
                 Walker = Walker->next;
                 CurrentAtom = copy->AddCopyAtom(Walker);
+        }
         // copy all bonds
         bond *Binder = first;
         bond *NewBond = NULL;
         while(Binder->next != last) {
                 Binder = Binder->next;
                 // get the pendant atoms of current bond in the copy molecule
                 LeftAtom = copy->start;
                 while (LeftAtom->next != copy->end) {
                         LeftAtom = LeftAtom->next;
                         if (LeftAtom->father == Binder->leftatom)
                                 break;
+                }
                 RightAtom = copy->start;
                 while (RightAtom->next != copy->end) {
                         RightAtom = RightAtom->next;
                         if (RightAtom->father == Binder->rightatom)
                                 break;
+                }
                 NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
                 NewBond->Cyclic = Binder->Cyclic;
                 if (Binder->Cyclic)
                         copy->NoCyclicBonds++;
                 NewBond->Type = Binder->Type;
+        }
         // correct fathers
         Walker = copy->start;
         while(Walker->next != copy->end) {
                 Walker = Walker->next;
                 if (Walker->father->father == Walker->father)    // same atom in copy's father points to itself
                         Walker->father = Walker;        // set father to itself (copy of a whole molecule)
                 else
                  Walker->father = Walker->father->father;       // set father to original's father
+        }
         // copy values
         copy->CountAtoms((ofstream *)&cout);
         copy->CountElements();
         if (first->next != last) {      // if adjaceny list is present
                 copy->BondDistance = BondDistance;
                 copy->CreateListOfBondsPerAtom((ofstream *)&cout);
+        }
         return copy;
+  molecule *copy = new molecule(elemente);
+  atom *CurrentAtom = NULL;
+  atom *LeftAtom = NULL, *RightAtom = NULL;
+  atom *Walker = NULL;
+  // copy all atoms
+  Walker = start;
+  while(Walker->next != end) {
+    Walker = Walker->next;
+    CurrentAtom = copy->AddCopyAtom(Walker);
+  }
+  // copy all bonds
+  bond *Binder = first;
+  bond *NewBond = NULL;
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    // get the pendant atoms of current bond in the copy molecule
+    LeftAtom = copy->start;
+    while (LeftAtom->next != copy->end) {
+      LeftAtom = LeftAtom->next;
+      if (LeftAtom->father == Binder->leftatom)
+        break;
+    }
+    RightAtom = copy->start;
+    while (RightAtom->next != copy->end) {
+      RightAtom = RightAtom->next;
+      if (RightAtom->father == Binder->rightatom)
+        break;
+    }
+    NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
+    NewBond->Cyclic = Binder->Cyclic;
+    if (Binder->Cyclic)
+      copy->NoCyclicBonds++;
+    NewBond->Type = Binder->Type;
+  }
+  // correct fathers
+  Walker = copy->start;
+  while(Walker->next != copy->end) {
+    Walker = Walker->next;
+    if (Walker->father->father == Walker->father)   // same atom in copy's father points to itself
+      Walker->father = Walker;  // set father to itself (copy of a whole molecule)
+    else
+     Walker->father = Walker->father->father;  // set father to original's father
+  }
+  // copy values
+  copy->CountAtoms((ofstream *)&cout);
+  copy->CountElements();
+  if (first->next != last) {  // if adjaceny list is present
+    copy->BondDistance = BondDistance;
+    copy->CreateListOfBondsPerAtom((ofstream *)&cout);
+  }
+  return copy;
 };
 …
 bond * molecule::AddBond(atom *atom1, atom *atom2, int degree=1)
+{
         bond *Binder = NULL;
         if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
                 Binder = new bond(atom1, atom2, degree, BondCount++);
                 if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
                         NoNonBonds++;
                 add(Binder, last);
         } else {
                 cerr << Verbose(1) << "ERROR: Could not add bond between " << atom1->Name << " and " << atom2->Name << " as one or both are not present in the molecule." << endl;
+        }
         return Binder;
+  bond *Binder = NULL;
+  if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
+    Binder = new bond(atom1, atom2, degree, BondCount++);
+    if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
+      NoNonBonds++;
+    add(Binder, last);
+  } else {
+    cerr << Verbose(1) << "ERROR: Could not add bond between " << atom1->Name << " and " << atom2->Name << " as one or both are not present in the molecule." << endl;
+  }
+  return Binder;
 };
 …
 bool molecule::RemoveBond(bond *pointer)
+{
         //cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
         removewithoutcheck(pointer);
         return true;
+  //cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
+  removewithoutcheck(pointer);
+  return true;
 };
 …
 bool molecule::RemoveBonds(atom *BondPartner)
+{
         cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
         return false;
+  cerr << Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl;
+  return false;
 };
 …
 void molecule::SetBoxDimension(Vector *dim)
+{
         cell_size[0] = dim->x[0];
         cell_size[1] = 0.;
         cell_size[2] = dim->x[1];
         cell_size[3] = 0.;
         cell_size[4] = 0.;
         cell_size[5] = dim->x[2];
+  cell_size[0] = dim->x[0];
+  cell_size[1] = 0.;
+  cell_size[2] = dim->x[1];
+  cell_size[3] = 0.;
+  cell_size[4] = 0.;
+  cell_size[5] = dim->x[2];
 };
 …
 bool molecule::CenterInBox(ofstream *out, Vector *BoxLengths)
+{
         bool status = true;
         atom *ptr = NULL;
         Vector *min = new Vector;
         Vector *max = new Vector;
         // gather min and max for each axis
         ptr = start->next;      // start at first in list
         if (ptr != end) {        //list not empty?
                 for (int i=NDIM;i--;) {
                         max->x[i] = ptr->x.x[i];
                         min->x[i] = ptr->x.x[i];
+                }
                 while (ptr->next != end) {      // continue with second if present
                         ptr = ptr->next;
                         //ptr->Output(1,1,out);
                         for (int i=NDIM;i--;) {
                                 max->x[i] = (max->x[i] < ptr->x.x[i]) ? ptr->x.x[i] : max->x[i];
                                 min->x[i] = (min->x[i] > ptr->x.x[i]) ? ptr->x.x[i] : min->x[i];
+                        }
+                }
+        }
         // sanity check
         for(int i=NDIM;i--;) {
                 if (max->x[i] - min->x[i] > BoxLengths->x[i])
                         status = false;
+        }
         // warn if check failed
         if (!status)
                 *out << "WARNING: molecule is bigger than defined box!" << endl;
         else {  // else center in box
                 max->AddVector(min);
                 max->Scale(-1.);
                 max->AddVector(BoxLengths);
                 max->Scale(0.5);
+  bool status = true;
+  atom *ptr = NULL;
+  Vector *min = new Vector;
+  Vector *max = new Vector;
+  // gather min and max for each axis
+  ptr = start->next;  // start at first in list
+  if (ptr != end) {   //list not empty?
+    for (int i=NDIM;i--;) {
+      max->x[i] = ptr->x.x[i];
+      min->x[i] = ptr->x.x[i];
+    }
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      //ptr->Output(1,1,out);
+      for (int i=NDIM;i--;) {
+        max->x[i] = (max->x[i] < ptr->x.x[i]) ? ptr->x.x[i] : max->x[i];
+        min->x[i] = (min->x[i] > ptr->x.x[i]) ? ptr->x.x[i] : min->x[i];
+      }
+    }
+  }
+  // sanity check
+  for(int i=NDIM;i--;) {
+    if (max->x[i] - min->x[i] > BoxLengths->x[i])
+      status = false;
+  }
+  // warn if check failed
+  if (!status)
+    *out << "WARNING: molecule is bigger than defined box!" << endl;
+  else {  // else center in box
+    max->AddVector(min);
+    max->Scale(-1.);
+    max->AddVector(BoxLengths);
+    max->Scale(0.5);
     Translate(max);
     Center.Zero();
+        }
         // free and exit
         delete(min);
         delete(max);
         return status;
+  }
+  // free and exit
+  delete(min);
+  delete(max);
+  return status;
 };
 …
 void molecule::CenterEdge(ofstream *out, Vector *max)
+{
         Vector *min = new Vector;
 //      *out << Verbose(3) << "Begin of CenterEdge." << endl;
         atom *ptr = start->next;        // start at first in list
         if (ptr != end) {        //list not empty?
                 for (int i=NDIM;i--;) {
                         max->x[i] = ptr->x.x[i];
                         min->x[i] = ptr->x.x[i];
+                }
                 while (ptr->next != end) {      // continue with second if present
                         ptr = ptr->next;
                         //ptr->Output(1,1,out);
                         for (int i=NDIM;i--;) {
                                 max->x[i] = (max->x[i] < ptr->x.x[i]) ? ptr->x.x[i] : max->x[i];
                                 min->x[i] = (min->x[i] > ptr->x.x[i]) ? ptr->x.x[i] : min->x[i];
+                        }
+                }
 //              *out << Verbose(4) << "Maximum is ";
 //              max->Output(out);
 //              *out << ", Minimum is ";
 //              min->Output(out);
 //              *out << endl;
                 min->Scale(-1.);
                 max->AddVector(min);
                 Translate(min);
                 Center.Zero();
+        }
         delete(min);
 //      *out << Verbose(3) << "End of CenterEdge." << endl;
+  Vector *min = new Vector;
+//  *out << Verbose(3) << "Begin of CenterEdge." << endl;
+  atom *ptr = start->next;  // start at first in list
+  if (ptr != end) {   //list not empty?
+    for (int i=NDIM;i--;) {
+      max->x[i] = ptr->x.x[i];
+      min->x[i] = ptr->x.x[i];
+    }
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      //ptr->Output(1,1,out);
+      for (int i=NDIM;i--;) {
+        max->x[i] = (max->x[i] < ptr->x.x[i]) ? ptr->x.x[i] : max->x[i];
+        min->x[i] = (min->x[i] > ptr->x.x[i]) ? ptr->x.x[i] : min->x[i];
+      }
+    }
+//    *out << Verbose(4) << "Maximum is ";
+//    max->Output(out);
+//    *out << ", Minimum is ";
+//    min->Output(out);
+//    *out << endl;
+    min->Scale(-1.);
+    max->AddVector(min);
+    Translate(min);
+    Center.Zero();
+  }
+  delete(min);
+//  *out << Verbose(3) << "End of CenterEdge." << endl;
 };
 …
 void molecule::CenterOrigin(ofstream *out)
+{
         int Num = 0;
         atom *ptr = start->next;        // start at first in list
         Center.Zero();
         if (ptr != end) {        //list not empty?
                 while (ptr->next != end) {      // continue with second if present
                         ptr = ptr->next;
                         Num++;
                         Center.AddVector(&ptr->x);
+                }
                 Center.Scale(-1./Num); // divide through total number (and sign for direction)
           Translate(&Center);
           Center.Zero();
+        }
+  int Num = 0;
+  atom *ptr = start->next;  // start at first in list
+  Center.Zero();
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      Num++;
+      Center.AddVector(&ptr->x);
+    }
+    Center.Scale(-1./Num); // divide through total number (and sign for direction)
+    Translate(&Center);
+    Center.Zero();
+  }
 };
 …
 Vector * molecule::DetermineCenterOfAll(ofstream *out)
+{
         atom *ptr = start->next;        // start at first in list
         Vector *a = new Vector();
         Vector tmp;
         double Num = 0;
         a->Zero();
         if (ptr != end) {        //list not empty?
                 while (ptr->next != end) {      // continue with second if present
                         ptr = ptr->next;
                         Num += 1.;
                         tmp.CopyVector(&ptr->x);
                         a->AddVector(&tmp);
+                }
                 a->Scale(-1./Num); // divide through total mass (and sign for direction)
+        }
         //cout << Verbose(1) << "Resulting center of gravity: ";
         //a->Output(out);
         //cout << endl;
         return a;
+  atom *ptr = start->next;  // start at first in list
+  Vector *a = new Vector();
+  Vector tmp;
+  double Num = 0;
+  a->Zero();
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      Num += 1.;
+      tmp.CopyVector(&ptr->x);
+      a->AddVector(&tmp);
+    }
+    a->Scale(-1./Num); // divide through total mass (and sign for direction)
+  }
+  //cout << Verbose(1) << "Resulting center of gravity: ";
+  //a->Output(out);
+  //cout << endl;
+  return a;
 };
 …
 Vector * molecule::DetermineCenterOfGravity(ofstream *out)
+{
         atom *ptr = start->next;        // start at first in list
         Vector *a = new Vector();
         Vector tmp;
         double Num = 0;
         a->Zero();
         if (ptr != end) {        //list not empty?
                 while (ptr->next != end) {      // continue with second if present
                         ptr = ptr->next;
                         Num += ptr->type->mass;
                         tmp.CopyVector(&ptr->x);
                         tmp.Scale(ptr->type->mass);     // scale by mass
                         a->AddVector(&tmp);
+                }
                 a->Scale(-1./Num); // divide through total mass (and sign for direction)
+        }
 //      *out << Verbose(1) << "Resulting center of gravity: ";
 //      a->Output(out);
 //      *out << endl;
         return a;
+  atom *ptr = start->next;  // start at first in list
+  Vector *a = new Vector();
+  Vector tmp;
+  double Num = 0;
+  a->Zero();
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      Num += ptr->type->mass;
+      tmp.CopyVector(&ptr->x);
+      tmp.Scale(ptr->type->mass);  // scale by mass
+      a->AddVector(&tmp);
+    }
+    a->Scale(-1./Num); // divide through total mass (and sign for direction)
+  }
+//  *out << Verbose(1) << "Resulting center of gravity: ";
+//  a->Output(out);
+//  *out << endl;
+  return a;
 };
 …
 void molecule::CenterPeriodic(ofstream *out)
+{
         DeterminePeriodicCenter(Center);
+  DeterminePeriodicCenter(Center);
 };
 …
 void molecule::Scale(double **factor)
+{
         atom *ptr = start;
         while (ptr->next != end) {
                 ptr = ptr->next;
                 for (int j=0;j<MDSteps;j++)
                         Trajectories[ptr].R.at(j).Scale(factor);
                 ptr->x.Scale(factor);
+        }
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    for (int j=0;j<MDSteps;j++)
+      Trajectories[ptr].R.at(j).Scale(factor);
+    ptr->x.Scale(factor);
+  }
 };
 …
 void molecule::Translate(const Vector *trans)
+{
         atom *ptr = start;
         while (ptr->next != end) {
                 ptr = ptr->next;
                 for (int j=0;j<MDSteps;j++)
                         Trajectories[ptr].R.at(j).Translate(trans);
                 ptr->x.Translate(trans);
+        }
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    for (int j=0;j<MDSteps;j++)
+      Trajectories[ptr].R.at(j).Translate(trans);
+    ptr->x.Translate(trans);
+  }
 };
 …
 void molecule::Mirror(const Vector *n)
+{
         atom *ptr = start;
         while (ptr->next != end) {
                 ptr = ptr->next;
                 for (int j=0;j<MDSteps;j++)
                         Trajectories[ptr].R.at(j).Mirror(n);
                 ptr->x.Mirror(n);
+        }
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    for (int j=0;j<MDSteps;j++)
+      Trajectories[ptr].R.at(j).Mirror(n);
+    ptr->x.Mirror(n);
+  }
 };
 …
 void molecule::DeterminePeriodicCenter(Vector &center)
+{
         atom *Walker = start;
         bond *Binder = NULL;
         double *matrix = ReturnFullMatrixforSymmetric(cell_size);
         double tmp;
         bool flag;
         Vector Testvector, Translationvector;
         do {
                 center.Zero();
                 flag = true;
                 while (Walker->next != end) {
                         Walker = Walker->next;
+  atom *Walker = start;
+  bond *Binder = NULL;
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  double tmp;
+  bool flag;
+  Vector Testvector, Translationvector;
+  do {
+    center.Zero();
+    flag = true;
+    while (Walker->next != end) {
+      Walker = Walker->next;
 #ifdef ADDHYDROGEN
                         if (Walker->type->Z != 1) {
+      if (Walker->type->Z != 1) {
 #endif
                                 Testvector.CopyVector(&Walker->x);
                                 Testvector.InverseMatrixMultiplication(matrix);
                                 Translationvector.Zero();
                                 for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
                                         Binder = ListOfBondsPerAtom[Walker->nr][i];
                                         if (Walker->nr < Binder->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
                                                 for (int j=0;j<NDIM;j++) {
                                                         tmp = Walker->x.x[j] - Binder->GetOtherAtom(Walker)->x.x[j];
                                                         if ((fabs(tmp)) > BondDistance) {
                                                                 flag = false;
                                                                 cout << Verbose(0) << "Hit: atom " << Walker->Name << " in bond " << *Binder << " has to be shifted due to " << tmp << "." << endl;
                                                                 if (tmp > 0)
                                                                         Translationvector.x[j] -= 1.;
                                                                 else
                                                                         Translationvector.x[j] += 1.;
+                                                        }
+                                                }
+                                }
                                 Testvector.AddVector(&Translationvector);
                                 Testvector.MatrixMultiplication(matrix);
                                 center.AddVector(&Testvector);
                                 cout << Verbose(1) << "vector is: ";
                                 Testvector.Output((ofstream *)&cout);
                                 cout << endl;
+        Testvector.CopyVector(&Walker->x);
+        Testvector.InverseMatrixMultiplication(matrix);
+        Translationvector.Zero();
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
+          Binder = ListOfBondsPerAtom[Walker->nr][i];
+          if (Walker->nr < Binder->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
+            for (int j=0;j<NDIM;j++) {
+              tmp = Walker->x.x[j] - Binder->GetOtherAtom(Walker)->x.x[j];
+              if ((fabs(tmp)) > BondDistance) {
+                flag = false;
+                cout << Verbose(0) << "Hit: atom " << Walker->Name << " in bond " << *Binder << " has to be shifted due to " << tmp << "." << endl;
+                if (tmp > 0)
+                  Translationvector.x[j] -= 1.;
+                else
+                  Translationvector.x[j] += 1.;
+              }
+            }
+        }
+        Testvector.AddVector(&Translationvector);
+        Testvector.MatrixMultiplication(matrix);
+        center.AddVector(&Testvector);
+        cout << Verbose(1) << "vector is: ";
+        Testvector.Output((ofstream *)&cout);
+        cout << endl;
 #ifdef ADDHYDROGEN
                                 // now also change all hydrogens
                                 for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
                                         Binder = ListOfBondsPerAtom[Walker->nr][i];
                                         if (Binder->GetOtherAtom(Walker)->type->Z == 1) {
                                                 Testvector.CopyVector(&Binder->GetOtherAtom(Walker)->x);
                                                 Testvector.InverseMatrixMultiplication(matrix);
                                                 Testvector.AddVector(&Translationvector);
                                                 Testvector.MatrixMultiplication(matrix);
                                                 center.AddVector(&Testvector);
                                                 cout << Verbose(1) << "Hydrogen vector is: ";
                                                 Testvector.Output((ofstream *)&cout);
                                                 cout << endl;
+                                        }
+                                }
+                        }
+        // now also change all hydrogens
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
+          Binder = ListOfBondsPerAtom[Walker->nr][i];
+          if (Binder->GetOtherAtom(Walker)->type->Z == 1) {
+            Testvector.CopyVector(&Binder->GetOtherAtom(Walker)->x);
+            Testvector.InverseMatrixMultiplication(matrix);
+            Testvector.AddVector(&Translationvector);
+            Testvector.MatrixMultiplication(matrix);
+            center.AddVector(&Testvector);
+            cout << Verbose(1) << "Hydrogen vector is: ";
+            Testvector.Output((ofstream *)&cout);
+            cout << endl;
+          }
+        }
+      }
 #endif
+                }
         } while (!flag);
         Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
         center.Scale(1./(double)AtomCount);
+    }
+  } while (!flag);
+  Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
+  center.Scale(1./(double)AtomCount);
 };
 …
 void molecule::PrincipalAxisSystem(ofstream *out, bool DoRotate)
+{
         atom *ptr = start;      // start at first in list
         double InertiaTensor[NDIM*NDIM];
         Vector *CenterOfGravity = DetermineCenterOfGravity(out);
         CenterAtVector(out, CenterOfGravity);
         // reset inertia tensor
         for(int i=0;i<NDIM*NDIM;i++)
                 InertiaTensor[i] = 0.;
         // sum up inertia tensor
         while (ptr->next != end) {
                 ptr = ptr->next;
                 Vector x;
                 x.CopyVector(&ptr->x);
                 //x.SubtractVector(CenterOfGravity);
                 InertiaTensor[0] += ptr->type->mass*(x.x[1]*x.x[1] + x.x[2]*x.x[2]);
                 InertiaTensor[1] += ptr->type->mass*(-x.x[0]*x.x[1]);
                 InertiaTensor[2] += ptr->type->mass*(-x.x[0]*x.x[2]);
                 InertiaTensor[3] += ptr->type->mass*(-x.x[1]*x.x[0]);
                 InertiaTensor[4] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[2]*x.x[2]);
                 InertiaTensor[5] += ptr->type->mass*(-x.x[1]*x.x[2]);
                 InertiaTensor[6] += ptr->type->mass*(-x.x[2]*x.x[0]);
                 InertiaTensor[7] += ptr->type->mass*(-x.x[2]*x.x[1]);
                 InertiaTensor[8] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[1]*x.x[1]);
+        }
         // print InertiaTensor for debugging
         *out << "The inertia tensor is:" << endl;
         for(int i=0;i<NDIM;i++) {
                 for(int j=0;j<NDIM;j++)
                         *out << InertiaTensor[i*NDIM+j] << " ";
                 *out << endl;
+        }
         *out << endl;
         // diagonalize to determine principal axis system
         gsl_eigen_symmv_workspace *T = gsl_eigen_symmv_alloc(NDIM);
         gsl_matrix_view m = gsl_matrix_view_array(InertiaTensor, NDIM, NDIM);
         gsl_vector *eval = gsl_vector_alloc(NDIM);
         gsl_matrix *evec = gsl_matrix_alloc(NDIM, NDIM);
         gsl_eigen_symmv(&m.matrix, eval, evec, T);
         gsl_eigen_symmv_free(T);
         gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
         for(int i=0;i<NDIM;i++) {
                 *out << Verbose(1) << "eigenvalue = " << gsl_vector_get(eval, i);
                 *out << ", eigenvector = (" << evec->data[i * evec->tda + 0] << "," << evec->data[i * evec->tda + 1] << "," << evec->data[i * evec->tda + 2] << ")" << endl;
+        }
         // check whether we rotate or not
         if (DoRotate) {
                 *out << Verbose(1) << "Transforming molecule into PAS ... ";
                 // the eigenvectors specify the transformation matrix
                 ptr = start;
                 while (ptr->next != end) {
                         ptr = ptr->next;
                         for (int j=0;j<MDSteps;j++)
                                 Trajectories[ptr].R.at(j).MatrixMultiplication(evec->data);
                         ptr->x.MatrixMultiplication(evec->data);
+                }
                 *out << "done." << endl;
                 // summing anew for debugging (resulting matrix has to be diagonal!)
                 // reset inertia tensor
                 for(int i=0;i<NDIM*NDIM;i++)
                         InertiaTensor[i] = 0.;
                 // sum up inertia tensor
                 ptr = start;
                 while (ptr->next != end) {
                         ptr = ptr->next;
                         Vector x;
                         x.CopyVector(&ptr->x);
                         //x.SubtractVector(CenterOfGravity);
                         InertiaTensor[0] += ptr->type->mass*(x.x[1]*x.x[1] + x.x[2]*x.x[2]);
                         InertiaTensor[1] += ptr->type->mass*(-x.x[0]*x.x[1]);
                         InertiaTensor[2] += ptr->type->mass*(-x.x[0]*x.x[2]);
                         InertiaTensor[3] += ptr->type->mass*(-x.x[1]*x.x[0]);
                         InertiaTensor[4] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[2]*x.x[2]);
                         InertiaTensor[5] += ptr->type->mass*(-x.x[1]*x.x[2]);
                         InertiaTensor[6] += ptr->type->mass*(-x.x[2]*x.x[0]);
                         InertiaTensor[7] += ptr->type->mass*(-x.x[2]*x.x[1]);
                         InertiaTensor[8] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[1]*x.x[1]);
+                }
                 // print InertiaTensor for debugging
                 *out << "The inertia tensor is:" << endl;
                 for(int i=0;i<NDIM;i++) {
                         for(int j=0;j<NDIM;j++)
                                 *out << InertiaTensor[i*NDIM+j] << " ";
                         *out << endl;
+                }
                 *out << endl;
+        }
         // free everything
         delete(CenterOfGravity);
         gsl_vector_free(eval);
         gsl_matrix_free(evec);
+  atom *ptr = start;  // start at first in list
+  double InertiaTensor[NDIM*NDIM];
+  Vector *CenterOfGravity = DetermineCenterOfGravity(out);
+  CenterAtVector(out, CenterOfGravity);
+  // reset inertia tensor
+  for(int i=0;i<NDIM*NDIM;i++)
+    InertiaTensor[i] = 0.;
+  // sum up inertia tensor
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    Vector x;
+    x.CopyVector(&ptr->x);
+    //x.SubtractVector(CenterOfGravity);
+    InertiaTensor[0] += ptr->type->mass*(x.x[1]*x.x[1] + x.x[2]*x.x[2]);
+    InertiaTensor[1] += ptr->type->mass*(-x.x[0]*x.x[1]);
+    InertiaTensor[2] += ptr->type->mass*(-x.x[0]*x.x[2]);
+    InertiaTensor[3] += ptr->type->mass*(-x.x[1]*x.x[0]);
+    InertiaTensor[4] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[2]*x.x[2]);
+    InertiaTensor[5] += ptr->type->mass*(-x.x[1]*x.x[2]);
+    InertiaTensor[6] += ptr->type->mass*(-x.x[2]*x.x[0]);
+    InertiaTensor[7] += ptr->type->mass*(-x.x[2]*x.x[1]);
+    InertiaTensor[8] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[1]*x.x[1]);
+  }
+  // print InertiaTensor for debugging
+  *out << "The inertia tensor is:" << endl;
+  for(int i=0;i<NDIM;i++) {
+    for(int j=0;j<NDIM;j++)
+      *out << InertiaTensor[i*NDIM+j] << " ";
+    *out << endl;
+  }
+  *out << endl;
+  // diagonalize to determine principal axis system
+  gsl_eigen_symmv_workspace *T = gsl_eigen_symmv_alloc(NDIM);
+  gsl_matrix_view m = gsl_matrix_view_array(InertiaTensor, NDIM, NDIM);
+  gsl_vector *eval = gsl_vector_alloc(NDIM);
+  gsl_matrix *evec = gsl_matrix_alloc(NDIM, NDIM);
+  gsl_eigen_symmv(&m.matrix, eval, evec, T);
+  gsl_eigen_symmv_free(T);
+  gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
+  for(int i=0;i<NDIM;i++) {
+    *out << Verbose(1) << "eigenvalue = " << gsl_vector_get(eval, i);
+    *out << ", eigenvector = (" << evec->data[i * evec->tda + 0] << "," << evec->data[i * evec->tda + 1] << "," << evec->data[i * evec->tda + 2] << ")" << endl;
+  }
+  // check whether we rotate or not
+  if (DoRotate) {
+    *out << Verbose(1) << "Transforming molecule into PAS ... ";
+    // the eigenvectors specify the transformation matrix
+    ptr = start;
+    while (ptr->next != end) {
+      ptr = ptr->next;
+      for (int j=0;j<MDSteps;j++)
+        Trajectories[ptr].R.at(j).MatrixMultiplication(evec->data);
+      ptr->x.MatrixMultiplication(evec->data);
+    }
+    *out << "done." << endl;
+    // summing anew for debugging (resulting matrix has to be diagonal!)
+    // reset inertia tensor
+    for(int i=0;i<NDIM*NDIM;i++)
+      InertiaTensor[i] = 0.;
+    // sum up inertia tensor
+    ptr = start;
+    while (ptr->next != end) {
+      ptr = ptr->next;
+      Vector x;
+      x.CopyVector(&ptr->x);
+      //x.SubtractVector(CenterOfGravity);
+      InertiaTensor[0] += ptr->type->mass*(x.x[1]*x.x[1] + x.x[2]*x.x[2]);
+      InertiaTensor[1] += ptr->type->mass*(-x.x[0]*x.x[1]);
+      InertiaTensor[2] += ptr->type->mass*(-x.x[0]*x.x[2]);
+      InertiaTensor[3] += ptr->type->mass*(-x.x[1]*x.x[0]);
+      InertiaTensor[4] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[2]*x.x[2]);
+      InertiaTensor[5] += ptr->type->mass*(-x.x[1]*x.x[2]);
+      InertiaTensor[6] += ptr->type->mass*(-x.x[2]*x.x[0]);
+      InertiaTensor[7] += ptr->type->mass*(-x.x[2]*x.x[1]);
+      InertiaTensor[8] += ptr->type->mass*(x.x[0]*x.x[0] + x.x[1]*x.x[1]);
+    }
+    // print InertiaTensor for debugging
+    *out << "The inertia tensor is:" << endl;
+    for(int i=0;i<NDIM;i++) {
+      for(int j=0;j<NDIM;j++)
+        *out << InertiaTensor[i*NDIM+j] << " ";
+      *out << endl;
+    }
+    *out << endl;
+  }
+  // free everything
+  delete(CenterOfGravity);
+  gsl_vector_free(eval);
+  gsl_matrix_free(evec);
 };
 …
 bool molecule::VerletForceIntegration(char *file, double delta_t, bool IsAngstroem)
+{
         element *runner = elemente->start;
         atom *walker = NULL;
         int AtomNo;
         ifstream input(file);
         string token;
         stringstream item;
         double a, IonMass;
         ForceMatrix Force;
         Vector tmpvector;
         CountElements();        // make sure ElementsInMolecule is up to date
         // check file
         if (input == NULL) {
                 return false;
         } else {
                 // parse file into ForceMatrix
                 if (!Force.ParseMatrix(file, 0,0,0)) {
                         cerr << "Could not parse Force Matrix file " << file << "." << endl;
                         return false;
+                }
                 if (Force.RowCounter[0] != AtomCount) {
                         cerr << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl;
                         return false;
+                }
                 // 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;
 //                      }
                 // 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;
                                         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);
+                                                }
                                                 // 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
+                                                }
                                                 // 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++;
+                                        }
+                                }
+                        }
+                }
+        }
 //      // 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;
+  element *runner = elemente->start;
+  atom *walker = NULL;
+  int AtomNo;
+  ifstream input(file);
+  string token;
+  stringstream item;
+  double a, IonMass;
+  ForceMatrix Force;
+  Vector tmpvector;
+  CountElements();  // make sure ElementsInMolecule is up to date
+  // check file
+  if (input == NULL) {
+    return false;
+  } else {
+    // parse file into ForceMatrix
+    if (!Force.ParseMatrix(file, 0,0,0)) {
+      cerr << "Could not parse Force Matrix file " << file << "." << endl;
+      return false;
+    }
+    if (Force.RowCounter[0] != AtomCount) {
+      cerr << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl;
+      return false;
+    }
+    // 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;
+//      }
+    // 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;
+          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);
+            }
+            // 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
+            }
+            // 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++;
+          }
+        }
+      }
+    }
+  }
+//  // 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;
 };
 …
 void molecule::Align(Vector *n)
+{
         atom *ptr = start;
         double alpha, tmp;
         Vector z_axis;
         z_axis.x[0] = 0.;
         z_axis.x[1] = 0.;
         z_axis.x[2] = 1.;
         // rotate on z-x plane
         cout << Verbose(0) << "Begin of Aligning all atoms." << endl;
         alpha = atan(-n->x[0]/n->x[2]);
         cout << Verbose(1) << "Z-X-angle: " << alpha << " ... ";
         while (ptr->next != end) {
                 ptr = ptr->next;
                 tmp = ptr->x.x[0];
                 ptr->x.x[0] =   cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
                 ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
                 for (int j=0;j<MDSteps;j++) {
                         tmp = Trajectories[ptr].R.at(j).x[0];
                         Trajectories[ptr].R.at(j).x[0] =        cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
                         Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
+                }
+        }
         // rotate n vector
         tmp = n->x[0];
         n->x[0] =       cos(alpha) * tmp +      sin(alpha) * n->x[2];
         n->x[2] = -sin(alpha) * tmp +   cos(alpha) * n->x[2];
         cout << Verbose(1) << "alignment vector after first rotation: ";
         n->Output((ofstream *)&cout);
         cout << endl;
         // rotate on z-y plane
         ptr = start;
         alpha = atan(-n->x[1]/n->x[2]);
         cout << Verbose(1) << "Z-Y-angle: " << alpha << " ... ";
         while (ptr->next != end) {
                 ptr = ptr->next;
                 tmp = ptr->x.x[1];
                 ptr->x.x[1] =   cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
                 ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
                 for (int j=0;j<MDSteps;j++) {
                         tmp = Trajectories[ptr].R.at(j).x[1];
                         Trajectories[ptr].R.at(j).x[1] =        cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
                         Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
+                }
+        }
         // rotate n vector (for consistency check)
         tmp = n->x[1];
         n->x[1] =       cos(alpha) * tmp +      sin(alpha) * n->x[2];
         n->x[2] = -sin(alpha) * tmp +   cos(alpha) * n->x[2];
         cout << Verbose(1) << "alignment vector after second rotation: ";
         n->Output((ofstream *)&cout);
         cout << Verbose(1) << endl;
         cout << Verbose(0) << "End of Aligning all atoms." << endl;
+  atom *ptr = start;
+  double alpha, tmp;
+  Vector z_axis;
+  z_axis.x[0] = 0.;
+  z_axis.x[1] = 0.;
+  z_axis.x[2] = 1.;
+  // rotate on z-x plane
+  cout << Verbose(0) << "Begin of Aligning all atoms." << endl;
+  alpha = atan(-n->x[0]/n->x[2]);
+  cout << Verbose(1) << "Z-X-angle: " << alpha << " ... ";
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x.x[0];
+    ptr->x.x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
+    ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
+    for (int j=0;j<MDSteps;j++) {
+      tmp = Trajectories[ptr].R.at(j).x[0];
+      Trajectories[ptr].R.at(j).x[0] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
+      Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
+    }
+  }
+  // rotate n vector
+  tmp = n->x[0];
+  n->x[0] =  cos(alpha) * tmp +  sin(alpha) * n->x[2];
+  n->x[2] = -sin(alpha) * tmp +  cos(alpha) * n->x[2];
+  cout << Verbose(1) << "alignment vector after first rotation: ";
+  n->Output((ofstream *)&cout);
+  cout << endl;
+  // rotate on z-y plane
+  ptr = start;
+  alpha = atan(-n->x[1]/n->x[2]);
+  cout << Verbose(1) << "Z-Y-angle: " << alpha << " ... ";
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x.x[1];
+    ptr->x.x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
+    ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
+    for (int j=0;j<MDSteps;j++) {
+      tmp = Trajectories[ptr].R.at(j).x[1];
+      Trajectories[ptr].R.at(j).x[1] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
+      Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
+    }
+  }
+  // rotate n vector (for consistency check)
+  tmp = n->x[1];
+  n->x[1] =  cos(alpha) * tmp +  sin(alpha) * n->x[2];
+  n->x[2] = -sin(alpha) * tmp +  cos(alpha) * n->x[2];
+  cout << Verbose(1) << "alignment vector after second rotation: ";
+  n->Output((ofstream *)&cout);
+  cout << Verbose(1) << endl;
+  cout << Verbose(0) << "End of Aligning all atoms." << endl;
 };
 …
 bool molecule::RemoveAtom(atom *pointer)
+{
         if (ElementsInMolecule[pointer->type->Z] != 0)  // this would indicate an error
                 ElementsInMolecule[pointer->type->Z]--; // decrease number of atom of this element
         else
                 cerr << "ERROR: Atom " << pointer->Name << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl;
         if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
                 ElementCount--;
         Trajectories.erase(pointer);
         return remove(pointer, start, end);
+  if (ElementsInMolecule[pointer->type->Z] != 0)  // this would indicate an error
+    ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
+  else
+    cerr << "ERROR: Atom " << pointer->Name << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl;
+  if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
+    ElementCount--;
+  Trajectories.erase(pointer);
+  return remove(pointer, start, end);
 };
 …
 bool molecule::CleanupMolecule()
+{
         return (cleanup(start,end) && cleanup(first,last));
+  return (cleanup(start,end) && cleanup(first,last));
 };
 …
  * \return pointer to atom or NULL
  */
 atom * molecule::FindAtom(int Nr)       const{
         atom * walker = find(&Nr, start,end);
         if (walker != NULL) {
                 //cout << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
                 return walker;
         } else {
                 cout << Verbose(0) << "Atom not found in list." << endl;
                 return NULL;
+        }
+atom * molecule::FindAtom(int Nr)  const{
+  atom * walker = find(&Nr, start,end);
+  if (walker != NULL) {
+    //cout << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
+    return walker;
+  } else {
+    cout << Verbose(0) << "Atom not found in list." << endl;
+    return NULL;
+  }
 };
 …
 atom * molecule::AskAtom(string text)
+{
         int No;
         atom *ion = NULL;
         do {
                 //cout << Verbose(0) << "============Atom list==========================" << endl;
                 //mol->Output((ofstream *)&cout);
                 //cout << Verbose(0) << "===============================================" << endl;
                 cout << Verbose(0) << text;
                 cin >> No;
                 ion = this->FindAtom(No);
         } while (ion == NULL);
         return ion;
+  int No;
+  atom *ion = NULL;
+  do {
+    //cout << Verbose(0) << "============Atom list==========================" << endl;
+    //mol->Output((ofstream *)&cout);
+    //cout << Verbose(0) << "===============================================" << endl;
+    cout << Verbose(0) << text;
+    cin >> No;
+    ion = this->FindAtom(No);
+  } while (ion == NULL);
+  return ion;
 };
 …
 bool molecule::CheckBounds(const Vector *x) const
+{
         bool result = true;
         int j =-1;
         for (int i=0;i<NDIM;i++) {
                 j += i+1;
                 result = result && ((x->x[i] >= 0) && (x->x[i] < cell_size[j]));
+        }
         //return result;
         return true; /// probably not gonna use the check no more
+  bool result = true;
+  int j =-1;
+  for (int i=0;i<NDIM;i++) {
+    j += i+1;
+    result = result && ((x->x[i] >= 0) && (x->x[i] < cell_size[j]));
+  }
+  //return result;
+  return true; /// probably not gonna use the check no more
 };
 …
 double LeastSquareDistance (const gsl_vector * x, void * params)
+{
         double res = 0, t;
         Vector a,b,c,d;
         struct lsq_params *par = (struct lsq_params *)params;
         atom *ptr = par->mol->start;
         // initialize vectors
         a.x[0] = gsl_vector_get(x,0);
         a.x[1] = gsl_vector_get(x,1);
         a.x[2] = gsl_vector_get(x,2);
         b.x[0] = gsl_vector_get(x,3);
         b.x[1] = gsl_vector_get(x,4);
         b.x[2] = gsl_vector_get(x,5);
         // go through all atoms
         while (ptr != par->mol->end) {
                 ptr = ptr->next;
                 if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
                         c.CopyVector(&ptr->x);  // copy vector to temporary one
                         c.SubtractVector(&a);    // subtract offset vector
                         t = c.ScalarProduct(&b);                                         // get direction parameter
                         d.CopyVector(&b);                        // and create vector
                         d.Scale(&t);
                         c.SubtractVector(&d);    // ... yielding distance vector
                         res += d.ScalarProduct((const Vector *)&d);                             // add squared distance
+                }
+        }
         return res;
+  double res = 0, t;
+  Vector a,b,c,d;
+  struct lsq_params *par = (struct lsq_params *)params;
+  atom *ptr = par->mol->start;
+  // initialize vectors
+  a.x[0] = gsl_vector_get(x,0);
+  a.x[1] = gsl_vector_get(x,1);
+  a.x[2] = gsl_vector_get(x,2);
+  b.x[0] = gsl_vector_get(x,3);
+  b.x[1] = gsl_vector_get(x,4);
+  b.x[2] = gsl_vector_get(x,5);
+  // go through all atoms
+  while (ptr != par->mol->end) {
+    ptr = ptr->next;
+    if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
+      c.CopyVector(&ptr->x);  // copy vector to temporary one
+      c.SubtractVector(&a);   // subtract offset vector
+      t = c.ScalarProduct(&b);           // get direction parameter
+      d.CopyVector(&b);       // and create vector
+      d.Scale(&t);
+      c.SubtractVector(&d);   // ... yielding distance vector
+      res += d.ScalarProduct((const Vector *)&d);        // add squared distance
+    }
+  }
+  return res;
 };
 …
 void molecule::GetAlignvector(struct lsq_params * par) const
+{
                 int np = 6;
          const gsl_multimin_fminimizer_type *T =
                  gsl_multimin_fminimizer_nmsimplex;
          gsl_multimin_fminimizer *s = NULL;
          gsl_vector *ss;
          gsl_multimin_function minex_func;
          size_t iter = 0, i;
          int status;
          double size;
          /* Initial vertex size vector */
          ss = gsl_vector_alloc (np);
          /* Set all step sizes to 1 */
          gsl_vector_set_all (ss, 1.0);
          /* Starting point */
          par->x = gsl_vector_alloc (np);
          par->mol = this;
          gsl_vector_set (par->x, 0, 0.0);       // offset
          gsl_vector_set (par->x, 1, 0.0);
          gsl_vector_set (par->x, 2, 0.0);
          gsl_vector_set (par->x, 3, 0.0);       // direction
          gsl_vector_set (par->x, 4, 0.0);
          gsl_vector_set (par->x, 5, 1.0);
          /* Initialize method and iterate */
          minex_func.f = &LeastSquareDistance;
          minex_func.n = np;
          minex_func.params = (void *)par;
          s = gsl_multimin_fminimizer_alloc (T, np);
          gsl_multimin_fminimizer_set (s, &minex_func, par->x, ss);
          do
+                 {
                          iter++;
                          status = gsl_multimin_fminimizer_iterate(s);
                          if (status)
                                  break;
                          size = gsl_multimin_fminimizer_size (s);
                          status = gsl_multimin_test_size (size, 1e-2);
                          if (status == GSL_SUCCESS)
+                                 {
                                          printf ("converged to minimum at\n");
+                                 }
                          printf ("%5d ", (int)iter);
                          for (i = 0; i < (size_t)np; i++)
+                                 {
                                          printf ("%10.3e ", gsl_vector_get (s->x, i));
+                                 }
                          printf ("f() = %7.3f size = %.3f\n", s->fval, size);
+                 }
          while (status == GSL_CONTINUE && iter < 100);
         for (i=0;i<(size_t)np;i++)
                 gsl_vector_set(par->x, i, gsl_vector_get(s->x, i));
          //gsl_vector_free(par->x);
          gsl_vector_free(ss);
          gsl_multimin_fminimizer_free (s);
+    int np = 6;
+   const gsl_multimin_fminimizer_type *T =
+     gsl_multimin_fminimizer_nmsimplex;
+   gsl_multimin_fminimizer *s = NULL;
+   gsl_vector *ss;
+   gsl_multimin_function minex_func;
+   size_t iter = 0, i;
+   int status;
+   double size;
+   /* Initial vertex size vector */
+   ss = gsl_vector_alloc (np);
+   /* Set all step sizes to 1 */
+   gsl_vector_set_all (ss, 1.0);
+   /* Starting point */
+   par->x = gsl_vector_alloc (np);
+   par->mol = this;
+   gsl_vector_set (par->x, 0, 0.0);  // offset
+   gsl_vector_set (par->x, 1, 0.0);
+   gsl_vector_set (par->x, 2, 0.0);
+   gsl_vector_set (par->x, 3, 0.0);  // direction
+   gsl_vector_set (par->x, 4, 0.0);
+   gsl_vector_set (par->x, 5, 1.0);
+   /* Initialize method and iterate */
+   minex_func.f = &LeastSquareDistance;
+   minex_func.n = np;
+   minex_func.params = (void *)par;
+   s = gsl_multimin_fminimizer_alloc (T, np);
+   gsl_multimin_fminimizer_set (s, &minex_func, par->x, ss);
+   do
+     {
+       iter++;
+       status = gsl_multimin_fminimizer_iterate(s);
+       if (status)
+         break;
+       size = gsl_multimin_fminimizer_size (s);
+       status = gsl_multimin_test_size (size, 1e-2);
+       if (status == GSL_SUCCESS)
+         {
+           printf ("converged to minimum at\n");
+         }
+       printf ("%5d ", (int)iter);
+       for (i = 0; i < (size_t)np; i++)
+         {
+           printf ("%10.3e ", gsl_vector_get (s->x, i));
+         }
+       printf ("f() = %7.3f size = %.3f\n", s->fval, size);
+     }
+   while (status == GSL_CONTINUE && iter < 100);
+  for (i=0;i<(size_t)np;i++)
+    gsl_vector_set(par->x, i, gsl_vector_get(s->x, i));
+   //gsl_vector_free(par->x);
+   gsl_vector_free(ss);
+   gsl_multimin_fminimizer_free (s);
 };
 …
 bool molecule::Output(ofstream *out)
+{
         element *runner;
         atom *walker = NULL;
         int ElementNo, AtomNo;
         CountElements();
         if (out == NULL) {
                 return false;
         } else {
                 *out << "#Ion_TypeNr._Nr.R[0]           R[1]            R[2]            MoveType (0 MoveIon, 1 FixedIon)" << endl;
                 ElementNo = 0;
                 runner = elemente->start;
                 while (runner->next != elemente->end) { // go through every element
                         runner = runner->next;
                         if (ElementsInMolecule[runner->Z]) { // if this element got atoms
                                 ElementNo++;
                                 AtomNo = 0;
                                 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
                                                 AtomNo++;
                                                 walker->Output(ElementNo, AtomNo, out); // removed due to trajectories
+                                        }
+                                }
+                        }
+                }
                 return true;
+        }
+  element *runner;
+  atom *walker = NULL;
+  int ElementNo, AtomNo;
+  CountElements();
+  if (out == NULL) {
+    return false;
+  } else {
+    *out << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
+    ElementNo = 0;
+    runner = elemente->start;
+    while (runner->next != elemente->end) { // go through every element
+      runner = runner->next;
+      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+        ElementNo++;
+        AtomNo = 0;
+        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
+            AtomNo++;
+            walker->Output(ElementNo, AtomNo, out); // removed due to trajectories
+          }
+        }
+      }
+    }
+    return true;
+  }
 };
 …
 bool molecule::OutputTrajectories(ofstream *out)
+{
         element *runner = NULL;
         atom *walker = NULL;
         int ElementNo, AtomNo;
         CountElements();
         if (out == NULL) {
                 return false;
         } else {
                 for (int step = 0; step < MDSteps; step++) {
                         if (step == 0) {
                                 *out << "#Ion_TypeNr._Nr.R[0]           R[1]            R[2]            MoveType (0 MoveIon, 1 FixedIon)" << endl;
                         } else {
                                 *out << "# ====== MD step " << step << " =========" << endl;
+                        }
                         ElementNo = 0;
                         runner = elemente->start;
                         while (runner->next != elemente->end) { // go through every element
                                 runner = runner->next;
                                 if (ElementsInMolecule[runner->Z]) { // if this element got atoms
                                         ElementNo++;
                                         AtomNo = 0;
                                         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
                                                         AtomNo++;
                                                         *out << "Ion_Type" << ElementNo << "_" << AtomNo << "\t"        << fixed << setprecision(9) << showpoint;
                                                         *out << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2];
                                                         *out << "\t" << walker->FixedIon;
                                                         if (Trajectories[walker].U.at(step).Norm() > MYEPSILON)
                                                                 *out << "\t" << scientific << setprecision(6) << Trajectories[walker].U.at(step).x[0] << "\t" << Trajectories[walker].U.at(step).x[1] << "\t" << Trajectories[walker].U.at(step).x[2] << "\t";
                                                         if (Trajectories[walker].F.at(step).Norm() > MYEPSILON)
                                                                 *out << "\t" << scientific << setprecision(6) << Trajectories[walker].F.at(step).x[0] << "\t" << Trajectories[walker].F.at(step).x[1] << "\t" << Trajectories[walker].F.at(step).x[2] << "\t";
                                                         *out << "\t# Number in molecule " << walker->nr << endl;
+                                                }
+                                        }
+                                }
+                        }
+                }
                 return true;
+        }
+  element *runner = NULL;
+  atom *walker = NULL;
+  int ElementNo, AtomNo;
+  CountElements();
+  if (out == NULL) {
+    return false;
+  } else {
+    for (int step = 0; step < MDSteps; step++) {
+      if (step == 0) {
+        *out << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
+      } else {
+        *out << "# ====== MD step " << step << " =========" << endl;
+      }
+      ElementNo = 0;
+      runner = elemente->start;
+      while (runner->next != elemente->end) { // go through every element
+        runner = runner->next;
+        if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+          ElementNo++;
+          AtomNo = 0;
+          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
+              AtomNo++;
+              *out << "Ion_Type" << ElementNo << "_" << AtomNo << "\t"  << fixed << setprecision(9) << showpoint;
+              *out << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2];
+              *out << "\t" << walker->FixedIon;
+              if (Trajectories[walker].U.at(step).Norm() > MYEPSILON)
+                *out << "\t" << scientific << setprecision(6) << Trajectories[walker].U.at(step).x[0] << "\t" << Trajectories[walker].U.at(step).x[1] << "\t" << Trajectories[walker].U.at(step).x[2] << "\t";
+              if (Trajectories[walker].F.at(step).Norm() > MYEPSILON)
+                *out << "\t" << scientific << setprecision(6) << Trajectories[walker].F.at(step).x[0] << "\t" << Trajectories[walker].F.at(step).x[1] << "\t" << Trajectories[walker].F.at(step).x[2] << "\t";
+              *out << "\t# Number in molecule " << walker->nr << endl;
+            }
+          }
+        }
+      }
+    }
+    return true;
+  }
 };
 …
 void molecule::OutputListOfBonds(ofstream *out) const
+{
         *out << Verbose(2) << endl << "From Contents of ListOfBondsPerAtom, all non-hydrogen atoms:" << endl;
         atom *Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
+  *out << Verbose(2) << endl << "From Contents of ListOfBondsPerAtom, all non-hydrogen atoms:" << endl;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
 #ifdef ADDHYDROGEN
                 if (Walker->type->Z != 1) {      // regard only non-hydrogen
+    if (Walker->type->Z != 1) {   // regard only non-hydrogen
 #endif
                         *out << Verbose(2) << "Atom " << Walker->Name << " has Bonds: "<<endl;
                         for(int j=0;j<NumberOfBondsPerAtom[Walker->nr];j++) {
                                 *out << Verbose(3) << *(ListOfBondsPerAtom)[Walker->nr][j] << endl;
+                        }
+      *out << Verbose(2) << "Atom " << Walker->Name << " has Bonds: "<<endl;
+      for(int j=0;j<NumberOfBondsPerAtom[Walker->nr];j++) {
+        *out << Verbose(3) << *(ListOfBondsPerAtom)[Walker->nr][j] << endl;
+      }
 #ifdef ADDHYDROGEN
+                }
+    }
 #endif
+        }
         *out << endl;
+  }
+  *out << endl;
 };
 …
  * \param *out stream pointer
  */
 bool molecule::Checkout(ofstream *out)  const
+{
         return elemente->Checkout(out, ElementsInMolecule);
+bool molecule::Checkout(ofstream *out)  const
+{
+  return elemente->Checkout(out, ElementsInMolecule);
 };
 …
 bool molecule::OutputTrajectoriesXYZ(ofstream *out)
+{
         atom *walker = NULL;
         int No = 0;
         time_t now;
         now = time((time_t *)NULL);      // Get the system time and put it into 'now' as 'calender time'
         walker = start;
         while (walker->next != end) { // go through every atom and count
                 walker = walker->next;
                 No++;
+        }
         if (out != NULL) {
                 for (int step=0;step<MDSteps;step++) {
                         *out << No << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
                         walker = start;
                         while (walker->next != end) { // go through every atom of this element
                                 walker = walker->next;
                                 *out << walker->type->symbol << "\t" << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2] << endl;
+                        }
+                }
                 return true;
         } else
                 return false;
+  atom *walker = NULL;
+  int No = 0;
+  time_t now;
+  now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
+  walker = start;
+  while (walker->next != end) { // go through every atom and count
+    walker = walker->next;
+    No++;
+  }
+  if (out != NULL) {
+    for (int step=0;step<MDSteps;step++) {
+      *out << No << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
+      walker = start;
+      while (walker->next != end) { // go through every atom of this element
+        walker = walker->next;
+        *out << walker->type->symbol << "\t" << Trajectories[walker].R.at(step).x[0] << "\t" << Trajectories[walker].R.at(step).x[1] << "\t" << Trajectories[walker].R.at(step).x[2] << endl;
+      }
+    }
+    return true;
+  } else
+    return false;
 };
 …
 bool molecule::OutputXYZ(ofstream *out) const
+{
         atom *walker = NULL;
         int AtomNo = 0, ElementNo;
         time_t now;
         element *runner = NULL;
         now = time((time_t *)NULL);      // Get the system time and put it into 'now' as 'calender time'
         walker = start;
         while (walker->next != end) { // go through every atom and count
                 walker = walker->next;
                 AtomNo++;
+        }
         if (out != NULL) {
                 *out << AtomNo << "\n\tCreated by molecuilder on " << ctime(&now);
                 ElementNo = 0;
                 runner = elemente->start;
                 while (runner->next != elemente->end) { // go through every element
                         runner = runner->next;
                         if (ElementsInMolecule[runner->Z]) { // if this element got atoms
                                 ElementNo++;
                                 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
                                                 walker->OutputXYZLine(out);
+                                        }
+                                }
+                        }
+                }
                 return true;
         } else
                 return false;
+  atom *walker = NULL;
+  int AtomNo = 0, ElementNo;
+  time_t now;
+  element *runner = NULL;
+  now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
+  walker = start;
+  while (walker->next != end) { // go through every atom and count
+    walker = walker->next;
+    AtomNo++;
+  }
+  if (out != NULL) {
+    *out << AtomNo << "\n\tCreated by molecuilder on " << ctime(&now);
+    ElementNo = 0;
+    runner = elemente->start;
+    while (runner->next != elemente->end) { // go through every element
+      runner = runner->next;
+      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+        ElementNo++;
+        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
+            walker->OutputXYZLine(out);
+          }
+        }
+      }
+    }
+    return true;
+  } else
+    return false;
 };
 …
 void molecule::CountAtoms(ofstream *out)
+{
         int i = 0;
         atom *Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 i++;
+        }
         if ((AtomCount == 0) || (i != AtomCount)) {
                 *out << Verbose(3) << "Mismatch in AtomCount " << AtomCount << " and recounted number " << i << ", renaming all." << endl;
                 AtomCount = i;
                 // count NonHydrogen atoms and give each atom a unique name
                 if (AtomCount != 0) {
                         i=0;
                         NoNonHydrogen = 0;
                         Walker = start;
                         while (Walker->next != end) {
                                 Walker = Walker->next;
                                 Walker->nr = i;  // update number in molecule (for easier referencing in FragmentMolecule lateron)
                                 if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
                                         NoNonHydrogen++;
                                 Free((void **)&Walker->Name, "molecule::CountAtoms: *walker->Name");
                                 Walker->Name = (char *) Malloc(sizeof(char)*6, "molecule::CountAtoms: *walker->Name");
                                 sprintf(Walker->Name, "%2s%02d", Walker->type->symbol, Walker->nr+1);
                                 *out << "Naming atom nr. " << Walker->nr << " " << Walker->Name << "." << endl;
                                 i++;
+                        }
                 } else
                         *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl;
+        }
+  int i = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    i++;
+  }
+  if ((AtomCount == 0) || (i != AtomCount)) {
+    *out << Verbose(3) << "Mismatch in AtomCount " << AtomCount << " and recounted number " << i << ", renaming all." << endl;
+    AtomCount = i;
+    // count NonHydrogen atoms and give each atom a unique name
+    if (AtomCount != 0) {
+      i=0;
+      NoNonHydrogen = 0;
+      Walker = start;
+      while (Walker->next != end) {
+        Walker = Walker->next;
+        Walker->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
+        if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
+          NoNonHydrogen++;
+        Free((void **)&Walker->Name, "molecule::CountAtoms: *walker->Name");
+        Walker->Name = (char *) Malloc(sizeof(char)*6, "molecule::CountAtoms: *walker->Name");
+        sprintf(Walker->Name, "%2s%02d", Walker->type->symbol, Walker->nr+1);
+        *out << "Naming atom nr. " << Walker->nr << " " << Walker->Name << "." << endl;
+        i++;
+      }
+    } else
+      *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl;
+  }
 };
 …
 void molecule::CountElements()
+{
         int i = 0;
         for(i=MAX_ELEMENTS;i--;)
                 ElementsInMolecule[i] = 0;
         ElementCount = 0;
         atom *walker = start;
         while (walker->next != end) {
                 walker = walker->next;
                 ElementsInMolecule[walker->type->Z]++;
                 i++;
+        }
         for(i=MAX_ELEMENTS;i--;)
                 ElementCount += (ElementsInMolecule[i] != 0 ? 1 : 0);
+  int i = 0;
+  for(i=MAX_ELEMENTS;i--;)
+    ElementsInMolecule[i] = 0;
+  ElementCount = 0;
+  atom *walker = start;
+  while (walker->next != end) {
+    walker = walker->next;
+    ElementsInMolecule[walker->type->Z]++;
+    i++;
+  }
+  for(i=MAX_ELEMENTS;i--;)
+    ElementCount += (ElementsInMolecule[i] != 0 ? 1 : 0);
 };
 …
 int molecule::CountCyclicBonds(ofstream *out)
+{
         int No = 0;
         int *MinimumRingSize = NULL;
         MoleculeLeafClass *Subgraphs = NULL;
         class StackClass<bond *> *BackEdgeStack = NULL;
         bond *Binder = first;
         if ((Binder->next != last) && (Binder->next->Type == Undetermined)) {
                 *out << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl;
                 Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
                 while (Subgraphs->next != NULL) {
                         Subgraphs = Subgraphs->next;
                         delete(Subgraphs->previous);
+                }
                 delete(Subgraphs);
                 delete[](MinimumRingSize);
+        }
         while(Binder->next != last) {
                 Binder = Binder->next;
                 if (Binder->Cyclic)
                         No++;
+        }
         delete(BackEdgeStack);
         return No;
+  int No = 0;
+  int *MinimumRingSize = NULL;
+  MoleculeLeafClass *Subgraphs = NULL;
+  class StackClass<bond *> *BackEdgeStack = NULL;
+  bond *Binder = first;
+  if ((Binder->next != last) && (Binder->next->Type == Undetermined)) {
+    *out << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl;
+    Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      delete(Subgraphs->previous);
+    }
+    delete(Subgraphs);
+    delete[](MinimumRingSize);
+  }
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    if (Binder->Cyclic)
+      No++;
+  }
+  delete(BackEdgeStack);
+  return No;
 };
 /** Returns Shading as a char string.
 …
 string molecule::GetColor(enum Shading color)
+{
         switch(color) {
                 case white:
                         return "white";
                         break;
                 case lightgray:
                         return "lightgray";
                         break;
                 case darkgray:
                         return "darkgray";
                         break;
                 case black:
                         return "black";
                         break;
                 default:
                         return "uncolored";
                         break;
         };
+  switch(color) {
+    case white:
+      return "white";
+      break;
+    case lightgray:
+      return "lightgray";
+      break;
+    case darkgray:
+      return "darkgray";
+      break;
+    case black:
+      return "black";
+      break;
+    default:
+      return "uncolored";
+      break;
+  };
 };
 …
 void molecule::CalculateOrbitals(class config &configuration)
+{
         configuration.MaxPsiDouble = configuration.PsiMaxNoDown = configuration.PsiMaxNoUp = configuration.PsiType = 0;
         for(int i=MAX_ELEMENTS;i--;) {
                 if (ElementsInMolecule[i] != 0) {
                         //cout << "CalculateOrbitals: " << elemente->FindElement(i)->name << " has a valence of " << (int)elemente->FindElement(i)->Valence << " and there are " << ElementsInMolecule[i] << " of it." << endl;
                         configuration.MaxPsiDouble += ElementsInMolecule[i]*((int)elemente->FindElement(i)->Valence);
+                }
+        }
         configuration.PsiMaxNoDown = configuration.MaxPsiDouble/2 + (configuration.MaxPsiDouble % 2);
         configuration.PsiMaxNoUp = configuration.MaxPsiDouble/2;
         configuration.MaxPsiDouble /= 2;
         configuration.PsiType = (configuration.PsiMaxNoDown == configuration.PsiMaxNoUp) ? 0 : 1;
         if ((configuration.PsiType == 1) && (configuration.ProcPEPsi < 2)) {
                 configuration.ProcPEGamma /= 2;
                 configuration.ProcPEPsi *= 2;
         } else {
                 configuration.ProcPEGamma *= configuration.ProcPEPsi;
                 configuration.ProcPEPsi = 1;
+        }
         configuration.InitMaxMinStopStep = configuration.MaxMinStopStep = configuration.MaxPsiDouble;
+  configuration.MaxPsiDouble = configuration.PsiMaxNoDown = configuration.PsiMaxNoUp = configuration.PsiType = 0;
+  for(int i=MAX_ELEMENTS;i--;) {
+    if (ElementsInMolecule[i] != 0) {
+      //cout << "CalculateOrbitals: " << elemente->FindElement(i)->name << " has a valence of " << (int)elemente->FindElement(i)->Valence << " and there are " << ElementsInMolecule[i] << " of it." << endl;
+      configuration.MaxPsiDouble += ElementsInMolecule[i]*((int)elemente->FindElement(i)->Valence);
+    }
+  }
+  configuration.PsiMaxNoDown = configuration.MaxPsiDouble/2 + (configuration.MaxPsiDouble % 2);
+  configuration.PsiMaxNoUp = configuration.MaxPsiDouble/2;
+  configuration.MaxPsiDouble /= 2;
+  configuration.PsiType = (configuration.PsiMaxNoDown == configuration.PsiMaxNoUp) ? 0 : 1;
+  if ((configuration.PsiType == 1) && (configuration.ProcPEPsi < 2)) {
+    configuration.ProcPEGamma /= 2;
+    configuration.ProcPEPsi *= 2;
+  } else {
+    configuration.ProcPEGamma *= configuration.ProcPEPsi;
+    configuration.ProcPEPsi = 1;
+  }
+  configuration.InitMaxMinStopStep = configuration.MaxMinStopStep = configuration.MaxPsiDouble;
 };
 …
+{
         // 1 We will parse bonds out of the dbond file created by tremolo.
                         int atom1, atom2, temp;
                         atom *Walker, *OtherWalker;
                                         if (!input)
+                                        {
                                                 cout << Verbose(1) << "Opening silica failed \n";
                                         };
                         *input >> ws >> atom1;
                         *input >> ws >> atom2;
                                         cout << Verbose(1) << "Scanning file\n";
                                         while (!input->eof()) // Check whether we read everything already
+                                        {
                                 *input >> ws >> atom1;
                                 *input >> ws >> atom2;
                                                 if(atom2<atom1) //Sort indices of atoms in order
+                                                {
                                                         temp=atom1;
                                                         atom1=atom2;
                                                         atom2=temp;
                                                 };
                                                 Walker=start;
                                                 while(Walker-> nr != atom1) // Find atom corresponding to first index
+                                                {
                                                         Walker = Walker->next;
                                                 };
                                                 OtherWalker = Walker->next;
                                                 while(OtherWalker->nr != atom2) // Find atom corresponding to second index
+                                                {
                                                         OtherWalker= OtherWalker->next;
                                                 };
                                                 AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+                                        }
                                         CreateListOfBondsPerAtom(out);
+  // 1 We will parse bonds out of the dbond file created by tremolo.
+      int atom1, atom2, temp;
+      atom *Walker, *OtherWalker;
+          if (!input)
+          {
+            cout << Verbose(1) << "Opening silica failed \n";
+          };
+      *input >> ws >> atom1;
+      *input >> ws >> atom2;
+          cout << Verbose(1) << "Scanning file\n";
+          while (!input->eof()) // Check whether we read everything already
+          {
+        *input >> ws >> atom1;
+        *input >> ws >> atom2;
+            if(atom2<atom1) //Sort indices of atoms in order
+            {
+              temp=atom1;
+              atom1=atom2;
+              atom2=temp;
+            };
+            Walker=start;
+            while(Walker-> nr != atom1) // Find atom corresponding to first index
+            {
+              Walker = Walker->next;
+            };
+            OtherWalker = Walker->next;
+            while(OtherWalker->nr != atom2) // Find atom corresponding to second index
+            {
+              OtherWalker= OtherWalker->next;
+            };
+            AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+          }
+          CreateListOfBondsPerAtom(out);
 };
 …
  * To make it O(N log N) the function uses the linked-cell technique as follows:
  * The procedure is step-wise:
  *      -# Remove every bond in list
  *      -# Count the atoms in the molecule with CountAtoms()
  *      -# partition cell into smaller linked cells of size \a bonddistance
  *      -# put each atom into its corresponding cell
  *      -# go through every cell, check the atoms therein against all possible bond partners in the 27 adjacent cells, add bond if true
  *      -# create the list of bonds via CreateListOfBondsPerAtom()
  *      -# correct the bond degree iteratively (single->double->triple bond)
  *      -# finally print the bond list to \a *out if desired
+ *  -# Remove every bond in list
+ *  -# Count the atoms in the molecule with CountAtoms()
+ *  -# partition cell into smaller linked cells of size \a bonddistance
+ *  -# put each atom into its corresponding cell
+ *  -# go through every cell, check the atoms therein against all possible bond partners in the 27 adjacent cells, add bond if true
+ *  -# create the list of bonds via CreateListOfBondsPerAtom()
+ *  -# correct the bond degree iteratively (single->double->triple bond)
+ *  -# finally print the bond list to \a *out if desired
  * \param *out out stream for printing the matrix, NULL if no output
  * \param bonddistance length of linked cells (i.e. maximum minimal length checked)
 …
+{
         atom *Walker = NULL, *OtherWalker = NULL, *Candidate = NULL;
         int No, NoBonds, CandidateBondNo;
         int NumberCells, divisor[NDIM], n[NDIM], N[NDIM], index, Index, j;
         molecule **CellList;
         double distance, MinDistance, MaxDistance;
         double *matrix = ReturnFullMatrixforSymmetric(cell_size);
         Vector x;
         int FalseBondDegree = 0;
         BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
         *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
         // remove every bond from the list
         if ((first->next != last) && (last->previous != first)) {       // there are bonds present
                 cleanup(first,last);
+        }
         // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
         CountAtoms(out);
         *out << Verbose(1) << "AtomCount " << AtomCount << "." << endl;
         if (AtomCount != 0) {
                 // 1. find divisor for each axis, such that a sphere with radius of at least bonddistance can be placed into each cell
                 j=-1;
                 for (int i=0;i<NDIM;i++) {
                         j += i+1;
                         divisor[i] = (int)floor(cell_size[j]/bonddistance); // take smaller value such that size of linked cell is at least bonddistance
                         //*out << Verbose(1) << "divisor[" << i << "]   = " << divisor[i] << "." << endl;
+                }
                 // 2a. allocate memory for the cell list
                 NumberCells = divisor[0]*divisor[1]*divisor[2];
                 *out << Verbose(1) << "Allocating " << NumberCells << " cells." << endl;
                 CellList = (molecule **) Malloc(sizeof(molecule *)*NumberCells, "molecule::CreateAdjacencyList - ** CellList");
                 for (int i=NumberCells;i--;)
                         CellList[i] = NULL;
                 // 2b. put all atoms into its corresponding list
                 Walker = start;
                 while(Walker->next != end) {
                         Walker = Walker->next;
                         //*out << Verbose(1) << "Current atom is " << *Walker << " with coordinates ";
                         //Walker->x.Output(out);
                         //*out << "." << endl;
                         // compute the cell by the atom's coordinates
                         j=-1;
                         for (int i=0;i<NDIM;i++) {
                                 j += i+1;
                                 x.CopyVector(&(Walker->x));
                                 x.KeepPeriodic(out, matrix);
                                 n[i] = (int)floor(x.x[i]/cell_size[j]*(double)divisor[i]);
+                        }
                         index = n[2] + (n[1] + n[0] * divisor[1]) * divisor[2];
                         //*out << Verbose(1) << "Atom " << *Walker << " goes into cell number [" << n[0] << "," << n[1] << "," << n[2] << "] = " << index << "." << endl;
                         // add copy atom to this cell
                         if (CellList[index] == NULL)    // allocate molecule if not done
                                 CellList[index] = new molecule(elemente);
                         OtherWalker = CellList[index]->AddCopyAtom(Walker); // add a copy of walker to this atom, father will be walker for later reference
                         //*out << Verbose(1) << "Copy Atom is " << *OtherWalker << "." << endl;
+                }
                 //for (int i=0;i<NumberCells;i++)
                         //*out << Verbose(1) << "Cell number " << i << ": " << CellList[i] << "." << endl;
                 // 3a. go through every cell
                 for (N[0]=divisor[0];N[0]--;)
                         for (N[1]=divisor[1];N[1]--;)
                                 for (N[2]=divisor[2];N[2]--;) {
                                         Index = N[2] + (N[1] + N[0] * divisor[1]) * divisor[2];
                                         if (CellList[Index] != NULL) { // if there atoms in this cell
                                                 //*out << Verbose(1) << "Current cell is " << Index << "." << endl;
                                                 // 3b. for every atom therein
                                                 Walker = CellList[Index]->start;
                                                 while (Walker->next != CellList[Index]->end) {  // go through every atom
                                                         Walker = Walker->next;
                                                         //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
                                                         // 3c. check for possible bond between each atom in this and every one in the 27 cells
                                                         for (n[0]=-1;n[0]<=1;n[0]++)
                                                                 for (n[1]=-1;n[1]<=1;n[1]++)
                                                                         for (n[2]=-1;n[2]<=1;n[2]++) {
                                                                                  // compute the index of this comparison cell and make it periodic
                                                                                 index = ((N[2]+n[2]+divisor[2])%divisor[2]) + (((N[1]+n[1]+divisor[1])%divisor[1]) + ((N[0]+n[0]+divisor[0])%divisor[0]) * divisor[1]) * divisor[2];
                                                                                 //*out << Verbose(1) << "Number of comparison cell is " << index << "." << endl;
                                                                                 if (CellList[index] != NULL) {  // if there are any atoms in this cell
                                                                                         OtherWalker = CellList[index]->start;
                                                                                         while(OtherWalker->next != CellList[index]->end) {      // go through every atom in this cell
                                                                                                 OtherWalker = OtherWalker->next;
                                                                                                 //*out << Verbose(0) << "Current comparison atom is " << *OtherWalker << "." << endl;
                                                                                                 /// \todo periodic check is missing here!
                                                                                                 //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                                                                                                 MinDistance = OtherWalker->type->CovalentRadius + Walker->type->CovalentRadius;
                                                                                                 MinDistance *= (IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem;
                                                                                                 MaxDistance = MinDistance + BONDTHRESHOLD;
                                                                                                 MinDistance -= BONDTHRESHOLD;
                                                                                                 distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
                                                                                                 if ((OtherWalker->father->nr > Walker->father->nr) && (distance <= MaxDistance*MaxDistance) && (distance >= MinDistance*MinDistance)) { // create bond if distance is smaller
                                                                                                         //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
                                                                                                         AddBond(Walker->father, OtherWalker->father, 1);        // also increases molecule::BondCount
                                                                                                 } else {
                                                                                                         //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
+                                                                                                }
+                                                                                        }
+                                                                                }
+                                                                        }
+                                                }
+                                        }
+                                }
                 // 4. free the cell again
                 for (int i=NumberCells;i--;)
                         if (CellList[i] != NULL) {
                                 delete(CellList[i]);
+                        }
                 Free((void **)&CellList, "molecule::CreateAdjacencyList - ** CellList");
                 // create the adjacency list per atom
                 CreateListOfBondsPerAtom(out);
                 // correct Bond degree of each bond by checking both bond partners for a mismatch between valence and current sum of bond degrees,
                 // iteratively increase the one first where the other bond partner has the fewest number of bonds (i.e. in general bonds oxygene
                 // preferred over carbon bonds). Beforehand, we had picked the first mismatching partner, which lead to oxygenes with single instead of
                 // double bonds as was expected.
                 if (BondCount != 0) {
                         NoCyclicBonds = 0;
                         *out << Verbose(1) << "Correcting Bond degree of each bond ... ";
                         do {
                                 No = 0; // No acts as breakup flag (if 1 we still continue)
                                 Walker = start;
                                 while (Walker->next != end) { // go through every atom
                                         Walker = Walker->next;
                                         // count valence of first partner
                                         NoBonds = 0;
                                         for(j=0;j<NumberOfBondsPerAtom[Walker->nr];j++)
                                                 NoBonds += ListOfBondsPerAtom[Walker->nr][j]->BondDegree;
                                         *out << Verbose(3) << "Walker " << *Walker << ": " << (int)Walker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
                                         if ((int)(Walker->type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
                                                 Candidate = NULL;
                                                 CandidateBondNo = -1;
                                                 for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) { // go through each of its bond partners
                                                         OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
                                                         // count valence of second partner
                                                         NoBonds = 0;
                                                         for(j=0;j<NumberOfBondsPerAtom[OtherWalker->nr];j++)
                                                                 NoBonds += ListOfBondsPerAtom[OtherWalker->nr][j]->BondDegree;
                                                         *out << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
                                                         if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
                                                                 if ((Candidate == NULL) || (NumberOfBondsPerAtom[Candidate->nr] > NumberOfBondsPerAtom[OtherWalker->nr])) { // pick the one with fewer number of bonds first
                                                                         Candidate = OtherWalker;
                                                                         CandidateBondNo = i;
                                                                         *out << Verbose(3) << "New candidate is " << *Candidate << "." << endl;
+                                                                }
+                                                        }
+                                                }
                                                 if ((Candidate != NULL) && (CandidateBondNo != -1)) {
                                                         ListOfBondsPerAtom[Walker->nr][CandidateBondNo]->BondDegree++;
                                                         *out << Verbose(2) << "Increased bond degree for bond " << *ListOfBondsPerAtom[Walker->nr][CandidateBondNo] << "." << endl;
                                                 } else
                                                         *out << Verbose(2) << "Could not find correct degree for atom " << *Walker << "." << endl;
                                                         FalseBondDegree++;
+                                        }
+                                }
                         } while (No);
                 *out << " done." << endl;
                 } else
                         *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
                 *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << bonddistance << ", " << FalseBondDegree << " bonds could not be corrected." << endl;
                 // output bonds for debugging (if bond chain list was correctly installed)
                 *out << Verbose(1) << endl << "From contents of bond chain list:";
                 bond *Binder = first;
                 while(Binder->next != last) {
                         Binder = Binder->next;
                         *out << *Binder << "\t" << endl;
+                }
                 *out << endl;
         } else
                 *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
         *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
         Free((void **)&matrix, "molecule::CreateAdjacencyList: *matrix");
+  atom *Walker = NULL, *OtherWalker = NULL, *Candidate = NULL;
+  int No, NoBonds, CandidateBondNo;
+  int NumberCells, divisor[NDIM], n[NDIM], N[NDIM], index, Index, j;
+  molecule **CellList;
+  double distance, MinDistance, MaxDistance;
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  Vector x;
+  int FalseBondDegree = 0;
+  BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
+  *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
+  // remove every bond from the list
+  if ((first->next != last) && (last->previous != first)) {  // there are bonds present
+    cleanup(first,last);
+  }
+  // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
+  CountAtoms(out);
+  *out << Verbose(1) << "AtomCount " << AtomCount << "." << endl;
+  if (AtomCount != 0) {
+    // 1. find divisor for each axis, such that a sphere with radius of at least bonddistance can be placed into each cell
+    j=-1;
+    for (int i=0;i<NDIM;i++) {
+      j += i+1;
+      divisor[i] = (int)floor(cell_size[j]/bonddistance); // take smaller value such that size of linked cell is at least bonddistance
+      //*out << Verbose(1) << "divisor[" << i << "]  = " << divisor[i] << "." << endl;
+    }
+    // 2a. allocate memory for the cell list
+    NumberCells = divisor[0]*divisor[1]*divisor[2];
+    *out << Verbose(1) << "Allocating " << NumberCells << " cells." << endl;
+    CellList = (molecule **) Malloc(sizeof(molecule *)*NumberCells, "molecule::CreateAdjacencyList - ** CellList");
+    for (int i=NumberCells;i--;)
+      CellList[i] = NULL;
+    // 2b. put all atoms into its corresponding list
+    Walker = start;
+    while(Walker->next != end) {
+      Walker = Walker->next;
+      //*out << Verbose(1) << "Current atom is " << *Walker << " with coordinates ";
+      //Walker->x.Output(out);
+      //*out << "." << endl;
+      // compute the cell by the atom's coordinates
+      j=-1;
+      for (int i=0;i<NDIM;i++) {
+        j += i+1;
+        x.CopyVector(&(Walker->x));
+        x.KeepPeriodic(out, matrix);
+        n[i] = (int)floor(x.x[i]/cell_size[j]*(double)divisor[i]);
+      }
+      index = n[2] + (n[1] + n[0] * divisor[1]) * divisor[2];
+      //*out << Verbose(1) << "Atom " << *Walker << " goes into cell number [" << n[0] << "," << n[1] << "," << n[2] << "] = " << index << "." << endl;
+      // add copy atom to this cell
+      if (CellList[index] == NULL)  // allocate molecule if not done
+        CellList[index] = new molecule(elemente);
+      OtherWalker = CellList[index]->AddCopyAtom(Walker); // add a copy of walker to this atom, father will be walker for later reference
+      //*out << Verbose(1) << "Copy Atom is " << *OtherWalker << "." << endl;
+    }
+    //for (int i=0;i<NumberCells;i++)
+      //*out << Verbose(1) << "Cell number " << i << ": " << CellList[i] << "." << endl;
+    // 3a. go through every cell
+    for (N[0]=divisor[0];N[0]--;)
+      for (N[1]=divisor[1];N[1]--;)
+        for (N[2]=divisor[2];N[2]--;) {
+          Index = N[2] + (N[1] + N[0] * divisor[1]) * divisor[2];
+          if (CellList[Index] != NULL) { // if there atoms in this cell
+            //*out << Verbose(1) << "Current cell is " << Index << "." << endl;
+            // 3b. for every atom therein
+            Walker = CellList[Index]->start;
+            while (Walker->next != CellList[Index]->end) {  // go through every atom
+              Walker = Walker->next;
+              //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              // 3c. check for possible bond between each atom in this and every one in the 27 cells
+              for (n[0]=-1;n[0]<=1;n[0]++)
+                for (n[1]=-1;n[1]<=1;n[1]++)
+                  for (n[2]=-1;n[2]<=1;n[2]++) {
+                     // compute the index of this comparison cell and make it periodic
+                    index = ((N[2]+n[2]+divisor[2])%divisor[2]) + (((N[1]+n[1]+divisor[1])%divisor[1]) + ((N[0]+n[0]+divisor[0])%divisor[0]) * divisor[1]) * divisor[2];
+                    //*out << Verbose(1) << "Number of comparison cell is " << index << "." << endl;
+                    if (CellList[index] != NULL) {  // if there are any atoms in this cell
+                      OtherWalker = CellList[index]->start;
+                      while(OtherWalker->next != CellList[index]->end) {  // go through every atom in this cell
+                        OtherWalker = OtherWalker->next;
+                        //*out << Verbose(0) << "Current comparison atom is " << *OtherWalker << "." << endl;
+                        /// \todo periodic check is missing here!
+                        //*out << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                        MinDistance = OtherWalker->type->CovalentRadius + Walker->type->CovalentRadius;
+                        MinDistance *= (IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem;
+                        MaxDistance = MinDistance + BONDTHRESHOLD;
+                        MinDistance -= BONDTHRESHOLD;
+                        distance = OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size);
+                        if ((OtherWalker->father->nr > Walker->father->nr) && (distance <= MaxDistance*MaxDistance) && (distance >= MinDistance*MinDistance)) { // create bond if distance is smaller
+                          //*out << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
+                          AddBond(Walker->father, OtherWalker->father, 1);  // also increases molecule::BondCount
+                        } else {
+                          //*out << Verbose(1) << "Not Adding: Wrong label order or distance too great." << endl;
+                        }
+                      }
+                    }
+                  }
+            }
+          }
+        }
+    // 4. free the cell again
+    for (int i=NumberCells;i--;)
+      if (CellList[i] != NULL) {
+        delete(CellList[i]);
+      }
+    Free((void **)&CellList, "molecule::CreateAdjacencyList - ** CellList");
+    // create the adjacency list per atom
+    CreateListOfBondsPerAtom(out);
+    // correct Bond degree of each bond by checking both bond partners for a mismatch between valence and current sum of bond degrees,
+    // iteratively increase the one first where the other bond partner has the fewest number of bonds (i.e. in general bonds oxygene
+    // preferred over carbon bonds). Beforehand, we had picked the first mismatching partner, which lead to oxygenes with single instead of
+    // double bonds as was expected.
+    if (BondCount != 0) {
+      NoCyclicBonds = 0;
+      *out << Verbose(1) << "Correcting Bond degree of each bond ... ";
+      do {
+        No = 0; // No acts as breakup flag (if 1 we still continue)
+        Walker = start;
+        while (Walker->next != end) { // go through every atom
+          Walker = Walker->next;
+          // count valence of first partner
+          NoBonds = 0;
+          for(j=0;j<NumberOfBondsPerAtom[Walker->nr];j++)
+            NoBonds += ListOfBondsPerAtom[Walker->nr][j]->BondDegree;
+          *out << Verbose(3) << "Walker " << *Walker << ": " << (int)Walker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+          if ((int)(Walker->type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
+            Candidate = NULL;
+            CandidateBondNo = -1;
+            for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) { // go through each of its bond partners
+              OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+              // count valence of second partner
+              NoBonds = 0;
+              for(j=0;j<NumberOfBondsPerAtom[OtherWalker->nr];j++)
+                NoBonds += ListOfBondsPerAtom[OtherWalker->nr][j]->BondDegree;
+              *out << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+              if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
+                if ((Candidate == NULL) || (NumberOfBondsPerAtom[Candidate->nr] > NumberOfBondsPerAtom[OtherWalker->nr])) { // pick the one with fewer number of bonds first
+                  Candidate = OtherWalker;
+                  CandidateBondNo = i;
+                  *out << Verbose(3) << "New candidate is " << *Candidate << "." << endl;
+                }
+              }
+            }
+            if ((Candidate != NULL) && (CandidateBondNo != -1)) {
+              ListOfBondsPerAtom[Walker->nr][CandidateBondNo]->BondDegree++;
+              *out << Verbose(2) << "Increased bond degree for bond " << *ListOfBondsPerAtom[Walker->nr][CandidateBondNo] << "." << endl;
+            } else
+              *out << Verbose(2) << "Could not find correct degree for atom " << *Walker << "." << endl;
+              FalseBondDegree++;
+          }
+        }
+      } while (No);
+    *out << " done." << endl;
+    } else
+      *out << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl;
+    *out << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << bonddistance << ", " << FalseBondDegree << " bonds could not be corrected." << endl;
+    // output bonds for debugging (if bond chain list was correctly installed)
+    *out << Verbose(1) << endl << "From contents of bond chain list:";
+    bond *Binder = first;
+    while(Binder->next != last) {
+      Binder = Binder->next;
+      *out << *Binder << "\t" << endl;
+    }
+    *out << endl;
+  } else
+    *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
+  *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
+  Free((void **)&matrix, "molecule::CreateAdjacencyList: *matrix");
 };
 …
 MoleculeLeafClass * molecule::DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack)
+{
         class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
         BackEdgeStack = new StackClass<bond *> (BondCount);
         MoleculeLeafClass *SubGraphs = new MoleculeLeafClass(NULL);
         MoleculeLeafClass *LeafWalker = SubGraphs;
         int CurrentGraphNr = 0, OldGraphNr;
         int ComponentNumber = 0;
         atom *Walker = NULL, *OtherAtom = NULL, *Root = start->next;
         bond *Binder = NULL;
         bool BackStepping = false;
         *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
         ResetAllBondsToUnused();
         ResetAllAtomNumbers();
         InitComponentNumbers();
         BackEdgeStack->ClearStack();
         while (Root != end) { // if there any atoms at all
                 // (1) mark all edges unused, empty stack, set atom->GraphNr = 0 for all
                 AtomStack->ClearStack();
                 // put into new subgraph molecule and add this to list of subgraphs
                 LeafWalker = new MoleculeLeafClass(LeafWalker);
                 LeafWalker->Leaf = new molecule(elemente);
                 LeafWalker->Leaf->AddCopyAtom(Root);
                 OldGraphNr = CurrentGraphNr;
                 Walker = Root;
                 do { // (10)
                         do { // (2) set number and Lowpoint of Atom to i, increase i, push current atom
                                 if (!BackStepping) { // if we don't just return from (8)
                                         Walker->GraphNr = CurrentGraphNr;
                                         Walker->LowpointNr = CurrentGraphNr;
                                         *out << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
                                         AtomStack->Push(Walker);
                                         CurrentGraphNr++;
+                                }
                                 do { // (3) if Walker has no unused egdes, go to (5)
                                         BackStepping = false; // reset backstepping flag for (8)
                                         if (Binder == NULL) // if we don't just return from (11), Binder is already set to next unused
                                                 Binder = FindNextUnused(Walker);
                                         if (Binder == NULL)
                                                 break;
                                         *out << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
                                         // (4) Mark Binder used, ...
                                         Binder->MarkUsed(black);
                                         OtherAtom = Binder->GetOtherAtom(Walker);
                                         *out << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
                                         if (OtherAtom->GraphNr != -1) {
                                                 // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
                                                 Binder->Type = BackEdge;
                                                 BackEdgeStack->Push(Binder);
                                                 Walker->LowpointNr = ( Walker->LowpointNr < OtherAtom->GraphNr ) ? Walker->LowpointNr : OtherAtom->GraphNr;
                                                 *out << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
                                         } else {
                                                 // (4b) ... otherwise set OtherAtom as Ancestor of Walker and Walker as OtherAtom, go to (2)
                                                 Binder->Type = TreeEdge;
                                                 OtherAtom->Ancestor = Walker;
                                                 Walker = OtherAtom;
                                                 *out << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
                                                 break;
+                                        }
                                         Binder = NULL;
                                 } while (1);    // (3)
                                 if (Binder == NULL) {
                                         *out << Verbose(2) << "No more Unused Bonds." << endl;
                                         break;
                                 } else
                                         Binder = NULL;
                         } while (1);    // (2)
                         // if we came from backstepping, yet there were no more unused bonds, we end up here with no Ancestor, because Walker is Root! Then we are finished!
                         if ((Walker == Root) && (Binder == NULL))
                                 break;
                         // (5) if Ancestor of Walker is ...
                         *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
                         if (Walker->Ancestor->GraphNr != Root->GraphNr) {
                                 // (6)  (Ancestor of Walker is not Root)
                                 if (Walker->LowpointNr < Walker->Ancestor->GraphNr) {
                                         // (6a) set Ancestor's Lowpoint number to minimum of of its Ancestor and itself, go to Step(8)
                                         Walker->Ancestor->LowpointNr = (Walker->Ancestor->LowpointNr < Walker->LowpointNr) ? Walker->Ancestor->LowpointNr : Walker->LowpointNr;
                                         *out << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
                                 } else {
                                         // (7) (Ancestor of Walker is a separating vertex, remove all from stack till Walker (including), these and Ancestor form a component
                                         Walker->Ancestor->SeparationVertex = true;
                                         *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
                                         SetNextComponentNumber(Walker->Ancestor, ComponentNumber);
                                         *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << ComponentNumber << "." << endl;
                                         SetNextComponentNumber(Walker, ComponentNumber);
                                         *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << ComponentNumber << "." << endl;
                                         do {
                                                 OtherAtom = AtomStack->PopLast();
                                                 LeafWalker->Leaf->AddCopyAtom(OtherAtom);
                                                 SetNextComponentNumber(OtherAtom, ComponentNumber);
                                                 *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
                                         } while (OtherAtom != Walker);
                                         ComponentNumber++;
+                                }
                                 // (8) Walker becomes its Ancestor, go to (3)
                                 *out << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
                                 Walker = Walker->Ancestor;
                                 BackStepping = true;
+                        }
                         if (!BackStepping) {    // coming from (8) want to go to (3)
                                 // (9) remove all from stack till Walker (including), these and Root form a component
                                 AtomStack->Output(out);
                                 SetNextComponentNumber(Root, ComponentNumber);
                                 *out << Verbose(3) << "(9) Root[" << Root->Name << "]'s Component is " << ComponentNumber << "." << endl;
                                 SetNextComponentNumber(Walker, ComponentNumber);
                                 *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << ComponentNumber << "." << endl;
                                 do {
                                         OtherAtom = AtomStack->PopLast();
                                         LeafWalker->Leaf->AddCopyAtom(OtherAtom);
                                         SetNextComponentNumber(OtherAtom, ComponentNumber);
                                         *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
                                 } while (OtherAtom != Walker);
                                 ComponentNumber++;
                                 // (11) Root is separation vertex,      set Walker to Root and go to (4)
                                 Walker = Root;
                                 Binder = FindNextUnused(Walker);
                                 *out << Verbose(1) << "(10) Walker is Root[" << Root->Name << "], next Unused Bond is " << Binder << "." << endl;
                                 if (Binder != NULL) { // Root is separation vertex
                                         *out << Verbose(1) << "(11) Root is a separation vertex." << endl;
                                         Walker->SeparationVertex = true;
+                                }
+                        }
                 } while ((BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
                 // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
                 *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;
                 LeafWalker->Leaf->Output(out);
                 *out << endl;
                 // step on to next root
                 while ((Root != end) && (Root->GraphNr != -1)) {
                         //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
                         if (Root->GraphNr != -1) // if already discovered, step on
                                 Root = Root->next;
+                }
+        }
         // set cyclic bond criterium on "same LP" basis
         Binder = first;
         while(Binder->next != last) {
                 Binder = Binder->next;
                 if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
                         Binder->Cyclic = true;
                         NoCyclicBonds++;
+                }
+        }
         *out << Verbose(1) << "Final graph info for each atom is:" << endl;
         Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 *out << Verbose(2) << "Atom " << Walker->Name << " is " << ((Walker->SeparationVertex) ? "a" : "not a") << " separation vertex, components are ";
                 OutputComponentNumber(out, Walker);
                 *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
+        }
         *out << Verbose(1) << "Final graph info for each bond is:" << endl;
         Binder = first;
         while(Binder->next != last) {
                 Binder = Binder->next;
                 *out << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
                 *out << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.";
                 OutputComponentNumber(out, Binder->leftatom);
                 *out << " ===   ";
                 *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
                 OutputComponentNumber(out, Binder->rightatom);
                 *out << ">." << endl;
                 if (Binder->Cyclic) // cyclic ??
                         *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
+        }
         // free all and exit
         delete(AtomStack);
         *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
         return SubGraphs;
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  BackEdgeStack = new StackClass<bond *> (BondCount);
+  MoleculeLeafClass *SubGraphs = new MoleculeLeafClass(NULL);
+  MoleculeLeafClass *LeafWalker = SubGraphs;
+  int CurrentGraphNr = 0, OldGraphNr;
+  int ComponentNumber = 0;
+  atom *Walker = NULL, *OtherAtom = NULL, *Root = start->next;
+  bond *Binder = NULL;
+  bool BackStepping = false;
+  *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
+  ResetAllBondsToUnused();
+  ResetAllAtomNumbers();
+  InitComponentNumbers();
+  BackEdgeStack->ClearStack();
+  while (Root != end) { // if there any atoms at all
+    // (1) mark all edges unused, empty stack, set atom->GraphNr = 0 for all
+    AtomStack->ClearStack();
+    // put into new subgraph molecule and add this to list of subgraphs
+    LeafWalker = new MoleculeLeafClass(LeafWalker);
+    LeafWalker->Leaf = new molecule(elemente);
+    LeafWalker->Leaf->AddCopyAtom(Root);
+    OldGraphNr = CurrentGraphNr;
+    Walker = Root;
+    do { // (10)
+      do { // (2) set number and Lowpoint of Atom to i, increase i, push current atom
+        if (!BackStepping) { // if we don't just return from (8)
+          Walker->GraphNr = CurrentGraphNr;
+          Walker->LowpointNr = CurrentGraphNr;
+          *out << Verbose(1) << "Setting Walker[" << Walker->Name << "]'s number to " << Walker->GraphNr << " with Lowpoint " << Walker->LowpointNr << "." << endl;
+          AtomStack->Push(Walker);
+          CurrentGraphNr++;
+        }
+        do { // (3) if Walker has no unused egdes, go to (5)
+          BackStepping = false; // reset backstepping flag for (8)
+          if (Binder == NULL) // if we don't just return from (11), Binder is already set to next unused
+            Binder = FindNextUnused(Walker);
+          if (Binder == NULL)
+            break;
+          *out << Verbose(2) << "Current Unused Bond is " << *Binder << "." << endl;
+          // (4) Mark Binder used, ...
+          Binder->MarkUsed(black);
+          OtherAtom = Binder->GetOtherAtom(Walker);
+          *out << Verbose(2) << "(4) OtherAtom is " << OtherAtom->Name << "." << endl;
+          if (OtherAtom->GraphNr != -1) {
+            // (4a) ... if "other" atom has been visited (GraphNr != 0), set lowpoint to minimum of both, go to (3)
+            Binder->Type = BackEdge;
+            BackEdgeStack->Push(Binder);
+            Walker->LowpointNr = ( Walker->LowpointNr < OtherAtom->GraphNr ) ? Walker->LowpointNr : OtherAtom->GraphNr;
+            *out << Verbose(3) << "(4a) Visited: Setting Lowpoint of Walker[" << Walker->Name << "] to " << Walker->LowpointNr << "." << endl;
+          } else {
+            // (4b) ... otherwise set OtherAtom as Ancestor of Walker and Walker as OtherAtom, go to (2)
+            Binder->Type = TreeEdge;
+            OtherAtom->Ancestor = Walker;
+            Walker = OtherAtom;
+            *out << Verbose(3) << "(4b) Not Visited: OtherAtom[" << OtherAtom->Name << "]'s Ancestor is now " << OtherAtom->Ancestor->Name << ", Walker is OtherAtom " << OtherAtom->Name << "." << endl;
+            break;
+          }
+          Binder = NULL;
+        } while (1);  // (3)
+        if (Binder == NULL) {
+          *out << Verbose(2) << "No more Unused Bonds." << endl;
+          break;
+        } else
+          Binder = NULL;
+      } while (1);  // (2)
+      // if we came from backstepping, yet there were no more unused bonds, we end up here with no Ancestor, because Walker is Root! Then we are finished!
+      if ((Walker == Root) && (Binder == NULL))
+        break;
+      // (5) if Ancestor of Walker is ...
+      *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
+      if (Walker->Ancestor->GraphNr != Root->GraphNr) {
+        // (6)  (Ancestor of Walker is not Root)
+        if (Walker->LowpointNr < Walker->Ancestor->GraphNr) {
+          // (6a) set Ancestor's Lowpoint number to minimum of of its Ancestor and itself, go to Step(8)
+          Walker->Ancestor->LowpointNr = (Walker->Ancestor->LowpointNr < Walker->LowpointNr) ? Walker->Ancestor->LowpointNr : Walker->LowpointNr;
+          *out << Verbose(2) << "(6) Setting Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s Lowpoint to " << Walker->Ancestor->LowpointNr << "." << endl;
+        } else {
+          // (7) (Ancestor of Walker is a separating vertex, remove all from stack till Walker (including), these and Ancestor form a component
+          Walker->Ancestor->SeparationVertex = true;
+          *out << Verbose(2) << "(7) Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "]'s is a separating vertex, creating component." << endl;
+          SetNextComponentNumber(Walker->Ancestor, ComponentNumber);
+          *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Ancestor's Compont is " << ComponentNumber << "." << endl;
+          SetNextComponentNumber(Walker, ComponentNumber);
+          *out << Verbose(3) << "(7) Walker[" << Walker->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+          do {
+            OtherAtom = AtomStack->PopLast();
+            LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+            SetNextComponentNumber(OtherAtom, ComponentNumber);
+            *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+          } while (OtherAtom != Walker);
+          ComponentNumber++;
+        }
+        // (8) Walker becomes its Ancestor, go to (3)
+        *out << Verbose(2) << "(8) Walker[" << Walker->Name << "] is now its Ancestor " << Walker->Ancestor->Name << ", backstepping. " << endl;
+        Walker = Walker->Ancestor;
+        BackStepping = true;
+      }
+      if (!BackStepping) {  // coming from (8) want to go to (3)
+        // (9) remove all from stack till Walker (including), these and Root form a component
+        AtomStack->Output(out);
+        SetNextComponentNumber(Root, ComponentNumber);
+        *out << Verbose(3) << "(9) Root[" << Root->Name << "]'s Component is " << ComponentNumber << "." << endl;
+        SetNextComponentNumber(Walker, ComponentNumber);
+        *out << Verbose(3) << "(9) Walker[" << Walker->Name << "]'s Component is " << ComponentNumber << "." << endl;
+        do {
+          OtherAtom = AtomStack->PopLast();
+          LeafWalker->Leaf->AddCopyAtom(OtherAtom);
+          SetNextComponentNumber(OtherAtom, ComponentNumber);
+          *out << Verbose(3) << "(7) Other[" << OtherAtom->Name << "]'s Compont is " << ComponentNumber << "." << endl;
+        } while (OtherAtom != Walker);
+        ComponentNumber++;
+        // (11) Root is separation vertex,  set Walker to Root and go to (4)
+        Walker = Root;
+        Binder = FindNextUnused(Walker);
+        *out << Verbose(1) << "(10) Walker is Root[" << Root->Name << "], next Unused Bond is " << Binder << "." << endl;
+        if (Binder != NULL) { // Root is separation vertex
+          *out << Verbose(1) << "(11) Root is a separation vertex." << endl;
+          Walker->SeparationVertex = true;
+        }
+      }
+    } while ((BackStepping) || (Binder != NULL)); // (10) halt only if Root has no unused edges
+    // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
+    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;
+    LeafWalker->Leaf->Output(out);
+    *out << endl;
+    // step on to next root
+    while ((Root != end) && (Root->GraphNr != -1)) {
+      //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
+      if (Root->GraphNr != -1) // if already discovered, step on
+        Root = Root->next;
+    }
+  }
+  // set cyclic bond criterium on "same LP" basis
+  Binder = first;
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
+      Binder->Cyclic = true;
+      NoCyclicBonds++;
+    }
+  }
+  *out << Verbose(1) << "Final graph info for each atom is:" << endl;
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    *out << Verbose(2) << "Atom " << Walker->Name << " is " << ((Walker->SeparationVertex) ? "a" : "not a") << " separation vertex, components are ";
+    OutputComponentNumber(out, Walker);
+    *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
+  }
+  *out << Verbose(1) << "Final graph info for each bond is:" << endl;
+  Binder = first;
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    *out << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <";
+    *out << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.";
+    OutputComponentNumber(out, Binder->leftatom);
+    *out << " ===  ";
+    *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
+    OutputComponentNumber(out, Binder->rightatom);
+    *out << ">." << endl;
+    if (Binder->Cyclic) // cyclic ??
+      *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
+  }
+  // free all and exit
+  delete(AtomStack);
+  *out << Verbose(0) << "End of DepthFirstSearchAnalysis" << endl;
+  return SubGraphs;
 };
 …
  * \todo BFS from the not-same-LP to find back to starting point of tributary cycle over more than one bond
  */
 void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *        BackEdgeStack, int *&MinimumRingSize)
+{
         atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
         int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
         enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
         class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);         // will hold the current ring
         class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);     // contains all "touched" atoms (that need to be reset after BFS loop)
         atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL;
         bond *Binder = NULL, *BackEdge = NULL;
         int RingSize, NumCycles, MinRingSize = -1;
         // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
         for (int i=AtomCount;i--;) {
                 PredecessorList[i] = NULL;
                 ShortestPathList[i] = -1;
                 ColorList[i] = white;
+        }
         *out << Verbose(1) << "Back edge list - ";
         BackEdgeStack->Output(out);
         *out << Verbose(1) << "Analysing cycles ... " << endl;
         NumCycles = 0;
         while (!BackEdgeStack->IsEmpty()) {
                 BackEdge = BackEdgeStack->PopFirst();
                 // this is the target
                 Root = BackEdge->leftatom;
                 // this is the source point
                 Walker = BackEdge->rightatom;
                 ShortestPathList[Walker->nr] = 0;
                 BFSStack->ClearStack(); // start with empty BFS stack
                 BFSStack->Push(Walker);
                 TouchedStack->Push(Walker);
                 *out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
                 OtherAtom = NULL;
                 do {    // look for Root
                         Walker = BFSStack->PopFirst();
                         *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
                         for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
                                 Binder = ListOfBondsPerAtom[Walker->nr][i];
                                 if (Binder != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
                                         OtherAtom = Binder->GetOtherAtom(Walker);
+void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *  BackEdgeStack, int *&MinimumRingSize)
+{
+  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
+  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
+  enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
+  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
+  class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
+  atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL;
+  bond *Binder = NULL, *BackEdge = NULL;
+  int RingSize, NumCycles, MinRingSize = -1;
+  // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
+  for (int i=AtomCount;i--;) {
+    PredecessorList[i] = NULL;
+    ShortestPathList[i] = -1;
+    ColorList[i] = white;
+  }
+  *out << Verbose(1) << "Back edge list - ";
+  BackEdgeStack->Output(out);
+  *out << Verbose(1) << "Analysing cycles ... " << endl;
+  NumCycles = 0;
+  while (!BackEdgeStack->IsEmpty()) {
+    BackEdge = BackEdgeStack->PopFirst();
+    // this is the target
+    Root = BackEdge->leftatom;
+    // this is the source point
+    Walker = BackEdge->rightatom;
+    ShortestPathList[Walker->nr] = 0;
+    BFSStack->ClearStack();  // start with empty BFS stack
+    BFSStack->Push(Walker);
+    TouchedStack->Push(Walker);
+    *out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+    OtherAtom = NULL;
+    do {  // look for Root
+      Walker = BFSStack->PopFirst();
+      *out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+        Binder = ListOfBondsPerAtom[Walker->nr][i];
+        if (Binder != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
+          OtherAtom = Binder->GetOtherAtom(Walker);
 #ifdef ADDHYDROGEN
                                         if (OtherAtom->type->Z != 1) {
+          if (OtherAtom->type->Z != 1) {
 #endif
                                                 *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
                                                 if (ColorList[OtherAtom->nr] == white) {
                                                         TouchedStack->Push(OtherAtom);
                                                         ColorList[OtherAtom->nr] = lightgray;
                                                         PredecessorList[OtherAtom->nr] = Walker;        // Walker is the predecessor
                                                         ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
                                                         *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
                                                         //if (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
                                                                 *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
                                                                 BFSStack->Push(OtherAtom);
                                                         //}
                                                 } else {
                                                         *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+                                                }
                                                 if (OtherAtom == Root)
                                                         break;
+            *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+            if (ColorList[OtherAtom->nr] == white) {
+              TouchedStack->Push(OtherAtom);
+              ColorList[OtherAtom->nr] = lightgray;
+              PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+              ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+              *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+              //if (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
+                *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
+                BFSStack->Push(OtherAtom);
+              //}
+            } else {
+              *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+            }
+            if (OtherAtom == Root)
+              break;
 #ifdef ADDHYDROGEN
                                         } else {
                                                 *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
                                                 ColorList[OtherAtom->nr] = black;
+                                        }
+          } else {
+            *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
+            ColorList[OtherAtom->nr] = black;
+          }
 #endif
                                 } else {
                                         *out << Verbose(2) << "Bond " << *Binder << " not Visiting, is the back edge." << endl;
+                                }
+                        }
                         ColorList[Walker->nr] = black;
                         *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
                         if (OtherAtom == Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
                                 // step through predecessor list
                                 while (OtherAtom != BackEdge->rightatom) {
                                         if (!OtherAtom->GetTrueFather()->IsCyclic)      // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
                                                 break;
                                         else
                                                 OtherAtom = PredecessorList[OtherAtom->nr];
+                                }
                                 if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
                                         *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;\
                                         do {
                                                 OtherAtom = TouchedStack->PopLast();
                                                 if (PredecessorList[OtherAtom->nr] == Walker) {
                                                         *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
                                                         PredecessorList[OtherAtom->nr] = NULL;
                                                         ShortestPathList[OtherAtom->nr] = -1;
                                                         ColorList[OtherAtom->nr] = white;
                                                         BFSStack->RemoveItem(OtherAtom);
+                                                }
                                         } while ((!TouchedStack->IsEmpty()) && (PredecessorList[OtherAtom->nr] == NULL));
                                         TouchedStack->Push(OtherAtom);  // last was wrongly popped
                                         OtherAtom = BackEdge->rightatom; // set to not Root
                                 } else
                                         OtherAtom = Root;
+                        }
                 } while ((!BFSStack->IsEmpty()) && (OtherAtom != Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
                 if (OtherAtom == Root) {
                         // now climb back the predecessor list and thus find the cycle members
                         NumCycles++;
                         RingSize = 1;
                         Root->GetTrueFather()->IsCyclic = true;
                         *out << Verbose(1) << "Found ring contains: ";
                         Walker = Root;
                         while (Walker != BackEdge->rightatom) {
                                 *out << Walker->Name << " <-> ";
                                 Walker = PredecessorList[Walker->nr];
                                 Walker->GetTrueFather()->IsCyclic = true;
                                 RingSize++;
+                        }
                         *out << Walker->Name << "       with a length of " << RingSize << "." << endl << endl;
                         // walk through all and set MinimumRingSize
                         Walker = Root;
                         MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
                         while (Walker != BackEdge->rightatom) {
                                 Walker = PredecessorList[Walker->nr];
                                 if (RingSize < MinimumRingSize[Walker->GetTrueFather()->nr])
                                         MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+                        }
                         if ((RingSize < MinRingSize) || (MinRingSize == -1))
                                 MinRingSize = RingSize;
                 } else {
                         *out << Verbose(1) << "No ring containing " << *Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+                }
                 // now clean the lists
                 while (!TouchedStack->IsEmpty()){
                         Walker = TouchedStack->PopFirst();
                         PredecessorList[Walker->nr] = NULL;
                         ShortestPathList[Walker->nr] = -1;
                         ColorList[Walker->nr] = white;
+                }
+        }
         if (MinRingSize != -1) {
                 // go over all atoms
                 Root = start;
                 while(Root->next != end) {
                         Root = Root->next;
                         if (MinimumRingSize[Root->GetTrueFather()->nr] == AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
                                 Walker = Root;
                                 ShortestPathList[Walker->nr] = 0;
                                 BFSStack->ClearStack(); // start with empty BFS stack
                                 BFSStack->Push(Walker);
                                 TouchedStack->Push(Walker);
                                 //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
                                 OtherAtom = Walker;
                                 while (OtherAtom != NULL) {     // look for Root
                                         Walker = BFSStack->PopFirst();
                                         //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
                                         for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
                                                 Binder = ListOfBondsPerAtom[Walker->nr][i];
                                                 if ((Binder != BackEdge) || (NumberOfBondsPerAtom[Walker->nr] == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
                                                         OtherAtom = Binder->GetOtherAtom(Walker);
                                                         //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
                                                         if (ColorList[OtherAtom->nr] == white) {
                                                                 TouchedStack->Push(OtherAtom);
                                                                 ColorList[OtherAtom->nr] = lightgray;
                                                                 PredecessorList[OtherAtom->nr] = Walker;        // Walker is the predecessor
                                                                 ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
                                                                 //*out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
                                                                 if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
                                                                         MinimumRingSize[Root->GetTrueFather()->nr] = ShortestPathList[OtherAtom->nr]+MinimumRingSize[OtherAtom->GetTrueFather()->nr];
                                                                         OtherAtom = NULL; //break;
                                                                         break;
                                                                 } else
                                                                         BFSStack->Push(OtherAtom);
                                                         } else {
                                                                 //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
+                                                        }
                                                 } else {
                                                         //*out << Verbose(3) << "Not Visiting, is a back edge." << endl;
+                                                }
+                                        }
                                         ColorList[Walker->nr] = black;
                                         //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+                                }
                                 // now clean the lists
                                 while (!TouchedStack->IsEmpty()){
                                         Walker = TouchedStack->PopFirst();
                                         PredecessorList[Walker->nr] = NULL;
                                         ShortestPathList[Walker->nr] = -1;
                                         ColorList[Walker->nr] = white;
+                                }
+                        }
                         *out << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
+                }
                 *out << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
         } else
                 *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
         Free((void **)&PredecessorList, "molecule::CyclicStructureAnalysis: **PredecessorList");
         Free((void **)&ShortestPathList, "molecule::CyclicStructureAnalysis: **ShortestPathList");
         Free((void **)&ColorList, "molecule::CyclicStructureAnalysis: **ColorList");
         delete(BFSStack);
+        } else {
+          *out << Verbose(2) << "Bond " << *Binder << " not Visiting, is the back edge." << endl;
+        }
+      }
+      ColorList[Walker->nr] = black;
+      *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+      if (OtherAtom == Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
+        // step through predecessor list
+        while (OtherAtom != BackEdge->rightatom) {
+          if (!OtherAtom->GetTrueFather()->IsCyclic)  // if one bond in the loop is not marked as cyclic, we haven't found this cycle yet
+            break;
+          else
+            OtherAtom = PredecessorList[OtherAtom->nr];
+        }
+        if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
+          *out << Verbose(3) << "This cycle was already found before, skipping and removing seeker from search." << endl;\
+          do {
+            OtherAtom = TouchedStack->PopLast();
+            if (PredecessorList[OtherAtom->nr] == Walker) {
+              *out << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl;
+              PredecessorList[OtherAtom->nr] = NULL;
+              ShortestPathList[OtherAtom->nr] = -1;
+              ColorList[OtherAtom->nr] = white;
+              BFSStack->RemoveItem(OtherAtom);
+            }
+          } while ((!TouchedStack->IsEmpty()) && (PredecessorList[OtherAtom->nr] == NULL));
+          TouchedStack->Push(OtherAtom);  // last was wrongly popped
+          OtherAtom = BackEdge->rightatom; // set to not Root
+        } else
+          OtherAtom = Root;
+      }
+    } while ((!BFSStack->IsEmpty()) && (OtherAtom != Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
+    if (OtherAtom == Root) {
+      // now climb back the predecessor list and thus find the cycle members
+      NumCycles++;
+      RingSize = 1;
+      Root->GetTrueFather()->IsCyclic = true;
+      *out << Verbose(1) << "Found ring contains: ";
+      Walker = Root;
+      while (Walker != BackEdge->rightatom) {
+        *out << Walker->Name << " <-> ";
+        Walker = PredecessorList[Walker->nr];
+        Walker->GetTrueFather()->IsCyclic = true;
+        RingSize++;
+      }
+      *out << Walker->Name << "  with a length of " << RingSize << "." << endl << endl;
+      // walk through all and set MinimumRingSize
+      Walker = Root;
+      MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+      while (Walker != BackEdge->rightatom) {
+        Walker = PredecessorList[Walker->nr];
+        if (RingSize < MinimumRingSize[Walker->GetTrueFather()->nr])
+          MinimumRingSize[Walker->GetTrueFather()->nr] = RingSize;
+      }
+      if ((RingSize < MinRingSize) || (MinRingSize == -1))
+        MinRingSize = RingSize;
+    } else {
+      *out << Verbose(1) << "No ring containing " << *Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
+    }
+    // now clean the lists
+    while (!TouchedStack->IsEmpty()){
+      Walker = TouchedStack->PopFirst();
+      PredecessorList[Walker->nr] = NULL;
+      ShortestPathList[Walker->nr] = -1;
+      ColorList[Walker->nr] = white;
+    }
+  }
+  if (MinRingSize != -1) {
+    // go over all atoms
+    Root = start;
+    while(Root->next != end) {
+      Root = Root->next;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
+        Walker = Root;
+        ShortestPathList[Walker->nr] = 0;
+        BFSStack->ClearStack();  // start with empty BFS stack
+        BFSStack->Push(Walker);
+        TouchedStack->Push(Walker);
+        //*out << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
+        OtherAtom = Walker;
+        while (OtherAtom != NULL) {  // look for Root
+          Walker = BFSStack->PopFirst();
+          //*out << Verbose(2) << "Current Walker is " << *Walker << ", we look for SP to Root " << *Root << "." << endl;
+          for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+            Binder = ListOfBondsPerAtom[Walker->nr][i];
+            if ((Binder != BackEdge) || (NumberOfBondsPerAtom[Walker->nr] == 1)) { // only walk along DFS spanning tree (otherwise we always find SP of 1 being backedge Binder), but terminal hydrogens may be connected via backedge, hence extra check
+              OtherAtom = Binder->GetOtherAtom(Walker);
+              //*out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+              if (ColorList[OtherAtom->nr] == white) {
+                TouchedStack->Push(OtherAtom);
+                ColorList[OtherAtom->nr] = lightgray;
+                PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+                ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+                //*out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+                if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
+                  MinimumRingSize[Root->GetTrueFather()->nr] = ShortestPathList[OtherAtom->nr]+MinimumRingSize[OtherAtom->GetTrueFather()->nr];
+                  OtherAtom = NULL; //break;
+                  break;
+                } else
+                  BFSStack->Push(OtherAtom);
+              } else {
+                //*out << Verbose(3) << "Not Adding, has already been visited." << endl;
+              }
+            } else {
+              //*out << Verbose(3) << "Not Visiting, is a back edge." << endl;
+            }
+          }
+          ColorList[Walker->nr] = black;
+          //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+        }
+        // now clean the lists
+        while (!TouchedStack->IsEmpty()){
+          Walker = TouchedStack->PopFirst();
+          PredecessorList[Walker->nr] = NULL;
+          ShortestPathList[Walker->nr] = -1;
+          ColorList[Walker->nr] = white;
+        }
+      }
+      *out << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->nr] << "." << endl;
+    }
+    *out << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl;
+  } else
+    *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
+  Free((void **)&PredecessorList, "molecule::CyclicStructureAnalysis: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::CyclicStructureAnalysis: **ShortestPathList");
+  Free((void **)&ColorList, "molecule::CyclicStructureAnalysis: **ColorList");
+  delete(BFSStack);
 };
 …
 void molecule::SetNextComponentNumber(atom *vertex, int nr)
+{
         int i=0;
         if (vertex != NULL) {
                 for(;i<NumberOfBondsPerAtom[vertex->nr];i++) {
                         if (vertex->ComponentNr[i] == -1) {      // check if not yet used
                                 vertex->ComponentNr[i] = nr;
                                 break;
+                        }
                         else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
                                 break;  // breaking here will not cause error!
+                }
                 if (i == NumberOfBondsPerAtom[vertex->nr])
                         cerr << "Error: All Component entries are already occupied!" << endl;
         } else
                         cerr << "Error: Given vertex is NULL!" << endl;
+  int i=0;
+  if (vertex != NULL) {
+    for(;i<NumberOfBondsPerAtom[vertex->nr];i++) {
+      if (vertex->ComponentNr[i] == -1) {   // check if not yet used
+        vertex->ComponentNr[i] = nr;
+        break;
+      }
+      else if (vertex->ComponentNr[i] == nr) // if number is already present, don't add another time
+        break;  // breaking here will not cause error!
+    }
+    if (i == NumberOfBondsPerAtom[vertex->nr])
+      cerr << "Error: All Component entries are already occupied!" << endl;
+  } else
+      cerr << "Error: Given vertex is NULL!" << endl;
 };
 …
 void molecule::OutputComponentNumber(ofstream *out, atom *vertex)
+{
         for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
                 *out << vertex->ComponentNr[i] << "     ";
+  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
+    *out << vertex->ComponentNr[i] << "  ";
 };
 …
 void molecule::InitComponentNumbers()
+{
         atom *Walker = start;
         while(Walker->next != end) {
                 Walker = Walker->next;
                 if (Walker->ComponentNr != NULL)
                         Free((void **)&Walker->ComponentNr, "molecule::InitComponentNumbers: **Walker->ComponentNr");
                 Walker->ComponentNr = (int *) Malloc(sizeof(int)*NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
                 for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
                         Walker->ComponentNr[i] = -1;
+        }
+  atom *Walker = start;
+  while(Walker->next != end) {
+    Walker = Walker->next;
+    if (Walker->ComponentNr != NULL)
+      Free((void **)&Walker->ComponentNr, "molecule::InitComponentNumbers: **Walker->ComponentNr");
+    Walker->ComponentNr = (int *) Malloc(sizeof(int)*NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
+    for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
+      Walker->ComponentNr[i] = -1;
+  }
 };
 …
 bond * molecule::FindNextUnused(atom *vertex)
+{
         for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
                 if (ListOfBondsPerAtom[vertex->nr][i]->IsUsed() == white)
                         return(ListOfBondsPerAtom[vertex->nr][i]);
         return NULL;
+  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
+    if (ListOfBondsPerAtom[vertex->nr][i]->IsUsed() == white)
+      return(ListOfBondsPerAtom[vertex->nr][i]);
+  return NULL;
 };
 …
 void molecule::ResetAllBondsToUnused()
+{
         bond *Binder = first;
         while (Binder->next != last) {
                 Binder = Binder->next;
                 Binder->ResetUsed();
+        }
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    Binder->ResetUsed();
+  }
 };
 …
 void molecule::ResetAllAtomNumbers()
+{
         atom *Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 Walker->GraphNr = -1;
+        }
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->GraphNr  = -1;
+  }
 };
 …
 void OutputAlreadyVisited(ofstream *out, int *list)
+{
         *out << Verbose(4) << "Already Visited Bonds:\t";
         for(int i=1;i<=list[0];i++) *out << Verbose(0) << list[i] << "  ";
         *out << endl;
+  *out << Verbose(4) << "Already Visited Bonds:\t";
+  for(int i=1;i<=list[0];i++) *out << Verbose(0) << list[i] << "  ";
+  *out << endl;
 };
 …
  * The upper limit is
  * \f[
  *      n = N \cdot C^k
+ *  n = N \cdot C^k
  * \f]
  * where \f$C=2^c\f$ and c is the maximum bond degree over N number of atoms.
 …
 int molecule::GuesstimateFragmentCount(ofstream *out, int order)
+{
         int c = 0;
         int FragmentCount;
         // get maximum bond degree
         atom *Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 c = (NumberOfBondsPerAtom[Walker->nr] > c) ? NumberOfBondsPerAtom[Walker->nr] : c;
+        }
         FragmentCount = NoNonHydrogen*(1 << (c*order));
         *out << Verbose(1) << "Upper limit for this subgraph is " << FragmentCount << " for " << NoNonHydrogen << " non-H atoms with maximum bond degree of " << c << "." << endl;
         return FragmentCount;
+  int c = 0;
+  int FragmentCount;
+  // get maximum bond degree
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    c = (NumberOfBondsPerAtom[Walker->nr] > c) ? NumberOfBondsPerAtom[Walker->nr] : c;
+  }
+  FragmentCount = NoNonHydrogen*(1 << (c*order));
+  *out << Verbose(1) << "Upper limit for this subgraph is " << FragmentCount << " for " << NoNonHydrogen << " non-H atoms with maximum bond degree of " << c << "." << endl;
+  return FragmentCount;
 };
 …
 bool molecule::ScanBufferIntoKeySet(ofstream *out, char *buffer, KeySet &CurrentSet)
+{
         stringstream line;
         int AtomNr;
         int status = 0;
         line.str(buffer);
         while (!line.eof()) {
                 line >> AtomNr;
                 if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
                         CurrentSet.insert(AtomNr);      // insert at end, hence in same order as in file!
                         status++;
                 } // else it's "-1" or else and thus must not be added
+        }
         *out << Verbose(1) << "The scanned KeySet is ";
         for(KeySet::iterator runner = CurrentSet.begin(); runner != CurrentSet.end(); runner++) {
                 *out << (*runner) << "\t";
+        }
         *out << endl;
         return (status != 0);
+  stringstream line;
+  int AtomNr;
+  int status = 0;
+  line.str(buffer);
+  while (!line.eof()) {
+    line >> AtomNr;
+    if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+      CurrentSet.insert(AtomNr);  // insert at end, hence in same order as in file!
+      status++;
+    } // else it's "-1" or else and thus must not be added
+  }
+  *out << Verbose(1) << "The scanned KeySet is ";
+  for(KeySet::iterator runner = CurrentSet.begin(); runner != CurrentSet.end(); runner++) {
+    *out << (*runner) << "\t";
+  }
+  *out << endl;
+  return (status != 0);
 };
 …
 bool molecule::ParseKeySetFile(ofstream *out, char *path, Graph *&FragmentList)
+{
         bool status = true;
         ifstream InputFile;
         stringstream line;
         GraphTestPair testGraphInsert;
         int NumberOfFragments = 0;
         double TEFactor;
         char *filename = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
         if (FragmentList == NULL) { // check list pointer
                 FragmentList = new Graph;
+        }
         // 1st pass: open file and read
         *out << Verbose(1) << "Parsing the KeySet file ... " << endl;
         sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, KEYSETFILE);
         InputFile.open(filename);
         if (InputFile != NULL) {
                 // each line represents a new fragment
                 char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
                 // 1. parse keysets and insert into temp. graph
                 while (!InputFile.eof()) {
                         InputFile.getline(buffer, MAXSTRINGSIZE);
                         KeySet CurrentSet;
                         if ((strlen(buffer) > 0) && (ScanBufferIntoKeySet(out, buffer, CurrentSet))) {  // if at least one valid atom was added, write config
                                 testGraphInsert = FragmentList->insert(GraphPair (CurrentSet,pair<int,double>(NumberOfFragments++,1))); // store fragment number and current factor
                                 if (!testGraphInsert.second) {
                                         cerr << "KeySet file must be corrupt as there are two equal key sets therein!" << endl;
+                                }
+                        }
+                }
                 // 2. Free and done
                 InputFile.close();
                 InputFile.clear();
                 Free((void **)&buffer, "molecule::ParseKeySetFile - *buffer");
                 *out << Verbose(1) << "done." << endl;
         } else {
                 *out << Verbose(1) << "File " << filename << " not found." << endl;
                 status = false;
+        }
         // 2nd pass: open TEFactors file and read
         *out << Verbose(1) << "Parsing the TEFactors file ... " << endl;
         sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, TEFACTORSFILE);
         InputFile.open(filename);
         if (InputFile != NULL) {
                 // 3. add found TEFactors to each keyset
                 NumberOfFragments = 0;
                 for(Graph::iterator runner = FragmentList->begin();runner != FragmentList->end(); runner++) {
                         if (!InputFile.eof()) {
                                 InputFile >> TEFactor;
                                 (*runner).second.second = TEFactor;
                                 *out << Verbose(2) << "Setting " << ++NumberOfFragments << " fragment's TEFactor to " << (*runner).second.second << "." << endl;
                         } else {
                                 status = false;
                                 break;
+                        }
+                }
                 // 4. Free and done
                 InputFile.close();
                 *out << Verbose(1) << "done." << endl;
         } else {
                 *out << Verbose(1) << "File " << filename << " not found." << endl;
                 status = false;
+        }
         // free memory
         Free((void **)&filename, "molecule::ParseKeySetFile - filename");
         return status;
+  bool status = true;
+  ifstream InputFile;
+  stringstream line;
+  GraphTestPair testGraphInsert;
+  int NumberOfFragments = 0;
+  double TEFactor;
+  char *filename = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
+  if (FragmentList == NULL) { // check list pointer
+    FragmentList = new Graph;
+  }
+  // 1st pass: open file and read
+  *out << Verbose(1) << "Parsing the KeySet file ... " << endl;
+  sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, KEYSETFILE);
+  InputFile.open(filename);
+  if (InputFile != NULL) {
+    // each line represents a new fragment
+    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
+    // 1. parse keysets and insert into temp. graph
+    while (!InputFile.eof()) {
+      InputFile.getline(buffer, MAXSTRINGSIZE);
+      KeySet CurrentSet;
+      if ((strlen(buffer) > 0) && (ScanBufferIntoKeySet(out, buffer, CurrentSet))) {  // if at least one valid atom was added, write config
+        testGraphInsert = FragmentList->insert(GraphPair (CurrentSet,pair<int,double>(NumberOfFragments++,1)));  // store fragment number and current factor
+        if (!testGraphInsert.second) {
+          cerr << "KeySet file must be corrupt as there are two equal key sets therein!" << endl;
+        }
+      }
+    }
+    // 2. Free and done
+    InputFile.close();
+    InputFile.clear();
+    Free((void **)&buffer, "molecule::ParseKeySetFile - *buffer");
+    *out << Verbose(1) << "done." << endl;
+  } else {
+    *out << Verbose(1) << "File " << filename << " not found." << endl;
+    status = false;
+  }
+  // 2nd pass: open TEFactors file and read
+  *out << Verbose(1) << "Parsing the TEFactors file ... " << endl;
+  sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, TEFACTORSFILE);
+  InputFile.open(filename);
+  if (InputFile != NULL) {
+    // 3. add found TEFactors to each keyset
+    NumberOfFragments = 0;
+    for(Graph::iterator runner = FragmentList->begin();runner != FragmentList->end(); runner++) {
+      if (!InputFile.eof()) {
+        InputFile >> TEFactor;
+        (*runner).second.second = TEFactor;
+        *out << Verbose(2) << "Setting " << ++NumberOfFragments << " fragment's TEFactor to " << (*runner).second.second << "." << endl;
+      } else {
+        status = false;
+        break;
+      }
+    }
+    // 4. Free and done
+    InputFile.close();
+    *out << Verbose(1) << "done." << endl;
+  } else {
+    *out << Verbose(1) << "File " << filename << " not found." << endl;
+    status = false;
+  }
+  // free memory
+  Free((void **)&filename, "molecule::ParseKeySetFile - filename");
+  return status;
 };
 …
 bool molecule::StoreKeySetFile(ofstream *out, Graph &KeySetList, char *path)
+{
         ofstream output;
         bool status =   true;
         string line;
         // open KeySet file
         line = path;
         line.append("/");
         line += FRAGMENTPREFIX;
         line += KEYSETFILE;
         output.open(line.c_str(), ios::out);
         *out << Verbose(1) << "Saving key sets of the total graph ... ";
         if(output != NULL) {
                 for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) {
                         for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
                                 if (sprinter != (*runner).first.begin())
                                         output << "\t";
                                 output << *sprinter;
+                        }
                         output << endl;
+                }
                 *out << "done." << endl;
         } else {
                 cerr << "Unable to open " << line << " for writing keysets!" << endl;
                 status = false;
+        }
         output.close();
         output.clear();
         // open TEFactors file
         line = path;
         line.append("/");
         line += FRAGMENTPREFIX;
         line += TEFACTORSFILE;
         output.open(line.c_str(), ios::out);
         *out << Verbose(1) << "Saving TEFactors of the total graph ... ";
         if(output != NULL) {
                 for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++)
                         output << (*runner).second.second << endl;
                 *out << Verbose(1) << "done." << endl;
         } else {
                 *out << Verbose(1) << "failed to open " << line << "." << endl;
                 status = false;
+        }
         output.close();
         return status;
+  ofstream output;
+  bool status =  true;
+  string line;
+  // open KeySet file
+  line = path;
+  line.append("/");
+  line += FRAGMENTPREFIX;
+  line += KEYSETFILE;
+  output.open(line.c_str(), ios::out);
+  *out << Verbose(1) << "Saving key sets of the total graph ... ";
+  if(output != NULL) {
+    for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) {
+      for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
+        if (sprinter != (*runner).first.begin())
+          output << "\t";
+        output << *sprinter;
+      }
+      output << endl;
+    }
+    *out << "done." << endl;
+  } else {
+    cerr << "Unable to open " << line << " for writing keysets!" << endl;
+    status = false;
+  }
+  output.close();
+  output.clear();
+  // open TEFactors file
+  line = path;
+  line.append("/");
+  line += FRAGMENTPREFIX;
+  line += TEFACTORSFILE;
+  output.open(line.c_str(), ios::out);
+  *out << Verbose(1) << "Saving TEFactors of the total graph ... ";
+  if(output != NULL) {
+    for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++)
+      output << (*runner).second.second << endl;
+    *out << Verbose(1) << "done." << endl;
+  } else {
+    *out << Verbose(1) << "failed to open " << line << "." << endl;
+    status = false;
+  }
+  output.close();
+  return status;
 };
 …
 bool molecule::StoreAdjacencyToFile(ofstream *out, char *path)
+{
         ofstream AdjacencyFile;
         atom *Walker = NULL;
         stringstream line;
         bool status = true;
         line << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
         AdjacencyFile.open(line.str().c_str(), ios::out);
         *out << Verbose(1) << "Saving adjacency list ... ";
         if (AdjacencyFile != NULL) {
                 Walker = start;
                 while(Walker->next != end) {
                         Walker = Walker->next;
                         AdjacencyFile << Walker->nr << "\t";
                         for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
                                 AdjacencyFile << ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker)->nr << "\t";
                         AdjacencyFile << endl;
+                }
                 AdjacencyFile.close();
                 *out << Verbose(1) << "done." << endl;
         } else {
                 *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
                 status = false;
+        }
         return status;
+  ofstream AdjacencyFile;
+  atom *Walker = NULL;
+  stringstream line;
+  bool status = true;
+  line << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
+  AdjacencyFile.open(line.str().c_str(), ios::out);
+  *out << Verbose(1) << "Saving adjacency list ... ";
+  if (AdjacencyFile != NULL) {
+    Walker = start;
+    while(Walker->next != end) {
+      Walker = Walker->next;
+      AdjacencyFile << Walker->nr << "\t";
+      for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
+        AdjacencyFile << ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker)->nr << "\t";
+      AdjacencyFile << endl;
+    }
+    AdjacencyFile.close();
+    *out << Verbose(1) << "done." << endl;
+  } else {
+    *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
+    status = false;
+  }
+  return status;
 };
 …
 bool molecule::CheckAdjacencyFileAgainstMolecule(ofstream *out, char *path, atom **ListOfAtoms)
+{
         ifstream File;
         stringstream filename;
         bool status = true;
         char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
         filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
         File.open(filename.str().c_str(), ios::out);
         *out << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
         if (File != NULL) {
                 // allocate storage structure
                 int NonMatchNumber = 0;  // will number of atoms with differing bond structure
                 int *CurrentBonds = (int *) Malloc(sizeof(int)*8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
                 int CurrentBondsOfAtom;
                 // Parse the file line by line and count the bonds
                 while (!File.eof()) {
                         File.getline(buffer, MAXSTRINGSIZE);
                         stringstream line;
                         line.str(buffer);
                         int AtomNr = -1;
                         line >> AtomNr;
                         CurrentBondsOfAtom = -1; // we count one too far due to line end
                         // parse into structure
                         if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
                                 while (!line.eof())
                                         line >> CurrentBonds[ ++CurrentBondsOfAtom ];
                                 // compare against present bonds
                                 //cout << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
                                 if (CurrentBondsOfAtom == NumberOfBondsPerAtom[AtomNr]) {
                                         for(int i=0;i<NumberOfBondsPerAtom[AtomNr];i++) {
                                                 int id = ListOfBondsPerAtom[AtomNr][i]->GetOtherAtom(ListOfAtoms[AtomNr])->nr;
                                                 int j = 0;
                                                 for (;(j<CurrentBondsOfAtom) && (CurrentBonds[j++] != id);); // check against all parsed bonds
                                                 if (CurrentBonds[j-1] != id) { // no match ? Then mark in ListOfAtoms
                                                         ListOfAtoms[AtomNr] = NULL;
                                                         NonMatchNumber++;
                                                         status = false;
                                                         //out << "[" << id << "]\t";
                                                 } else {
                                                         //out << id << "\t";
+                                                }
+                                        }
                                         //out << endl;
                                 } else {
                                         *out << "Number of bonds for Atom " << *ListOfAtoms[AtomNr] << " does not match, parsed " << CurrentBondsOfAtom << " against " << NumberOfBondsPerAtom[AtomNr] << "." << endl;
                                         status = false;
+                                }
+                        }
+                }
                 File.close();
                 File.clear();
                 if (status) { // if equal we parse the KeySetFile
                         *out << Verbose(1) << "done: Equal." << endl;
                         status = true;
                 } else
                         *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
                 Free((void **)&CurrentBonds, "molecule::CheckAdjacencyFileAgainstMolecule - **CurrentBonds");
         } else {
                 *out << Verbose(1) << "Adjacency file not found." << endl;
                 status = false;
+        }
         *out << endl;
         Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
         return status;
+  ifstream File;
+  stringstream filename;
+  bool status = true;
+  char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
+  File.open(filename.str().c_str(), ios::out);
+  *out << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ";
+  if (File != NULL) {
+    // allocate storage structure
+    int NonMatchNumber = 0;   // will number of atoms with differing bond structure
+    int *CurrentBonds = (int *) Malloc(sizeof(int)*8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+    int CurrentBondsOfAtom;
+    // Parse the file line by line and count the bonds
+    while (!File.eof()) {
+      File.getline(buffer, MAXSTRINGSIZE);
+      stringstream line;
+      line.str(buffer);
+      int AtomNr = -1;
+      line >> AtomNr;
+      CurrentBondsOfAtom = -1; // we count one too far due to line end
+      // parse into structure
+      if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
+        while (!line.eof())
+          line >> CurrentBonds[ ++CurrentBondsOfAtom ];
+        // compare against present bonds
+        //cout << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
+        if (CurrentBondsOfAtom == NumberOfBondsPerAtom[AtomNr]) {
+          for(int i=0;i<NumberOfBondsPerAtom[AtomNr];i++) {
+            int id = ListOfBondsPerAtom[AtomNr][i]->GetOtherAtom(ListOfAtoms[AtomNr])->nr;
+            int j = 0;
+            for (;(j<CurrentBondsOfAtom) && (CurrentBonds[j++] != id);); // check against all parsed bonds
+            if (CurrentBonds[j-1] != id) { // no match ? Then mark in ListOfAtoms
+              ListOfAtoms[AtomNr] = NULL;
+              NonMatchNumber++;
+              status = false;
+              //out << "[" << id << "]\t";
+            } else {
+              //out << id << "\t";
+            }
+          }
+          //out << endl;
+        } else {
+          *out << "Number of bonds for Atom " << *ListOfAtoms[AtomNr] << " does not match, parsed " << CurrentBondsOfAtom << " against " << NumberOfBondsPerAtom[AtomNr] << "." << endl;
+          status = false;
+        }
+      }
+    }
+    File.close();
+    File.clear();
+    if (status) { // if equal we parse the KeySetFile
+      *out << Verbose(1) << "done: Equal." << endl;
+      status = true;
+    } else
+      *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
+    Free((void **)&CurrentBonds, "molecule::CheckAdjacencyFileAgainstMolecule - **CurrentBonds");
+  } else {
+    *out << Verbose(1) << "Adjacency file not found." << endl;
+    status = false;
+  }
+  *out << endl;
+  Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  return status;
 };
 …
 bool molecule::CheckOrderAtSite(ofstream *out, bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
+{
         atom *Walker = start;
         bool status = false;
         ifstream InputFile;
         // initialize mask list
         for(int i=AtomCount;i--;)
                 AtomMask[i] = false;
         if (Order < 0) { // adaptive increase of BondOrder per site
                 if (AtomMask[AtomCount] == true)        // break after one step
                         return false;
                 // parse the EnergyPerFragment file
                 char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
                 sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
                 InputFile.open(buffer, ios::in);
                 if ((InputFile != NULL) && (GlobalKeySetList != NULL)) {
                         // transmorph graph keyset list into indexed KeySetList
                         map<int,KeySet> IndexKeySetList;
                         for(Graph::iterator runner = GlobalKeySetList->begin(); runner != GlobalKeySetList->end(); runner++) {
                                 IndexKeySetList.insert( pair<int,KeySet>(runner->second.first,runner->first) );
+                        }
                         int lines = 0;
                         // count the number of lines, i.e. the number of fragments
                         InputFile.getline(buffer, MAXSTRINGSIZE); // skip comment lines
                         InputFile.getline(buffer, MAXSTRINGSIZE);
                         while(!InputFile.eof()) {
                                 InputFile.getline(buffer, MAXSTRINGSIZE);
                                 lines++;
+                        }
                         //*out << Verbose(2) << "Scanned " << lines-1 << " lines." << endl;      // one endline too much
                         InputFile.clear();
                         InputFile.seekg(ios::beg);
                         map<int, pair<double,int> > AdaptiveCriteriaList;       // (Root No., (Value, Order)) !
                         int No, FragOrder;
                         double Value;
                         // each line represents a fragment root (Atom::nr) id and its energy contribution
                         InputFile.getline(buffer, MAXSTRINGSIZE); // skip comment lines
                         InputFile.getline(buffer, MAXSTRINGSIZE);
                         while(!InputFile.eof()) {
                                 InputFile.getline(buffer, MAXSTRINGSIZE);
                                 if (strlen(buffer) > 2) {
                                         //*out << Verbose(2) << "Scanning: " << buffer << endl;
                                         stringstream line(buffer);
                                         line >> FragOrder;
                                         line >> ws >> No;
                                         line >> ws >> Value; // skip time entry
                                         line >> ws >> Value;
                                         No -= 1;        // indices start at 1 in file, not 0
                                         //*out << Verbose(2) << " - yields (" << No << "," << Value << ", " << FragOrder << ")" << endl;
                                         // clean the list of those entries that have been superceded by higher order terms already
                                         map<int,KeySet>::iterator marker = IndexKeySetList.find(No);            // find keyset to Frag No.
                                         if (marker != IndexKeySetList.end()) {  // if found
                                                 Value *= 1 + MYEPSILON*(*((*marker).second.begin()));            // in case of equal energies this makes em not equal without changing anything actually
                                                 // as the smallest number in each set has always been the root (we use global id to keep the doubles away), seek smallest and insert into AtomMask
                                                 pair <map<int, pair<double,int> >::iterator, bool> InsertedElement = AdaptiveCriteriaList.insert( make_pair(*((*marker).second.begin()), pair<double,int>( fabs(Value), FragOrder) ));
                                                 map<int, pair<double,int> >::iterator PresentItem = InsertedElement.first;
                                                 if (!InsertedElement.second) { // this root is already present
                                                         if ((*PresentItem).second.second < FragOrder)   // if order there is lower, update entry with higher-order term
                                                                 //if ((*PresentItem).second.first < (*runner).first)            // as higher-order terms are not always better, we skip this part (which would always include this site into adaptive increase)
                                                                 {       // if value is smaller, update value and order
                                                                 (*PresentItem).second.first = fabs(Value);
                                                                 (*PresentItem).second.second = FragOrder;
                                                                 *out << Verbose(2) << "Updated element (" <<    (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl;
                                                         } else {
                                                                 *out << Verbose(2) << "Did not update element " <<      (*PresentItem).first << " as " << FragOrder << " is less than or equal to " << (*PresentItem).second.second << "." << endl;
+                                                        }
                                                 } else {
                                                         *out << Verbose(2) << "Inserted element (" <<   (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl;
+                                                }
                                         } else {
                                                 *out << Verbose(1) << "No Fragment under No. " << No << "found." << endl;
+                                        }
+                                }
+                        }
                         // then map back onto (Value, (Root Nr., Order)) (i.e. sorted by value to pick the highest ones)
                         map<double, pair<int,int> > FinalRootCandidates;
                         *out << Verbose(1) << "Root candidate list is: " << endl;
                         for(map<int, pair<double,int> >::iterator runner = AdaptiveCriteriaList.begin(); runner != AdaptiveCriteriaList.end(); runner++) {
                                 Walker = FindAtom((*runner).first);
                                 if (Walker != NULL) {
                                         //if ((*runner).second.second >= Walker->AdaptiveOrder) { // only insert if this is an "active" root site for the current order
                                         if (!Walker->MaxOrder) {
                                                 *out << Verbose(2) << "(" << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "])" << endl;
                                                 FinalRootCandidates.insert( make_pair( (*runner).second.first, pair<int,int>((*runner).first, (*runner).second.second) ) );
                                         } else {
                                                 *out << Verbose(2) << "Excluding (" << *Walker << ", " << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "]), as it has reached its maximum order." << endl;
+                                        }
                                 } else {
                                         cerr << "Atom No. " << (*runner).second.first << " was not found in this molecule." << endl;
+                                }
+                        }
                         // pick the ones still below threshold and mark as to be adaptively updated
                         for(map<double, pair<int,int> >::iterator runner = FinalRootCandidates.upper_bound(pow(10.,Order)); runner != FinalRootCandidates.end(); runner++) {
                                 No = (*runner).second.first;
                                 Walker = FindAtom(No);
                                 //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]) {
                                         *out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl;
                                         AtomMask[No] = true;
                                         status = true;
                                 //} else
                                         //*out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->nr] << " does not allow further adaptive increase." << endl;
+                        }
                         // close and done
                         InputFile.close();
                         InputFile.clear();
                 } else {
                         cerr << "Unable to parse " << buffer << " file, incrementing all." << endl;
                         while (Walker->next != end) {
                                 Walker = Walker->next;
                 #ifdef ADDHYDROGEN
                                 if (Walker->type->Z != 1) // skip hydrogen
                 #endif
+                                {
                                         AtomMask[Walker->nr] = true;    // include all (non-hydrogen) atoms
                                         status = true;
+                                }
+                        }
+                }
                 Free((void **)&buffer, "molecule::CheckOrderAtSite: *buffer");
                 // pick a given number of highest values and set AtomMask
         } else { // global increase of Bond Order
                 while (Walker->next != end) {
                         Walker = Walker->next;
         #ifdef ADDHYDROGEN
                         if (Walker->type->Z != 1) // skip hydrogen
         #endif
+                        {
                                 AtomMask[Walker->nr] = true;    // include all (non-hydrogen) atoms
                                 if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
                                         status = true;
+                        }
+                }
                 if ((Order == 0) && (AtomMask[AtomCount] == false))     // single stepping, just check
                         status = true;
                 if (!status) {
                         if (Order == 0)
                                 *out << Verbose(1) << "Single stepping done." << endl;
                         else
                                 *out << Verbose(1) << "Order at every site is already equal or above desired order " << Order << "." << endl;
+                }
+        }
         // print atom mask for debugging
         *out << "                                                       ";
         for(int i=0;i<AtomCount;i++)
                 *out << (i % 10);
         *out << endl << "Atom mask is: ";
         for(int i=0;i<AtomCount;i++)
                 *out << (AtomMask[i] ? "t" : "f");
         *out << endl;
         return status;
+  atom *Walker = start;
+  bool status = false;
+  ifstream InputFile;
+  // initialize mask list
+  for(int i=AtomCount;i--;)
+    AtomMask[i] = false;
+  if (Order < 0) { // adaptive increase of BondOrder per site
+    if (AtomMask[AtomCount] == true)  // break after one step
+      return false;
+    // parse the EnergyPerFragment file
+    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
+    sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
+    InputFile.open(buffer, ios::in);
+    if ((InputFile != NULL) && (GlobalKeySetList != NULL)) {
+      // transmorph graph keyset list into indexed KeySetList
+      map<int,KeySet> IndexKeySetList;
+      for(Graph::iterator runner = GlobalKeySetList->begin(); runner != GlobalKeySetList->end(); runner++) {
+        IndexKeySetList.insert( pair<int,KeySet>(runner->second.first,runner->first) );
+      }
+      int lines = 0;
+      // count the number of lines, i.e. the number of fragments
+      InputFile.getline(buffer, MAXSTRINGSIZE); // skip comment lines
+      InputFile.getline(buffer, MAXSTRINGSIZE);
+      while(!InputFile.eof()) {
+        InputFile.getline(buffer, MAXSTRINGSIZE);
+        lines++;
+      }
+      //*out << Verbose(2) << "Scanned " << lines-1 << " lines." << endl;   // one endline too much
+      InputFile.clear();
+      InputFile.seekg(ios::beg);
+      map<int, pair<double,int> > AdaptiveCriteriaList;  // (Root No., (Value, Order)) !
+      int No, FragOrder;
+      double Value;
+      // each line represents a fragment root (Atom::nr) id and its energy contribution
+      InputFile.getline(buffer, MAXSTRINGSIZE); // skip comment lines
+      InputFile.getline(buffer, MAXSTRINGSIZE);
+      while(!InputFile.eof()) {
+        InputFile.getline(buffer, MAXSTRINGSIZE);
+        if (strlen(buffer) > 2) {
+          //*out << Verbose(2) << "Scanning: " << buffer << endl;
+          stringstream line(buffer);
+          line >> FragOrder;
+          line >> ws >> No;
+          line >> ws >> Value; // skip time entry
+          line >> ws >> Value;
+          No -= 1;  // indices start at 1 in file, not 0
+          //*out << Verbose(2) << " - yields (" << No << "," << Value << ", " << FragOrder << ")" << endl;
+          // clean the list of those entries that have been superceded by higher order terms already
+          map<int,KeySet>::iterator marker = IndexKeySetList.find(No);    // find keyset to Frag No.
+          if (marker != IndexKeySetList.end()) {  // if found
+            Value *= 1 + MYEPSILON*(*((*marker).second.begin()));     // in case of equal energies this makes em not equal without changing anything actually
+            // as the smallest number in each set has always been the root (we use global id to keep the doubles away), seek smallest and insert into AtomMask
+            pair <map<int, pair<double,int> >::iterator, bool> InsertedElement = AdaptiveCriteriaList.insert( make_pair(*((*marker).second.begin()), pair<double,int>( fabs(Value), FragOrder) ));
+            map<int, pair<double,int> >::iterator PresentItem = InsertedElement.first;
+            if (!InsertedElement.second) { // this root is already present
+              if ((*PresentItem).second.second < FragOrder)  // if order there is lower, update entry with higher-order term
+                //if ((*PresentItem).second.first < (*runner).first)    // as higher-order terms are not always better, we skip this part (which would always include this site into adaptive increase)
+                {  // if value is smaller, update value and order
+                (*PresentItem).second.first = fabs(Value);
+                (*PresentItem).second.second = FragOrder;
+                *out << Verbose(2) << "Updated element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl;
+              } else {
+                *out << Verbose(2) << "Did not update element " <<  (*PresentItem).first << " as " << FragOrder << " is less than or equal to " << (*PresentItem).second.second << "." << endl;
+              }
+            } else {
+              *out << Verbose(2) << "Inserted element (" <<  (*PresentItem).first << ",[" << (*PresentItem).second.first << "," << (*PresentItem).second.second << "])." << endl;
+            }
+          } else {
+            *out << Verbose(1) << "No Fragment under No. " << No << "found." << endl;
+          }
+        }
+      }
+      // then map back onto (Value, (Root Nr., Order)) (i.e. sorted by value to pick the highest ones)
+      map<double, pair<int,int> > FinalRootCandidates;
+      *out << Verbose(1) << "Root candidate list is: " << endl;
+      for(map<int, pair<double,int> >::iterator runner = AdaptiveCriteriaList.begin(); runner != AdaptiveCriteriaList.end(); runner++) {
+        Walker = FindAtom((*runner).first);
+        if (Walker != NULL) {
+          //if ((*runner).second.second >= Walker->AdaptiveOrder) { // only insert if this is an "active" root site for the current order
+          if (!Walker->MaxOrder) {
+            *out << Verbose(2) << "(" << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "])" << endl;
+            FinalRootCandidates.insert( make_pair( (*runner).second.first, pair<int,int>((*runner).first, (*runner).second.second) ) );
+          } else {
+            *out << Verbose(2) << "Excluding (" << *Walker << ", " << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "]), as it has reached its maximum order." << endl;
+          }
+        } else {
+          cerr << "Atom No. " << (*runner).second.first << " was not found in this molecule." << endl;
+        }
+      }
+      // pick the ones still below threshold and mark as to be adaptively updated
+      for(map<double, pair<int,int> >::iterator runner = FinalRootCandidates.upper_bound(pow(10.,Order)); runner != FinalRootCandidates.end(); runner++) {
+        No = (*runner).second.first;
+        Walker = FindAtom(No);
+        //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]) {
+          *out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl;
+          AtomMask[No] = true;
+          status = true;
+        //} else
+          //*out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->nr] << " does not allow further adaptive increase." << endl;
+      }
+      // close and done
+      InputFile.close();
+      InputFile.clear();
+    } else {
+      cerr << "Unable to parse " << buffer << " file, incrementing all." << endl;
+      while (Walker->next != end) {
+        Walker = Walker->next;
+    #ifdef ADDHYDROGEN
+        if (Walker->type->Z != 1) // skip hydrogen
+    #endif
+        {
+          AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+          status = true;
+        }
+      }
+    }
+    Free((void **)&buffer, "molecule::CheckOrderAtSite: *buffer");
+    // pick a given number of highest values and set AtomMask
+  } else { // global increase of Bond Order
+    while (Walker->next != end) {
+      Walker = Walker->next;
+  #ifdef ADDHYDROGEN
+      if (Walker->type->Z != 1) // skip hydrogen
+  #endif
+      {
+        AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
+          status = true;
+      }
+    }
+    if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
+      status = true;
+    if (!status) {
+      if (Order == 0)
+        *out << Verbose(1) << "Single stepping done." << endl;
+      else
+        *out << Verbose(1) << "Order at every site is already equal or above desired order " << Order << "." << endl;
+    }
+  }
+  // print atom mask for debugging
+  *out << "              ";
+  for(int i=0;i<AtomCount;i++)
+    *out << (i % 10);
+  *out << endl << "Atom mask is: ";
+  for(int i=0;i<AtomCount;i++)
+    *out << (AtomMask[i] ? "t" : "f");
+  *out << endl;
+  return status;
 };
 …
 bool molecule::CreateMappingLabelsToConfigSequence(ofstream *out, int *&SortIndex)
+{
         element *runner = elemente->start;
         int AtomNo = 0;
         atom *Walker = NULL;
         if (SortIndex != NULL) {
                 *out << Verbose(1) << "SortIndex is " << SortIndex << " and not NULL as expected." << endl;
                 return false;
+        }
         SortIndex = (int *) Malloc(sizeof(int)*AtomCount, "molecule::FragmentMolecule: *SortIndex");
         for(int i=AtomCount;i--;)
                 SortIndex[i] = -1;
         while (runner->next != elemente->end) { // go through every element
                 runner = runner->next;
                 if (ElementsInMolecule[runner->Z]) { // if this element got atoms
                         Walker = start;
                         while (Walker->next != end) { // go through every atom of this element
                                 Walker = Walker->next;
                                 if (Walker->type->Z == runner->Z) // if this atom fits to element
                                         SortIndex[Walker->nr] = AtomNo++;
+                        }
+                }
+        }
         return true;
+  element *runner = elemente->start;
+  int AtomNo = 0;
+  atom *Walker = NULL;
+  if (SortIndex != NULL) {
+    *out << Verbose(1) << "SortIndex is " << SortIndex << " and not NULL as expected." << endl;
+    return false;
+  }
+  SortIndex = (int *) Malloc(sizeof(int)*AtomCount, "molecule::FragmentMolecule: *SortIndex");
+  for(int i=AtomCount;i--;)
+    SortIndex[i] = -1;
+  while (runner->next != elemente->end) { // go through every element
+    runner = runner->next;
+    if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+      Walker = start;
+      while (Walker->next != end) { // go through every atom of this element
+        Walker = Walker->next;
+        if (Walker->type->Z == runner->Z) // if this atom fits to element
+          SortIndex[Walker->nr] = AtomNo++;
+      }
+    }
+  }
+  return true;
 };
 …
 y contribution", and that's why this consciously not done in the following loop)
  * -# in a loop over all subgraphs
  *      -# calls FragmentBOSSANOVA with this RootStack and within the subgraph molecule structure
  *      -# creates molecule (fragment)s from the returned keysets (StoreFragmentFromKeySet)
+ *  -# calls FragmentBOSSANOVA with this RootStack and within the subgraph molecule structure
+ *  -# creates molecule (fragment)s from the returned keysets (StoreFragmentFromKeySet)
  * -# combines the generated molecule lists from all subgraphs
  * -# saves to disk: fragment configs, adjacency, orderatsite, keyset files
 …
 int molecule::FragmentMolecule(ofstream *out, int Order, config *configuration)
+{
         MoleculeListClass *BondFragments = NULL;
         int *SortIndex = NULL;
         int *MinimumRingSize = new int[AtomCount];
         int FragmentCounter;
         MoleculeLeafClass *MolecularWalker = NULL;
         MoleculeLeafClass *Subgraphs = NULL;                    // list of subgraphs from DFS analysis
         fstream File;
         bool FragmentationToDo = true;
         class StackClass<bond *> *BackEdgeStack = NULL, *LocalBackEdgeStack = NULL;
         bool CheckOrder = false;
         Graph **FragmentList = NULL;
         Graph *ParsedFragmentList = NULL;
         Graph TotalGraph;                // graph with all keysets however local numbers
         int TotalNumberOfKeySets = 0;
         atom **ListOfAtoms = NULL;
         atom ***ListOfLocalAtoms = NULL;
         bool *AtomMask = NULL;
         *out << endl;
+  MoleculeListClass *BondFragments = NULL;
+  int *SortIndex = NULL;
+  int *MinimumRingSize = new int[AtomCount];
+  int FragmentCounter;
+  MoleculeLeafClass *MolecularWalker = NULL;
+  MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+  fstream File;
+  bool FragmentationToDo = true;
+  class StackClass<bond *> *BackEdgeStack = NULL, *LocalBackEdgeStack = NULL;
+  bool CheckOrder = false;
+  Graph **FragmentList = NULL;
+  Graph *ParsedFragmentList = NULL;
+  Graph TotalGraph;     // graph with all keysets however local numbers
+  int TotalNumberOfKeySets = 0;
+  atom **ListOfAtoms = NULL;
+  atom ***ListOfLocalAtoms = NULL;
+  bool *AtomMask = NULL;
+  *out << endl;
 #ifdef ADDHYDROGEN
         *out << Verbose(0) << "I will treat hydrogen special and saturate dangling bonds with it." << endl;
+  *out << Verbose(0) << "I will treat hydrogen special and saturate dangling bonds with it." << endl;
 #else
         *out << Verbose(0) << "Hydrogen is treated just like the rest of the lot." << endl;
+  *out << Verbose(0) << "Hydrogen is treated just like the rest of the lot." << endl;
 #endif
         // ++++++++++++++++++++++++++++ INITIAL STUFF: Bond structure analysis, file parsing, ... ++++++++++++++++++++++++++++++++++++++++++
         // ===== 1. Check whether bond structure is same as stored in files ====
         // fill the adjacency list
         CreateListOfBondsPerAtom(out);
         // create lookup table for Atom::nr
         FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(out, start, end, ListOfAtoms, AtomCount);
         // === compare it with adjacency file ===
         FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms);
         Free((void **)&ListOfAtoms, "molecule::FragmentMolecule - **ListOfAtoms");
         // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
         Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
         // fill the bond structure of the individually stored subgraphs
         Subgraphs->next->FillBondStructureFromReference(out, this, (FragmentCounter = 0), ListOfLocalAtoms, false);     // we want to keep the created ListOfLocalAtoms
         // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
         for(int i=AtomCount;i--;)
                 MinimumRingSize[i] = AtomCount;
         MolecularWalker = Subgraphs;
         FragmentCounter = 0;
         while (MolecularWalker->next != NULL) {
                 MolecularWalker = MolecularWalker->next;
                 LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
 //              // check the list of local atoms for debugging
 //              *out << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
 //              for (int i=0;i<AtomCount;i++)
 //                      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
 //                              *out << "\tNULL";
 //                      else
 //                              *out << "\t" << ListOfLocalAtoms[FragmentCounter][i]->Name;
                 *out << Verbose(0) << "Gathering local back edges for subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
                 MolecularWalker->Leaf->PickLocalBackEdges(out, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
                 *out << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
                 MolecularWalker->Leaf->CyclicStructureAnalysis(out, LocalBackEdgeStack, MinimumRingSize);
                 *out << Verbose(0) << "Done with Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
                 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 =====
         Subgraphs->next->AssignKeySetsToFragment(out, this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, (FragmentCounter = 0), true);
         // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
         KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
         AtomMask = new bool[AtomCount+1];
         AtomMask[AtomCount] = false;
         FragmentationToDo = false;      // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
         while ((CheckOrder = CheckOrderAtSite(out, AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
                 FragmentationToDo = FragmentationToDo || CheckOrder;
                 AtomMask[AtomCount] = true;      // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
                 // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
                 Subgraphs->next->FillRootStackForSubgraphs(out, RootStack, AtomMask, (FragmentCounter = 0));
                 // ===== 7. fill the bond fragment list =====
                 FragmentCounter = 0;
                 MolecularWalker = Subgraphs;
                 while (MolecularWalker->next != NULL) {
                         MolecularWalker = MolecularWalker->next;
                         *out << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl;
                         //MolecularWalker->Leaf->OutputListOfBonds(out);        // output ListOfBondsPerAtom for debugging
                         if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
                                 // call BOSSANOVA method
                                 *out << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl;
                                 MolecularWalker->Leaf->FragmentBOSSANOVA(out, FragmentList[FragmentCounter], RootStack[FragmentCounter], MinimumRingSize);
                         } else {
                                 cerr << "Subgraph " << MolecularWalker << " has no atoms!" << endl;
+                        }
                         FragmentCounter++;      // next fragment list
+                }
+        }
         delete[](RootStack);
         delete[](AtomMask);
         delete(ParsedFragmentList);
         delete[](MinimumRingSize);
         // ==================================== End of FRAGMENTATION ============================================
         // ===== 8a. translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
         Subgraphs->next->TranslateIndicesToGlobalIDs(out, FragmentList, (FragmentCounter = 0), TotalNumberOfKeySets, TotalGraph);
         // free subgraph memory again
         FragmentCounter = 0;
         if (Subgraphs != NULL) {
                 while (Subgraphs->next != NULL) {
                         Subgraphs = Subgraphs->next;
                         delete(FragmentList[FragmentCounter++]);
                         delete(Subgraphs->previous);
+                }
                 delete(Subgraphs);
+        }
         Free((void **)&FragmentList, "molecule::FragmentMolecule - **FragmentList");
         // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
         //if (FragmentationToDo) {              // we should always store the fragments again as coordination might have changed slightly without changing bond structure
                 // allocate memory for the pointer array and transmorph graphs into full molecular fragments
                 BondFragments = new MoleculeListClass();
                 int k=0;
                 for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
                         KeySet test = (*runner).first;
                         *out << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl;
                         BondFragments->insert(StoreFragmentFromKeySet(out, test, configuration));
                         k++;
+                }
                 *out << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl;
                 // ===== 9. Save fragments' configuration and keyset files et al to disk ===
                 if (BondFragments->ListOfMolecules.size() != 0) {
                         // create the SortIndex from BFS labels to order in the config file
                         CreateMappingLabelsToConfigSequence(out, SortIndex);
                         *out << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl;
                         if (BondFragments->OutputConfigForListOfFragments(out, configuration, SortIndex))
                                 *out << Verbose(1) << "All configs written." << endl;
                         else
                                 *out << Verbose(1) << "Some config writing failed." << endl;
                         // store force index reference file
                         BondFragments->StoreForcesFile(out, configuration->configpath, SortIndex);
                         // store keysets file
                         StoreKeySetFile(out, TotalGraph, configuration->configpath);
                         // store Adjacency file
                         StoreAdjacencyToFile(out, configuration->configpath);
                         // store Hydrogen saturation correction file
                         BondFragments->AddHydrogenCorrection(out, configuration->configpath);
                         // store adaptive orders into file
                         StoreOrderAtSiteFile(out, configuration->configpath);
                         // restore orbital and Stop values
                         CalculateOrbitals(*configuration);
                         // free memory for bond part
                         *out << Verbose(1) << "Freeing bond memory" << endl;
                         delete(FragmentList); // remove bond molecule from memory
                         Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex");
                 } else
                         *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
         //} else
         //      *out << Verbose(1) << "No fragments to store." << endl;
         *out << Verbose(0) << "End of bond fragmentation." << endl;
         return ((int)(!FragmentationToDo)+1);           // 1 - continue, 2 - stop (no fragmentation occured)
+  // ++++++++++++++++++++++++++++ INITIAL STUFF: Bond structure analysis, file parsing, ... ++++++++++++++++++++++++++++++++++++++++++
+  // ===== 1. Check whether bond structure is same as stored in files ====
+  // fill the adjacency list
+  CreateListOfBondsPerAtom(out);
+  // create lookup table for Atom::nr
+  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(out, start, end, ListOfAtoms, AtomCount);
+  // === compare it with adjacency file ===
+  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms);
+  Free((void **)&ListOfAtoms, "molecule::FragmentMolecule - **ListOfAtoms");
+  // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
+  Subgraphs = DepthFirstSearchAnalysis(out, BackEdgeStack);
+  // fill the bond structure of the individually stored subgraphs
+  Subgraphs->next->FillBondStructureFromReference(out, this, (FragmentCounter = 0), ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+  // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
+  for(int i=AtomCount;i--;)
+    MinimumRingSize[i] = AtomCount;
+  MolecularWalker = Subgraphs;
+  FragmentCounter = 0;
+  while (MolecularWalker->next != NULL) {
+    MolecularWalker = MolecularWalker->next;
+    LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
+//    // check the list of local atoms for debugging
+//    *out << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
+//    for (int i=0;i<AtomCount;i++)
+//      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
+//        *out << "\tNULL";
+//      else
+//        *out << "\t" << ListOfLocalAtoms[FragmentCounter][i]->Name;
+    *out << Verbose(0) << "Gathering local back edges for subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
+    MolecularWalker->Leaf->PickLocalBackEdges(out, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
+    *out << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
+    MolecularWalker->Leaf->CyclicStructureAnalysis(out, LocalBackEdgeStack, MinimumRingSize);
+    *out << Verbose(0) << "Done with Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
+    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 =====
+  Subgraphs->next->AssignKeySetsToFragment(out, this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, (FragmentCounter = 0), true);
+  // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
+  KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
+  AtomMask = new bool[AtomCount+1];
+  AtomMask[AtomCount] = false;
+  FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
+  while ((CheckOrder = CheckOrderAtSite(out, AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
+    FragmentationToDo = FragmentationToDo || CheckOrder;
+    AtomMask[AtomCount] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
+    // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
+    Subgraphs->next->FillRootStackForSubgraphs(out, RootStack, AtomMask, (FragmentCounter = 0));
+    // ===== 7. fill the bond fragment list =====
+    FragmentCounter = 0;
+    MolecularWalker = Subgraphs;
+    while (MolecularWalker->next != NULL) {
+      MolecularWalker = MolecularWalker->next;
+      *out << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl;
+      //MolecularWalker->Leaf->OutputListOfBonds(out);  // output ListOfBondsPerAtom for debugging
+      if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
+        // call BOSSANOVA method
+        *out << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl;
+        MolecularWalker->Leaf->FragmentBOSSANOVA(out, FragmentList[FragmentCounter], RootStack[FragmentCounter], MinimumRingSize);
+      } else {
+        cerr << "Subgraph " << MolecularWalker << " has no atoms!" << endl;
+      }
+      FragmentCounter++;  // next fragment list
+    }
+  }
+  delete[](RootStack);
+  delete[](AtomMask);
+  delete(ParsedFragmentList);
+  delete[](MinimumRingSize);
+  // ==================================== End of FRAGMENTATION ============================================
+  // ===== 8a. translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
+  Subgraphs->next->TranslateIndicesToGlobalIDs(out, FragmentList, (FragmentCounter = 0), TotalNumberOfKeySets, TotalGraph);
+  // free subgraph memory again
+  FragmentCounter = 0;
+  if (Subgraphs != NULL) {
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      delete(FragmentList[FragmentCounter++]);
+      delete(Subgraphs->previous);
+    }
+    delete(Subgraphs);
+  }
+  Free((void **)&FragmentList, "molecule::FragmentMolecule - **FragmentList");
+  // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
+  //if (FragmentationToDo) {    // we should always store the fragments again as coordination might have changed slightly without changing bond structure
+    // allocate memory for the pointer array and transmorph graphs into full molecular fragments
+    BondFragments = new MoleculeListClass();
+    int k=0;
+    for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
+      KeySet test = (*runner).first;
+      *out << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl;
+      BondFragments->insert(StoreFragmentFromKeySet(out, test, configuration));
+      k++;
+    }
+    *out << k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets." << endl;
+    // ===== 9. Save fragments' configuration and keyset files et al to disk ===
+    if (BondFragments->ListOfMolecules.size() != 0) {
+      // create the SortIndex from BFS labels to order in the config file
+      CreateMappingLabelsToConfigSequence(out, SortIndex);
+      *out << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl;
+      if (BondFragments->OutputConfigForListOfFragments(out, configuration, SortIndex))
+        *out << Verbose(1) << "All configs written." << endl;
+      else
+        *out << Verbose(1) << "Some config writing failed." << endl;
+      // store force index reference file
+      BondFragments->StoreForcesFile(out, configuration->configpath, SortIndex);
+      // store keysets file
+      StoreKeySetFile(out, TotalGraph, configuration->configpath);
+      // store Adjacency file
+      StoreAdjacencyToFile(out, configuration->configpath);
+      // store Hydrogen saturation correction file
+      BondFragments->AddHydrogenCorrection(out, configuration->configpath);
+      // store adaptive orders into file
+      StoreOrderAtSiteFile(out, configuration->configpath);
+      // restore orbital and Stop values
+      CalculateOrbitals(*configuration);
+      // free memory for bond part
+      *out << Verbose(1) << "Freeing bond memory" << endl;
+      delete(FragmentList); // remove bond molecule from memory
+      Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex");
+    } else
+      *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
+  //} else
+  //  *out << Verbose(1) << "No fragments to store." << endl;
+  *out << Verbose(0) << "End of bond fragmentation." << endl;
+  return ((int)(!FragmentationToDo)+1);    // 1 - continue, 2 - stop (no fragmentation occured)
 };
 …
 bool molecule::PickLocalBackEdges(ofstream *out, atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack)
+{
         bool status = true;
         if (ReferenceStack->IsEmpty()) {
                 cerr << "ReferenceStack is empty!" << endl;
                 return false;
+        }
         bond *Binder = ReferenceStack->PopFirst();
         bond *FirstBond = Binder;        // mark the first bond, so that we don't loop through the stack indefinitely
         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
                 if (Walker != NULL) // if this Walker exists in the subgraph ...
                         for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {           // go through the local list of bonds
                                 OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
                                 if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
                                         LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
                                         *out << Verbose(3) << "Found local edge " << *(ListOfBondsPerAtom[Walker->nr][i]) << "." << endl;
                                         break;
+                                }
+                        }
                 Binder = ReferenceStack->PopFirst();    // loop the stack for next item
                 *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
                 ReferenceStack->Push(Binder);
         } while (FirstBond != Binder);
         return status;
+  bool status = true;
+  if (ReferenceStack->IsEmpty()) {
+    cerr << "ReferenceStack is empty!" << endl;
+    return false;
+  }
+  bond *Binder = ReferenceStack->PopFirst();
+  bond *FirstBond = Binder;   // mark the first bond, so that we don't loop through the stack indefinitely
+  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
+    if (Walker != NULL) // if this Walker exists in the subgraph ...
+      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {    // go through the local list of bonds
+        OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+        if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
+          LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
+          *out << Verbose(3) << "Found local edge " << *(ListOfBondsPerAtom[Walker->nr][i]) << "." << endl;
+          break;
+        }
+      }
+    Binder = ReferenceStack->PopFirst();  // loop the stack for next item
+    *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
+    ReferenceStack->Push(Binder);
+  } while (FirstBond != Binder);
+  return status;
 };
 …
 bool molecule::StoreOrderAtSiteFile(ofstream *out, char *path)
+{
         stringstream line;
         ofstream file;
         line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
         file.open(line.str().c_str());
         *out << Verbose(1) << "Writing OrderAtSite " << ORDERATSITEFILE << " ... " << endl;
         if (file != NULL) {
                 atom *Walker = start;
                 while (Walker->next != end) {
                         Walker = Walker->next;
                         file << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << endl;
                         *out << Verbose(2) << "Storing: " << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << "." << endl;
+                }
                 file.close();
                 *out << Verbose(1) << "done." << endl;
                 return true;
         } else {
                 *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
                 return false;
+        }
+  stringstream line;
+  ofstream file;
+  line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
+  file.open(line.str().c_str());
+  *out << Verbose(1) << "Writing OrderAtSite " << ORDERATSITEFILE << " ... " << endl;
+  if (file != NULL) {
+    atom *Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      file << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << endl;
+      *out << Verbose(2) << "Storing: " << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << "." << endl;
+    }
+    file.close();
+    *out << Verbose(1) << "done." << endl;
+    return true;
+  } else {
+    *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
+    return false;
+  }
 };
 …
 bool molecule::ParseOrderAtSiteFromFile(ofstream *out, char *path)
+{
         unsigned char *OrderArray = (unsigned char *) Malloc(sizeof(unsigned char)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
         bool *MaxArray = (bool *) Malloc(sizeof(bool)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
         bool status;
         int AtomNr, value;
         stringstream line;
         ifstream file;
         *out << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl;
         for(int i=AtomCount;i--;)
                 OrderArray[i] = 0;
         line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
         file.open(line.str().c_str());
         if (file != NULL) {
                 for (int i=AtomCount;i--;) { // initialise with 0
                         OrderArray[i] = 0;
                         MaxArray[i] = 0;
+                }
                 while (!file.eof()) { // parse from file
                         AtomNr = -1;
                         file >> AtomNr;
                         if (AtomNr != -1) {      // test whether we really parsed something (this is necessary, otherwise last atom is set twice and to 0 on second time)
                                 file >> value;
                                 OrderArray[AtomNr] = value;
                                 file >> value;
                                 MaxArray[AtomNr] = value;
                                 //*out << Verbose(2) << "AtomNr " << AtomNr << " with order " << (int)OrderArray[AtomNr] << " and max order set to " << (int)MaxArray[AtomNr] << "." << endl;
+                        }
+                }
                 atom *Walker = start;
                 while (Walker->next != end) { // fill into atom classes
                         Walker = Walker->next;
                         Walker->AdaptiveOrder = OrderArray[Walker->nr];
                         Walker->MaxOrder = MaxArray[Walker->nr];
                         *out << Verbose(2) << *Walker << " gets order " << (int)Walker->AdaptiveOrder << " and is " << (!Walker->MaxOrder ? "not " : " ") << "maxed." << endl;
+                }
                 file.close();
                 *out << Verbose(1) << "done." << endl;
                 status = true;
         } else {
                 *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
                 status = false;
+        }
         Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
         Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
         *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
         return status;
+  unsigned char *OrderArray = (unsigned char *) Malloc(sizeof(unsigned char)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  bool *MaxArray = (bool *) Malloc(sizeof(bool)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  bool status;
+  int AtomNr, value;
+  stringstream line;
+  ifstream file;
+  *out << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl;
+  for(int i=AtomCount;i--;)
+    OrderArray[i] = 0;
+  line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
+  file.open(line.str().c_str());
+  if (file != NULL) {
+    for (int i=AtomCount;i--;) { // initialise with 0
+      OrderArray[i] = 0;
+      MaxArray[i] = 0;
+    }
+    while (!file.eof()) { // parse from file
+      AtomNr = -1;
+      file >> AtomNr;
+      if (AtomNr != -1) {   // test whether we really parsed something (this is necessary, otherwise last atom is set twice and to 0 on second time)
+        file >> value;
+        OrderArray[AtomNr] = value;
+        file >> value;
+        MaxArray[AtomNr] = value;
+        //*out << Verbose(2) << "AtomNr " << AtomNr << " with order " << (int)OrderArray[AtomNr] << " and max order set to " << (int)MaxArray[AtomNr] << "." << endl;
+      }
+    }
+    atom *Walker = start;
+    while (Walker->next != end) { // fill into atom classes
+      Walker = Walker->next;
+      Walker->AdaptiveOrder = OrderArray[Walker->nr];
+      Walker->MaxOrder = MaxArray[Walker->nr];
+      *out << Verbose(2) << *Walker << " gets order " << (int)Walker->AdaptiveOrder << " and is " << (!Walker->MaxOrder ? "not " : " ") << "maxed." << endl;
+    }
+    file.close();
+    *out << Verbose(1) << "done." << endl;
+    status = true;
+  } else {
+    *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
+    status = false;
+  }
+  Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
+  return status;
 };
 …
 void molecule::CreateListOfBondsPerAtom(ofstream *out)
+{
         bond *Binder = NULL;
         atom *Walker = NULL;
         int TotalDegree;
         *out << Verbose(1) << "Begin of Creating ListOfBondsPerAtom: AtomCount = " << AtomCount << "\tBondCount = " << BondCount << "\tNoNonBonds = " << NoNonBonds << "." << endl;
         // re-allocate memory
         *out << Verbose(2) << "(Re-)Allocating memory." << endl;
         if (ListOfBondsPerAtom != NULL) {
                 for(int i=AtomCount;i--;)
                         Free((void **)&ListOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom[i]");
                 Free((void **)&ListOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom");
+        }
         if (NumberOfBondsPerAtom != NULL)
                 Free((void **)&NumberOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: NumberOfBondsPerAtom");
         ListOfBondsPerAtom = (bond ***) Malloc(sizeof(bond **)*AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
         NumberOfBondsPerAtom = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
         // reset bond counts per atom
         for(int i=AtomCount;i--;)
                 NumberOfBondsPerAtom[i] = 0;
         // count bonds per atom
         Binder = first;
         while (Binder->next != last) {
                 Binder = Binder->next;
                 NumberOfBondsPerAtom[Binder->leftatom->nr]++;
                 NumberOfBondsPerAtom[Binder->rightatom->nr]++;
+        }
         for(int i=AtomCount;i--;) {
                 // allocate list of bonds per atom
                 ListOfBondsPerAtom[i] = (bond **) Malloc(sizeof(bond *)*NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
                 // clear the list again, now each NumberOfBondsPerAtom marks current free field
                 NumberOfBondsPerAtom[i] = 0;
+        }
         // fill the list
         Binder = first;
         while (Binder->next != last) {
                 Binder = Binder->next;
                 ListOfBondsPerAtom[Binder->leftatom->nr][NumberOfBondsPerAtom[Binder->leftatom->nr]++] = Binder;
                 ListOfBondsPerAtom[Binder->rightatom->nr][NumberOfBondsPerAtom[Binder->rightatom->nr]++] = Binder;
+        }
         // output list for debugging
         *out << Verbose(3) << "ListOfBondsPerAtom for each atom:" << endl;
         Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 *out << Verbose(4) << "Atom " << Walker->Name << "/" << Walker->nr << " with " << NumberOfBondsPerAtom[Walker->nr] << " bonds: ";
                 TotalDegree = 0;
                 for (int j=0;j<NumberOfBondsPerAtom[Walker->nr];j++) {
                         *out << *ListOfBondsPerAtom[Walker->nr][j] << "\t";
                         TotalDegree += ListOfBondsPerAtom[Walker->nr][j]->BondDegree;
+                }
                 *out << " -- TotalDegree: " << TotalDegree << endl;
+        }
         *out << Verbose(1) << "End of Creating ListOfBondsPerAtom." << endl << endl;
+  bond *Binder = NULL;
+  atom *Walker = NULL;
+  int TotalDegree;
+  *out << Verbose(1) << "Begin of Creating ListOfBondsPerAtom: AtomCount = " << AtomCount << "\tBondCount = " << BondCount << "\tNoNonBonds = " << NoNonBonds << "." << endl;
+  // re-allocate memory
+  *out << Verbose(2) << "(Re-)Allocating memory." << endl;
+  if (ListOfBondsPerAtom != NULL) {
+    for(int i=AtomCount;i--;)
+      Free((void **)&ListOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom[i]");
+    Free((void **)&ListOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom");
+  }
+  if (NumberOfBondsPerAtom != NULL)
+    Free((void **)&NumberOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: NumberOfBondsPerAtom");
+  ListOfBondsPerAtom = (bond ***) Malloc(sizeof(bond **)*AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
+  NumberOfBondsPerAtom = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
+  // reset bond counts per atom
+  for(int i=AtomCount;i--;)
+    NumberOfBondsPerAtom[i] = 0;
+  // count bonds per atom
+  Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    NumberOfBondsPerAtom[Binder->leftatom->nr]++;
+    NumberOfBondsPerAtom[Binder->rightatom->nr]++;
+  }
+  for(int i=AtomCount;i--;) {
+    // allocate list of bonds per atom
+    ListOfBondsPerAtom[i] = (bond **) Malloc(sizeof(bond *)*NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
+    // clear the list again, now each NumberOfBondsPerAtom marks current free field
+    NumberOfBondsPerAtom[i] = 0;
+  }
+  // fill the list
+  Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    ListOfBondsPerAtom[Binder->leftatom->nr][NumberOfBondsPerAtom[Binder->leftatom->nr]++] = Binder;
+    ListOfBondsPerAtom[Binder->rightatom->nr][NumberOfBondsPerAtom[Binder->rightatom->nr]++] = Binder;
+  }
+  // output list for debugging
+  *out << Verbose(3) << "ListOfBondsPerAtom for each atom:" << endl;
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    *out << Verbose(4) << "Atom " << Walker->Name << "/" << Walker->nr << " with " << NumberOfBondsPerAtom[Walker->nr] << " bonds: ";
+    TotalDegree = 0;
+    for (int j=0;j<NumberOfBondsPerAtom[Walker->nr];j++) {
+      *out << *ListOfBondsPerAtom[Walker->nr][j] << "\t";
+      TotalDegree += ListOfBondsPerAtom[Walker->nr][j]->BondDegree;
+    }
+    *out << " -- TotalDegree: " << TotalDegree << endl;
+  }
+  *out << Verbose(1) << "End of Creating ListOfBondsPerAtom." << endl << endl;
 };
 …
 void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
+{
         atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::BreadthFirstSearchAdd: **PredecessorList");
         int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::BreadthFirstSearchAdd: *ShortestPathList");
         enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::BreadthFirstSearchAdd: *ColorList");
         class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
         atom *Walker = NULL, *OtherAtom = NULL;
         bond *Binder = NULL;
         // add Root if not done yet
         AtomStack->ClearStack();
         if (AddedAtomList[Root->nr] == NULL)    // add Root if not yet present
                 AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
         AtomStack->Push(Root);
         // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
         for (int i=AtomCount;i--;) {
                 PredecessorList[i] = NULL;
                 ShortestPathList[i] = -1;
                 if (AddedAtomList[i] != NULL) // mark already present atoms (i.e. Root and maybe others) as visited
                         ColorList[i] = lightgray;
                 else
                         ColorList[i] = white;
+        }
         ShortestPathList[Root->nr] = 0;
         // and go on ... Queue always contains all lightgray vertices
         while (!AtomStack->IsEmpty()) {
                 // we have to pop the oldest atom from stack. This keeps the atoms on the stack always of the same ShortestPath distance.
                 // e.g. if current atom is 2, push to end of stack are of length 3, but first all of length 2 would be popped. They again
                 // append length of 3 (their neighbours). Thus on stack we have always atoms of a certain length n at bottom of stack and
                 // followed by n+1 till top of stack.
                 Walker = AtomStack->PopFirst(); // pop oldest added
                 *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl;
                 for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
                         Binder = ListOfBondsPerAtom[Walker->nr][i];
                         if (Binder != NULL) { // don't look at bond equal NULL
                                 OtherAtom = Binder->GetOtherAtom(Walker);
                                 *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
                                 if (ColorList[OtherAtom->nr] == white) {
                                         if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
                                                 ColorList[OtherAtom->nr] = lightgray;
                                         PredecessorList[OtherAtom->nr] = Walker;        // Walker is the predecessor
                                         ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
                                         *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
                                         if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
                                                 *out << Verbose(3);
                                                 if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
                                                         AddedAtomList[OtherAtom->nr] = Mol->AddCopyAtom(OtherAtom);
                                                         *out << "Added OtherAtom " << OtherAtom->Name;
                                                         AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
                                                         AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
                                                         AddedBondList[Binder->nr]->Type = Binder->Type;
                                                         *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
                                                 } else {        // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
                                                         *out << "Not adding OtherAtom " << OtherAtom->Name;
                                                         if (AddedBondList[Binder->nr] == NULL) {
                                                                 AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
                                                                 AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
                                                                 AddedBondList[Binder->nr]->Type = Binder->Type;
                                                                 *out << ", added Bond " << *(AddedBondList[Binder->nr]);
                                                         } else
                                                                 *out << ", not added Bond ";
+                                                }
                                                 *out << ", putting OtherAtom into queue." << endl;
                                                 AtomStack->Push(OtherAtom);
                                         } else { // out of bond order, then replace
                                                 if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
                                                         ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
                                                 if (Binder == Bond)
                                                         *out << Verbose(3) << "Not Queueing, is the Root bond";
                                                 else if (ShortestPathList[OtherAtom->nr] >= BondOrder)
                                                         *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BondOrder;
                                                 if (!Binder->Cyclic)
                                                         *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
                                                 if (AddedBondList[Binder->nr] == NULL) {
                                                         if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
                                                                 AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
                                                                 AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
                                                                 AddedBondList[Binder->nr]->Type = Binder->Type;
                                                         } else {
+  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::BreadthFirstSearchAdd: **PredecessorList");
+  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::BreadthFirstSearchAdd: *ShortestPathList");
+  enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::BreadthFirstSearchAdd: *ColorList");
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  atom *Walker = NULL, *OtherAtom = NULL;
+  bond *Binder = NULL;
+  // add Root if not done yet
+  AtomStack->ClearStack();
+  if (AddedAtomList[Root->nr] == NULL)  // add Root if not yet present
+    AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
+  AtomStack->Push(Root);
+  // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
+  for (int i=AtomCount;i--;) {
+    PredecessorList[i] = NULL;
+    ShortestPathList[i] = -1;
+    if (AddedAtomList[i] != NULL) // mark already present atoms (i.e. Root and maybe others) as visited
+      ColorList[i] = lightgray;
+    else
+      ColorList[i] = white;
+  }
+  ShortestPathList[Root->nr] = 0;
+  // and go on ... Queue always contains all lightgray vertices
+  while (!AtomStack->IsEmpty()) {
+    // we have to pop the oldest atom from stack. This keeps the atoms on the stack always of the same ShortestPath distance.
+    // e.g. if current atom is 2, push to end of stack are of length 3, but first all of length 2 would be popped. They again
+    // append length of 3 (their neighbours). Thus on stack we have always atoms of a certain length n at bottom of stack and
+    // followed by n+1 till top of stack.
+    Walker = AtomStack->PopFirst(); // pop oldest added
+    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl;
+    for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+      Binder = ListOfBondsPerAtom[Walker->nr][i];
+      if (Binder != NULL) { // don't look at bond equal NULL
+        OtherAtom = Binder->GetOtherAtom(Walker);
+        *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
+        if (ColorList[OtherAtom->nr] == white) {
+          if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
+            ColorList[OtherAtom->nr] = lightgray;
+          PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
+          ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
+          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
+            *out << Verbose(3);
+            if (AddedAtomList[OtherAtom->nr] == NULL) { // add if it's not been so far
+              AddedAtomList[OtherAtom->nr] = Mol->AddCopyAtom(OtherAtom);
+              *out << "Added OtherAtom " << OtherAtom->Name;
+              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+              AddedBondList[Binder->nr]->Type = Binder->Type;
+              *out << " and bond " << *(AddedBondList[Binder->nr]) << ", ";
+            } else {  // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
+              *out << "Not adding OtherAtom " << OtherAtom->Name;
+              if (AddedBondList[Binder->nr] == NULL) {
+                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+                AddedBondList[Binder->nr]->Type = Binder->Type;
+                *out << ", added Bond " << *(AddedBondList[Binder->nr]);
+              } else
+                *out << ", not added Bond ";
+            }
+            *out << ", putting OtherAtom into queue." << endl;
+            AtomStack->Push(OtherAtom);
+          } else { // out of bond order, then replace
+            if ((AddedAtomList[OtherAtom->nr] == NULL) && (Binder->Cyclic))
+              ColorList[OtherAtom->nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
+            if (Binder == Bond)
+              *out << Verbose(3) << "Not Queueing, is the Root bond";
+            else if (ShortestPathList[OtherAtom->nr] >= BondOrder)
+              *out << Verbose(3) << "Not Queueing, is out of Bond Count of " << BondOrder;
+            if (!Binder->Cyclic)
+              *out << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl;
+            if (AddedBondList[Binder->nr] == NULL) {
+              if ((AddedAtomList[OtherAtom->nr] != NULL)) { // .. whether we add or saturate
+                AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+                AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+                AddedBondList[Binder->nr]->Type = Binder->Type;
+              } else {
 #ifdef ADDHYDROGEN
                                                                 if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
                                                                         exit(1);
+                if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                  exit(1);
 #endif
+                                                        }
+                                                }
+                                        }
                                 } else {
                                         *out << Verbose(3) << "Not Adding, has already been visited." << endl;
                                         // This has to be a cyclic bond, check whether it's present ...
                                         if (AddedBondList[Binder->nr] == NULL) {
                                                 if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
                                                         AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
                                                         AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
                                                         AddedBondList[Binder->nr]->Type = Binder->Type;
                                                 } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
+              }
+            }
+          }
+        } else {
+          *out << Verbose(3) << "Not Adding, has already been visited." << endl;
+          // This has to be a cyclic bond, check whether it's present ...
+          if (AddedBondList[Binder->nr] == NULL) {
+            if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
+              AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
+              AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
+              AddedBondList[Binder->nr]->Type = Binder->Type;
+            } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
 #ifdef ADDHYDROGEN
                                                         if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
                                                                 exit(1);
+              if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                exit(1);
 #endif
+                                                }
+                                        }
+                                }
+                        }
+                }
                 ColorList[Walker->nr] = black;
                 *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+        }
         Free((void **)&PredecessorList, "molecule::BreadthFirstSearchAdd: **PredecessorList");
         Free((void **)&ShortestPathList, "molecule::BreadthFirstSearchAdd: **ShortestPathList");
         Free((void **)&ColorList, "molecule::BreadthFirstSearchAdd: **ColorList");
         delete(AtomStack);
+            }
+          }
+        }
+      }
+    }
+    ColorList[Walker->nr] = black;
+    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+  }
+  Free((void **)&PredecessorList, "molecule::BreadthFirstSearchAdd: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::BreadthFirstSearchAdd: **ShortestPathList");
+  Free((void **)&ColorList, "molecule::BreadthFirstSearchAdd: **ColorList");
+  delete(AtomStack);
 };
 …
 bool molecule::BuildInducedSubgraph(ofstream *out, const molecule *Father)
+{
         atom *Walker = NULL, *OtherAtom = NULL;
         bool status = true;
         atom **ParentList = (atom **) Malloc(sizeof(atom *)*Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
         *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
         // reset parent list
         *out << Verbose(3) << "Resetting ParentList." << endl;
         for (int i=Father->AtomCount;i--;)
                 ParentList[i] = NULL;
         // fill parent list with sons
         *out << Verbose(3) << "Filling Parent List." << endl;
         Walker = start;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 ParentList[Walker->father->nr] = Walker;
                 // Outputting List for debugging
                 *out << Verbose(4) << "Son["<< Walker->father->nr <<"] of " << Walker->father <<        " is " << ParentList[Walker->father->nr] << "." << endl;
+        }
         // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
         *out << Verbose(3) << "Creating bonds." << endl;
         Walker = Father->start;
         while (Walker->next != Father->end) {
                 Walker = Walker->next;
                 if (ParentList[Walker->nr] != NULL) {
                         if (ParentList[Walker->nr]->father != Walker) {
                                 status = false;
                         } else {
                                 for (int i=0;i<Father->NumberOfBondsPerAtom[Walker->nr];i++) {
                                         OtherAtom = Father->ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
                                         if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
                                                 *out << Verbose(4) << "Endpoints of Bond " << Father->ListOfBondsPerAtom[Walker->nr][i] << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
                                                 AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], Father->ListOfBondsPerAtom[Walker->nr][i]->BondDegree);
+                                        }
+                                }
+                        }
+                }
+        }
         Free((void **)&ParentList, "molecule::BuildInducedSubgraph: **ParentList");
         *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
         return status;
+  atom *Walker = NULL, *OtherAtom = NULL;
+  bool status = true;
+  atom **ParentList = (atom **) Malloc(sizeof(atom *)*Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
+  *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
+  // reset parent list
+  *out << Verbose(3) << "Resetting ParentList." << endl;
+  for (int i=Father->AtomCount;i--;)
+    ParentList[i] = NULL;
+  // fill parent list with sons
+  *out << Verbose(3) << "Filling Parent List." << endl;
+  Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ParentList[Walker->father->nr] = Walker;
+    // Outputting List for debugging
+    *out << Verbose(4) << "Son["<< Walker->father->nr <<"] of " << Walker->father <<  " is " << ParentList[Walker->father->nr] << "." << endl;
+  }
+  // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
+  *out << Verbose(3) << "Creating bonds." << endl;
+  Walker = Father->start;
+  while (Walker->next != Father->end) {
+    Walker = Walker->next;
+    if (ParentList[Walker->nr] != NULL) {
+      if (ParentList[Walker->nr]->father != Walker) {
+        status = false;
+      } else {
+        for (int i=0;i<Father->NumberOfBondsPerAtom[Walker->nr];i++) {
+          OtherAtom = Father->ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+          if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
+            *out << Verbose(4) << "Endpoints of Bond " << Father->ListOfBondsPerAtom[Walker->nr][i] << " are both present: " << ParentList[Walker->nr]->Name << " and " << ParentList[OtherAtom->nr]->Name << "." << endl;
+            AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], Father->ListOfBondsPerAtom[Walker->nr][i]->BondDegree);
+          }
+        }
+      }
+    }
+  }
+  Free((void **)&ParentList, "molecule::BuildInducedSubgraph: **ParentList");
+  *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
+  return status;
 };
 …
 int molecule::LookForRemovalCandidate(ofstream *&out, KeySet *&Leaf, int *&ShortestPathList)
+{
         atom *Runner = NULL;
         int SP, Removal;
         *out << Verbose(2) << "Looking for removal candidate." << endl;
         SP = -1; //0;   // not -1, so that Root is never removed
         Removal = -1;
         for (KeySet::iterator runner = Leaf->begin(); runner != Leaf->end(); runner++) {
                 Runner = FindAtom((*runner));
                 if (Runner->type->Z != 1) { // skip all those added hydrogens when re-filling snake stack
                         if (ShortestPathList[(*runner)] > SP) { // remove the oldest one with longest shortest path
                                 SP = ShortestPathList[(*runner)];
                                 Removal = (*runner);
+                        }
+                }
+        }
         return Removal;
+  atom *Runner = NULL;
+  int SP, Removal;
+  *out << Verbose(2) << "Looking for removal candidate." << endl;
+  SP = -1; //0;  // not -1, so that Root is never removed
+  Removal = -1;
+  for (KeySet::iterator runner = Leaf->begin(); runner != Leaf->end(); runner++) {
+    Runner = FindAtom((*runner));
+    if (Runner->type->Z != 1) { // skip all those added hydrogens when re-filling snake stack
+      if (ShortestPathList[(*runner)] > SP) {  // remove the oldest one with longest shortest path
+        SP = ShortestPathList[(*runner)];
+        Removal = (*runner);
+      }
+    }
+  }
+  return Removal;
 };
 …
 molecule * molecule::StoreFragmentFromKeySet(ofstream *out, KeySet &Leaflet, bool IsAngstroem)
+{
         atom *Runner = NULL, *FatherOfRunner = NULL, *OtherFather = NULL;
         atom **SonList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::StoreFragmentFromStack: **SonList");
         molecule *Leaf = new molecule(elemente);
         bool LonelyFlag = false;
         int size;
 //      *out << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
         Leaf->BondDistance = BondDistance;
         for(int i=NDIM*2;i--;)
                 Leaf->cell_size[i] = cell_size[i];
         // initialise SonList (indicates when we need to replace a bond with hydrogen instead)
         for(int i=AtomCount;i--;)
                 SonList[i] = NULL;
         // first create the minimal set of atoms from the KeySet
         size = 0;
         for(KeySet::iterator runner = Leaflet.begin(); runner != Leaflet.end(); runner++) {
                 FatherOfRunner = FindAtom((*runner));   // find the id
                 SonList[FatherOfRunner->nr] = Leaf->AddCopyAtom(FatherOfRunner);
                 size++;
+        }
         // create the bonds between all: Make it an induced subgraph and add hydrogen
 //      *out << Verbose(2) << "Creating bonds from father graph (i.e. induced subgraph creation)." << endl;
         Runner = Leaf->start;
         while (Runner->next != Leaf->end) {
                 Runner = Runner->next;
                 LonelyFlag = true;
                 FatherOfRunner = Runner->father;
                 if (SonList[FatherOfRunner->nr] != NULL)        {       // check if this, our father, is present in list
                         // create all bonds
                         for (int i=0;i<NumberOfBondsPerAtom[FatherOfRunner->nr];i++) { // go through every bond of father
                                 OtherFather = ListOfBondsPerAtom[FatherOfRunner->nr][i]->GetOtherAtom(FatherOfRunner);
 //                              *out << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->nr] << " is bound to " << *OtherFather;
                                 if (SonList[OtherFather->nr] != NULL) {
 //                                      *out << ", whose son is " << *SonList[OtherFather->nr] << "." << endl;
                                         if (OtherFather->nr > FatherOfRunner->nr) { // add bond (nr check is for adding only one of both variants: ab, ba)
 //                                              *out << Verbose(3) << "Adding Bond: ";
 //                                              *out <<
                                                 Leaf->AddBond(Runner, SonList[OtherFather->nr], ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree);
 //                                              *out << "." << endl;
                                                 //NumBonds[Runner->nr]++;
                                         } else {
 //                                              *out << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
+                                        }
                                         LonelyFlag = false;
                                 } else {
 //                                      *out << ", who has no son in this fragment molecule." << endl;
+  atom *Runner = NULL, *FatherOfRunner = NULL, *OtherFather = NULL;
+  atom **SonList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  molecule *Leaf = new molecule(elemente);
+  bool LonelyFlag = false;
+  int size;
+//  *out << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
+  Leaf->BondDistance = BondDistance;
+  for(int i=NDIM*2;i--;)
+    Leaf->cell_size[i] = cell_size[i];
+  // initialise SonList (indicates when we need to replace a bond with hydrogen instead)
+  for(int i=AtomCount;i--;)
+    SonList[i] = NULL;
+  // first create the minimal set of atoms from the KeySet
+  size = 0;
+  for(KeySet::iterator runner = Leaflet.begin(); runner != Leaflet.end(); runner++) {
+    FatherOfRunner = FindAtom((*runner));  // find the id
+    SonList[FatherOfRunner->nr] = Leaf->AddCopyAtom(FatherOfRunner);
+    size++;
+  }
+  // create the bonds between all: Make it an induced subgraph and add hydrogen
+//  *out << Verbose(2) << "Creating bonds from father graph (i.e. induced subgraph creation)." << endl;
+  Runner = Leaf->start;
+  while (Runner->next != Leaf->end) {
+    Runner = Runner->next;
+    LonelyFlag = true;
+    FatherOfRunner = Runner->father;
+    if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
+      // create all bonds
+      for (int i=0;i<NumberOfBondsPerAtom[FatherOfRunner->nr];i++) { // go through every bond of father
+        OtherFather = ListOfBondsPerAtom[FatherOfRunner->nr][i]->GetOtherAtom(FatherOfRunner);
+//        *out << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->nr] << " is bound to " << *OtherFather;
+        if (SonList[OtherFather->nr] != NULL) {
+//          *out << ", whose son is " << *SonList[OtherFather->nr] << "." << endl;
+          if (OtherFather->nr > FatherOfRunner->nr) { // add bond (nr check is for adding only one of both variants: ab, ba)
+//            *out << Verbose(3) << "Adding Bond: ";
+//            *out <<
+            Leaf->AddBond(Runner, SonList[OtherFather->nr], ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree);
+//            *out << "." << endl;
+            //NumBonds[Runner->nr]++;
+          } else {
+//            *out << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
+          }
+          LonelyFlag = false;
+        } else {
+//          *out << ", who has no son in this fragment molecule." << endl;
 #ifdef ADDHYDROGEN
                                         //*out << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
                                         if(!Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem))
                                                 exit(1);
+          //*out << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
+          if(!Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem))
+            exit(1);
 #endif
                                         //NumBonds[Runner->nr] += ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree;
+                                }
+                        }
                 } else {
                         *out << Verbose(0) << "ERROR: Son " << Runner->Name << " has father " << FatherOfRunner->Name << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl;
+                }
                 if ((LonelyFlag) && (size > 1)) {
                         *out << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl;
+                }
+          //NumBonds[Runner->nr] += ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree;
+        }
+      }
+    } else {
+      *out << Verbose(0) << "ERROR: Son " << Runner->Name << " has father " << FatherOfRunner->Name << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl;
+    }
+    if ((LonelyFlag) && (size > 1)) {
+      *out << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl;
+    }
 #ifdef ADDHYDROGEN
                 while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
                         Runner = Runner->next;
+    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
+      Runner = Runner->next;
 #endif
+        }
         Leaf->CreateListOfBondsPerAtom(out);
         //Leaflet->Leaf->ScanForPeriodicCorrection(out);
         Free((void **)&SonList, "molecule::StoreFragmentFromStack: **SonList");
 //      *out << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
         return Leaf;
+  }
+  Leaf->CreateListOfBondsPerAtom(out);
+  //Leaflet->Leaf->ScanForPeriodicCorrection(out);
+  Free((void **)&SonList, "molecule::StoreFragmentFromStack: **SonList");
+//  *out << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
+  return Leaf;
 };
 …
  */
 struct UniqueFragments {
         config *configuration;
         atom *Root;
         Graph *Leaflet;
         KeySet *FragmentSet;
         int ANOVAOrder;
         int FragmentCounter;
         int CurrentIndex;
         double TEFactor;
         int *ShortestPathList;
         bool **UsedList;
         bond **BondsPerSPList;
         int *BondsPerSPCount;
+  config *configuration;
+  atom *Root;
+  Graph *Leaflet;
+  KeySet *FragmentSet;
+  int ANOVAOrder;
+  int FragmentCounter;
+  int CurrentIndex;
+  double TEFactor;
+  int *ShortestPathList;
+  bool **UsedList;
+  bond **BondsPerSPList;
+  int *BondsPerSPCount;
 };
 /** From a given set of Bond sorted by Shortest Path distance, create all possible fragments of size \a SetDimension.
  * -# loops over every possible combination (2^dimension of edge set)
  *      -# inserts current set, if there's still space left
  *              -# yes: calls SPFragmentGenerator with structure, created new edge list and size respective to root dist
+ *  -# inserts current set, if there's still space left
+ *    -# yes: calls SPFragmentGenerator with structure, created new edge list and size respective to root dist
 ance+1
  *              -# no: stores fragment into keyset list by calling InsertFragmentIntoGraph
  *      -# removes all items added into the snake stack (in UniqueFragments structure) added during level (root
+ *    -# no: stores fragment into keyset list by calling InsertFragmentIntoGraph
+ *  -# removes all items added into the snake stack (in UniqueFragments structure) added during level (root
 distance) and current set
  * \param *out output stream for debugging
 …
 void molecule::SPFragmentGenerator(ofstream *out, struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder)
+{
         atom *OtherWalker = NULL;
         int verbosity = 0; //FragmentSearch->ANOVAOrder-SubOrder;
         int NumCombinations;
         bool bit;
         int bits, TouchedIndex, SubSetDimension, SP, Added;
         int Removal;
         int SpaceLeft;
         int *TouchedList = (int *) Malloc(sizeof(int)*(SubOrder+1), "molecule::SPFragmentGenerator: *TouchedList");
         bond *Binder = NULL;
         bond **BondsList = NULL;
         KeySetTestPair TestKeySetInsert;
         NumCombinations = 1 << SetDimension;
         // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
         // von Endstuecken (aus den Bonds) hinzugefï¿œï¿œgt werden und fï¿œï¿œr verbleibende ANOVAOrder
         // rekursiv GraphCrawler in der nï¿œï¿œchsten Ebene aufgerufen werden
         *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
         *out << Verbose(1+verbosity) << "We are " << RootDistance << " away from Root, which is " << *FragmentSearch->Root << ", SubOrder is " << SubOrder << ", SetDimension is " << SetDimension << " and this means " <<     NumCombinations-1 << " combination(s)." << endl;
         // initialised touched list (stores added atoms on this level)
         *out << Verbose(1+verbosity) << "Clearing touched list." << endl;
         for (TouchedIndex=SubOrder+1;TouchedIndex--;)   // empty touched list
                 TouchedList[TouchedIndex] = -1;
         TouchedIndex = 0;
         // create every possible combination of the endpieces
         *out << Verbose(1+verbosity) << "Going through all combinations of the power set." << endl;
         for (int i=1;i<NumCombinations;i++) {   // sweep through all power set combinations (skip empty set!)
                 // count the set bit of i
                 bits = 0;
                 for (int j=SetDimension;j--;)
                         bits += (i & (1 << j)) >> j;
                 *out << Verbose(1+verbosity) << "Current set is " << Binary(i | (1 << SetDimension)) << ", number of bits is " << bits << "." << endl;
                 if (bits <= SubOrder) { // if not greater than additional atoms allowed on stack, continue
                         // --1-- add this set of the power set of bond partners to the snake stack
                         Added = 0;
                         for (int j=0;j<SetDimension;j++) {      // pull out every bit by shifting
                                 bit = ((i & (1 << j)) != 0);    // mask the bit for the j-th bond
                                 if (bit) {      // if bit is set, we add this bond partner
                                         OtherWalker = BondsSet[j]->rightatom;   // rightatom is always the one more distant, i.e. the one to add
                                         //*out << Verbose(1+verbosity) << "Current Bond is " << ListOfBondsPerAtom[Walker->nr][i] << ", checking on " << *OtherWalker << "." << endl;
                                         *out << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->nr << "." << endl;
                                         TestKeySetInsert = FragmentSearch->FragmentSet->insert(OtherWalker->nr);
                                         if (TestKeySetInsert.second) {
                                                 TouchedList[TouchedIndex++] = OtherWalker->nr;  // note as added
                                                 Added++;
                                         } else {
                                                 *out << Verbose(2+verbosity) << "This was item was already present in the keyset." << endl;
+                                        }
                                                 //FragmentSearch->UsedList[OtherWalker->nr][i] = true;
                                         //}
                                 } else {
                                         *out << Verbose(2+verbosity) << "Not adding." << endl;
+                                }
+                        }
                         SpaceLeft = SubOrder - Added ;// SubOrder - bits; // due to item's maybe being already present, this does not work anymore
                         if (SpaceLeft > 0) {
                                 *out << Verbose(1+verbosity) << "There's still some space left on stack: " << SpaceLeft << "." << endl;
                                 if (SubOrder > 1) {             // Due to Added above we have to check extra whether we're not already reaching beyond the desired Order
                                         // --2-- look at all added end pieces of this combination, construct bond subsets and sweep through a power set of these by recursion
                                         SP = RootDistance+1;    // this is the next level
                                         // first count the members in the subset
                                         SubSetDimension = 0;
                                         Binder = FragmentSearch->BondsPerSPList[2*SP];          // start node for this level
                                         while (Binder->next != FragmentSearch->BondsPerSPList[2*SP+1]) {                // compare to end node of this level
                                                 Binder = Binder->next;
                                                 for (int k=TouchedIndex;k--;) {
                                                         if (Binder->Contains(TouchedList[k]))    // if we added this very endpiece
                                                                 SubSetDimension++;
+                                                }
+                                        }
                                         // then allocate and fill the list
                                         BondsList = (bond **) Malloc(sizeof(bond *)*SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
                                         SubSetDimension = 0;
                                         Binder = FragmentSearch->BondsPerSPList[2*SP];
                                         while (Binder->next != FragmentSearch->BondsPerSPList[2*SP+1]) {
                                                 Binder = Binder->next;
                                                 for (int k=0;k<TouchedIndex;k++) {
                                                         if (Binder->leftatom->nr == TouchedList[k])      // leftatom is always the close one
                                                                 BondsList[SubSetDimension++] = Binder;
+                                                }
+                                        }
                                         *out << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
                                         SPFragmentGenerator(out, FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
                                         Free((void **)&BondsList, "molecule::SPFragmentGenerator: **BondsList");
+                                }
                         } else {
                                 // --2-- otherwise store the complete fragment
                                 *out << Verbose(1+verbosity) << "Enough items on stack for a fragment!" << endl;
                                 // store fragment as a KeySet
                                 *out << Verbose(2) << "Found a new fragment[" << FragmentSearch->FragmentCounter << "], local nr.s are: ";
                                 for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
                                         *out << (*runner) << " ";
                                 *out << endl;
                                 //if (!CheckForConnectedSubgraph(out, FragmentSearch->FragmentSet))
                                         //*out << Verbose(0) << "ERROR: The found fragment is not a connected subgraph!" << endl;
                                 InsertFragmentIntoGraph(out, FragmentSearch);
                                 //Removal = LookForRemovalCandidate(out, FragmentSearch->FragmentSet, FragmentSearch->ShortestPathList);
                                 //Removal = StoreFragmentFromStack(out, FragmentSearch->Root, FragmentSearch->Leaflet, FragmentSearch->FragmentStack, FragmentSearch->ShortestPathList, &FragmentSearch->FragmentCounter, FragmentSearch->configuration);
+                        }
                         // --3-- remove all added items in this level from snake stack
                         *out << Verbose(1+verbosity) << "Removing all items that were added on this SP level " << RootDistance << "." << endl;
                         for(int j=0;j<TouchedIndex;j++) {
                                 Removal = TouchedList[j];
                                 *out << Verbose(2+verbosity) << "Removing item nr. " << Removal << " from snake stack." << endl;
                                 FragmentSearch->FragmentSet->erase(Removal);
                                 TouchedList[j] = -1;
+                        }
                         *out << Verbose(2) << "Remaining local nr.s on snake stack are: ";
                         for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
                                 *out << (*runner) << " ";
                         *out << endl;
                         TouchedIndex = 0; // set Index to 0 for list of atoms added on this level
                 } else {
                         *out << Verbose(2+verbosity) << "More atoms to add for this set (" << bits << ") than space left on stack " << SubOrder << ", skipping this set." << endl;
+                }
+        }
         Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");
         *out << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
+  atom *OtherWalker = NULL;
+  int verbosity = 0; //FragmentSearch->ANOVAOrder-SubOrder;
+  int NumCombinations;
+  bool bit;
+  int bits, TouchedIndex, SubSetDimension, SP, Added;
+  int Removal;
+  int SpaceLeft;
+  int *TouchedList = (int *) Malloc(sizeof(int)*(SubOrder+1), "molecule::SPFragmentGenerator: *TouchedList");
+  bond *Binder = NULL;
+  bond **BondsList = NULL;
+  KeySetTestPair TestKeySetInsert;
+  NumCombinations = 1 << SetDimension;
+  // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
+  // von Endstuecken (aus den Bonds) hinzugefï¿œï¿œgt werden und fï¿œï¿œr verbleibende ANOVAOrder
+  // rekursiv GraphCrawler in der nï¿œï¿œchsten Ebene aufgerufen werden
+  *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
+  *out << Verbose(1+verbosity) << "We are " << RootDistance << " away from Root, which is " << *FragmentSearch->Root << ", SubOrder is " << SubOrder << ", SetDimension is " << SetDimension << " and this means " <<  NumCombinations-1 << " combination(s)." << endl;
+  // initialised touched list (stores added atoms on this level)
+  *out << Verbose(1+verbosity) << "Clearing touched list." << endl;
+  for (TouchedIndex=SubOrder+1;TouchedIndex--;)  // empty touched list
+    TouchedList[TouchedIndex] = -1;
+  TouchedIndex = 0;
+  // create every possible combination of the endpieces
+  *out << Verbose(1+verbosity) << "Going through all combinations of the power set." << endl;
+  for (int i=1;i<NumCombinations;i++) {  // sweep through all power set combinations (skip empty set!)
+    // count the set bit of i
+    bits = 0;
+    for (int j=SetDimension;j--;)
+      bits += (i & (1 << j)) >> j;
+    *out << Verbose(1+verbosity) << "Current set is " << Binary(i | (1 << SetDimension)) << ", number of bits is " << bits << "." << endl;
+    if (bits <= SubOrder) { // if not greater than additional atoms allowed on stack, continue
+      // --1-- add this set of the power set of bond partners to the snake stack
+      Added = 0;
+      for (int j=0;j<SetDimension;j++) {  // pull out every bit by shifting
+        bit = ((i & (1 << j)) != 0);  // mask the bit for the j-th bond
+        if (bit) {  // if bit is set, we add this bond partner
+          OtherWalker = BondsSet[j]->rightatom;  // rightatom is always the one more distant, i.e. the one to add
+          //*out << Verbose(1+verbosity) << "Current Bond is " << ListOfBondsPerAtom[Walker->nr][i] << ", checking on " << *OtherWalker << "." << endl;
+          *out << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->nr << "." << endl;
+          TestKeySetInsert = FragmentSearch->FragmentSet->insert(OtherWalker->nr);
+          if (TestKeySetInsert.second) {
+            TouchedList[TouchedIndex++] = OtherWalker->nr;  // note as added
+            Added++;
+          } else {
+            *out << Verbose(2+verbosity) << "This was item was already present in the keyset." << endl;
+          }
+            //FragmentSearch->UsedList[OtherWalker->nr][i] = true;
+          //}
+        } else {
+          *out << Verbose(2+verbosity) << "Not adding." << endl;
+        }
+      }
+      SpaceLeft = SubOrder - Added ;// SubOrder - bits; // due to item's maybe being already present, this does not work anymore
+      if (SpaceLeft > 0) {
+        *out << Verbose(1+verbosity) << "There's still some space left on stack: " << SpaceLeft << "." << endl;
+        if (SubOrder > 1) {    // Due to Added above we have to check extra whether we're not already reaching beyond the desired Order
+          // --2-- look at all added end pieces of this combination, construct bond subsets and sweep through a power set of these by recursion
+          SP = RootDistance+1;  // this is the next level
+          // first count the members in the subset
+          SubSetDimension = 0;
+          Binder = FragmentSearch->BondsPerSPList[2*SP];    // start node for this level
+          while (Binder->next != FragmentSearch->BondsPerSPList[2*SP+1]) {    // compare to end node of this level
+            Binder = Binder->next;
+            for (int k=TouchedIndex;k--;) {
+              if (Binder->Contains(TouchedList[k]))   // if we added this very endpiece
+                SubSetDimension++;
+            }
+          }
+          // then allocate and fill the list
+          BondsList = (bond **) Malloc(sizeof(bond *)*SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
+          SubSetDimension = 0;
+          Binder = FragmentSearch->BondsPerSPList[2*SP];
+          while (Binder->next != FragmentSearch->BondsPerSPList[2*SP+1]) {
+            Binder = Binder->next;
+            for (int k=0;k<TouchedIndex;k++) {
+              if (Binder->leftatom->nr == TouchedList[k])   // leftatom is always the close one
+                BondsList[SubSetDimension++] = Binder;
+            }
+          }
+          *out << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
+          SPFragmentGenerator(out, FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
+          Free((void **)&BondsList, "molecule::SPFragmentGenerator: **BondsList");
+        }
+      } else {
+        // --2-- otherwise store the complete fragment
+        *out << Verbose(1+verbosity) << "Enough items on stack for a fragment!" << endl;
+        // store fragment as a KeySet
+        *out << Verbose(2) << "Found a new fragment[" << FragmentSearch->FragmentCounter << "], local nr.s are: ";
+        for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
+          *out << (*runner) << " ";
+        *out << endl;
+        //if (!CheckForConnectedSubgraph(out, FragmentSearch->FragmentSet))
+          //*out << Verbose(0) << "ERROR: The found fragment is not a connected subgraph!" << endl;
+        InsertFragmentIntoGraph(out, FragmentSearch);
+        //Removal = LookForRemovalCandidate(out, FragmentSearch->FragmentSet, FragmentSearch->ShortestPathList);
+        //Removal = StoreFragmentFromStack(out, FragmentSearch->Root, FragmentSearch->Leaflet, FragmentSearch->FragmentStack, FragmentSearch->ShortestPathList, &FragmentSearch->FragmentCounter, FragmentSearch->configuration);
+      }
+      // --3-- remove all added items in this level from snake stack
+      *out << Verbose(1+verbosity) << "Removing all items that were added on this SP level " << RootDistance << "." << endl;
+      for(int j=0;j<TouchedIndex;j++) {
+        Removal = TouchedList[j];
+        *out << Verbose(2+verbosity) << "Removing item nr. " << Removal << " from snake stack." << endl;
+        FragmentSearch->FragmentSet->erase(Removal);
+        TouchedList[j] = -1;
+      }
+      *out << Verbose(2) << "Remaining local nr.s on snake stack are: ";
+      for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
+        *out << (*runner) << " ";
+      *out << endl;
+      TouchedIndex = 0; // set Index to 0 for list of atoms added on this level
+    } else {
+      *out << Verbose(2+verbosity) << "More atoms to add for this set (" << bits << ") than space left on stack " << SubOrder << ", skipping this set." << endl;
+    }
+  }
+  Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");
+  *out << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
 …
 bool molecule::CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment)
+{
         atom *Walker = NULL, *Walker2 = NULL;
         bool BondStatus = false;
         int size;
         *out << Verbose(1) << "Begin of CheckForConnectedSubgraph" << endl;
         *out << Verbose(2) << "Disconnected atom: ";
         // count number of atoms in graph
         size = 0;
         for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
                 size++;
         if (size > 1)
                 for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
                         Walker = FindAtom(*runner);
                         BondStatus = false;
                         for(KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
                                 Walker2 = FindAtom(*runners);
                                 for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
                                         if (ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker) == Walker2) {
                                                 BondStatus = true;
                                                 break;
+                                        }
                                         if (BondStatus)
                                                 break;
+                                }
+                        }
                         if (!BondStatus) {
                                 *out << (*Walker) << endl;
                                 return false;
+                        }
+                }
         else {
                 *out << "none." << endl;
                 return true;
+        }
         *out << "none." << endl;
         *out << Verbose(1) << "End of CheckForConnectedSubgraph" << endl;
         return true;
+  atom *Walker = NULL, *Walker2 = NULL;
+  bool BondStatus = false;
+  int size;
+  *out << Verbose(1) << "Begin of CheckForConnectedSubgraph" << endl;
+  *out << Verbose(2) << "Disconnected atom: ";
+  // count number of atoms in graph
+  size = 0;
+  for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++)
+    size++;
+  if (size > 1)
+    for(KeySet::iterator runner = Fragment->begin(); runner != Fragment->end(); runner++) {
+      Walker = FindAtom(*runner);
+      BondStatus = false;
+      for(KeySet::iterator runners = Fragment->begin(); runners != Fragment->end(); runners++) {
+        Walker2 = FindAtom(*runners);
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr]; i++) {
+          if (ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker) == Walker2) {
+            BondStatus = true;
+            break;
+          }
+          if (BondStatus)
+            break;
+        }
+      }
+      if (!BondStatus) {
+        *out << (*Walker) << endl;
+        return false;
+      }
+    }
+  else {
+    *out << "none." << endl;
+    return true;
+  }
+  *out << "none." << endl;
+  *out << Verbose(1) << "End of CheckForConnectedSubgraph" << endl;
+  return true;
+}
 …
 int molecule::PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet)
+{
         int SP, AtomKeyNr;
         atom *Walker = NULL, *OtherWalker = NULL, *Predecessor = NULL;
         bond *Binder = NULL;
         bond *CurrentEdge = NULL;
         bond **BondsList = NULL;
         int RootKeyNr = FragmentSearch.Root->GetTrueFather()->nr;
         int Counter = FragmentSearch.FragmentCounter;
         int RemainingWalkers;
         *out << endl;
         *out << Verbose(0) << "Begin of PowerSetGenerator with order " << Order << " at Root " << *FragmentSearch.Root << "." << endl;
         // prepare Label and SP arrays of the BFS search
         FragmentSearch.ShortestPathList[FragmentSearch.Root->nr] = 0;
         // prepare root level (SP = 0) and a loop bond denoting Root
         for (int i=1;i<Order;i++)
                 FragmentSearch.BondsPerSPCount[i] = 0;
         FragmentSearch.BondsPerSPCount[0] = 1;
         Binder = new bond(FragmentSearch.Root, FragmentSearch.Root);
         add(Binder, FragmentSearch.BondsPerSPList[1]);
         // do a BFS search to fill the SP lists and label the found vertices
         // Actually, we should construct a spanning tree vom the root atom and select all edges therefrom and put them into
         // according shortest path lists. However, we don't. Rather we fill these lists right away, as they do form a spanning
         // tree already sorted into various SP levels. That's why we just do loops over the depth (CurrentSP) and breadth
         // (EdgeinSPLevel) of this tree ...
         // In another picture, the bonds always contain a direction by rightatom being the one more distant from root and hence
         // naturally leftatom forming its predecessor, preventing the BFS"seeker" from continuing in the wrong direction.
         *out << endl;
         *out << Verbose(0) << "Starting BFS analysis ..." << endl;
         for (SP = 0; SP < (Order-1); SP++) {
                 *out << Verbose(1) << "New SP level reached: " << SP << ", creating new SP list with " << FragmentSearch.BondsPerSPCount[SP] << " item(s)";
                 if (SP > 0) {
                         *out << ", old level closed with " << FragmentSearch.BondsPerSPCount[SP-1] << " item(s)." << endl;
                         FragmentSearch.BondsPerSPCount[SP] = 0;
                 } else
                         *out << "." << endl;
                 RemainingWalkers = FragmentSearch.BondsPerSPCount[SP];
                 CurrentEdge = FragmentSearch.BondsPerSPList[2*SP];              /// start of this SP level's list
                 while (CurrentEdge->next != FragmentSearch.BondsPerSPList[2*SP+1]) {            /// end of this SP level's list
                         CurrentEdge = CurrentEdge->next;
                         RemainingWalkers--;
                         Walker = CurrentEdge->rightatom;                // rightatom is always the one more distant
                         Predecessor = CurrentEdge->leftatom;            // ... and leftatom is predecessor
                         AtomKeyNr = Walker->nr;
                         *out << Verbose(0) << "Current Walker is: " << *Walker << " with nr " << Walker->nr << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level." << endl;
                         // check for new sp level
                         // go through all its bonds
                         *out << Verbose(1) << "Going through all bonds of Walker." << endl;
                         for (int i=0;i<NumberOfBondsPerAtom[AtomKeyNr];i++) {
                                 Binder = ListOfBondsPerAtom[AtomKeyNr][i];
                                 OtherWalker = Binder->GetOtherAtom(Walker);
                                 if ((RestrictedKeySet.find(OtherWalker->nr) != RestrictedKeySet.end())
         #ifdef ADDHYDROGEN
                                  && (OtherWalker->type->Z != 1)
         #endif
                                                                                                                                                                                                                                                         ) {     // skip hydrogens and restrict to fragment
                                         *out << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->nr << " in bond " << *Binder << "." << endl;
                                         // set the label if not set (and push on root stack as well)
                                         if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->nr > RootKeyNr)) { // only pass through those with label bigger than Root's
                                                 FragmentSearch.ShortestPathList[OtherWalker->nr] = SP+1;
                                                 *out << Verbose(3) << "Set Shortest Path to " << FragmentSearch.ShortestPathList[OtherWalker->nr] << "." << endl;
                                                 // add the bond in between to the SP list
                                                 Binder = new bond(Walker, OtherWalker); // create a new bond in such a manner, that bond::rightatom is always the one more distant
                                                 add(Binder, FragmentSearch.BondsPerSPList[2*(SP+1)+1]);
                                                 FragmentSearch.BondsPerSPCount[SP+1]++;
                                                 *out << Verbose(3) << "Added its bond to SP list, having now " << FragmentSearch.BondsPerSPCount[SP+1] << " item(s)." << endl;
                                         } else {
                                                 if (OtherWalker != Predecessor)
                                                         *out << Verbose(3) << "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->nr << " is smaller than that of Root " << RootKeyNr << "." << endl;
                                                 else
                                                         *out << Verbose(3) << "This is my predecessor " << *Predecessor << "." << endl;
+                                        }
                                 } else *out << Verbose(2) << "Is not in the restricted keyset or skipping hydrogen " << *OtherWalker << "." << endl;
+                        }
+                }
+        }
         // outputting all list for debugging
         *out << Verbose(0) << "Printing all found lists." << endl;
         for(int i=1;i<Order;i++) {              // skip the root edge in the printing
                 Binder = FragmentSearch.BondsPerSPList[2*i];
                 *out << Verbose(1) << "Current SP level is " << i << "." << endl;
                 while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
                         Binder = Binder->next;
                         *out << Verbose(2) << *Binder << endl;
+                }
+        }
         // creating fragments with the found edge sets  (may be done in reverse order, faster)
         SP = -1;        // the Root <-> Root edge must be subtracted!
         for(int i=Order;i--;) { // sum up all found edges
                 Binder = FragmentSearch.BondsPerSPList[2*i];
                 while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
                         Binder = Binder->next;
                         SP ++;
+                }
+        }
         *out << Verbose(0) << "Total number of edges is " << SP << "." << endl;
         if (SP >= (Order-1)) {
                 // start with root (push on fragment stack)
                 *out << Verbose(0) << "Starting fragment generation with " << *FragmentSearch.Root << ", local nr is " << FragmentSearch.Root->nr << "." << endl;
                 FragmentSearch.FragmentSet->clear();
                 *out << Verbose(0) << "Preparing subset for this root and calling generator." << endl;
                 // prepare the subset and call the generator
                 BondsList = (bond **) Malloc(sizeof(bond *)*FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
                 BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
                 SPFragmentGenerator(out, &FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
                 Free((void **)&BondsList, "molecule::PowerSetGenerator: **BondsList");
         } else {
                 *out << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl;
+        }
         // as FragmentSearch structure is used only once, we don't have to clean it anymore
         // remove root from stack
         *out << Verbose(0) << "Removing root again from stack." << endl;
         FragmentSearch.FragmentSet->erase(FragmentSearch.Root->nr);
         // free'ing the bonds lists
         *out << Verbose(0) << "Free'ing all found lists. and resetting index lists" << endl;
         for(int i=Order;i--;) {
                 *out << Verbose(1) << "Current SP level is " << i << ": ";
                 Binder = FragmentSearch.BondsPerSPList[2*i];
                 while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
                         Binder = Binder->next;
                         // *out << "Removing atom " << Binder->leftatom->nr << " and " << Binder->rightatom->nr << "." << endl; // make sure numbers are local
                         FragmentSearch.ShortestPathList[Binder->leftatom->nr] = -1;
                         FragmentSearch.ShortestPathList[Binder->rightatom->nr] = -1;
+                }
                 // delete added bonds
                 cleanup(FragmentSearch.BondsPerSPList[2*i], FragmentSearch.BondsPerSPList[2*i+1]);
                 // also start and end node
                 *out << "cleaned." << endl;
+        }
         // return list
         *out << Verbose(0) << "End of PowerSetGenerator." << endl;
         return (FragmentSearch.FragmentCounter - Counter);
+  int SP, AtomKeyNr;
+  atom *Walker = NULL, *OtherWalker = NULL, *Predecessor = NULL;
+  bond *Binder = NULL;
+  bond *CurrentEdge = NULL;
+  bond **BondsList = NULL;
+  int RootKeyNr = FragmentSearch.Root->GetTrueFather()->nr;
+  int Counter = FragmentSearch.FragmentCounter;
+  int RemainingWalkers;
+  *out << endl;
+  *out << Verbose(0) << "Begin of PowerSetGenerator with order " << Order << " at Root " << *FragmentSearch.Root << "." << endl;
+  // prepare Label and SP arrays of the BFS search
+  FragmentSearch.ShortestPathList[FragmentSearch.Root->nr] = 0;
+  // prepare root level (SP = 0) and a loop bond denoting Root
+  for (int i=1;i<Order;i++)
+    FragmentSearch.BondsPerSPCount[i] = 0;
+  FragmentSearch.BondsPerSPCount[0] = 1;
+  Binder = new bond(FragmentSearch.Root, FragmentSearch.Root);
+  add(Binder, FragmentSearch.BondsPerSPList[1]);
+  // do a BFS search to fill the SP lists and label the found vertices
+  // Actually, we should construct a spanning tree vom the root atom and select all edges therefrom and put them into
+  // according shortest path lists. However, we don't. Rather we fill these lists right away, as they do form a spanning
+  // tree already sorted into various SP levels. That's why we just do loops over the depth (CurrentSP) and breadth
+  // (EdgeinSPLevel) of this tree ...
+  // In another picture, the bonds always contain a direction by rightatom being the one more distant from root and hence
+  // naturally leftatom forming its predecessor, preventing the BFS"seeker" from continuing in the wrong direction.
+  *out << endl;
+  *out << Verbose(0) << "Starting BFS analysis ..." << endl;
+  for (SP = 0; SP < (Order-1); SP++) {
+    *out << Verbose(1) << "New SP level reached: " << SP << ", creating new SP list with " << FragmentSearch.BondsPerSPCount[SP] << " item(s)";
+    if (SP > 0) {
+      *out << ", old level closed with " << FragmentSearch.BondsPerSPCount[SP-1] << " item(s)." << endl;
+      FragmentSearch.BondsPerSPCount[SP] = 0;
+    } else
+      *out << "." << endl;
+    RemainingWalkers = FragmentSearch.BondsPerSPCount[SP];
+    CurrentEdge = FragmentSearch.BondsPerSPList[2*SP];    /// start of this SP level's list
+    while (CurrentEdge->next != FragmentSearch.BondsPerSPList[2*SP+1]) {    /// end of this SP level's list
+      CurrentEdge = CurrentEdge->next;
+      RemainingWalkers--;
+      Walker = CurrentEdge->rightatom;    // rightatom is always the one more distant
+      Predecessor = CurrentEdge->leftatom;    // ... and leftatom is predecessor
+      AtomKeyNr = Walker->nr;
+      *out << Verbose(0) << "Current Walker is: " << *Walker << " with nr " << Walker->nr << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level." << endl;
+      // check for new sp level
+      // go through all its bonds
+      *out << Verbose(1) << "Going through all bonds of Walker." << endl;
+      for (int i=0;i<NumberOfBondsPerAtom[AtomKeyNr];i++) {
+        Binder = ListOfBondsPerAtom[AtomKeyNr][i];
+        OtherWalker = Binder->GetOtherAtom(Walker);
+        if ((RestrictedKeySet.find(OtherWalker->nr) != RestrictedKeySet.end())
+  #ifdef ADDHYDROGEN
+         && (OtherWalker->type->Z != 1)
+  #endif
+                                                              ) {  // skip hydrogens and restrict to fragment
+          *out << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->nr << " in bond " << *Binder << "." << endl;
+          // set the label if not set (and push on root stack as well)
+          if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->nr > RootKeyNr)) { // only pass through those with label bigger than Root's
+            FragmentSearch.ShortestPathList[OtherWalker->nr] = SP+1;
+            *out << Verbose(3) << "Set Shortest Path to " << FragmentSearch.ShortestPathList[OtherWalker->nr] << "." << endl;
+            // add the bond in between to the SP list
+            Binder = new bond(Walker, OtherWalker); // create a new bond in such a manner, that bond::rightatom is always the one more distant
+            add(Binder, FragmentSearch.BondsPerSPList[2*(SP+1)+1]);
+            FragmentSearch.BondsPerSPCount[SP+1]++;
+            *out << Verbose(3) << "Added its bond to SP list, having now " << FragmentSearch.BondsPerSPCount[SP+1] << " item(s)." << endl;
+          } else {
+            if (OtherWalker != Predecessor)
+              *out << Verbose(3) << "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->nr << " is smaller than that of Root " << RootKeyNr << "." << endl;
+            else
+              *out << Verbose(3) << "This is my predecessor " << *Predecessor << "." << endl;
+          }
+        } else *out << Verbose(2) << "Is not in the restricted keyset or skipping hydrogen " << *OtherWalker << "." << endl;
+      }
+    }
+  }
+  // outputting all list for debugging
+  *out << Verbose(0) << "Printing all found lists." << endl;
+  for(int i=1;i<Order;i++) {    // skip the root edge in the printing
+    Binder = FragmentSearch.BondsPerSPList[2*i];
+    *out << Verbose(1) << "Current SP level is " << i << "." << endl;
+    while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
+      Binder = Binder->next;
+      *out << Verbose(2) << *Binder << endl;
+    }
+  }
+  // creating fragments with the found edge sets  (may be done in reverse order, faster)
+  SP = -1;  // the Root <-> Root edge must be subtracted!
+  for(int i=Order;i--;) { // sum up all found edges
+    Binder = FragmentSearch.BondsPerSPList[2*i];
+    while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
+      Binder = Binder->next;
+      SP ++;
+    }
+  }
+  *out << Verbose(0) << "Total number of edges is " << SP << "." << endl;
+  if (SP >= (Order-1)) {
+    // start with root (push on fragment stack)
+    *out << Verbose(0) << "Starting fragment generation with " << *FragmentSearch.Root << ", local nr is " << FragmentSearch.Root->nr << "." << endl;
+    FragmentSearch.FragmentSet->clear();
+    *out << Verbose(0) << "Preparing subset for this root and calling generator." << endl;
+    // prepare the subset and call the generator
+    BondsList = (bond **) Malloc(sizeof(bond *)*FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
+    SPFragmentGenerator(out, &FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
+    Free((void **)&BondsList, "molecule::PowerSetGenerator: **BondsList");
+  } else {
+    *out << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl;
+  }
+  // as FragmentSearch structure is used only once, we don't have to clean it anymore
+  // remove root from stack
+  *out << Verbose(0) << "Removing root again from stack." << endl;
+  FragmentSearch.FragmentSet->erase(FragmentSearch.Root->nr);
+  // free'ing the bonds lists
+  *out << Verbose(0) << "Free'ing all found lists. and resetting index lists" << endl;
+  for(int i=Order;i--;) {
+    *out << Verbose(1) << "Current SP level is " << i << ": ";
+    Binder = FragmentSearch.BondsPerSPList[2*i];
+    while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
+      Binder = Binder->next;
+      // *out << "Removing atom " << Binder->leftatom->nr << " and " << Binder->rightatom->nr << "." << endl; // make sure numbers are local
+      FragmentSearch.ShortestPathList[Binder->leftatom->nr] = -1;
+      FragmentSearch.ShortestPathList[Binder->rightatom->nr] = -1;
+    }
+    // delete added bonds
+    cleanup(FragmentSearch.BondsPerSPList[2*i], FragmentSearch.BondsPerSPList[2*i+1]);
+    // also start and end node
+    *out << "cleaned." << endl;
+  }
+  // return list
+  *out << Verbose(0) << "End of PowerSetGenerator." << endl;
+  return (FragmentSearch.FragmentCounter - Counter);
 };
 …
 void molecule::ScanForPeriodicCorrection(ofstream *out)
+{
         bond *Binder = NULL;
         bond *OtherBinder = NULL;
         atom *Walker = NULL;
         atom *OtherWalker = NULL;
         double *matrix = ReturnFullMatrixforSymmetric(cell_size);
         enum Shading *ColorList = NULL;
         double tmp;
         Vector Translationvector;
         //class StackClass<atom *> *CompStack = NULL;
         class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
         bool flag = true;
         *out << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl;
         ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
         while (flag) {
                 // remove bonds that are beyond bonddistance
                 for(int i=NDIM;i--;)
                         Translationvector.x[i] = 0.;
                 // scan all bonds
                 Binder = first;
                 flag = false;
                 while ((!flag) && (Binder->next != last)) {
                         Binder = Binder->next;
                         for (int i=NDIM;i--;) {
                                 tmp = fabs(Binder->leftatom->x.x[i] - Binder->rightatom->x.x[i]);
                                 //*out << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
                                 if (tmp > BondDistance) {
                                         OtherBinder = Binder->next; // note down binding partner for later re-insertion
                                         unlink(Binder);  // unlink bond
                                         *out << Verbose(2) << "Correcting at bond " << *Binder << "." << endl;
                                         flag = true;
                                         break;
+                                }
+                        }
+                }
                 if (flag) {
                         // create translation vector from their periodically modified distance
                         for (int i=NDIM;i--;) {
                                 tmp = Binder->leftatom->x.x[i] - Binder->rightatom->x.x[i];
                                 if (fabs(tmp) > BondDistance)
                                         Translationvector.x[i] = (tmp < 0) ? +1. : -1.;
+                        }
                         Translationvector.MatrixMultiplication(matrix);
                         //*out << Verbose(3) << "Translation vector is ";
                         Translationvector.Output(out);
                         *out << endl;
                         // apply to all atoms of first component via BFS
                         for (int i=AtomCount;i--;)
                                 ColorList[i] = white;
                         AtomStack->Push(Binder->leftatom);
                         while (!AtomStack->IsEmpty()) {
                                 Walker = AtomStack->PopFirst();
                                 //*out << Verbose (3) << "Current Walker is: " << *Walker << "." << endl;
                                 ColorList[Walker->nr] = black;          // mark as explored
                                 Walker->x.AddVector(&Translationvector); // translate
                                 for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {  // go through all binding partners
                                         if (ListOfBondsPerAtom[Walker->nr][i] != Binder) {
                                                 OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
                                                 if (ColorList[OtherWalker->nr] == white) {
                                                         AtomStack->Push(OtherWalker); // push if yet unexplored
+                                                }
+                                        }
+                                }
+                        }
                         // re-add bond
                         link(Binder, OtherBinder);
                 } else {
                         *out << Verbose(3) << "No corrections for this fragment." << endl;
+                }
                 //delete(CompStack);
+        }
         // free allocated space from ReturnFullMatrixforSymmetric()
         delete(AtomStack);
         Free((void **)&ColorList, "molecule::ScanForPeriodicCorrection: *ColorList");
         Free((void **)&matrix, "molecule::ScanForPeriodicCorrection: *matrix");
         *out << Verbose(2) << "End of ScanForPeriodicCorrection." << endl;
+  bond *Binder = NULL;
+  bond *OtherBinder = NULL;
+  atom *Walker = NULL;
+  atom *OtherWalker = NULL;
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  enum Shading *ColorList = NULL;
+  double tmp;
+  Vector Translationvector;
+  //class StackClass<atom *> *CompStack = NULL;
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  bool flag = true;
+  *out << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl;
+  ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  while (flag) {
+    // remove bonds that are beyond bonddistance
+    for(int i=NDIM;i--;)
+      Translationvector.x[i] = 0.;
+    // scan all bonds
+    Binder = first;
+    flag = false;
+    while ((!flag) && (Binder->next != last)) {
+      Binder = Binder->next;
+      for (int i=NDIM;i--;) {
+        tmp = fabs(Binder->leftatom->x.x[i] - Binder->rightatom->x.x[i]);
+        //*out << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
+        if (tmp > BondDistance) {
+          OtherBinder = Binder->next; // note down binding partner for later re-insertion
+          unlink(Binder);   // unlink bond
+          *out << Verbose(2) << "Correcting at bond " << *Binder << "." << endl;
+          flag = true;
+          break;
+        }
+      }
+    }
+    if (flag) {
+      // create translation vector from their periodically modified distance
+      for (int i=NDIM;i--;) {
+        tmp = Binder->leftatom->x.x[i] - Binder->rightatom->x.x[i];
+        if (fabs(tmp) > BondDistance)
+          Translationvector.x[i] = (tmp < 0) ? +1. : -1.;
+      }
+      Translationvector.MatrixMultiplication(matrix);
+      //*out << Verbose(3) << "Translation vector is ";
+      Translationvector.Output(out);
+      *out << endl;
+      // apply to all atoms of first component via BFS
+      for (int i=AtomCount;i--;)
+        ColorList[i] = white;
+      AtomStack->Push(Binder->leftatom);
+      while (!AtomStack->IsEmpty()) {
+        Walker = AtomStack->PopFirst();
+        //*out << Verbose (3) << "Current Walker is: " << *Walker << "." << endl;
+        ColorList[Walker->nr] = black;    // mark as explored
+        Walker->x.AddVector(&Translationvector); // translate
+        for (int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {  // go through all binding partners
+          if (ListOfBondsPerAtom[Walker->nr][i] != Binder) {
+            OtherWalker = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+            if (ColorList[OtherWalker->nr] == white) {
+              AtomStack->Push(OtherWalker); // push if yet unexplored
+            }
+          }
+        }
+      }
+      // re-add bond
+      link(Binder, OtherBinder);
+    } else {
+      *out << Verbose(3) << "No corrections for this fragment." << endl;
+    }
+    //delete(CompStack);
+  }
+  // free allocated space from ReturnFullMatrixforSymmetric()
+  delete(AtomStack);
+  Free((void **)&ColorList, "molecule::ScanForPeriodicCorrection: *ColorList");
+  Free((void **)&matrix, "molecule::ScanForPeriodicCorrection: *matrix");
+  *out << Verbose(2) << "End of ScanForPeriodicCorrection." << endl;
 };
 …
 double * molecule::ReturnFullMatrixforSymmetric(double *symm)
+{
         double *matrix = (double *) Malloc(sizeof(double)*NDIM*NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
         matrix[0] = symm[0];
         matrix[1] = symm[1];
         matrix[2] = symm[3];
         matrix[3] = symm[1];
         matrix[4] = symm[2];
         matrix[5] = symm[4];
         matrix[6] = symm[3];
         matrix[7] = symm[4];
         matrix[8] = symm[5];
         return matrix;
+  double *matrix = (double *) Malloc(sizeof(double)*NDIM*NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
+  matrix[0] = symm[0];
+  matrix[1] = symm[1];
+  matrix[2] = symm[3];
+  matrix[3] = symm[1];
+  matrix[4] = symm[2];
+  matrix[5] = symm[4];
+  matrix[6] = symm[3];
+  matrix[7] = symm[4];
+  matrix[8] = symm[5];
+  return matrix;
 };
 bool KeyCompare::operator() (const KeySet SubgraphA, const KeySet SubgraphB) const
+{
         //cout << "my check is used." << endl;
         if (SubgraphA.size() < SubgraphB.size()) {
                 return true;
         } else {
                 if (SubgraphA.size() > SubgraphB.size()) {
                         return false;
                 } else {
                         KeySet::iterator IteratorA = SubgraphA.begin();
                         KeySet::iterator IteratorB = SubgraphB.begin();
                         while ((IteratorA != SubgraphA.end()) && (IteratorB != SubgraphB.end())) {
                                 if ((*IteratorA) <      (*IteratorB))
                                         return true;
                                 else if ((*IteratorA) > (*IteratorB)) {
                                                 return false;
                                         } // else, go on to next index
                                 IteratorA++;
                                 IteratorB++;
                         } // end of while loop
                 }// end of check in case of equal sizes
+        }
         return false; // if we reach this point, they are equal
+  //cout << "my check is used." << endl;
+  if (SubgraphA.size() < SubgraphB.size()) {
+    return true;
+  } else {
+    if (SubgraphA.size() > SubgraphB.size()) {
+      return false;
+    } else {
+      KeySet::iterator IteratorA = SubgraphA.begin();
+      KeySet::iterator IteratorB = SubgraphB.begin();
+      while ((IteratorA != SubgraphA.end()) && (IteratorB != SubgraphB.end())) {
+        if ((*IteratorA) <  (*IteratorB))
+          return true;
+        else if ((*IteratorA) > (*IteratorB)) {
+            return false;
+          } // else, go on to next index
+        IteratorA++;
+        IteratorB++;
+      } // end of while loop
+    }// end of check in case of equal sizes
+  }
+  return false; // if we reach this point, they are equal
 };
 //bool operator < (KeySet SubgraphA, KeySet SubgraphB)
 //{
 //      return KeyCompare(SubgraphA, SubgraphB);
+//  return KeyCompare(SubgraphA, SubgraphB);
 //};
 …
 inline void InsertFragmentIntoGraph(ofstream *out, struct UniqueFragments *Fragment)
+{
         GraphTestPair testGraphInsert;
         testGraphInsert = Fragment->Leaflet->insert(GraphPair (*Fragment->FragmentSet,pair<int,double>(Fragment->FragmentCounter,Fragment->TEFactor))); // store fragment number and current factor
         if (testGraphInsert.second) {
                 *out << Verbose(2) << "KeySet " << Fragment->FragmentCounter << " successfully inserted." << endl;
                 Fragment->FragmentCounter++;
         } else {
                 *out << Verbose(2) << "KeySet " << Fragment->FragmentCounter << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first << endl;
                 ((*(testGraphInsert.first)).second).second += Fragment->TEFactor;       // increase the "created" counter
                 *out << Verbose(2) << "New factor is " << ((*(testGraphInsert.first)).second).second << "." << endl;
+        }
+  GraphTestPair testGraphInsert;
+  testGraphInsert = Fragment->Leaflet->insert(GraphPair (*Fragment->FragmentSet,pair<int,double>(Fragment->FragmentCounter,Fragment->TEFactor)));  // store fragment number and current factor
+  if (testGraphInsert.second) {
+    *out << Verbose(2) << "KeySet " << Fragment->FragmentCounter << " successfully inserted." << endl;
+    Fragment->FragmentCounter++;
+  } else {
+    *out << Verbose(2) << "KeySet " << Fragment->FragmentCounter << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first << endl;
+    ((*(testGraphInsert.first)).second).second += Fragment->TEFactor;  // increase the "created" counter
+    *out << Verbose(2) << "New factor is " << ((*(testGraphInsert.first)).second).second << "." << endl;
+  }
 };
 //void inline InsertIntoGraph(ofstream *out, KeyStack &stack, Graph &graph, int *counter, double factor)
 //{
 //      // copy stack contents to set and call overloaded function again
 //      KeySet set;
 //      for(KeyStack::iterator runner = stack.begin(); runner != stack.begin(); runner++)
 //              set.insert((*runner));
 //      InsertIntoGraph(out, set, graph, counter, factor);
+//  // copy stack contents to set and call overloaded function again
+//  KeySet set;
+//  for(KeyStack::iterator runner = stack.begin(); runner != stack.begin(); runner++)
+//    set.insert((*runner));
+//  InsertIntoGraph(out, set, graph, counter, factor);
 //};
 …
 inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter)
+{
         GraphTestPair testGraphInsert;
         for(Graph::iterator runner = graph2.begin(); runner != graph2.end(); runner++) {
                 testGraphInsert = graph1.insert(GraphPair ((*runner).first,pair<int,double>((*counter)++,((*runner).second).second)));  // store fragment number and current factor
                 if (testGraphInsert.second) {
                         *out << Verbose(2) << "KeySet " << (*counter)-1 << " successfully inserted." << endl;
                 } else {
                         *out << Verbose(2) << "KeySet " << (*counter)-1 << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first << endl;
                         ((*(testGraphInsert.first)).second).second += (*runner).second.second;
                         *out << Verbose(2) << "New factor is " << (*(testGraphInsert.first)).second.second << "." << endl;
+                }
+        }
+  GraphTestPair testGraphInsert;
+  for(Graph::iterator runner = graph2.begin(); runner != graph2.end(); runner++) {
+    testGraphInsert = graph1.insert(GraphPair ((*runner).first,pair<int,double>((*counter)++,((*runner).second).second)));  // store fragment number and current factor
+    if (testGraphInsert.second) {
+      *out << Verbose(2) << "KeySet " << (*counter)-1 << " successfully inserted." << endl;
+    } else {
+      *out << Verbose(2) << "KeySet " << (*counter)-1 << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first << endl;
+      ((*(testGraphInsert.first)).second).second += (*runner).second.second;
+      *out << Verbose(2) << "New factor is " << (*(testGraphInsert.first)).second.second << "." << endl;
+    }
+  }
 };
 …
  * -# constructs a complete keyset of the molecule
  * -# In a loop over all possible roots from the given rootstack
  *      -# increases order of root site
  *      -# calls PowerSetGenerator with this order, the complete keyset and the rootkeynr
  *      -# for all consecutive lower levels PowerSetGenerator is called with the suborder, the higher order keyset
+ *  -# increases order of root site
+ *  -# calls PowerSetGenerator with this order, the complete keyset and the rootkeynr
+ *  -# for all consecutive lower levels PowerSetGenerator is called with the suborder, the higher order keyset
 as the restricted one and each site in the set as the root)
  *      -# these are merged into a fragment list of keysets
+ *  -# these are merged into a fragment list of keysets
  * -# All fragment lists (for all orders, i.e. from all destination fields) are merged into one list for return
  * Important only is that we create all fragments, it is not important if we create them more than once
 …
 void molecule::FragmentBOSSANOVA(ofstream *out, Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize)
+{
         Graph ***FragmentLowerOrdersList = NULL;
         int NumLevels, NumMolecules, TotalNumMolecules = 0, *NumMoleculesOfOrder = NULL;
         int counter = 0, Order;
         int UpgradeCount = RootStack.size();
         KeyStack FragmentRootStack;
         int RootKeyNr, RootNr;
         struct UniqueFragments FragmentSearch;
         *out << Verbose(0) << "Begin of FragmentBOSSANOVA." << endl;
         // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
         // with all needed lower orders that are subtracted, the other dimension is the BondOrder (i.e. from 1 to 5)
         NumMoleculesOfOrder = (int *) Malloc(sizeof(int)*UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
         FragmentLowerOrdersList = (Graph ***) Malloc(sizeof(Graph **)*UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
         // initialise the fragments structure
         FragmentSearch.ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
         FragmentSearch.FragmentCounter = 0;
         FragmentSearch.FragmentSet = new KeySet;
         FragmentSearch.Root = FindAtom(RootKeyNr);
         for (int i=AtomCount;i--;) {
                 FragmentSearch.ShortestPathList[i] = -1;
+        }
         // Construct the complete KeySet which we need for topmost level only (but for all Roots)
         atom *Walker = start;
         KeySet CompleteMolecule;
         while (Walker->next != end) {
                 Walker = Walker->next;
                 CompleteMolecule.insert(Walker->GetTrueFather()->nr);
+        }
         // this can easily be seen: if Order is 5, then the number of levels for each lower order is the total sum of the number of levels above, as
         // each has to be split up. E.g. for the second level we have one from 5th, one from 4th, two from 3th (which in turn is one from 5th, one from 4th),
         // hence we have overall four 2th order levels for splitting. This also allows for putting all into a single array (FragmentLowerOrdersList[])
         // with the order along the cells as this: 5433222211111111 for BondOrder 5 needing 16=pow(2,5-1) cells (only we use bit-shifting which is faster)
         RootNr = 0;      // counts through the roots in RootStack
         while ((RootNr < UpgradeCount) && (!RootStack.empty())) {
                 RootKeyNr = RootStack.front();
                 RootStack.pop_front();
                 Walker = FindAtom(RootKeyNr);
                 // check cyclic lengths
                 //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
                 //      *out << Verbose(0) << "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed." << endl;
                 //} else
+                {
                         // increase adaptive order by one
                         Walker->GetTrueFather()->AdaptiveOrder++;
                         Order = Walker->AdaptiveOrder = Walker->GetTrueFather()->AdaptiveOrder;
                         // initialise Order-dependent entries of UniqueFragments structure
                         FragmentSearch.BondsPerSPList = (bond **) Malloc(sizeof(bond *)*Order*2, "molecule::PowerSetGenerator: ***BondsPerSPList");
                         FragmentSearch.BondsPerSPCount = (int *) Malloc(sizeof(int)*Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
                         for (int i=Order;i--;) {
                                 FragmentSearch.BondsPerSPList[2*i] = new bond();                // start node
                                 FragmentSearch.BondsPerSPList[2*i+1] = new bond();      // end node
                                 FragmentSearch.BondsPerSPList[2*i]->next = FragmentSearch.BondsPerSPList[2*i+1];                 // intertwine these two
                                 FragmentSearch.BondsPerSPList[2*i+1]->previous = FragmentSearch.BondsPerSPList[2*i];
                                 FragmentSearch.BondsPerSPCount[i] = 0;
+                        }
                         // allocate memory for all lower level orders in this 1D-array of ptrs
                         NumLevels = 1 << (Order-1); // (int)pow(2,Order);
                         FragmentLowerOrdersList[RootNr] = (Graph **) Malloc(sizeof(Graph *)*NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
                         for (int i=0;i<NumLevels;i++)
                                 FragmentLowerOrdersList[RootNr][i] = NULL;
                         // create top order where nothing is reduced
                         *out << Verbose(0) << "==============================================================================================================" << endl;
                         *out << Verbose(0) << "Creating KeySets of Bond Order " << Order << " for " << *Walker << ", " << (RootStack.size()-RootNr) << " Roots remaining." << endl; // , NumLevels is " << NumLevels << "
                         // Create list of Graphs of current Bond Order (i.e. F_{ij})
                         FragmentLowerOrdersList[RootNr][0] =    new Graph;
                         FragmentSearch.TEFactor = 1.;
                         FragmentSearch.Leaflet = FragmentLowerOrdersList[RootNr][0];                    // set to insertion graph
                         FragmentSearch.Root = Walker;
                         NumMoleculesOfOrder[RootNr] = PowerSetGenerator(out, Walker->AdaptiveOrder, FragmentSearch, CompleteMolecule);
                         *out << Verbose(1) << "Number of resulting KeySets is: " << NumMoleculesOfOrder[RootNr] << "." << endl;
                         if (NumMoleculesOfOrder[RootNr] != 0) {
                                 NumMolecules = 0;
                                 // we don't have to dive into suborders! These keysets are all already created on lower orders!
                                 // this was all ancient stuff, when we still depended on the TEFactors (and for those the suborders were needed)
 //                              if ((NumLevels >> 1) > 0) {
 //                                      // create lower order fragments
 //                                      *out << Verbose(0) << "Creating list of unique fragments of lower Bond Order terms to be subtracted." << endl;
 //                                      Order = Walker->AdaptiveOrder;
 //                                      for (int source=0;source<(NumLevels >> 1);source++) { // 1-terms don't need any more splitting, that's why only half is gone through (shift again)
 //                                              // step down to next order at (virtual) boundary of powers of 2 in array
 //                                              while (source >= (1 << (Walker->AdaptiveOrder-Order))) // (int)pow(2,Walker->AdaptiveOrder-Order))
 //                                                      Order--;
 //                                              *out << Verbose(0) << "Current Order is: " << Order << "." << endl;
 //                                              for (int SubOrder=Order-1;SubOrder>0;SubOrder--) {
 //                                                      int dest = source + (1 << (Walker->AdaptiveOrder-(SubOrder+1)));
 //                                                      *out << Verbose(0) << "--------------------------------------------------------------------------------------------------------------" << endl;
 //                                                      *out << Verbose(0) << "Current SubOrder is: " << SubOrder << " with source " << source << " to destination " << dest << "." << endl;
+  Graph ***FragmentLowerOrdersList = NULL;
+  int NumLevels, NumMolecules, TotalNumMolecules = 0, *NumMoleculesOfOrder = NULL;
+  int counter = 0, Order;
+  int UpgradeCount = RootStack.size();
+  KeyStack FragmentRootStack;
+  int RootKeyNr, RootNr;
+  struct UniqueFragments FragmentSearch;
+  *out << Verbose(0) << "Begin of FragmentBOSSANOVA." << endl;
+  // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
+  // with all needed lower orders that are subtracted, the other dimension is the BondOrder (i.e. from 1 to 5)
+  NumMoleculesOfOrder = (int *) Malloc(sizeof(int)*UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = (Graph ***) Malloc(sizeof(Graph **)*UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  // initialise the fragments structure
+  FragmentSearch.ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
+  FragmentSearch.FragmentCounter = 0;
+  FragmentSearch.FragmentSet = new KeySet;
+  FragmentSearch.Root = FindAtom(RootKeyNr);
+  for (int i=AtomCount;i--;) {
+    FragmentSearch.ShortestPathList[i] = -1;
+  }
+  // Construct the complete KeySet which we need for topmost level only (but for all Roots)
+  atom *Walker = start;
+  KeySet CompleteMolecule;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    CompleteMolecule.insert(Walker->GetTrueFather()->nr);
+  }
+  // this can easily be seen: if Order is 5, then the number of levels for each lower order is the total sum of the number of levels above, as
+  // each has to be split up. E.g. for the second level we have one from 5th, one from 4th, two from 3th (which in turn is one from 5th, one from 4th),
+  // hence we have overall four 2th order levels for splitting. This also allows for putting all into a single array (FragmentLowerOrdersList[])
+  // with the order along the cells as this: 5433222211111111 for BondOrder 5 needing 16=pow(2,5-1) cells (only we use bit-shifting which is faster)
+  RootNr = 0;   // counts through the roots in RootStack
+  while ((RootNr < UpgradeCount) && (!RootStack.empty())) {
+    RootKeyNr = RootStack.front();
+    RootStack.pop_front();
+    Walker = FindAtom(RootKeyNr);
+    // check cyclic lengths
+    //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
+    //  *out << Verbose(0) << "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed." << endl;
+    //} else
+    {
+      // increase adaptive order by one
+      Walker->GetTrueFather()->AdaptiveOrder++;
+      Order = Walker->AdaptiveOrder = Walker->GetTrueFather()->AdaptiveOrder;
+      // initialise Order-dependent entries of UniqueFragments structure
+      FragmentSearch.BondsPerSPList = (bond **) Malloc(sizeof(bond *)*Order*2, "molecule::PowerSetGenerator: ***BondsPerSPList");
+      FragmentSearch.BondsPerSPCount = (int *) Malloc(sizeof(int)*Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
+      for (int i=Order;i--;) {
+        FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
+        FragmentSearch.BondsPerSPList[2*i+1] = new bond();  // end node
+        FragmentSearch.BondsPerSPList[2*i]->next = FragmentSearch.BondsPerSPList[2*i+1];     // intertwine these two
+        FragmentSearch.BondsPerSPList[2*i+1]->previous = FragmentSearch.BondsPerSPList[2*i];
+        FragmentSearch.BondsPerSPCount[i] = 0;
+      }
+      // allocate memory for all lower level orders in this 1D-array of ptrs
+      NumLevels = 1 << (Order-1); // (int)pow(2,Order);
+      FragmentLowerOrdersList[RootNr] = (Graph **) Malloc(sizeof(Graph *)*NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      for (int i=0;i<NumLevels;i++)
+        FragmentLowerOrdersList[RootNr][i] = NULL;
+      // create top order where nothing is reduced
+      *out << Verbose(0) << "==============================================================================================================" << endl;
+      *out << Verbose(0) << "Creating KeySets of Bond Order " << Order << " for " << *Walker << ", " << (RootStack.size()-RootNr) << " Roots remaining." << endl; // , NumLevels is " << NumLevels << "
+      // Create list of Graphs of current Bond Order (i.e. F_{ij})
+      FragmentLowerOrdersList[RootNr][0] =  new Graph;
+      FragmentSearch.TEFactor = 1.;
+      FragmentSearch.Leaflet = FragmentLowerOrdersList[RootNr][0];      // set to insertion graph
+      FragmentSearch.Root = Walker;
+      NumMoleculesOfOrder[RootNr] = PowerSetGenerator(out, Walker->AdaptiveOrder, FragmentSearch, CompleteMolecule);
+      *out << Verbose(1) << "Number of resulting KeySets is: " << NumMoleculesOfOrder[RootNr] << "." << endl;
+      if (NumMoleculesOfOrder[RootNr] != 0) {
+        NumMolecules = 0;
+        // we don't have to dive into suborders! These keysets are all already created on lower orders!
+        // this was all ancient stuff, when we still depended on the TEFactors (and for those the suborders were needed)
+//        if ((NumLevels >> 1) > 0) {
+//          // create lower order fragments
+//          *out << Verbose(0) << "Creating list of unique fragments of lower Bond Order terms to be subtracted." << endl;
+//          Order = Walker->AdaptiveOrder;
+//          for (int source=0;source<(NumLevels >> 1);source++) { // 1-terms don't need any more splitting, that's why only half is gone through (shift again)
+//            // step down to next order at (virtual) boundary of powers of 2 in array
+//            while (source >= (1 << (Walker->AdaptiveOrder-Order))) // (int)pow(2,Walker->AdaptiveOrder-Order))
+//              Order--;
+//            *out << Verbose(0) << "Current Order is: " << Order << "." << endl;
+//            for (int SubOrder=Order-1;SubOrder>0;SubOrder--) {
+//              int dest = source + (1 << (Walker->AdaptiveOrder-(SubOrder+1)));
+//              *out << Verbose(0) << "--------------------------------------------------------------------------------------------------------------" << endl;
+//              *out << Verbose(0) << "Current SubOrder is: " << SubOrder << " with source " << source << " to destination " << dest << "." << endl;
 //
 //                                                      // every molecule is split into a list of again (Order - 1) molecules, while counting all molecules
 //                                                      //*out << Verbose(1) << "Splitting the " << (*FragmentLowerOrdersList[RootNr][source]).size() << " molecules of the " << source << "th cell in the array." << endl;
 //                                                      //NumMolecules = 0;
 //                                                      FragmentLowerOrdersList[RootNr][dest] = new Graph;
 //                                                      for(Graph::iterator runner = (*FragmentLowerOrdersList[RootNr][source]).begin();runner != (*FragmentLowerOrdersList[RootNr][source]).end(); runner++) {
 //                                                              for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
 //                                                                      Graph TempFragmentList;
 //                                                                      FragmentSearch.TEFactor = -(*runner).second.second;
 //                                                                      FragmentSearch.Leaflet = &TempFragmentList;                     // set to insertion graph
 //                                                                      FragmentSearch.Root = FindAtom(*sprinter);
 //                                                                      NumMoleculesOfOrder[RootNr] += PowerSetGenerator(out, SubOrder, FragmentSearch, (*runner).first);
 //                                                                      // insert new keysets FragmentList into FragmentLowerOrdersList[Walker->AdaptiveOrder-1][dest]
 //                                                                      *out << Verbose(1) << "Merging resulting key sets with those present in destination " << dest << "." << endl;
 //                                                                      InsertGraphIntoGraph(out, *FragmentLowerOrdersList[RootNr][dest], TempFragmentList, &NumMolecules);
 //                                                              }
 //                                                      }
 //                                                      *out << Verbose(1) << "Number of resulting molecules for SubOrder " << SubOrder << " is: " << NumMolecules << "." << endl;
 //                                              }
 //                                      }
 //                              }
                         } else {
                                 Walker->GetTrueFather()->MaxOrder = true;
 //                              *out << Verbose(1) << "Hence, we don't dive into SubOrders ... " << endl;
+                        }
                         // now, we have completely filled each cell of FragmentLowerOrdersList[] for the current Walker->AdaptiveOrder
                         //NumMoleculesOfOrder[Walker->AdaptiveOrder-1] = NumMolecules;
                         TotalNumMolecules += NumMoleculesOfOrder[RootNr];
 //                      *out << Verbose(1) << "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->AdaptiveOrder << " is: " << NumMoleculesOfOrder[RootNr] << "." << endl;
                         RootStack.push_back(RootKeyNr); // put back on stack
                         RootNr++;
                         // free Order-dependent entries of UniqueFragments structure for next loop cycle
                         Free((void **)&FragmentSearch.BondsPerSPCount, "molecule::PowerSetGenerator: *BondsPerSPCount");
                         for (int i=Order;i--;) {
                                 delete(FragmentSearch.BondsPerSPList[2*i]);
                                 delete(FragmentSearch.BondsPerSPList[2*i+1]);
+                        }
                         Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
+                }
+        }
         *out << Verbose(0) << "==============================================================================================================" << endl;
         *out << Verbose(1) << "Total number of resulting molecules is: " << TotalNumMolecules << "." << endl;
         *out << Verbose(0) << "==============================================================================================================" << endl;
         // cleanup FragmentSearch structure
         Free((void **)&FragmentSearch.ShortestPathList, "molecule::PowerSetGenerator: *ShortestPathList");
         delete(FragmentSearch.FragmentSet);
         // now, FragmentLowerOrdersList is complete, it looks - for BondOrder 5 - as this (number is the ANOVA Order of the terms therein)
         // 5433222211111111
         // 43221111
         // 3211
         // 21
         // 1
         // Subsequently, we combine all into a single list (FragmentList)
         *out << Verbose(0) << "Combining the lists of all orders per order and finally into a single one." << endl;
         if (FragmentList == NULL) {
                 FragmentList = new Graph;
                 counter = 0;
         } else {
                 counter = FragmentList->size();
+        }
         RootNr = 0;
         while (!RootStack.empty()) {
                 RootKeyNr = RootStack.front();
                 RootStack.pop_front();
                 Walker = FindAtom(RootKeyNr);
                 NumLevels = 1 << (Walker->AdaptiveOrder - 1);
                 for(int i=0;i<NumLevels;i++) {
                         if (FragmentLowerOrdersList[RootNr][i] != NULL) {
                                 InsertGraphIntoGraph(out, *FragmentList, (*FragmentLowerOrdersList[RootNr][i]), &counter);
                                 delete(FragmentLowerOrdersList[RootNr][i]);
+                        }
+                }
                 Free((void **)&FragmentLowerOrdersList[RootNr], "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
                 RootNr++;
+        }
         Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
         Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
         *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
+//              // every molecule is split into a list of again (Order - 1) molecules, while counting all molecules
+//              //*out << Verbose(1) << "Splitting the " << (*FragmentLowerOrdersList[RootNr][source]).size() << " molecules of the " << source << "th cell in the array." << endl;
+//              //NumMolecules = 0;
+//              FragmentLowerOrdersList[RootNr][dest] = new Graph;
+//              for(Graph::iterator runner = (*FragmentLowerOrdersList[RootNr][source]).begin();runner != (*FragmentLowerOrdersList[RootNr][source]).end(); runner++) {
+//                for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
+//                  Graph TempFragmentList;
+//                  FragmentSearch.TEFactor = -(*runner).second.second;
+//                  FragmentSearch.Leaflet = &TempFragmentList;      // set to insertion graph
+//                  FragmentSearch.Root = FindAtom(*sprinter);
+//                  NumMoleculesOfOrder[RootNr] += PowerSetGenerator(out, SubOrder, FragmentSearch, (*runner).first);
+//                  // insert new keysets FragmentList into FragmentLowerOrdersList[Walker->AdaptiveOrder-1][dest]
+//                  *out << Verbose(1) << "Merging resulting key sets with those present in destination " << dest << "." << endl;
+//                  InsertGraphIntoGraph(out, *FragmentLowerOrdersList[RootNr][dest], TempFragmentList, &NumMolecules);
+//                }
+//              }
+//              *out << Verbose(1) << "Number of resulting molecules for SubOrder " << SubOrder << " is: " << NumMolecules << "." << endl;
+//            }
+//          }
+//        }
+      } else {
+        Walker->GetTrueFather()->MaxOrder = true;
+//        *out << Verbose(1) << "Hence, we don't dive into SubOrders ... " << endl;
+      }
+      // now, we have completely filled each cell of FragmentLowerOrdersList[] for the current Walker->AdaptiveOrder
+      //NumMoleculesOfOrder[Walker->AdaptiveOrder-1] = NumMolecules;
+      TotalNumMolecules += NumMoleculesOfOrder[RootNr];
+//      *out << Verbose(1) << "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->AdaptiveOrder << " is: " << NumMoleculesOfOrder[RootNr] << "." << endl;
+      RootStack.push_back(RootKeyNr); // put back on stack
+      RootNr++;
+      // free Order-dependent entries of UniqueFragments structure for next loop cycle
+      Free((void **)&FragmentSearch.BondsPerSPCount, "molecule::PowerSetGenerator: *BondsPerSPCount");
+      for (int i=Order;i--;) {
+        delete(FragmentSearch.BondsPerSPList[2*i]);
+        delete(FragmentSearch.BondsPerSPList[2*i+1]);
+      }
+      Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
+    }
+  }
+  *out << Verbose(0) << "==============================================================================================================" << endl;
+  *out << Verbose(1) << "Total number of resulting molecules is: " << TotalNumMolecules << "." << endl;
+  *out << Verbose(0) << "==============================================================================================================" << endl;
+  // cleanup FragmentSearch structure
+  Free((void **)&FragmentSearch.ShortestPathList, "molecule::PowerSetGenerator: *ShortestPathList");
+  delete(FragmentSearch.FragmentSet);
+  // now, FragmentLowerOrdersList is complete, it looks - for BondOrder 5 - as this (number is the ANOVA Order of the terms therein)
+  // 5433222211111111
+  // 43221111
+  // 3211
+  // 21
+  // 1
+  // Subsequently, we combine all into a single list (FragmentList)
+  *out << Verbose(0) << "Combining the lists of all orders per order and finally into a single one." << endl;
+  if (FragmentList == NULL) {
+    FragmentList = new Graph;
+    counter = 0;
+  } else {
+    counter = FragmentList->size();
+  }
+  RootNr = 0;
+  while (!RootStack.empty()) {
+    RootKeyNr = RootStack.front();
+    RootStack.pop_front();
+    Walker = FindAtom(RootKeyNr);
+    NumLevels = 1 << (Walker->AdaptiveOrder - 1);
+    for(int i=0;i<NumLevels;i++) {
+      if (FragmentLowerOrdersList[RootNr][i] != NULL) {
+        InsertGraphIntoGraph(out, *FragmentList, (*FragmentLowerOrdersList[RootNr][i]), &counter);
+        delete(FragmentLowerOrdersList[RootNr][i]);
+      }
+    }
+    Free((void **)&FragmentLowerOrdersList[RootNr], "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+    RootNr++;
+  }
+  Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
 };
 …
 inline int CompareDoubles (const void * a, const void * b)
+{
         if (*(double *)a > *(double *)b)
                 return -1;
         else if (*(double *)a < *(double *)b)
                 return 1;
         else
                 return 0;
+  if (*(double *)a > *(double *)b)
+    return -1;
+  else if (*(double *)a < *(double *)b)
+    return 1;
+  else
+    return 0;
 };
 …
 int * molecule::IsEqualToWithinThreshold(ofstream *out, molecule *OtherMolecule, double threshold)
+{
         int flag;
         double *Distances = NULL, *OtherDistances = NULL;
         Vector CenterOfGravity, OtherCenterOfGravity;
         size_t *PermMap = NULL, *OtherPermMap = NULL;
         int *PermutationMap = NULL;
         atom *Walker = NULL;
         bool result = true; // status of comparison
         *out << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl;
         /// first count both their atoms and elements and update lists thereby ...
         //*out << Verbose(0) << "Counting atoms, updating list" << endl;
         CountAtoms(out);
         OtherMolecule->CountAtoms(out);
         CountElements();
         OtherMolecule->CountElements();
         /// ... and compare:
         /// -# AtomCount
         if (result) {
                 if (AtomCount != OtherMolecule->AtomCount) {
                         *out << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
                         result = false;
                 } else *out << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+        }
         /// -# ElementCount
         if (result) {
                 if (ElementCount != OtherMolecule->ElementCount) {
                         *out << Verbose(4) << "ElementCount don't match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl;
                         result = false;
                 } else *out << Verbose(4) << "ElementCount match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl;
+        }
         /// -# ElementsInMolecule
         if (result) {
                 for (flag=MAX_ELEMENTS;flag--;) {
                         //*out << Verbose(5) << "Element " <<   flag << ": " << ElementsInMolecule[flag] << " <-> " << OtherMolecule->ElementsInMolecule[flag] << "." << endl;
                         if (ElementsInMolecule[flag] != OtherMolecule->ElementsInMolecule[flag])
                                 break;
+                }
                 if (flag < MAX_ELEMENTS) {
                         *out << Verbose(4) << "ElementsInMolecule don't match." << endl;
                         result = false;
                 } else *out << Verbose(4) << "ElementsInMolecule match." << endl;
+        }
         /// then determine and compare center of gravity for each molecule ...
         if (result) {
                 *out << Verbose(5) << "Calculating Centers of Gravity" << endl;
                 DeterminePeriodicCenter(CenterOfGravity);
                 OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
                 *out << Verbose(5) << "Center of Gravity: ";
                 CenterOfGravity.Output(out);
                 *out << endl << Verbose(5) << "Other Center of Gravity: ";
                 OtherCenterOfGravity.Output(out);
                 *out << endl;
                 if (CenterOfGravity.DistanceSquared(&OtherCenterOfGravity) > threshold*threshold) {
                         *out << Verbose(4) << "Centers of gravity don't match." << endl;
                         result = false;
+                }
+        }
         /// ... then make a list with the euclidian distance to this center for each atom of both molecules
         if (result) {
                 *out << Verbose(5) << "Calculating distances" << endl;
                 Distances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
                 OtherDistances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
                 Walker = start;
                 while (Walker->next != end) {
                         Walker = Walker->next;
                         Distances[Walker->nr] = CenterOfGravity.DistanceSquared(&Walker->x);
+                }
                 Walker = OtherMolecule->start;
                 while (Walker->next != OtherMolecule->end) {
                         Walker = Walker->next;
                         OtherDistances[Walker->nr] = OtherCenterOfGravity.DistanceSquared(&Walker->x);
+                }
                 /// ... sort each list (using heapsort (o(N log N)) from GSL)
                 *out << Verbose(5) << "Sorting distances" << endl;
                 PermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
                 OtherPermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
                 gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
                 gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
                 PermutationMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
                 *out << Verbose(5) << "Combining Permutation Maps" << endl;
                 for(int i=AtomCount;i--;)
                         PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
                 /// ... and compare them step by step, whether the difference is individiually(!) below \a threshold for all
                 *out << Verbose(4) << "Comparing distances" << endl;
                 flag = 0;
                 for (int i=0;i<AtomCount;i++) {
                         *out << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<      threshold << endl;
                         if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
                                 flag = 1;
+                }
                 Free((void **)&PermMap, "molecule::IsEqualToWithinThreshold: *PermMap");
                 Free((void **)&OtherPermMap, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
                 /// free memory
                 Free((void **)&Distances, "molecule::IsEqualToWithinThreshold: Distances");
                 Free((void **)&OtherDistances, "molecule::IsEqualToWithinThreshold: OtherDistances");
                 if (flag) { // if not equal
                         Free((void **)&PermutationMap, "molecule::IsEqualToWithinThreshold: *PermutationMap");
                         result = false;
+                }
+        }
         /// return pointer to map if all distances were below \a threshold
         *out << Verbose(3) << "End of IsEqualToWithinThreshold." << endl;
         if (result) {
                 *out << Verbose(3) << "Result: Equal." << endl;
                 return PermutationMap;
         } else {
                 *out << Verbose(3) << "Result: Not equal." << endl;
                 return NULL;
+        }
+  int flag;
+  double *Distances = NULL, *OtherDistances = NULL;
+  Vector CenterOfGravity, OtherCenterOfGravity;
+  size_t *PermMap = NULL, *OtherPermMap = NULL;
+  int *PermutationMap = NULL;
+  atom *Walker = NULL;
+  bool result = true; // status of comparison
+  *out << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl;
+  /// first count both their atoms and elements and update lists thereby ...
+  //*out << Verbose(0) << "Counting atoms, updating list" << endl;
+  CountAtoms(out);
+  OtherMolecule->CountAtoms(out);
+  CountElements();
+  OtherMolecule->CountElements();
+  /// ... and compare:
+  /// -# AtomCount
+  if (result) {
+    if (AtomCount != OtherMolecule->AtomCount) {
+      *out << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+      result = false;
+    } else *out << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+  }
+  /// -# ElementCount
+  if (result) {
+    if (ElementCount != OtherMolecule->ElementCount) {
+      *out << Verbose(4) << "ElementCount don't match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl;
+      result = false;
+    } else *out << Verbose(4) << "ElementCount match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl;
+  }
+  /// -# ElementsInMolecule
+  if (result) {
+    for (flag=MAX_ELEMENTS;flag--;) {
+      //*out << Verbose(5) << "Element " <<  flag << ": " << ElementsInMolecule[flag] << " <-> " << OtherMolecule->ElementsInMolecule[flag] << "." << endl;
+      if (ElementsInMolecule[flag] != OtherMolecule->ElementsInMolecule[flag])
+        break;
+    }
+    if (flag < MAX_ELEMENTS) {
+      *out << Verbose(4) << "ElementsInMolecule don't match." << endl;
+      result = false;
+    } else *out << Verbose(4) << "ElementsInMolecule match." << endl;
+  }
+  /// then determine and compare center of gravity for each molecule ...
+  if (result) {
+    *out << Verbose(5) << "Calculating Centers of Gravity" << endl;
+    DeterminePeriodicCenter(CenterOfGravity);
+    OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
+    *out << Verbose(5) << "Center of Gravity: ";
+    CenterOfGravity.Output(out);
+    *out << endl << Verbose(5) << "Other Center of Gravity: ";
+    OtherCenterOfGravity.Output(out);
+    *out << endl;
+    if (CenterOfGravity.DistanceSquared(&OtherCenterOfGravity) > threshold*threshold) {
+      *out << Verbose(4) << "Centers of gravity don't match." << endl;
+      result = false;
+    }
+  }
+  /// ... then make a list with the euclidian distance to this center for each atom of both molecules
+  if (result) {
+    *out << Verbose(5) << "Calculating distances" << endl;
+    Distances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
+    OtherDistances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      Distances[Walker->nr] = CenterOfGravity.DistanceSquared(&Walker->x);
+    }
+    Walker = OtherMolecule->start;
+    while (Walker->next != OtherMolecule->end) {
+      Walker = Walker->next;
+      OtherDistances[Walker->nr] = OtherCenterOfGravity.DistanceSquared(&Walker->x);
+    }
+    /// ... sort each list (using heapsort (o(N log N)) from GSL)
+    *out << Verbose(5) << "Sorting distances" << endl;
+    PermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
+    PermutationMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    *out << Verbose(5) << "Combining Permutation Maps" << endl;
+    for(int i=AtomCount;i--;)
+      PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
+    /// ... and compare them step by step, whether the difference is individiually(!) below \a threshold for all
+    *out << Verbose(4) << "Comparing distances" << endl;
+    flag = 0;
+    for (int i=0;i<AtomCount;i++) {
+      *out << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl;
+      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
+        flag = 1;
+    }
+    Free((void **)&PermMap, "molecule::IsEqualToWithinThreshold: *PermMap");
+    Free((void **)&OtherPermMap, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    /// free memory
+    Free((void **)&Distances, "molecule::IsEqualToWithinThreshold: Distances");
+    Free((void **)&OtherDistances, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    if (flag) { // if not equal
+      Free((void **)&PermutationMap, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+      result = false;
+    }
+  }
+  /// return pointer to map if all distances were below \a threshold
+  *out << Verbose(3) << "End of IsEqualToWithinThreshold." << endl;
+  if (result) {
+    *out << Verbose(3) << "Result: Equal." << endl;
+    return PermutationMap;
+  } else {
+    *out << Verbose(3) << "Result: Not equal." << endl;
+    return NULL;
+  }
 };
 …
 int * molecule::GetFatherSonAtomicMap(ofstream *out, molecule *OtherMolecule)
+{
         atom *Walker = NULL, *OtherWalker = NULL;
         *out << Verbose(3) << "Begin of GetFatherAtomicMap." << endl;
         int *AtomicMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::GetAtomicMap: *AtomicMap");   //Calloc
         for (int i=AtomCount;i--;)
                 AtomicMap[i] = -1;
         if (OtherMolecule == this) {    // same molecule
                 for (int i=AtomCount;i--;) // no need as -1 means already that there is trivial correspondence
                         AtomicMap[i] = i;
                 *out << Verbose(4) << "Map is trivial." << endl;
         } else {
                 *out << Verbose(4) << "Map is ";
                 Walker = start;
                 while (Walker->next != end) {
                         Walker = Walker->next;
                         if (Walker->father == NULL) {
                                 AtomicMap[Walker->nr] = -2;
                         } else {
                                 OtherWalker = OtherMolecule->start;
                                 while (OtherWalker->next != OtherMolecule->end) {
                                         OtherWalker = OtherWalker->next;
                         //for (int i=0;i<AtomCount;i++) { // search atom
                                 //for (int j=0;j<OtherMolecule->AtomCount;j++) {
                                         //*out << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
                                         if (Walker->father == OtherWalker)
                                                 AtomicMap[Walker->nr] = OtherWalker->nr;
+                                }
+                        }
                         *out << AtomicMap[Walker->nr] << "\t";
+                }
                 *out << endl;
+        }
         *out << Verbose(3) << "End of GetFatherAtomicMap." << endl;
         return AtomicMap;
+  atom *Walker = NULL, *OtherWalker = NULL;
+  *out << Verbose(3) << "Begin of GetFatherAtomicMap." << endl;
+  int *AtomicMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::GetAtomicMap: *AtomicMap");  //Calloc
+  for (int i=AtomCount;i--;)
+    AtomicMap[i] = -1;
+  if (OtherMolecule == this) {  // same molecule
+    for (int i=AtomCount;i--;) // no need as -1 means already that there is trivial correspondence
+      AtomicMap[i] = i;
+    *out << Verbose(4) << "Map is trivial." << endl;
+  } else {
+    *out << Verbose(4) << "Map is ";
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      if (Walker->father == NULL) {
+        AtomicMap[Walker->nr] = -2;
+      } else {
+        OtherWalker = OtherMolecule->start;
+        while (OtherWalker->next != OtherMolecule->end) {
+          OtherWalker = OtherWalker->next;
+      //for (int i=0;i<AtomCount;i++) { // search atom
+        //for (int j=0;j<OtherMolecule->AtomCount;j++) {
+          //*out << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
+          if (Walker->father == OtherWalker)
+            AtomicMap[Walker->nr] = OtherWalker->nr;
+        }
+      }
+      *out << AtomicMap[Walker->nr] << "\t";
+    }
+    *out << endl;
+  }
+  *out << Verbose(3) << "End of GetFatherAtomicMap." << endl;
+  return AtomicMap;
 };
 …
 bool molecule::OutputTemperatureFromTrajectories(ofstream *out, int startstep, int endstep, ofstream *output)
+{
         double temperature;
         atom *Walker = NULL;
         // test stream
         if (output == NULL)
                 return false;
         else
                 *output << "# Step Temperature [K] Temperature [a.u.]" << endl;
         for (int step=startstep;step < endstep; step++) { // loop over all time steps
                 temperature = 0.;
                 Walker = start;
                 while (Walker->next != end) {
                         Walker = Walker->next;
                         for (int i=NDIM;i--;)
                                 temperature += Walker->type->mass * Trajectories[Walker].U.at(step).x[i]* Trajectories[Walker].U.at(step).x[i];
+                }
                 *output << step << "\t" << temperature*AtomicEnergyToKelvin << "\t" << temperature << endl;
+        }
         return true;
 };
+  double temperature;
+  atom *Walker = NULL;
+  // test stream
+  if (output == NULL)
+    return false;
+  else
+    *output << "# Step Temperature [K] Temperature [a.u.]" << endl;
+  for (int step=startstep;step < endstep; step++) { // loop over all time steps
+    temperature = 0.;
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      for (int i=NDIM;i--;)
+        temperature += Walker->type->mass * Trajectories[Walker].U.at(step).x[i]* Trajectories[Walker].U.at(step).x[i];
+    }
+    *output << step << "\t" << temperature*AtomicEnergyToKelvin << "\t" << temperature << endl;
+  }
+  return true;
+};

src/molecules.hpp

-              r178f92
+              r437922
 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:
+  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:
 };
 …
  */
 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()
+  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()
 };
 …
  */
 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);
         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);
         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);
+  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
 };
 …
  */
 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);
         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
+  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;
+    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);
 };

src/parser.cpp

-              r178f92
+              r437922
 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)*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;
 };
 …
  */
 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 (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");
 };
 /** 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;
+  }
+  // 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;
 };
 …
  * -# 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;
+  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;
 };
 …
 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;
+  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;
 };
 …
 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;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;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;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;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;
+  for(int j=RowCounter[MatrixCounter]+1;j--;)
+    for(int k=skipcolumns;k<ColumnCounter;k++)
+      Matrix[MatrixCounter][j][k] = values[j][k];
+   return true;
 };
 …
 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;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;
 };
 …
 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 << 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;
 };
 …
 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 << 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;
 };
 …
 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;
 };
 …
 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;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;
 };
 …
 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;
+    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;
 };
 …
 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;
 };
 …
  * \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;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();
+    // 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;
 };
 …
  */
 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

-              r178f92
+              r437922
 class MatrixContainer {
         public:
                 double ***Matrix;
                 int **Indices;
                 char *Header;
                 int MatrixCounter;
                 int *RowCounter;
                 int ColumnCounter;
+  public:
+    double ***Matrix;
+    int **Indices;
+    char *Header;
+    int MatrixCounter;
+    int *RowCounter;
+    int ColumnCounter;
         MatrixContainer();
         virtual ~MatrixContainer();
+  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);
+  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 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

-              r178f92
+              r437922
 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;
+};

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

Context Navigation

Changeset 437922

Legend:

Download in other formats: