Changeset 6ac7ee for src

Timestamp:

Feb 9, 2009, 5:24:10 PM (17 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, Candidate_v1.7.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

d8b94a

Parents:

124df1

git-author:

Frederik Heber <heber@…> (02/09/09 15:55:37)

git-committer:

Frederik Heber <heber@…> (02/09/09 17:24:10)

Message:

Merge branch 'ConcaveHull' of ../espack2 into ConcaveHull

Conflicts:

molecuilder/src/boundary.cpp
molecuilder/src/boundary.hpp
molecuilder/src/builder.cpp
molecuilder/src/linkedcell.cpp
molecuilder/src/linkedcell.hpp
molecuilder/src/vector.cpp
molecuilder/src/vector.hpp
util/src/NanoCreator.c

Basically, this resulted from a lot of conversions two from spaces to one tab, which is my standard indentation. The mess was caused by eclipse auto-indenting. And in espack2:ConcaveHull was the new stuff, so all from ConcaveHull was replaced in case of doubt.
Additionally, vector had ofstream << operator instead ostream << ...

Location:

src

Files:

• .#border.cpp (deleted)
• .#molecules.hpp (deleted)
• Hbondangle.db (modified) (1 prop)
• Hbonddistance.db (modified) (1 prop)
• Makefile.am (modified) (1 diff, 1 prop)
• analyzer.cpp (modified) (3 diffs, 1 prop)
• atom.cpp (modified) (6 diffs, 1 prop)
• bond.cpp (modified) (11 diffs, 1 prop)
• boundary.cpp (modified) (33 diffs, 1 prop)
• boundary.hpp (modified) (2 diffs, 1 prop)
• builder.cpp (modified) (13 diffs, 1 prop)
• config.cpp (modified) (14 diffs, 1 prop)
• datacreator.cpp (modified) (28 diffs, 1 prop)
• datacreator.hpp (modified) (3 diffs, 1 prop)
• defs.hpp (modified) (4 diffs, 1 prop)
• element.cpp (modified) (2 diffs, 1 prop)
• elements.db (modified) (1 prop)
• ellipsoid.cpp (added)
• ellipsoid.hpp (added)
• graph.cpp (modified) (2 diffs, 1 prop)
• helpers.cpp (modified) (13 diffs, 1 prop)
• helpers.hpp (modified) (12 diffs, 1 prop)
• joiner.cpp (modified) (2 diffs, 1 prop)
• linkedcell.cpp (modified) (7 diffs)
• linkedcell.hpp (modified) (1 diff)
• moleculelist.cpp (modified) (16 diffs, 1 prop)
• molecules.cpp (modified) (93 diffs, 1 prop)
• molecules.hpp (modified) (11 diffs, 1 prop)
• orbitals.db (modified) (1 prop)
• parser.cpp (modified) (26 diffs, 1 prop)
• parser.hpp (modified) (4 diffs, 1 prop)
• periodentafel.cpp (modified) (11 diffs, 1 prop)
• periodentafel.hpp (modified) (2 diffs, 1 prop)
• stackclass.hpp (modified) (12 diffs, 1 prop)
• valence.db (modified) (1 prop)
• vector.cpp (modified) (37 diffs, 1 prop)
• vector.hpp (modified) (1 diff, 1 prop)
• verbose.cpp (modified) (2 diffs, 1 prop)

src/Makefile.am

@@ -1 @@
-SOURCE = atom.cpp bond.cpp boundary.cpp builder.cpp config.cpp element.cpp helpers.cpp molecules.cpp moleculelist.cpp parser.cpp periodentafel.cpp vector.cpp verbose.cpp
-HEADER = boundary.hpp defs.hpp helpers.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp vector.hpp
+SOURCE = atom.cpp bond.cpp boundary.cpp builder.cpp config.cpp element.cpp ellipsoid.cpp helpers.cpp molecules.cpp linkedcell.cpp moleculelist.cpp parser.cpp periodentafel.cpp vector.cpp verbose.cpp
+HEADER = boundary.hpp defs.hpp ellipsoid.hpp helpers.hpp linkedcell.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp vector.hpp
 
 bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
-molecuilder_DATA = elements.db valence.db       orbitals.db Hbonddistance.db Hbondangle.db
+molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_SOURCES =  ${SOURCE} ${HEADER}
 joiner_SOURCES = joiner.cpp datacreator.cpp element.cpp helpers.cpp periodentafel.cpp parser.cpp verbose.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp 

src/analyzer.cpp

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

src/atom.cpp

@@ -14 +14 @@
 {
         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;
+        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;
 };
 
@@ -36 +36 @@
 {
         Free((void **)&Name, "atom::~atom: *Name");
-  Free((void **)&ComponentNr, "atom::~atom: *ComponentNr");
+        Free((void **)&ComponentNr, "atom::~atom: *ComponentNr");
 };
 
@@ -45 +45 @@
 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;
 };
 
@@ -61 +61 @@
 bool atom::Output(int ElementNo, int AtomNo, ofstream *out) 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";
-    *out << " # Number in molecule " << 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";
+                *out << " # Number in molecule " << nr << endl;
+                return true;
+        } else
+                return false;
 };
 
@@ -78 +78 @@
 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;
 };
 
@@ -97 +97 @@
 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

@@ -16 +16 @@
         leftatom = NULL;
         rightatom = NULL;
-  previous = NULL;
-  next = NULL;
+        previous = NULL;
+        next = NULL;
         nr = -1;
         HydrogenBond = 0;
         BondDegree = 0;
-  Used = white;
-  Cyclic = false;
-  Type = Undetermined;
+        Used = white;
+        Cyclic = false;
+        Type = Undetermined;
 };
 
@@ -36 +36 @@
         leftatom = left;
         rightatom = right;
-  previous = NULL;
-  next = NULL;
+        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;
+        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;
 };
 
@@ -73 +73 @@
 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;
 };
 
@@ -94 +94 @@
 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;
 };
 
@@ -107 +107 @@
 bond * bond::GetFirstBond()
 {
-  return GetFirst(this);
+        return GetFirst(this);
 };
 
@@ -116 +116 @@
 bond * bond::GetLastBond()
 {
-  return GetLast(this);
+        return GetLast(this);
 };
 
@@ -124 +124 @@
 enum Shading bond::IsUsed() 
 {
-  return Used;
+        return Used;
 };
 
@@ -133 +133 @@
 bool bond::Contains(const atom *ptr)
 {
-  return ((leftatom == ptr) || (rightatom == ptr));
+        return ((leftatom == ptr) || (rightatom == ptr));
 };
 
@@ -142 +142 @@
 bool bond::Contains(const int number)
 {
-  return ((leftatom->nr == number) || (rightatom->nr == number));
+        return ((leftatom->nr == number) || (rightatom->nr == number));
 };
 
@@ -149 +149 @@
  */
 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;
+        }
 };
 
@@ -162 +162 @@
  */
 void bond::ResetUsed() {
-  Used = white;
+        Used = white;
 };

src/boundary.cpp

@@ -1 @@
-#include "molecules.hpp"
 #include "boundary.hpp"
 
 #define DEBUG 1
-#define DoTecplotOutput 0
+#define DoSingleStepOutput 0
+#define DoTecplotOutput 1
 #define DoRaster3DOutput 1
+#define DoVRMLOutput 1
 #define TecplotSuffix ".dat"
 #define Raster3DSuffix ".r3d"
+#define VRMLSUffix ".wrl"
+#define HULLEPSILON MYEPSILON
 
 // ======================================== Points on Boundary =================================
@@ -12 +15 @@
 BoundaryPointSet::BoundaryPointSet()
 {
-  LinesCount = 0;
-  Nr = -1;
+        LinesCount = 0;
+        Nr = -1;
 }
 ;
@@ -19 +22 @@
 BoundaryPointSet::BoundaryPointSet(atom *Walker)
 {
-  node = Walker;
-  LinesCount = 0;
-  Nr = Walker->nr;
+        node = Walker;
+        LinesCount = 0;
+        Nr = Walker->nr;
 }
 ;
@@ -27 +30 @@
 BoundaryPointSet::~BoundaryPointSet()
 {
-  cout << Verbose(5) << "Erasing point nr. " << Nr << "." << 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(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++;
 }
 ;
@@ -52 +56 @@
 operator <<(ostream &ost, BoundaryPointSet &a)
 {
-  ost << "[" << a.Nr << "|" << a.node->Name << "]";
-  return ost;
+        ost << "[" << a.Nr << "|" << a.node->Name << "]";
+        return ost;
 }
 ;
@@ -61 +65 @@
 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;
 }
 ;
@@ -70 +74 @@
 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;
 }
 ;
@@ -85 +89 @@
 BoundaryLineSet::~BoundaryLineSet()
 {
-  for (int i = 0; i < 2; i++)
-    {
-      cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point "
-          << *endpoints[i] << "." << endl;
-      endpoints[i]->lines.erase(Nr);
-      LineMap::iterator tester = endpoints[i]->lines.begin();
-      tester++;
-      if (tester == endpoints[i]->lines.end())
-        {
-          cout << Verbose(5) << *endpoints[i]
-              << " has no more lines it's attached to, erasing." << endl;
-          //delete(endpoints[i]);
-        }
-      else
-        cout << Verbose(5) << *endpoints[i]
-            << " has still lines it's attached to." << 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;
 }
 ;
@@ -108 +113 @@
 BoundaryLineSet::AddTriangle(class BoundaryTriangleSet *triangle)
 {
-  cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
-      << endl;
-  triangles.insert(TrianglePair(TrianglesCount, triangle));
-  TrianglesCount++;
+        cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
+                        << endl;
+        triangles.insert(TrianglePair(triangle->Nr, triangle));
+        TrianglesCount++;
 }
 ;
@@ -118 +123 @@
 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;
 }
 ;
@@ -129 +134 @@
 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;
 }
 ;
@@ -182 +187 @@
 BoundaryTriangleSet::~BoundaryTriangleSet()
 {
-  for (int i = 0; i < 3; i++)
-    {
-      cout << Verbose(5) << "Erasing triangle Nr." << Nr << endl;
-      lines[i]->triangles.erase(Nr);
-      TriangleMap::iterator tester = lines[i]->triangles.begin();
-      tester++;
-      if (tester == lines[i]->triangles.end())
-        {
-          cout << Verbose(5) << *lines[i]
-              << " is no more attached to any triangle, erasing." << endl;
-          delete (lines[i]);
-        }
-      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;
+        }
 }
 ;
@@ -204 +206 @@
 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 (endpoints[0]->node->x.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.);
 }
 ;
@@ -217 +219 @@
 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;
 }
 ;
@@ -233 +235 @@
 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;
 }
 ;
@@ -268 +270 @@
 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;
 }
 ;
@@ -476 +478 @@
 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;
-}
-;
-
-/** Creates the objects in a raster3d file (renderable with a header.r3d)
+                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;
+}
+;
+
+/** Creates the objects in a VRML file.
  * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
+ * \param *vrmlfile output stream for tecplot data
+ * \param *Tess Tesselation structure with constructed triangles
+ * \param *mol molecule structure with atom positions
+ */
+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);
+};
+
+/** Creates the objects in a raster3d file (renderable with a header.r3d).
+ * \param *out output stream for debugging
+ * \param *rasterfile output stream for tecplot data
  * \param *Tess Tesselation structure with constructed triangles
  * \param *mol molecule structure with atom positions
@@ -577 +633 @@
 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;
-    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
-    }
-  } 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);
 };
 
-/*
- * This function creates the tecplot file, displaying the tesselation of the hull.
+/** This function creates the tecplot file, displaying the tesselation of the hull.
  * \param *out output stream for debugging
  * \param *tecplot output stream for tecplot data
@@ -631 +688 @@
 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;
+                }
 }
 
@@ -678 +735 @@
  * Determines first the convex envelope, then tesselates it and calculates its volume.
  * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
+ * \param *filename filename prefix for output of vertex data
  * \param *configuration needed for path to store convex envelope file
  * \param *BoundaryPoints NDIM set of boundary points on the projected plane per axis, on return if desired
@@ -685 +742 @@
  */
 double
-VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, 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.Distance(
-          &runner->second->endpoints[1]->node->x));
-      b = sqrt(runner->second->endpoints[0]->node->x.Distance(
-          &runner->second->endpoints[2]->node->x));
-      c = sqrt(runner->second->endpoints[2]->node->x.Distance(
-          &runner->second->endpoints[1]->node->x));
-      G = sqrt(((a * a + b * b + c * c) * (a * a + b * b + c * c) - 2 * (a * a
-          * a * a + b * b * b * b + c * c * 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
-  write_tecplot_file(out, tecplot, TesselStruct, mol, 0);
-
-  // free reference lists
-  if (BoundaryFreeFlag)
-    delete[] (BoundaryPoints);
-
-  return volume;
+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;
 }
 ;
@@ -822 +883 @@
 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;
 }
 ;
@@ -939 +1000 @@
 Tesselation::Tesselation()
 {
-  PointsOnBoundaryCount = 0;
-  LinesOnBoundaryCount = 0;
-  TrianglesOnBoundaryCount = 0;
-  TriangleFilesWritten = 0;
+        PointsOnBoundaryCount = 0;
+        LinesOnBoundaryCount = 0;
+        TrianglesOnBoundaryCount = 0;
+        TriangleFilesWritten = 0;
 }
 ;
@@ -951 +1012 @@
 Tesselation::~Tesselation()
 {
-  cout << Verbose(1) << "Free'ing TesselStruct ... " << endl;
-  for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner
-      != TrianglesOnBoundary.end(); runner++)
-    {
-      delete (runner->second);
-    }
+        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;
+        }
 }
 ;
@@ -968 +1031 @@
 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.Distance(&B->second->node->x);
-              distance = tmp * tmp;
-              tmp = A->second->node->x.Distance(&C->second->node->x);
-              distance += tmp * tmp;
-              tmp = B->second->node->x.Distance(&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.Distance(&A->second->node->x);
-          int innerpoint = 0;
-          if ((tmp < A->second->node->x.Distance(
-              &baseline->second.first->second->node->x)) && (tmp
-              < A->second->node->x.Distance(
-                  &baseline->second.second->second->node->x)))
-            innerpoint++;
-          tmp = checker->second->node->x.Distance(
-              &baseline->second.first->second->node->x);
-          if ((tmp < baseline->second.first->second->node->x.Distance(
-              &A->second->node->x)) && (tmp
-              < baseline->second.first->second->node->x.Distance(
-                  &baseline->second.second->second->node->x)))
-            innerpoint++;
-          tmp = checker->second->node->x.Distance(
-              &baseline->second.second->second->node->x);
-          if ((tmp < baseline->second.second->second->node->x.Distance(
-              &baseline->second.first->second->node->x)) && (tmp
-              < baseline->second.second->second->node->x.Distance(
-                  &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);
+                }
 }
 ;
@@ -1128 +1191 @@
  * -# 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
@@ -1138 +1201 @@
 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);
 
 }
@@ -1368 +1431 @@
 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++;
 }
 ;
@@ -1384 +1447 @@
 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;
+                }
 }
 ;
@@ -1410 +1473 @@
 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))->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++;
+
+                }
 }
 ;
@@ -1457 +1520 @@
 {
 
-  cout << Verbose(1) << "Adding triangle to its lines" << endl;
-  int i = 0;
-  TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
-  TrianglesOnBoundaryCount++;
-
-  /*
-   * this is apparently done when constructing triangle
-
-   for (i=0; i<3; i++)
-   {
-   BLS[i]->AddTriangle(BTS);
-   }
-   */
-}
-;
+        cout << Verbose(1) << "Adding triangle to its lines" << endl;
+        int i = 0;
+        TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
+        TrianglesOnBoundaryCount++;
+
+        /*
+         * this is apparently done when constructing triangle
+
+         for (i=0; i<3; i++)
+         {
+         BLS[i]->AddTriangle(BTS);
+         }
+         */
+}
+;
+
+
+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;
+};
+
+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);
+};
+
+
 
 /**
@@ -1489 +1629 @@
  * @param Umkreisradius double radius of circumscribing circle
  */
-
-  void Get_center_of_sphere(Vector* Center, Vector a, Vector b, Vector c, Vector* Direction, Vector* AlternativeDirection,
-      double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
-  {
-    Vector TempNormal, helper;
-    double Restradius;
-
-    *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)));
-    // Here we calculated center of circumscribing circle, using barycentric coordinates
-
-    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);
-    TempNormal.Scale(Restradius);
-
-    Center->AddVector(&TempNormal);
-  }
-  ;
-
+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";
+};
 
 /** 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
@@ -1552 +1709 @@
  * @param mol molecule structure with atoms and bonds
  */
-
-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)
-{
-  //cout << "ReferencePoint is " << ReferencePoint.x[0] << " "<< ReferencePoint.x[1] << " "<< ReferencePoint.x[2] << " "<< endl;
-  /* OldNormal is normal vector on the old triangle
-   * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
-   * Chord points from b to a!!!
-   */
-  Vector dif_a; //Vector from a to candidate
-  Vector dif_b; //Vector from b to candidate
-  Vector AngleCheck;
-  Vector TempNormal, Umkreismittelpunkt;
-  Vector Mittelpunkt;
-
-  double CurrentEpsilon = 0.1;
-  double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius, Distance;
-  double BallAngle, AlternativeSign;
-  atom *Walker; // variable atom point
-
-
-  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);
-
-
-  if (a != Candidate and b != Candidate and c != Candidate)
-    {
-
-      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(1) << "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);
-            }
-
-
-
-          Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
-
-          AngleCheck.CopyVector(&ReferencePoint);
-          AngleCheck.Scale(-1);
-          //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-          AngleCheck.AddVector(&Mittelpunkt);
-          //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-
-          BallAngle = AngleCheck.Angle(OldNormal);
-
-          //cout << "direction1 is " << direction1->x[0] <<" "<< direction1->x[1] <<" "<< direction1->x[2] <<" " << endl;
-          //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-
-          cout << Verbose(1) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
-
-          if (AngleCheck.ScalarProduct(direction1) >=0)
-            {
-              if (Storage[0]< -1.5) // first Candidate at all
-                {
-
-                  cout << "Next better candidate is " << *Candidate << " with ";
-                  Opt_Candidate = Candidate;
-                  Storage[0] = sign;
-                  Storage[1] = AlternativeSign;
-                  Storage[2] = BallAngle;
-                  cout << "Angle is " << Storage[2] << ", Halbraum ist "
-                    << Storage[0] << endl;
-
-
-                }
-              else
-                {
-                  if ( Storage[2] > BallAngle)
-                    {
-                      cout << "Next better candidate is " << *Candidate << " with ";
-                      Opt_Candidate = Candidate;
-                      Storage[0] = sign;
-                      Storage[1] = AlternativeSign;
-                      Storage[2] = BallAngle;
-                      cout << "Angle is " << Storage[2] << ", Halbraum ist "
-                        << Storage[0] << endl;
-                    }
-                  else
-                    {
-                      //if (DEBUG)
-                        cout << "Looses to better candidate" << endl;
-
-                    }
-                }
-              }
-            else
-              {
-                //if (DEBUG)
-                  cout << "Refused due to bad direction of ball centre." << endl;
-              }
-          }
-        else
-          {
-            //if (DEBUG)
-              cout << "Doesn't satisfy requirements for circumscribing circle" << endl;
-          }
-      }
-    else
-      {
-        //if (DEBUG)
-          cout << "identisch mit Ursprungslinie" << endl;
-
-      }
-
-
-
-  if (RecursionLevel < 9) // 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
-            }
-        }
-    }
-}
-;
-
-
-  /** 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.
-   * @param a first point
-   * @param b second point
-   * @param Candidate base point along whose bonds to start looking from
-   * @param Parent point to avoid during search as its wrong direction
-   * @param RecursionLevel contains current recursion depth
-   * @param Chord baseline vector of first and second point
-   * @param d1 second in plane vector (along with \a Chord) of the triangle the baseline belongs to
-   * @param OldNormal normal of the triangle which the baseline belongs to
-   * @param Opt_Candidate candidate reference to return
-   * @param Opt_Mittelpunkt Centerpoint of ball, when resting on Opt_Candidate
-   * @param Storage array containing two angles of current Opt_Candidate
-   * @param RADIUS radius of ball
-   * @param mol molecule structure with atoms and bonds
-   */
-
-void Find_next_suitable_point(atom* a, atom* b, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector *Chord, Vector *d1, Vector *OldNormal,
-    atom*& Opt_Candidate, Vector *Opt_Mittelpunkt, double *Storage, const double RADIUS, molecule* mol)
-{
-  /* OldNormal is normal vector on the old triangle
-   * d1 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, AngleCheckReference, DirectionCheckPoint;
-  Vector TempNormal, Umkreismittelpunkt, Mittelpunkt;
-
-  double CurrentEpsilon = 0.1;
-  double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius, Distance;
-  double BallAngle;
-  atom *Walker; // variable atom point
-
-
-  dif_a.CopyVector(&(a->x));
-  dif_a.SubtractVector(&(Candidate->x));
-  dif_b.CopyVector(&(b->x));
-  dif_b.SubtractVector(&(Candidate->x));
-  DirectionCheckPoint.CopyVector(&dif_a);
-  DirectionCheckPoint.Scale(-1);
-  DirectionCheckPoint.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);
-
-
-  if (DEBUG)
-    {
-      cout << "Atom number" << Candidate->nr << endl;
-      Candidate->x.Output((ofstream *) &cout);
-      cout << "number of bonds " << mol->NumberOfBondsPerAtom[Candidate->nr]
-          << endl;
-    }
-
-  if (a != Candidate and b != Candidate)
-    {
-      //      alpha = dif_a.Angle(&dif_b) / 2.;
-      //      SideA = Chord->Norm() / 2.;// (Chord->Norm()/2.) / sin(0.5*alpha);
-      //      SideB = dif_a.Norm();
-      //      centerline = SideA * SideA + SideB * SideB - 2. * SideA * SideB * cos(
-      //          alpha); // note this is squared of center line length
-      //      centerline = (Chord->Norm()/2.) / sin(0.5*alpha);
-      // Those are remains from Freddie. Needed?
-
-
-
-      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 && DirectionCheckPoint.ScalarProduct(&(Candidate->x))>0) //Checking whether ball will at least rest o points.
-        {
-
-          // intermediate calculations to aquire centre of sphere, called Mittelpunkt:
-
-          Umkreismittelpunkt = (a->x) * sin(2.*alpha) + b->x * sin(2.*beta) + (Candidate->x) * sin(2.*gamma) ;
-          Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-
-          TempNormal.CopyVector(&dif_a);
-          TempNormal.VectorProduct(&dif_b);
-          if (TempNormal.ScalarProduct(OldNormal)<0 && sign>0 || TempNormal.ScalarProduct(OldNormal)>0 && sign<0)
-            {
-              TempNormal.Scale(-1);
-            }
-          TempNormal.Normalize();
-          Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
-          TempNormal.Scale(Restradius);
-
-          Mittelpunkt.CopyVector(&Umkreismittelpunkt);
-          Mittelpunkt.AddVector(&TempNormal);  //this is center of sphere supported by a, b and Candidate
-
-          AngleCheck.CopyVector(Chord);
-          AngleCheck.Scale(-0.5);
-          AngleCheck.SubtractVector(&(b->x));
-          AngleCheckReference.CopyVector(&AngleCheck);
-          AngleCheckReference.AddVector(Opt_Mittelpunkt);
-          AngleCheck.AddVector(&Mittelpunkt);
-
-          BallAngle = AngleCheck.Angle(&AngleCheckReference);
-
-          d1->ProjectOntoPlane(&AngleCheckReference);
-          sign = AngleCheck.ScalarProduct(d1);
-          sign /= fabs(sign); // +1 if in direction of triangle plane, -1 if in other direction...
-
-
-          if (Storage[0]< -1.5) // first Candidate at all
-            {
-
-              cout << "Next better candidate is " << *Candidate << " with ";
-              Opt_Candidate = Candidate;
-              Storage[0] = sign;
-              Storage[1] = BallAngle;
-              Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-              cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                  << Storage[0] << endl;
-
-
-            }
-          else
-            {
-              /*
-               * removed due to change in criterium, now checking angle of ball to old normal.
-              //We will now check for non interference, that is if the new candidate would have the Opt_Candidate
-              //within the ball.
-
-              Distance = Opt_Candidate->x.Distance(&Mittelpunkt);
-              //cout << "Opt_Candidate " << Opt_Candidate << " has distance " << Distance << " to Center of Candidate " << endl;
-
-
-              if (Distance >RADIUS) // We have no interference and may now check whether the new point is better.
-                */
-                {
-                  //cout << "Atom " << Candidate << " has distance " << Candidate->x.Distance(Opt_Mittelpunkt) << " to Center of Candidate " << endl;
-
-                  if (((Storage[0] < 0 && fabs(sign - Storage[0]) > CurrentEpsilon)))  //This will give absolute preference to those in "right-hand" quadrants
-                      //(Candidate->x.Distance(Opt_Mittelpunkt) < RADIUS))    //and those where Candidate would be within old Sphere.
-                    {
-                      cout << "Next better candidate is " << *Candidate << " with ";
-                      Opt_Candidate = Candidate;
-                      Storage[0] = sign;
-                      Storage[1] = BallAngle;
-                      Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                      cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                          << Storage[0] << endl;
-
-
-                    }
-                  else
-                    {
-                      if ((fabs(sign - Storage[0]) < CurrentEpsilon && sign > 0
-                          && Storage[1] > BallAngle) ||
-                          (fabs(sign - Storage[0]) < CurrentEpsilon && sign < 0
-                          && Storage[1] < BallAngle))
-                      //Depending on quadrant we prefer higher or lower atom with respect to Triangle normal first.
-                        {
-                          cout << "Next better candidate is " << *Candidate << " with ";
-                          Opt_Candidate = Candidate;
-                          Storage[0] = sign;
-                          Storage[1] = BallAngle;
-                          Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                          cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                              << Storage[0] << endl;
-                        }
-
-                    }
-                }
-              /*
-               * This is for checking point-angle and presence of Candidates in Ball, currently we are checking the ball Angle.
-               *
-                else
-                {
-                  if (sign>0 && BallAngle>0 && Storage[0]<0)
-                    {
-                      cout << "Next better candidate is " << *Candidate << " with ";
-                      Opt_Candidate = Candidate;
-                      Storage[0] = sign;
-                      Storage[1] = BallAngle;
-                      Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                      cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                      << Storage[0] << endl;
-
-//Debugging purposes only
-                      cout << "Umkreismittelpunkt has coordinates" << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] <<" "<<Umkreismittelpunkt.x[2] << endl;
-                      cout << "Candidate has coordinates" << Candidate->x.x[0]<< " " << Candidate->x.x[1] << " " << Candidate->x.x[2] << endl;
-                      cout << "a has coordinates" << a->x.x[0]<< " " << a->x.x[1] << " " << a->x.x[2] << endl;
-                      cout << "b has coordinates" << b->x.x[0]<< " " << b->x.x[1] << " " << b->x.x[2] << endl;
-                      cout << "Mittelpunkt has coordinates" << Mittelpunkt.x[0] << " " << Mittelpunkt.x[1]<< " "  <<Mittelpunkt.x[2] << endl;
-                      cout << "Umkreisradius ist " << Umkreisradius << endl;
-                      cout << "Restradius ist " << Restradius << endl;
-                      cout << "TempNormal has coordinates " << TempNormal.x[0] << " " << TempNormal.x[1] << " " << TempNormal.x[2] << " " << endl;
-                      cout << "OldNormal has coordinates " << OldNormal->x[0] << " " << OldNormal->x[1] << " " << OldNormal->x[2] << " " << endl;
-                      cout << "Dist a to UmkreisMittelpunkt " << a->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist b to UmkreisMittelpunkt " << b->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist Candidate to UmkreisMittelpunkt " << Candidate->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist a to Mittelpunkt " << a->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist b to Mittelpunkt " << b->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist Candidate to Mittelpunkt " << Candidate->x.Distance(&Mittelpunkt) << endl;
-
-
-
-                    }
-                  else
-                    {
-                      if (DEBUG)
-                        cout << "Looses to better candidate" << endl;
-                    }
-                }
-                */
-            }
-        }
-      else
-        {
-          if (DEBUG)
-            {
-              cout << "Doesn't satisfy requirements for circumscribing circle" << endl;
-            }
-        }
-    }
-
-  else
-    {
-      if (DEBUG)
-        cout << "identisch mit Ursprungslinie" << endl;
-    }
-
-  if (RecursionLevel < 9) // Five 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(a, b, Walker, Candidate, RecursionLevel
-                  + 1, Chord, d1, OldNormal, Opt_Candidate, Opt_Mittelpunkt, Storage, RADIUS,
-                  mol); //call function again
-
-            }
-        }
-    }
-}
-;
+void Tesselation::Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent,
+                int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint,
+                atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol)
+{
+        cout << Verbose(2) << "Begin of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+        cout << Verbose(3) << "Candidate is "<< *Candidate << endl;
+        cout << Verbose(4) << "Baseline vector is " << *Chord << "." << endl;
+        cout << Verbose(4) << "ReferencePoint is " << ReferencePoint << "." << endl;
+        cout << Verbose(4) << "Normal of base triangle is " << *OldNormal << "." << endl;
+        cout << Verbose(4) << "Search direction is " << *direction1 << "." << endl;
+        /* OldNormal is normal vector on the old triangle
+         * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
+         * Chord points from b to a!!!
+         */
+        Vector dif_a; //Vector from a to candidate
+        Vector dif_b; //Vector from b to candidate
+        Vector AngleCheck;
+        Vector TempNormal, Umkreismittelpunkt;
+        Vector Mittelpunkt;
+
+        double CurrentEpsilon = 0.1;
+        double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius, Distance;
+        double BallAngle, AlternativeSign;
+        atom *Walker; // variable atom point
+
+        Vector NewUmkreismittelpunkt;
+
+        if (a != Candidate and b != Candidate and c != Candidate) {
+                cout << Verbose(3) << "We have a unique candidate!" << endl;
+                dif_a.CopyVector(&(a->x));
+                dif_a.SubtractVector(&(Candidate->x));
+                dif_b.CopyVector(&(b->x));
+                dif_b.SubtractVector(&(Candidate->x));
+                AngleCheck.CopyVector(&(Candidate->x));
+                AngleCheck.SubtractVector(&(a->x));
+                AngleCheck.ProjectOntoPlane(Chord);
+
+                SideA = dif_b.Norm();
+                SideB = dif_a.Norm();
+                SideC = Chord->Norm();
+                //Chord->Scale(-1);
+
+                alpha = Chord->Angle(&dif_a);
+                beta = M_PI - Chord->Angle(&dif_b);
+                gamma = dif_a.Angle(&dif_b);
+
+                cout << Verbose(2) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+
+                if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON) {
+                        cerr << Verbose(0) << "WARNING: sum of angles for base triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
+                        cout << Verbose(1) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
+                }
+
+                if ((M_PI*179./180. > alpha) && (M_PI*179./180. > beta) && (M_PI*179./180. > gamma)) {
+                        Umkreisradius = SideA / 2.0 / sin(alpha);
+                        //cout << Umkreisradius << endl;
+                        //cout << SideB / 2.0 / sin(beta) << endl;
+                        //cout << SideC / 2.0 / sin(gamma) << endl;
+
+                        if (Umkreisradius < RADIUS) { //Checking whether ball will at least rest on points.
+                                cout << Verbose(3) << "Circle of circumference would fit: " << Umkreisradius << " < " << RADIUS << "." << endl;
+                                cout << Verbose(2) << "Candidate is "<< *Candidate << endl;
+                                sign = AngleCheck.ScalarProduct(direction1);
+                                if (fabs(sign)<MYEPSILON) {
+                                        if (AngleCheck.ScalarProduct(OldNormal)<0) {
+                                                sign =0;
+                                                AlternativeSign=1;
+                                        } else {
+                                                sign =0;
+                                                AlternativeSign=-1;
+                                        }
+                                } else {
+                                        sign /= fabs(sign);
+                                }
+                                if (sign >= 0) {
+                                        cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
+                                        Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), &NewUmkreismittelpunkt, OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
+                                        Mittelpunkt.SubtractVector(&ReferencePoint);
+                                        cout << Verbose(3) << "Reference vector to sphere's center is " << Mittelpunkt << "." << endl;
+                                        BallAngle = Mittelpunkt.Angle(OldNormal);
+                                        cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
+
+                                        //cout << "direction1 is " << *direction1 << "." << endl;
+                                        //cout << "Mittelpunkt is " << Mittelpunkt << "."<< endl;
+                                        //cout << Verbose(3) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
+
+                                        NewUmkreismittelpunkt.SubtractVector(&ReferencePoint);
+
+                                        if ((Mittelpunkt.ScalarProduct(direction1) >=0) || (fabs(NewUmkreismittelpunkt.Norm()) < MYEPSILON)) {
+                                                if (Storage[0]< -1.5) { // first Candidate at all
+                                                        if (1) {//if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                                                                cout << Verbose(2) << "First good candidate is " << *Candidate << " with ";
+                                                                Opt_Candidate = Candidate;
+                                                                Storage[0] = sign;
+                                                                Storage[1] = AlternativeSign;
+                                                                Storage[2] = BallAngle;
+                                                                cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+                                                        } else
+                                                                cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+                                                } else {
+                                                        if ( Storage[2] > BallAngle) {
+                                                                if (1) { //if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
+                                                                        cout << Verbose(2) << "Next better candidate is " << *Candidate << " with ";
+                                                                        Opt_Candidate = Candidate;
+                                                                        Storage[0] = sign;
+                                                                        Storage[1] = AlternativeSign;
+                                                                        Storage[2] = BallAngle;
+                                                                        cout << " angle " << Storage[2] << " and Up/Down " << Storage[0] << endl;
+                                                                } else
+                                                                        cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
+                                                        } else {
+                                                                if (DEBUG) {
+                                                                        cout << Verbose(3) << *Candidate << " looses against better candidate " << *Opt_Candidate << "." << endl;
+                                                                }
+                                                        }
+                                                }
+                                        } else {
+                                                if (DEBUG) {
+                                                        cout << Verbose(3) << *Candidate << " refused due to Up/Down sign which is " << sign << endl;
+                                                }
+                                        }
+                                } else {
+                                        if (DEBUG) {
+                                                cout << Verbose(3) << *Candidate << " is not in search direction." << endl;
+                                        }
+                                }
+                        } else {
+                                if (DEBUG) {
+                                        cout << Verbose(3) << *Candidate << " would have circumference of " << Umkreisradius << " bigger than ball's radius " << RADIUS << "." << endl;
+                                }
+                        }
+                } else {
+                        if (DEBUG) {
+                                cout << Verbose(0) << "Triangle consisting of " << *Candidate << ", " << *a << " and " << *b << " has an angle >150!" << endl;
+                        }
+                }
+        } else {
+                if (DEBUG) {
+                        cout << Verbose(3) << *Candidate << " is either " << *a << " or " << *b << "." << endl;
+                }
+        }
+
+        if (RecursionLevel < 5) { // Seven is the recursion level threshold.
+                for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
+                        Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
+                        if (Walker == Parent) { // don't go back the same bond
+                                continue;
+                        } else {
+                                Find_next_suitable_point_via_Angle_of_Sphere(a, b, c, Walker, Candidate, RecursionLevel+1, Chord, direction1, OldNormal, ReferencePoint, Opt_Candidate, Storage, RADIUS, mol); //call function again
+                        }
+                }
+        }
+        cout << Verbose(2) << "End of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
+}
+;
+
+
+/** Constructs the center of the circumcircle defined by three points \a *a, \a *b and \a *c.
+ * \param *Center new center on return
+ * \param *a first point
+ * \param *b second point
+ * \param *c third point
+ */
+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)));
+};
+
+/** Returns the parameter "path length" for a given \a NewSphereCenter relative to \a OldSphereCenter on a circle on the plane \a CirclePlaneNormal with center \a CircleCenter and radius \a CircleRadius.
+ * Test whether the \a NewSphereCenter is really on the given plane and in distance \a CircleRadius from \a CircleCenter.
+ * It calculates the angle, making it unique on [0,2.*M_PI) by comparing to SearchDirection.
+ * Also the new center is invalid if it the same as the old one and does not lie right above (\a NormalVector) the base line (\a CircleCenter).
+ * \param CircleCenter Center of the parameter circle
+ * \param CirclePlaneNormal normal vector to plane of the parameter circle
+ * \param CircleRadius radius of the parameter circle
+ * \param NewSphereCenter new center of a circumcircle
+ * \param OldSphereCenter old center of a circumcircle, defining the zero "path length" on the parameter circle
+ * \param NormalVector normal vector
+ * \param SearchDirection search direction to make angle unique on return.
+ * \return Angle between \a NewSphereCenter and \a OldSphereCenter relative to \a CircleCenter, 2.*M_PI if one test fails
+ */
+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;
+        }
+};
+
+
+/** This recursive function finds a third point, to form a triangle with two given ones.
+ * The idea is as follows: A sphere with fixed radius is (almost) uniquely defined in space by three points
+ * that sit on its boundary. Hence, when two points are given and we look for the (next) third point, then
+ * the center of the sphere is still fixed up to a single parameter. The band of possible values
+ * describes a circle in 3D-space. The old center of the sphere for the current base triangle gives
+ * us the "null" on this circle, the new center of the candidate point will be some way along this
+ * circle. The shorter the way the better is the candidate. Note that the direction is clearly given
+ * by the normal vector of the base triangle that always points outwards by construction.
+ * Hence, we construct a Center of this circle which sits right in the middle of the current base line.
+ * We construct the normal vector that defines the plane this circle lies in, it is just in the
+ * direction of the baseline. And finally, we need the radius of the circle, which is given by the rest
+ * with respect to the length of the baseline and the sphere's fixed \a RADIUS.
+ * Note that there is one difficulty: The circumcircle is uniquely defined, but for the circumsphere's center
+ * there are two possibilities which becomes clear from the construction as seen below. Hence, we must check
+ * both.
+ * Note also that the acos() function is not unique on [0, 2.*M_PI). Hence, we need an additional check
+ * to decide for one of the two possible angles. Therefore we need a SearchDirection and to make this check
+ * sensible we need OldSphereCenter to be orthogonal to it. Either we construct SearchDirection orthogonal
+ * right away, or -- what we do here -- we rotate the relative sphere centers such that this orthogonality
+ * holds. Then, the normalized projection onto the SearchDirection is either +1 or -1 and thus states whether
+ * the angle is uniquely in either (0,M_PI] or [M_PI, 2.*M_PI).
+ * @param BaseTriangle BoundaryTriangleSet of the current base triangle with all three points
+ * @param BaseLine BoundaryLineSet of BaseTriangle with the current base line
+ * @param OptCandidate candidate reference on return
+ * @param OptCandidateCenter candidate's sphere center on return
+ * @param ShortestAngle the current path length on this circle band for the current Opt_Candidate
+ * @param RADIUS radius of sphere
+ * @param *LC LinkedCell structure with neighbouring atoms
+ */
+// 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;
+//
+//       cout << Verbose(1) << "Begin of Find_next_suitable_point" << 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 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;
+//
+//               // 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) {
+//
+//                       // 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);
+//
+//                                                               // 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);
+//
+//                                                                       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, 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;
+//       }
+//
+//       cout << Verbose(1) << "End of Find_next_suitable_point" << endl;
+// };
+
+
+/** Checks whether the triangle consisting of the three atoms is already present.
+ * Searches for the points in Tesselation::PointsOnBoundary and checks their
+ * lines. If any of the three edges already has two triangles attached, false is
+ * returned.
+ * \param *out output stream for debugging
+ * \param *Candidates endpoints of the triangle candidate
+ * \return false - triangle invalid due to edge criteria, true - triangle may be added.
+ */
+bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *Candidates[3]) {
+        LineMap::iterator FindLine;
+        PointMap::iterator FindPoint;
+        bool Present[3];
+
+        *out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
+        for (int i=0;i<3;i++) { // check through all endpoints
+                FindPoint = PointsOnBoundary.find(Candidates[i]->nr);
+                if (FindPoint != PointsOnBoundary.end())
+                        TPS[i] = FindPoint->second;
+                else
+                        TPS[i] = NULL;
+        }
+
+        // check lines
+        for (int i=0;i<3;i++)
+                if (TPS[i] != NULL)
+                        for (int j=i;j<3;j++)
+                                if (TPS[j] != NULL) {
+                                        FindLine = TPS[i]->lines.find(TPS[j]->node->nr);
+                                        if ((FindLine != TPS[i]->lines.end()) && (FindLine->second->TrianglesCount > 1)) {
+                                                *out << "WARNING: Line " << *FindLine->second << " already present with " << FindLine->second->TrianglesCount << " triangles attached." << endl;
+                                                *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
+                                                return false;
+                                        }
+                                }
+        *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
+        return true;
+};
+
+/** This recursive function finds a third point, to form a triangle with two given ones.
+ * Note that this function is for the starting triangle.
+ * The idea is as follows: A sphere with fixed radius is (almost) uniquely defined in space by three points
+ * that sit on its boundary. Hence, when two points are given and we look for the (next) third point, then
+ * the center of the sphere is still fixed up to a single parameter. The band of possible values
+ * describes a circle in 3D-space. The old center of the sphere for the current base triangle gives
+ * us the "null" on this circle, the new center of the candidate point will be some way along this
+ * circle. The shorter the way the better is the candidate. Note that the direction is clearly given
+ * by the normal vector of the base triangle that always points outwards by construction.
+ * Hence, we construct a Center of this circle which sits right in the middle of the current base line.
+ * We construct the normal vector that defines the plane this circle lies in, it is just in the
+ * direction of the baseline. And finally, we need the radius of the circle, which is given by the rest
+ * with respect to the length of the baseline and the sphere's fixed \a RADIUS.
+ * Note that there is one difficulty: The circumcircle is uniquely defined, but for the circumsphere's center
+ * there are two possibilities which becomes clear from the construction as seen below. Hence, we must check
+ * both.
+ * Note also that the acos() function is not unique on [0, 2.*M_PI). Hence, we need an additional check
+ * to decide for one of the two possible angles. Therefore we need a SearchDirection and to make this check
+ * sensible we need OldSphereCenter to be orthogonal to it. Either we construct SearchDirection orthogonal
+ * right away, or -- what we do here -- we rotate the relative sphere centers such that this orthogonality
+ * holds. Then, the normalized projection onto the SearchDirection is either +1 or -1 and thus states whether
+ * the angle is uniquely in either (0,M_PI] or [M_PI, 2.*M_PI).
+ * @param NormalVector normal direction of the base triangle (here the unit axis vector, \sa Find_starting_triangle())
+ * @param SearchDirection general direction where to search for the next point, relative to center of BaseLine
+ * @param OldSphereCenter center of sphere for base triangle, relative to center of BaseLine, giving null angle for the parameter circle
+ * @param BaseLine BoundaryLineSet with the current base line
+ * @param ThirdNode third atom to avoid in search
+ * @param OptCandidate candidate reference on return
+ * @param OptCandidateCenter candidate's sphere center on return
+ * @param ShortestAngle the current path length on this circle band for the current Opt_Candidate
+ * @param RADIUS radius of sphere
+ * @param *LC LinkedCell structure with neighbouring atoms
+ */
+void Find_third_point_for_Tesselation(Vector NormalVector, Vector SearchDirection, Vector OldSphereCenter, class BoundaryLineSet *BaseLine, atom *ThirdNode, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC)
+{
+        atom *Walker = NULL;
+        Vector CircleCenter;    // center of the circle, i.e. of the band of sphere's centers
+        Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+        Vector NewSphereCenter;  // center of the sphere defined by the two points of BaseLine and the one of Candidate, first possibility
+        Vector OtherNewSphereCenter;     // center of the sphere defined by the two points of BaseLine and the one of Candidate, second possibility
+        Vector NewNormalVector;  // normal vector of the Candidate's triangle
+        Vector helper;
+        LinkedAtoms *List = NULL;
+        double CircleRadius; // radius of this circle
+        double radius;
+        double alpha, Otheralpha; // angles (i.e. parameter for the circle).
+        double Nullalpha; // angle between OldSphereCenter and NormalVector of base triangle
+        int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+        atom *Candidate = NULL;
+
+        cout << Verbose(1) << "Begin of Find_third_point_for_Tesselation" << endl;
+
+        cout << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
+
+        // construct center of circle
+        CircleCenter.CopyVector(&(BaseLine->endpoints[0]->node->x));
+        CircleCenter.AddVector(&BaseLine->endpoints[1]->node->x);
+        CircleCenter.Scale(0.5);
+
+        // construct normal vector of circle
+        CirclePlaneNormal.CopyVector(&BaseLine->endpoints[0]->node->x);
+        CirclePlaneNormal.SubtractVector(&BaseLine->endpoints[1]->node->x);
+
+        // calculate squared radius of circle
+        radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+        if (radius/4. < RADIUS*RADIUS) {
+                CircleRadius = RADIUS*RADIUS - radius/4.;
+                CirclePlaneNormal.Normalize();
+                cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+
+                // test whether old center is on the band's plane
+                if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+                        cerr << "ERROR: Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
+                        OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+                }
+                radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
+                if (fabs(radius - CircleRadius) < HULLEPSILON) {
+
+                        // check SearchDirection
+                        cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+                        if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {      // rotated the wrong way!
+                                cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are not orthogonal!" << endl;
+                        }
+                        // get cell for the starting atom
+                        if (LC->SetIndexToVector(&CircleCenter)) {
+                                        for(int i=0;i<NDIM;i++) // store indices of this cell
+                                        N[i] = LC->n[i];
+                                cout << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+                        } else {
+                                cerr << "ERROR: Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
+                                return;
+                        }
+                        // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+                        cout << Verbose(2) << "LC Intervals:";
+                        for (int i=0;i<NDIM;i++) {
+                                Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+                                Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+                                cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+                        }
+                        cout << endl;
+                        for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+                                for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+                                        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+                                                List = LC->GetCurrentCell();
+                                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                                if (List != NULL) {
+                                                        for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+                                                                Candidate = (*Runner);
+
+                                                                // check for three unique points
+                                                                if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) && (Candidate != ThirdNode)) {
+                                                                        cout << Verbose(1) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->x << "." << endl;
+
+                                                                        // construct both new centers
+                                                                        GetCenterofCircumcircle(&NewSphereCenter, &(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x));
+                                                                        OtherNewSphereCenter.CopyVector(&NewSphereCenter);
+
+                                                                        if ((NewNormalVector.MakeNormalVector(&(BaseLine->endpoints[0]->node->x), &(BaseLine->endpoints[1]->node->x), &(Candidate->x))) && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)) {
+                                                                                helper.CopyVector(&NewNormalVector);
+                                                                                cout << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                                                                                radius = BaseLine->endpoints[0]->node->x.DistanceSquared(&NewSphereCenter);
+                                                                                if (radius < RADIUS*RADIUS) {
+                                                                                        helper.Scale(sqrt(RADIUS*RADIUS - radius));
+                                                                                        cout << Verbose(3) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << "." << endl;
+                                                                                        NewSphereCenter.AddVector(&helper);
+                                                                                        NewSphereCenter.SubtractVector(&CircleCenter);
+                                                                                        cout << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+
+                                                                                        helper.Scale(-1.); // OtherNewSphereCenter is created by the same vector just in the other direction
+                                                                                        OtherNewSphereCenter.AddVector(&helper);
+                                                                                        OtherNewSphereCenter.SubtractVector(&CircleCenter);
+                                                                                        cout << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+
+                                                                                        // check both possible centers
+                                                                                        alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                                                                                        Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
+                                                                                        alpha = min(alpha, Otheralpha);
+                                                                                        if (*ShortestAngle > alpha) {
+                                                                                                        OptCandidate = Candidate;
+                                                                                                        *ShortestAngle = alpha;
+                                                                                                        if (alpha != Otheralpha)
+                                                                                                                OptCandidateCenter->CopyVector(&NewSphereCenter);
+                                                                                                        else
+                                                                                                                OptCandidateCenter->CopyVector(&OtherNewSphereCenter);
+                                                                                                        cout << Verbose(1) << "ACCEPT: We have found a better candidate: " << *OptCandidate << " with " << alpha << " and circumsphere's center at " << *OptCandidateCenter << "." << endl;
+                                                                                        } else {
+                                                                                                if (OptCandidate != NULL)
+                                                                                                        cout << Verbose(1) << "REJECT: Old candidate: " << *OptCandidate << " is better than " << alpha << " with " << *ShortestAngle << "." << endl;
+                                                                                                else
+                                                                                                        cout << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                                                                                        }
+
+                                                                                } else {
+                                                                                        cout << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " is too far away: " << radius << "." << endl;
+                                                                                }
+                                                                        } else {
+                                                                                cout << Verbose(1) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                                                                        }
+                                                                } else {
+                                                                        if (ThirdNode != NULL)
+                                                                                cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
+                                                                        else
+                                                                                cout << Verbose(1) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                                                                }
+                                                        }
+                                                }
+                                        }
+                } else {
+                        cerr << Verbose(1) << "ERROR: The projected center of the old sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
+                }
+        } else {
+                if (ThirdNode != NULL)
+                        cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
+                else
+                        cout << Verbose(1) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
+        }
+
+        cout << Verbose(1) << "End of Find_third_point_for_Tesselation" << endl;
+};
+
+/** Finds the second point of starting triangle.
+ * \param *a first atom
+ * \param *Candidate pointer to candidate atom on return
+ * \param Oben vector indicating the outside
+ * \param Opt_Candidate reference to recommended candidate on return
+ * \param Storage[3] array storing angles and other candidate information
+ * \param RADIUS radius of virtual sphere
+ * \param *LC LinkedCell structure with neighbouring atoms
+ */
+void Find_second_point_for_Tesselation(atom* a, atom* Candidate, Vector Oben, atom*& Opt_Candidate, double Storage[3], double RADIUS, LinkedCell *LC)
+{
+        cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation" << endl;
+        int i;
+        Vector AngleCheck;
+        atom* Walker;
+        double norm = -1., angle;
+        LinkedAtoms *List = NULL;
+        int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+
+        if (LC->SetIndexToAtom(a)) {    // get cell for the starting atom
+                for(int i=0;i<NDIM;i++) // store indices of this cell
+                        N[i] = LC->n[i];
+        } else {
+                cerr << "ERROR: Atom " << *a << " is not found in cell " << LC->index << "." << endl;
+                return;
+        }
+        // then go through the current and all neighbouring cells and check the contained atoms for possible candidates
+        cout << Verbose(2) << "LC Intervals:";
+        for (int i=0;i<NDIM;i++) {
+                Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
+                Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+                cout << " [" << Nlower[i] << "," << Nupper[i] << "] ";
+        }
+        cout << endl;
+        for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+                for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+                        for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+                                List = LC->GetCurrentCell();
+                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                if (List != NULL) {
+                                        for (LinkedAtoms::iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+                                                Candidate = (*Runner);
+                                                                // check if we only have one unique point yet ...
+                                                                if (a != Candidate) {
+                        cout << Verbose(3) << "Current candidate is " << *Candidate << ": ";
+                        AngleCheck.CopyVector(&(Candidate->x));
+                        AngleCheck.SubtractVector(&(a->x));
+                        norm = AngleCheck.Norm();
+                                                        // second point shall have smallest angle with respect to Oben vector
+                                                        if (norm < RADIUS) {
+                                                                angle = AngleCheck.Angle(&Oben);
+                                                                if (angle < Storage[0]) {
+                                                                        //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
+                                                                        cout << "Is a better candidate with distance " << norm << " and " << angle << ".\n";
+                                                                        Opt_Candidate = Candidate;
+                                                                        Storage[0] = AngleCheck.Angle(&Oben);
+                                                                        //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                                                                } else {
+                                                                        cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
+                                                                }
+                                                        } else {
+                                                                cout << "Refused due to Radius " << norm << endl;
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+        cout << Verbose(2) << "End of Find_second_point_for_Tesselation" << endl;
+};
+
+/** Finds the starting triangle for find_non_convex_border().
+ * Looks at the outermost atom per axis, then Find_second_point_for_Tesselation()
+ * for the second and Find_next_suitable_point_via_Angle_of_Sphere() for the third
+ * point are called.
+ * \param RADIUS radius of virtual rolling sphere
+ * \param *LC LinkedCell structure with neighbouring atoms
+ */
+void Tesselation::Find_starting_triangle(ofstream *out, molecule *mol, const double RADIUS, LinkedCell *LC)
+{
+        cout << Verbose(1) << "Begin of Find_starting_triangle\n";
+        int i = 0;
+        LinkedAtoms *List = NULL;
+        atom* Walker;
+        atom* FirstPoint;
+        atom* SecondPoint;
+        atom* MaxAtom[NDIM];
+        double max_coordinate[NDIM];
+        Vector Oben;
+        Vector helper;
+        Vector Chord;
+        Vector SearchDirection;
+        Vector OptCandidateCenter;
+
+        Oben.Zero();
+
+        for (i = 0; i < 3; i++) {
+                MaxAtom[i] = NULL;
+                max_coordinate[i] = -1;
+        }
+
+        // 1. searching topmost atom with respect to each axis
+        for (int i=0;i<NDIM;i++) { // each axis
+                LC->n[i] = LC->N[i]-1; // current axis is topmost cell
+                for (LC->n[(i+1)%NDIM]=0;LC->n[(i+1)%NDIM]<LC->N[(i+1)%NDIM];LC->n[(i+1)%NDIM]++)
+                        for (LC->n[(i+2)%NDIM]=0;LC->n[(i+2)%NDIM]<LC->N[(i+2)%NDIM];LC->n[(i+2)%NDIM]++) {
+                                List = LC->GetCurrentCell();
+                                //cout << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+                                if (List != NULL) {
+                                        for (LinkedAtoms::iterator Runner = List->begin();Runner != List->end();Runner++) {
+                                                cout << Verbose(2) << "Current atom is " << *(*Runner) << "." << endl;
+                                                if ((*Runner)->x.x[i] > max_coordinate[i]) {
+                                                        max_coordinate[i] = (*Runner)->x.x[i];
+                                                        MaxAtom[i] = (*Runner);
+                                                }
+                                        }
+                                } else {
+                                        cerr << "ERROR: The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl;
+                                }
+                        }
+        }
+
+        cout << Verbose(2) << "Found maximum coordinates: ";
+        for (int i=0;i<NDIM;i++)
+                cout << i << ": " << *MaxAtom[i] << "\t";
+        cout << endl;
+        const int k = 1;                // arbitrary choice
+        Oben.x[k] = 1.;
+        FirstPoint = MaxAtom[k];
+        cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << "." << endl;
+
+        // add first point
+        AddTrianglePoint(FirstPoint, 0);
+
+        double ShortestAngle;
+        atom* Opt_Candidate = NULL;
+        ShortestAngle = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
+
+        Find_second_point_for_Tesselation(FirstPoint, NULL, Oben, Opt_Candidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+        SecondPoint = Opt_Candidate;
+        cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
+
+        // add second point and first baseline
+        AddTrianglePoint(SecondPoint, 1);
+        AddTriangleLine(TPS[0], TPS[1], 0);
+
+        helper.CopyVector(&(FirstPoint->x));
+        helper.SubtractVector(&(SecondPoint->x));
+        helper.Normalize();
+        Oben.ProjectOntoPlane(&helper);
+        Oben.Normalize();
+        helper.VectorProduct(&Oben);
+        ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+
+        Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
+        Chord.SubtractVector(&(SecondPoint->x));
+        double radius = Chord.ScalarProduct(&Chord);
+        double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+        helper.CopyVector(&Oben);
+        helper.Scale(CircleRadius);
+        // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
+
+        cout << Verbose(2) << "Looking for third point candidates \n";
+        // look in one direction of baseline for initial candidate
+        Opt_Candidate = NULL;
+        SearchDirection.MakeNormalVector(&Chord, &Oben);        // whether we look "left" first or "right" first is not important ...
+
+        cout << Verbose(1) << "Looking for third point candidates ...\n";
+        Find_third_point_for_Tesselation(Oben, SearchDirection, helper, BLS[0], NULL, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+        cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
+
+        // add third point
+        AddTrianglePoint(Opt_Candidate, 2);
+
+        // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
+
+        // Finally, we only have to add the found further lines
+        AddTriangleLine(TPS[1], TPS[2], 1);
+        AddTriangleLine(TPS[0], TPS[2], 2);
+        // ... and triangles to the Maps of the Tesselation class
+        BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+        AddTriangleToLines();
+        // ... and calculate its normal vector (with correct orientation)
+        OptCandidateCenter.Scale(-1.);
+        cout << Verbose(2) << "Oben is currently " << OptCandidateCenter << "." << endl;
+        BTS->GetNormalVector(OptCandidateCenter);
+        cout << Verbose(0) << "==> The found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate << " with normal vector " << BTS->NormalVector << ".\n";
+        cout << Verbose(2) << "Projection is " << BTS->NormalVector.Projection(&Oben) << "." << endl;
+        cout << Verbose(1) << "End of Find_starting_triangle\n";
+};
 
 /** This function finds a triangle to a line, adjacent to an existing one.
- * @param out   output stream for debugging
- * @param mol molecule structure with all atoms and bonds
+ * @param out output stream for debugging
+ * @param *mol molecule with Atom's and Bond's
  * @param Line current baseline to search from
  * @param T current triangle which \a Line is edge of
  * @param RADIUS radius of the rolling ball
  * @param N number of found triangles
+ * @param *filename filename base for intermediate envelopes
+ * @param *LC LinkedCell structure with neighbouring atoms
  */
-void Tesselation::Find_next_suitable_triangle(ofstream *out,
-    molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
-    const double& RADIUS, int N, const char *tempbasename)
-{
-  cout << Verbose(1) << "Looking for next suitable triangle \n";
-  Vector direction1;
-  Vector helper;
-  Vector Chord;
-  ofstream *tempstream = NULL;
-  char NumberName[255];
-  double tmp;
-  //atom* Walker;
-  atom* OldThirdPoint;
-
-  double Storage[3];
-  Storage[0] = -2.; // This direction is either +1 or -1 one, so any result will take precedence over initial values
-  Storage[1] = -2.; // This is also lower then any value produced by an eligible atom, which are all positive
-  Storage[2] = 9999999.;
-  atom* Opt_Candidate = NULL;
-  Vector Opt_Mittelpunkt;
-
-  cout << Verbose(1) << "Constructing helpful vectors ... " << endl;
-  helper.CopyVector(&(Line.endpoints[0]->node->x));
-  for (int i = 0; i < 3; i++)
-    {
-      if (T.endpoints[i]->node->nr != Line.endpoints[0]->node->nr
-          && T.endpoints[i]->node->nr != Line.endpoints[1]->node->nr)
-        {
-          OldThirdPoint = T.endpoints[i]->node;
-          helper.SubtractVector(&T.endpoints[i]->node->x);
-          break;
-        }
-    }
-
-  direction1.CopyVector(&Line.endpoints[0]->node->x);
-  direction1.SubtractVector(&Line.endpoints[1]->node->x);
-  direction1.VectorProduct(&(T.NormalVector));
-
-  if (direction1.ScalarProduct(&helper) < 0)
-    {
-      direction1.Scale(-1);
-    }
-
-  Chord.CopyVector(&(Line.endpoints[0]->node->x)); // bring into calling function
-  Chord.SubtractVector(&(Line.endpoints[1]->node->x));
-
-
-    Vector Umkreismittelpunkt, a, b, c;
-    double alpha, beta, gamma;
-    a.CopyVector(&(T.endpoints[0]->node->x));
-    b.CopyVector(&(T.endpoints[1]->node->x));
-    c.CopyVector(&(T.endpoints[2]->node->x));
-    a.SubtractVector(&(T.endpoints[1]->node->x));
-    b.SubtractVector(&(T.endpoints[2]->node->x));
-    c.SubtractVector(&(T.endpoints[0]->node->x));
-
-    alpha = M_PI - a.Angle(&c);
-    beta = M_PI - b.Angle(&a);
-    gamma = M_PI - c.Angle(&b);
-
-    Umkreismittelpunkt = (T.endpoints[0]->node->x) * sin(2.*alpha) + T.endpoints[1]->node->x * sin(2.*beta) + (T.endpoints[2]->node->x) * sin(2.*gamma) ;
-    //cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-    Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-    cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-    cout << " We look over line " << Line << " in direction " << direction1.x[0] << " " << direction1.x[1] << " " << direction1.x[2] << " " << endl;
-    cout << " Old Normal is " <<  (T.NormalVector.x)[0] << " " << T.NormalVector.x[1] << " " << (T.NormalVector.x)[2] << " " << endl;
-
-
-  cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
-
-  Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint,
-      Line.endpoints[0]->node, Line.endpoints[1]->node, 0, &Chord, &direction1,
-      &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-  Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint,
-      Line.endpoints[1]->node, Line.endpoints[0]->node, 0, &Chord, &direction1,
-      &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-
-
-      cout << "Letzter Winkel bei " << TrianglesOnBoundaryCount << " Winkel ist " << Storage[2] << endl;
-
-  if ((TrianglesOnBoundaryCount % 10) == 0) {
-    sprintf(NumberName, "-%d", TriangleFilesWritten);
-    if (DoTecplotOutput) {
-      string NameofTempFile(tempbasename);
-      NameofTempFile.append(NumberName);
-      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);
-      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);
-      tempstream->close();
-      tempstream->flush();
-      delete(tempstream);
-    }
-    if (DoTecplotOutput || DoRaster3DOutput)
-      TriangleFilesWritten++;
-  }
-
-      // Konstruiere nun neues Dreieck am Ende der Liste der Dreiecke
-
-  cout << " Optimal candidate is " << *Opt_Candidate << endl;
-
-  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();
-  cout << "New triangle with " << *BTS << endl;
-  cout << "We have "<< TrianglesOnBoundaryCount << endl;
-  cout << Verbose(1) << "Constructing normal vector for this triangle ... " << endl;
-
-  BTS->GetNormalVector(BTS->NormalVector);
-
-  if ((BTS->NormalVector.ScalarProduct(&(T.NormalVector)) < 0 && Storage[0] > 0)  ||
-      (BTS->NormalVector.ScalarProduct(&(T.NormalVector)) > 0 && Storage[0] < 0) ||
-      (fabs(Storage[0]) < MYEPSILON && Storage[1]*BTS->NormalVector.ScalarProduct(&direction1) < 0) )
-
-    {
-      BTS->NormalVector.Scale(-1);
-    };
-
-}
-;
-
-void Find_second_point_for_Tesselation(atom* a, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector Oben, atom*& Opt_Candidate, double Storage[3],
-    molecule* mol, double RADIUS)
-{
-  cout << Verbose(1)
-      << "Looking for second point of starting triangle, recursive level "
-      << RecursionLevel << endl;;
-  int i;
-  Vector AngleCheck;
-  atom* Walker;
-  double norm = -1.;
-
-  // check if we only have one unique point yet ...
-  if (a != 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)
-        {
-          if (AngleCheck.Angle(&Oben) < Storage[0])
-            {
-              //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[2]);
-              cout << "Next better candidate is " << *Candidate
-                  << " with distance " << norm << ".\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 << Verbose(1) << "Supposedly looses to a better candidate "
-                  << *Opt_Candidate << endl;
-            }
-        }
-      else
-        {
-          cout << Verbose(1) << *Candidate << " refused due to Radius " << norm
-              << endl;
-        }
-    }
-
-  // if not recursed to deeply, look at all its bonds
-  if (RecursionLevel < 7)
-    {
-      for (i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++)
-        {
-          Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(
-              Candidate);
-          if (Walker == Parent) // don't go back along the bond we came from
-            continue;
-          else
-            Find_second_point_for_Tesselation(a, Walker, Candidate,
-                RecursionLevel + 1, Oben, Opt_Candidate, Storage, mol, RADIUS);
-        };
-    };
-}
-;
-
-void Tesselation::Find_starting_triangle(molecule* mol, const double RADIUS)
-{
-  cout << Verbose(1) << "Looking for starting triangle \n";
-  int i = 0;
-  atom* Walker;
-  atom* FirstPoint;
-  atom* SecondPoint;
-  atom* max_index[3];
-  double max_coordinate[3];
-  Vector Oben;
-  Vector helper;
-  Vector Chord;
-  Vector CenterOfFirstLine;
-
-  Oben.Zero();
-
-  for (i = 0; i < 3; i++)
-    {
-      max_index[i] = NULL;
-      max_coordinate[i] = -1;
-    }
-  cout << Verbose(1) << "Molecule mol is there and has " << mol->AtomCount
-      << " Atoms \n";
-
-  // 1. searching topmost atom with respect to each axis
-  Walker = mol->start;
-  while (Walker->next != mol->end)
-    {
-      Walker = Walker->next;
-      for (i = 0; i < 3; i++)
-        {
-          if (Walker->x.x[i] > max_coordinate[i])
-            {
-              max_coordinate[i] = Walker->x.x[i];
-              max_index[i] = Walker;
-            }
-        }
-    }
-
-  cout << Verbose(1) << "Found maximum coordinates. " << endl;
-  //Koennen dies fuer alle Richtungen, legen hier erstmal Richtung auf k=0
-  const int k = 1;
-  Oben.x[k] = 1.;
-  FirstPoint = max_index[k];
-
-  cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << ": "
-      << FirstPoint->x.x[0] << endl;
-  double Storage[3];
-  atom* Opt_Candidate = NULL;
-  Storage[0] = 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.
-  Storage[1] = 999999.; // This will be an angle looking for the third point.
-  Storage[2] = 999999.;
-  cout << Verbose(1) << "Number of Bonds: "
-      << mol->NumberOfBondsPerAtom[FirstPoint->nr] << endl;
-
-  Find_second_point_for_Tesselation(FirstPoint, FirstPoint, FirstPoint, 0,
-      Oben, Opt_Candidate, Storage, mol, RADIUS); // 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 << ".\n";
-
-  helper.CopyVector(&(FirstPoint->x));
-  helper.SubtractVector(&(SecondPoint->x));
-  helper.Normalize();
-  Oben.ProjectOntoPlane(&helper);
-  Oben.Normalize();
-  helper.VectorProduct(&Oben);
-  Storage[0] = -2.; // This will indicate the quadrant.
-  Storage[1] = 9999999.; // This will be an angle looking for the third point.
-  Storage[2] = 9999999.;
-
-  Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
-  Chord.SubtractVector(&(SecondPoint->x));
-  // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
-
-  cout << Verbose(1) << "Looking for third point candidates \n";
-  cout << Verbose(1) << " In direction " << helper.x[0] << " " << helper.x[1] << " " << helper.x[2] << " " << endl;
-  // look in one direction of baseline for initial candidate
-  Opt_Candidate = NULL;
-  CenterOfFirstLine.CopyVector(&Chord);
-  CenterOfFirstLine.Scale(0.5);
-  CenterOfFirstLine.AddVector(&(SecondPoint->x));
-
-  Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, SecondPoint, FirstPoint, 0,
-      &Chord, &helper, &Oben, CenterOfFirstLine,  Opt_Candidate, Storage, RADIUS, mol);
-  // look in other direction of baseline for possible better candidate
-  Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, FirstPoint, SecondPoint, 0,
-      &Chord, &helper, &Oben, CenterOfFirstLine, Opt_Candidate, Storage, RADIUS, mol);
-  cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
-
-  // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
-
-  cout << Verbose(1) << "The found starting triangle consists of "
-      << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate
-      << "." << endl;
-
-  // Finally, we only have to add the found points
-  AddTrianglePoint(FirstPoint, 0);
-  AddTrianglePoint(SecondPoint, 1);
-  AddTrianglePoint(Opt_Candidate, 2);
-  // ... and respective lines
-  AddTriangleLine(TPS[0], TPS[1], 0);
-  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)
-  Oben.Scale(-1.);
-  BTS->GetNormalVector(Oben);
-}
-;
-
-void Find_non_convex_border(ofstream *out, const char *filename, molecule* mol)
-{
-  int N = 0;
-  struct Tesselation *Tess = new Tesselation;
-  cout << Verbose(1) << "Entering search for non convex hull. " << endl;
-  cout << flush;
-  const double RADIUS = 6.;
-  LineMap::iterator baseline;
-  cout << 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
-
-  if ((mol->first->next == mol->last) || (mol->last->previous == mol->first))
-    mol->CreateAdjacencyList((ofstream *)&cout, 1.6, true);
-
-  Tess->Find_starting_triangle(mol, RADIUS);
-
-  baseline = Tess->LinesOnBoundary.begin();
-  while (baseline != Tess->LinesOnBoundary.end())
-    {
-      if (baseline->second->TrianglesCount == 1)
-        {
-          cout << Verbose(1) << "Begin of Tesselation ... " << endl;
-          Tess->Find_next_suitable_triangle(out, mol,
-              *(baseline->second),
-              *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename); //the line is there, so there is a triangle, but only one.
-          flag = true;
-          cout << Verbose(1) << "End of Tesselation ... " << endl;
-        }
-      else
-        {
-          cout << Verbose(1) << "There is a line with "
-              << baseline->second->TrianglesCount << " triangles adjacent"
-              << endl;
-        }
-      N++;
-      baseline++;
-    }
-  cout << Verbose(1) << "Writing final tecplot file\n";
-  if (DoTecplotOutput) {
-    string Name(filename);
-    Name.append(TecplotSuffix);
-    ofstream tecplot(Name.c_str(), ios::trunc);
-    write_tecplot_file(out, &tecplot, Tess, mol, -1);
-    tecplot.close();
-  }
-  if (DoRaster3DOutput) {
-    string Name(filename);
-    Name.append(Raster3DSuffix);
-    ofstream raster(Name.c_str(), ios::trunc);
-    write_raster3d_file(out, &raster, Tess, mol);
-    raster.close();
-  }
-}
-;
+bool Tesselation::Find_next_suitable_triangle(ofstream *out,
+                molecule *mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
+                const double& RADIUS, int N, const char *tempbasename, LinkedCell *LC)
+{
+        cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
+        ofstream *tempstream = NULL;
+        char NumberName[255];
+        double tmp;
+
+        atom* Opt_Candidate = NULL;
+        Vector OptCandidateCenter;
+
+        Vector CircleCenter;
+        Vector CirclePlaneNormal;
+        Vector OldSphereCenter;
+        Vector SearchDirection;
+        Vector helper;
+        atom *ThirdNode = NULL;
+        double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+        double radius, CircleRadius;
+
+        cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
+        for (int i=0;i<3;i++)
+                if ((T.endpoints[i]->node != Line.endpoints[0]->node) && (T.endpoints[i]->node != Line.endpoints[1]->node))
+                        ThirdNode = T.endpoints[i]->node;
+
+        // construct center of circle
+        CircleCenter.CopyVector(&Line.endpoints[0]->node->x);
+        CircleCenter.AddVector(&Line.endpoints[1]->node->x);
+        CircleCenter.Scale(0.5);
+
+        // construct normal vector of circle
+        CirclePlaneNormal.CopyVector(&Line.endpoints[0]->node->x);
+        CirclePlaneNormal.SubtractVector(&Line.endpoints[1]->node->x);
+
+        // calculate squared radius of circle
+        radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+        if (radius/4. < RADIUS*RADIUS) {
+                CircleRadius = RADIUS*RADIUS - radius/4.;
+                CirclePlaneNormal.Normalize();
+                cout << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+
+                // construct old center
+                GetCenterofCircumcircle(&OldSphereCenter, &(T.endpoints[0]->node->x), &(T.endpoints[1]->node->x), &(T.endpoints[2]->node->x));
+                helper.CopyVector(&T.NormalVector);     // normal vector ensures that this is correct center of the two possible ones
+                radius = Line.endpoints[0]->node->x.DistanceSquared(&OldSphereCenter);
+                helper.Scale(sqrt(RADIUS*RADIUS - radius));
+                OldSphereCenter.AddVector(&helper);
+                OldSphereCenter.SubtractVector(&CircleCenter);
+                cout << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+
+                // construct SearchDirection
+                SearchDirection.MakeNormalVector(&T.NormalVector, &CirclePlaneNormal);
+                helper.CopyVector(&Line.endpoints[0]->node->x);
+                helper.SubtractVector(&ThirdNode->x);
+                if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)      // ohoh, SearchDirection points inwards!
+                        SearchDirection.Scale(-1.);
+                SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+                SearchDirection.Normalize();
+                cout << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+                if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {      // rotated the wrong way!
+                        cerr << "ERROR: SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+                }
+
+                // add third point
+                cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
+                Find_third_point_for_Tesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, Opt_Candidate, &OptCandidateCenter, &ShortestAngle, RADIUS, LC);
+
+        } else {
+                cout << Verbose(1) << "Circumcircle for base line " << Line << " and base triangle " << T << " is too big!" << endl;
+        }
+
+        if (Opt_Candidate == NULL) {
+                cerr << "WARNING: Could not find a suitable candidate." << endl;
+                return false;
+        }
+        cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << " with circumsphere's center at " << OptCandidateCenter << "." << endl;
+
+        // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+        atom *AtomCandidates[3];
+        AtomCandidates[0] = Opt_Candidate;
+        AtomCandidates[1] = Line.endpoints[0]->node;
+        AtomCandidates[2] = Line.endpoints[1]->node;
+        bool flag = CheckPresenceOfTriangle(out, AtomCandidates);
+
+        if (flag) { // if so, add
+                AddTrianglePoint(Opt_Candidate, 0);
+                AddTrianglePoint(Line.endpoints[0]->node, 1);
+                AddTrianglePoint(Line.endpoints[1]->node, 2);
+
+                AddTriangleLine(TPS[0], TPS[1], 0);
+                AddTriangleLine(TPS[0], TPS[2], 1);
+                AddTriangleLine(TPS[1], TPS[2], 2);
+
+                BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+                AddTriangleToLines();
+
+                OptCandidateCenter.Scale(-1.);
+                BTS->GetNormalVector(OptCandidateCenter);
+                OptCandidateCenter.Scale(-1.);
+
+                cout << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
+                cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << Line << "." << endl;
+        } else { // else, yell and do nothing
+                cout << Verbose(1) << "This triangle consisting of ";
+                cout << *Opt_Candidate << ", ";
+                cout << *Line.endpoints[0]->node << " and ";
+                cout << *Line.endpoints[1]->node << " ";
+                cout << "is invalid!" << endl;
+                return false;
+        }
+
+        if (flag && (DoSingleStepOutput && (TrianglesOnBoundaryCount % 10 == 0))) { // if we have a new triangle and want to output each new triangle configuration
+                sprintf(NumberName, "-%04d-%s_%s_%s", TriangleFilesWritten, BTS->endpoints[0]->node->Name, BTS->endpoints[1]->node->Name, BTS->endpoints[2]->node->Name);
+                if (DoTecplotOutput) {
+                        string NameofTempFile(tempbasename);
+                        NameofTempFile.append(NumberName);
+                        for(size_t npos = NameofTempFile.find_first_of(' '); npos != -1; npos = NameofTempFile.find(' ', npos))
+                                NameofTempFile.erase(npos, 1);
+                        NameofTempFile.append(TecplotSuffix);
+                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+                        write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
+                        tempstream->close();
+                        tempstream->flush();
+                        delete(tempstream);
+                }
+
+                if (DoRaster3DOutput) {
+                        string NameofTempFile(tempbasename);
+                        NameofTempFile.append(NumberName);
+                        for(size_t npos = NameofTempFile.find_first_of(' '); npos != -1; npos = NameofTempFile.find(' ', npos))
+                                NameofTempFile.erase(npos, 1);
+                        NameofTempFile.append(Raster3DSuffix);
+                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
+                        write_raster3d_file(out, tempstream, this, mol);
+                        // include the current position of the virtual sphere in the temporary raster3d file
+                        // make the circumsphere's center absolute again
+                        helper.CopyVector(&Line.endpoints[0]->node->x);
+                        helper.AddVector(&Line.endpoints[1]->node->x);
+                        helper.Scale(0.5);
+                        OptCandidateCenter.AddVector(&helper);
+                        Vector *center = mol->DetermineCenterOfAll(out);
+                        OptCandidateCenter.AddVector(center);
+                        delete(center);
+                        // and add to file plus translucency object
+                        *tempstream << "# current virtual sphere\n";
+                        *tempstream << "8\n     25.0            0.6              -1.0 -1.0 -1.0          0.2                            0 0 0 0\n";
+                        *tempstream << "2\n     " << OptCandidateCenter.x[0] << " " << OptCandidateCenter.x[1] << " " << OptCandidateCenter.x[2] << "\t" << RADIUS << "\t1 0 0\n";
+                        *tempstream << "9\n     terminating special property\n";
+                        tempstream->close();
+                        tempstream->flush();
+                        delete(tempstream);
+                }
+                if (DoTecplotOutput || DoRaster3DOutput)
+                        TriangleFilesWritten++;
+        }
+
+        cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
+        return true;
+};
+
+/** Tesselates the non convex boundary by rolling a virtual sphere along the surface of the molecule.
+ * \param *out output stream for debugging
+ * \param *mol molecule structure with Atom's and Bond's
+ * \param *Tess Tesselation filled with points, lines and triangles on boundary on return
+ * \param *LCList linked cell list of all atoms
+ * \param *filename filename prefix for output of vertex data
+ * \para RADIUS radius of the virtual sphere
+ */
+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";
+};
+

src/boundary.hpp

@@ -17 +17 @@
 
 #include <gsl/gsl_poly.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_multimin.h>
+#include <gsl/gsl_permutation.h>
 
+#include "linkedcell.hpp"
 #include "molecules.hpp"
 
 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(molecule* mol, const double RADIUS);
-    void Find_next_suitable_triangle(ofstream *out, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *tempbasename);
+                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;
 };
 
@@ -107 +114 @@
 
 
-double VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
+double VolumeOfConvexEnvelope(ofstream *out, const char *filename, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
 double * GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem);
 void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity);
-void Find_next_suitable_point(atom a, atom b, atom Candidate, int n, Vector *d1, Vector *d2, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule *mol, bool problem);
-void Find_non_convex_border(ofstream *out, const char *filename, molecule* mol);
+void Find_non_convex_border(ofstream *out, molecule* mol, class Tesselation *T, class LinkedCell *LCList, const char *tempbasename, const double RADIUS);
+void Find_next_suitable_point(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
 
 

src/builder.cpp

@@ -15 +15 @@
  * \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.
  *
  */
@@ -50 +50 @@
 using namespace std;
 
+#include "boundary.hpp"
+#include "ellipsoid.hpp"
 #include "helpers.hpp"
 #include "molecules.hpp"
-#include "boundary.hpp"
 
 /********************************************** Submenu routine **************************************/
@@ -62 +63 @@
 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) {
-      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 = new atom;
-        valid = true;
-        do {
-          if (!valid) cout << Verbose(0) << "Resulting position out of cell." << endl;
-          cout << Verbose(0) << "Enter reference coordinates." << endl;
-          x.AskPosition(mol->cell_size, true);
-          cout << Verbose(0) << "Enter relative coordinates." << endl;
-          first->x.AskPosition(mol->cell_size, false);
-          first->x.AddVector((const Vector *)&x);
-          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 = new atom;
-        valid = true;
-        do {
-          if (!valid) cout << Verbose(0) << "Resulting position out of cell." << endl;
-          second = mol->AskAtom("Enter atom number: ");
-          cout << Verbose(0) << "Enter relative coordinates." << endl;
-          first->x.AskPosition(mol->cell_size, false);
-          for (int i=NDIM;i--;) {
-            first->x.x[i] += second->x.x[i];
-          }
-        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
-        first->type = periode->AskElement();  // give type
-        mol->AddAtom(first);  // add to molecule
-        break;
-
-      case 'd': // two atoms, two angles and a distance
-        first = new atom;
-        valid = true;
-        do {
-          if (!valid) {
-            cout << Verbose(0) << "Resulting coordinates out of cell - ";
-            first->x.Output((ofstream *)&cout);
-            cout << Verbose(0) << endl;
-          }
-          cout << Verbose(0) << "First, we need two atoms, the first atom is the central, while the second is the outer one." << endl;
-          second = mol->AskAtom("Enter central atom: ");
-          third = mol->AskAtom("Enter second atom (specifying the axis for first angle): ");
-          fourth = mol->AskAtom("Enter third atom (specifying a plane for second angle): ");
-          a = ask_value("Enter distance between central (first) and new atom: ");
-          b = ask_value("Enter angle between new, first and second atom (degrees): ");
-          b *= M_PI/180.;
-          bound(&b, 0., 2.*M_PI);
-          c = ask_value("Enter second angle between new and normal vector of plane defined by first, second and third atom (degrees): ");
-          c *= M_PI/180.;
-          bound(&c, -M_PI, M_PI);
-          cout << Verbose(0) << "radius: " << a << "\t phi: " << b*180./M_PI << "\t theta: " << c*180./M_PI << endl;
+        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) {
+                        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 = new atom;
+                                valid = true;
+                                do {
+                                        if (!valid) cout << Verbose(0) << "Resulting position out of cell." << endl;
+                                        cout << Verbose(0) << "Enter reference coordinates." << endl;
+                                        x.AskPosition(mol->cell_size, true);
+                                        cout << Verbose(0) << "Enter relative coordinates." << endl;
+                                        first->x.AskPosition(mol->cell_size, false);
+                                        first->x.AddVector((const Vector *)&x);
+                                        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 = new atom;
+                                valid = true;
+                                do {
+                                        if (!valid) cout << Verbose(0) << "Resulting position out of cell." << endl;
+                                        second = mol->AskAtom("Enter atom number: ");
+                                        cout << Verbose(0) << "Enter relative coordinates." << endl;
+                                        first->x.AskPosition(mol->cell_size, false);
+                                        for (int i=NDIM;i--;) {
+                                                first->x.x[i] += second->x.x[i];
+                                        }
+                                } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
+                                first->type = periode->AskElement();    // give type
+                                mol->AddAtom(first);    // add to molecule
+                                break;
+
+                        case 'd': // two atoms, two angles and a distance
+                                first = new atom;
+                                valid = true;
+                                do {
+                                        if (!valid) {
+                                                cout << Verbose(0) << "Resulting coordinates out of cell - ";
+                                                first->x.Output((ofstream *)&cout);
+                                                cout << Verbose(0) << endl;
+                                        }
+                                        cout << Verbose(0) << "First, we need two atoms, the first atom is the central, while the second is the outer one." << endl;
+                                        second = mol->AskAtom("Enter central atom: ");
+                                        third = mol->AskAtom("Enter second atom (specifying the axis for first angle): ");
+                                        fourth = mol->AskAtom("Enter third atom (specifying a plane for second angle): ");
+                                        a = ask_value("Enter distance between central (first) and new atom: ");
+                                        b = ask_value("Enter angle between new, first and second atom (degrees): ");
+                                        b *= M_PI/180.;
+                                        bound(&b, 0., 2.*M_PI);
+                                        c = ask_value("Enter second angle between new and normal vector of plane defined by first, second and third atom (degrees): ");
+                                        c *= M_PI/180.;
+                                        bound(&c, -M_PI, M_PI);
+                                        cout << Verbose(0) << "radius: " << a << "\t phi: " << b*180./M_PI << "\t theta: " << c*180./M_PI << endl;
 /*
-          second->Output(1,1,(ofstream *)&cout);
-          third->Output(1,2,(ofstream *)&cout);
-          fourth->Output(1,3,(ofstream *)&cout);
-          n.MakeNormalvector((const vector *)&second->x, (const vector *)&third->x, (const vector *)&fourth->x);
-          x.Copyvector(&second->x);
-          x.SubtractVector(&third->x);
-          x.Copyvector(&fourth->x);
-          x.SubtractVector(&third->x);
-
-          if (!z.SolveSystem(&x,&y,&n, b, c, a)) {
-            cout << Verbose(0) << "Failure solving self-dependent linear system!" << endl;
-            continue;
-          }
-          cout << Verbose(0) << "resulting relative coordinates: ";
-          z.Output((ofstream *)&cout);
-          cout << Verbose(0) << endl;
-          */
-          // calc axis vector
-          x.CopyVector(&second->x);
-          x.SubtractVector(&third->x);
-          x.Normalize();
-          cout << "x: ",
-          x.Output((ofstream *)&cout);
-          cout << endl;
-          z.MakeNormalVector(&second->x,&third->x,&fourth->x);
-          cout << "z: ",
-          z.Output((ofstream *)&cout);
-          cout << endl;
-          y.MakeNormalVector(&x,&z);
-          cout << "y: ",
-          y.Output((ofstream *)&cout);
-          cout << endl;
-
-          // rotate vector around first angle
-          first->x.CopyVector(&x);
-          first->x.RotateVector(&z,b - M_PI);
-          cout << "Rotated vector: ",
-          first->x.Output((ofstream *)&cout);
-          cout << endl;
-          // remove the projection onto the rotation plane of the second angle
-          n.CopyVector(&y);
-          n.Scale(first->x.Projection(&y));
-          cout << "N1: ",
-          n.Output((ofstream *)&cout);
-          cout << endl;
-          first->x.SubtractVector(&n);
-          cout << "Subtracted vector: ",
-          first->x.Output((ofstream *)&cout);
-          cout << endl;
-          n.CopyVector(&z);
-          n.Scale(first->x.Projection(&z));
-          cout << "N2: ",
-          n.Output((ofstream *)&cout);
-          cout << endl;
-          first->x.SubtractVector(&n);
-          cout << "2nd subtracted vector: ",
-          first->x.Output((ofstream *)&cout);
-          cout << endl;
-
-          // rotate another vector around second angle
-          n.CopyVector(&y);
-          n.RotateVector(&x,c - M_PI);
-          cout << "2nd Rotated vector: ",
-          n.Output((ofstream *)&cout);
-          cout << endl;
-
-          // add the two linear independent vectors
-          first->x.AddVector(&n);
-          first->x.Normalize();
-          first->x.Scale(a);
-          first->x.AddVector(&second->x);
-
-          cout << Verbose(0) << "resulting coordinates: ";
-          first->x.Output((ofstream *)&cout);
-          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 = new atom;
-        atoms = new (Vector*[128]);
-        valid = true;
-        for(int i=128;i--;)
-          atoms[i] = NULL;
-        int i=0, j=0;
-        cout << Verbose(0) << "Now we need at least three molecules.\n";
-        do {
-          cout << Verbose(0) << "Enter " << i+1 << "th atom: ";
-          cin >> j;
-          if (j != -1) {
-            second = mol->FindAtom(j);
-            atoms[i++] = &(second->x);
-          }
-        } while ((j != -1) && (i<128));
-        if (i >= 2) {
-          first->x.LSQdistance(atoms, i);
-
-          first->x.Output((ofstream *)&cout);
-          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;
-  };
+                                        second->Output(1,1,(ofstream *)&cout);
+                                        third->Output(1,2,(ofstream *)&cout);
+                                        fourth->Output(1,3,(ofstream *)&cout);
+                                        n.MakeNormalvector((const vector *)&second->x, (const vector *)&third->x, (const vector *)&fourth->x);
+                                        x.Copyvector(&second->x);
+                                        x.SubtractVector(&third->x);
+                                        x.Copyvector(&fourth->x);
+                                        x.SubtractVector(&third->x);
+
+                                        if (!z.SolveSystem(&x,&y,&n, b, c, a)) {
+                                                cout << Verbose(0) << "Failure solving self-dependent linear system!" << endl;
+                                                continue;
+                                        }
+                                        cout << Verbose(0) << "resulting relative coordinates: ";
+                                        z.Output((ofstream *)&cout);
+                                        cout << Verbose(0) << endl;
+                                        */
+                                        // calc axis vector
+                                        x.CopyVector(&second->x);
+                                        x.SubtractVector(&third->x);
+                                        x.Normalize();
+                                        cout << "x: ",
+                                        x.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        z.MakeNormalVector(&second->x,&third->x,&fourth->x);
+                                        cout << "z: ",
+                                        z.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        y.MakeNormalVector(&x,&z);
+                                        cout << "y: ",
+                                        y.Output((ofstream *)&cout);
+                                        cout << endl;
+
+                                        // rotate vector around first angle
+                                        first->x.CopyVector(&x);
+                                        first->x.RotateVector(&z,b - M_PI);
+                                        cout << "Rotated vector: ",
+                                        first->x.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        // remove the projection onto the rotation plane of the second angle
+                                        n.CopyVector(&y);
+                                        n.Scale(first->x.Projection(&y));
+                                        cout << "N1: ",
+                                        n.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        first->x.SubtractVector(&n);
+                                        cout << "Subtracted vector: ",
+                                        first->x.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        n.CopyVector(&z);
+                                        n.Scale(first->x.Projection(&z));
+                                        cout << "N2: ",
+                                        n.Output((ofstream *)&cout);
+                                        cout << endl;
+                                        first->x.SubtractVector(&n);
+                                        cout << "2nd subtracted vector: ",
+                                        first->x.Output((ofstream *)&cout);
+                                        cout << endl;
+
+                                        // rotate another vector around second angle
+                                        n.CopyVector(&y);
+                                        n.RotateVector(&x,c - M_PI);
+                                        cout << "2nd Rotated vector: ",
+                                        n.Output((ofstream *)&cout);
+                                        cout << endl;
+
+                                        // add the two linear independent vectors
+                                        first->x.AddVector(&n);
+                                        first->x.Normalize();
+                                        first->x.Scale(a);
+                                        first->x.AddVector(&second->x);
+
+                                        cout << Verbose(0) << "resulting coordinates: ";
+                                        first->x.Output((ofstream *)&cout);
+                                        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 = new atom;
+                                atoms = new (Vector*[128]);
+                                valid = true;
+                                for(int i=128;i--;)
+                                        atoms[i] = NULL;
+                                int i=0, j=0;
+                                cout << Verbose(0) << "Now we need at least three molecules.\n";
+                                do {
+                                        cout << Verbose(0) << "Enter " << i+1 << "th atom: ";
+                                        cin >> j;
+                                        if (j != -1) {
+                                                second = mol->FindAtom(j);
+                                                atoms[i++] = &(second->x);
+                                        }
+                                } while ((j != -1) && (i<128));
+                                if (i >= 2) {
+                                        first->x.LSQdistance(atoms, i);
+
+                                        first->x.Output((ofstream *)&cout);
+                                        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;
+        };
 };
 
@@ -259 +260 @@
 static void CenterAtoms(molecule *mol)
 {
-  Vector x, y;
-  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, &x);
-      break;
-    case 'b':
-      cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
-      mol->CenterGravity((ofstream *)&cout, &x);
-      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->Translate(&y); // translate by boundary
-      mol->SetBoxDimension(&(x+y*2));  // 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, &x);
+                        break;
+                case 'b':
+                        cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
+                        mol->CenterGravity((ofstream *)&cout, &x);
+                        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->Translate(&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;
+        }
 };
 
@@ -314 +318 @@
 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);
 };
 
@@ -382 +386 @@
 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);
 };
 
@@ -429 +433 @@
 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.Distance((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';
 };
 
@@ -487 +491 @@
 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;
+        }
 };
 
@@ -598 +602 @@
 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;
 };
 
@@ -619 +623 @@
 static void testroutine(molecule *mol)
 {
-  // the current test routine checks the functionality of the KeySet&Graph concept:
-  // We want to have a multiindex (the KeySet) describing a unique subgraph
-  atom *Walker = mol->start;
-  int i, comp, counter=0;
-
-  // 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++;
-  }
+        // the current test routine checks the functionality of the KeySet&Graph concept:
+        // We want to have a multiindex (the KeySet) describing a unique subgraph
+        atom *Walker = mol->start;
+        int i, comp, counter=0;
+
+        // 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++;
+        }
 };
 
@@ -692 +696 @@
 static void SaveConfig(char *ConfigFileName, config *configuration, periodentafel *periode, molecule *mol)
 {
-  char filename[MAXSTRINGSIZE];
-  ofstream output;
-
-  cout << Verbose(0) << "Storing configuration ... " << endl;
-  // get correct valence orbitals
-  mol->CalculateOrbitals(*configuration);
-  configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  strcpy(filename, ConfigFileName);
-  if (ConfigFileName != NULL) { // test the file name
-    output.open(ConfigFileName, 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;
-  }
+        char filename[MAXSTRINGSIZE];
+        ofstream output;
+
+        cout << Verbose(0) << "Storing configuration ... " << endl;
+        // get correct valence orbitals
+        mol->CalculateOrbitals(*configuration);
+        configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
+        strcpy(filename, ConfigFileName);
+        if (ConfigFileName != NULL) { // test the file name
+                output.open(ConfigFileName, 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;
+        }
 };
 
@@ -771 +775 @@
 static int ParseCommandLineOptions(int argc, char **argv, molecule *&mol, 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;
-
-  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-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;
-          ConfigFileName = argv[1];
-          config_present = empty;
-          output.close();
-        }
-      } else {
-        test.close();
-        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 '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();
-                }
-                break;
-            case 'N':
-                ExitFlag = 1;
-                if ((argptr >= argc) || (argv[argptr][0] == '-')){
-                        ExitFlag = 255;
-                        cerr << "Not enough or invalid arguments given for non-convex envelope: -o <tecplot output file>" << endl;
-                        }
-                else {
-                        cout << Verbose(0) << "Evaluating npn-convex envelope.";
-                        cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
-                        Find_non_convex_border((ofstream *)&cout, argv[argptr], mol);
-                        argptr+=1;
-                        }
-                break;
-            case 'T':
-              ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for storing temperature: -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 in origin." << endl;
-              mol->CenterOrigin((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.";
-                ofstream *output = new ofstream(argv[argptr], ios::trunc);
-                //$$$
-                cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
-                VolumeOfConvexEnvelope((ofstream *)&cout, output, &configuration, NULL, mol);
-                output->close();
-                delete(output);
-                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, mol);
-    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);
+        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;
+
+        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-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;
+                                        ConfigFileName = argv[1];
+                                        config_present = empty;
+                                        output.close();
+                                }
+                        } else {
+                                test.close();
+                                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 '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 in origin." << endl;
+                                                        mol->CenterOrigin((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, mol);
+                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);
 };
 
@@ -1332 +1336 @@
 int main(int argc, char **argv)
 {
-  periodentafel *periode = new periodentafel; // and a period table of all elements
-  molecule *mol = new molecule(periode);    // first we need an empty molecule
-  config configuration;
-  double tmp1;
-  double bond, min_bond;
-  atom *first, *second;
-  char choice;  // menu choice char
-  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+        periodentafel *periode = new periodentafel; // and a period table of all elements
+        molecule *mol = new molecule(periode);          // first we need an empty molecule
+        config configuration;
+        double tmp1;
+        double bond, min_bond;
+        atom *first, *second;
+        char choice;    // menu choice char
+        Vector x,y,z,n; // coordinates for absolute point in cell volume
         double *factor; // unit factor if desired
-  bool valid; // flag if input was valid or not
-  ifstream test;
-  ofstream output;
-  string line;
-  char filename[MAXSTRINGSIZE];
-  char *ConfigFileName = NULL;
-  char *ElementsFileName = NULL;
-  int Z;
-  int j, axis, count, faktor;
-  clock_t start,end;
-//  int *MinimumRingSize = NULL;
-  MoleculeLeafClass *Subgraphs = NULL;
-//  class StackClass<bond *> *BackEdgeStack = NULL;
-  element **Elements;
-  Vector **vectors;
-
-  // =========================== PARSE COMMAND LINE OPTIONS ====================================
-  j = ParseCommandLineOptions(argc, argv, mol, 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 (mol->cell_size[0] == 0.) {
-    cout << Verbose(0) << "enter lower triadiagonal form of basis matrix" << endl << endl;
-    for (int i=0;i<6;i++) {
-      cout << Verbose(1) << "Cell size" << i << ": ";
-      cin >> mol->cell_size[i];
-    }
-  }
-
-  // =========================== 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) << "============Element list=======================" << endl;
-    mol->Checkout((ofstream *)&cout);
-    cout << Verbose(0) << "============Atom list==========================" << endl;
-    mol->Output((ofstream *)&cout);
-    cout << Verbose(0) << "============Menu===============================" << endl;
-    cout << Verbose(0) << "a - add an atom" << endl;
-    cout << Verbose(0) << "r - remove an atom" << endl;
-    cout << Verbose(0) << "b - scale a bond between atoms" << endl;
-    cout << Verbose(0) << "u - change an atoms element" << endl;
-    cout << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl;
-    cout << Verbose(0) << "-----------------------------------------------" << endl;
-    cout << Verbose(0) << "p - Parse xyz file" << endl;
-    cout << Verbose(0) << "e - edit the current configuration" << endl;
-    cout << Verbose(0) << "o - create connection matrix" << endl;
-    cout << Verbose(0) << "f - fragment molecule many-body bond order style" << endl;
-    cout << Verbose(0) << "-----------------------------------------------" << endl;
-    cout << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
-    cout << Verbose(0) << "i - realign molecule" << endl;
-    cout << Verbose(0) << "m - mirror all molecules" << endl;
-    cout << Verbose(0) << "t - translate molecule by vector" << endl;
-    cout << Verbose(0) << "c - scale by unit transformation" << endl;
-    cout << Verbose(0) << "g - center atoms in box" << endl;
-    cout << Verbose(0) << "-----------------------------------------------" << endl;
-    cout << Verbose(0) << "s - save current setup to config file" << endl;
-    cout << Verbose(0) << "T - call the current test routine" << endl;
-    cout << Verbose(0) << "q - quit" << endl;
-    cout << Verbose(0) << "===============================================" << endl;
-    cout << Verbose(0) << "Input: ";
-    cin >> choice;
-
-    switch (choice) {
-      default:
-      case 'a': // add atom
-        AddAtoms(periode, mol);
-        choice = 'a';
-        break;
-
-      case 'b': // scale a bond
-        cout << Verbose(0) << "Scaling bond length between two atoms." << endl;
-        first = mol->AskAtom("Enter first (fixed) atom: ");
-        second = mol->AskAtom("Enter second (shifting) atom: ");
-        min_bond = 0.;
-        for (int i=NDIM;i--;)
-          min_bond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
-        min_bond = sqrt(min_bond);
-        cout << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << min_bond << " a.u." << endl;
-        cout << Verbose(0) << "Enter new bond length [a.u.]: ";
-        cin >> bond;
-        for (int i=NDIM;i--;) {
-          second->x.x[i] -= (second->x.x[i]-first->x.x[i])/min_bond*(min_bond-bond);
-        }
-        //cout << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
-        //second->Output(second->type->No, 1, (ofstream *)&cout);
-        break;
-
-      case 'c': // unit scaling of the metric
-       cout << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
-       cout << Verbose(0) << "Enter three factors: ";
-       factor = new double[NDIM];
-       cin >> factor[0];
-       cin >> factor[1];
-       cin >> factor[2];
-       valid = true;
-       mol->Scale(&factor);
-       delete[](factor);
-       break;
-
-      case 'd': // duplicate the periodic cell along a given axis, given times
-        cout << Verbose(0) << "State the axis [(+-)123]: ";
-        cin >> axis;
-        cout << Verbose(0) << "State the factor: ";
-        cin >> faktor;
-
-        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, ...)
-            }
-          }
-          if (mol->first->next != mol->last) // if connect matrix is present already, redo it
-            mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration.GetIsAngstroem());
-          // 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;
-
-      case 'e': // edit each field of the configuration
-       configuration.Edit(mol);
-       break;
-
-      case 'f':
-        FragmentAtoms(mol, &configuration);
-        break;
-
-      case 'g': // center the atoms
-        CenterAtoms(mol);
-        break;
-
-      case 'i': // align all atoms
-        AlignAtoms(periode, mol);
-        break;
-
-      case 'l': // measure distances or angles
-        MeasureAtoms(periode, mol, &configuration);
-        break;
-
-      case 'm': // mirror atoms along a given axis
-        MirrorAtoms(mol);
-        break;
-
-      case 'o': // create the connection matrix
-        {
-          cout << Verbose(0) << "What's the maximum bond distance: ";
-          cin >> tmp1;
-          start = clock();
-          mol->CreateAdjacencyList((ofstream *)&cout, tmp1, configuration.GetIsAngstroem());
-          mol->CreateListOfBondsPerAtom((ofstream *)&cout);
-//          Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
-//          while (Subgraphs->next != NULL) {
-//            Subgraphs = Subgraphs->next;
-//            Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
-//            delete(Subgraphs->previous);
-//          }
-//          delete(Subgraphs);    // we don't need the list here, so free everything
-//          delete[](MinimumRingSize);
-//          Subgraphs = NULL;
-          end = clock();
-          cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
-        }
-        break;
-
-      case 'p': // parse and XYZ file
-        cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
-        do {
-          cout << Verbose(0) << "Enter file name: ";
-          cin >> filename;
-        } while (!mol->AddXYZFile(filename));
-        break;
-
-      case 'q': // quit
-        break;
-
-      case 'r': // remove atom
-        RemoveAtoms(mol);
-        break;
-
-      case 's': // save to config file
-        SaveConfig(ConfigFileName, &configuration, periode, mol);
-        break;
-
-      case 't': // translate all atoms
-       cout << Verbose(0) << "Enter translation vector." << endl;
-       x.AskPosition(mol->cell_size,0);
-       mol->Translate((const Vector *)&x);
-       break;
-
-      case 'T':
-        testroutine(mol);
-        break;
-
-      case 'u': // change an atom's element
-        first = NULL;
-        do {
-          cout << Verbose(0) << "Change the element of which atom: ";
-          cin >> Z;
-        } while ((first = mol->FindAtom(Z)) == NULL);
-        cout << Verbose(0) << "New element by atomic number Z: ";
-        cin >> Z;
-        first->type = periode->FindElement(Z);
-        cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
-        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;
-
-  // Free all
-  if (Subgraphs != NULL) {  // free disconnected subgraph list of DFS analysis was performed
-    while (Subgraphs->next != NULL) {
-      Subgraphs = Subgraphs->next;
-      delete(Subgraphs->previous);
-    }
-    delete(Subgraphs);
-  }
-  delete(mol);
-  delete(periode);
-  return (0);
+        bool valid; // flag if input was valid or not
+        ifstream test;
+        ofstream output;
+        string line;
+        char filename[MAXSTRINGSIZE];
+        char *ConfigFileName = NULL;
+        char *ElementsFileName = NULL;
+        int Z;
+        int j, axis, count, faktor;
+        clock_t start,end;
+//      int *MinimumRingSize = NULL;
+        MoleculeLeafClass *Subgraphs = NULL;
+//      class StackClass<bond *> *BackEdgeStack = NULL;
+        element **Elements;
+        Vector **vectors;
+
+        // =========================== PARSE COMMAND LINE OPTIONS ====================================
+        j = ParseCommandLineOptions(argc, argv, mol, 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 (mol->cell_size[0] == 0.) {
+                cout << Verbose(0) << "enter lower triadiagonal form of basis matrix" << endl << endl;
+                for (int i=0;i<6;i++) {
+                        cout << Verbose(1) << "Cell size" << i << ": ";
+                        cin >> mol->cell_size[i];
+                }
+        }
+
+        // =========================== 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) << "============Element list=======================" << endl;
+                mol->Checkout((ofstream *)&cout);
+                cout << Verbose(0) << "============Atom list==========================" << endl;
+                mol->Output((ofstream *)&cout);
+                cout << Verbose(0) << "============Menu===============================" << endl;
+                cout << Verbose(0) << "a - add an atom" << endl;
+                cout << Verbose(0) << "r - remove an atom" << endl;
+                cout << Verbose(0) << "b - scale a bond between atoms" << endl;
+                cout << Verbose(0) << "u - change an atoms element" << endl;
+                cout << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl;
+                cout << Verbose(0) << "-----------------------------------------------" << endl;
+                cout << Verbose(0) << "p - Parse xyz file" << endl;
+                cout << Verbose(0) << "e - edit the current configuration" << endl;
+                cout << Verbose(0) << "o - create connection matrix" << endl;
+                cout << Verbose(0) << "f - fragment molecule many-body bond order style" << endl;
+                cout << Verbose(0) << "-----------------------------------------------" << endl;
+                cout << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
+                cout << Verbose(0) << "i - realign molecule" << endl;
+                cout << Verbose(0) << "m - mirror all molecules" << endl;
+                cout << Verbose(0) << "t - translate molecule by vector" << endl;
+                cout << Verbose(0) << "c - scale by unit transformation" << endl;
+                cout << Verbose(0) << "g - center atoms in box" << endl;
+                cout << Verbose(0) << "-----------------------------------------------" << endl;
+                cout << Verbose(0) << "s - save current setup to config file" << endl;
+                cout << Verbose(0) << "T - call the current test routine" << endl;
+                cout << Verbose(0) << "q - quit" << endl;
+                cout << Verbose(0) << "===============================================" << endl;
+                cout << Verbose(0) << "Input: ";
+                cin >> choice;
+
+                switch (choice) {
+                        default:
+                        case 'a': // add atom
+                                AddAtoms(periode, mol);
+                                choice = 'a';
+                                break;
+
+                        case 'b': // scale a bond
+                                cout << Verbose(0) << "Scaling bond length between two atoms." << endl;
+                                first = mol->AskAtom("Enter first (fixed) atom: ");
+                                second = mol->AskAtom("Enter second (shifting) atom: ");
+                                min_bond = 0.;
+                                for (int i=NDIM;i--;)
+                                        min_bond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
+                                min_bond = sqrt(min_bond);
+                                cout << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << min_bond << " a.u." << endl;
+                                cout << Verbose(0) << "Enter new bond length [a.u.]: ";
+                                cin >> bond;
+                                for (int i=NDIM;i--;) {
+                                        second->x.x[i] -= (second->x.x[i]-first->x.x[i])/min_bond*(min_bond-bond);
+                                }
+                                //cout << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
+                                //second->Output(second->type->No, 1, (ofstream *)&cout);
+                                break;
+
+                        case 'c': // unit scaling of the metric
+                         cout << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
+                         cout << Verbose(0) << "Enter three factors: ";
+                         factor = new double[NDIM];
+                         cin >> factor[0];
+                         cin >> factor[1];
+                         cin >> factor[2];
+                         valid = true;
+                         mol->Scale(&factor);
+                         delete[](factor);
+                         break;
+
+                        case 'd': // duplicate the periodic cell along a given axis, given times
+                                cout << Verbose(0) << "State the axis [(+-)123]: ";
+                                cin >> axis;
+                                cout << Verbose(0) << "State the factor: ";
+                                cin >> faktor;
+
+                                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, ...)
+                                                }
+                                        }
+                                        if (mol->first->next != mol->last) // if connect matrix is present already, redo it
+                                                mol->CreateAdjacencyList((ofstream *)&cout, mol->BondDistance, configuration.GetIsAngstroem());
+                                        // 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;
+
+                        case 'e': // edit each field of the configuration
+                         configuration.Edit(mol);
+                         break;
+
+                        case 'f':
+                                FragmentAtoms(mol, &configuration);
+                                break;
+
+                        case 'g': // center the atoms
+                                CenterAtoms(mol);
+                                break;
+
+                        case 'i': // align all atoms
+                                AlignAtoms(periode, mol);
+                                break;
+
+                        case 'l': // measure distances or angles
+                                MeasureAtoms(periode, mol, &configuration);
+                                break;
+
+                        case 'm': // mirror atoms along a given axis
+                                MirrorAtoms(mol);
+                                break;
+
+                        case 'o': // create the connection matrix
+                                {
+                                        cout << Verbose(0) << "What's the maximum bond distance: ";
+                                        cin >> tmp1;
+                                        start = clock();
+                                        mol->CreateAdjacencyList((ofstream *)&cout, tmp1, configuration.GetIsAngstroem());
+                                        mol->CreateListOfBondsPerAtom((ofstream *)&cout);
+//                                      Subgraphs = mol->DepthFirstSearchAnalysis((ofstream *)&cout, BackEdgeStack);
+//                                      while (Subgraphs->next != NULL) {
+//                                              Subgraphs = Subgraphs->next;
+//                                              Subgraphs->Leaf->CyclicStructureAnalysis((ofstream *)&cout, BackEdgeStack, MinimumRingSize);
+//                                              delete(Subgraphs->previous);
+//                                      }
+//                                      delete(Subgraphs);              // we don't need the list here, so free everything
+//                                      delete[](MinimumRingSize);
+//                                      Subgraphs = NULL;
+                                        end = clock();
+                                        cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+                                }
+                                break;
+
+                        case 'p': // parse and XYZ file
+                                cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+                                do {
+                                        cout << Verbose(0) << "Enter file name: ";
+                                        cin >> filename;
+                                } while (!mol->AddXYZFile(filename));
+                                break;
+
+                        case 'q': // quit
+                                break;
+
+                        case 'r': // remove atom
+                                RemoveAtoms(mol);
+                                break;
+
+                        case 's': // save to config file
+                                SaveConfig(ConfigFileName, &configuration, periode, mol);
+                                break;
+
+                        case 't': // translate all atoms
+                         cout << Verbose(0) << "Enter translation vector." << endl;
+                         x.AskPosition(mol->cell_size,0);
+                         mol->Translate((const Vector *)&x);
+                         break;
+
+                        case 'T':
+                                testroutine(mol);
+                                break;
+
+                        case 'u': // change an atom's element
+                                first = NULL;
+                                do {
+                                        cout << Verbose(0) << "Change the element of which atom: ";
+                                        cin >> Z;
+                                } while ((first = mol->FindAtom(Z)) == NULL);
+                                cout << Verbose(0) << "New element by atomic number Z: ";
+                                cin >> Z;
+                                first->type = periode->FindElement(Z);
+                                cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
+                                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;
+
+        // Free all
+        if (Subgraphs != NULL) {        // free disconnected subgraph list of DFS analysis was performed
+                while (Subgraphs->next != NULL) {
+                        Subgraphs = Subgraphs->next;
+                        delete(Subgraphs->previous);
+                }
+                delete(Subgraphs);
+        }
+        delete(mol);
+        delete(periode);
+        return (0);
 }
 

src/config.cpp

@@ -13 +13 @@
 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';
-  
-  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';
+        
+        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;
 };
 
@@ -89 +89 @@
 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");
 };
 
@@ -102 +102 @@
 void config::Edit(molecule *mol)
 {
-  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');
 };
 
@@ -367 +367 @@
 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;
 }
 
@@ -389 +389 @@
 bool config::GetIsAngstroem() const
 {
-  return (IsAngstroem == 1);
+        return (IsAngstroem == 1);
 };
 
@@ -397 +397 @@
 char * config::GetDefaultPath() const
 {
-  return defaultpath;
+        return defaultpath;
 };
 
@@ -406 +406 @@
 void config::SetDefaultPath(const char *path)
 {
-  strcpy(defaultpath, path);
+        strcpy(defaultpath, path);
 };
 
@@ -414 +414 @@
 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);
 };
 
@@ -444 +444 @@
 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);
 };
 
@@ -773 +773 @@
 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);
 };
 
@@ -977 +977 @@
 bool config::Save(const char *filename, periodentafel *periode, molecule *mol) const
 {
-  bool result = true;
+        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;
+        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;
 };
 
@@ -1084 +1084 @@
 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<CLHF>: (" << endl;
-  *output << "\t\tmaxiter = 200" << endl;
-  *output << "\t\tbasis = $:basis" << 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);
-
-  // 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 = \"3-21G\"" << 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;
 };
 
@@ -1199 +1203 @@
  * \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
@@ -1212 +1216 @@
  */
 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

@@ -1 +1 @@
 /** \file datacreator.cpp
  *
- * Declarations of assisting functions in creating data and plot files. 
- *    
+ * Declarations of assisting functions in creating data and plot files.
+ *
  */
 
@@ -19 +19 @@
 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;
+};
 
 /** Opens a file for appending with \a *filename in \a *dir.
@@ -37 +37 @@
 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;
+};
 
 /** Plots an energy vs. order.
@@ -54 +54 @@
  * \return true if file was written successfully
  */
-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;
+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;
 };
 
@@ -87 +87 @@
  * \return true if file was written successfully
  */
-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;
+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;
 };
 
@@ -126 +126 @@
 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;
 };
 
@@ -158 +158 @@
 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;
 };
 
@@ -188 +188 @@
  * \return true if file was written successfully
  */
-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;
+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;
 };
 
@@ -235 +235 @@
  * \return true if file was written successfully
  */
-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;
+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;
 };
 
@@ -266 +266 @@
 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;
 };
 
@@ -291 +291 @@
  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
  * \param BondOrder current bond order
- */ 
+ */
 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];
+                        }
+                }
+        }
 };
 
@@ -308 +308 @@
  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
  * \param BondOrder current bond order
- */ 
+ */
 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];
+                        }
+                }
+        }
 };
 
@@ -331 +331 @@
 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;
 };
 
@@ -358 +358 @@
 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];
 };
 
@@ -369 +369 @@
 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;
+                        }
+                }
+        }
 };
 
@@ -399 +399 @@
  * 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;
+        }
 };
 
@@ -428 +428 @@
 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;
+                        }
+                }
+        }
 };
 
@@ -450 +450 @@
 void CreateSameForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  // does nothing
+        // does nothing
 };
 
@@ -460 +460 @@
 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];
+        }
 };
 
@@ -472 +472 @@
  * \param *key position of key
  * \param *logscale axis for logscale
- * \param *extraline extra set lines if desired 
+ * \param *extraline extra set lines if desired
  * \param mxtics small tics at ...
  * \param xtics large tics at ...
- * \param *xlabel label for x axis  
+ * \param *xlabel label for x axis
  * \param *ylabel label for y axis
- */ 
+ */
 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;
 };
 
@@ -506 +506 @@
  * \param mxtics small tics at ...
  * \param xtics large tics at ...
- * \param xlabel label for x axis  
+ * \param xlabel label for x axis
  * \param xlabel label for x axis
  * \param *xrange xrange
@@ -514 +514 @@
  * \param (*CreatePlotLines) function reference that writes a single plot line
  * \return true if file was written successfully
- */   
+ */
 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;
 };
 
@@ -538 +538 @@
 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;
+        }
 };
 
@@ -562 +562 @@
 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;
+        }
 };
 
@@ -586 +586 @@
 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');
+        }
 };
 
@@ -617 +617 @@
 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');
+        }
 };
 
@@ -648 +648 @@
 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');
+        }
 };
 
@@ -680 +680 @@
 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/datacreator.hpp

@@ -1 +1 @@
 /** \file datacreator.cpp
  *
- * Definitions of assisting functions in creating data and plot files. 
- *    
+ * Definitions of assisting functions in creating data and plot files.
+ *
  */
 
@@ -12 +12 @@
 //============================ INCLUDES ===========================
 
-#include "helpers.hpp" 
+#include "helpers.hpp"
 #include "parser.hpp"
 
@@ -20 +20 @@
 bool AppendOutputFile(ofstream &output, const char *dir, const char *filename);
 
-bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
+bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
+bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
 bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
 bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
 bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
-bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
+bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum);
 bool CreateDataFragment(class MatrixContainer &ForceFragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
 bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int));

src/defs.hpp

@@ -10 +10 @@
 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"
 
@@ -24 +24 @@
 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
@@ -43 +43 @@
 
 // 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
@@ -68 +68 @@
 
 
-#define UPDATECOUNT 10  //!< update ten sites per BOSSANOVA interval
+#define UPDATECOUNT 10  //!< update ten sites per BOSSANOVA interval
 
 #endif /*DEFS_HPP_*/

src/element.cpp

@@ -12 +12 @@
  */
 element::element() {
-  Z = -1;
-  No = -1;
-  previous = NULL;
-  next = NULL;
-  sort = NULL;
+        Z = -1;
+        No = -1;
+        previous = NULL;
+        next = NULL;
+        sort = NULL;
 };
 
@@ -28 +28 @@
 bool element::Output(ofstream *out) const
 { 
-  if (out != NULL) {
-    *out << name << "\t" << symbol << "\t" << period << "\t" << group << "\t" << block << "\t" << Z << "\t" << mass << "\t" << CovalentRadius << "\t" << VanDerWaalsRadius << endl;
-    //*out << Z << "\t"  << fixed << setprecision(11) << showpoint << mass << "g/mol\t" << name << "\t" << symbol << "\t" << endl;
-    return true;
-  } else
-    return false;
+        if (out != NULL) {
+                *out << name << "\t" << symbol << "\t" << period << "\t" << group << "\t" << block << "\t" << Z << "\t" << mass << "\t" << CovalentRadius << "\t" << VanDerWaalsRadius << endl;
+                //*out << Z << "\t"     << fixed << setprecision(11) << showpoint << mass << "g/mol\t" << name << "\t" << symbol << "\t" << endl;
+                return true;
+        } else
+                return false;
 };
 
 /** Prints element data to \a *out.
  * \param *out outstream
- * \param No  cardinal number of element
+ * \param No    cardinal number of element
  * \param NoOfAtoms total number of atom of this element type
  */
 bool element::Checkout(ofstream *out, const int Number, const int NoOfAtoms) const
 { 
-  if (out != NULL) {
-    *out << "Ion_Type" << Number << "\t" << NoOfAtoms << "\t" << Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << mass << "\t" << name << "\t" << symbol <<endl;
-    return true;
-  } else
-    return false;
+        if (out != NULL) {
+                *out << "Ion_Type" << Number << "\t" << NoOfAtoms << "\t" << Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << mass << "\t" << name << "\t" << symbol <<endl;
+                return true;
+        } else
+                return false;
 };

src/graph.cpp

@@ -1 +1 @@
 /** \file graph.cpp
- * 
+ *
  * Function implementations for the class graph.
- * 
+ *
  */
 
@@ -15 +15 @@
 
 
- 

src/helpers.cpp

@@ -1 +1 @@
 /** \file helpers.cpp
  *
- * Implementation of some auxiliary functions for memory dis-/allocation and so on 
+ * Implementation of some auxiliary functions for memory dis-/allocation and so on
  */
 
@@ -15 +15 @@
 double ask_value(const char *text)
 {
-  double test = 0.1439851348959832147598734598273456723948652983045928346598365;
-  do {
-    cout << Verbose(0) << text;
-    cin >> test;
-  } while (test == 0.1439851348959832147598734598273456723948652983045928346598365);
-  return test;   
+        double test = 0.1439851348959832147598734598273456723948652983045928346598365;
+        do {
+                cout << Verbose(0) << text;
+                cin >> test;
+        } while (test == 0.1439851348959832147598734598273456723948652983045928346598365);
+        return test;
 };
 
@@ -29 +29 @@
 #ifdef HAVE_DEBUG
 void debug_in(const char *output, const char *file, const int line) {
-  if (output) fprintf(stderr,"DEBUG: in %s at line %i: %s\n", file, line, output);
+        if (output) fprintf(stderr,"DEBUG: in %s at line %i: %s\n", file, line, output);
 }
 #else
-void debug_in(const char *output, const char *file, const int line) {}  // print nothing
+void debug_in(const char *output, const char *file, const int line) {}  // print nothing
 #endif
 
@@ -40 +40 @@
  * \return pointer to memory range
  */
-void * Malloc(size_t size, const char* output) 
+void * Malloc(size_t size, const char* output)
 {
-  void *buffer = NULL;
-  buffer = (void *)malloc(size); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "Malloc failed - pointer is NULL: " << output << endl;
-  return(buffer);
+        void *buffer = NULL;
+        buffer = (void *)malloc(size); // alloc
+        if (buffer == NULL)
+                cout << Verbose(0) << "Malloc failed - pointer is NULL: " << output << endl;
+        return(buffer);
 };
 
@@ -54 +54 @@
  * \return pointer to memory range
  */
-void * Calloc(size_t size, const char* output) 
+void * Calloc(size_t size, const char* output)
 {
-  void *buffer = NULL;
-  buffer = (void *)calloc(size, (size_t)0); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "Calloc failed - pointer is NULL: " << output << endl;
-  return(buffer);
+        void *buffer = NULL;
+        buffer = (void *)calloc(size, (size_t)0); // alloc
+        if (buffer == NULL)
+                cout << Verbose(0) << "Calloc failed - pointer is NULL: " << output << endl;
+        return(buffer);
 };
 
@@ -69 +69 @@
  * \return pointer to memory range
  */
-void * ReAlloc(void * OldPointer, size_t size, const char* output) 
+void * ReAlloc(void * OldPointer, size_t size, const char* output)
 {
-  void *buffer = NULL;
-  if (OldPointer == NULL)
-        //cout << Verbose(0) << "ReAlloc impossible - old is NULL: " << output << endl;
-    buffer = (void *)malloc(size); // malloc
-  else
-    buffer = (void *)realloc(OldPointer, size); // realloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "ReAlloc failed - new is NULL: " << output << endl;
-  return(buffer);
+        void *buffer = NULL;
+        if (OldPointer == NULL)
+                //cout << Verbose(0) << "ReAlloc impossible - old is NULL: " << output << endl;
+                buffer = (void *)malloc(size); // malloc
+        else
+                buffer = (void *)realloc(OldPointer, size); // realloc
+        if (buffer == NULL)
+                cout << Verbose(0) << "ReAlloc failed - new is NULL: " << output << endl;
+        return(buffer);
 };
 
@@ -86 +86 @@
  * \param *output message if free fails
  */
-void Free(void ** buffer, const char* output) 
+void Free(void ** buffer, const char* output)
 {
-  if (*buffer == NULL) {
-    //cout << Verbose(5) << "Free not necesary: " << output << endl;
-  } else {
-    free(*buffer);
-    *buffer = NULL;
-  }
+        if (*buffer == NULL) {
+                //cout << Verbose(5) << "Free not necesary: " << output << endl;
+        } else {
+                free(*buffer);
+                *buffer = NULL;
+        }
 };
 
@@ -101 +101 @@
  * \return pointer to string array
  */
-char* MallocString(size_t size, const char* output) 
+char* MallocString(size_t size, const char* output)
 {
-  size_t i;
-  char *buffer;
-  buffer = (char *)malloc(sizeof(char) * (size+1)); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << output << endl;
-  for (i=size;i--;)  // reset
-    buffer[i] = i % 2 == 0 ? 'p': 'c';
-  buffer[size] = '\0'; // and set length marker on its end
-  return(buffer);
+        size_t i;
+        char *buffer;
+        buffer = (char *)malloc(sizeof(char) * (size+1)); // alloc
+        if (buffer == NULL)
+                cout << Verbose(0) << output << endl;
+        for (i=size;i--;)       // reset
+                buffer[i] = i % 2 == 0 ? 'p': 'c';
+        buffer[size] = '\0'; // and set length marker on its end
+        return(buffer);
 }
 
@@ -121 +121 @@
 void bound(double *b, double lower_bound, double upper_bound)
 {
-  double step = (upper_bound - lower_bound);
-  while (*b >= upper_bound)
-    *b -= step;    
-  while (*b < lower_bound)
-    *b += step;    
-}; 
+        double step = (upper_bound - lower_bound);
+        while (*b >= upper_bound)
+                *b -= step;
+        while (*b < lower_bound)
+                *b += step;
+};
 
 /** Flips two doubles.
@@ -134 +134 @@
 void flip(double *x, double *y)
 {
-  double tmp;
-  tmp = *x;
-  *x = *y;
-  *y = tmp;
+        double tmp;
+        tmp = *x;
+        *x = *y;
+        *y = tmp;
 };
 
@@ -147 +147 @@
 int pot(int base, int n)
 {
-  int res = 1;
-  int j;
-  for (j=n;j--;)
-    res *= base;
-  return res;
+        int res = 1;
+        int j;
+        for (j=n;j--;)
+                res *= base;
+        return res;
 };
 
@@ -161 +161 @@
 char *FixedDigitNumber(const int FragmentNumber, const int digits)
 {
-  char *returnstring;
-  int number = FragmentNumber;
-  int order = 0;
-  while (number != 0) { // determine number of digits needed
-    number = (int)floor(((double)number / 10.));
-    order++;
-    //cout << "Number is " << number << ", order is " << order << "." << endl;
-  }
-  // allocate string
-  returnstring = (char *) Malloc(sizeof(char)*(order+2), "MoleculeListClass::CreateFragmentNumberForOutput: *returnstring");
-  // terminate  and fill string array from end backward
-  returnstring[order] = '\0';
-  number = digits;
-  for (int i=order;i--;) {
-    returnstring[i] = '0' + (char)(number % 10);
-    number = (int)floor(((double)number / 10.));
-  }
-  //cout << returnstring << endl;
-  return returnstring;
+        char *returnstring;
+        int number = FragmentNumber;
+        int order = 0;
+        while (number != 0) { // determine number of digits needed
+                number = (int)floor(((double)number / 10.));
+                order++;
+                //cout << "Number is " << number << ", order is " << order << "." << endl;
+        }
+        // allocate string
+        returnstring = (char *) Malloc(sizeof(char)*(order+2), "MoleculeListClass::CreateFragmentNumberForOutput: *returnstring");
+        // terminate    and fill string array from end backward
+        returnstring[order] = '\0';
+        number = digits;
+        for (int i=order;i--;) {
+                returnstring[i] = '0' + (char)(number % 10);
+                number = (int)floor(((double)number / 10.));
+        }
+        //cout << returnstring << endl;
+        return returnstring;
 };
 
@@ -186 +186 @@
  * \return true - is a number, false - is not a valid number
  */
-bool IsValidNumber( const char *string) 
+bool IsValidNumber( const char *string)
 {
-  int ptr = 0;
-  if ((string[ptr] == '.') || (string[ptr] == '-')) // number may be negative or start with dot
-    ptr++;
-  if ((string[ptr] >= '0') && (string[ptr] <= '9'))
-    return true;
-  return false;
+        int ptr = 0;
+        if ((string[ptr] == '.') || (string[ptr] == '-')) // number may be negative or start with dot
+                ptr++;
+        if ((string[ptr] >= '0') && (string[ptr] <= '9'))
+                return true;
+        return false;
 };
 

src/helpers.hpp

@@ -1 +1 @@
 /** \file helpers.hpp
  *
- * Declaration of some auxiliary functions for memory dis-/allocation and so on 
+ * Declaration of some auxiliary functions for memory dis-/allocation and so on
  */
 
@@ -38 +38 @@
 
 /* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
-   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
-   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
+         void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
+         Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
 extern void /*@exits@*/ debug(const char *output);
-  //__attribute__ ((__return__));
+        //__attribute__ ((__return__));
 #define debug(data) debug_in((data), __FILE__, __LINE__)
 
 extern void /*@exits@*/ debug_in(const char *output,
-    const char *file, const int line);
-  //__attribute__ ((__return__));
+                const char *file, const int line);
+        //__attribute__ ((__return__));
 
 double ask_value(const char *text);
@@ -73 +73 @@
 template <typename T> bool CreateFatherLookupTable(ofstream *out, T *start, T *end, T **&LookupTable, int count = 0)
 {
-  bool status = true;
-  T *Walker = NULL;
-  int AtomNo;
-  
-  if (LookupTable != NULL) {
-    *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
-    return false;
-  }
-  
-  // count them
-  if (count == 0) {
-    Walker = start;
-    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron 
-      Walker = Walker->next;
-      count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
-    }
-  }
-  if (count <= 0) {
-    *out << "Count of lookup list is 0 or less." << endl;
-    return false;
-  }
-
-  // allocat and fill
-  LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
-  if (LookupTable == NULL) {
-    cerr << "LookupTable memory allocation failed!" << endl;
-    status = false;
-  } else {
-    for (int i=0;i<count;i++)
-      LookupTable[i] = NULL;
-    Walker = start;
-    while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron 
-      Walker = Walker->next;
-      AtomNo = Walker->GetTrueFather()->nr;
-      if ((AtomNo >= 0) && (AtomNo < count)) {
-        //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
-        LookupTable[AtomNo] = Walker;
-      } else {
-        *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl; 
-        status = false;
-        break;
-      }
-    }
-  }
-  
-  return status; 
+        bool status = true;
+        T *Walker = NULL;
+        int AtomNo;
+
+        if (LookupTable != NULL) {
+                *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
+                return false;
+        }
+
+        // count them
+        if (count == 0) {
+                Walker = start;
+                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+                        Walker = Walker->next;
+                        count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
+                }
+        }
+        if (count <= 0) {
+                *out << "Count of lookup list is 0 or less." << endl;
+                return false;
+        }
+
+        // allocat and fill
+        LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
+        if (LookupTable == NULL) {
+                cerr << "LookupTable memory allocation failed!" << endl;
+                status = false;
+        } else {
+                for (int i=0;i<count;i++)
+                        LookupTable[i] = NULL;
+                Walker = start;
+                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+                        Walker = Walker->next;
+                        AtomNo = Walker->GetTrueFather()->nr;
+                        if ((AtomNo >= 0) && (AtomNo < count)) {
+                                //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
+                                LookupTable[AtomNo] = Walker;
+                        } else {
+                                *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl;
+                                status = false;
+                                break;
+                        }
+                }
+        }
+
+        return status;
 };
 
@@ -129 +129 @@
 template <typename X> void link(X *walker, X *end)
 {
-  X *vorher = end->previous;
-  if (vorher != NULL)
-    vorher->next = walker;
-  end->previous = walker;
-  walker->previous = vorher;
-  walker->next = end;
+        X *vorher = end->previous;
+        if (vorher != NULL)
+                vorher->next = walker;
+        end->previous = walker;
+        walker->previous = vorher;
+        walker->next = end;
 };
 
@@ -143 +143 @@
 template <typename X> void unlink(X *walker)
 {
-  if (walker->next != NULL) 
-    walker->next->previous = walker->previous;
-  if (walker->previous != NULL)
-    walker->previous->next = walker->next;
+        if (walker->next != NULL)
+                walker->next->previous = walker->previous;
+        if (walker->previous != NULL)
+                walker->previous->next = walker->next;
 };
 
 /** Adds new item before an item \a *end in a list.
- * \param *pointer   item to be added
- * \param *end  end of list
+ * \param *pointer       item to be added
+ * \param *end  end of list
  * \return true - addition succeeded, false - unable to add item to list
  */
-template <typename X>  bool add(X *pointer, X *end)
-{
-  if (end != NULL) {
-    link(pointer, end);
-  } else {
-    pointer->previous = NULL;
-    pointer->next = NULL; 
-  }
-  return true;
+template <typename X>   bool add(X *pointer, X *end)
+{
+        if (end != NULL) {
+                link(pointer, end);
+        } else {
+                pointer->previous = NULL;
+                pointer->next = NULL;
+        }
+        return true;
 };
 
 /** Finds item in list
- * \param *suche  search criteria
- * \param *start  begin of list
- * \param *end  end of list
+ * \param *suche        search criteria
+ * \param *start        begin of list
+ * \param *end  end of list
  * \return X - if found, NULL - if not found
  */
 template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
 {
-  X *walker = start;
-  while (walker->next != end) { // go through list
-    walker = walker->next; // step onward beforehand
-    if (*walker->sort == *suche) return (walker);
-  }
-  return NULL;
+        X *walker = start;
+        while (walker->next != end) { // go through list
+                walker = walker->next; // step onward beforehand
+                if (*walker->sort == *suche) return (walker);
+        }
+        return NULL;
 };
 
@@ -187 +187 @@
 template <typename X> void removewithoutcheck(X *walker)
 {
-  if (walker != NULL) {
-    unlink(walker);
-    delete(walker);
-    walker = NULL;
-  }
+        if (walker != NULL) {
+                unlink(walker);
+                delete(walker);
+                walker = NULL;
+        }
 };
 
 /** Removes an item from the list, checks if exists.
  * Checks beforehand if atom is really within molecule list.
- * \param *pointer   item to be removed
- * \param *start  begin of list
- * \param *end  end of list
+ * \param *pointer       item to be removed
+ * \param *start        begin of list
+ * \param *end  end of list
  * \return true - removing succeeded, false - given item not found in list
  */
 template <typename X> bool remove(X *pointer, X *start, X *end)
 {
-  X *walker = find (pointer->sort, start, end);
-/*  while (walker->next != pointer) { // search through list
-    walker = walker->next;
-    if (walker == end) return false;  // item not found in list
-  }*/
-  // atom found, now unlink
-  if (walker != NULL)
-    removewithoutcheck(walker);
-  else
-    return false;
-  return true;
+        X *walker = find (pointer->sort, start, end);
+/*      while (walker->next != pointer) { // search through list
+                walker = walker->next;
+                if (walker == end) return false;        // item not found in list
+        }*/
+        // atom found, now unlink
+        if (walker != NULL)
+                removewithoutcheck(walker);
+        else
+                return false;
+        return true;
 };
 
@@ -223 +223 @@
 template <typename X> bool cleanup(X *start, X *end)
 {
-  X *pointer = start->next;
-  X *walker;
-  while (pointer != end) { // go through list
-    walker = pointer; // mark current
-    pointer = pointer->next; // step onward beforehand
-    // remove walker
-    unlink(walker);
-    delete(walker);
-    walker = NULL;
-  }
-  return true;
+        X *pointer = start->next;
+        X *walker;
+        while (pointer != end) { // go through list
+                walker = pointer; // mark current
+                pointer = pointer->next; // step onward beforehand
+                // remove walker
+                unlink(walker);
+                delete(walker);
+                walker = NULL;
+        }
+        return true;
 };
 
@@ -242 +242 @@
 template <typename X> X *GetFirst(X *me)
 {
-  X *Binder = me;
-  while(Binder->previous != NULL)
-    Binder = Binder->previous;
-  return Binder;
-}; 
+        X *Binder = me;
+        while(Binder->previous != NULL)
+                Binder = Binder->previous;
+        return Binder;
+};
 
 /** Returns the last marker in a chain list.
@@ -254 +254 @@
 template <typename X> X *GetLast(X *me)
 {
-  X *Binder = me;
-  while(Binder->next != NULL)
-    Binder = Binder->next;
-  return Binder;
-}; 
+        X *Binder = me;
+        while(Binder->next != NULL)
+                Binder = Binder->next;
+        return Binder;
+};
 
 /** Frees a two-dimensional array.
@@ -266 +266 @@
 template <typename X> void Free2DArray(X **ptr, int dim)
 {
-  int i;
-  if (ptr != NULL) {
-    for(i=dim;i--;)
-      if (ptr[i] != NULL)
-        free(ptr[i]);
-    free(ptr);
-  }
+        int i;
+        if (ptr != NULL) {
+                for(i=dim;i--;)
+                        if (ptr[i] != NULL)
+                                free(ptr[i]);
+                free(ptr);
+        }
 };
 
@@ -281 +281 @@
 class Verbose
 {
-  public:
-    Verbose(int value) : Verbosity(value) { }
-
-    ostream& print (ostream &ost) const;
-  private:
-    int Verbosity;
+        public:
+                Verbose(int value) : Verbosity(value) { }
+
+                ostream& print (ostream &ost) const;
+        private:
+                int Verbosity;
 };
 
@@ -295 +295 @@
 class Binary
 {
-  public:
-    Binary(int value) : BinaryNumber(value) { }
-
-    ostream& print (ostream &ost) const;
-  private:
-    int BinaryNumber;
+        public:
+                Binary(int value) : BinaryNumber(value) { }
+
+                ostream& print (ostream &ost) const;
+        private:
+                int BinaryNumber;
 };
 

src/joiner.cpp

@@ -2 +2 @@
  *
  * Takes evaluated fragments (energy and forces) and by reading the factors files determines total energy
- * and each force for the whole molecule. 
- *    
+ * and each force for the whole molecule.
+ *
  */
 
 //============================ INCLUDES ===========================
 
-#include "datacreator.hpp" 
-#include "helpers.hpp" 
-#include "parser.hpp" 
-#include "periodentafel.hpp" 
+#include "datacreator.hpp"
+#include "helpers.hpp"
+#include "parser.hpp"
+#include "periodentafel.hpp"
 
 //============================== MAIN =============================
@@ -17 +17 @@
 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;
-  
-  // Get the command line options
-  if (argc < 3) {
-    cout << "Usage: " << argv[0] << " <inputdir> <prefix> [elementsdb]" << endl;
-    cout << "<inputdir>\ttherein the output of a molecuilder fragmentation is expected, each fragment with a subdir containing an energy.all and a forces.all file." << endl;
-    cout << "<prefix>\tprefix of energy and forces file." << endl;
-    cout << "[elementsdb]\tpath to elements database, needed for shieldings." << endl;
-    return 1;
-  } else {
-    dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
-    strcpy(dir, "/");
-    strcat(dir, argv[2]);
-  }
-  if (argc > 3) {
-    periode = new periodentafel;
-    periode->LoadPeriodentafel(argv[3]);
-  }
-  
-  // Test the given directory
-  if (!TestParams(argc, argv))
-    return 1;
-  
-  // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
-  
-  // ------------- Parse through all Fragment subdirs --------
-  if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
-  Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0);
-  if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix, 0,0)) return 1;
-  if (periode != NULL) { // also look for PAS values
-    if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
-    if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
-  }
+        cout << "Joiner" << endl;
+        cout << "======" << endl;
 
-  // ---------- 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;
+        // 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]);
+        }
 
-  // ---------- 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;
-  }
+        // Test the given directory
+        if (!TestParams(argc, argv))
+                return 1;
 
-  // ---------- Parse the KeySets into an array ---------------
-  if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+        // +++++++++++++++++ PARSING +++++++++++++++++++++++++++++++
 
-  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;
-  }
+        // ------------- 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;
+        }
 
-  // +++++++++++++++++ SUMMING +++++++++++++++++++++++++++++++
+        // ---------- Parse the TE Factors into an array -----------------
+        if (!Energy.ParseIndices()) return 1;
+        if (Hcorrected) Hcorrection.ParseIndices();
 
-  // --------- 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;
-    }
+        // ---------- Parse the Force indices into an array ---------------
+        if (!Force.ParseIndices(argv[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;
-  }
+        // ---------- 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;
+        }
 
-  // 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;
-  }
+        // ---------- Parse the KeySets into an array ---------------
+        if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
 
-  // exit  
-  delete(periode);
-  Free((void **)&dir, "main: *dir");
-  cout << "done." << endl;
-  return 0;
+        if (!KeySet.ParseManyBodyTerms()) return 1;
+        if (!EnergyFragments.AllocateMatrix(Energy.Header, Energy.MatrixCounter, Energy.RowCounter, Energy.ColumnCounter)) return 1;
+        if (Hcorrected) HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
+        if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
+                if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
+        }
+
+        // ----------- Resetting last matrices (where full QM values are stored right now)
+        if(!Energy.SetLastMatrix(0., 0)) return 1;
+        if(!Force.SetLastMatrix(0., 2)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if(!Shielding.SetLastMatrix(0., 2)) return 1;
+                if(!ShieldingPAS.SetLastMatrix(0., 2)) return 1;
+        }
+
+        // +++++++++++++++++ SUMMING +++++++++++++++++++++++++++++++
+
+        // --------- sum up and write for each order----------------
+        for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+                // --------- sum up energy --------------------
+                cout << "Summing energy of order " << BondOrder+1 << " ..." << endl;
+                if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
+                if (Hcorrected) {
+                        HcorrectionFragments.SumSubManyBodyTerms(Hcorrection, KeySet, BondOrder);
+                        if (!Energy.SumSubEnergy(EnergyFragments, &HcorrectionFragments, KeySet, BondOrder, 1.)) return 1;
+                        if (Hcorrected) Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
+                } else
+                        if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
+                // --------- sum up Forces --------------------
+                cout << "Summing forces of order " << BondOrder+1 << " ..." << endl;
+                if (!ForceFragments.SumSubManyBodyTerms(Force, KeySet, BondOrder)) return 1;
+                if (!Force.SumSubForces(ForceFragments, KeySet, BondOrder, 1.)) return 1;
+                if (periode != NULL) { // also look for PAS values
+                        cout << "Summing shieldings of order " << BondOrder+1 << " ..." << endl;
+                        if (!ShieldingFragments.SumSubManyBodyTerms(Shielding, KeySet, BondOrder)) return 1;
+                        if (!Shielding.SumSubForces(ShieldingFragments, KeySet, BondOrder, 1.)) return 1;
+                        if (!ShieldingPASFragments.SumSubManyBodyTerms(ShieldingPAS, KeySet, BondOrder)) return 1;
+                        if (!ShieldingPAS.SumSubForces(ShieldingPASFragments, KeySet, BondOrder, 1.)) return 1;
+                }
+
+                // --------- write the energy and forces file --------------------
+                prefix.str(" ");
+                prefix << dir << OrderSuffix << (BondOrder+1);
+                cout << "Writing files " << argv[1] << prefix.str() << ". ..." << endl;
+                // energy
+                if (!Energy.WriteLastMatrix(argv[1], (prefix.str()).c_str(), EnergySuffix)) return 1;
+                // forces
+                if (!Force.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ForcesSuffix)) return 1;
+                // shieldings
+                if (periode != NULL) { // also look for PAS values
+                        if (!Shielding.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingSuffix)) return 1;
+                        if (!ShieldingPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingPASSuffix)) return 1;
+                }
+        }
+        // fragments
+        prefix.str(" ");
+        prefix << dir << EnergyFragmentSuffix;
+        if (!EnergyFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        if (Hcorrected) {
+                prefix.str(" ");
+                prefix << dir << HcorrectionFragmentSuffix;
+                if (!HcorrectionFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        }
+        prefix.str(" ");
+        prefix << dir << ForceFragmentSuffix;
+        if (!ForceFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        if (!CreateDataFragment(EnergyFragments, KeySet, argv[1], FRAGMENTPREFIX ENERGYPERFRAGMENT, "fragment energy versus the Fragment No", "today", CreateEnergy)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                prefix.str(" ");
+                prefix << dir << ShieldingFragmentSuffix;
+                if (!ShieldingFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+                prefix.str(" ");
+                prefix << dir << ShieldingPASFragmentSuffix;
+                if (!ShieldingPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
+        }
+
+        // write last matrices as fragments into central dir (not subdir as above), for analyzer to know index bounds
+        if (!Energy.WriteLastMatrix(argv[1], dir, EnergyFragmentSuffix)) return 1;
+        if (Hcorrected) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
+        if (!Force.WriteLastMatrix(argv[1], dir, ForceFragmentSuffix)) return 1;
+        if (periode != NULL) { // also look for PAS values
+                if (!Shielding.WriteLastMatrix(argv[1], dir, ShieldingFragmentSuffix)) return 1;
+                if (!ShieldingPAS.WriteLastMatrix(argv[1], dir, ShieldingPASFragmentSuffix)) return 1;
+        }
+
+        // exit
+        delete(periode);
+        Free((void **)&dir, "main: *dir");
+        cout << "done." << endl;
+        return 0;
 };
 

src/linkedcell.cpp

@@ -6 +6 @@
 LinkedCell::LinkedCell()
 {
-  LC = NULL;
-  for(int i=0;i<NDIM;i++)
-    N[i] = 0;
-  index = -1;
-  RADIUS = 0.;
-  max.Zero();
-  min.Zero();
+        LC = NULL;
+        for(int i=0;i<NDIM;i++)
+                N[i] = 0;
+        index = -1;
+        RADIUS = 0.;
+        max.Zero();
+        min.Zero();
 };
 
@@ -21 +21 @@
 LinkedCell::LinkedCell(molecule *mol, double radius)
 {
-  atom *Walker = NULL;
+        atom *Walker = NULL;
 
-  RADIUS = radius;
-  LC = NULL;
-  for(int i=0;i<NDIM;i++)
-    N[i] = 0;
-  index = -1;
-  max.Zero();
-  min.Zero();
-  cout << Verbose(1) << "Begin of LinkedCell" << endl;
-  if (mol->start->next == mol->end) {
-    cerr << "ERROR: molecule contains no atoms!" << endl;
-    return;
-  }
-  // 1. find max and min per axis of atoms
-  Walker = mol->start->next;
-  for (int i=0;i<NDIM;i++) {
-    max.x[i] = Walker->x.x[i];
-    min.x[i] = Walker->x.x[i];
-  }
-  while (Walker != mol->end) {
-    for (int i=0;i<NDIM;i++) {
-      if (max.x[i] < Walker->x.x[i])
-        max.x[i] = Walker->x.x[i];
-      if (min.x[i] > Walker->x.x[i])
-        min.x[i] = Walker->x.x[i];
-    }
-    Walker = Walker->next;
-  }
-  cout << Verbose(2) << "Bounding box is " << min << " and " << max << "." << endl;
-  
-  // 2. find then umber of cells per axis
-  for (int i=0;i<NDIM;i++) {
-    N[i] = (int)floor((max.x[i] - min.x[i])/RADIUS)+1;
-  }
-  cout << Verbose(2) << "Number of cells per axis are " << N[0] << ", " << N[1] << " and " << N[2] << "." << endl;
-  
-  // 3. allocate the lists  
-  cout << Verbose(2) << "Allocating cells ... " << endl;
-  if (LC != NULL) {
-    cout << Verbose(1) << "ERROR: Linked Cell list is already allocated, I do nothing." << endl;
-    return;
-  }
-  LC = new LinkedAtoms[N[0]*N[1]*N[2]]; 
-  for (index=0;index<N[0]*N[1]*N[2];index++) {
-    LC [index].clear(); 
-  }
-  
-  // 4. put each atom into its respective cell 
-  Walker = mol->start;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    for (int i=0;i<NDIM;i++) {
-      n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
-    }
-    index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-    LC[index].push_back(Walker);
-    cout << Verbose(2) << *Walker << " goes into cell " << n[0] << ", " << n[1] << ", " << n[2] << " with No. " << index << "." << endl;
-  }
-  cout << Verbose(1) << "End of LinkedCell" << endl;
+        RADIUS = radius;
+        LC = NULL;
+        for(int i=0;i<NDIM;i++)
+                N[i] = 0;
+        index = -1;
+        max.Zero();
+        min.Zero();
+        cout << Verbose(1) << "Begin of LinkedCell" << endl;
+        if (mol->start->next == mol->end) {
+                cerr << "ERROR: molecule contains no atoms!" << endl;
+                return;
+        }
+        // 1. find max and min per axis of atoms
+        Walker = mol->start->next;
+        for (int i=0;i<NDIM;i++) {
+                max.x[i] = Walker->x.x[i];
+                min.x[i] = Walker->x.x[i];
+        }
+        while (Walker != mol->end) {
+                for (int i=0;i<NDIM;i++) {
+                        if (max.x[i] < Walker->x.x[i])
+                                max.x[i] = Walker->x.x[i];
+                        if (min.x[i] > Walker->x.x[i])
+                                min.x[i] = Walker->x.x[i];
+                }
+                Walker = Walker->next;
+        }
+        cout << Verbose(2) << "Bounding box is " << min << " and " << max << "." << endl;
+
+        // 2. find then umber of cells per axis
+        for (int i=0;i<NDIM;i++) {
+                N[i] = (int)floor((max.x[i] - min.x[i])/RADIUS)+1;
+        }
+        cout << Verbose(2) << "Number of cells per axis are " << N[0] << ", " << N[1] << " and " << N[2] << "." << endl;
+
+        // 3. allocate the lists
+        cout << Verbose(2) << "Allocating cells ... " << endl;
+        if (LC != NULL) {
+                cout << Verbose(1) << "ERROR: Linked Cell list is already allocated, I do nothing." << endl;
+                return;
+        }
+        LC = new LinkedAtoms[N[0]*N[1]*N[2]];
+        for (index=0;index<N[0]*N[1]*N[2];index++) {
+                LC [index].clear();
+        }
+
+        // 4. put each atom into its respective cell
+        Walker = mol->start;
+        while (Walker->next != mol->end) {
+                Walker = Walker->next;
+                for (int i=0;i<NDIM;i++) {
+                        n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
+                }
+                index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+                LC[index].push_back(Walker);
+                cout << Verbose(2) << *Walker << " goes into cell " << n[0] << ", " << n[1] << ", " << n[2] << " with No. " << index << "." << endl;
+        }
+        cout << Verbose(1) << "End of LinkedCell" << endl;
 };
 
@@ -87 +87 @@
 LinkedCell::~LinkedCell()
 {
-  if (LC != NULL)
-    for (index=0;index<N[0]*N[1]*N[2];index++)
-      LC[index].clear();
-  delete[](LC);
-  for(int i=0;i<NDIM;i++)
-    N[i] = 0;
-  index = -1;
-  max.Zero();
-  min.Zero();
+        if (LC != NULL)
+        for (index=0;index<N[0]*N[1]*N[2];index++)
+                LC[index].clear();
+        delete[](LC);
+        for(int i=0;i<NDIM;i++)
+                N[i] = 0;
+        index = -1;
+        max.Zero();
+        min.Zero();
 };
 
@@ -103 +103 @@
 bool LinkedCell::CheckBounds()
 {
-  bool status = true;
-  for(int i=0;i<NDIM;i++)
-    status = status && ((n[i] >=0) && (n[i] < N[i]));
-  if (!status)
-    cerr << "ERROR: indices are out of bounds!" << endl;
-  return status;
+        bool status = true;
+        for(int i=0;i<NDIM;i++)
+                status = status && ((n[i] >=0) && (n[i] < N[i]));
+        if (!status)
+        cerr << "ERROR: indices are out of bounds!" << endl;
+        return status;
 };
 
@@ -117 +117 @@
 LinkedAtoms* LinkedCell::GetCurrentCell()
 {
-  if (CheckBounds()) {
-    index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-    return (&(LC[index]));
-  } else {
-    return NULL;
-  }
+        if (CheckBounds()) {
+                index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+                return (&(LC[index]));
+        } else {
+                return NULL;
+        }
 };
 
@@ -131 +131 @@
 bool LinkedCell::SetIndexToAtom(atom *Walker)
 {
-  bool status = false;
-  for (int i=0;i<NDIM;i++) {
-    n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
-  }
-  index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-  if (CheckBounds()) {
-    for (LinkedAtoms::iterator Runner = LC[index].begin(); Runner != LC[index].end(); Runner++)
-      status = status || ((*Runner) == Walker);
-    return status;
-  } else {
-    cerr << Verbose(1) << "ERROR: Atom "<< *Walker << " at " << Walker->x << " is out of bounds." << endl;
-    return false;
-  }
+        bool status = false;
+        for (int i=0;i<NDIM;i++) {
+                n[i] = (int)floor((Walker->x.x[i] - min.x[i])/RADIUS);
+        }
+        index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+        if (CheckBounds()) {
+                for (LinkedAtoms::iterator Runner = LC[index].begin(); Runner != LC[index].end(); Runner++)
+                        status = status || ((*Runner) == Walker);
+                return status;
+        } else {
+                cerr << Verbose(1) << "ERROR: Atom "<< *Walker << " at " << Walker->x << " is out of bounds." << endl;
+                return false;
+        }
 };
 
@@ -152 +152 @@
 bool LinkedCell::SetIndexToVector(Vector *x)
 {
-  bool status = true;
-  for (int i=0;i<NDIM;i++) {
-    n[i] = (int)floor((x->x[i] - min.x[i])/RADIUS);
-    if (max.x[i] < x->x[i])
-      status = false;
-    if (min.x[i] > x->x[i])
-      status = false;
-  }
-  return status;
+        bool status = true;
+        for (int i=0;i<NDIM;i++) {
+                n[i] = (int)floor((x->x[i] - min.x[i])/RADIUS);
+                if (max.x[i] < x->x[i])
+                        status = false;
+                if (min.x[i] > x->x[i])
+                        status = false;
+        }
+        return status;
 };
+

src/linkedcell.hpp

@@ -9 +9 @@
 #include "molecules.hpp"
 
+#define LinkedAtoms list <atom *>
+
 class LinkedCell{
-  public:
-    Vector max;       // upper boundary
-    Vector min;       // lower boundary
-    LinkedAtoms *LC;  // linked cell list
-    double RADIUS;    // cell edge length
-    int N[NDIM];      // number of cells per axis
-    int n[NDIM];      // temporary variable for current cell per axis
-    int index;        // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
-    
-    LinkedCell();
-    LinkedCell(molecule *mol, double RADIUS);
-    ~LinkedCell();
-    LinkedAtoms* GetCurrentCell();
-    bool SetIndexToAtom(atom *Walker);
-    bool SetIndexToVector(Vector *x);
-    bool CheckBounds();
+        public:
+                Vector max;                      // upper boundary
+                Vector min;                      // lower boundary
+                LinkedAtoms *LC;        // linked cell list
+                double RADIUS;          // cell edge length
+                int N[NDIM];                    // number of cells per axis
+                int n[NDIM];                    // temporary variable for current cell per axis
+                int index;                              // temporary index variable , access by index = n[0] * N[1] * N[2] + n[1] * N[2] + n[2];
+
+                LinkedCell();
+                LinkedCell(molecule *mol, double RADIUS);
+                ~LinkedCell();
+                LinkedAtoms* GetCurrentCell();
+                bool SetIndexToAtom(atom *Walker);
+                bool SetIndexToVector(Vector *x);
+                bool CheckBounds();
+
+                // not implemented yet
+                bool AddAtom(atom *Walker);
+                bool DeleteAtom(atom *Walker);
+                bool MoveAtom(atom *Walker);
 };
 

src/moleculelist.cpp

@@ -21 +21 @@
 MoleculeListClass::MoleculeListClass(int NumMolecules, int NumAtoms)
 {
-  ListOfMolecules = (molecule **) Malloc(sizeof(molecule *)*NumMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
-  for (int i=NumMolecules;i--;)
-    ListOfMolecules[i] = NULL;
-  NumberOfMolecules = NumMolecules;
-  NumberOfTopAtoms = NumAtoms;
+        ListOfMolecules = (molecule **) Malloc(sizeof(molecule *)*NumMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
+        for (int i=NumMolecules;i--;)
+                ListOfMolecules[i] = NULL;
+        NumberOfMolecules = NumMolecules;
+        NumberOfTopAtoms = NumAtoms;
 };
 
@@ -33 +33 @@
 MoleculeListClass::~MoleculeListClass()
 {
-  cout << Verbose(3) << this << ": Freeing ListOfMolcules." << endl;
-  for (int i=NumberOfMolecules;i--;) {
-    if (ListOfMolecules[i] != NULL) { // if NULL don't free
-      cout << Verbose(4) << "ListOfMolecules: Freeing " << ListOfMolecules[i] << "." << endl;
-      delete(ListOfMolecules[i]);
-      ListOfMolecules[i] = NULL;
-    }
-  }
-  cout << Verbose(4) << "Freeing ListOfMolecules." << endl;
-  Free((void **)&ListOfMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
+        cout << Verbose(3) << this << ": Freeing ListOfMolcules." << endl;
+        for (int i=NumberOfMolecules;i--;) {
+                if (ListOfMolecules[i] != NULL) { // if NULL don't free
+                        cout << Verbose(4) << "ListOfMolecules: Freeing " << ListOfMolecules[i] << "." << endl;
+                        delete(ListOfMolecules[i]);
+                        ListOfMolecules[i] = NULL;
+                }
+        }
+        cout << Verbose(4) << "Freeing ListOfMolecules." << endl;
+        Free((void **)&ListOfMolecules, "MoleculeListClass:MoleculeListClass: **ListOfMolecules");
 };
 
@@ -52 +52 @@
 int MolCompare(const void *a, const void *b)
 {
-  int *aList = NULL, *bList = NULL;
-  int Count, Counter, aCounter, bCounter;
-  int flag;
-  atom *aWalker = NULL;
-  atom *bWalker = NULL;
-  
-  // sort each atom list and put the numbers into a list, then go through
-  //cout << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
-  if ( (**(molecule **)a).AtomCount < (**(molecule **)b).AtomCount ) {
-    return -1;
-  } else { if ((**(molecule **)a).AtomCount > (**(molecule **)b).AtomCount)
-    return +1;
-    else {
-      Count = (**(molecule **)a).AtomCount;
-      aList = new int[Count];
-      bList = new int[Count];
-  
-      // fill the lists
-      aWalker = (**(molecule **)a).start;
-      bWalker = (**(molecule **)b).start;
-      Counter = 0;
-      aCounter = 0;
-      bCounter = 0;
-      while ((aWalker->next != (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
-        aWalker = aWalker->next;
-        bWalker = bWalker->next;
-        if (aWalker->GetTrueFather() == NULL)
-          aList[Counter] = Count + (aCounter++);
-        else
-          aList[Counter] = aWalker->GetTrueFather()->nr;
-        if (bWalker->GetTrueFather() == NULL)
-          bList[Counter] = Count + (bCounter++);
-        else
-          bList[Counter] = bWalker->GetTrueFather()->nr;
-        Counter++;
-      }
-      // check if AtomCount was for real
-      flag = 0;
-      if ((aWalker->next == (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
-        flag = -1;
-      } else {
-        if ((aWalker->next != (**(molecule **)a).end) && (bWalker->next == (**(molecule **)b).end))
-          flag = 1;
-      }
-      if (flag == 0) {
-        // sort the lists
-        gsl_heapsort(aList,Count, sizeof(int), CompareDoubles); 
-        gsl_heapsort(bList,Count, sizeof(int), CompareDoubles);
-        // compare the lists 
-        
-        flag = 0;
-        for(int i=0;i<Count;i++) {
-          if (aList[i] < bList[i]) {
-            flag = -1;
-          } else {
-            if (aList[i] > bList[i])
-              flag = 1;
-          }
-          if (flag != 0)
-            break;
-        }
-      }
-      delete[](aList);
-      delete[](bList);
-      return flag;
-    }
-  }
-  return  -1;
+        int *aList = NULL, *bList = NULL;
+        int Count, Counter, aCounter, bCounter;
+        int flag;
+        atom *aWalker = NULL;
+        atom *bWalker = NULL;
+        
+        // sort each atom list and put the numbers into a list, then go through
+        //cout << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
+        if ( (**(molecule **)a).AtomCount < (**(molecule **)b).AtomCount ) {
+                return -1;
+        } else { if ((**(molecule **)a).AtomCount > (**(molecule **)b).AtomCount)
+                return +1;
+                else {
+                        Count = (**(molecule **)a).AtomCount;
+                        aList = new int[Count];
+                        bList = new int[Count];
+        
+                        // fill the lists
+                        aWalker = (**(molecule **)a).start;
+                        bWalker = (**(molecule **)b).start;
+                        Counter = 0;
+                        aCounter = 0;
+                        bCounter = 0;
+                        while ((aWalker->next != (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
+                                aWalker = aWalker->next;
+                                bWalker = bWalker->next;
+                                if (aWalker->GetTrueFather() == NULL)
+                                        aList[Counter] = Count + (aCounter++);
+                                else
+                                        aList[Counter] = aWalker->GetTrueFather()->nr;
+                                if (bWalker->GetTrueFather() == NULL)
+                                        bList[Counter] = Count + (bCounter++);
+                                else
+                                        bList[Counter] = bWalker->GetTrueFather()->nr;
+                                Counter++;
+                        }
+                        // check if AtomCount was for real
+                        flag = 0;
+                        if ((aWalker->next == (**(molecule **)a).end) && (bWalker->next != (**(molecule **)b).end)) {
+                                flag = -1;
+                        } else {
+                                if ((aWalker->next != (**(molecule **)a).end) && (bWalker->next == (**(molecule **)b).end))
+                                        flag = 1;
+                        }
+                        if (flag == 0) {
+                                // sort the lists
+                                gsl_heapsort(aList,Count, sizeof(int), CompareDoubles); 
+                                gsl_heapsort(bList,Count, sizeof(int), CompareDoubles);
+                                // compare the lists 
+                                
+                                flag = 0;
+                                for(int i=0;i<Count;i++) {
+                                        if (aList[i] < bList[i]) {
+                                                flag = -1;
+                                        } else {
+                                                if (aList[i] > bList[i])
+                                                        flag = 1;
+                                        }
+                                        if (flag != 0)
+                                                break;
+                                }
+                        }
+                        delete[](aList);
+                        delete[](bList);
+                        return flag;
+                }
+        }
+        return  -1;
 };
 
@@ -127 +127 @@
 void MoleculeListClass::Output(ofstream *out)
 {
-  *out<< Verbose(1) << "MoleculeList: ";
-  for (int i=0;i<NumberOfMolecules;i++)
-    *out << ListOfMolecules[i] << "\t";
-  *out << endl;
+        *out<< Verbose(1) << "MoleculeList: ";
+        for (int i=0;i<NumberOfMolecules;i++)
+                *out << ListOfMolecules[i] << "\t";
+        *out << endl;
 };
 
@@ -142 +142 @@
 bool MoleculeListClass::AddHydrogenCorrection(ofstream *out, char *path)
 {
-  atom *Walker = NULL;
-  atom *Runner = NULL;
-  double ***FitConstant = NULL, **correction = NULL;
-  int a,b;
-  ofstream output;
-  ifstream input;
-  string line;
-  stringstream zeile;
-  double distance;
-  char ParsedLine[1023];
-  double tmp;
-  char *FragmentNumber = NULL;
-
-  cout << Verbose(1) << "Saving hydrogen saturation correction ... ";
-  // 0. parse in fit constant files that should have the same dimension as the final energy files
-  // 0a. find dimension of matrices with constants
-  line = path;
-  line.append("/");
-  line += FRAGMENTPREFIX;
-  line += "1";
-  line += FITCONSTANTSUFFIX;
-  input.open(line.c_str());
-  if (input == NULL) {
-    cerr << endl << "Unable to open " << line << ", is the directory correct?" << endl;
-    return false;
-  }
-  a=0;
-  b=-1; // we overcount by one 
-  while (!input.eof()) {
-    input.getline(ParsedLine, 1023);
-    zeile.str(ParsedLine);
-    int i=0;
-    while (!zeile.eof()) {
-      zeile >> distance;
-      i++;
-    }
-    if (i > a) 
-      a = i; 
-    b++;
-  }
-  cout << "I recognized " << a << " columns and " << b << " rows, ";
-  input.close();
-  
-  // 0b. allocate memory for constants
-  FitConstant = (double ***) Malloc(sizeof(double **)*3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
-  for (int k=0;k<3;k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
-    for (int i=a;i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
-    }
-  }
-  // 0c. parse in constants
-  for (int i=0;i<3;i++) {
-    line = path;
-    line.append("/");
-    line += FRAGMENTPREFIX;
-    sprintf(ParsedLine, "%d", i+1);
-    line += ParsedLine;
-    line += FITCONSTANTSUFFIX;
-    input.open(line.c_str());
-    if (input == NULL) {
-      cerr << endl << "Unable to open " << line << ", is the directory correct?" << endl;
-      return false;
-    }
-    int k = 0,l;
-    while ((!input.eof()) && (k < b)) {
-      input.getline(ParsedLine, 1023);
-      //cout << "Current Line: " << ParsedLine << endl;
-      zeile.str(ParsedLine);
-      zeile.clear();
-      l = 0;
-      while ((!zeile.eof()) && (l < a)) {
-        zeile >> FitConstant[i][l][k];
-        //cout << FitConstant[i][l][k] << "\t";
-        l++;
-      }
-      //cout << endl;
-      k++;
-    }
-    input.close();
-  }
-  for(int k=0;k<3;k++) {
-    cout << "Constants " << k << ":" << endl;
-    for (int j=0;j<b;j++) {
-      for (int i=0;i<a;i++) {
-        cout << FitConstant[k][i][j] << "\t";
-      }
-      cout << endl;
-    }
-    cout << endl;
-  }
-  
-  // 0d. allocate final correction matrix
-  correction = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **correction");
-  for (int i=a;i--;)
-    correction[i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
-        
-  // 1a. go through every molecule in the list
-  for(int i=NumberOfMolecules;i--;) {
-    // 1b. zero final correction matrix
-    for (int k=a;k--;)
-      for (int j=b;j--;)
-        correction[k][j] = 0.;
-    // 2. take every hydrogen that is a saturated one
-    Walker = ListOfMolecules[i]->start;
-    while (Walker->next != ListOfMolecules[i]->end) {
-      Walker = Walker->next;
-      //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0] << "." << endl;
-      if ((Walker->type->Z == 1) && ((Walker->father == NULL) || (Walker->father->type->Z != 1))) { // if it's a hydrogen
-        Runner = ListOfMolecules[i]->start;
-        while (Runner->next != ListOfMolecules[i]->end) {
-          Runner = Runner->next;
-          //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0] << "." << endl;
-          // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
-          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0]->GetOtherAtom(Runner) != ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0]->GetOtherAtom(Walker))) {  // (hydrogens have only one bonding partner!)
-            // 4. evaluate the morse potential for each matrix component and add up
-            distance = sqrt(Runner->x.Distance(&Walker->x));
-            //cout << "Fragment " << i << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
-            for(int k=0;k<a;k++) {
-              for (int j=0;j<b;j++) {
-                switch(k) {
-                case 1:
-                case 7:
-                case 11:
-                  tmp = pow(FitConstant[0][k][j] * ( 1. - exp(-FitConstant[1][k][j] * (distance - FitConstant[2][k][j]) ) ),2);
-                  break;
-                default:
-                  tmp = FitConstant[0][k][j] * pow( distance,  FitConstant[1][k][j]) + FitConstant[2][k][j];
-                };
-                correction[k][j] -= tmp;    // ground state is actually lower (disturbed by additional interaction)
-                //cout << tmp << "\t";
-              }
-              //cout << endl;
-            }
-            //cout << endl;
-          }
-        }
-      }
-    }
-    // 5. write final matrix to file
-    line = path;
-    line.append("/");
-    line += FRAGMENTPREFIX;
-    FragmentNumber = FixedDigitNumber(NumberOfMolecules, i);
-    line += FragmentNumber;
-    delete(FragmentNumber);
-    line += HCORRECTIONSUFFIX;
-    output.open(line.c_str());
-    output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
-    for (int j=0;j<b;j++) {
-      for(int i=0;i<a;i++)
-        output << correction[i][j] << "\t";
-      output << endl;
-    }
-    output.close();
-  }
-  line = path;
-  line.append("/");
-  line += HCORRECTIONSUFFIX;
-  output.open(line.c_str());
-  output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
-  for (int j=0;j<b;j++) {
-    for(int i=0;i<a;i++)
-      output << 0 << "\t";
-    output << endl;
-  }
-  output.close();
-  // 6. free memory of parsed matrices
-  FitConstant = (double ***) Malloc(sizeof(double **)*a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
-  for (int k=0;k<3;k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
-    for (int i=a;i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
-    }
-  }
-  cout << "done." << endl;
-  return true;
+        atom *Walker = NULL;
+        atom *Runner = NULL;
+        double ***FitConstant = NULL, **correction = NULL;
+        int a,b;
+        ofstream output;
+        ifstream input;
+        string line;
+        stringstream zeile;
+        double distance;
+        char ParsedLine[1023];
+        double tmp;
+        char *FragmentNumber = NULL;
+
+        cout << Verbose(1) << "Saving hydrogen saturation correction ... ";
+        // 0. parse in fit constant files that should have the same dimension as the final energy files
+        // 0a. find dimension of matrices with constants
+        line = path;
+        line.append("/");
+        line += FRAGMENTPREFIX;
+        line += "1";
+        line += FITCONSTANTSUFFIX;
+        input.open(line.c_str());
+        if (input == NULL) {
+                cerr << endl << "Unable to open " << line << ", is the directory correct?" << endl;
+                return false;
+        }
+        a=0;
+        b=-1; // we overcount by one 
+        while (!input.eof()) {
+                input.getline(ParsedLine, 1023);
+                zeile.str(ParsedLine);
+                int i=0;
+                while (!zeile.eof()) {
+                        zeile >> distance;
+                        i++;
+                }
+                if (i > a) 
+                        a = i; 
+                b++;
+        }
+        cout << "I recognized " << a << " columns and " << b << " rows, ";
+        input.close();
+        
+        // 0b. allocate memory for constants
+        FitConstant = (double ***) Malloc(sizeof(double **)*3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+        for (int k=0;k<3;k++) {
+                FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+                for (int i=a;i--;) {
+                        FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+                }
+        }
+        // 0c. parse in constants
+        for (int i=0;i<3;i++) {
+                line = path;
+                line.append("/");
+                line += FRAGMENTPREFIX;
+                sprintf(ParsedLine, "%d", i+1);
+                line += ParsedLine;
+                line += FITCONSTANTSUFFIX;
+                input.open(line.c_str());
+                if (input == NULL) {
+                        cerr << endl << "Unable to open " << line << ", is the directory correct?" << endl;
+                        return false;
+                }
+                int k = 0,l;
+                while ((!input.eof()) && (k < b)) {
+                        input.getline(ParsedLine, 1023);
+                        //cout << "Current Line: " << ParsedLine << endl;
+                        zeile.str(ParsedLine);
+                        zeile.clear();
+                        l = 0;
+                        while ((!zeile.eof()) && (l < a)) {
+                                zeile >> FitConstant[i][l][k];
+                                //cout << FitConstant[i][l][k] << "\t";
+                                l++;
+                        }
+                        //cout << endl;
+                        k++;
+                }
+                input.close();
+        }
+        for(int k=0;k<3;k++) {
+                cout << "Constants " << k << ":" << endl;
+                for (int j=0;j<b;j++) {
+                        for (int i=0;i<a;i++) {
+                                cout << FitConstant[k][i][j] << "\t";
+                        }
+                        cout << endl;
+                }
+                cout << endl;
+        }
+        
+        // 0d. allocate final correction matrix
+        correction = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+        for (int i=a;i--;)
+                correction[i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+                                
+        // 1a. go through every molecule in the list
+        for(int i=NumberOfMolecules;i--;) {
+                // 1b. zero final correction matrix
+                for (int k=a;k--;)
+                        for (int j=b;j--;)
+                                correction[k][j] = 0.;
+                // 2. take every hydrogen that is a saturated one
+                Walker = ListOfMolecules[i]->start;
+                while (Walker->next != ListOfMolecules[i]->end) {
+                        Walker = Walker->next;
+                        //cout << Verbose(1) << "Walker: " << *Walker << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0] << "." << endl;
+                        if ((Walker->type->Z == 1) && ((Walker->father == NULL) || (Walker->father->type->Z != 1))) { // if it's a hydrogen
+                                Runner = ListOfMolecules[i]->start;
+                                while (Runner->next != ListOfMolecules[i]->end) {
+                                        Runner = Runner->next;
+                                        //cout << Verbose(2) << "Runner: " << *Runner << " with first bond " << *ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0] << "." << endl;
+                                        // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
+                                        if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (ListOfMolecules[i]->ListOfBondsPerAtom[Runner->nr][0]->GetOtherAtom(Runner) != ListOfMolecules[i]->ListOfBondsPerAtom[Walker->nr][0]->GetOtherAtom(Walker))) {      // (hydrogens have only one bonding partner!)
+                                                // 4. evaluate the morse potential for each matrix component and add up
+                                                distance = Runner->x.Distance(&Walker->x);
+                                                //cout << "Fragment " << i << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
+                                                for(int k=0;k<a;k++) {
+                                                        for (int j=0;j<b;j++) {
+                                                                switch(k) {
+                                                                case 1:
+                                                                case 7:
+                                                                case 11:
+                                                                        tmp = pow(FitConstant[0][k][j] * ( 1. - exp(-FitConstant[1][k][j] * (distance - FitConstant[2][k][j]) ) ),2);
+                                                                        break;
+                                                                default:
+                                                                        tmp = FitConstant[0][k][j] * pow( distance,     FitConstant[1][k][j]) + FitConstant[2][k][j];
+                                                                };
+                                                                correction[k][j] -= tmp;                // ground state is actually lower (disturbed by additional interaction)
+                                                                //cout << tmp << "\t";
+                                                        }
+                                                        //cout << endl;
+                                                }
+                                                //cout << endl;
+                                        }
+                                }
+                        }
+                }
+                // 5. write final matrix to file
+                line = path;
+                line.append("/");
+                line += FRAGMENTPREFIX;
+                FragmentNumber = FixedDigitNumber(NumberOfMolecules, i);
+                line += FragmentNumber;
+                delete(FragmentNumber);
+                line += HCORRECTIONSUFFIX;
+                output.open(line.c_str());
+                output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
+                for (int j=0;j<b;j++) {
+                        for(int i=0;i<a;i++)
+                                output << correction[i][j] << "\t";
+                        output << endl;
+                }
+                output.close();
+        }
+        line = path;
+        line.append("/");
+        line += HCORRECTIONSUFFIX;
+        output.open(line.c_str());
+        output << "Time\t\tTotal\t\tKinetic\t\tNonLocal\tCorrelation\tExchange\tPseudo\t\tHartree\t\t-Gauss\t\tEwald\t\tIonKin\t\tETotal" << endl;
+        for (int j=0;j<b;j++) {
+                for(int i=0;i<a;i++)
+                        output << 0 << "\t";
+                output << endl;
+        }
+        output.close();
+        // 6. free memory of parsed matrices
+        FitConstant = (double ***) Malloc(sizeof(double **)*a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+        for (int k=0;k<3;k++) {
+                FitConstant[k] = (double **) Malloc(sizeof(double *)*a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+                for (int i=a;i--;) {
+                        FitConstant[k][i] = (double *) Malloc(sizeof(double)*b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+                }
+        }
+        cout << "done." << endl;
+        return true;
 };
 
@@ -329 +329 @@
 bool MoleculeListClass::StoreForcesFile(ofstream *out, char *path, int *SortIndex)
 {
-  bool status = true;
-  ofstream ForcesFile;
-  stringstream line;
-  atom *Walker = NULL;
-  element *runner = NULL;
-
-  // open file for the force factors
-  *out << Verbose(1) << "Saving  force factors ... ";
-  line << path << "/" << FRAGMENTPREFIX << FORCESFILE;
-  ForcesFile.open(line.str().c_str(), ios::out);
-  if (ForcesFile != NULL) {
-    //cout << Verbose(1) << "Final AtomicForcesList: ";
-    //output << prefix << "Forces" << endl;
-    for(int j=0;j<NumberOfMolecules;j++) {
-      //if (TEList[j] != 0) {
-      runner = ListOfMolecules[j]->elemente->start;
-      while (runner->next != ListOfMolecules[j]->elemente->end) { // go through every element
-        runner = runner->next;
-        if (ListOfMolecules[j]->ElementsInMolecule[runner->Z]) { // if this element got atoms
-          Walker = ListOfMolecules[j]->start;
-          while (Walker->next != ListOfMolecules[j]->end) { // go through every atom of this element
-            Walker = Walker->next;
-            if (Walker->type->Z == runner->Z) {
-              if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
-                //cout << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
-                ForcesFile <<  SortIndex[Walker->GetTrueFather()->nr] << "\t";
-                } else  // otherwise a -1 to indicate an added saturation hydrogen
-                  ForcesFile << "-1\t";
-              }
-            }
-          }
-      }
-      ForcesFile << endl;
-    }
-    ForcesFile.close();
-    *out << Verbose(1) << "done." << endl;
-  } else {
-    status = false;
-    *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
-  }
-  ForcesFile.close();
-  
-  return status;
+        bool status = true;
+        ofstream ForcesFile;
+        stringstream line;
+        atom *Walker = NULL;
+        element *runner = NULL;
+
+        // open file for the force factors
+        *out << Verbose(1) << "Saving   force factors ... ";
+        line << path << "/" << FRAGMENTPREFIX << FORCESFILE;
+        ForcesFile.open(line.str().c_str(), ios::out);
+        if (ForcesFile != NULL) {
+                //cout << Verbose(1) << "Final AtomicForcesList: ";
+                //output << prefix << "Forces" << endl;
+                for(int j=0;j<NumberOfMolecules;j++) {
+                        //if (TEList[j] != 0) {
+                        runner = ListOfMolecules[j]->elemente->start;
+                        while (runner->next != ListOfMolecules[j]->elemente->end) { // go through every element
+                                runner = runner->next;
+                                if (ListOfMolecules[j]->ElementsInMolecule[runner->Z]) { // if this element got atoms
+                                        Walker = ListOfMolecules[j]->start;
+                                        while (Walker->next != ListOfMolecules[j]->end) { // go through every atom of this element
+                                                Walker = Walker->next;
+                                                if (Walker->type->Z == runner->Z) {
+                                                        if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
+                                                                //cout << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
+                                                                ForcesFile <<   SortIndex[Walker->GetTrueFather()->nr] << "\t";
+                                                                } else  // otherwise a -1 to indicate an added saturation hydrogen
+                                                                        ForcesFile << "-1\t";
+                                                        }
+                                                }
+                                        }
+                        }
+                        ForcesFile << endl;
+                }
+                ForcesFile.close();
+                *out << Verbose(1) << "done." << endl;
+        } else {
+                status = false;
+                *out << Verbose(1) << "failed to open file " << line.str() << "." << endl;
+        }
+        ForcesFile.close();
+        
+        return status;
 };
 
@@ -382 +382 @@
 bool MoleculeListClass::OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex)
 {
-  ofstream outputFragment;
-  char FragmentName[MAXSTRINGSIZE];
-  char PathBackup[MAXSTRINGSIZE];
-  bool result = true;
-  bool intermediateResult = true;
-  atom *Walker = NULL;
-  Vector BoxDimension;
-  char *FragmentNumber = NULL;
-  char *path = NULL;
-  int FragmentCounter = 0;
-  ofstream output;
-  
-  // store the fragments as config and as xyz
-  for(int i=0;i<NumberOfMolecules;i++) {
-    // save default path as it is changed for each fragment
-    path = configuration->GetDefaultPath();
-    if (path != NULL)
-      strcpy(PathBackup, path);
-    else
-      cerr << "OutputConfigForListOfFragments: NULL default path obtained from config!" << endl;
-
-    // correct periodic
-    ListOfMolecules[i]->ScanForPeriodicCorrection(out);
-
-    // output xyz file
-    FragmentNumber = FixedDigitNumber(NumberOfMolecules, FragmentCounter++);
-    sprintf(FragmentName, "%s/%s%s.conf.xyz", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
-    outputFragment.open(FragmentName, ios::out);
-    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as XYZ ...";
-    if ((intermediateResult = ListOfMolecules[i]->OutputXYZ(&outputFragment)))
-      *out << " done." << endl;
-    else
-      *out << " failed." << endl;
-    result = result && intermediateResult;
-    outputFragment.close();
-    outputFragment.clear();
-
-    // list atoms in fragment for debugging
-    *out << Verbose(2) << "Contained atoms: ";
-    Walker = ListOfMolecules[i]->start;
-    while (Walker->next != ListOfMolecules[i]->end) {
-      Walker = Walker->next;
-      *out << Walker->Name << " ";
-    }
-    *out << endl;
-    
-    // center on edge
-    ListOfMolecules[i]->CenterEdge(out, &BoxDimension);
-    ListOfMolecules[i]->SetBoxDimension(&BoxDimension);  // update Box of atoms by boundary
-    int j = -1;
-    for (int k=0;k<NDIM;k++) {
-      j += k+1;
-      BoxDimension.x[k] = 2.5* (configuration->GetIsAngstroem() ? 1. : 1./AtomicLengthToAngstroem);
-      ListOfMolecules[i]->cell_size[j] += BoxDimension.x[k]*2.;
-    }
-    ListOfMolecules[i]->Translate(&BoxDimension);
-
-    // also calculate necessary orbitals
-    ListOfMolecules[i]->CountElements();  // this is a bugfix, atoms should should actually be added correctly to this fragment 
-    ListOfMolecules[i]->CalculateOrbitals(*configuration);
-    
-    // change path in config
-    //strcpy(PathBackup, configuration->configpath);
-    sprintf(FragmentName, "%s/%s%s/", PathBackup, FRAGMENTPREFIX, FragmentNumber);
-    configuration->SetDefaultPath(FragmentName);
-    
-    // and save as config
-    sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
-    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as config ...";
-    if ((intermediateResult = configuration->Save(FragmentName, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
-      *out << " done." << endl;
-    else
-      *out << " failed." << endl;
-    result = result && intermediateResult;
-
-    // restore old config
-    configuration->SetDefaultPath(PathBackup);
-
-
-    // and save as mpqc input file
-    sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
-    *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as mpqc input ...";
-    if ((intermediateResult = configuration->SaveMPQC(FragmentName, ListOfMolecules[i])))
-      *out << " done." << endl;
-    else
-      *out << " failed." << endl;
-       
-    result = result && intermediateResult;
-    //outputFragment.close();
-    //outputFragment.clear();
-    delete(FragmentNumber);
-    //Free((void **)&FragmentNumber, "MoleculeListClass::OutputConfigForListOfFragments: *FragmentNumber");
-  }
-  cout << " done." << endl;
-  
-  // printing final number
-  *out << "Final number of fragments: " << FragmentCounter << "." << endl;
-      
-  return result;
+        ofstream outputFragment;
+        char FragmentName[MAXSTRINGSIZE];
+        char PathBackup[MAXSTRINGSIZE];
+        bool result = true;
+        bool intermediateResult = true;
+        atom *Walker = NULL;
+        Vector BoxDimension;
+        char *FragmentNumber = NULL;
+        char *path = NULL;
+        int FragmentCounter = 0;
+        ofstream output;
+        
+        // store the fragments as config and as xyz
+        for(int i=0;i<NumberOfMolecules;i++) {
+                // save default path as it is changed for each fragment
+                path = configuration->GetDefaultPath();
+                if (path != NULL)
+                        strcpy(PathBackup, path);
+                else
+                        cerr << "OutputConfigForListOfFragments: NULL default path obtained from config!" << endl;
+
+                // correct periodic
+                ListOfMolecules[i]->ScanForPeriodicCorrection(out);
+
+                // output xyz file
+                FragmentNumber = FixedDigitNumber(NumberOfMolecules, FragmentCounter++);
+                sprintf(FragmentName, "%s/%s%s.conf.xyz", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+                outputFragment.open(FragmentName, ios::out);
+                *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as XYZ ...";
+                if ((intermediateResult = ListOfMolecules[i]->OutputXYZ(&outputFragment)))
+                        *out << " done." << endl;
+                else
+                        *out << " failed." << endl;
+                result = result && intermediateResult;
+                outputFragment.close();
+                outputFragment.clear();
+
+                // list atoms in fragment for debugging
+                *out << Verbose(2) << "Contained atoms: ";
+                Walker = ListOfMolecules[i]->start;
+                while (Walker->next != ListOfMolecules[i]->end) {
+                        Walker = Walker->next;
+                        *out << Walker->Name << " ";
+                }
+                *out << endl;
+                
+                // center on edge
+                ListOfMolecules[i]->CenterEdge(out, &BoxDimension);
+                ListOfMolecules[i]->SetBoxDimension(&BoxDimension);     // update Box of atoms by boundary
+                int j = -1;
+                for (int k=0;k<NDIM;k++) {
+                        j += k+1;
+                        BoxDimension.x[k] = 2.5* (configuration->GetIsAngstroem() ? 1. : 1./AtomicLengthToAngstroem);
+                        ListOfMolecules[i]->cell_size[j] += BoxDimension.x[k]*2.;
+                }
+                ListOfMolecules[i]->Translate(&BoxDimension);
+
+                // also calculate necessary orbitals
+                ListOfMolecules[i]->CountElements();    // this is a bugfix, atoms should should actually be added correctly to this fragment 
+                ListOfMolecules[i]->CalculateOrbitals(*configuration);
+                
+                // change path in config
+                //strcpy(PathBackup, configuration->configpath);
+                sprintf(FragmentName, "%s/%s%s/", PathBackup, FRAGMENTPREFIX, FragmentNumber);
+                configuration->SetDefaultPath(FragmentName);
+                
+                // and save as config
+                sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+                *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as config ...";
+                if ((intermediateResult = configuration->Save(FragmentName, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
+                        *out << " done." << endl;
+                else
+                        *out << " failed." << endl;
+                result = result && intermediateResult;
+
+                // restore old config
+                configuration->SetDefaultPath(PathBackup);
+
+
+                // and save as mpqc input file
+                sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+                *out << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter-1 << " as mpqc input ...";
+                if ((intermediateResult = configuration->SaveMPQC(FragmentName, ListOfMolecules[i])))
+                        *out << " done." << endl;
+                else
+                        *out << " failed." << endl;
+                         
+                result = result && intermediateResult;
+                //outputFragment.close();
+                //outputFragment.clear();
+                delete(FragmentNumber);
+                //Free((void **)&FragmentNumber, "MoleculeListClass::OutputConfigForListOfFragments: *FragmentNumber");
+        }
+        cout << " done." << endl;
+        
+        // printing final number
+        *out << "Final number of fragments: " << FragmentCounter << "." << endl;
+                        
+        return result;
 };
 
@@ -492 +492 @@
 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;
-  Leaf = NULL;
-  previous = PreviousLeaf;
-  if (previous != NULL) {
-    MoleculeLeafClass *Walker = previous->next;
-    previous->next = this;
-    next = Walker;
-  } else {
-    next = 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;
+        if (previous != NULL) {
+                MoleculeLeafClass *Walker = previous->next;
+                previous->next = this;
+                next = Walker;
+        } else {
+                next = NULL;
+        }
 };
 
@@ -512 +512 @@
 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
-//  }
-  // remove the leaf itself
-  if (Leaf != NULL) {
-    delete(Leaf);
-    Leaf = NULL;
-  }
-  // remove this Leaf from level list
-  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;
-  if (next != NULL) // are we last in list
-    next->previous = previous;
-  next = NULL;
-  previous = 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) {
+                delete(Leaf);
+                Leaf = NULL;
+        }
+        // remove this Leaf from level list
+        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;
+        if (next != NULL) // are we last in list
+                next->previous = previous;
+        next = NULL;
+        previous = NULL;
 };
 
@@ -550 +550 @@
 bool MoleculeLeafClass::AddLeaf(molecule *ptr, MoleculeLeafClass *Previous)
 {
-  return false;
+        return false;
 };
 
@@ -564 +564 @@
 bool MoleculeLeafClass::FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
 {
-  atom *Walker = NULL, *OtherWalker = NULL;
-  bond *Binder = NULL;
-  bool status = true;
-  int AtomNo;
-
-  *out << Verbose(1) << "Begin of FillBondStructureFromReference." << endl;
-  // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(out, ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
-    *out << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl;
-    return false;
-  }
-  
-  if (status) {
-    *out << Verbose(1) << "Creating adjacency list for subgraph " << this << "." << endl;
-    Walker = Leaf->start;
-    while (Walker->next != Leaf->end) {
-      Walker = Walker->next;
-      AtomNo = Walker->GetTrueFather()->nr;  // global id of the current walker
-      for(int i=0;i<reference->NumberOfBondsPerAtom[AtomNo];i++) { // go through father's bonds and copy them all
-        Binder = reference->ListOfBondsPerAtom[AtomNo][i];
-        OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->GetTrueFather())->nr];    // local copy of current bond partner of walker
-        if (OtherWalker != NULL) {
-          if (OtherWalker->nr > Walker->nr)
-          Leaf->AddBond(Walker, OtherWalker, Binder->BondDegree);
-        } else {
-          *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << Binder->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl;
-          status = false;
-        }
-      }
-    }
-    Leaf->CreateListOfBondsPerAtom(out);
-    FragmentCounter++;
-    if (next != NULL)
-      status = next->FillBondStructureFromReference(out, reference, FragmentCounter, ListOfLocalAtoms);
-    FragmentCounter--;
-  }
-  
-  if ((FreeList) && (ListOfLocalAtoms != NULL)) {
-    // free the index lookup list
-    Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
-    if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
-  }
-  FragmentCounter--;
-  *out << Verbose(1) << "End of FillBondStructureFromReference." << endl;
-  return status;
+        atom *Walker = NULL, *OtherWalker = NULL;
+        bond *Binder = NULL;
+        bool status = true;
+        int AtomNo;
+
+        *out << Verbose(1) << "Begin of FillBondStructureFromReference." << endl;
+        // fill ListOfLocalAtoms if NULL was given
+        if (!FillListOfLocalAtoms(out, ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+                *out << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl;
+                return false;
+        }
+        
+        if (status) {
+                *out << Verbose(1) << "Creating adjacency list for subgraph " << this << "." << endl;
+                Walker = Leaf->start;
+                while (Walker->next != Leaf->end) {
+                        Walker = Walker->next;
+                        AtomNo = Walker->GetTrueFather()->nr;   // global id of the current walker
+                        for(int i=0;i<reference->NumberOfBondsPerAtom[AtomNo];i++) { // go through father's bonds and copy them all
+                                Binder = reference->ListOfBondsPerAtom[AtomNo][i];
+                                OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->GetTrueFather())->nr];             // local copy of current bond partner of walker
+                                if (OtherWalker != NULL) {
+                                        if (OtherWalker->nr > Walker->nr)
+                                        Leaf->AddBond(Walker, OtherWalker, Binder->BondDegree);
+                                } else {
+                                        *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << Binder->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl;
+                                        status = false;
+                                }
+                        }
+                }
+                Leaf->CreateListOfBondsPerAtom(out);
+                FragmentCounter++;
+                if (next != NULL)
+                        status = next->FillBondStructureFromReference(out, reference, FragmentCounter, ListOfLocalAtoms);
+                FragmentCounter--;
+        }
+        
+        if ((FreeList) && (ListOfLocalAtoms != NULL)) {
+                // free the index lookup list
+                Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
+                if (FragmentCounter == 0) // first fragments frees the initial pointer to list
+                        Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+        }
+        FragmentCounter--;
+        *out << Verbose(1) << "End of FillBondStructureFromReference." << endl;
+        return status;
 };
 
@@ -622 +622 @@
 bool MoleculeLeafClass::FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
 {
-  atom *Walker = NULL, *Father = NULL;
-
-  if (RootStack != NULL) {
-    // find first root candidates 
-    if (&(RootStack[FragmentCounter]) != NULL) {
-      RootStack[FragmentCounter].clear();  
-      Walker = Leaf->start;
-      while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
-        Walker = Walker->next;
-        Father = Walker->GetTrueFather();
-        if (AtomMask[Father->nr]) // apply mask
-    #ifdef ADDHYDROGEN
-          if (Walker->type->Z != 1) // skip hydrogen
-    #endif
-            RootStack[FragmentCounter].push_front(Walker->nr);
-      }
-      if (next != NULL)
-        next->FillRootStackForSubgraphs(out, RootStack, AtomMask, ++FragmentCounter);
-    }  else {
-      *out << Verbose(1) << "Rootstack[" << FragmentCounter  << "] is NULL." << endl;
-      return false;
-    }
-    FragmentCounter--;
-    return true;
-  } else {
-    *out << Verbose(1) << "Rootstack is NULL." << endl;
-    return false;
-  }
+        atom *Walker = NULL, *Father = NULL;
+
+        if (RootStack != NULL) {
+                // find first root candidates 
+                if (&(RootStack[FragmentCounter]) != NULL) {
+                        RootStack[FragmentCounter].clear();     
+                        Walker = Leaf->start;
+                        while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
+                                Walker = Walker->next;
+                                Father = Walker->GetTrueFather();
+                                if (AtomMask[Father->nr]) // apply mask
+                #ifdef ADDHYDROGEN
+                                        if (Walker->type->Z != 1) // skip hydrogen
+                #endif
+                                                RootStack[FragmentCounter].push_front(Walker->nr);
+                        }
+                        if (next != NULL)
+                                next->FillRootStackForSubgraphs(out, RootStack, AtomMask, ++FragmentCounter);
+                }       else {
+                        *out << Verbose(1) << "Rootstack[" << FragmentCounter   << "] is NULL." << endl;
+                        return false;
+                }
+                FragmentCounter--;
+                return true;
+        } else {
+                *out << Verbose(1) << "Rootstack is NULL." << endl;
+                return false;
+        }
 };
 
@@ -662 +662 @@
 bool MoleculeLeafClass::FillListOfLocalAtoms(ofstream *out, atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList)
 {
-  bool status = true;
-  
-  int Counter = Count();
-  if (ListOfLocalAtoms == NULL) { // allocated initial pointer
-    // allocate and set each field to NULL
-    ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **)*Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
-    if (ListOfLocalAtoms != NULL) {
-      for (int i=Counter;i--;)
-        ListOfLocalAtoms[i] = NULL;
-      FreeList = FreeList && true;
-    } else
-      status = false;
-  }
-  
-  if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
-    status = status && CreateFatherLookupTable(out, Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
-    FreeList = FreeList && true;
-  }
-  
-  return status;
+        bool status = true;
+        
+        int Counter = Count();
+        if (ListOfLocalAtoms == NULL) { // allocated initial pointer
+                // allocate and set each field to NULL
+                ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **)*Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+                if (ListOfLocalAtoms != NULL) {
+                        for (int i=Counter;i--;)
+                                ListOfLocalAtoms[i] = NULL;
+                        FreeList = FreeList && true;
+                } else
+                        status = false;
+        }
+        
+        if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
+                status = status && CreateFatherLookupTable(out, Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+                FreeList = FreeList && true;
+        }
+        
+        return status;
 };
 
@@ -696 +696 @@
 bool MoleculeLeafClass::AssignKeySetsToFragment(ofstream *out, molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
 {
-  bool status = true;
-  int KeySetCounter = 0;
-  
-  *out << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl;
-  // fill ListOfLocalAtoms if NULL was given
-  if (!FillListOfLocalAtoms(out, ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
-    *out << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl;
-    return false;
-  }
-
-  // allocate fragment list
-  if (FragmentList == NULL) {
-    KeySetCounter = Count();
-    FragmentList = (Graph **) Malloc(sizeof(Graph *)*KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
-    for(int i=KeySetCounter;i--;)
-      FragmentList[i] = NULL;
-    KeySetCounter = 0;
-  }
-  
-  if ((KeySetList != NULL) && (KeySetList->size() != 0)) { // if there are some scanned keysets at all
-    // assign scanned keysets
-    if (FragmentList[FragmentCounter] == NULL)
-      FragmentList[FragmentCounter] = new Graph;
-    KeySet *TempSet = new KeySet;
-    for(Graph::iterator runner = KeySetList->begin();runner != KeySetList->end(); runner++) { // key sets contain global numbers!
-      if ( ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->nr] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
-        // translate keyset to local numbers
-        for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
-          TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->nr]->nr);
-        // insert into FragmentList
-        FragmentList[FragmentCounter]->insert(GraphPair (*TempSet, pair<int,double>(KeySetCounter++, (*runner).second.second)));
-      }
-      TempSet->clear();
-    }
-    delete(TempSet);
-    if (KeySetCounter == 0) {// if there are no keysets, delete the list
-      *out << Verbose(1) << "KeySetCounter is zero, deleting FragmentList." << endl;
-      delete(FragmentList[FragmentCounter]);
-    } else
-      *out << Verbose(1) << KeySetCounter << " keysets were assigned to subgraph " << FragmentCounter << "." << endl;
-    FragmentCounter++;
-    if (next != NULL)
-      next->AssignKeySetsToFragment(out, reference, KeySetList, ListOfLocalAtoms, FragmentList, FragmentCounter, FreeList);
-    FragmentCounter--;
-  } else
-    *out << Verbose(1) << "KeySetList is NULL or empty." << endl;
-  
-  if ((FreeList) && (ListOfLocalAtoms != NULL)) {
-    // free the index lookup list
-    Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::AssignKeySetsToFragment - **ListOfLocalAtoms[]");
-    if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::AssignKeySetsToFragment - ***ListOfLocalAtoms");
-  }
-  *out << Verbose(1) << "End of AssignKeySetsToFragment." << endl;
-  return status;
+        bool status = true;
+        int KeySetCounter = 0;
+        
+        *out << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl;
+        // fill ListOfLocalAtoms if NULL was given
+        if (!FillListOfLocalAtoms(out, ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+                *out << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl;
+                return false;
+        }
+
+        // allocate fragment list
+        if (FragmentList == NULL) {
+                KeySetCounter = Count();
+                FragmentList = (Graph **) Malloc(sizeof(Graph *)*KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+                for(int i=KeySetCounter;i--;)
+                        FragmentList[i] = NULL;
+                KeySetCounter = 0;
+        }
+        
+        if ((KeySetList != NULL) && (KeySetList->size() != 0)) { // if there are some scanned keysets at all
+                // assign scanned keysets
+                if (FragmentList[FragmentCounter] == NULL)
+                        FragmentList[FragmentCounter] = new Graph;
+                KeySet *TempSet = new KeySet;
+                for(Graph::iterator runner = KeySetList->begin();runner != KeySetList->end(); runner++) { // key sets contain global numbers!
+                        if ( ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->nr] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
+                                // translate keyset to local numbers
+                                for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
+                                        TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->nr]->nr);
+                                // insert into FragmentList
+                                FragmentList[FragmentCounter]->insert(GraphPair (*TempSet, pair<int,double>(KeySetCounter++, (*runner).second.second)));
+                        }
+                        TempSet->clear();
+                }
+                delete(TempSet);
+                if (KeySetCounter == 0) {// if there are no keysets, delete the list
+                        *out << Verbose(1) << "KeySetCounter is zero, deleting FragmentList." << endl;
+                        delete(FragmentList[FragmentCounter]);
+                } else
+                        *out << Verbose(1) << KeySetCounter << " keysets were assigned to subgraph " << FragmentCounter << "." << endl;
+                FragmentCounter++;
+                if (next != NULL)
+                        next->AssignKeySetsToFragment(out, reference, KeySetList, ListOfLocalAtoms, FragmentList, FragmentCounter, FreeList);
+                FragmentCounter--;
+        } else
+                *out << Verbose(1) << "KeySetList is NULL or empty." << endl;
+        
+        if ((FreeList) && (ListOfLocalAtoms != NULL)) {
+                // free the index lookup list
+                Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::AssignKeySetsToFragment - **ListOfLocalAtoms[]");
+                if (FragmentCounter == 0) // first fragments frees the initial pointer to list
+                        Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::AssignKeySetsToFragment - ***ListOfLocalAtoms");
+        }
+        *out << Verbose(1) << "End of AssignKeySetsToFragment." << endl;
+        return status;
 };
 
@@ -762 +762 @@
 void MoleculeLeafClass::TranslateIndicesToGlobalIDs(ofstream *out, Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph)
 {
-  *out << Verbose(1) << "Begin of TranslateIndicesToGlobalIDs." << endl;
-  KeySet *TempSet = new KeySet;
-  if (FragmentList[FragmentCounter] != NULL) {
-    for(Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
-      for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
-        TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->nr);
-      TotalGraph.insert(GraphPair(*TempSet, pair<int,double>(TotalNumberOfKeySets++, (*runner).second.second)));
-      TempSet->clear();
-    }
-    delete(TempSet);
-  } else {
-    *out << Verbose(1) << "FragmentList is NULL." << endl;
-  }
-  if (next != NULL)
-    next->TranslateIndicesToGlobalIDs(out, FragmentList, ++FragmentCounter, TotalNumberOfKeySets, TotalGraph);
-  FragmentCounter--;
-  *out << Verbose(1) << "End of TranslateIndicesToGlobalIDs." << endl;
+        *out << Verbose(1) << "Begin of TranslateIndicesToGlobalIDs." << endl;
+        KeySet *TempSet = new KeySet;
+        if (FragmentList[FragmentCounter] != NULL) {
+                for(Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
+                        for(KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
+                                TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->nr);
+                        TotalGraph.insert(GraphPair(*TempSet, pair<int,double>(TotalNumberOfKeySets++, (*runner).second.second)));
+                        TempSet->clear();
+                }
+                delete(TempSet);
+        } else {
+                *out << Verbose(1) << "FragmentList is NULL." << endl;
+        }
+        if (next != NULL)
+                next->TranslateIndicesToGlobalIDs(out, FragmentList, ++FragmentCounter, TotalNumberOfKeySets, TotalGraph);
+        FragmentCounter--;
+        *out << Verbose(1) << "End of TranslateIndicesToGlobalIDs." << endl;
 };
 
@@ -786 +786 @@
 int MoleculeLeafClass::Count() const
 {
-  if (next != NULL)
-    return next->Count()+1;
-  else
-    return 1; 
-};
+        if (next != NULL)
+                return next->Count()+1;
+        else
+                return 1; 
+};

src/molecules.cpp

@@ -16 +16 @@
 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;
 };
 
@@ -36 +36 @@
 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;
+        // 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.;
+        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.;
 };
 
@@ -69 +69 @@
 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);
 };
 
@@ -88 +88 @@
 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;
 };
 
@@ -116 +116 @@
 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;
 };
 
@@ -141 +141 @@
  * -# 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
@@ -167 +167 @@
  * \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
@@ -174 +174 @@
 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;
+        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;
-  }
+        // 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;
+        return AllWentWell;
 };
 
@@ -438 +438 @@
 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;
 };
 
@@ -499 +499 @@
 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;
 };
 
@@ -563 +563 @@
 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;
 };
 
@@ -582 +582 @@
 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;
 };
 
@@ -594 +594 @@
 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;
 };
 
@@ -603 +603 @@
 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];
 };
 
@@ -617 +617 @@
 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);
-    Translate(max);
-  }
-
-  // free and exit
-  delete(min);
-  delete(max);
-  return status;
+        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);
+        }
+
+        // free and exit
+        delete(min);
+        delete(max);
+        return status;
 };
 
@@ -666 +666 @@
 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);
-  }
-  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);
+        }
+        delete(min);
+//      *out << Verbose(3) << "End of CenterEdge." << endl;
 };
 
@@ -702 +702 @@
 void molecule::CenterOrigin(ofstream *out, Vector *center)
 {
-  int Num = 0;
-  atom *ptr = start->next;  // start at first in list
-
-  for(int i=NDIM;i--;) // zero center vector
-    center->x[i] = 0.;
-
-  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);
-  }
+        int Num = 0;
+        atom *ptr = start->next;        // start at first in list
+
+        for(int i=NDIM;i--;) // zero center vector
+                center->x[i] = 0.;
+
+        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);
+        }
 };
 
@@ -725 +725 @@
 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;
 };
 
@@ -753 +753 @@
 Vector * molecule::DetermineCenterOfGravity(ofstream *out)
 {
-        atom *ptr = start->next;  // start at first in list
+        atom *ptr = start->next;        // start at first in list
         Vector *a = new Vector();
         Vector tmp;
-  double Num = 0;
+        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;
+        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;
 };
 
@@ -782 +782 @@
 void molecule::CenterGravity(ofstream *out, Vector *center)
 {
-  if (center == NULL) {
-    DetermineCenter(*center);
-    Translate(center);
-    delete(center);
-  } else {
-    Translate(center);
-  }
+        if (center == NULL) {
+                DetermineCenter(*center);
+                Translate(center);
+                delete(center);
+        } else {
+                Translate(center);
+        }
 };
 
@@ -796 +796 @@
 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);
+        }
 };
 
@@ -811 +811 @@
 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);
+        }
 };
 
@@ -826 +826 @@
 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);
+        }
 };
 
@@ -841 +841 @@
 void molecule::DetermineCenter(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);
 };
 
@@ -909 +909 @@
 void molecule::PrincipalAxisSystem(ofstream *out, bool DoRotate)
 {
-        atom *ptr = start;  // start at first in list
+        atom *ptr = start;      // start at first in list
         double InertiaTensor[NDIM*NDIM];
         Vector *CenterOfGravity = DetermineCenterOfGravity(out);
@@ -938 +938 @@
         *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;
+                for(int j=0;j<NDIM;j++)
+                        *out << InertiaTensor[i*NDIM+j] << " ";
+                *out << endl;
         }
         *out << endl;
@@ -960 +960 @@
         // 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;
+                *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;
         }
 
@@ -1020 +1020 @@
 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;
 };
 
@@ -1131 +1131 @@
 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;
 };
 
@@ -1193 +1193 @@
 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);
 };
 
@@ -1208 +1208 @@
 bool molecule::CleanupMolecule()
 {
-  return (cleanup(start,end) && cleanup(first,last));
+        return (cleanup(start,end) && cleanup(first,last));
 };
 
@@ -1215 +1215 @@
  * \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;
+        }
 };
 
@@ -1231 +1231 @@
 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;
 };
 
@@ -1250 +1250 @@
 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
 };
 
@@ -1267 +1267 @@
 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;
 };
 
@@ -1300 +1300 @@
 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);
 };
 
@@ -1374 +1374 @@
 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;
+        }
 };
 
@@ -1409 +1409 @@
 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;
+        }
 };
 
@@ -1457 +1457 @@
 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;
 };
 
@@ -1478 +1478 @@
  * \param *out stream pointer
  */
-bool molecule::Checkout(ofstream *out)  const
+bool molecule::Checkout(ofstream *out)  const
 {
         return elemente->Checkout(out, ElementsInMolecule);
@@ -1488 +1488 @@
 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;
 };
 
@@ -1517 +1517 @@
 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;
 };
 
@@ -1557 +1557 @@
         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;
-  }
+        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;
+        }
 };
 
@@ -1591 +1591 @@
 {
         int i = 0;
-  for(i=MAX_ELEMENTS;i--;)
-        ElementsInMolecule[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);
+        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);
 };
 
@@ -1612 +1612 @@
 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.
@@ -1641 +1641 @@
 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;
+        };
 };
 
@@ -1666 +1666 @@
 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;
 };
 
@@ -1697 +1697 @@
                         atom *Walker, *OtherWalker;
 
-                if (!input)
-                {
-                        cout << Verbose(1) << "Opening silica failed \n";
-                };
+                                        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
-                {
+                                        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);
+                                                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);
 
 };
@@ -1741 +1741 @@
  * 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)
@@ -1756 +1756 @@
 {
 
-  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.PeriodicDistance(&(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.PeriodicDistance(&(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(0) << "Adding Bond between " << *Walker << " and " << *OtherWalker << "." << endl;
-                          AddBond(Walker->father, OtherWalker->father, 1);  // also increases molecule::BondCount
-                          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.
+        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);
+                        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 << 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");
+                }
+                *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");
 
 };
@@ -1951 +1950 @@
 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;
 };
 
@@ -2143 +2142 @@
  * \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);
 };
 
@@ -2351 +2350 @@
 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;
 };
 
@@ -2372 +2371 @@
 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] << "     ";
 };
 
@@ -2380 +2379 @@
 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;
+        }
 };
 
@@ -2397 +2396 @@
 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;
 };
 
@@ -2408 +2407 @@
 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();
+        }
 };
 
@@ -2419 +2418 @@
 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;
+        }
 };
 
@@ -2432 +2431 @@
 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;
 };
 
@@ -2440 +2439 @@
  * 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.
@@ -2449 +2448 @@
 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;
 };
 
@@ -2470 +2469 @@
 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);
 };
 
@@ -2502 +2501 @@
 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;
-        }
-        //FragmentList->ListOfMolecules[NumberOfFragments++] = StoreFragmentFromKeySet(out, CurrentSet, IsAngstroem);
-      }
-    }
-    // 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;
+                                }
+                                //FragmentList->ListOfMolecules[NumberOfFragments++] = StoreFragmentFromKeySet(out, CurrentSet, IsAngstroem);
+                        }
+                }
+                // 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;
 };
 
@@ -2582 +2581 @@
 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;
 };
 
@@ -2638 +2637 @@
 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;
 };
 
@@ -2673 +2672 @@
 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;
 };
 
@@ -2751 +2750 @@
 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;
 };
 
@@ -2914 +2913 @@
 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;
 };
 
@@ -2945 +2944 @@
 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
@@ -2960 +2959 @@
 {
         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;
+        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(TotalGraph.size(), AtomCount);
-    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->ListOfMolecules[k] = StoreFragmentFromKeySet(out, test, configuration);
-      k++;
-    }
-    *out << k << "/" << BondFragments->NumberOfMolecules << " fragments generated from the keysets." << endl;
-
-    // ===== 9. Save fragments' configuration and keyset files et al to disk ===
-    if (BondFragments->NumberOfMolecules != 0) {
-      // create the SortIndex from BFS labels to order in the config file
-      CreateMappingLabelsToConfigSequence(out, SortIndex);
-
-      *out << Verbose(1) << "Writing " << BondFragments->NumberOfMolecules << " 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(TotalGraph.size(), AtomCount);
+                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->ListOfMolecules[k] = StoreFragmentFromKeySet(out, test, configuration);
+                        k++;
+                }
+                *out << k << "/" << BondFragments->NumberOfMolecules << " fragments generated from the keysets." << endl;
+
+                // ===== 9. Save fragments' configuration and keyset files et al to disk ===
+                if (BondFragments->NumberOfMolecules != 0) {
+                        // create the SortIndex from BFS labels to order in the config file
+                        CreateMappingLabelsToConfigSequence(out, SortIndex);
+
+                        *out << Verbose(1) << "Writing " << BondFragments->NumberOfMolecules << " 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)
 };
 
@@ -3151 +3150 @@
 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]);
+        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
+                                        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;
+                ReferenceStack->Push(Binder);
+        } while (FirstBond != Binder);
+
+        return status;
 };
 
@@ -3188 +3187 @@
 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;
+        }
 };
 
@@ -3219 +3218 @@
 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;
 };
 
@@ -3276 +3275 @@
 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;
 };
 
@@ -3347 +3346 @@
 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);
 };
 
@@ -3471 +3470 @@
 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;
 };
 
@@ -3526 +3525 @@
 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;
 };
 
@@ -3554 +3553 @@
 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;
 };
 
@@ -3646 +3645 @@
 MoleculeListClass * molecule::CreateListOfUniqueFragmentsOfOrder(ofstream *out, int Order, config *configuration)
 {
-  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
-  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
-  int *Labels = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
-  enum Shading *ColorVertexList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
-  enum Shading *ColorEdgeList = (enum Shading *) Malloc(sizeof(enum Shading)*BondCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorBondList");
-  StackClass<atom *> *RootStack = new StackClass<atom *>(AtomCount);
-  StackClass<atom *> *TouchedStack = new StackClass<atom *>((int)pow(4,Order)+2); // number of atoms reached from one with maximal 4 bonds plus Root itself
-  StackClass<atom *> *SnakeStack = new StackClass<atom *>(Order+1); // equal to Order is not possible, as then the StackClass<atom *> cannot discern between full and empty stack!
-  MoleculeLeafClass *Leaflet = NULL, *TempLeaf = NULL;
-  MoleculeListClass *FragmentList = NULL;
-  atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL, *Removal = NULL;
-  bond *Binder = NULL;
-  int RunningIndex = 0, FragmentCounter = 0;
-
-  *out << Verbose(1) << "Begin of CreateListOfUniqueFragmentsOfOrder." << endl;
-
-  // reset parent list
-  *out << Verbose(3) << "Resetting labels, parent, predecessor, color and shortest path lists." << endl;
-  for (int i=0;i<AtomCount;i++) { // reset all atom labels
-    // initialise each vertex as white with no predecessor, empty queue, color lightgray, not labelled, no sons
+        atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+        int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+        int *Labels = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+        enum Shading *ColorVertexList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+        enum Shading *ColorEdgeList = (enum Shading *) Malloc(sizeof(enum Shading)*BondCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorBondList");
+        StackClass<atom *> *RootStack = new StackClass<atom *>(AtomCount);
+        StackClass<atom *> *TouchedStack = new StackClass<atom *>((int)pow(4,Order)+2); // number of atoms reached from one with maximal 4 bonds plus Root itself
+        StackClass<atom *> *SnakeStack = new StackClass<atom *>(Order+1); // equal to Order is not possible, as then the StackClass<atom *> cannot discern between full and empty stack!
+        MoleculeLeafClass *Leaflet = NULL, *TempLeaf = NULL;
+        MoleculeListClass *FragmentList = NULL;
+        atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL, *Removal = NULL;
+        bond *Binder = NULL;
+        int RunningIndex = 0, FragmentCounter = 0;
+
+        *out << Verbose(1) << "Begin of CreateListOfUniqueFragmentsOfOrder." << endl;
+
+        // reset parent list
+        *out << Verbose(3) << "Resetting labels, parent, predecessor, color and shortest path lists." << endl;
+        for (int i=0;i<AtomCount;i++) { // reset all atom labels
+                // initialise each vertex as white with no predecessor, empty queue, color lightgray, not labelled, no sons
                 Labels[i] = -1;
-    SonList[i] = NULL;
-    PredecessorList[i] = NULL;
-    ColorVertexList[i] = white;
-    ShortestPathList[i] = -1;
-  }
-  for (int i=0;i<BondCount;i++)
-    ColorEdgeList[i] = white;
+                SonList[i] = NULL;
+                PredecessorList[i] = NULL;
+                ColorVertexList[i] = white;
+                ShortestPathList[i] = -1;
+        }
+        for (int i=0;i<BondCount;i++)
+                ColorEdgeList[i] = white;
         RootStack->ClearStack();        // clearstack and push first atom if exists
-  TouchedStack->ClearStack();
-  Walker = start->next;
-  while ((Walker != end)
+        TouchedStack->ClearStack();
+        Walker = start->next;
+        while ((Walker != end)
 #ifdef ADDHYDROGEN
-   && (Walker->type->Z == 1)
+         && (Walker->type->Z == 1)
 #endif
-                        ) { // search for first non-hydrogen atom
-    *out << Verbose(4) << "Current Root candidate is " << Walker->Name << "." << endl;
-    Walker = Walker->next;
-  }
-  if (Walker != end)
-    RootStack->Push(Walker);
-  else
-    *out << Verbose(0) << "ERROR: Could not find an appropriate Root atom!" << endl;
-  *out << Verbose(3) << "Root " << Walker->Name << " is on AtomStack, beginning loop through all vertices ..." << endl;
-
-  ///// OUTER LOOP ////////////
-  while (!RootStack->IsEmpty()) {
-        // get new root vertex from atom stack
-        Root = RootStack->PopFirst();
-    ShortestPathList[Root->nr] = 0;
-    if (Labels[Root->nr] == -1)
-      Labels[Root->nr] = RunningIndex++; // prevent it from getting again on AtomStack
-    PredecessorList[Root->nr] = Root;
-    TouchedStack->Push(Root);
-    *out << Verbose(0) << "Root for this loop is: " << Root->Name << ".\n";
+                                                                                                ) { // search for first non-hydrogen atom
+                *out << Verbose(4) << "Current Root candidate is " << Walker->Name << "." << endl;
+                Walker = Walker->next;
+        }
+        if (Walker != end)
+                RootStack->Push(Walker);
+        else
+                *out << Verbose(0) << "ERROR: Could not find an appropriate Root atom!" << endl;
+        *out << Verbose(3) << "Root " << Walker->Name << " is on AtomStack, beginning loop through all vertices ..." << endl;
+
+        ///// OUTER LOOP ////////////
+        while (!RootStack->IsEmpty()) {
+                // get new root vertex from atom stack
+                Root = RootStack->PopFirst();
+                ShortestPathList[Root->nr] = 0;
+                if (Labels[Root->nr] == -1)
+                        Labels[Root->nr] = RunningIndex++; // prevent it from getting again on AtomStack
+                PredecessorList[Root->nr] = Root;
+                TouchedStack->Push(Root);
+                *out << Verbose(0) << "Root for this loop is: " << Root->Name << ".\n";
 
                 // clear snake stack
-          SnakeStack->ClearStack();
-    //SnakeStack->TestImplementation(out, start->next);
-
-    ///// INNER LOOP ////////////
-    // Problems:
-    // - what about cyclic bonds?
-    Walker = Root;
-        do {
-      *out << Verbose(1) << "Current Walker is: " << Walker->Name;
-      // initial setting of the new Walker: label, color, shortest path and put on stacks
-                if (Labels[Walker->nr] == -1)   {       // give atom a unique, monotonely increasing number
-                        Labels[Walker->nr] = RunningIndex++;
-        RootStack->Push(Walker);
-      }
-      *out << ", has label " << Labels[Walker->nr];
-                if ((ColorVertexList[Walker->nr] == white) || ((Binder != NULL) && (ColorEdgeList[Binder->nr] == white))) {     // color it if newly discovered and push on stacks (and if within reach!)
-        if ((Binder != NULL) && (ColorEdgeList[Binder->nr] == white)) {
-          // Binder ought to be set still from last neighbour search
-          *out << ", coloring bond " << *Binder << " black";
-          ColorEdgeList[Binder->nr] = black; // mark this bond as used
-        }
-        if (ShortestPathList[Walker->nr] == -1) {
-          ShortestPathList[Walker->nr] = ShortestPathList[PredecessorList[Walker->nr]->nr]+1;
-          TouchedStack->Push(Walker); // mark every atom for lists cleanup later, whose shortest path has been changed
-        }
-        if ((ShortestPathList[Walker->nr] < Order) && (ColorVertexList[Walker->nr] != darkgray)) {  // if not already on snake stack
-          SnakeStack->Push(Walker);
-          ColorVertexList[Walker->nr] = darkgray; // mark as dark gray of on snake stack
-        }
-                }
-      *out << ", SP of " << ShortestPathList[Walker->nr]  << " and its color is " << GetColor(ColorVertexList[Walker->nr]) << "." << endl;
-
-      // then check the stack for a newly stumbled upon fragment
-                if (SnakeStack->ItemCount() == Order) { // is stack full?
-        // store the fragment if it is one and get a removal candidate
-        Removal = StoreFragmentFromStack(out, Root, Walker, Leaflet, SnakeStack, ShortestPathList, SonList, Labels, &FragmentCounter, configuration);
-        // remove the candidate if one was found
-        if (Removal != NULL) {
-          *out << Verbose(2) << "Removing item " << Removal->Name << " with SP of " << ShortestPathList[Removal->nr] << " from snake stack." << endl;
-          SnakeStack->RemoveItem(Removal);
-          ColorVertexList[Removal->nr] = lightgray; // return back to not on snake stack but explored marking
-          if (Walker == Removal) { // if the current atom is to be removed, we also have to take a step back
-            Walker = PredecessorList[Removal->nr];
-            *out << Verbose(2) << "Stepping back to " << Walker->Name << "." << endl;
-          }
-        }
-                } else
-        Removal = NULL;
-
-      // finally, look for a white neighbour as the next Walker
-      Binder = NULL;
-      if ((Removal == NULL) || (Walker != PredecessorList[Removal->nr])) {  // don't look, if a new walker has been set above
-        *out << Verbose(2) << "Snake has currently " << SnakeStack->ItemCount() << " item(s)." << endl;
-                        OtherAtom = NULL; // this is actually not needed, every atom has at least one neighbour
-        if (ShortestPathList[Walker->nr] < Order) {
-                        for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
-            Binder = ListOfBondsPerAtom[Walker->nr][i];
-            *out << Verbose(2) << "Current bond is " << *Binder << ": ";
-                                OtherAtom = Binder->GetOtherAtom(Walker);
-            if ((Labels[OtherAtom->nr] != -1) && (Labels[OtherAtom->nr] < Labels[Root->nr])) { // we don't step up to labels bigger than us
-              *out << "Label " << Labels[OtherAtom->nr] << " is smaller than Root's " << Labels[Root->nr] << "." << endl;
-              //ColorVertexList[OtherAtom->nr] = lightgray;    // mark as explored
-            } else { // otherwise check its colour and element
-                                if (
+                SnakeStack->ClearStack();
+                //SnakeStack->TestImplementation(out, start->next);
+
+                ///// INNER LOOP ////////////
+                // Problems:
+                // - what about cyclic bonds?
+                Walker = Root;
+                do {
+                        *out << Verbose(1) << "Current Walker is: " << Walker->Name;
+                        // initial setting of the new Walker: label, color, shortest path and put on stacks
+                        if (Labels[Walker->nr] == -1)   {       // give atom a unique, monotonely increasing number
+                                Labels[Walker->nr] = RunningIndex++;
+                                RootStack->Push(Walker);
+                        }
+                        *out << ", has label " << Labels[Walker->nr];
+                        if ((ColorVertexList[Walker->nr] == white) || ((Binder != NULL) && (ColorEdgeList[Binder->nr] == white))) {     // color it if newly discovered and push on stacks (and if within reach!)
+                                if ((Binder != NULL) && (ColorEdgeList[Binder->nr] == white)) {
+                                        // Binder ought to be set still from last neighbour search
+                                        *out << ", coloring bond " << *Binder << " black";
+                                        ColorEdgeList[Binder->nr] = black; // mark this bond as used
+                                }
+                                if (ShortestPathList[Walker->nr] == -1) {
+                                        ShortestPathList[Walker->nr] = ShortestPathList[PredecessorList[Walker->nr]->nr]+1;
+                                        TouchedStack->Push(Walker); // mark every atom for lists cleanup later, whose shortest path has been changed
+                                }
+                                if ((ShortestPathList[Walker->nr] < Order) && (ColorVertexList[Walker->nr] != darkgray)) {      // if not already on snake stack
+                                        SnakeStack->Push(Walker);
+                                        ColorVertexList[Walker->nr] = darkgray; // mark as dark gray of on snake stack
+                                }
+                        }
+                        *out << ", SP of " << ShortestPathList[Walker->nr]      << " and its color is " << GetColor(ColorVertexList[Walker->nr]) << "." << endl;
+
+                        // then check the stack for a newly stumbled upon fragment
+                        if (SnakeStack->ItemCount() == Order) { // is stack full?
+                                // store the fragment if it is one and get a removal candidate
+                                Removal = StoreFragmentFromStack(out, Root, Walker, Leaflet, SnakeStack, ShortestPathList, SonList, Labels, &FragmentCounter, configuration);
+                                // remove the candidate if one was found
+                                if (Removal != NULL) {
+                                        *out << Verbose(2) << "Removing item " << Removal->Name << " with SP of " << ShortestPathList[Removal->nr] << " from snake stack." << endl;
+                                        SnakeStack->RemoveItem(Removal);
+                                        ColorVertexList[Removal->nr] = lightgray; // return back to not on snake stack but explored marking
+                                        if (Walker == Removal) { // if the current atom is to be removed, we also have to take a step back
+                                                Walker = PredecessorList[Removal->nr];
+                                                *out << Verbose(2) << "Stepping back to " << Walker->Name << "." << endl;
+                                        }
+                                }
+                        } else
+                                Removal = NULL;
+
+                        // finally, look for a white neighbour as the next Walker
+                        Binder = NULL;
+                        if ((Removal == NULL) || (Walker != PredecessorList[Removal->nr])) {    // don't look, if a new walker has been set above
+                                *out << Verbose(2) << "Snake has currently " << SnakeStack->ItemCount() << " item(s)." << endl;
+                                OtherAtom = NULL; // this is actually not needed, every atom has at least one neighbour
+                                if (ShortestPathList[Walker->nr] < Order) {
+                                        for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
+                                                Binder = ListOfBondsPerAtom[Walker->nr][i];
+                                                *out << Verbose(2) << "Current bond is " << *Binder << ": ";
+                                                OtherAtom = Binder->GetOtherAtom(Walker);
+                                                if ((Labels[OtherAtom->nr] != -1) && (Labels[OtherAtom->nr] < Labels[Root->nr])) { // we don't step up to labels bigger than us
+                                                        *out << "Label " << Labels[OtherAtom->nr] << " is smaller than Root's " << Labels[Root->nr] << "." << endl;
+                                                        //ColorVertexList[OtherAtom->nr] = lightgray;           // mark as explored
+                                                } else { // otherwise check its colour and element
+                                                        if (
 #ifdef ADDHYDROGEN
-              (OtherAtom->type->Z != 1) &&
+                                                        (OtherAtom->type->Z != 1) &&
 #endif
-                    (ColorEdgeList[Binder->nr] == white)) {  // skip hydrogen, look for unexplored vertices
-                *out << "Moving along " << GetColor(ColorEdgeList[Binder->nr]) << " bond " << Binder << " to " << ((ColorVertexList[OtherAtom->nr] == white) ? "unexplored" : "explored") << " item: " << OtherAtom->Name << "." << endl;
-                // i find it currently rather sensible to always set the predecessor in order to find one's way back
-                //if (PredecessorList[OtherAtom->nr] == NULL) {
-                PredecessorList[OtherAtom->nr] = Walker;
-                *out << Verbose(3) << "Setting Predecessor of " << OtherAtom->Name << " to " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
-                //} else {
-                //  *out << Verbose(3) << "Predecessor of " << OtherAtom->Name << " is " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
-                //}
-                Walker = OtherAtom;
-                break;
-              } else {
-                if (OtherAtom->type->Z == 1)
-                  *out << "Links to a hydrogen atom." << endl;
-                else
-                  *out << "Bond has not white but " << GetColor(ColorEdgeList[Binder->nr]) << " color." << endl;
-              }
-            }
-                        }
-        } else {  // means we have stepped beyond the horizon: Return!
-          Walker = PredecessorList[Walker->nr];
-          OtherAtom = Walker;
-          *out << Verbose(3) << "We have gone too far, stepping back to " << Walker->Name << "." << endl;
-        }
-                        if (Walker != OtherAtom) {      // if no white neighbours anymore, color it black
-          *out << Verbose(2) << "Coloring " << Walker->Name << " black." << endl;
-                                ColorVertexList[Walker->nr] = black;
-                                Walker = PredecessorList[Walker->nr];
-                        }
-      }
-        } while ((Walker != Root) || (ColorVertexList[Root->nr] != black));
-    *out << Verbose(2) << "Inner Looping is finished." << endl;
-
-    // if we reset all AtomCount atoms, we have again technically O(N^2) ...
-    *out << Verbose(2) << "Resetting lists." << endl;
-    Walker = NULL;
-    Binder = NULL;
-    while (!TouchedStack->IsEmpty()) {
-      Walker = TouchedStack->PopLast();
-      *out << Verbose(3) << "Re-initialising entries of " << *Walker << "." << endl;
-      for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
-        ColorEdgeList[ListOfBondsPerAtom[Walker->nr][i]->nr] = white;
-      PredecessorList[Walker->nr] = NULL;
-      ColorVertexList[Walker->nr] = white;
-      ShortestPathList[Walker->nr] = -1;
-    }
-  }
-  *out << Verbose(1) << "Outer Looping over all vertices is done." << endl;
-
-  // copy together
-  *out << Verbose(1) << "Copying all fragments into MoleculeList structure." << endl;
-  FragmentList = new MoleculeListClass(FragmentCounter, AtomCount);
-  RunningIndex = 0;
-  while ((Leaflet != NULL) && (RunningIndex < FragmentCounter))  {
-    FragmentList->ListOfMolecules[RunningIndex++] = Leaflet->Leaf;
-    Leaflet->Leaf = NULL; // prevent molecule from being removed
-    TempLeaf = Leaflet;
-    Leaflet = Leaflet->previous;
-    delete(TempLeaf);
-  };
-
-  // free memory and exit
-  Free((void **)&PredecessorList, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
-  Free((void **)&ShortestPathList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
-  Free((void **)&Labels, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
-  Free((void **)&ColorVertexList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
-  delete(RootStack);
-  delete(TouchedStack);
-  delete(SnakeStack);
-
-  *out << Verbose(1) << "End of CreateListOfUniqueFragmentsOfOrder." << endl;
-  return FragmentList;
+                                                                                (ColorEdgeList[Binder->nr] == white)) { // skip hydrogen, look for unexplored vertices
+                                                                *out << "Moving along " << GetColor(ColorEdgeList[Binder->nr]) << " bond " << Binder << " to " << ((ColorVertexList[OtherAtom->nr] == white) ? "unexplored" : "explored") << " item: " << OtherAtom->Name << "." << endl;
+                                                                // i find it currently rather sensible to always set the predecessor in order to find one's way back
+                                                                //if (PredecessorList[OtherAtom->nr] == NULL) {
+                                                                PredecessorList[OtherAtom->nr] = Walker;
+                                                                *out << Verbose(3) << "Setting Predecessor of " << OtherAtom->Name << " to " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
+                                                                //} else {
+                                                                //      *out << Verbose(3) << "Predecessor of " << OtherAtom->Name << " is " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
+                                                                //}
+                                                                Walker = OtherAtom;
+                                                                break;
+                                                        } else {
+                                                                if (OtherAtom->type->Z == 1)
+                                                                        *out << "Links to a hydrogen atom." << endl;
+                                                                else
+                                                                        *out << "Bond has not white but " << GetColor(ColorEdgeList[Binder->nr]) << " color." << endl;
+                                                        }
+                                                }
+                                        }
+                                } else {        // means we have stepped beyond the horizon: Return!
+                                        Walker = PredecessorList[Walker->nr];
+                                        OtherAtom = Walker;
+                                        *out << Verbose(3) << "We have gone too far, stepping back to " << Walker->Name << "." << endl;
+                                }
+                                if (Walker != OtherAtom) {      // if no white neighbours anymore, color it black
+                                        *out << Verbose(2) << "Coloring " << Walker->Name << " black." << endl;
+                                        ColorVertexList[Walker->nr] = black;
+                                        Walker = PredecessorList[Walker->nr];
+                                }
+                        }
+                } while ((Walker != Root) || (ColorVertexList[Root->nr] != black));
+                *out << Verbose(2) << "Inner Looping is finished." << endl;
+
+                // if we reset all AtomCount atoms, we have again technically O(N^2) ...
+                *out << Verbose(2) << "Resetting lists." << endl;
+                Walker = NULL;
+                Binder = NULL;
+                while (!TouchedStack->IsEmpty()) {
+                        Walker = TouchedStack->PopLast();
+                        *out << Verbose(3) << "Re-initialising entries of " << *Walker << "." << endl;
+                        for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++)
+                                ColorEdgeList[ListOfBondsPerAtom[Walker->nr][i]->nr] = white;
+                        PredecessorList[Walker->nr] = NULL;
+                        ColorVertexList[Walker->nr] = white;
+                        ShortestPathList[Walker->nr] = -1;
+                }
+        }
+        *out << Verbose(1) << "Outer Looping over all vertices is done." << endl;
+
+        // copy together
+        *out << Verbose(1) << "Copying all fragments into MoleculeList structure." << endl;
+        FragmentList = new MoleculeListClass(FragmentCounter, AtomCount);
+        RunningIndex = 0;
+        while ((Leaflet != NULL) && (RunningIndex < FragmentCounter))   {
+                FragmentList->ListOfMolecules[RunningIndex++] = Leaflet->Leaf;
+                Leaflet->Leaf = NULL; // prevent molecule from being removed
+                TempLeaf = Leaflet;
+                Leaflet = Leaflet->previous;
+                delete(TempLeaf);
+        };
+
+        // free memory and exit
+        Free((void **)&PredecessorList, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+        Free((void **)&ShortestPathList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+        Free((void **)&Labels, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+        Free((void **)&ColorVertexList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+        delete(RootStack);
+        delete(TouchedStack);
+        delete(SnakeStack);
+
+        *out << Verbose(1) << "End of CreateListOfUniqueFragmentsOfOrder." << endl;
+        return FragmentList;
 };
 */
@@ -3848 +3847 @@
  */
 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
@@ -3878 +3877 @@
 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;
 };
 
@@ -4012 +4011 @@
 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;
 }
 
@@ -4071 +4070 @@
 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);
 };
 
@@ -4223 +4222 @@
 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;
 };
 
@@ -4309 +4308 @@
 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);
 //};
 
@@ -4361 +4360 @@
 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);
 //};
 
@@ -4390 +4389 @@
 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;
+                }
+        }
 };
 
@@ -4408 +4407 @@
  * -# 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
@@ -4424 +4423 @@
 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;
 };
 
@@ -4614 +4613 @@
 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;
 };
 
@@ -4630 +4629 @@
 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;
-    DetermineCenter(CenterOfGravity);
-    OtherMolecule->DetermineCenter(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.Distance(&OtherCenterOfGravity) > 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.Distance(&Walker->x);
-    }
-    Walker = OtherMolecule->start;
-    while (Walker->next != OtherMolecule->end) {
-      Walker = Walker->next;
-      OtherDistances[Walker->nr] = OtherCenterOfGravity.Distance(&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: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl;
-      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > 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;
+                DetermineCenter(CenterOfGravity);
+                OtherMolecule->DetermineCenter(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;
+        }
 };
 
@@ -4755 +4754 @@
 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;
 };
 
@@ -4801 +4800 @@
 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

@@ -60 +60 @@
 #define LineMap map < int, class BoundaryLineSet * >
 #define LinePair pair < int, class BoundaryLineSet * >
-#define LineTestPair pair < LinePair::iterator, bool >
+#define LineTestPair pair < LineMap::iterator, bool >
 
 #define TriangleMap map < int, class BoundaryTriangleSet * >
@@ -73 +73 @@
 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);
 
@@ -94 +94 @@
 
 // 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
 
 
@@ -101 +101 @@
  */
 struct LSQ_params {
-  Vector **vectors;
-  int num;
+        Vector **vectors;
+        int num;
 };
 
@@ -110 +110 @@
  */
 struct lsq_params {
-  gsl_vector *x;
-  const molecule *mol;
-  element *type;
-};
-
-
+        gsl_vector *x;
+        const molecule *mol;
+        element *type;
+};
 
 /** Single atom.
@@ -121 +119 @@
  */
 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;
-  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;
+        bool OutputXYZLine(ofstream *out) const;
+        atom *GetTrueFather();
+        bool Compare(atom &ptr);
+
+        private:
 };
 
@@ -160 +158 @@
  */
 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()
 };
 
@@ -199 +197 @@
  */
 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
-
-  molecule(periodentafel *teil);
-  ~molecule();
-
-  /// remove atoms from molecule.
-  bool AddAtom(atom *pointer);
-  bool RemoveAtom(atom *pointer);
-  bool CleanupMolecule();
-
-  /// Add/remove atoms to/from molecule.
-  atom * AddCopyAtom(atom *pointer);
-  bool AddXYZFile(string filename);
-  bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
-  bond * AddBond(atom *first, atom *second, int degree);
-  bool RemoveBond(bond *pointer);
-  bool RemoveBonds(atom *BondPartner);
-
-  /// Find atoms.
-  atom * FindAtom(int Nr) const;
-  atom * AskAtom(string text);
-
-  /// Count and change present atoms' coordination.
-  void CountAtoms(ofstream *out);
-  void CountElements();
-  void CalculateOrbitals(class config &configuration);
-  bool CenterInBox(ofstream *out, Vector *BoxLengths);
-  void CenterEdge(ofstream *out, Vector *max);
-  void CenterOrigin(ofstream *out, Vector *max);
-  void CenterGravity(ofstream *out, Vector *max);
-  void Translate(const Vector *x);
-  void Mirror(const Vector *x);
-  void Align(Vector *n);
-  void Scale(double **factor);
-  void DetermineCenter(Vector &center);
-  Vector * DetermineCenterOfGravity(ofstream *out);
-  Vector * DetermineCenterOfAll(ofstream *out);
-  void SetBoxDimension(Vector *dim);
-  double * ReturnFullMatrixforSymmetric(double *cell_size);
-  void ScanForPeriodicCorrection(ofstream *out);
+        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
+
+        molecule(periodentafel *teil);
+        ~molecule();
+
+        /// remove atoms from molecule.
+        bool AddAtom(atom *pointer);
+        bool RemoveAtom(atom *pointer);
+        bool CleanupMolecule();
+
+        /// Add/remove atoms to/from molecule.
+        atom * AddCopyAtom(atom *pointer);
+        bool AddXYZFile(string filename);
+        bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
+        bond * AddBond(atom *first, atom *second, int degree);
+        bool RemoveBond(bond *pointer);
+        bool RemoveBonds(atom *BondPartner);
+
+        /// Find atoms.
+        atom * FindAtom(int Nr) const;
+        atom * AskAtom(string text);
+
+        /// Count and change present atoms' coordination.
+        void CountAtoms(ofstream *out);
+        void CountElements();
+        void CalculateOrbitals(class config &configuration);
+        bool CenterInBox(ofstream *out, Vector *BoxLengths);
+        void CenterEdge(ofstream *out, Vector *max);
+        void CenterOrigin(ofstream *out, Vector *max);
+        void CenterGravity(ofstream *out, Vector *max);
+        void Translate(const Vector *x);
+        void Mirror(const Vector *x);
+        void Align(Vector *n);
+        void Scale(double **factor);
+        void DetermineCenter(Vector &center);
+        Vector * DetermineCenterOfGravity(ofstream *out);
+        Vector * DetermineCenterOfAll(ofstream *out);
+        void SetBoxDimension(Vector *dim);
+        double * ReturnFullMatrixforSymmetric(double *cell_size);
+        void ScanForPeriodicCorrection(ofstream *out);
         void PrincipalAxisSystem(ofstream *out, bool DoRotate);
         double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
         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);
+        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
+        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
 };
 
@@ -327 +325 @@
  */
 class MoleculeListClass {
-  public:
-    molecule **ListOfMolecules;   //!< pointer list of fragment molecules to check for equality
-    int NumberOfMolecules;        //!< Number of entries in \a **FragmentList and of to be returned one.
-    int NumberOfTopAtoms;         //!< Number of atoms in the molecule from which all fragments originate
-
-  MoleculeListClass();
-  MoleculeListClass(int Num, int NumAtoms);
-  ~MoleculeListClass();
-
-  /// Output configs.
-  bool AddHydrogenCorrection(ofstream *out, char *path);
-  bool StoreForcesFile(ofstream *out, char *path, int *SortIndex);
-  bool OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex);
-  void Output(ofstream *out);
-
-  private:
+        public:
+                molecule **ListOfMolecules;      //!< pointer list of fragment molecules to check for equality
+                int NumberOfMolecules;                          //!< Number of entries in \a **FragmentList and of to be returned one.
+                int NumberOfTopAtoms;                            //!< Number of atoms in the molecule from which all fragments originate
+
+        MoleculeListClass();
+        MoleculeListClass(int Num, int NumAtoms);
+        ~MoleculeListClass();
+
+        /// Output configs.
+        bool AddHydrogenCorrection(ofstream *out, char *path);
+        bool StoreForcesFile(ofstream *out, char *path, int *SortIndex);
+        bool OutputConfigForListOfFragments(ofstream *out, config *configuration, int *SortIndex);
+        void Output(ofstream *out);
+
+        private:
 };
 
@@ -350 +348 @@
  */
 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;
 };
 
@@ -374 +372 @@
  */
 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;
-
-    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(molecule *mol);
-  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;
+
+                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(molecule *mol);
+        bool GetIsAngstroem() const;
+        char *GetDefaultPath() const;
+        void SetDefaultPath(const char *path);
 };
 

src/parser.cpp

@@ -2 +2 @@
  *
  * Declarations of various class functions for the parsing of value files.
- *    
+ *
  */
 
 // ======================================= INCLUDES ==========================================
 
-#include "helpers.hpp" 
+#include "helpers.hpp"
 #include "parser.hpp"
 
@@ -24 +24 @@
 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;
 };
 
@@ -43 +43 @@
 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);
 };
 
@@ -55 +55 @@
  */
 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;
 };
 
@@ -68 +68 @@
  */
 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
  * \param skiplines number of inital columns to skip
  * \param MatrixNr index number in Matrix array to parse into
- * \return parsing successful 
+ * \return parsing successful
  */
 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;
 };
 
 /** Parsing a number of matrices.
  * -# 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
- * -# Finally, allocate one additional matrix (\a MatrixCounter) containing combined or temporary values 
+ * -# 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
+ * -# Finally, allocate one additional matrix (\a MatrixCounter) containing combined or temporary values
  * \param *name directory with files
  * \param *prefix prefix of each matrix file
@@ -206 +206 @@
  * \param skiplines number of inital lines to skip
  * \param skiplines number of inital columns to skip
- * \return parsing successful 
+ * \return parsing successful
  */
 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;
 };
 
@@ -256 +256 @@
  * \param *RCounter number of rows for each matrix
  * \param CCounter number of columns for all matrices
- * \return Allocation successful 
+ * \return Allocation successful
  */
 bool MatrixContainer::AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter)
 {
-  Header = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseFragmentMatrix: *EnergyHeader");
-  strncpy(Header, GivenHeader, 1023);
-
-  MatrixCounter = MCounter;
-  ColumnCounter = CCounter;
-  Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
-  RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
-  for(int i=MatrixCounter+1;i--;) {
-    RowCounter[i] = RCounter[i];
-    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");  
-    for(int j=RowCounter[i]+1;j--;) {
-      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
-      for(int k=ColumnCounter;k--;)
-        Matrix[i][j][k] = 0.;
-    }
-  }
-  return true;
+        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;
 };
 
@@ -284 +284 @@
 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;
 };
 
@@ -296 +296 @@
 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;
 };
@@ -312 +312 @@
 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;
 };
 
@@ -330 +330 @@
 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;
 };
 
@@ -343 +343 @@
 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;
 };
 
@@ -358 +358 @@
 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;
 };
 
@@ -412 +412 @@
 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;
 };
 
@@ -445 +445 @@
 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;
 };
 
@@ -471 +471 @@
  * \return creation sucessful
  */
-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; 
+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;
 };
 
@@ -494 +494 @@
 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;
 };
 
@@ -515 +515 @@
  * \param skiplines number of inital columns to skip
  * \return parsing successful
- */ 
+ */
 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;
 };
 
@@ -546 +546 @@
 /** Parsing force Indices of each fragment
  * \param *name directory with \a ForcesFile
- * \return parsing successful 
- */
-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;
+ * \return parsing successful
+ */
+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;
 };
 
@@ -592 +592 @@
  * \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;
 };
 
@@ -625 +625 @@
  * \param skiplines number of inital columns to skip
  * \return parsing successful
- */ 
+ */
 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;
 };
 
@@ -678 +678 @@
  */
 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;
 };
 
@@ -689 +689 @@
  */
 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");
 };
 
@@ -706 +706 @@
  */
 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;
 };
 
@@ -751 +751 @@
 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;
 };
 
@@ -814 +814 @@
 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

@@ -2 +2 @@
  *
  * Definitions of various class functions for the parsing of value files.
- *    
+ *
  */
 
@@ -40 +40 @@
 
 class MatrixContainer {
-  public:
-    double ***Matrix;
-    int **Indices;
-    char *Header;
-    int MatrixCounter;
-    int *RowCounter;
-    int ColumnCounter;
-  
-  MatrixContainer();
-  ~MatrixContainer();
-  
-  bool ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr);
-  virtual bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
-  bool AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter);
-  bool ResetMatrix();
-  double FindMinValue();
-  double FindMaxValue();
-  bool SetLastMatrix(double value, int skipcolumns);
-  bool SetLastMatrix(double **values, int skipcolumns);
-  //bool ParseIndices();
-  //bool SumSubValues();
-  bool SumSubManyBodyTerms(class MatrixContainer &Matrix, class KeySetsContainer &KeySet, int Order);
-  bool WriteTotalFragments(const char *name, const char *prefix);
-  bool WriteLastMatrix(const char *name, const char *prefix, const char *suffix);
-}; 
+        public:
+                double ***Matrix;
+                int **Indices;
+                char *Header;
+                int MatrixCounter;
+                int *RowCounter;
+                int ColumnCounter;
+
+        MatrixContainer();
+        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);
+};
 
 // ======================================= CLASS EnergyMatrix =============================
 
 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);
 };
 
@@ -78 +78 @@
 
 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);
 };
 
@@ -87 +87 @@
 
 class KeySetsContainer {
-  public:
-    int **KeySets;
-    int *AtomCounter;
-    int FragmentCounter;
-    int Order;
-    int *FragmentsPerOrder;
-    int **OrderSet;
-  
-  KeySetsContainer();
-  ~KeySetsContainer();
-   
-  bool ParseKeySets(const char *name, const int *ACounter, const int FCounter);
-  bool ParseManyBodyTerms();
-  bool Contains(const int GreaterSet, const int SmallerSet);
+        public:
+                int **KeySets;
+                int *AtomCounter;
+                int FragmentCounter;
+                int Order;
+                int *FragmentsPerOrder;
+                int **OrderSet;
+
+        KeySetsContainer();
+        ~KeySetsContainer();
+
+        bool ParseKeySets(const char *name, const int *ACounter, const int FCounter);
+        bool ParseManyBodyTerms();
+        bool Contains(const int GreaterSet, const int SmallerSet);
 };
 

src/periodentafel.cpp

@@ -1 +1 @@
 /** \file periodentafel.cpp
- * 
+ *
  * Function implementations for the class periodentafel.
- * 
+ *
  */
 
@@ -14 +14 @@
  * Initialises start and end of list and resets periodentafel::checkliste to false.
  */
-periodentafel::periodentafel() 
-{ 
-  start = new element; 
-  end = new element; 
-  start->previous = NULL; 
-  start->next = end; 
-  end->previous = start; 
-  end->next = NULL;
+periodentafel::periodentafel()
+{
+        start = new element;
+        end = new element;
+        start->previous = NULL;
+        start->next = end;
+        end->previous = start;
+        end->next = NULL;
 };
 
@@ -27 +27 @@
  * Removes every element and afterwards deletes start and end of list.
  */
-periodentafel::~periodentafel() 
-{ 
-  CleanupPeriodtable(); 
-  delete(end); 
-  delete(start); 
-}; 
+periodentafel::~periodentafel()
+{
+        CleanupPeriodtable();
+        delete(end);
+        delete(start);
+};
 
 /** Adds element to period table list
@@ -38 +38 @@
  * \return true - succeeded, false - does not occur
  */
-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); 
+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);
 };
 
@@ -50 +50 @@
  * \return true - succeeded, false - element not found
  */
-bool periodentafel::RemoveElement(element *pointer) 
-{ 
-  return remove(pointer, start, end); 
+bool periodentafel::RemoveElement(element *pointer)
+{
+        return remove(pointer, start, end);
 };
 
@@ -58 +58 @@
  * \return true - succeeded, false - does not occur
  */
-bool periodentafel::CleanupPeriodtable() 
-{ 
-  return cleanup(start,end); 
+bool periodentafel::CleanupPeriodtable()
+{
+        return cleanup(start,end);
 };
 
@@ -70 +70 @@
 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);
 };
 
@@ -94 +94 @@
 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);
 };
 
 /** Asks for element number and returns pointer to element
  */
-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 * 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;
+};
 
 /** Prints period table to given stream.
  * \param output stream
- */ 
+ */
 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;
 };
 
@@ -138 +137 @@
  * \param *output output stream
  * \param *checkliste elements table for this molecule
- */ 
+ */
 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;
+};
 
 /** Loads element list from file.
@@ -166 +164 @@
 bool periodentafel::LoadPeriodentafel(char *path)
 {
-  ifstream infile;
-  double tmp;
-  element *ptr;
-  bool status = true;
-  bool otherstatus = true;
-  char *filename = new char[MAXSTRINGSIZE];
-  
-  // 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;
 };
 
@@ -305 +303 @@
 bool periodentafel::StorePeriodentafel(char *path) const
 {
-  bool result = true;
-  ofstream f;
-  char filename[MAXSTRINGSIZE];
-  
-  strncpy(filename, path, MAXSTRINGSIZE);
-  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
-  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
-  f.open(filename);
-  if (f != NULL) {
-    f << header1 << endl;
-    f << header2 << endl;
-    element *walker = periodentafel::start;
-    while (walker->next != periodentafel::end) {
-      walker = walker->next;
-      result = result && walker->Output(&f);
-    }
-    f.close();
-  } else
-    result = false;
-  return result;
-};
+        bool result = true;
+        ofstream f;
+        char filename[MAXSTRINGSIZE];
+
+        strncpy(filename, path, MAXSTRINGSIZE);
+        strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+        strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
+        f.open(filename);
+        if (f != NULL) {
+                f << header1 << endl;
+                f << header2 << endl;
+                element *walker = periodentafel::start;
+                while (walker->next != periodentafel::end) {
+                        walker = walker->next;
+                        result = result && walker->Output(&f);
+                }
+                f.close();
+        } else
+                result = false;
+        return result;
+};

src/periodentafel.hpp

@@ -21 +21 @@
  */
 class element {
-  public:
-    double mass;    //!< mass in g/mol
-    double CovalentRadius;  //!< covalent radius
-    double VanDerWaalsRadius;  //!< can-der-Waals radius
-    int Z;          //!< atomic number
-    char name[64];  //!< atom name, i.e. "Hydrogren"
-    char symbol[3]; //!< short form of the atom, i.e. "H"
-    char period[8];    //!< period: n quantum number
-    char group[8];    //!< group: l quantum number
-    char block[8];    //!< block: l quantum number
-    element *previous;  //!< previous item in list
-    element *next;  //!< next element in list
-    int *sort;      //!< sorc criteria
-    int No;         //!< number of element set on periodentafel::Output()
-    double Valence;   //!< number of valence electrons for this element
-    int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
-    double HBondDistance[NDIM]; //!< distance in Angstrom of this element to hydrogen  (for single, double and triple bonds)
-    double HBondAngle[NDIM];     //!< typical angle for one, two, three bonded hydrogen (in degrees)
+        public:
+                double mass;            //!< mass in g/mol
+                double CovalentRadius;  //!< covalent radius
+                double VanDerWaalsRadius;       //!< can-der-Waals radius
+                int Z;                                  //!< atomic number
+                char name[64];  //!< atom name, i.e. "Hydrogren"
+                char symbol[3]; //!< short form of the atom, i.e. "H"
+                char period[8];         //!< period: n quantum number
+                char group[8];          //!< group: l quantum number
+                char block[8];          //!< block: l quantum number
+                element *previous;      //!< previous item in list
+                element *next;  //!< next element in list
+                int *sort;                      //!< sorc criteria
+                int No;                          //!< number of element set on periodentafel::Output()
+                double Valence;  //!< number of valence electrons for this element
+                int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
+                double HBondDistance[NDIM]; //!< distance in Angstrom of this element to hydrogen       (for single, double and triple bonds)
+                double HBondAngle[NDIM];                 //!< typical angle for one, two, three bonded hydrogen (in degrees)
 
-  element();
-  ~element();
+        element();
+        ~element();
 
-  //> print element entries to screen
-  bool Output(ofstream *out) const;
-  bool Checkout(ofstream *out, const int No, const int NoOfAtoms) const;
-  
-  private:
+        //> print element entries to screen
+        bool Output(ofstream *out) const;
+        bool Checkout(ofstream *out, const int No, const int NoOfAtoms) const;
+
+        private:
 };
 
@@ -53 +53 @@
  */
 class periodentafel {
-  public:
-    element *start; //!< start of element list
-    element *end;   //!< end of element list
-    char header1[MAXSTRINGSIZE]; //!< store first header line
-    char header2[MAXSTRINGSIZE]; //!< store second header line
-  
-  periodentafel();
-  ~periodentafel(); 
-  
-  bool AddElement(element *pointer);
-  bool RemoveElement(element *pointer);
-  bool CleanupPeriodtable();
-  element * FindElement(int Z);
-  element * FindElement(char *shorthand) const;
-  element * AskElement(); 
-  bool Output(ofstream *output) const;
-  bool Checkout(ofstream *output, const int *checkliste) const;
-  bool LoadPeriodentafel(char *path = NULL);
-  bool StorePeriodentafel(char *path = NULL) const;
-  
-  private:
+        public:
+                element *start; //!< start of element list
+                element *end;    //!< end of element list
+                char header1[MAXSTRINGSIZE]; //!< store first header line
+                char header2[MAXSTRINGSIZE]; //!< store second header line
+
+        periodentafel();
+        ~periodentafel();
+
+        bool AddElement(element *pointer);
+        bool RemoveElement(element *pointer);
+        bool CleanupPeriodtable();
+        element * FindElement(int Z);
+        element * FindElement(char *shorthand) const;
+        element * AskElement();
+        bool Output(ofstream *output) const;
+        bool Checkout(ofstream *output, const int *checkliste) const;
+        bool LoadPeriodentafel(char *path = NULL);
+        bool StorePeriodentafel(char *path = NULL) const;
+
+        private:
 };
 

src/stackclass.hpp

@@ -10 +10 @@
  */
 template <typename T> class StackClass {
-  public:
-  StackClass<T>(int dimension);
-  ~StackClass<T>();
-  
-  bool Push(T object);
-  T PopFirst();
-  T PopLast();
-  bool RemoveItem(T ptr);
-  void ClearStack();
-  bool IsEmpty();
-  bool IsFull();
-  int ItemCount();
-  void Output(ofstream *out) const;
-  void TestImplementation(ofstream *out, T test);
-  
-  private:
-    T *StackList;   //!< the list containing the atom pointers
-    int EntryCount;     //!< number of entries in the stack
-    int CurrentLastEntry;   //!< Current last entry (newest item on stack)
-    int CurrentFirstEntry;   //!< Current first entry (oldest item on stack)
-    int NextFreeField;       //!< Current index of next free field
+        public:
+        StackClass<T>(int dimension);
+        ~StackClass<T>();
+
+        bool Push(T object);
+        T PopFirst();
+        T PopLast();
+        bool RemoveItem(T ptr);
+        void ClearStack();
+        bool IsEmpty();
+        bool IsFull();
+        int ItemCount();
+        void Output(ofstream *out) const;
+        void TestImplementation(ofstream *out, T test);
+
+        private:
+                T *StackList;    //!< the list containing the atom pointers
+                int EntryCount;          //!< number of entries in the stack
+                int CurrentLastEntry;    //!< Current last entry (newest item on stack)
+                int CurrentFirstEntry;   //!< Current first entry (oldest item on stack)
+                int NextFreeField;                       //!< Current index of next free field
 };
 
@@ -37 +37 @@
 template <typename T> StackClass<T>::StackClass(int dimension)
 {
-  CurrentLastEntry = 0;
-  CurrentFirstEntry = 0;
-  NextFreeField = 0;
-  EntryCount = dimension;
-  StackList = (T *) Malloc(sizeof(T)*EntryCount, "StackClass::StackClass: **StackList");
+        CurrentLastEntry = 0;
+        CurrentFirstEntry = 0;
+        NextFreeField = 0;
+        EntryCount = dimension;
+        StackList = (T *) Malloc(sizeof(T)*EntryCount, "StackClass::StackClass: **StackList");
 };
 
@@ -48 +48 @@
 template <typename T> StackClass<T>::~StackClass()
 {
-  Free((void **)&StackList, "StackClass::StackClass: **StackList");
+        Free((void **)&StackList, "StackClass::StackClass: **StackList");
 };
 
@@ -57 +57 @@
 template <typename T> bool StackClass<T>::Push(T object)
 {
-  if (!IsFull()) {    // check whether free field is really not occupied
-    StackList[NextFreeField] = object;
-    CurrentLastEntry = NextFreeField;
-    NextFreeField = (NextFreeField + 1) % EntryCount; // step on to next free field
-    return true;
-  } else {
-    cerr << "ERROR: Stack is full, " << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tNextFreeField " << NextFreeField << "\tEntryCount " << EntryCount << "!" << endl;
-    return false;
-  }
+        if (!IsFull()) {                // check whether free field is really not occupied
+                StackList[NextFreeField] = object;
+                CurrentLastEntry = NextFreeField;
+                NextFreeField = (NextFreeField + 1) % EntryCount; // step on to next free field
+                return true;
+        } else {
+                cerr << "ERROR: Stack is full, " << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tNextFreeField " << NextFreeField << "\tEntryCount " << EntryCount << "!" << endl;
+                return false;
+        }
 };
 
@@ -74 +74 @@
 template <typename T> T StackClass<T>::PopFirst()
 {
-  T Walker = NULL;
-  if (!IsEmpty()) {
-    Walker = StackList[CurrentFirstEntry];
-    if (Walker == NULL)
-      cerr << "ERROR: Stack's field is empty!" << endl;
-    StackList[CurrentFirstEntry] = NULL;
-    if (CurrentFirstEntry != CurrentLastEntry) { // hasn't last item been popped as well?
-      CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
-    } else {
-      CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
-      CurrentLastEntry = CurrentFirstEntry;
-    }
-  } else
-    cerr << "ERROR: Stack is empty!" << endl; 
-  return Walker;
+        T Walker = NULL;
+        if (!IsEmpty()) {
+                Walker = StackList[CurrentFirstEntry];
+                if (Walker == NULL)
+                        cerr << "ERROR: Stack's field is empty!" << endl;
+                StackList[CurrentFirstEntry] = NULL;
+                if (CurrentFirstEntry != CurrentLastEntry) { // hasn't last item been popped as well?
+                        CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
+                } else {
+                        CurrentFirstEntry = (CurrentFirstEntry + 1) % EntryCount; // step back from current free field to last used (somehow modulo does not work in -1)
+                        CurrentLastEntry = CurrentFirstEntry;
+                }
+        } else
+                cerr << "ERROR: Stack is empty!" << endl;
+        return Walker;
 };
 
@@ -97 +97 @@
 template <typename T> T StackClass<T>::PopLast()
 {
-  T Walker = NULL;
-  if (!IsEmpty()) {
-    Walker = StackList[CurrentLastEntry];
-    StackList[CurrentLastEntry] = NULL;
-    if (Walker == NULL)
-      cerr << "ERROR: Stack's field is empty!" << endl;
-    NextFreeField = CurrentLastEntry;
-    if (CurrentLastEntry != CurrentFirstEntry)  // has there been more than one item on stack
-      CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount; // step back from current free field to last (modulo does not work in -1, thus go EntryCount-1 instead)
-  } else {
-    cerr << "ERROR: Stack is empty!" << endl;
-  } 
-  return Walker;
+        T Walker = NULL;
+        if (!IsEmpty()) {
+                Walker = StackList[CurrentLastEntry];
+                StackList[CurrentLastEntry] = NULL;
+                if (Walker == NULL)
+                        cerr << "ERROR: Stack's field is empty!" << endl;
+                NextFreeField = CurrentLastEntry;
+                if (CurrentLastEntry != CurrentFirstEntry)      // has there been more than one item on stack
+                        CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount; // step back from current free field to last (modulo does not work in -1, thus go EntryCount-1 instead)
+        } else {
+                cerr << "ERROR: Stack is empty!" << endl;
+        }
+        return Walker;
 };
 
@@ -120 +120 @@
 template <typename T> bool StackClass<T>::RemoveItem(T ptr)
 {
-  bool found = false;
-  cout << Verbose(5) << "First " << CurrentFirstEntry<< "\tLast " << CurrentLastEntry<< "\tNext " << NextFreeField<< "\tCount " << EntryCount<< "." << endl;
-  int i=CurrentFirstEntry;
-  if (!IsEmpty())
-    do {
-      if (StackList[i] == ptr) {  // if item found, remove
-        cout << Verbose(5) << "Item " << *ptr << " was number " << i << " on stack, removing it." << endl;
-        found = true;
-        StackList[i] = NULL;
-      }
-      if ((found) && (StackList[i] != NULL)) {  // means we have to shift (and not the removed item)
-        if (i == 0) { // we are down to first item in stack, have to put onto last item
-          cout << Verbose(5) << "Shifting item 0 to place " << EntryCount-1 << "." << endl;
-          StackList[EntryCount-1] = StackList[0];
-        } else {
-          cout << Verbose(5) << "Shifting item " << i << " to place " << i-1 << "." << endl;
-          StackList[i-1] = StackList[i];
-        }
-      }
-      i=((i + 1) % EntryCount); // step on
-    } while (i!=NextFreeField);
-  else
-    cerr << "ERROR: Stack is already empty!" << endl;
-  if (found) {
-    NextFreeField = CurrentLastEntry;
-    if (CurrentLastEntry != CurrentFirstEntry)  // has there been more than one item on stack
-      CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount;
-  }
-  return found;
+        bool found = false;
+        cout << Verbose(5) << "First " << CurrentFirstEntry<< "\tLast " << CurrentLastEntry<< "\tNext " << NextFreeField<< "\tCount " << EntryCount<< "." << endl;
+        int i=CurrentFirstEntry;
+        if (!IsEmpty())
+                do {
+                        if (StackList[i] == ptr) {      // if item found, remove
+                                cout << Verbose(5) << "Item " << *ptr << " was number " << i << " on stack, removing it." << endl;
+                                found = true;
+                                StackList[i] = NULL;
+                        }
+                        if ((found) && (StackList[i] != NULL)) {        // means we have to shift (and not the removed item)
+                                if (i == 0) { // we are down to first item in stack, have to put onto last item
+                                        cout << Verbose(5) << "Shifting item 0 to place " << EntryCount-1 << "." << endl;
+                                        StackList[EntryCount-1] = StackList[0];
+                                } else {
+                                        cout << Verbose(5) << "Shifting item " << i << " to place " << i-1 << "." << endl;
+                                        StackList[i-1] = StackList[i];
+                                }
+                        }
+                        i=((i + 1) % EntryCount); // step on
+                } while (i!=NextFreeField);
+        else
+                cerr << "ERROR: Stack is already empty!" << endl;
+        if (found) {
+                NextFreeField = CurrentLastEntry;
+                if (CurrentLastEntry != CurrentFirstEntry)      // has there been more than one item on stack
+                        CurrentLastEntry = (CurrentLastEntry + (EntryCount-1)) % EntryCount;
+        }
+        return found;
 };
 
 /** Test the functionality of the stack.
  * \param *out ofstream for debugging
- * \param *test one item to put on stack  
+ * \param *test one item to put on stack
  * \return true - all tests worked correctly
  */
 template <typename T> void StackClass<T>::TestImplementation(ofstream *out, T test)
 {
-  T Walker = test;
-  *out << Verbose(1) << "Testing the snake stack..." << endl;
-  for (int i=0;i<EntryCount;i++) {
-    *out << Verbose(2) << "Filling " << i << "th element of stack." << endl; 
-    Push(Walker);
-    Walker=Walker->next;
-  }
-  *out << endl;
-  Output(out);
-  if (IsFull())
-    *out << "Stack is full as supposed to be!" << endl;
-  else
-    *out << "ERROR: Stack is not as full as supposed to be!" << endl;
-  //if (StackList[(EntryCount+1)/2] != NULL) {
-    *out << "Removing element in the middle ..." << endl;
-    RemoveItem(StackList[(EntryCount+1)/2]);
-    Output(out);
-  //}
-  //if (StackList[CurrentFirstEntry] != NULL) {
-    *out << "Removing first element  ..." << endl;
-    RemoveItem(StackList[CurrentFirstEntry]);
-    Output(out);
-  //}
-  //if (StackList[CurrentLastEntry] != NULL) {
-    *out << "Removing last element ..." << endl;
-    RemoveItem(StackList[CurrentLastEntry]);
-    Output(out);
-  //}
-  *out << "Clearing stack ... " << endl;  
-  ClearStack();
-  Output(out);
-  if (IsEmpty())
-    *out << "Stack is empty as supposed to be!" << endl;
-  else
-    *out << "ERROR: Stack is not as empty as supposed to be!" << endl;
-  *out << "done." << endl;
+        T Walker = test;
+        *out << Verbose(1) << "Testing the snake stack..." << endl;
+        for (int i=0;i<EntryCount;i++) {
+                *out << Verbose(2) << "Filling " << i << "th element of stack." << endl;
+                Push(Walker);
+                Walker=Walker->next;
+        }
+        *out << endl;
+        Output(out);
+        if (IsFull())
+                *out << "Stack is full as supposed to be!" << endl;
+        else
+                *out << "ERROR: Stack is not as full as supposed to be!" << endl;
+        //if (StackList[(EntryCount+1)/2] != NULL) {
+                *out << "Removing element in the middle ..." << endl;
+                RemoveItem(StackList[(EntryCount+1)/2]);
+                Output(out);
+        //}
+        //if (StackList[CurrentFirstEntry] != NULL) {
+                *out << "Removing first element ..." << endl;
+                RemoveItem(StackList[CurrentFirstEntry]);
+                Output(out);
+        //}
+        //if (StackList[CurrentLastEntry] != NULL) {
+                *out << "Removing last element ..." << endl;
+                RemoveItem(StackList[CurrentLastEntry]);
+                Output(out);
+        //}
+        *out << "Clearing stack ... " << endl;
+        ClearStack();
+        Output(out);
+        if (IsEmpty())
+                *out << "Stack is empty as supposed to be!" << endl;
+        else
+                *out << "ERROR: Stack is not as empty as supposed to be!" << endl;
+        *out << "done." << endl;
 };
 
@@ -201 +201 @@
 template <typename T> void StackClass<T>::Output(ofstream *out) const
 {
-  *out << "Contents of Stack: ";
-  for(int i=0;i<EntryCount;i++) {
-    *out << "\t";
-    if (i == CurrentFirstEntry)
-      *out << " 1";
-    if  (i == CurrentLastEntry)
-      *out << " "<< EntryCount;
-    if (i ==  NextFreeField)
-      *out << " F";
-    *out << ": " << StackList[i];
-  }
-  *out << endl;
+        *out << "Contents of Stack: ";
+        for(int i=0;i<EntryCount;i++) {
+                *out << "\t";
+                if (i == CurrentFirstEntry)
+                        *out << " 1";
+                if      (i == CurrentLastEntry)
+                        *out << " "<< EntryCount;
+                if (i ==        NextFreeField)
+                        *out << " F";
+                *out << ": " << StackList[i];
+        }
+        *out << endl;
 };
 
@@ -222 +222 @@
 template <typename T> bool StackClass<T>::IsEmpty()
 {
-  return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry == CurrentFirstEntry));
+        return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry == CurrentFirstEntry));
 };
 
@@ -232 +232 @@
 template <typename T> bool StackClass<T>::IsFull()
 {
-  return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry != CurrentFirstEntry));
+        return((NextFreeField == CurrentFirstEntry) && (CurrentLastEntry != CurrentFirstEntry));
 };
 
@@ -242 +242 @@
 template <typename T> int StackClass<T>::ItemCount()
 {
-  //cout << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tEntryCount " << EntryCount << "." << endl;
-  return((NextFreeField + (EntryCount - CurrentFirstEntry)) % EntryCount);
+        //cout << "Stack: CurrentLastEntry " << CurrentLastEntry<< "\tCurrentFirstEntry " << CurrentFirstEntry << "\tEntryCount " << EntryCount << "." << endl;
+        return((NextFreeField + (EntryCount - CurrentFirstEntry)) % EntryCount);
 };
 
@@ -251 +251 @@
 template <typename T> void StackClass<T>::ClearStack()
 {
-  for(int i=EntryCount; i--;)
-    StackList[i] = NULL;
-  CurrentFirstEntry = 0;
-  CurrentLastEntry = 0;
-  NextFreeField = 0;
+        for(int i=EntryCount; i--;)
+                StackList[i] = NULL;
+        CurrentFirstEntry = 0;
+        CurrentLastEntry = 0;
+        NextFreeField = 0;
 };
 

src/vector.cpp

@@ -28 +28 @@
 double Vector::DistanceSquared(const Vector *y) const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-  return (res);
+        double res = 0.;
+        for (int i=NDIM;i--;)
+                res += (x[i]-y->x[i])*(x[i]-y->x[i]);
+        return (res);
 };
 
@@ -40 +40 @@
 double Vector::Distance(const Vector *y) const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-  return (sqrt(res));
+        double res = 0.;
+        for (int i=NDIM;i--;)
+                res += (x[i]-y->x[i])*(x[i]-y->x[i]);
+        return (sqrt(res));
+};
+
+/** Calculates distance between this and another vector in a periodic cell.
+ * \param *y array to second vector
+ * \param *cell_size 6-dimensional array with (xx, xy, yy, xz, yz, zz) entries specifying the periodic cell
+ * \return \f$| x - y |\f$
+ */
+double Vector::PeriodicDistance(const Vector *y, const double *cell_size) const
+{
+        double res = Distance(y), tmp, matrix[NDIM*NDIM];
+        Vector Shiftedy, TranslationVector;
+        int N[NDIM];
+        matrix[0] = cell_size[0];
+        matrix[1] = cell_size[1];
+        matrix[2] = cell_size[3];
+        matrix[3] = cell_size[1];
+        matrix[4] = cell_size[2];
+        matrix[5] = cell_size[4];
+        matrix[6] = cell_size[3];
+        matrix[7] = cell_size[4];
+        matrix[8] = cell_size[5];
+        // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring 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]++) {
+                                // create the translation vector
+                                TranslationVector.Zero();
+                                for (int i=NDIM;i--;)
+                                        TranslationVector.x[i] = (double)N[i];
+                                TranslationVector.MatrixMultiplication(matrix);
+                                // add onto the original vector to compare with
+                                Shiftedy.CopyVector(y);
+                                Shiftedy.AddVector(&TranslationVector);
+                                // get distance and compare with minimum so far
+                                tmp = Distance(&Shiftedy);
+                                if (tmp < res) res = tmp;
+                        }
+        return (res);
 };
 
@@ -51 +89 @@
  * \return \f$| x - y |^2\f$
  */
-double Vector::PeriodicDistance(const Vector *y, const double *cell_size) const
-{
-  double res = Distance(y), tmp, matrix[NDIM*NDIM];
-  Vector Shiftedy, TranslationVector;
-  int N[NDIM];
-  matrix[0] = cell_size[0];
-  matrix[1] = cell_size[1];
-  matrix[2] = cell_size[3];
-  matrix[3] = cell_size[1];
-  matrix[4] = cell_size[2];
-  matrix[5] = cell_size[4];
-  matrix[6] = cell_size[3];
-  matrix[7] = cell_size[4];
-  matrix[8] = cell_size[5];
-  // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring 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]++) {
-        // create the translation vector
-        TranslationVector.Zero();
-        for (int i=NDIM;i--;)
-          TranslationVector.x[i] = (double)N[i];
-        TranslationVector.MatrixMultiplication(matrix);
-        // add onto the original vector to compare with
-        Shiftedy.CopyVector(y);
-        Shiftedy.AddVector(&TranslationVector);
-        // get distance and compare with minimum so far
-        tmp = Distance(&Shiftedy);
-        if (tmp < res) res = tmp;
-      }
-  return (res);
+double Vector::PeriodicDistanceSquared(const Vector *y, const double *cell_size) const
+{
+        double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
+        Vector Shiftedy, TranslationVector;
+        int N[NDIM];
+        matrix[0] = cell_size[0];
+        matrix[1] = cell_size[1];
+        matrix[2] = cell_size[3];
+        matrix[3] = cell_size[1];
+        matrix[4] = cell_size[2];
+        matrix[5] = cell_size[4];
+        matrix[6] = cell_size[3];
+        matrix[7] = cell_size[4];
+        matrix[8] = cell_size[5];
+        // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring 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]++) {
+                                // create the translation vector
+                                TranslationVector.Zero();
+                                for (int i=NDIM;i--;)
+                                        TranslationVector.x[i] = (double)N[i];
+                                TranslationVector.MatrixMultiplication(matrix);
+                                // add onto the original vector to compare with
+                                Shiftedy.CopyVector(y);
+                                Shiftedy.AddVector(&TranslationVector);
+                                // get distance and compare with minimum so far
+                                tmp = DistanceSquared(&Shiftedy);
+                                if (tmp < res) res = tmp;
+                        }
+        return (res);
 };
 
@@ -90 +128 @@
 void Vector::KeepPeriodic(ofstream *out, double *matrix)
 {
-//  int N[NDIM];
-//  bool flag = false;
-  //vector Shifted, TranslationVector;
-  Vector TestVector;
-//  *out << Verbose(1) << "Begin of KeepPeriodic." << endl;
-//  *out << Verbose(2) << "Vector is: ";
-//  Output(out);
-//  *out << endl;
-  TestVector.CopyVector(this);
-  TestVector.InverseMatrixMultiplication(matrix);
-  for(int i=NDIM;i--;) { // correct periodically
-    if (TestVector.x[i] < 0) {  // get every coefficient into the interval [0,1)
-      TestVector.x[i] += ceil(TestVector.x[i]);
-    } else {
-      TestVector.x[i] -= floor(TestVector.x[i]);
-    }
-  }
-  TestVector.MatrixMultiplication(matrix);
-  CopyVector(&TestVector);
-//  *out << Verbose(2) << "New corrected vector is: ";
-//  Output(out);
-//  *out << endl;
-//  *out << Verbose(1) << "End of KeepPeriodic." << endl;
+//      int N[NDIM];
+//      bool flag = false;
+        //vector Shifted, TranslationVector;
+        Vector TestVector;
+//      *out << Verbose(1) << "Begin of KeepPeriodic." << endl;
+//      *out << Verbose(2) << "Vector is: ";
+//      Output(out);
+//      *out << endl;
+        TestVector.CopyVector(this);
+        TestVector.InverseMatrixMultiplication(matrix);
+        for(int i=NDIM;i--;) { // correct periodically
+                if (TestVector.x[i] < 0) {      // get every coefficient into the interval [0,1)
+                        TestVector.x[i] += ceil(TestVector.x[i]);
+                } else {
+                        TestVector.x[i] -= floor(TestVector.x[i]);
+                }
+        }
+        TestVector.MatrixMultiplication(matrix);
+        CopyVector(&TestVector);
+//      *out << Verbose(2) << "New corrected vector is: ";
+//      Output(out);
+//      *out << endl;
+//      *out << Verbose(1) << "End of KeepPeriodic." << endl;
 };
 
@@ -121 +159 @@
 double Vector::ScalarProduct(const Vector *y) const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += x[i]*y->x[i];
-  return (res);
+        double res = 0.;
+        for (int i=NDIM;i--;)
+                res += x[i]*y->x[i];
+        return (res);
 };
 
 
 /** Calculates VectorProduct between this and another vector.
- *  -# returns the Product in place of vector from which it was initiated
- *  -# ATTENTION: Only three dim.
- *  \param *y array to vector with which to calculate crossproduct
- *  \return \f$ x \times y \f&
+ *      -# returns the Product in place of vector from which it was initiated
+ *      -# ATTENTION: Only three dim.
+ *      \param *y array to vector with which to calculate crossproduct
+ *      \return \f$ x \times y \f&
  */
 void Vector::VectorProduct(const Vector *y)
 {
-  Vector tmp;
-  tmp.x[0] = x[1]* (y->x[2]) - x[2]* (y->x[1]);
-  tmp.x[1] = x[2]* (y->x[0]) - x[0]* (y->x[2]);
-  tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
-  this->CopyVector(&tmp);
+        Vector tmp;
+        tmp.x[0] = x[1]* (y->x[2]) - x[2]* (y->x[1]);
+        tmp.x[1] = x[2]* (y->x[0]) - x[0]* (y->x[2]);
+        tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
+        this->CopyVector(&tmp);
 
 };
@@ -151 +189 @@
 void Vector::ProjectOntoPlane(const Vector *y)
 {
-  Vector tmp;
-  tmp.CopyVector(y);
-  tmp.Normalize();
-  tmp.Scale(ScalarProduct(&tmp));
-  this->SubtractVector(&tmp);
+        Vector tmp;
+        tmp.CopyVector(y);
+        tmp.Normalize();
+        tmp.Scale(ScalarProduct(&tmp));
+        this->SubtractVector(&tmp);
 };
 
@@ -164 +202 @@
 double Vector::Projection(const Vector *y) const
 {
-  return (ScalarProduct(y));
+        return (ScalarProduct(y));
 };
 
@@ -172 +210 @@
 double Vector::Norm() const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += this->x[i]*this->x[i];
-  return (sqrt(res));
+        double res = 0.;
+        for (int i=NDIM;i--;)
+                res += this->x[i]*this->x[i];
+        return (sqrt(res));
 };
 
@@ -182 +220 @@
 void Vector::Normalize()
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += this->x[i]*this->x[i];
-  if (fabs(res) > MYEPSILON)
-    res = 1./sqrt(res);
-  Scale(&res);
+        double res = 0.;
+        for (int i=NDIM;i--;)
+                res += this->x[i]*this->x[i];
+        if (fabs(res) > MYEPSILON)
+                res = 1./sqrt(res);
+        Scale(&res);
 };
 
@@ -194 +232 @@
 void Vector::Zero()
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = 0.;
+        for (int i=NDIM;i--;)
+                this->x[i] = 0.;
 };
 
@@ -202 +240 @@
 void Vector::One(double one)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = one;
+        for (int i=NDIM;i--;)
+                this->x[i] = one;
 };
 
@@ -210 +248 @@
 void Vector::Init(double x1, double x2, double x3)
 {
-  x[0] = x1;
-  x[1] = x2;
-  x[2] = x3;
+        x[0] = x1;
+        x[1] = x2;
+        x[2] = x3;
 };
 
@@ -219 +257 @@
  * \return \f$\acos\bigl(frac{\langle x, y \rangle}{|x||y|}\bigr)\f$
  */
-double Vector::Angle(Vector *y) const
-{
-  return acos(this->ScalarProduct(y)/Norm()/y->Norm());
+double Vector::Angle(const Vector *y) const
+{
+        return acos(this->ScalarProduct(y)/Norm()/y->Norm());
 };
 
@@ -230 +268 @@
 void Vector::RotateVector(const Vector *axis, const double alpha)
 {
-  Vector a,y;
-  // normalise this vector with respect to axis
-  a.CopyVector(this);
-  a.Scale(Projection(axis));
-  SubtractVector(&a);
-  // construct normal vector
-  y.MakeNormalVector(axis,this);
-  y.Scale(Norm());
-  // scale normal vector by sine and this vector by cosine
-  y.Scale(sin(alpha));
-  Scale(cos(alpha));
-  // add scaled normal vector onto this vector
-  AddVector(&y);
-  // add part in axis direction
-  AddVector(&a);
+        Vector a,y;
+        // normalise this vector with respect to axis
+        a.CopyVector(this);
+        a.Scale(Projection(axis));
+        SubtractVector(&a);
+        // construct normal vector
+        y.MakeNormalVector(axis,this);
+        y.Scale(Norm());
+        // scale normal vector by sine and this vector by cosine
+        y.Scale(sin(alpha));
+        Scale(cos(alpha));
+        // add scaled normal vector onto this vector
+        AddVector(&y);
+        // add part in axis direction
+        AddVector(&a);
 };
 
@@ -254 +292 @@
 Vector& operator+=(Vector& a, const Vector& b)
 {
-  a.AddVector(&b);
-  return a;
+        a.AddVector(&b);
+        return a;
 };
 /** factor each component of \a a times a double \a m.
@@ -264 +302 @@
 Vector& operator*=(Vector& a, const double m)
 {
-  a.Scale(m);
-  return a;
-};
-
-/** Sums two vectors \a  and \b component-wise.
+        a.Scale(m);
+        return a;
+};
+
+/** Sums two vectors \a and \b component-wise.
  * \param a first vector
  * \param b second vector
@@ -275 +313 @@
 Vector& operator+(const Vector& a, const Vector& b)
 {
-  Vector *x = new Vector;
-  x->CopyVector(&a);
-  x->AddVector(&b);
-  return *x;
+        Vector *x = new Vector;
+        x->CopyVector(&a);
+        x->AddVector(&b);
+        return *x;
 };
 
@@ -288 +326 @@
 Vector& operator*(const Vector& a, const double m)
 {
-  Vector *x = new Vector;
-  x->CopyVector(&a);
-  x->Scale(m);
-  return *x;
+        Vector *x = new Vector;
+        x->CopyVector(&a);
+        x->Scale(m);
+        return *x;
 };
 
@@ -300 +338 @@
 bool Vector::Output(ofstream *out) const
 {
-  if (out != NULL) {
-    *out << "(";
-    for (int i=0;i<NDIM;i++) {
-      *out << x[i];
-      if (i != 2)
-        *out << ",";
-    }
-    *out << ")";
-    return true;
-  } else
-    return false;
-};
-
-ofstream& operator<<(ofstream& ost,Vector& m)
-{
-        m.Output(&ost);
+        if (out != NULL) {
+                *out << "(";
+                for (int i=0;i<NDIM;i++) {
+                        *out << x[i];
+                        if (i != 2)
+                                *out << ",";
+                }
+                *out << ")";
+                return true;
+        } else
+                return false;
+};
+
+ostream& operator<<(ostream& ost,Vector& m)
+{
+        ost << "(";
+        for (int i=0;i<NDIM;i++) {
+                ost << m.x[i];
+                if (i != 2)
+                        ost << ",";
+        }
+        ost << ")";
         return ost;
 };
@@ -324 +368 @@
 void Vector::Scale(double **factor)
 {
-  for (int i=NDIM;i--;)
-    x[i] *= (*factor)[i];
+        for (int i=NDIM;i--;)
+                x[i] *= (*factor)[i];
 };
 
 void Vector::Scale(double *factor)
 {
-  for (int i=NDIM;i--;)
-    x[i] *= *factor;
+        for (int i=NDIM;i--;)
+                x[i] *= *factor;
 };
 
 void Vector::Scale(double factor)
 {
-  for (int i=NDIM;i--;)
-    x[i] *= factor;
+        for (int i=NDIM;i--;)
+                x[i] *= factor;
 };
 
@@ -345 +389 @@
 void Vector::Translate(const Vector *trans)
 {
-  for (int i=NDIM;i--;)
-    x[i] += trans->x[i];
+        for (int i=NDIM;i--;)
+                x[i] += trans->x[i];
 };
 
@@ -354 +398 @@
 void Vector::MatrixMultiplication(double *M)
 {
-  Vector C;
-  // do the matrix multiplication
-  C.x[0] = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
-  C.x[1] = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
-  C.x[2] = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
-  // transfer the result into this
-  for (int i=NDIM;i--;)
-    x[i] = C.x[i];
+        Vector C;
+        // do the matrix multiplication
+        C.x[0] = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
+        C.x[1] = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
+        C.x[2] = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
+        // transfer the result into this
+        for (int i=NDIM;i--;)
+                x[i] = C.x[i];
 };
 
@@ -369 +413 @@
 void Vector::InverseMatrixMultiplication(double *A)
 {
-  Vector C;
-  double B[NDIM*NDIM];
-  double detA = RDET3(A);
-  double detAReci;
-
-  // calculate the inverse B
-  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
-    detAReci = 1./detA;
-    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
-    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
-    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
-    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
-    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
-    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
-    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
-    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
-    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
-
-    // do the matrix multiplication
-    C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
-    C.x[1] = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
-    C.x[2] = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
-    // transfer the result into this
-    for (int i=NDIM;i--;)
-      x[i] = C.x[i];
-  } else {
-    cerr << "ERROR: inverse of matrix does not exists!" << endl;
-  }
+        Vector C;
+        double B[NDIM*NDIM];
+        double detA = RDET3(A);
+        double detAReci;
+
+        // calculate the inverse B
+        if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
+                detAReci = 1./detA;
+                B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);            // A_11
+                B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);            // A_12
+                B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);            // A_13
+                B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);            // A_21
+                B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);            // A_22
+                B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);            // A_23
+                B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);            // A_31
+                B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);            // A_32
+                B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);            // A_33
+
+                // do the matrix multiplication
+                C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
+                C.x[1] = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
+                C.x[2] = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
+                // transfer the result into this
+                for (int i=NDIM;i--;)
+                        x[i] = C.x[i];
+        } else {
+                cerr << "ERROR: inverse of matrix does not exists!" << endl;
+        }
 };
 
@@ -409 +453 @@
 void Vector::LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors)
 {
-  for(int i=NDIM;i--;)
-    x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i];
+        for(int i=NDIM;i--;)
+                x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i];
 };
 
@@ -418 +462 @@
 void Vector::Mirror(const Vector *n)
 {
-  double projection;
-  projection = ScalarProduct(n)/n->ScalarProduct(n);    // remove constancy from n (keep as logical one)
-  // withdraw projected vector twice from original one
-  cout << Verbose(1) << "Vector: ";
-  Output((ofstream *)&cout);
-  cout << "\t";
-  for (int i=NDIM;i--;)
-    x[i] -= 2.*projection*n->x[i];
-  cout << "Projected vector: ";
-  Output((ofstream *)&cout);
-  cout << endl;
+        double projection;
+        projection = ScalarProduct(n)/n->ScalarProduct(n);              // remove constancy from n (keep as logical one)
+        // withdraw projected vector twice from original one
+        cout << Verbose(1) << "Vector: ";
+        Output((ofstream *)&cout);
+        cout << "\t";
+        for (int i=NDIM;i--;)
+                x[i] -= 2.*projection*n->x[i];
+        cout << "Projected vector: ";
+        Output((ofstream *)&cout);
+        cout << endl;
 };
 
@@ -440 +484 @@
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2, const Vector *y3)
 {
-  Vector x1, x2;
-
-  x1.CopyVector(y1);
-  x1.SubtractVector(y2);
-  x2.CopyVector(y3);
-  x2.SubtractVector(y2);
-  if ((x1.Norm()==0) || (x2.Norm()==0)) {
-    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
-    return false;
-  }
-//  cout << Verbose(4) << "relative, first plane coordinates:";
-//  x1.Output((ofstream *)&cout);
-//  cout << endl;
-//  cout << Verbose(4) << "second plane coordinates:";
-//  x2.Output((ofstream *)&cout);
-//  cout << endl;
-
-  this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
-  this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
-  this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
-  Normalize();
-
-  return true;
+        Vector x1, x2;
+
+        x1.CopyVector(y1);
+        x1.SubtractVector(y2);
+        x2.CopyVector(y3);
+        x2.SubtractVector(y2);
+        if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
+                cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+                return false;
+        }
+//      cout << Verbose(4) << "relative, first plane coordinates:";
+//      x1.Output((ofstream *)&cout);
+//      cout << endl;
+//      cout << Verbose(4) << "second plane coordinates:";
+//      x2.Output((ofstream *)&cout);
+//      cout << endl;
+
+        this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
+        this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
+        this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
+        Normalize();
+
+        return true;
 };
 
@@ -476 +520 @@
 bool Vector::MakeNormalVector(const Vector *y1, const Vector *y2)
 {
-  Vector x1,x2;
-  x1.CopyVector(y1);
-  x2.CopyVector(y2);
-  Zero();
-  if ((x1.Norm()==0) || (x2.Norm()==0)) {
-    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
-    return false;
-  }
-//  cout << Verbose(4) << "relative, first plane coordinates:";
-//  x1.Output((ofstream *)&cout);
-//  cout << endl;
-//  cout << Verbose(4) << "second plane coordinates:";
-//  x2.Output((ofstream *)&cout);
-//  cout << endl;
-
-  this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
-  this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
-  this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
-  Normalize();
-
-  return true;
+        Vector x1,x2;
+        x1.CopyVector(y1);
+        x2.CopyVector(y2);
+        Zero();
+        if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
+                cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+                return false;
+        }
+//      cout << Verbose(4) << "relative, first plane coordinates:";
+//      x1.Output((ofstream *)&cout);
+//      cout << endl;
+//      cout << Verbose(4) << "second plane coordinates:";
+//      x2.Output((ofstream *)&cout);
+//      cout << endl;
+
+        this->x[0] = (x1.x[1]*x2.x[2] - x1.x[2]*x2.x[1]);
+        this->x[1] = (x1.x[2]*x2.x[0] - x1.x[0]*x2.x[2]);
+        this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
+        Normalize();
+
+        return true;
 };
 
@@ -507 +551 @@
 {
         bool result = false;
-  Vector x1;
-  x1.CopyVector(y1);
-  x1.Scale(x1.Projection(this));
-  SubtractVector(&x1);
-  for (int i=NDIM;i--;)
-          result = result || (fabs(x[i]) > MYEPSILON);
-
-  return result;
+        Vector x1;
+        x1.CopyVector(y1);
+        x1.Scale(x1.Projection(this));
+        SubtractVector(&x1);
+        for (int i=NDIM;i--;)
+                result = result || (fabs(x[i]) > MYEPSILON);
+
+        return result;
 };
 
@@ -525 +569 @@
 bool Vector::GetOneNormalVector(const Vector *GivenVector)
 {
-  int Components[NDIM]; // contains indices of non-zero components
-  int Last = 0;   // count the number of non-zero entries in vector
-  int j;  // loop variables
-  double norm;
-
-  cout << Verbose(4);
-  GivenVector->Output((ofstream *)&cout);
-  cout << endl;
-  for (j=NDIM;j--;)
-    Components[j] = -1;
-  // find two components != 0
-  for (j=0;j<NDIM;j++)
-    if (fabs(GivenVector->x[j]) > MYEPSILON)
-      Components[Last++] = j;
-  cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
-
-  switch(Last) {
-    case 3:  // threecomponent system
-    case 2:  // two component system
-      norm = sqrt(1./(GivenVector->x[Components[1]]*GivenVector->x[Components[1]]) + 1./(GivenVector->x[Components[0]]*GivenVector->x[Components[0]]));
-      x[Components[2]] = 0.;
-      // in skp both remaining parts shall become zero but with opposite sign and third is zero
-      x[Components[1]] = -1./GivenVector->x[Components[1]] / norm;
-      x[Components[0]] = 1./GivenVector->x[Components[0]] / norm;
-      return true;
-      break;
-    case 1: // one component system
-      // set sole non-zero component to 0, and one of the other zero component pendants to 1
-      x[(Components[0]+2)%NDIM] = 0.;
-      x[(Components[0]+1)%NDIM] = 1.;
-      x[Components[0]] = 0.;
-      return true;
-      break;
-    default:
-      return false;
-  }
+        int Components[NDIM]; // contains indices of non-zero components
+        int Last = 0;    // count the number of non-zero entries in vector
+        int j;  // loop variables
+        double norm;
+
+        cout << Verbose(4);
+        GivenVector->Output((ofstream *)&cout);
+        cout << endl;
+        for (j=NDIM;j--;)
+                Components[j] = -1;
+        // find two components != 0
+        for (j=0;j<NDIM;j++)
+                if (fabs(GivenVector->x[j]) > MYEPSILON)
+                        Components[Last++] = j;
+        cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
+
+        switch(Last) {
+                case 3: // threecomponent system
+                case 2: // two component system
+                        norm = sqrt(1./(GivenVector->x[Components[1]]*GivenVector->x[Components[1]]) + 1./(GivenVector->x[Components[0]]*GivenVector->x[Components[0]]));
+                        x[Components[2]] = 0.;
+                        // in skp both remaining parts shall become zero but with opposite sign and third is zero
+                        x[Components[1]] = -1./GivenVector->x[Components[1]] / norm;
+                        x[Components[0]] = 1./GivenVector->x[Components[0]] / norm;
+                        return true;
+                        break;
+                case 1: // one component system
+                        // set sole non-zero component to 0, and one of the other zero component pendants to 1
+                        x[(Components[0]+2)%NDIM] = 0.;
+                        x[(Components[0]+1)%NDIM] = 1.;
+                        x[Components[0]] = 0.;
+                        return true;
+                        break;
+                default:
+                        return false;
+        }
 };
 
@@ -571 +615 @@
 double Vector::CutsPlaneAt(Vector *A, Vector *B, Vector *C)
 {
-//  cout << Verbose(3) << "For comparison: ";
-//  cout << "A " << A->Projection(this) << "\t";
-//  cout << "B " << B->Projection(this) << "\t";
-//  cout << "C " << C->Projection(this) << "\t";
-//  cout << endl;
-  return A->Projection(this);
+//      cout << Verbose(3) << "For comparison: ";
+//      cout << "A " << A->Projection(this) << "\t";
+//      cout << "B " << B->Projection(this) << "\t";
+//      cout << "C " << C->Projection(this) << "\t";
+//      cout << endl;
+        return A->Projection(this);
 };
 
@@ -594 +638 @@
         }
 
-  int np = 3;
+        int np = 3;
         struct LSQ_params par;
 
-   const gsl_multimin_fminimizer_type *T =
-     gsl_multimin_fminimizer_nmsimplex;
-   gsl_multimin_fminimizer *s = NULL;
-   gsl_vector *ss, *y;
-   gsl_multimin_function minex_func;
-
-   size_t iter = 0, i;
-   int status;
-   double size;
-
-   /* Initial vertex size vector */
-   ss = gsl_vector_alloc (np);
-   y = gsl_vector_alloc (np);
-
-   /* Set all step sizes to 1 */
-   gsl_vector_set_all (ss, 1.0);
-
-   /* Starting point */
-   par.vectors = vectors;
+         const gsl_multimin_fminimizer_type *T =
+                 gsl_multimin_fminimizer_nmsimplex;
+         gsl_multimin_fminimizer *s = NULL;
+         gsl_vector *ss, *y;
+         gsl_multimin_function minex_func;
+
+         size_t iter = 0, i;
+         int status;
+         double size;
+
+         /* Initial vertex size vector */
+         ss = gsl_vector_alloc (np);
+         y = gsl_vector_alloc (np);
+
+         /* Set all step sizes to 1 */
+         gsl_vector_set_all (ss, 1.0);
+
+         /* Starting point */
+         par.vectors = vectors;
          par.num = num;
 
@@ -621 +665 @@
                 gsl_vector_set(y, i, (vectors[0]->x[i] - vectors[1]->x[i])/2.);
 
-   /* Initialize method and iterate */
-   minex_func.f = &LSQ;
-   minex_func.n = np;
-   minex_func.params = (void *)&par;
-
-   s = gsl_multimin_fminimizer_alloc (T, np);
-   gsl_multimin_fminimizer_set (s, &minex_func, y, 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=(size_t)np;i--;)
-    this->x[i] = gsl_vector_get(s->x, i);
-   gsl_vector_free(y);
-   gsl_vector_free(ss);
-   gsl_multimin_fminimizer_free (s);
+         /* Initialize method and iterate */
+         minex_func.f = &LSQ;
+         minex_func.n = np;
+         minex_func.params = (void *)&par;
+
+         s = gsl_multimin_fminimizer_alloc (T, np);
+         gsl_multimin_fminimizer_set (s, &minex_func, y, 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=(size_t)np;i--;)
+                this->x[i] = gsl_vector_get(s->x, i);
+         gsl_vector_free(y);
+         gsl_vector_free(ss);
+         gsl_multimin_fminimizer_free (s);
 
         return true;
@@ -668 +712 @@
 void Vector::AddVector(const Vector *y)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] += y->x[i];
+        for (int i=NDIM;i--;)
+                this->x[i] += y->x[i];
 }
 
@@ -677 +721 @@
 void Vector::SubtractVector(const Vector *y)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] -= y->x[i];
+        for (int i=NDIM;i--;)
+                this->x[i] -= y->x[i];
 }
 
@@ -686 +730 @@
 void Vector::CopyVector(const Vector *y)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = y->x[i];
+        for (int i=NDIM;i--;)
+                this->x[i] = y->x[i];
 }
 
@@ -697 +741 @@
 void Vector::AskPosition(double *cell_size, bool check)
 {
-  char coords[3] = {'x','y','z'};
-  int j = -1;
-  for (int i=0;i<3;i++) {
-    j += i+1;
-    do {
-      cout << Verbose(0) << coords[i] << "[0.." << cell_size[j] << "]: ";
-      cin >> x[i];
-    } while (((x[i] < 0) || (x[i] >= cell_size[j])) && (check));
-  }
+        char coords[3] = {'x','y','z'};
+        int j = -1;
+        for (int i=0;i<3;i++) {
+                j += i+1;
+                do {
+                        cout << Verbose(0) << coords[i] << "[0.." << cell_size[j] << "]: ";
+                        cin >> x[i];
+                } while (((x[i] < 0) || (x[i] >= cell_size[j])) && (check));
+        }
 };
 
@@ -725 +769 @@
 bool Vector::SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c)
 {
-  double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
-  double ang; // angle on testing
-  double sign[3];
-  int i,j,k;
-  A = cos(alpha) * x1->Norm() * c;
-  B1 = cos(beta + M_PI/2.) * y->Norm() * c;
-  B2 = cos(beta) * x2->Norm() * c;
-  C = c * c;
-  cout << Verbose(2) << "A " << A << "\tB " << B1 << "\tC " << C << endl;
-  int flag = 0;
-  if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
-    if (fabs(x1->x[1]) > MYEPSILON) {
-      flag = 1;
-    } else if (fabs(x1->x[2]) > MYEPSILON) {
-       flag = 2;
-    } else {
-      return false;
-    }
-  }
-  switch (flag) {
-    default:
-    case 0:
-      break;
-    case 2:
-      flip(&x1->x[0],&x1->x[1]);
-      flip(&x2->x[0],&x2->x[1]);
-      flip(&y->x[0],&y->x[1]);
-      //flip(&x[0],&x[1]);
-      flip(&x1->x[1],&x1->x[2]);
-      flip(&x2->x[1],&x2->x[2]);
-      flip(&y->x[1],&y->x[2]);
-      //flip(&x[1],&x[2]);
-    case 1:
-      flip(&x1->x[0],&x1->x[1]);
-      flip(&x2->x[0],&x2->x[1]);
-      flip(&y->x[0],&y->x[1]);
-      //flip(&x[0],&x[1]);
-      flip(&x1->x[1],&x1->x[2]);
-      flip(&x2->x[1],&x2->x[2]);
-      flip(&y->x[1],&y->x[2]);
-      //flip(&x[1],&x[2]);
-      break;
-  }
-  // now comes the case system
-  D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
-  D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
-  D3 = y->x[0]/x1->x[0]*A-B1;
-  cout << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
-  if (fabs(D1) < MYEPSILON) {
-    cout << Verbose(2) << "D1 == 0!\n";
-    if (fabs(D2) > MYEPSILON) {
-      cout << Verbose(3) << "D2 != 0!\n";
-      x[2] = -D3/D2;
-      E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
-      E2 = -x1->x[1]/x1->x[0];
-      cout << Verbose(3) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-      F1 = E1*E1 + 1.;
-      F2 = -E1*E2;
-      F3 = E1*E1 + D3*D3/(D2*D2) - C;
-      cout << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-      if (fabs(F1) < MYEPSILON) {
-        cout << Verbose(4) << "F1 == 0!\n";
-        cout << Verbose(4) << "Gleichungssystem linear\n";
-        x[1] = F3/(2.*F2);
-      } else {
-        p = F2/F1;
-        q = p*p - F3/F1;
-        cout << Verbose(4) << "p " << p << "\tq " << q << endl;
-        if (q < 0) {
-          cout << Verbose(4) << "q < 0" << endl;
-          return false;
-        }
-        x[1] = p + sqrt(q);
-      }
-      x[0] =  A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-    } else {
-      cout << Verbose(2) << "Gleichungssystem unterbestimmt\n";
-      return false;
-    }
-  } else {
-    E1 = A/x1->x[0]+x1->x[1]/x1->x[0]*D3/D1;
-    E2 = x1->x[1]/x1->x[0]*D2/D1 - x1->x[2];
-    cout << Verbose(2) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-    F1 = E2*E2 + D2*D2/(D1*D1) + 1.;
-    F2 = -(E1*E2 + D2*D3/(D1*D1));
-    F3 = E1*E1 + D3*D3/(D1*D1) - C;
-    cout << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-    if (fabs(F1) < MYEPSILON) {
-      cout << Verbose(3) << "F1 == 0!\n";
-      cout << Verbose(3) << "Gleichungssystem linear\n";
-      x[2] = F3/(2.*F2);
-    } else {
-      p = F2/F1;
-      q = p*p - F3/F1;
-      cout << Verbose(3) << "p " << p << "\tq " << q << endl;
-      if (q < 0) {
-        cout << Verbose(3) << "q < 0" << endl;
-        return false;
-      }
-      x[2] = p + sqrt(q);
-    }
-    x[1] = (-D2 * x[2] - D3)/D1;
-    x[0] = A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-  }
-  switch (flag) { // back-flipping
-    default:
-    case 0:
-      break;
-    case 2:
-      flip(&x1->x[0],&x1->x[1]);
-      flip(&x2->x[0],&x2->x[1]);
-      flip(&y->x[0],&y->x[1]);
-      flip(&x[0],&x[1]);
-      flip(&x1->x[1],&x1->x[2]);
-      flip(&x2->x[1],&x2->x[2]);
-      flip(&y->x[1],&y->x[2]);
-      flip(&x[1],&x[2]);
-    case 1:
-      flip(&x1->x[0],&x1->x[1]);
-      flip(&x2->x[0],&x2->x[1]);
-      flip(&y->x[0],&y->x[1]);
-      //flip(&x[0],&x[1]);
-      flip(&x1->x[1],&x1->x[2]);
-      flip(&x2->x[1],&x2->x[2]);
-      flip(&y->x[1],&y->x[2]);
-      flip(&x[1],&x[2]);
-      break;
-  }
-  // one z component is only determined by its radius (without sign)
-  // thus check eight possible sign flips and determine by checking angle with second vector
-  for (i=0;i<8;i++) {
-    // set sign vector accordingly
-    for (j=2;j>=0;j--) {
-      k = (i & pot(2,j)) << j;
-      cout << Verbose(2) << "k " << k << "\tpot(2,j) " << pot(2,j) << endl;
-      sign[j] = (k == 0) ? 1. : -1.;
-    }
-    cout << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
-    // apply sign matrix
-    for (j=NDIM;j--;)
-      x[j] *= sign[j];
-    // calculate angle and check
-    ang = x2->Angle (this);
-    cout << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
-    if (fabs(ang - cos(beta)) < MYEPSILON) {
-      break;
-    }
-    // unapply sign matrix (is its own inverse)
-    for (j=NDIM;j--;)
-      x[j] *= sign[j];
-  }
-  return true;
-};
+        double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
+        double ang; // angle on testing
+        double sign[3];
+        int i,j,k;
+        A = cos(alpha) * x1->Norm() * c;
+        B1 = cos(beta + M_PI/2.) * y->Norm() * c;
+        B2 = cos(beta) * x2->Norm() * c;
+        C = c * c;
+        cout << Verbose(2) << "A " << A << "\tB " << B1 << "\tC " << C << endl;
+        int flag = 0;
+        if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
+                if (fabs(x1->x[1]) > MYEPSILON) {
+                        flag = 1;
+                } else if (fabs(x1->x[2]) > MYEPSILON) {
+                         flag = 2;
+                } else {
+                        return false;
+                }
+        }
+        switch (flag) {
+                default:
+                case 0:
+                        break;
+                case 2:
+                        flip(&x1->x[0],&x1->x[1]);
+                        flip(&x2->x[0],&x2->x[1]);
+                        flip(&y->x[0],&y->x[1]);
+                        //flip(&x[0],&x[1]);
+                        flip(&x1->x[1],&x1->x[2]);
+                        flip(&x2->x[1],&x2->x[2]);
+                        flip(&y->x[1],&y->x[2]);
+                        //flip(&x[1],&x[2]);
+                case 1:
+                        flip(&x1->x[0],&x1->x[1]);
+                        flip(&x2->x[0],&x2->x[1]);
+                        flip(&y->x[0],&y->x[1]);
+                        //flip(&x[0],&x[1]);
+                        flip(&x1->x[1],&x1->x[2]);
+                        flip(&x2->x[1],&x2->x[2]);
+                        flip(&y->x[1],&y->x[2]);
+                        //flip(&x[1],&x[2]);
+                        break;
+        }
+        // now comes the case system
+        D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
+        D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
+        D3 = y->x[0]/x1->x[0]*A-B1;
+        cout << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
+        if (fabs(D1) < MYEPSILON) {
+                cout << Verbose(2) << "D1 == 0!\n";
+                if (fabs(D2) > MYEPSILON) {
+                        cout << Verbose(3) << "D2 != 0!\n";
+                        x[2] = -D3/D2;
+                        E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
+                        E2 = -x1->x[1]/x1->x[0];
+                        cout << Verbose(3) << "E1 " << E1 << "\tE2 " << E2 << "\n";
+                        F1 = E1*E1 + 1.;
+                        F2 = -E1*E2;
+                        F3 = E1*E1 + D3*D3/(D2*D2) - C;
+                        cout << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
+                        if (fabs(F1) < MYEPSILON) {
+                                cout << Verbose(4) << "F1 == 0!\n";
+                                cout << Verbose(4) << "Gleichungssystem linear\n";
+                                x[1] = F3/(2.*F2);
+                        } else {
+                                p = F2/F1;
+                                q = p*p - F3/F1;
+                                cout << Verbose(4) << "p " << p << "\tq " << q << endl;
+                                if (q < 0) {
+                                        cout << Verbose(4) << "q < 0" << endl;
+                                        return false;
+                                }
+                                x[1] = p + sqrt(q);
+                        }
+                        x[0] =  A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
+                } else {
+                        cout << Verbose(2) << "Gleichungssystem unterbestimmt\n";
+                        return false;
+                }
+        } else {
+                E1 = A/x1->x[0]+x1->x[1]/x1->x[0]*D3/D1;
+                E2 = x1->x[1]/x1->x[0]*D2/D1 - x1->x[2];
+                cout << Verbose(2) << "E1 " << E1 << "\tE2 " << E2 << "\n";
+                F1 = E2*E2 + D2*D2/(D1*D1) + 1.;
+                F2 = -(E1*E2 + D2*D3/(D1*D1));
+                F3 = E1*E1 + D3*D3/(D1*D1) - C;
+                cout << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
+                if (fabs(F1) < MYEPSILON) {
+                        cout << Verbose(3) << "F1 == 0!\n";
+                        cout << Verbose(3) << "Gleichungssystem linear\n";
+                        x[2] = F3/(2.*F2);
+                } else {
+                        p = F2/F1;
+                        q = p*p - F3/F1;
+                        cout << Verbose(3) << "p " << p << "\tq " << q << endl;
+                        if (q < 0) {
+                                cout << Verbose(3) << "q < 0" << endl;
+                                return false;
+                        }
+                        x[2] = p + sqrt(q);
+                }
+                x[1] = (-D2 * x[2] - D3)/D1;
+                x[0] = A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
+        }
+        switch (flag) { // back-flipping
+                default:
+                case 0:
+                        break;
+                case 2:
+                        flip(&x1->x[0],&x1->x[1]);
+                        flip(&x2->x[0],&x2->x[1]);
+                        flip(&y->x[0],&y->x[1]);
+                        flip(&x[0],&x[1]);
+                        flip(&x1->x[1],&x1->x[2]);
+                        flip(&x2->x[1],&x2->x[2]);
+                        flip(&y->x[1],&y->x[2]);
+                        flip(&x[1],&x[2]);
+                case 1:
+                        flip(&x1->x[0],&x1->x[1]);
+                        flip(&x2->x[0],&x2->x[1]);
+                        flip(&y->x[0],&y->x[1]);
+                        //flip(&x[0],&x[1]);
+                        flip(&x1->x[1],&x1->x[2]);
+                        flip(&x2->x[1],&x2->x[2]);
+                        flip(&y->x[1],&y->x[2]);
+                        flip(&x[1],&x[2]);
+                        break;
+        }
+        // one z component is only determined by its radius (without sign)
+        // thus check eight possible sign flips and determine by checking angle with second vector
+        for (i=0;i<8;i++) {
+                // set sign vector accordingly
+                for (j=2;j>=0;j--) {
+                        k = (i & pot(2,j)) << j;
+                        cout << Verbose(2) << "k " << k << "\tpot(2,j) " << pot(2,j) << endl;
+                        sign[j] = (k == 0) ? 1. : -1.;
+                }
+                cout << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
+                // apply sign matrix
+                for (j=NDIM;j--;)
+                        x[j] *= sign[j];
+                // calculate angle and check
+                ang = x2->Angle (this);
+                cout << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
+                if (fabs(ang - cos(beta)) < MYEPSILON) {
+                        break;
+                }
+                // unapply sign matrix (is its own inverse)
+                for (j=NDIM;j--;)
+                        x[j] *= sign[j];
+        }
+        return true;
+};

src/vector.hpp

@@ -8 +8 @@
  */
 class Vector {
-  public:
-    double x[NDIM];
+        public:
+                double x[NDIM];
 
-  Vector();
-  Vector(double x1, double x2, double x3);
-  ~Vector();
+        Vector();
+        Vector(double x1, double x2, double x3);
+        ~Vector();
 
-  double Distance(const Vector *y) const;
-  double DistanceSquared(const Vector *y) const;
-  double PeriodicDistance(const Vector *y, const double *cell_size) const;
-  double ScalarProduct(const Vector *y) const;
-  double Projection(const Vector *y) const;
-  double Norm() const ;
-  double Angle(Vector *y) const;
+        double Distance(const Vector *y) const;
+        double DistanceSquared(const Vector *y) const;
+        double PeriodicDistance(const Vector *y, const double *cell_size) const;
+        double PeriodicDistanceSquared(const Vector *y, const double *cell_size) const;
+        double ScalarProduct(const Vector *y) const;
+        double Projection(const Vector *y) const;
+        double Norm() const ;
+        double Angle(const Vector *y) const;
 
-  void AddVector(const Vector *y);
-  void SubtractVector(const Vector *y);
-  void CopyVector(const Vector *y);
-  void RotateVector(const Vector *y, const double alpha);
-  void VectorProduct(const Vector *y);
-  void ProjectOntoPlane(const Vector *y);
-  void Zero();
-  void One(double one);
-  void Init(double x1, double x2, double x3);
-  void Normalize();
-  void Translate(const Vector *x);
-  void Mirror(const Vector *x);
-  void Scale(double **factor);
-  void Scale(double *factor);
-  void Scale(double factor);
-  void MatrixMultiplication(double *M);
-  void InverseMatrixMultiplication(double *M);
-  void KeepPeriodic(ofstream *out, double *matrix);
-  void LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors);
-
-  double CutsPlaneAt(Vector *A, Vector *B, Vector *C);
-  bool GetOneNormalVector(const Vector *x1);
-  bool MakeNormalVector(const Vector *y1);
-  bool MakeNormalVector(const Vector *y1, const Vector *y2);
-  bool MakeNormalVector(const Vector *x1, const Vector *x2, const Vector *x3);
-  bool SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c);
-  bool LSQdistance(Vector **vectors, int dim);
-
-  void AskPosition(double *cell_size, bool check);
-  bool Output(ofstream *out) const;
+        void AddVector(const Vector *y);
+        void SubtractVector(const Vector *y);
+        void CopyVector(const Vector *y);
+        void RotateVector(const Vector *y, const double alpha);
+        void VectorProduct(const Vector *y);
+        void ProjectOntoPlane(const Vector *y);
+        void Zero();
+        void One(double one);
+        void Init(double x1, double x2, double x3);
+        void Normalize();
+        void Translate(const Vector *x);
+        void Mirror(const Vector *x);
+        void Scale(double **factor);
+        void Scale(double *factor);
+        void Scale(double factor);
+        void MatrixMultiplication(double *M);
+        void InverseMatrixMultiplication(double *M);
+        void KeepPeriodic(ofstream *out, double *matrix);
+        void LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors);
+        double CutsPlaneAt(Vector *A, Vector *B, Vector *C);
+        bool GetOneNormalVector(const Vector *x1);
+        bool MakeNormalVector(const Vector *y1);
+        bool MakeNormalVector(const Vector *y1, const Vector *y2);
+        bool MakeNormalVector(const Vector *x1, const Vector *x2, const Vector *x3);
+        bool SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c);
+        bool LSQdistance(Vector **vectors, int dim);
+        void AskPosition(double *cell_size, bool check);
+        bool Output(ofstream *out) const;
 };
 
-ofstream& operator<<(ofstream& ost, Vector& m);
-Vector& operator+=(Vector& a, const Vector& b);
-Vector& operator*=(Vector& a, const double m);
-Vector& operator*(const Vector& a, const double m);
-Vector& operator+(const Vector& a, const Vector& b);
+ostream & operator << (ostream& ost, Vector &m);
+//Vector& operator+=(Vector& a, const Vector& b);
+//Vector& operator*=(Vector& a, const double m);
+//Vector& operator*(const Vector& a, const double m);
+//Vector& operator+(const Vector& a, const Vector& b);
 
 #endif /*VECTOR_HPP_*/

src/verbose.cpp

@@ -7 +7 @@
 ostream& Verbose::print (ostream &ost) const
 {
-  for (int i=Verbosity;i--;)
-    ost.put('\t');
-  //cout << "Verbose(.) called." << endl;
-  return ost;
+        for (int i=Verbosity;i--;)
+                ost.put('\t');
+        //cout << "Verbose(.) called." << endl;
+        return ost;
 };
 
@@ -35 +35 @@
         int bits = 1, counter = 1;
         while ((bits = 1 << counter) < BinaryNumber)
-    counter++;
-  for (int i=0;i<counter-1;i++) {
-        if ((BinaryNumber & (1 << i)) == 0)
-                ost.put('0');
+                counter++;
+        for (int i=0;i<counter-1;i++) {
+                if ((BinaryNumber & (1 << i)) == 0)
+                        ost.put('0');
                 else
-                ost.put('1');
-  }
-  ost.put('b');
-  //cout << "Binary(.) called." << endl;
-  return ost;
+                        ost.put('1');
+        }
+        ost.put('b');
+        //cout << "Binary(.) called." << endl;
+        return ost;
 };