Diff [0c7ed8641ea0c9f19538167d4633515f9dc0bc2e:1dc9ece817dde18f1ddda86a6a9bf1ceed029ec3] for / – MoleCuilder

configure.ac

-              r0c7ed8
+              r1dc9ec
 # Boost libraries
 AX_BOOST_BASE([1.33.1])
 #AX_BOOST_PROGRAM_OPTIONS
+AX_BOOST_BASE([1.40])
+AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_FOREACH
 #AX_BOOST_FILESYSTEM
 AX_BOOST_THREAD
-#AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_SERIALIZATION
 …
 # test suite
+AC_CONFIG_TESTDIR(tests)
+AC_CONFIG_FILES([tests/atlocal tests/Makefile])
+AC_CONFIG_FILES([tests/Tesselations/Makefile tests/Tesselations/defs])
+AC_CONFIG_FILES([tests/molecuilder], [chmod +x tests/molecuilder])
+AC_CONFIG_FILES([doc/molecuilder.xml])
+AC_CONFIG_FILES([Makefile src/Makefile doc/Makefile src/unittests/Makefile])
+AC_CONFIG_TESTDIR(tests/regression)
+AC_CONFIG_FILES([
+        tests/Makefile
+        tests/regression/atlocal
+        tests/regression/Makefile])
+AC_CONFIG_FILES([tests/regression/molecuilder], [chmod +x tests/regression/molecuilder])
+AC_CONFIG_FILES([
+        tests/Tesselations/Makefile
+        tests/Tesselations/defs])
+AC_CONFIG_FILES([
+        doc/molecuilder.xml])
+AC_CONFIG_FILES([
+        Makefile
+        doc/Makefile
+        src/Makefile
+        src/Actions/Makefile
+        src/UIElements/Makefile
+        src/unittests/Makefile])
 AC_OUTPUT

src/Actions/Action.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include <string>
 …
 using namespace std;
+Action::state_ptr getEmptyState() {
+  return Action::state_ptr(Memory::ignore(new ActionState()));
+}
 // An empty state to indicate success
 Action::state_ptr Action::success = Action::state_ptr(Memory::ignore(new ActionState()));
 Action::state_ptr Action::failure = Action::state_ptr(Memory::ignore(new ActionState()));
+Action::state_ptr Action::success = getEmptyState();
+Action::state_ptr Action::failure = getEmptyState();
 Action::Action(std::string _name,bool _doRegister) :

src/Actions/ActionHistory.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ActionHistory.hpp"

src/Actions/ActionRegistry.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include "Actions/ActionRegistry.hpp"
 …
+}
+bool ActionRegistry::isActionByNamePresent(const std::string name){
+  map<const string,Action*>::iterator iter;
+  iter = actionMap.find(name);
+  return iter!=actionMap.end();
+}
 void ActionRegistry::registerAction(Action* action){
   pair<map<const string,Action*>::iterator,bool> ret;
 …
+}
+void ActionRegistry::unregisterAction(Action* action){
+  actionMap.erase(action->getName());
+}
+std::map<const std::string,Action*>::iterator ActionRegistry::getBeginIter()
+{
+  return actionMap.begin();
+}
+std::map<const std::string,Action*>::iterator ActionRegistry::getEndIter()
+{
+  return actionMap.end();
+}
 CONSTRUCT_SINGLETON(ActionRegistry)

src/Actions/ActionRegistry.hpp

-              r0c7ed8
+              r1dc9ec
 public:
   Action* getActionByName(const std::string);
+  bool isActionByNamePresent(const std::string name);
   void registerAction(Action*);
+  void unregisterAction(Action*);
+  std::map<const std::string,Action*>::iterator getBeginIter();
+  std::map<const std::string,Action*>::iterator getEndIter();
 private:

src/Actions/ActionSequence.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Actions/ActionSequence.hpp"

src/Actions/ErrorAction.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/Actions/MakroAction.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <string>

src/Actions/ManipulateAtomsProcess.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ManipulateAtomsProcess.hpp"

src/Actions/MethodAction.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/Actions/Process.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "Process.hpp"
 …
 Process::Process(int _maxSteps, std::string _name, bool _doRegister) :
+  Observable("Process"),
   Action(_name,_doRegister),
   maxSteps(_maxSteps),

src/Descriptors/AtomDescriptor.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Descriptors/AtomDescriptor.hpp"

src/Descriptors/AtomIdDescriptor.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "AtomIdDescriptor.hpp"

src/Descriptors/AtomTypeDescriptor.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Descriptors/AtomTypeDescriptor.hpp"

src/Descriptors/MoleculeDescriptor.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Descriptors/MoleculeDescriptor.hpp"

src/Descriptors/MoleculeIdDescriptor.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "MoleculeIdDescriptor.hpp"

src/Exceptions/CustomException.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "CustomException.hpp"

src/Exceptions/LinearDependenceException.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "LinearDependenceException.hpp"

src/Exceptions/MathException.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "MathException.hpp"

src/Exceptions/SkewException.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "SkewException.hpp"

src/Exceptions/ZeroVectorException.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ZeroVectorException.hpp"

src/Helpers/Assert.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include "Helpers/Assert.hpp"
 …
 using namespace Assert;
+#ifndef NDEBUG
 Action _my_assert::defaultAction = Ask;
 std::vector<Assert::hook_t> _my_assert::hooks;
 …
 const char* _wrapper::message_ptr = "source pointer did not point to object of desired type";
 const char* _wrapper::message_ref = "source reference did not contain object of desired type";
 …
+{
   if(!res){
     cout << "Assertion " << condition << " failed in file " << filename << " at line " << line << endl;
+    cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
     cout << "Assertion Message: " << message << std::endl;
     while(true){
 …
   return ActionNames[defaultAction];
+}
+#endif

src/Helpers/MemDebug.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
 #include <iostream>
 #include <cstdlib>
 …
 #include <boost/thread.hpp>
+#ifdef __GNUC__
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif
 using namespace std;
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
+// we need our own low level mutexex, since we cannot assure the time of construction and destruction
+// otherwise
+#if defined(unix) || defined(__unix)
+#include <pthread.h>
+#include <cassert>
+#define mutex_t    pthread_mutex_t
+#define mutex_init PTHREAD_MUTEX_INITIALIZER
+#define mutex_lock(mtx) \
+  do{\
+    int res = pthread_mutex_lock(&(mtx));\
+    assert(!res && "Could not lock mutex!");\
+  }while(0)
+#define mutex_unlock(mtx) \
+  do{\
+    int res = pthread_mutex_unlock(&(mtx));\
+    assert(!res && "Could not unlock mutex!");\
+  }while(0)
+#else
+# error "No thread structure defined for this plattform..."
+#endif
 namespace Memory {
 …
       char file[length+1];
       int line;
+#ifdef __GNUC__  // function tracking only works with GCC
+      // function names can get looooong
+      enum {length2 = 256};
+      char function[length2+1];
+#endif
       size_t nbytes;
       bool isUsed;
 …
   };
+  boost::mutex memorylock;
+  mutex_t memorylock = mutex_init;
   // start and end of the doubly-linked list
 …
     for(entry_t *pos=begin;pos;pos=pos->next){
       cout << "\nChunk of " << pos->info.nbytes << " bytes" << " still available" << endl;
+#ifdef __GNUC__
+      cout << "Chunk reserved at: " << pos->info.function
+           << " (" << pos->info.file << ":" << pos->info.line  << ")" << endl;
+#else
       cout << "Chunk reserved at: " << pos->info.file << ":" << pos->info.line << endl;
+    }
+#endif
+    }
+  }
+  // Adds an entry to the linked list
+  void addEntry(entry_t *entry){
+    // check if the entry is already in the list
+    if(!entry->isIgnored)
+      return;
+    mutex_lock(Memory::memorylock);
+    entry->next=0;            // the created block is last in the list
+    entry->prev=Memory::end;  // the created block is last in the list
+    if(!Memory::begin){
+      // the list was empty... start a new one
+      Memory::begin=entry;
+    }
+    else {
+      // other blocks present... we can add to the last one
+      Memory::end->next=entry;
+    }
+    Memory::end=entry;
+    // update some global info
+    Memory::state  += entry->info.nbytes;
+    if(Memory::state>Memory::max){
+        Memory::max = Memory::state;
+    }
+    ++Memory::allocs;
+    // done with the list... it is safe to unlock now
+    mutex_unlock(Memory::memorylock);
+    entry->isIgnored = false;
+  }
 …
       return;
+    mutex_lock(memorylock);
     if(entry->prev){
       entry->prev->next = entry->next;
 …
       end = entry->prev;
+    }
+    Memory::state  -= entry->info.nbytes;
+    mutex_unlock(memorylock);
     entry->isIgnored = true;
+    Memory::state  -= entry->info.nbytes;
+  }
 …
     deleteEntry(entry);
+  }
+}
+void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+  // we need to lock, so that no one changes the linked list while we are here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
+#ifdef __GNUC__
+  // this function let's us find the caller's name
+  char* getCaller(){
+    // stack looks like this:
+    // getCaller();
+    // operator new();
+    // function_we_are_looking_for(); <-
+    const size_t max_depth = 3;
+    void* stack_addrs[max_depth];
+    size_t stack_depth;
+    char **stack_strings=0;
+    const char *func_name=0;
+    const char *toplevel = "Global scope";
+    char *retval=0;
+    // get the backtrace, depth three
+    stack_depth   = backtrace(stack_addrs,max_depth);
+    stack_strings = backtrace_symbols(stack_addrs, stack_depth);
+    // used later for demangling
+    // reserved here, so we can free it unconditionally
+    char *dm_function = static_cast<char*>(malloc(entry_t::info_t::length2));
+    if(!dm_function){
+      // malloc failed... we are out of luck
+      throw std::bad_alloc();
+    }
+    // see if we found our function name
+    if(stack_depth==max_depth){
+      // find the mangled function name
+      char *begin = stack_strings[max_depth-1];
+      // function name starts with a (
+      while(*begin && *begin!='(') ++begin;
+      char *end=begin;
+      while(*end && *end!='+') ++end;
+      // see if we found our function name
+      if(*begin && *end){
+        *begin++ = 0;
+        *end = 0;
+        // use the C++ demangler
+        size_t sz = entry_t::info_t::length2;
+        int status;
+        char *func_ret = abi::__cxa_demangle(begin, dm_function, &sz, &status);
+        if(func_ret){
+          // abi might have realloced...
+          dm_function = func_ret;
+          func_name = dm_function;
+        }
+        else{
+          // demangling failed... get the function name without demangling
+          func_name = begin;
+        }
+      }
+      else{
+        // function name not found... get the whole line
+        func_name = stack_strings[max_depth-1];
+      }
+    }
+    else{
+      func_name = toplevel;
+    }
+    // now we copy the desired function name
+    if((retval = static_cast<char*>(malloc(strlen(func_name)+1)))){
+      // we know that the string will fit, so strcpy is safe here
+      strcpy(retval,func_name);
+    }
+    else{
+      free(stack_strings); // malloc()ed by backtrace_symbols
+      free(dm_function);
+      // uh-uh ... seems we are out of luck for allocations now
+      throw std::bad_alloc();
+    }
+    free(dm_function);
+    free(stack_strings); // malloc()ed by backtrace_symbols
+    return retval;
+  }
+#endif
+}
+#ifdef __GNUC__
+void *operator new(size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
   // to avoid allocations of 0 bytes if someone screws up
 …
+  }
+  // we got the space, so update the global info
+  Memory::state += nbytes;
+  if(Memory::state>Memory::max){
+    Memory::max = Memory::state;
+  }
+  Memory::allocs++;
+  // build the entry in front of the space
+  Memory::entry_t *entry = (Memory::entry_t*) res;
+  memset(res,0,entrySpace);
+  entry->info.nbytes = nbytes;
+  entry->info.isUsed = true;
+  strncpy(entry->info.file,file,Memory::entry_t::info_t::length);
+  entry->info.file[Memory::entry_t::info_t::length] = '\0';
+  entry->info.line=line;
+  strncpy(entry->info.function,func,Memory::entry_t::info_t::length2);
+  entry->info.function[Memory::entry_t::info_t::length2] = '\0';
+  // the space starts behind the info
+  entry->info.location = (char*)res + entrySpace;
+  // mark the block as not in the list (will be changed by addEntry)
+  entry->isIgnored = true;
+  Memory::addEntry(entry);
+  // get the checksum...
+  entry->checksum = Memory::calcChecksum(&entry->info);
+  // ok, space is prepared... the user can have it.
+  // the rest (constructor, deleting when something is thrown etc)
+  // is handled automatically
+  return entry->info.location;
+}
+#else
+void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+  // to avoid allocations of 0 bytes if someone screws up
+  // allocation with 0 byte size are undefined behavior, so we are
+  // free to handle it this way
+  if(!nbytes) {
+    nbytes = 1;
+  }
+  // get the size of the entry, including alignment
+  static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
+  void *res;
+  if(!(res=malloc(entrySpace + nbytes))){
+    // new must throw, when space is low
+    throw std::bad_alloc();
+  }
   // build the entry in front of the space
 …
   entry->info.location = (char*)res + entrySpace;
+  // add the entry at the end of the list
+  entry->next=0;            // the created block is last in the list
+  entry->prev=Memory::end;  // the created block is last in the list
+  if(!Memory::begin){
+    // the list was empty... start a new one
+    Memory::begin=entry;
+  }
+  else {
+    // other blocks present... we can add to the last one
+    Memory::end->next=entry;
+  }
+  Memory::end=entry;
+  // mark the block as not in the list (will be changed by addEntry)
+  entry->isIgnored = true;
+  Memory::addEntry(entry);
   // get the checksum...
 …
+}
+#endif
 void *operator new(size_t nbytes) throw(std::bad_alloc) {
   // Just forward to the other operator, when we do not know from
   // where the allocation came
+#ifdef __GNUC__
+  // this might throw bad_alloc
+  char *caller = Memory::getCaller();
+  void* retval = 0;
+  // if this throws, we have to clean up the caller anyway
+  try{
+    retval = operator new(nbytes,"Unknown",0,caller);
+  }
+  catch(...)
+  {
+    free(caller); // malloc()ed by Memory::getCaller();
+    throw;
+  }
+  free(caller); // malloc()ed by Memory::getCaller();
+  return retval;
+#else
   return operator new(nbytes,"Unknown",0);
+}
+#endif
+}
+#ifdef __GNUC__
+void *operator new[] (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
+  // The difference between new and new[] is just for compiler bookkeeping.
+  return operator new(nbytes,file,line,func);
+}
+#else
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
 …
+}
+#endif
 void *operator new[] (size_t nbytes) throw(std::bad_alloc) {
   // Forward again
+#ifdef __GNUC__
+  // this might throw bad_alloc
+    char *caller = Memory::getCaller();
+    void *retval=0;
+    // if this throws, we have to clean up the caller anyway
+    try{
+      retval = operator new[] (nbytes,"Unknown",0,caller);
+    }
+    catch(...)
+    {
+      free(caller); // malloc()ed by Memory::getCaller();
+      throw;
+    }
+    free(caller); // malloc()ed by Memory::getCaller();
+    return retval;
+#else
   return operator new[] (nbytes,"Unknown",0);
+#endif
+}
 …
     return;
+  }
-  // we need to lock, so the linked list does not changed while we are in here
-  boost::mutex::scoped_lock guard(Memory::memorylock);
   // get the size for the entry, including alignment

src/Helpers/MemDebug.hpp

-              r0c7ed8
+              r1dc9ec
 #endif
+#include <new>
+// some light header files, that do weird new stuff and therefore need
+// to be loaded before the define
+#include <string>
+#include <boost/optional.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/program_options.hpp>
 namespace Memory {
 …
+  }
+}
+#ifdef __GNUC__
+void *operator new   (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc);
+void *operator new[] (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc);
+#else
 void *operator new   (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
+#endif
 void operator delete   (void *ptr,const char*, int) throw();
 void operator delete[] (void *ptr,const char*, int) throw();
 /**
 …
  * version that allows tracking.
  */
+#ifdef __GNUC__
+#define new new(__FILE__,__LINE__,__PRETTY_FUNCTION__)
+#else
 #define new new(__FILE__,__LINE__)
+#endif
 #endif
 #endif
+#ifdef NDEBUG
+#undef MEMDEBUG
+#endif
 #ifndef MEMDEBUG

src/Legacy/oldmenu.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include "Legacy/oldmenu.hpp"
 …
 #include "Menu/DisplayMenuItem.hpp"
 #include "Menu/SubMenuItem.hpp"
+#include "Actions/MapOfActions.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/ErrorAction.hpp"
 …
         Dialog *dialog = UIFactory::getInstance().makeDialog();
         first = World::getInstance().createAtom();
+        std::vector<element *> elements;
         dialog->queryVector("Please enter coordinates: ",&first->x,World::getInstance().getDomain(), false);
         dialog->queryElement("Please choose element: ",&first->type);
+        dialog->queryElement("Please choose element: ",&elements);
         if(dialog->display()){
+          mol->AddAtom(first);  // add to molecule
+          if (elements.size() == 1) {
+            first->type = elements.at(0);
+            mol->AddAtom(first);  // add to molecule
+          } else {
+            DoeLog(1) && (eLog() << Verbose(1) << "Unequal to one element given for element of new atom." << endl);
+          }
+        }
         else{
 …
 void oldmenu::RemoveAtoms(molecule *mol)
+{
   atom *first, *second;
+  atom *second;
   int axis;
   double tmp1, tmp2;
 …
       break;
     case 'b':
       second = mol->AskAtom("Enter number of atom as reference point: ");
       Log() << Verbose(0) << "Enter radius: ";
       cin >> tmp1;
       first = mol->start;
       second = first->next;
       while(second != mol->end) {
         first = second;
         second = first->next;
         if (first->x.DistanceSquared(second->x) > tmp1*tmp1) // distance to first above radius ...
           mol->RemoveAtom(first);
+      {
+        second = mol->AskAtom("Enter number of atom as reference point: ");
+        Log() << Verbose(0) << "Enter radius: ";
+        cin >> tmp1;
+        molecule::iterator runner;
+        for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+          runner = iter++;
+          if ((*runner)->x.DistanceSquared((*runner)->x) > tmp1*tmp1) // distance to first above radius ...
+            mol->RemoveAtom((*runner));
+        }
+      }
       break;
 …
       Log() << Verbose(0) << "Upper boundary: ";
       cin >> tmp2;
+      first = mol->start;
+      second = first->next;
+      while(second != mol->end) {
+        first = second;
+        second = first->next;
+        if ((first->x[axis] < tmp1) || (first->x[axis] > tmp2)) {// out of boundary ...
+          //Log() << Verbose(0) << "Atom " << *first << " with " << first->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
+          mol->RemoveAtom(first);
+      molecule::iterator runner;
+      for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+        runner = iter++;
+        if (((*runner)->x[axis] < tmp1) || ((*runner)->x[axis] > tmp2)) {// out of boundary ...
+          //Log() << Verbose(0) << "Atom " << *(*runner) << " with " << (*runner)->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
+          mol->RemoveAtom((*runner));
+        }
+      }
 …
         min[i] = 0.;
+      second = mol->start;
+      while ((second->next != mol->end)) {
+        second = second->next; // advance
+        Z = second->type->Z;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Z = (*iter)->type->Z;
         tmp1 = 0.;
         if (first != second) {
           x = first->x - second->x;
+        if (first != (*iter)) {
+          x = first->x - (*iter)->x;
           tmp1 = x.Norm();
+        }
         if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
         //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << ((*iter)->nr << ": " << tmp1 << " a.u." << endl;
+      }
       for (int i=MAX_ELEMENTS;i--;)
 …
   Log() << Verbose(0) << "What's the desired bond order: ";
   cin >> Order1;
   if (mol->first->next != mol->last) {  // there are bonds
+  if (mol->hasBondStructure()) {
     start = clock();
     mol->FragmentMolecule(Order1, configuration);
 …
     Log() << Verbose(0) << "State the factor: ";
     cin >> faktor;
+    mol->CountAtoms(); // 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
+    if (mol->getAtomCount() != 0) {  // if there is more than none
+      count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
       Elements = new const 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;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Elements[j] = (*iter)->type;
+        vectors[j] = &(*iter)->x;
         j++;
+      }
 …
+        }
+      }
       if (mol->first->next != mol->last) // if connect matrix is present already, redo it
+      if (mol->hasBondStructure())
         mol->CreateAdjacencyList(mol->BondDistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
       // free memory
 …
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of destination molecule: ",&destmol, molecules);
   dialog->queryMolecule("Enter index of source molecule to add from: ",&srcmol, molecules);
+  dialog->queryMolecule("molecule-by-id",&destmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryMolecule("molecule-by-id",&srcmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
   if(dialog->display()) {
     molecules->SimpleAdd(srcmol, destmol);
 …
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of matrix molecule (the variable one): ",&srcmol,molecules);
   dialog->queryMolecule("Enter index of molecule to merge into (the fixed one): ",&destmol,molecules);
+  dialog->queryMolecule("molecule-by-id",&destmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryMolecule("molecule-by-id",&srcmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
   if(dialog->display()) {
     molecules->EmbedMerge(destmol, srcmol);
 …
     return;
+  }
-  atom *Walker = mol->start;
   // generate some KeySets
   Log() << Verbose(0) << "Generating KeySets." << endl;
   KeySet TestSets[mol->AtomCount+1];
+  KeySet TestSets[mol->getAtomCount()+1];
   i=1;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     for (int j=0;j<i;j++) {
       TestSets[j].insert(Walker->nr);
+      TestSets[j].insert((*iter)->nr);
+    }
     i++;
 …
   Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
   KeySetTestPair test;
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  if (test.second) {
+    Log() << Verbose(1) << "Insertion worked?!" << endl;
+  molecule::const_iterator iter = mol->begin();
+  if (iter != mol->end()) {
+    test = TestSets[mol->getAtomCount()-1].insert((*iter)->nr);
+    if (test.second) {
+      Log() << Verbose(1) << "Insertion worked?!" << endl;
+    } else {
+      Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+    }
   } else {
+    Log() << 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);
+    eLog() << Verbose(1) << "No atoms to test double insertion." << endl;
+  }
   // constructing Graph structure
 …
   // insert KeySets into Subgraphs
   Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
   for (int j=0;j<mol->AtomCount;j++) {
+  for (int j=0;j<mol->getAtomCount();j++) {
     Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
   Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl;
   GraphTestPair test2;
   test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     Log() << Verbose(1) << "Insertion worked?!" << endl;

src/Line.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Line.hpp"

src/Makefile.am

-              r0c7ed8
+              r1dc9ec
+# PLEASE adhere to the alphabetical ordering in this Makefile!
+# Also indentation by a single tab
+SUBDIRS = Actions UIElements
 # this includes source files that need to be present at multiple points
+HELPERSOURCE =  Helpers/Assert.cpp \
+                                Helpers/MemDebug.cpp
+HELPERSOURCE =  \
+  Helpers/Assert.cpp \
+  Helpers/MemDebug.cpp
+ATOMSOURCE = atom.cpp atom_atominfo.cpp atom_bondedparticle.cpp atom_bondedparticleinfo.cpp atom_graphnode.cpp atom_graphnodeinfo.cpp atom_particleinfo.cpp atom_trajectoryparticle.cpp atom_trajectoryparticleinfo.cpp
+ATOMHEADER = atom.hpp atom_atominfo.hpp atom_bondedparticle.hpp atom_bondedparticleinfo.hpp atom_graphnode.hpp atom_graphnodeinfo.hpp atom_particleinfo.hpp atom_trajectoryparticle.hpp atom_trajectoryparticleinfo.hpp
+LINALGSOURCE = ${HELPERSOURCE} \
+               gslmatrix.cpp \
+                           gslvector.cpp \
+                           linearsystemofequations.cpp \
+                           Space.cpp \
+                           vector.cpp
+ATOMSOURCE = \
+  atom.cpp \
+  atom_atominfo.cpp \
+  atom_bondedparticle.cpp \
+  atom_bondedparticleinfo.cpp \
+  atom_graphnode.cpp \
+  atom_graphnodeinfo.cpp \
+  atom_particleinfo.cpp \
+  atom_trajectoryparticle.cpp \
+  atom_trajectoryparticleinfo.cpp
+ATOMHEADER = \
+  atom.hpp \
+  atom_atominfo.hpp \
+  atom_bondedparticle.hpp \
+  atom_bondedparticleinfo.hpp \
+  atom_graphnode.hpp \
+  atom_graphnodeinfo.hpp \
+  atom_particleinfo.hpp \
+  atom_trajectoryparticle.hpp \
+  atom_trajectoryparticleinfo.hpp
+LINALGSOURCE = \
+  ${HELPERSOURCE} \
+  gslmatrix.cpp \
+  gslvector.cpp \
+  linearsystemofequations.cpp \
+  Space.cpp \
+  vector.cpp
 LINALGHEADER = gslmatrix.hpp \
                            gslvector.hpp \
                            linearsystemofequations.hpp \
                            Space.hpp \
                            vector.hpp
+  gslvector.hpp \
+  linearsystemofequations.hpp \
+  Space.hpp \
+  vector.hpp
+ANALYSISSOURCE = analysis_bonds.cpp analysis_correlation.cpp
+ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
+ACTIONSSOURCE = Actions/Action.cpp \
+                                Actions/ActionHistory.cpp \
+                                Actions/ActionRegistry.cpp \
+                                Actions/ActionSequence.cpp \
+                                Actions/ErrorAction.cpp \
+                                Actions/MakroAction.cpp \
+                                Actions/ManipulateAtomsProcess.cpp \
+                                Actions/MethodAction.cpp \
+                Actions/Process.cpp \
+                Actions/small_actions.cpp
+ACTIONSHEADER = Actions/Action.hpp \
+                                Actions/ActionHistory.hpp \
+                                Actions/ActionRegistry.hpp \
+                                Actions/ActionSequence.hpp \
+                            Actions/Calculation.hpp \
+                            Actions/Calculation_impl.hpp \
+                            Actions/ErrorAction.hpp \
+                            Actions/MakroAction.hpp \
+                            Actions/ManipulateAtomsProcess.hpp \
+                            Actions/MethodAction.hpp \
+                            Actions/Process.hpp \
+                            Actions/small_actions.hpp
+PATTERNSOURCE = Patterns/Observer.cpp
+PATTERNHEADER = Patterns/Cacheable.hpp \
+                                Patterns/Observer.hpp \
+                Patterns/Singleton.hpp
+VIEWSOURCE = Views/View.cpp Views/StringView.cpp Views/MethodStringView.cpp Views/StreamStringView.cpp
+VIEWHEADER = Views/View.hpp Views/StringView.hpp Views/MethodStringView.hpp Views/StreamStringView.hpp
+MENUSOURCE = Menu/Menu.cpp Menu/TextMenu.cpp Menu/MenuItem.cpp Menu/SubMenuItem.cpp Menu/ActionMenuItem.cpp Menu/SeperatorItem.cpp Menu/DisplayMenuItem.cpp
+MENUHEADER = Menu/Menu.hpp Menu/TextMenu.hpp Menu/MenuItem.hpp Menu/SubMenuItem.hpp Menu/ActionMenuItem.hpp Menu/SeperatorItem.hpp Menu/DisplayMenuItem.hpp
+UISOURCE = ${ACTIONSSOURCE} ${VIEWSOURCE} ${MENUSOURCE} UIElements/UIFactory.cpp UIElements/TextUIFactory.cpp UIElements/MainWindow.cpp UIElements/TextWindow.cpp UIElements/TextStatusIndicator.cpp UIElements/Dialog.cpp UIElements/TextDialog.cpp
+UIHEADER = ${ACTIONSHEADER} ${VIEWHEADER} ${MENUHEADER} UIElements/UIFactory.hpp UIElements/TextUIFactory.hpp UIElements/MainWindow.hpp UIElements/TextWindow.hpp UIElements/TextStatusIndicator.hpp UIElements/Dialog.hpp UIElements/TextDialog.hpp
+ANALYSISSOURCE = \
+  analysis_bonds.cpp \
+  analysis_correlation.cpp
+ANALYSISHEADER = \
+  analysis_bonds.hpp \
+  analysis_correlation.hpp
+ACTIONSSOURCE = \
+  Actions/Action.cpp \
+  Actions/ActionHistory.cpp \
+  Actions/ActionRegistry.cpp \
+  Actions/ActionSequence.cpp \
+  Actions/ErrorAction.cpp \
+  Actions/MakroAction.cpp \
+  Actions/ManipulateAtomsProcess.cpp \
+  Actions/MethodAction.cpp \
+  Actions/Process.cpp
+ACTIONSHEADER = \
+  ${ANALYSISACTIONHEADER} \
+  ${ATOMACTIONHEADER} \
+  ${CMDACTIONHEADER} \
+  ${FRAGMENTATIONACTIONHEADER} \
+  ${MOLECULEACTIONHEADER} \
+  ${PARSERACTIONHEADER} \
+  ${TESSELATIONACTIONHEADER} \
+  ${WORLDACTIONHEADER} \
+  Actions/Action.hpp \
+  Actions/ActionHistory.hpp \
+  Actions/ActionRegistry.hpp \
+  Actions/ActionSequence.hpp \
+  Actions/Calculation.hpp \
+  Actions/Calculation_impl.hpp \
+  Actions/ErrorAction.hpp \
+  Actions/MakroAction.hpp \
+  Actions/ManipulateAtomsProcess.hpp \
+  Actions/MapOfActions.hpp \
+  Actions/MethodAction.hpp \
+  Actions/Process.hpp
+PARSERSOURCE = \
+  Parser/ChangeTracker.cpp \
+  Parser/FormatParser.cpp \
+  Parser/TremoloParser.cpp \
+  Parser/XyzParser.cpp
+PARSERHEADER = \
+  Parser/ChangeTracker.hpp \
+  Parser/FormatParser.hpp \
+  Parser/TremoloParser.hpp \
+  Parser/XyzParser.hpp
+PATTERNSOURCE = \
+  Patterns/Observer.cpp
+PATTERNHEADER = \
+  Patterns/Cacheable.hpp \
+  Patterns/Observer.hpp \
+  Patterns/Singleton.hpp
 # all these files are only used for legacy reasons while the transition is in progress
 …
 DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp \
+                                   Descriptors/AtomIdDescriptor.cpp \
+                                   Descriptors/AtomTypeDescriptor.cpp \
+                                   Descriptors/MoleculeDescriptor.cpp \
+                                   Descriptors/MoleculeIdDescriptor.cpp
+  Descriptors/AtomIdDescriptor.cpp \
+  Descriptors/AtomTypeDescriptor.cpp \
+  Descriptors/MoleculeDescriptor.cpp \
+  Descriptors/MoleculeIdDescriptor.cpp \
+  Descriptors/MoleculeNameDescriptor.cpp \
+  Descriptors/MoleculePtrDescriptor.cpp
+DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
+  Descriptors/AtomIdDescriptor.hpp \
+  Descriptors/AtomTypeDescriptor.hpp \
+  Descriptors/MoleculeDescriptor.hpp \
+  Descriptors/MoleculeIdDescriptor.hpp \
+  Descriptors/MoleculeNameDescriptor.hpp \
+  Descriptors/MoleculePtrDescriptor.hpp
-DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
-                                   Descriptors/AtomIdDescriptor.hpp \
-                                   Descriptors/AtomTypeDescriptor.hpp \
-                                   Descriptors/MoleculeDescriptor.hpp \
-                                   Descriptors/MoleculeIdDescriptor.hpp
 EXCEPTIONSOURCE = Exceptions/CustomException.cpp \
                                   Exceptions/LinearDependenceException.cpp \
 …
                                   Exceptions/ZeroVectorException.hpp
+SOURCE = ${ANALYSISSOURCE} \
+                 ${ATOMSOURCE} \
+                 ${PATTERNSOURCE} \
+                 ${UISOURCE} \
+                 ${DESCRIPTORSOURCE} \
+                 ${HELPERSOURCE} \
+                 ${LEGACYSOURCE} \
+                 ${EXCEPTIONSOURCE} \
+                 bond.cpp \
+                 bondgraph.cpp \
+                 boundary.cpp \
+                 config.cpp \
+                 element.cpp \
+                 ellipsoid.cpp \
+                 errorlogger.cpp \
+                 graph.cpp \
+                 helpers.cpp \
+                 info.cpp \
+                 leastsquaremin.cpp \
+                 Line.cpp \
+                 linkedcell.cpp \
+                 lists.cpp \
+                 log.cpp \
+                 logger.cpp \
+                 memoryusageobserver.cpp \
+                 moleculelist.cpp \
+                 molecule.cpp \
+                 molecule_dynamics.cpp \
+                 molecule_fragmentation.cpp \
+                 molecule_geometry.cpp \
+                 molecule_graph.cpp \
+                 molecule_pointcloud.cpp \
+                 parser.cpp \
+                 periodentafel.cpp \
+                 Plane.cpp \
+                 tesselation.cpp \
+                 tesselationhelpers.cpp \
+                 triangleintersectionlist.cpp \
+                 verbose.cpp \
+                 vector_ops.cpp \
+                 World.cpp
+SOURCE = \
+  ${ANALYSISSOURCE} \
+  ${ACTIONSSOURCE} \
+  ${ATOMSOURCE} \
+  ${PATTERNSOURCE} \
+  ${PARSERSOURCE} \
+  ${DESCRIPTORSOURCE} \
+  ${HELPERSOURCE} \
+  ${LEGACYSOURCE} \
+  ${EXCEPTIONSOURCE} \
+  bond.cpp \
+  bondgraph.cpp \
+  boundary.cpp \
+  CommandLineParser.cpp \
+  config.cpp \
+  element.cpp \
+  elements_db.cpp \
+  ellipsoid.cpp \
+  errorlogger.cpp \
+  graph.cpp \
+  helpers.cpp \
+  info.cpp \
+  leastsquaremin.cpp \
+  Line.cpp \
+  linkedcell.cpp \
+  log.cpp \
+  logger.cpp \
+  moleculelist.cpp \
+  molecule.cpp \
+  molecule_dynamics.cpp \
+  molecule_fragmentation.cpp \
+  molecule_geometry.cpp \
+  molecule_graph.cpp \
+  molecule_pointcloud.cpp \
+  parser.cpp \
+  periodentafel.cpp \
+  Plane.cpp \
+  Space.cpp \
+  tesselation.cpp \
+  tesselationhelpers.cpp \
+  triangleintersectionlist.cpp \
+  vector.cpp \
+  vector_ops.cpp \
+  verbose.cpp \
+  World.cpp
 HEADER = \
+          ${ANALYSISHEADER} \
+          ${ATOMHEADER} \
+          ${PATTERNHEADER} \
+          ${UIHEADER} \
+          ${DESCRIPTORHEADER} \
+          ${EXCEPTIONHEADER} \
+          ${LEGACYHEADER} \
+          bond.hpp \
+          bondgraph.hpp \
+          boundary.hpp \
+          config.hpp \
+          defs.hpp \
+          element.hpp \
+          ellipsoid.hpp \
+          errorlogger.hpp \
+          graph.hpp \
+          helpers.hpp \
+          info.hpp \
+          leastsquaremin.hpp \
+          Line.hpp \
+          linkedcell.hpp \
+          lists.hpp \
+          log.hpp \
+          logger.hpp \
+          memoryallocator.hpp \
+          memoryusageobserver.hpp \
+          molecule.hpp \
+          molecule_template.hpp \
+          parser.hpp \
+          periodentafel.hpp \
+          Plane.hpp \
+          stackclass.hpp \
+          tesselation.hpp \
+          tesselationhelpers.hpp \
+          triangleintersectionlist.hpp \
+          verbose.hpp \
+          vector_ops.hpp \
+          World.hpp
+  ${ANALYSISHEADER} \
+  ${ACTIONSHEADER} \
+  ${ATOMHEADER} \
+  ${PARSERHEADER} \
+  ${PATTERNHEADER} \
+  ${DESCRIPTORHEADER} \
+  ${EXCEPTIONHEADER} \
+  ${LEGACYHEADER} \
+  bond.hpp \
+  bondgraph.hpp \
+  boundary.hpp \
+  CommandLineParser.hpp \
+  config.hpp \
+  defs.hpp \
+  element.hpp \
+  elements_db.hpp \
+  ellipsoid.hpp \
+  errorlogger.hpp \
+  graph.hpp \
+  helpers.hpp \
+  info.hpp \
+  leastsquaremin.hpp \
+  Line.hpp \
+  linkedcell.hpp \
+  lists.hpp \
+  log.hpp \
+  logger.hpp \
+  molecule.hpp \
+  molecule_template.hpp \
+  parser.hpp \
+  periodentafel.hpp \
+  Plane.hpp \
+  stackclass.hpp \
+  tesselation.hpp \
+  tesselationhelpers.hpp \
+  triangleintersectionlist.hpp \
+  verbose.hpp \
+  vector_ops.hpp \
+  World.hpp
+# the following files are no longer used:
+#  memoryallocator.hpp \
+#  memoryallocator.cpp \
+#  memoryusageobserver.hpp \
+#  memoryusageobserver.cpp
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
 INCLUDES = -I$(top_srcdir)/src/unittests
+INCLUDES = -I$(top_srcdir)/src/unittests -I$(top_srcdir)/src/Actions -I$(top_srcdir)/src/UIElements
 noinst_LIBRARIES = libmolecuilder.a libgslwrapper.a
 …
 molecuilder_LDFLAGS = $(BOOST_LDFLAGS)
 molecuilder_SOURCES = builder.cpp
 molecuilder_LDADD = libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+molecuilder_LDADD =  UIElements/libMolecuilderUI.a Actions/libMolecuilderActions.a libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}
 joiner_SOURCES = joiner.cpp datacreator.cpp parser.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp
 joiner_LDADD = libmolecuilder.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 analyzer_SOURCES = analyzer.cpp datacreator.cpp parser.cpp helpers.hpp periodentafel.hpp parser.hpp datacreator.hpp
 analyzer_LDADD = libmolecuilder.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
-#EXTRA_DIST = ${molecuilder_DATA}
 FORCE:

src/Patterns/Cacheable.hpp

-              r0c7ed8
+              r1dc9ec
         owner(_owner)
         {}
       virtual T getValue()=0;
+      virtual T& getValue()=0;
       virtual void invalidate()=0;
       virtual bool isValid()=0;
 …
         return busy;
+      }
+    virtual std::string getName()=0;
     protected:
       bool busy;
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         // set the state to valid
         State::owner->switchState(State::owner->validState);
 …
         // nothing to do when entering this
+      }
+      virtual std::string getName(){
+        return "invalid";
+      }
     };
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         return content;
+      }
 …
         State::busy = false;
+      }
+      virtual std::string getName(){
+        return "valid";
+      }
     private:
       T content;
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         ASSERT(0,"Cannot get a value from a Cacheable after it's Observable has died");
         // we have to return a grossly invalid reference, because no value can be produced anymore
 …
         // nothing to do when entering this state
+      }
+      virtual std::string getName(){
+        return "destroyed";
+      }
     };
 …
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name);
     virtual ~Cacheable();
 …
     void subjectKilled(Observable *subject);
   private:
     void switchState(state_ptr newState);
 …
     Observable *owner;
     boost::function<T()> recalcMethod;
 …
   template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
+    Observer(name + "(Cached)"),
     owner(_owner),
     recalcMethod(_recalcMethod)
 …
   void Cacheable<T>::switchState(state_ptr newState){
     ASSERT(!state->isBusy(),"LOOP DETECTED: Cacheable state switched while recalculating.\nDid the recalculation trigger the Observable?");
+#ifdef LOG_OBSERVER
+    observerLog().addMessage() << "## Cacheable " << observerLog().getName(this) << " changed state (" << state->getName()
+                               << "->" << newState->getName() << ")" << std::endl;
+#endif
     state = newState;
     state->enter();
 …
+  {
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod,std::string name);
     virtual ~Cacheable();
 …
   template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
+    Observer(name),
     recalcMethod(_recalcMethod)
   {}

src/Patterns/Observer.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "Observer.hpp"
 …
 #include "Helpers/Assert.hpp"
+#include "Helpers/MemDebug.hpp"
 using namespace std;
 …
   // if no entry for this observable is found, an new one is created
   // by the STL and initialized to 0 (see STL documentation)
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << ">> Locking " << observerLog().getName(publisher) << endl;
+#endif
   depth[publisher]++;
+}
 …
   // if zero is reached all observed blocks are done and we can
   // start to notify our observers
+  if(--(depth[publisher])){}
+  --depth[publisher];
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << "<< Unlocking " << observerLog().getName(publisher) << endl;
+#endif
+  if(depth[publisher]){}
   else{
     publisher->notifyAll();
 …
 Observable::_Observable_protector::_Observable_protector(Observable *_protege) :
   protege(_protege)
+{
+  start_observer_internal(protege);
+}
+Observable::_Observable_protector::_Observable_protector(const _Observable_protector &dest) :
+    protege(dest.protege)
+{
   start_observer_internal(protege);
 …
       callees_t::iterator iter;
       for(iter=callees.begin();iter!=callees.end();++iter){
+#ifdef LOG_OBSERVER
+        observerLog().addMessage() << "-> Sending update from " << observerLog().getName(this)
+                                   << " to " << observerLog().getName((*iter).second)
+                                   << " (priority=" << (*iter).first << ")"<< endl;
+#endif
         (*iter).second->update(this);
+      }
 …
     // we do not need to publish all the changes at each time we are called
     if(depth.find(this)==depth.end()) {
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-* Update from " << observerLog().getName(publisher)
+                                 << " propagated by " << observerLog().getName(this) << endl;
+#endif
       notifyAll();
+    }
+    else{
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-| Update from " <<  observerLog().getName(publisher)
+                                 << " not propagated by " << observerLog().getName(this) << endl;
+#endif
+    }
+  }
 …
 void Observable::signOn(Observer *target,int priority) {
   ASSERT(priority>=-20 && priority<=+20, "Priority out of range [-20:+20] when signing on Observer");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "@@ Signing on " << observerLog().getName(target) << " to " << observerLog().getName(this) << endl;
+#endif
   bool res = false;
   callees_t &callees = callTable[this];
 …
 void Observable::signOff(Observer *target) {
   ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "** Signing off " << observerLog().getName(target) << " from " << observerLog().getName(this) << endl;
+#endif
   callees_t &callees = callTable[this];
   callees_t::iterator iter;
   callees_t::iterator deliter;
 …
 /** Constructor for class Observable.
  */
+Observable::Observable()
+{}
+Observable::Observable(string name) :
+  Observer(Observer::BaseConstructor())
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observable " << observerLog().getName(this) << endl;
+#endif
+}
 /** Destructor for class Observable.
 …
 Observable::~Observable()
+{
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "-- Destroying Observable " << observerLog().getName(this) << endl;
+#endif
   if(callTable.count(this)) {
     // delete all entries for this observable
 …
 /** Constructor for class Observer.
  */
+Observer::Observer()
+{}
+Observer::Observer(string name)
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observer " << observerLog().getName(this) << endl;
+#endif
+}
+/**
+ * Base Constructor for class Observer
+ *
+ * only called from Observable Constructor
+ */
+Observer::Observer(Observer::BaseConstructor){
+#ifdef LOG_OBSERVER
+  observerLog().addObservable(this);
+#endif
+}
 /** Destructor for class Observer.
  */
 Observer::~Observer()
+{}
+{
+#ifdef LOG_OBSERVER
+  if(!observerLog().isObservable(this)){
+    observerLog().addMessage() << "-- Destroying Observer " << observerLog().getName(this) << endl;
+  }
+#endif
+}
 /**
 …
+  }
+}
+#ifdef LOG_OBSERVER
+/************************* Methods to do logging of the Observer Mechanism *********/
+// The log needs to exist fairly early, so we make it construct on first use,
+// and never destroy it
+ObserverLog &observerLog(){
+  // yes, this memory is never freed... we need it around for the whole programm,
+  // so no freeing is possible
+  static ObserverLog *theLog = Memory::ignore(new ObserverLog());
+  return *theLog;
+}
+ObserverLog::ObserverLog() :
+  count (0)
+{}
+ObserverLog::~ObserverLog(){}
+string ObserverLog::getLog(){return log.str();}
+std::string ObserverLog::getName(void* obj){
+  return names[obj];
+}
+bool ObserverLog::isObservable(void* obj){
+  return observables.count(obj);
+}
+void ObserverLog::addName(void* obj , string name){
+  stringstream sstr;
+  sstr << name << "_" << count++;
+  names[obj] = sstr.str();
+}
+void ObserverLog::addObservable(void* obj){
+  observables.insert(obj);
+}
+void ObserverLog::deleteName(void* obj){
+  names.erase(obj);
+}
+void ObserverLog::deleteObservable(void* obj){
+  observables.erase(obj);
+}
+stringstream &ObserverLog::addMessage(int depth){
+  for(int i=depth;i--;)
+    log << "  ";
+  return log;
+}
+#endif

src/Patterns/Observer.hpp

-              r0c7ed8
+              r1dc9ec
 #include <map>
 #include <set>
+#include <string>
+#include <sstream>
 /**
 …
  */
+// Deactivate any logging when we are not in debug mode
+#ifdef NDEBUG
+#undef LOG_OBSERVER
+#endif
 class Observable;
 class Notification;
 …
 // identification process
 typedef Notification *const Notification_ptr;
+template<class _Set>
+class ObservedIterator;
 /**
 …
   friend class Observable;
   friend class Notification;
+public:
+  Observer();
+  template<class> friend class ObservedIterator;
+  // indicates the constructor called from Observables
+  struct BaseConstructor{};
+public:
+  Observer(BaseConstructor);
+  Observer(std::string);
   virtual ~Observer();
 …
 class Observable : public Observer {
 public:
   Observable();
+  Observable(std::string _name);
   virtual ~Observable();
 …
   static std::set<Observable*> busyObservables;
   //! @cond
   // Structure for RAII-Style notification
 …
   public:
     _Observable_protector(Observable *);
+    _Observable_protector(const _Observable_protector&);
     ~_Observable_protector();
   private:
 …
 };
+#ifdef LOG_OBSERVER
+/**
+ * This class is used to log the working of the observer mechanism
+ *
+ * TODO: make this conditional dependent on compiler Flag.
+ */
+class ObserverLog{
+  friend class Observable;
+  friend class Observer;
+  template <typename> friend class Cacheable;
+public:
+  ObserverLog();
+  ~ObserverLog();
+  std::string getLog();                        // get everything that has been logged
+  std::string getName(void*);                  // get the name of an actor
+  bool isObservable(void*);
+private:
+  int count;                                   // number to reference each actor in this framework
+  std::map<void*,std::string> names;           // List of names assigned to actors
+  std::set<void*> observables;                 // List of pointers to Observables. Needed to distinguish Observers and Observables
+  void addName(void*, std::string);            // Assign a name to an Actor
+  void addObservable(void*);
+  void deleteName(void*);                      // delete the name of an Actor
+  void deleteObservable(void*);
+  std::stringstream &addMessage(int depth=0);  // Add a Message to the logging
+  std::stringstream log;                       // The internal log object
+};
+ObserverLog &observerLog();
+#endif
 // extra macro is necessary to work with __LINE__
 #define PASTE(a,b) PASTE_HELPER(a,b)

src/Plane.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Plane.hpp"

src/Space.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Space.hpp"

src/UIElements/Dialog.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include <cassert>
+#include "UIElements/Dialog.hpp"
+#include "Dialog.hpp"
+#include "atom.hpp"
+#include "element.hpp"
+#include "molecule.hpp"
 #include "vector.hpp"
 …
     retval &= (*iter)->handle();
     // if any query fails (is canceled), we can end the handling process
+    if(!retval)
+    if(!retval) {
+      DoeLog(1) && (eLog() << Verbose(1) << "The following query failed: " << (**iter).getTitle() << "." << endl);
       break;
+    }
+  }
   if (retval){
 …
 // Base class
+Dialog::Query::Query(string _title) :
+    title(_title)
+Dialog::Query::Query(string _title, string _description) :
+    title(_title),
+    description(_description)
 {}
 …
+}
+const std::string Dialog::Query::getDescription() const{
+  return description;
+}
+// empty Queries
+Dialog::EmptyQuery::EmptyQuery(string title, std::string description) :
+    Query(title, description)
+{}
+Dialog::EmptyQuery::~EmptyQuery() {}
+void Dialog::EmptyQuery::setResult() {
+}
 // Int Queries
 Dialog::IntQuery::IntQuery(string title,int *_target) :
     Query(title), target(_target)
+Dialog::IntQuery::IntQuery(string title,int *_target, std::string description) :
+    Query(title, description), target(_target)
 {}
 …
+}
+// Int Queries
+Dialog::BooleanQuery::BooleanQuery(string title,bool *_target, std::string description) :
+    Query(title, description), target(_target)
+{}
+Dialog::BooleanQuery::~BooleanQuery() {}
+void Dialog::BooleanQuery::setResult() {
+  *target = tmp;
+}
 // String Queries
 Dialog::StringQuery::StringQuery(string title,string *_target) :
     Query(title), target(_target)
+Dialog::StringQuery::StringQuery(string title,string *_target, std::string _description) :
+    Query(title, _description), target(_target)
 {}
 …
 // Double Queries
 Dialog::DoubleQuery::DoubleQuery(string title,double *_target) :
     Query(title), target(_target)
+Dialog::DoubleQuery::DoubleQuery(string title,double *_target, std::string _description) :
+    Query(title, _description), target(_target)
 {}
 …
+// Atom Queries
+Dialog::AtomQuery::AtomQuery(string title, atom **_target, std::string _description) :
+    Query(title, _description),
+    tmp(0),
+    target(_target)
+{}
+Dialog::AtomQuery::~AtomQuery() {}
+void Dialog::AtomQuery::setResult() {
+  *target = tmp;
+}
 // Molecule Queries
 Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, MoleculeListClass *_molecules) :
     Query(title),
+Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, std::string _description) :
+    Query(title, _description),
     tmp(0),
-    molecules(_molecules),
     target(_target)
 …
 // Vector Queries
 Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check) :
   Query(title),
+Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description) :
+  Query(title, _description),
   cellSize(_cellSize),
   check(_check),
   target(_target)
+{
 tmp = new Vector();
+  tmp = new Vector();
+}
 …
+}
+// Box Queries
+Dialog::BoxQuery::BoxQuery(std::string title, double ** const _cellSize, std::string _description) :
+  Query(title, _description),
+  target(_cellSize)
+{
+    tmp = new double[6];
+}
+Dialog::BoxQuery::~BoxQuery()
+{
+  delete[] tmp;
+}
+void Dialog::BoxQuery::setResult() {
+  for (int i=0;i<6;i++) {
+    (*target)[i] = tmp[i];
+  }
+}
 // Element Queries
+Dialog::ElementQuery::ElementQuery(std::string title, const element **_target) :
+  Query(title),
+  tmp(0),
+Dialog::ElementQuery::ElementQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+  Query(title, _description),
   target(_target)
   {}
 …
 void Dialog::ElementQuery::setResult(){
   *target=tmp;
+}
+  *target=elements;
+}

src/UIElements/Dialog.hpp

-              r0c7ed8
+              r1dc9ec
 #include<string>
 #include<list>
+#include<vector>
+class MoleculeListClass;
+class atom;
+class element;
 class molecule;
 class Vector;
-class element;
 class Dialog
 …
   virtual ~Dialog();
+  virtual void queryInt(const char *, int *)=0;
+  virtual void queryDouble(const char*,double *)=0;
+  virtual void queryString(const char*, std::string *)=0;
+  virtual void queryMolecule(const char*,molecule**,MoleculeListClass*)=0;
+  virtual void queryVector(const char*,Vector *,const double *const,bool)=0;
+  virtual void queryElement(const char*,const element **)=0;
+  virtual void queryEmpty(const char *, std::string = "")=0;
+  virtual void queryBoolean(const char *, bool *, std::string = "")=0;
+  virtual void queryInt(const char *, int *, std::string = "")=0;
+  virtual void queryDouble(const char*,double *, std::string = "")=0;
+  virtual void queryString(const char*, std::string *, std::string = "")=0;
+  virtual void queryAtom(const char*,atom**,std::string = "")=0;
+  virtual void queryMolecule(const char*,molecule**, std::string = "")=0;
+  virtual void queryVector(const char*,Vector *,const double *const,bool, std::string = "")=0;
+  virtual void queryBox(const char*,double ** const, std::string = "")=0;
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "")=0;
   virtual bool display();
 …
   //base class for all queries
   class Query {
+    friend class Dialog;
   public:
     Query(std::string _title);
+    Query(std::string _title, std::string _description = "");
     virtual ~Query();
     virtual bool handle()=0;
 …
   protected:
     const std::string getTitle() const;
+    const std::string getDescription() const;
   private:
+    std::string title;
+    std::string title;  //!< short title of the query
+    std::string description; //!< longer description for tooltips or for help
+  };
+  // Empty Query is just meant for showing text, such as version, help, initial message or alike
+  class EmptyQuery : public Query {
+  public:
+    EmptyQuery(std::string title, std::string _description = "");
+    virtual ~EmptyQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
   };
   //Specialized classes for certain types. GUI-Types are not specialized at this time
+  class BooleanQuery : public Query {
+  public:
+    BooleanQuery(std::string title,bool *_target, std::string _description = "");
+    virtual ~BooleanQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    bool tmp;
+  private:
+    bool *target;
+  };
   class IntQuery : public Query {
   public:
     IntQuery(std::string title,int *_target);
+    IntQuery(std::string title,int *_target, std::string _description = "");
     virtual ~IntQuery();
     virtual bool handle()=0;
 …
   class DoubleQuery : public Query {
   public:
     DoubleQuery(std::string title,double *_target);
+    DoubleQuery(std::string title,double *_target, std::string _description = "");
     virtual ~DoubleQuery();
     virtual bool handle()=0;
 …
   class StringQuery : public Query {
   public:
     StringQuery(std::string title,std::string *_target);
+    StringQuery(std::string title,std::string *_target, std::string _description = "");
     virtual ~StringQuery();
     virtual bool handle()=0;
 …
   };
   class MoleculeQuery : public Query {
   public:
     MoleculeQuery(std::string title, molecule **_target, MoleculeListClass *_molecules);
+    MoleculeQuery(std::string title, molecule **_target, std::string _description = "");
     virtual ~MoleculeQuery();
     virtual bool handle()=0;
 …
   protected:
     molecule *tmp;
-    MoleculeListClass *molecules;
   private:
     molecule **target;
   };
+  class AtomQuery : public Query {
+  public:
+    AtomQuery(std::string title, atom **_target, std::string _description = "");
+    virtual ~AtomQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    atom *tmp;
+  private:
+    atom **target;
+  };
   class VectorQuery : public Query {
   public:
       VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
+      VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description = "");
       virtual ~VectorQuery();
       virtual bool handle()=0;
 …
   };
+  class BoxQuery : public Query {
+  public:
+      BoxQuery(std::string title,double ** const _cellSize, std::string _description = "");
+      virtual ~BoxQuery();
+      virtual bool handle()=0;
+      virtual void setResult();
+    protected:
+      double *tmp;
+    private:
+      double **target;
+  };
   class ElementQuery : public Query {
   public:
     ElementQuery(std::string title, const element**_target);
+    ElementQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
     virtual ~ElementQuery();
     virtual bool handle()=0;
     virtual void setResult();
   protected:
     const element *tmp;
+    std::vector<element *> elements;
   private:
     const element **target;
+    std::vector<element *> * const target;
   };
 …
 };
 #endif /* DIALOG_HPP_ */

src/UIElements/MainWindow.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "UIElements/MainWindow.hpp"
+#include "Helpers/MemDebug.hpp"
+#include "MainWindow.hpp"
 MainWindow::MainWindow()

src/UIElements/MainWindow.hpp

-              r0c7ed8
+              r1dc9ec
 };
-/**
- * The type of menuPopulators
- */
-typedef void (*MenuMaker)(Menu*,MoleculeListClass*, config*, periodentafel*);
-/**
- * This contains all Functions that are used to create the menus.
- * Needs a specific funtion for each menu. All populators will be called
- * by the UIFactory upon creation of the main menu. Thus the actuall construction
- * of the Menus can be kept independent of the concrete type of UI that is being
- * built.
- */
-struct menuPopulaters{
-  MenuMaker MakeEditMoleculesMenu;
-};
 #endif /* MAINWINDOW_HPP_ */

src/UIElements/UIFactory.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include <cassert>
+#include <utility>
 #include "Patterns/Singleton_impl.hpp"
 #include "UIElements/UIFactory.hpp"
+#include "Helpers/Assert.hpp"
+// all factories that can be used:
+#include "UIElements/TextUIFactory.hpp"
+using namespace std;
+std::map<std::string,boost::shared_ptr<UIFactory::factoryDescription> > UIFactory::factories;
 UIFactory::UIFactory()
+{
+  // TODO Auto-generated constructor stub
+{}
+UIFactory::~UIFactory()
+{}
+void UIFactory::makeUserInterface(std::string type) {
+  ASSERT(factories.count(type),"Selected factory was not registered before creation.");
+  // call the factory factory
+  setInstance(factories[type]->makeFactory());
+}
+UIFactory::~UIFactory()
+{
+  // TODO Auto-generated destructor stub
+}
+void UIFactory::makeUserInterface(InterfaceTypes type) {
+  switch(type) {
+    case Text :
+      setInstance(new TextUIFactory());
+      break;
+    default:
+      assert(0 && "No such Factory in stock");
+      break;
+  }
+void UIFactory::registerFactory(factoryDescription *factoryDesc) {
+  ASSERT(!factories.count(factoryDesc->name),"Trying to re-register an already registered factory.");
+  factories.insert(make_pair(factoryDesc->name,
+                             boost::shared_ptr<factoryDescription>(factoryDesc)));
+}
 CONSTRUCT_SINGLETON(UIFactory)
+UIFactory::factoryDescription::factoryDescription(string _name) :
+  name(_name)
+{}
+UIFactory::factoryDescription::~factoryDescription()
+{}

src/UIElements/UIFactory.hpp

-              r0c7ed8
+              r1dc9ec
 class MainWindow;
 class Dialog;
+class MoleculeListClass;
+class config;
+class periodentafel;
+struct menuPopulaters;
+class DialogDescription;
 #include "Patterns/Singleton.hpp"
+#include <string>
+#include <map>
+#include <boost/smart_ptr.hpp>
 /**
 …
 class UIFactory : public Singleton<UIFactory,false>
+{
+  friend class Singleton<UIFactory,false>;
 public:
-  enum InterfaceTypes {Text};
-  virtual ~UIFactory();
   /**
    * Produce some kind of main window, of whichever type was chosen when the factory was created
    */
   virtual MainWindow* makeMainWindow(menuPopulaters,MoleculeListClass *, config *, periodentafel *, char *)=0;
+  virtual MainWindow* makeMainWindow()=0;
   /**
 …
 protected:
   UIFactory();
+  virtual ~UIFactory();
 public:
+  struct factoryDescription {
+    factoryDescription(std::string _name);
+    virtual ~factoryDescription();
+    const std::string name;
+    // yes this method really is a factory factory, to allow insertion of
+    // arbitrary factories
+    virtual UIFactory* makeFactory()=0;
+  };
   /**
    * create a Factory of a certain type. From that moment on only those UIElements can be produced by the factory
    */
+  static void makeUserInterface(InterfaceTypes type);
+  static void makeUserInterface(std::string type);
+  static void registerFactory(factoryDescription *factoryDesc);
+protected:
+private:
+  static std::map<std::string,boost::shared_ptr<factoryDescription> > factories;
 };

src/World.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 #include "atom.hpp"
+#include "config.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
 …
+}
+config *&World::getConfig(){
+  return configuration;
+}
 // Atoms
 …
+}
+std::vector<molecule*> World::getAllMolecules(){
+  return getAllMolecules(AllMolecules());
+}
 int World::numMolecules(){
   return molecules_deprecated->ListOfMolecules.size();
 …
+}
 char * World::getDefaultName() {
+std::string World::getDefaultName() {
   return defaultName;
+}
 void World::setDefaultName(char * name)
+void World::setDefaultName(std::string name)
+{
+  delete[](defaultName);
+  const int length = strlen(name);
+  defaultName = new char[length+2];
+  if (length < MAXSTRINGSIZE)
+    strncpy(defaultName, name, length);
+  else
+    strcpy(defaultName, "none");
+  defaultName = name;
 };
+int World::getExitFlag() {
+  return ExitFlag;
+}
+void World::setExitFlag(int flag) {
+  if (ExitFlag < flag)
+    ExitFlag = flag;
+}
 /******************** Methods to change World state *********************/
 …
 double *World::cell_size = NULL;
-char *World::defaultName = NULL;
 atom *World::createAtom(){
 …
 World::World() :
+    Observable("World"),
     periode(new periodentafel),
+    configuration(new config),
+    ExitFlag(0),
     atoms(),
     currAtomId(0),
 …
   cell_size[4] = 0.;
   cell_size[5] = 20.;
+  defaultName = new char[MAXSTRINGSIZE];
+  strcpy(defaultName, "none");
+  defaultName = "none";
   molecules_deprecated->signOn(this);
+}
 …
   molecules_deprecated->signOff(this);
   delete[] cell_size;
-  delete[] defaultName;
   delete molecules_deprecated;
   delete periode;
+  delete configuration;
   MoleculeSet::iterator molIter;
   for(molIter=molecules.begin();molIter!=molecules.end();++molIter){

src/World.hpp

-              r0c7ed8
+              r1dc9ec
 // forward declarations
+class config;
 class periodentafel;
 class MoleculeListClass;
 …
   /**
+   * returns the configuration for the world.
+   */
+  config *&getConfig();
+  /**
    * returns the first atom that matches a given descriptor.
    * Do not rely on ordering for descriptors that match more than one atom.
 …
    */
   std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
+  std::vector<molecule*> getAllMolecules();
   /**
 …
    * get the default name
    */
   char * getDefaultName();
+  std::string getDefaultName();
   /**
    * set the default name
    */
+  void setDefaultName(char * name);
+  void setDefaultName(std::string name);
+  /*
+   * get the ExitFlag
+   */
+  int getExitFlag();
+  /*
+   * set the ExitFlag
+   */
+  void setExitFlag(int flag);
   /***** Methods to work with the World *****/
 …
   periodentafel *periode;
+  config *configuration;
   static double *cell_size;
+  static char *defaultName;
+  std::string defaultName;
+  int ExitFlag;
 public:
   AtomSet atoms;

src/analysis_bonds.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "analysis_bonds.hpp"
 …
   Mean = 0.;
-  atom *Walker = mol->start;
   int AtomCount = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (Max < count)
       Max = count;
 …
  * \param &Max maximum distance on return, 0 if no bond between the two elements
  */
 void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, element *type1, element *type2, double &Min, double &Mean, double &Max)
+void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, const element *type1, const element *type2, double &Min, double &Mean, double &Max)
+{
   Min = 2e+6;
 …
   int AtomNo = 0;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    if (Walker->type == type1)
+      for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++)
+        if ((*BondRunner)->GetOtherAtom(Walker)->type == type2) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type == type1)
+      for (BondList::const_iterator BondRunner = (*iter)->ListOfBonds.begin(); BondRunner != (*iter)->ListOfBonds.end(); BondRunner++)
+        if ((*BondRunner)->GetOtherAtom((*iter))->type == type2) {
           const double distance = (*BondRunner)->GetDistanceSquared();
           if (Min > distance)
 …
  * \param *InterfaceElement or NULL
  */
+int CountHydrogenBridgeBonds(MoleculeListClass *molecules, element * InterfaceElement = NULL)
+{
+  atom *Walker = NULL;
+  atom *Runner = NULL;
+int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL)
+{
   int count = 0;
   int OtherHydrogens = 0;
 …
   bool InterfaceFlag = false;
   bool OtherHydrogenFlag = true;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); MolRunner++) {
+        Runner = (*MolRunner)->start;
+        while (Runner->next != (*MolRunner)->end) {
+          Runner = Runner->next;
+          if ((Walker->type->Z  == 8) && (Runner->type->Z  == 8)) {
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); ++MolWalker) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); ++MolRunner) {
+        molecule::iterator Runner = (*MolRunner)->begin();
+        for(;Runner!=(*MolRunner)->end();++Runner){
+          if (((*Walker)->type->Z  == 8) && ((*Runner)->type->Z  == 8)) {
             // check distance
             const double distance = Runner->x.DistanceSquared(Walker->x);
+            const double distance = (*Runner)->x.DistanceSquared((*Walker)->x);
             if ((distance > MYEPSILON) && (distance < HBRIDGEDISTANCE*HBRIDGEDISTANCE)) { // distance >0 means  different atoms
               // on other atom(Runner) we check for bond to interface element and
 …
               OtherHydrogens = 0;
               InterfaceFlag = (InterfaceElement == NULL);
               for (BondList::const_iterator BondRunner = Runner->ListOfBonds.begin(); BondRunner != Runner->ListOfBonds.end(); BondRunner++) {
                 atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Runner);
+              for (BondList::const_iterator BondRunner = (*Runner)->ListOfBonds.begin(); BondRunner != (*Runner)->ListOfBonds.end(); BondRunner++) {
+                atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
                 // if hydrogen, check angle to be greater(!) than 30 degrees
                 if (OtherAtom->type->Z == 1) {
                   const double angle = CalculateAngle(&OtherAtom->x, &Runner->x, &Walker->x);
+                  const double angle = CalculateAngle(&OtherAtom->x, &(*Runner)->x, &(*Walker)->x);
                   OtherHydrogenFlag = OtherHydrogenFlag && (angle > M_PI*(30./180.) + MYEPSILON);
                   Otherangle += angle;
 …
               if (InterfaceFlag && OtherHydrogenFlag) {
                 // on this element (Walker) we check for bond to hydrogen, i.e. part of water molecule
                 for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
                   atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+                for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {
+                  atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Walker);
                   if (OtherAtom->type->Z == 1) {
                     // check angle
                     if (CheckHydrogenBridgeBondAngle(Walker, OtherAtom, Runner)) {
                       DoLog(1) && (Log() << Verbose(1) << Walker->getName() << ", " << OtherAtom->getName() << " and " << Runner->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &Walker->x, &Runner->x)*(180./M_PI) << "." << endl);
+                    if (CheckHydrogenBridgeBondAngle(*Walker, OtherAtom, *Runner)) {
+                      DoLog(1) && (Log() << Verbose(1) << (*Walker)->getName() << ", " << OtherAtom->getName() << " and " << (*Runner)->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &(*Walker)->x, &(*Runner)->x)*(180./M_PI) << "." << endl);
                       count++;
                       break;
 …
 int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second)
+{
-  atom *Walker = NULL;
   int count = 0;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
     Walker = (*MolWalker)->start;
     while (Walker->next != (*MolWalker)->end) {
       Walker = Walker->next;
       if ((Walker->type == first) || (Walker->type == second)) {  // first element matches
         for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
           if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (Walker->nr < OtherAtom->nr)) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom * theAtom = *Walker;
+      if ((theAtom->type == first) || (theAtom->type == second)) {  // first element matches
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
+          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (theAtom->nr < OtherAtom->nr)) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
 …
   bool MatchFlag[2];
   bool result = false;
-  atom *Walker = NULL;
   const element * ElementArray[2];
   ElementArray[0] = first;
 …
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
     Walker = (*MolWalker)->start;
     while (Walker->next != (*MolWalker)->end) {
       Walker = Walker->next;
       if (Walker->type == second) {  // first element matches
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom *theAtom = *Walker;
+      if (theAtom->type == second) {  // first element matches
         for (int i=0;i<2;i++)
           MatchFlag[i] = false;
         for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
           for (int i=0;i<2;i++)
             if ((!MatchFlag[i]) && (OtherAtom->type == ElementArray[i])) {

src/analysis_bonds.hpp

-              r0c7ed8
+              r1dc9ec
 void GetMaxMinMeanBondCount(const molecule * const mol, double &Min, double &Mean, double &Max);
 void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, element *type1, element *type2, double &Min, double &Mean, double &Max);
+void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, const element *type1, const element *type2, double &Min, double &Mean, double &Max);
 int CountHydrogenBridgeBonds(MoleculeListClass * const molecules, element * InterfaceElement);
+int CountHydrogenBridgeBonds(MoleculeListClass * const molecules, const element * InterfaceElement);
 int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second);
 int CountBondsOfThree(MoleculeListClass * const molecules, const element * const first, const element * const second, const element * const third);

src/analysis_correlation.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <iostream>
 …
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type1 first element or NULL (if any element)
+ * \param *type2 second element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const type2 )
+PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements)
+{
   Info FunctionInfo(__func__);
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
+  double *domain = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
+  // create all possible pairs of elements
+  set <pair<element *, element *> > PairsOfElements;
+  if (elements.size() >= 2) {
+    for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+        if (type1 != type2) {
+          PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+        }
+  } else if (elements.size() == 1) { // one to all are valid
+    element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+  } else { // all elements valid
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
+  }
   outmap = new PairCorrelationMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
     if ((*MolWalker)->ActiveFlag) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
+            if ((*MolOtherWalker)->ActiveFlag) {
+              DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+              atom *OtherWalker = (*MolOtherWalker)->start;
+              while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                OtherWalker = OtherWalker->next;
+                DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
+                if (Walker->nr < OtherWalker->nr)
+                  if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                    distance = Walker->node->PeriodicDistance(*OtherWalker->node, World::getInstance().getDomain());
+                    //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+          if ((*MolOtherWalker)->ActiveFlag) {
+            DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+            for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+              DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+              if ((*iter)->getId() < (*runner)->getId()){
+                for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                  if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                    distance = (*iter)->node->PeriodicDistance(*(*runner)->node,  domain);
+                    //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                  }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   return outmap;
 };
 …
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type1 first element or NULL (if any element)
+ * \param *type2 second element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate
  * \param ranges[NDIM] interval boundaries for the periodic images to scan also
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const type2, const int ranges[NDIM] )
+PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
+  // create all possible pairs of elements
+  set <pair<element *, element *> > PairsOfElements;
+  if (elements.size() >= 2) {
+    for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+        if (type1 != type2) {
+          PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+        }
+  } else if (elements.size() == 1) { // one to all are valid
+    element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+  } else { // all elements valid
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
+  }
   outmap = new PairCorrelationMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
     if ((*MolWalker)->ActiveFlag) {
       double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          periodicX = *(Walker->node);
+          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                checkX.MatrixMultiplication(FullMatrix);
+                for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
+                  if ((*MolOtherWalker)->ActiveFlag) {
+                    DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                    atom *OtherWalker = (*MolOtherWalker)->start;
+                    while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                      OtherWalker = OtherWalker->next;
+                      DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
+                      if (Walker->nr < OtherWalker->nr)
+                        if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                          periodicOtherX = *(OtherWalker->node);
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        periodicX = *(*iter)->node;
+        periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+        // go through every range in xyz and get distance
+        for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+          for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+            for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+              checkX = Vector(n[0], n[1], n[2]) + periodicX;
+              checkX.MatrixMultiplication(FullMatrix);
+              for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+                if ((*MolOtherWalker)->ActiveFlag) {
+                  DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                  for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                    DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                    if ((*iter)->getId() < (*runner)->getId()){
+                      for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                        if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                          periodicOtherX = *(*runner)->node;
                           periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
                           // go through every range in xyz and get distance
 …
                                 checkOtherX.MatrixMultiplication(FullMatrix);
                                 distance = checkX.distance(checkOtherX);
                                 //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
                                 outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                              }
+                        }
+                    }
+                  }
+                }
+              }
+            }
+        }
+      }
       Free(&FullMatrix);
       Free(&FullInverseMatrix);
+    }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }
+  }
   return outmap;
 …
 /** Calculates the distance (pair) correlation between a given element and a point.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate with point
  * \param *point vector to the correlation point
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point )
+CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point )
+{
   Info FunctionInfo(__func__);
   CorrelationToPointMap *outmap = NULL;
   double distance = 0.;
+  double *cell_size = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type == NULL) || (Walker->type == type)) {
+          distance = Walker->node->PeriodicDistance(*point, World::getInstance().getDomain());
+          DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+        }
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            distance = (*iter)->node->PeriodicDistance(*point, cell_size);
+            DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+            outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+          }
+      }
+    }
 …
 /** Calculates the distance (pair) correlation between a given element, all its periodic images and a point.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to point
  * \param *point vector to the correlation point
  * \param ranges[NDIM] interval boundaries for the periodic images to scan also
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] )
+CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
 …
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type == NULL) || (Walker->type == type)) {
+          periodicX = *(Walker->node);
+          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                checkX.MatrixMultiplication(FullMatrix);
+                distance = checkX.distance(*point);
+                DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+              }
+        }
+      }
+      Free(&FullMatrix);
+      Free(&FullInverseMatrix);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = *(*iter)->node;
+            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                  checkX.MatrixMultiplication(FullMatrix);
+                  distance = checkX.distance(*point);
+                  DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                  outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
+                }
+          }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }
 …
 /** Calculates the distance (pair) correlation between a given element and a surface.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to surface
  * \param *Surface pointer to Tesselation class surface
  * \param *LC LinkedCell structure to quickly find neighbouring atoms
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC )
+CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
       DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        //Log() << Verbose(1) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          TriangleIntersectionList Intersections(Walker->node,Surface,LC);
+          distance = Intersections.GetSmallestDistance();
+          triangle = Intersections.GetClosestTriangle();
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+        }
+      }
+    } else
+      if ((*MolWalker)->empty())
+        DoLog(1) && (1) && (Log() << Verbose(1) << "\t is empty." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(1) && (Log() << Verbose(1) << "\tCurrent atom is " << *(*iter) << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
+            distance = Intersections.GetSmallestDistance();
+            triangle = Intersections.GetClosestTriangle();
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+          }
+      }
+    } else {
       DoLog(1) && (Log() << Verbose(1) << "molecule " << (*MolWalker)->name << " is not active." << endl);
+    }
   return outmap;
 …
  * axis an integer from [ -ranges[i], ranges[i] ] onto it and multiply with the domain matrix to bring it back into
  * the real space. Then, we Tesselation::FindClosestTriangleToPoint() and DistanceToTrianglePlane().
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to surface
  * \param *Surface pointer to Tesselation class surface
  * \param *LC LinkedCell structure to quickly find neighbouring atoms
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
   double ShortestDistance = 0.;
 …
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
       atom *Walker = (*MolWalker)->start;
       while (Walker->next != (*MolWalker)->end) {
         Walker = Walker->next;
         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
         if ((type == NULL) || (Walker->type == type)) {
           periodicX = *(Walker->node);
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
           ShortestDistance = -1.;
           for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
             for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
               for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
                 checkX = Vector(n[0], n[1], n[2]) + periodicX;
                 checkX.MatrixMultiplication(FullMatrix);
                 TriangleIntersectionList Intersections(&checkX,Surface,LC);
                 distance = Intersections.GetSmallestDistance();
                 triangle = Intersections.GetClosestTriangle();
                 if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
                   ShortestDistance = distance;
                   ShortestTriangle = triangle;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = *(*iter)->node;
+            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            ShortestDistance = -1.;
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                  checkX.MatrixMultiplication(FullMatrix);
+                  TriangleIntersectionList Intersections(&checkX,Surface,LC);
+                  distance = Intersections.GetSmallestDistance();
+                  triangle = Intersections.GetClosestTriangle();
+                  if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                    ShortestDistance = distance;
+                    ShortestTriangle = triangle;
+                  }
+                }
+              }
+          // insert
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, ShortestTriangle) ) );
+          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+        }
+      }
+      Free(&FullMatrix);
+      Free(&FullInverseMatrix);
+            // insert
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+            //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+          }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }

src/analysis_correlation.hpp

-              r0c7ed8
+              r1dc9ec
 /********************************************** declarations *******************************/
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const  type2 );
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point );
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC );
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const  type2, const int ranges[NDIM] );
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] );
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements);
+CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
+PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
+CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
 int GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

src/analyzer.cpp

-              r0c7ed8
+              r1dc9ec
 //============================ INCLUDES ===========================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
     return 1;
   } else {
     dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
+    dir = new char[strlen(argv[2]) + 2];
     strcpy(dir, "/");
     strcat(dir, argv[2]);
 …
   if (argc > 4) {
     DoLog(0) && (Log() << Verbose(0) << "Loading periodentafel." << endl);
     periode = Malloc<periodentafel>(1, "main - periode");
+    periode = new periodentafel;
     periode->LoadPeriodentafel(argv[4]);
+  }
 …
   // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
   delete(periode);
   Free(&dir);
+  delete[](dir);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return 0;

src/atom.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 #include "vector.hpp"
 #include "World.hpp"
+#include "molecule.hpp"
 /************************************* Functions for class atom *************************************/
 …
  */
 atom::atom() :
   previous(NULL), next(NULL), father(this), sort(&nr)
+  father(this), sort(&nr), mol(0)
+{
   node = &x;  // TesselPoint::x can only be referenced from here
 …
  */
 atom::atom(atom *pointer) :
+    ParticleInfo(pointer),
+    previous(NULL), next(NULL), father(pointer), sort(&nr)
+    ParticleInfo(pointer),father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
 …
   FixedIon = pointer->FixedIon;
   node = &x;
+  mol = 0;
 };
 atom *atom::clone(){
   atom *res = new atom(this);
-  res->previous=0;
-  res->next=0;
   res->father = this;
   res->sort = &res->nr;
 …
   res->FixedIon = FixedIon;
   res->node = &x;
+  res->mol = 0;
   World::getInstance().registerAtom(res);
   return res;
 …
 atom::~atom()
+{
+  unlink(this);
+  removeFromMolecule();
+  for(BondList::iterator iter=ListOfBonds.begin(); iter!=ListOfBonds.end();){
+    // deleting the bond will invalidate the iterator !!!
+    bond *bond =*(iter++);
+    delete(bond);
+  }
 };
 …
+{
   if (ComponentNr != NULL)
     Free(&ComponentNr);
   ComponentNr = Malloc<int>(ListOfBonds.size()+1, "atom::InitComponentNumbers: *ComponentNr");
+    delete[](ComponentNr);
+  ComponentNr = new int[ListOfBonds.size()+1];
   for (int i=ListOfBonds.size()+1;i--;)
     ComponentNr[i] = -1;
 …
+}
+void atom::setMolecule(molecule *_mol){
+  // take this atom from the old molecule
+  removeFromMolecule();
+  mol = _mol;
+  if(!mol->containsAtom(this)){
+    mol->AddAtom(this);
+  }
+}
+void atom::removeFromMolecule(){
+  if(mol){
+    if(mol->containsAtom(this)){
+      mol->erase(this);
+    }
+    mol=0;
+  }
+}
 atom* NewAtom(atomId_t _id){
   atom * res =new atom();

src/atom.hpp

-              r0c7ed8
+              r1dc9ec
 class Vector;
 class World;
+class molecule;
 /********************************************** declarations *******************************/
 …
   friend void  DeleteAtom(atom*);
   public:
-    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
     int *sort;      //!< sort criteria
 …
    virtual void setId(atomId_t);
+   void setMolecule(molecule*);
+   void removeFromMolecule();
   protected:
     /**
      * Protected constructor to ensure construction of atoms through the world.
 …
     virtual ~atom();
   private:
+    molecule *mol; // !< the molecule this atom belongs to
     World* world;
     atomId_t id;

src/atom_atominfo.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "periodentafel.hpp"

src/atom_bondedparticle.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
       *BondFile << nr << "\t" << (*Runner)->GetOtherAtom(this)->nr << "\n";
 };
+/**
+ * Adds a bond between this bonded particle and another. Does nothing if this
+ * bond already exists.
+ *
+ * \param bonding partner
+ */
+void BondedParticle::addBond(BondedParticle* Partner) {
+  if (IsBondedTo(Partner)) {
+    return;
+  }
+  bond* newBond = new bond((atom*) this, (atom*) Partner, 1, 0);
+  RegisterBond(newBond);
+  Partner->RegisterBond(newBond);
+}
 /** Puts a given bond into atom::ListOfBonds.

src/atom_bondedparticle.hpp

r0c7ed8	r1dc9ec
37	37	virtual ~BondedParticle();
38	38
	39	void addBond(BondedParticle* Partner);
39	40	bool RegisterBond(bond *Binder);
40	41	bool UnregisterBond(bond *Binder);

src/atom_bondedparticleinfo.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_bondedparticleinfo.hpp"

src/atom_graphnode.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_graphnode.hpp"

src/atom_graphnodeinfo.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom_graphnodeinfo.hpp"
 …
 GraphNodeInfo::~GraphNodeInfo()
+{
   Free<int>(&ComponentNr, "atom::~atom: *ComponentNr");
+  delete[](ComponentNr);
 };

src/atom_particleinfo.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_particleinfo.hpp"

src/atom_trajectoryparticle.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "atom_trajectoryparticle.hpp"
 #include "config.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "parser.hpp"
 …
 void TrajectoryParticle::ResizeTrajectory(int MaxSteps)
+{
+  Info FunctionInfo(__func__);
   if (Trajectory.R.size() <= (unsigned int)(MaxSteps)) {
     //Log() << Verbose(0) << "Increasing size for trajectory array of " << keyword << " to " << (MaxSteps+1) << "." << endl;
+    DoLog(0) && (Log() << Verbose(0) << "Increasing size for trajectory array of " << nr << " from " << Trajectory.R.size() << " to " << (MaxSteps+1) << "." << endl);
     Trajectory.R.resize(MaxSteps+1);
     Trajectory.U.resize(MaxSteps+1);

src/atom_trajectoryparticleinfo.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_trajectoryparticleinfo.hpp"

src/bond.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 /** Empty Constructor for class bond.
  */
+bond::bond() : leftatom(NULL), rightatom(NULL), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(0), nr(-1), Cyclic(false), Type(Undetermined), Used(white)
+bond::bond()
+  : leftatom(NULL), rightatom(NULL), previous(NULL), next(NULL), HydrogenBond(0),
+    BondDegree(0), nr(-1), Cyclic(false), Type(Undetermined), Used(white)
+{
 };
 …
  * \param number increasing index
  */
+bond::bond(atom *left, atom *right, const int degree, const int number) : leftatom(left), rightatom(right), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(degree), nr(number), Cyclic(false), Type(Undetermined), Used(white)
+bond::bond(atom *left, atom *right, const int degree, const int number)
+  : leftatom(left), rightatom(right), previous(NULL), next(NULL), HydrogenBond(0),
+    BondDegree(degree), nr(number), Cyclic(false), Type(Undetermined), Used(white)
+{
   if ((left != NULL) && (right != NULL)) {

src/bondgraph.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <iostream>
 …
+{
   Info FunctionInfo(__func__);
 bool status = true;
+  bool status = true;
   if (mol->start->next == mol->end) // only construct if molecule is not empty
+  if (mol->empty()) // only construct if molecule is not empty
     return false;
 …
   max_distance = 0.;
+  atom *Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if (Runner->type->CovalentRadius > max_distance)
+      max_distance = Runner->type->CovalentRadius;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type->CovalentRadius > max_distance)
+      max_distance = (*iter)->type->CovalentRadius;
+  }
   max_distance *= 2.;

src/bondgraph.hpp

r0c7ed8	r1dc9ec
27	27
28	28	class molecule;
29		class ~~periodentafel~~;
	29	class BondedParticle;
30	30	class MatrixContainer;
31	31

src/boundary.cpp

-              r0c7ed8
+              r1dc9ec
  * Implementations and super-function for envelopes
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 …
+{
         Info FunctionInfo(__func__);
-  atom *Walker = NULL;
   PointMap PointsOnBoundary;
   LineMap LinesOnBoundary;
 …
     // 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;
+      ProjectedVector = Walker->x - (*MolCenter);
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      ProjectedVector = (*iter)->x - (*MolCenter);
       ProjectedVector.ProjectOntoPlane(AxisVector);
 …
         angle = 2. * M_PI - angle;
+      }
       DoLog(1) && (Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
       BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
+    DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
+      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
       if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
         DoLog(2) && (Log() << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl);
         DoLog(2) && (Log() << Verbose(2) << "Present vector: " << *BoundaryTestPair.first->second.second << endl);
         DoLog(2) && (Log() << Verbose(2) << "New vector: " << *Walker << endl);
+        DoLog(2) && (Log() << Verbose(2) << "New vector: " << **iter << endl);
         const double ProjectedVectorNorm = ProjectedVector.NormSquared();
         if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
           BoundaryTestPair.first->second.first = ProjectedVectorNorm;
           BoundaryTestPair.first->second.second = Walker;
+          BoundaryTestPair.first->second.second = (*iter);
           DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger projected distance " << ProjectedVectorNorm << "." << endl);
         } else if (fabs(ProjectedVectorNorm - BoundaryTestPair.first->second.first) < MYEPSILON) {
+          helper = Walker->x - (*MolCenter);
+          helper = (*iter)->x;
+          helper -= *MolCenter;
           const double oldhelperNorm = helper.NormSquared();
           helper = BoundaryTestPair.first->second.second->x - (*MolCenter);
           if (helper.NormSquared() < oldhelperNorm) {
             BoundaryTestPair.first->second.second = Walker;
+            BoundaryTestPair.first->second.second = (*iter);
             DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl);
           } else {
 …
     do { // do as long as we still throw one out per round
       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++) {
+      Boundaries::iterator left = BoundaryPoints[axis].begin();
+      Boundaries::iterator right = BoundaryPoints[axis].begin();
+      Boundaries::iterator runner = BoundaryPoints[axis].begin();
+      bool LoopOnceDone = false;
+      while (!LoopOnceDone) {
+        runner = right;
+        right++;
         // set neighbours correctly
         if (runner == BoundaryPoints[axis].begin()) {
 …
+        }
         left--;
-        right = runner;
-        right++;
         if (right == BoundaryPoints[axis].end()) {
           right = BoundaryPoints[axis].begin();
+          LoopOnceDone = true;
+        }
         // check distance
 …
             DoLog(1) && (Log() << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl);
             BoundaryPoints[axis].erase(runner);
+            runner = right;
             flag = true;
+          }
 …
   // 4. Store triangles in tecplot file
+  if (filename != NULL) {
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append("_intermed");
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
+      WriteTecplotFile(tecplot, TesselStruct, mol, 0);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append("_intermed");
+      OutputName.append(Raster3DSuffix);
+      ofstream *rasterplot = new ofstream(OutputName.c_str());
+      WriteRaster3dFile(rasterplot, TesselStruct, mol);
+      rasterplot->close();
+      delete(rasterplot);
+    }
+  }
+  StoreTrianglesinFile(mol, TesselStruct, filename, "_intermed");
   // 3d. check all baselines whether the peaks of the two adjacent triangles with respect to center of baseline are convex, if not, make the baseline between the two peaks and baseline endpoints become the new peaks
 …
           TesselStruct->FlipBaseline(line);
           DoLog(1) && (Log() << Verbose(1) << "INFO: Correction of concave baselines worked." << endl);
+          LineRunner = TesselStruct->LinesOnBoundary.begin(); // LineRunner may have been erase if line was deleted from LinesOnBoundary
+        }
+      }
 …
   // 4. Store triangles in tecplot file
+  if (filename != NULL) {
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
+      WriteTecplotFile(tecplot, TesselStruct, mol, 0);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append(Raster3DSuffix);
+      ofstream *rasterplot = new ofstream(OutputName.c_str());
+      WriteRaster3dFile(rasterplot, TesselStruct, mol);
+      rasterplot->close();
+      delete(rasterplot);
+    }
+  }
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
   // free reference lists
 …
 /** Creates multiples of the by \a *mol given cluster and suspends them in water with a given final density.
  * We get cluster volume by VolumeOfConvexEnvelope() and its diameters by GetDiametersOfCluster()
+ * TODO: Here, we need a VolumeOfGeneralEnvelope (i.e. non-convex one)
  * \param *out output stream for debugging
  * \param *configuration needed for path to store convex envelope file
 …
   int repetition[NDIM] = { 1, 1, 1 };
   int TotalNoClusters = 1;
-  atom *Walker = NULL;
   double totalmass = 0.;
   double clustervolume = 0.;
 …
   GreatestDiameter = GetDiametersOfCluster(BoundaryPoints, mol, TesselStruct, IsAngstroem);
   BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
+  LinkedCell LCList(mol, 10.);
+  FindConvexBorder(mol, TesselStruct, &LCList, NULL);
+  LinkedCell *LCList = new LinkedCell(mol, 10.);
+  FindConvexBorder(mol, TesselStruct, (const LinkedCell *&)LCList, NULL);
+  delete (LCList);
   // some preparations beforehand
 …
   // sum up the atomic masses
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      totalmass += Walker->type->mass;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      totalmass += (*iter)->type->mass;
+  }
   DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
 …
   Vector Inserter;
   double FillIt = false;
-  atom *Walker = NULL;
   bond *Binder = NULL;
   double phi[NDIM];
 …
   for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++)
     if ((*ListRunner)->AtomCount > 0) {
+    if ((*ListRunner)->getAtomCount() > 0) {
       DoLog(1) && (Log() << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl);
       LCList[(*ListRunner)] = new LinkedCell((*ListRunner), 10.); // get linked cell list
 …
   filler->CenterEdge(&Inserter);
   filler->Center.Zero();
+  const int FillerCount = filler->getAtomCount();
   DoLog(2) && (Log() << Verbose(2) << "INFO: Filler molecule has the following bonds:" << endl);
+  Binder = filler->first;
+  while(Binder->next != filler->last) {
+    Binder = Binder->next;
+    DoLog(2) && (Log() << Verbose(2) << "  " << *Binder << endl);
+  }
+  filler->CountAtoms();
+  atom * CopyAtoms[filler->AtomCount];
+  for(molecule::iterator AtomRunner = filler->begin(); AtomRunner != filler->end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        DoLog(2) && (Log() << Verbose(2) << "  " << *(*BondRunner) << endl);
+  atom * CopyAtoms[FillerCount];
   // calculate filler grid in [0,1]^3
 …
         // go through all atoms
         for (int i=0;i<filler->AtomCount;i++)
+        for (int i=0;i<FillerCount;i++)
           CopyAtoms[i] = NULL;
+        Walker = filler->start;
+        while (Walker->next != filler->end) {
+          Walker = Walker->next;
+        for(molecule::const_iterator iter = filler->begin(); iter !=filler->end();++iter){
           // create atomic random translation vector ...
 …
           // ... and put at new position
           Inserter = Walker->x;
+          Inserter = (*iter)->x;
           if (DoRandomRotation)
             Inserter.MatrixMultiplication(Rotations);
 …
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
             CopyAtoms[Walker->nr] = Walker->clone();
             CopyAtoms[Walker->nr]->x = Inserter;
             Filling->AddAtom(CopyAtoms[Walker->nr]);
             DoLog(4) && (Log() << Verbose(4) << "Filling atom " << *Walker << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[Walker->nr]->x) << "." << endl);
+            CopyAtoms[(*iter)->nr] = (*iter)->clone();
+            CopyAtoms[(*iter)->nr]->x = Inserter;
+            Filling->AddAtom(CopyAtoms[(*iter)->nr]);
+            DoLog(4) && (Log() << Verbose(4) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->nr]->x) << "." << endl);
           } else {
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
             CopyAtoms[Walker->nr] = NULL;
+            CopyAtoms[(*iter)->nr] = NULL;
             continue;
+          }
+        }
         // go through all bonds and add as well
+        Binder = filler->first;
+        while(Binder->next != filler->last) {
+          Binder = Binder->next;
+          if ((CopyAtoms[Binder->leftatom->nr] != NULL) && (CopyAtoms[Binder->rightatom->nr] != NULL)) {
+            Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl;
+            Filling->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+          }
+        }
+        for(molecule::iterator AtomRunner = filler->begin(); AtomRunner != filler->end(); ++AtomRunner)
+          for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+            if ((*BondRunner)->leftatom == *AtomRunner) {
+              Binder = (*BondRunner);
+              if ((CopyAtoms[Binder->leftatom->nr] != NULL) && (CopyAtoms[Binder->rightatom->nr] != NULL)) {
+                Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl;
+                Filling->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+              }
+            }
+      }
   Free(&M);
   Free(&MInverse);
+  delete[](M);
+  delete[](MInverse);
   return Filling;
 …
   bool TesselationFailFlag = false;
+  mol->getAtomCount();
   if (TesselStruct == NULL) {
     DoLog(1) && (Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl);
 …
 //  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
 //  //->InsertStraddlingPoints(mol, LCList);
 //  mol->GoToFirst();
+//  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
 //  class TesselPoint *Runner = NULL;
+//  while (!mol->IsEnd()) {
+//    Runner = mol->GetPoint();
+//    Runner = *iter;
 //    Log() << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
 //    if (!->IsInnerPoint(Runner, LCList)) {
 …
 //      Log() << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
 //    }
-//    mol->GoToNext();
 //  }
 …
   status = CheckListOfBaselines(TesselStruct);
+  cout << "before correction" << endl;
   // store before correction
   StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
 //  // correct degenerated polygons
 …
   // write final envelope
   CalculateConcavityPerBoundaryPoint(TesselStruct);
+  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  cout << "after correction" << endl;
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
   if (freeLC)

src/builder.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include <boost/bind.hpp>
 …
 #include <cstring>
+#include <cstdlib>
 #include "analysis_bonds.hpp"
 …
 #include "bondgraph.hpp"
 #include "boundary.hpp"
+#include "CommandLineParser.hpp"
 #include "config.hpp"
 #include "element.hpp"
 …
 #include "periodentafel.hpp"
 #include "UIElements/UIFactory.hpp"
+#include "UIElements/TextUI/TextUIFactory.hpp"
+#include "UIElements/CommandLineUI/CommandLineUIFactory.hpp"
 #include "UIElements/MainWindow.hpp"
 #include "UIElements/Dialog.hpp"
 …
 #include "Actions/ActionRegistry.hpp"
 #include "Actions/ActionHistory.hpp"
+#include "Actions/MapOfActions.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/small_actions.hpp"
+#include "Actions/MoleculeAction/ChangeNameAction.hpp"
 #include "World.hpp"
 #include "version.h"
 #include "World.hpp"
+#include "Helpers/MemDebug.hpp"
 /********************************************* Subsubmenu routine ************************************/
 …
         mol->CountAtoms(); // 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
+        if (mol->getAtomCount() != 0) {  // if there is more than none
+          count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
           Elements = new element *[count];
           vectors = new Vector *[count];
 …
   // generate some KeySets
   DoLog(0) && (Log() << Verbose(0) << "Generating KeySets." << endl);
   KeySet TestSets[mol->AtomCount+1];
+  KeySet TestSets[mol->getAtomCount()+1];
   i=1;
   while (Walker->next != mol->end) {
 …
   DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl);
   KeySetTestPair test;
   test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  test = TestSets[mol->getAtomCount()-1].insert(Walker->nr);
   if (test.second) {
     DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
 …
     DoLog(1) && (Log() << 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);
+  TestSets[mol->getAtomCount()].insert(mol->end->previous->nr);
+  TestSets[mol->getAtomCount()].insert(mol->end->previous->previous->previous->nr);
   // constructing Graph structure
 …
   // insert KeySets into Subgraphs
   DoLog(0) && (Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl);
   for (int j=0;j<mol->AtomCount;j++) {
+  for (int j=0;j<mol->getAtomCount();j++) {
     Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
   DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl);
   GraphTestPair test2;
   test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
 …
 /** Parses the command line options.
+ * Note that this function is from now on transitional. All commands that are not passed
+ * here are handled by CommandLineParser and the actions of CommandLineUIFactory.
  * \param argc argument count
  * \param **argv arguments array
 …
  * \param *ConfigFileName pointer to config file name in **argv
  * \param *PathToDatabases pointer to db's path in **argv
+ * \param &ArgcList list of arguments that we do not parse here
  * \return exit code (0 - successful, all else - something's wrong)
  */
 static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode,\
                                    config& configuration, char *&ConfigFileName)
+static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode,
+                                   config& configuration, char **ConfigFileName, set<int> &ArgcList)
+{
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
 …
   molecule *mol = NULL;
   string BondGraphFileName("\n");
+  int verbosity = 0;
+  strncpy(configuration.databasepath, LocalPath, MAXSTRINGSIZE-1);
+  bool DatabasePathGiven = false;
   if (argc > 1) { // config file specified as option
 …
           case 'H':
           case '?':
+            DoLog(0) && (Log() << Verbose(0) << "MoleCuilder suite" << endl << "==================" << endl << endl);
+            DoLog(0) && (Log() << Verbose(0) << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl);
+            DoLog(0) && (Log() << Verbose(0) << "or simply " << argv[0] << " without arguments for interactive session." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-b xx xy xz yy yz zz\tCenter atoms in domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-B xx xy xz yy yz zz\tBound atoms by domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-C <type> [params] <output> <bin output> <BinWidth> <BinStart> <BinEnd>\tPair Correlation analysis." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-e <file>\tSets the databases path to be parsed (default: ./)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-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);
+            DoLog(0) && (Log() << Verbose(0) << "\t-F <xyz of filler> <dist_x> <dist_y> <dist_z> <epsilon> <randatom> <randmol> <DoRotate>\tFilling Box with water molecules." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-FF <MaxDistance> <xyz of filler> <dist_x> <dist_y> <dist_z> <epsilon> <randatom> <randmol> <DoRotate>\tFilling Box with water molecules." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-g <file>\tParses a bond length table from the given file." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-h/-H/-?\tGive this help screen." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-I\t Dissect current system of molecules into a set of disconnected (subgraphs of) molecules." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-j\t<path> Store all bonds to file." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-J\t<path> Store adjacency per atom to file." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-L <step0> <step1> <prefix>\tStore a linear interpolation between two configurations <step0> and <step1> into single config files with prefix <prefix> and as Trajectories into the current config file." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-M <basis>\tSetting basis to store to MPQC config files." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-n\tFast parsing (i.e. no trajectories are looked for)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-N <radius> <file>\tGet non-convex-envelope." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-o <out>\tGet volume of the convex envelope (and store to tecplot file)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-O\tCenter atoms in origin." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-p <file>\tParse given xyz file and create raw config file from it." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-P <file>\tParse given forces file and append as an MD step to config file via Verlet." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-r <id>\t\tRemove an atom with given id." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-R <id> <radius>\t\tRemove all atoms out of sphere around a given one." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-S <file> Store temperatures from the config file in <file>." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-T x1 x2 x3\tTranslate periodically all atoms by this vector (x1,x2,x3)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-v\t\tsets verbosity (more is more)." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-V\t\tGives version information." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "\t-X\t\tset default name of a molecule." << endl);
+            DoLog(0) && (Log() << Verbose(0) << "Note: config files must not begin with '-' !" << endl);
+            return (1);
+            ArgcList.insert(argptr-1);
+            return(1);
             break;
           case 'v':
+            while (argv[argptr-1][verbosity+1] == 'v') {
+              verbosity++;
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for specifying verbosity: -v <level>" << endl);
+              performCriticalExit();
+            } else {
+              setVerbosity(atoi(argv[argptr]));
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
+              argptr++;
+            }
-            setVerbosity(verbosity);
-            DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
             break;
           case 'V':
+            DoLog(0) && (Log() << Verbose(0) << argv[0] << " " << VERSIONSTRING << endl);
+            DoLog(0) && (Log() << Verbose(0) << "Build your own molecule position set." << endl);
+            return (1);
+            ArgcList.insert(argptr-1);
+            return(1);
             break;
           case 'B':
             if (ExitFlag == 0) ExitFlag = 1;
+            if ((argptr+5 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) ) {
+              ExitFlag = 255;
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for bounding in box: -B <xx> <xy> <xz> <yy> <yz> <zz>" << endl);
+            if ((argptr+5 >= argc)) {
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for setting Box: -B <xx> <<xy> <<xz> <yy> <yz> <zz>" << endl);
               performCriticalExit();
             } else {
               SaveFlag = true;
               j = -1;
               DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
               double * const cell_size = World::getInstance().getDomain();
               for (int i=0;i<6;i++) {
                 cell_size[i] = atof(argv[argptr+i]);
+              }
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
+              ArgcList.insert(argptr+1);
+              ArgcList.insert(argptr+2);
+              ArgcList.insert(argptr+3);
+              ArgcList.insert(argptr+4);
+              ArgcList.insert(argptr+5);
               argptr+=6;
+            }
 …
               performCriticalExit();
             } else {
               DoLog(0) && (Log() << Verbose(0) << "Using " << argv[argptr] << " as elements database." << endl);
               strncpy (configuration.databasepath, argv[argptr], MAXSTRINGSIZE-1);
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
               argptr+=1;
+            }
 …
               performCriticalExit();
             } else {
+              BondGraphFileName = argv[argptr];
+              DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
+              argptr+=1;
+            }
+            break;
+          case 'M':
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              ExitFlag = 255;
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting MPQC basis: -M <basis name>" << endl);
+              performCriticalExit();
+            } else {
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
               argptr+=1;
+            }
             break;
           case 'n':
+            DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+            configuration.FastParsing = true;
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              ExitFlag = 255;
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting fast-parsing: -n <0/1>" << endl);
+              performCriticalExit();
+            } else {
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
+              argptr+=1;
+            }
             break;
           case 'X':
+            {
+              World::getInstance().setDefaultName(argv[argptr]);
+              DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << *World::getInstance().getDefaultName() << "." << endl);
+            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+              ExitFlag = 255;
+              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting default molecule name: -X <name>" << endl);
+              performCriticalExit();
+            } else {
+              ArgcList.insert(argptr-1);
+              ArgcList.insert(argptr);
+              argptr+=1;
+            }
             break;
 …
     } while (argptr < argc);
-    // 3a. Parse the element database
-    if (periode->LoadPeriodentafel(configuration.databasepath)) {
-      DoLog(0) && (Log() << Verbose(0) << "Element list loaded successfully." << endl);
-      //periode->Output();
-    } else {
-      DoLog(0) && (Log() << Verbose(0) << "Element list loading failed." << endl);
-      return 1;
+    }
     // 3b. Find config file name and parse if possible, also BondGraphFileName
     if (argv[1][0] != '-') {
 …
         } else {
           DoLog(0) && (Log() << Verbose(0) << "Empty configuration file." << endl);
           ConfigFileName = argv[1];
+          strcpy(*ConfigFileName, argv[1]);
           configPresent = empty;
           output.close();
 …
       } else {
         test.close();
         ConfigFileName = argv[1];
+        strcpy(*ConfigFileName, argv[1]);
         DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
         switch (configuration.TestSyntax(ConfigFileName, periode)) {
+        switch (configuration.TestSyntax(*ConfigFileName, periode)) {
           case 1:
             DoLog(0) && (Log() << Verbose(0) << "new syntax." << endl);
             configuration.Load(ConfigFileName, BondGraphFileName, periode, molecules);
+            configuration.Load(*ConfigFileName, BondGraphFileName, periode, molecules);
             configPresent = present;
             break;
           case 0:
             DoLog(0) && (Log() << Verbose(0) << "old syntax." << endl);
             configuration.LoadOld(ConfigFileName, BondGraphFileName, periode, molecules);
+            configuration.LoadOld(*ConfigFileName, BondGraphFileName, periode, molecules);
             configPresent = present;
             break;
 …
        mol = World::getInstance().createMolecule();
        mol->ActiveFlag = true;
        if (ConfigFileName != NULL)
          mol->SetNameFromFilename(ConfigFileName);
+       if (*ConfigFileName != NULL)
+         mol->SetNameFromFilename(*ConfigFileName);
        molecules->insert(mol);
+     }
-     if (configuration.BG == NULL) {
-       configuration.BG = new BondGraph(configuration.GetIsAngstroem());
-       if ((!BondGraphFileName.empty()) && (configuration.BG->LoadBondLengthTable(BondGraphFileName))) {
-         DoLog(0) && (Log() << Verbose(0) << "Bond length table loaded successfully." << endl);
-       } else {
-         DoeLog(1) && (eLog()<< Verbose(1) << "Bond length table loading failed." << endl);
+       }
+     }
 …
             case 'a':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3]))) {
+              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough arguments for adding atom: -a <Z> --position <x> <y> <z>" << endl);
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
+                first = World::getInstance().createAtom();
+                first->type = periode->FindElement(atoi(argv[argptr]));
+                if (first->type != NULL)
+                  DoLog(2) && (Log() << Verbose(2) << "found element " << first->type->name << endl);
+                for (int i=NDIM;i--;)
+                  first->x[i] = atof(argv[argptr+1+i]);
+                if (first->type != NULL) {
+                  mol->AddAtom(first);  // add to molecule
+                  if ((configPresent == empty) && (mol->AtomCount != 0))
+                    configPresent = present;
+                } else
+                  DoeLog(1) && (eLog()<< Verbose(1) << "Could not find the specified element." << endl);
+                argptr+=4;
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                argptr+=5;
+              }
               break;
 …
         if (configPresent == present) {
           switch(argv[argptr-1][1]) {
+            case 'M':
+            case 'D':
+              if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting MPQC basis: -B <basis name>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for depth-first-search analysis: -D <max. bond distance>" << endl);
                 performCriticalExit();
               } else {
                 configuration.basis = argv[argptr];
                 DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration.basis << "." << endl);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
                 argptr+=1;
+              }
-              break;
-            case 'D':
-              if (ExitFlag == 0) ExitFlag = 1;
+              {
-                DoLog(1) && (Log() << 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;
-                class StackClass<bond *> *BackEdgeStack = NULL;
-                class StackClass<bond *> *LocalBackEdgeStack = NULL;
-                mol->CreateAdjacencyList(atof(argv[argptr]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
-                Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
-                if (Subgraphs != NULL) {
-                  int FragmentCounter = 0;
-                  while (Subgraphs->next != NULL) {
-                    Subgraphs = Subgraphs->next;
-                    Subgraphs->FillBondStructureFromReference(mol, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
-                    LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
-                    Subgraphs->Leaf->PickLocalBackEdges(ListOfLocalAtoms[FragmentCounter], BackEdgeStack, LocalBackEdgeStack);
-                    Subgraphs->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
-                    delete(LocalBackEdgeStack);
-                    delete(Subgraphs->previous);
-                    FragmentCounter++;
+                  }
-                  delete(Subgraphs);
-                  for (int i=0;i<FragmentCounter;i++)
-                    Free(&ListOfLocalAtoms[i]);
-                  Free(&ListOfLocalAtoms);
+                }
-                delete(BackEdgeStack);
-                delete[](MinimumRingSize);
+              }
-              //argptr+=1;
               break;
             case 'I':
               DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+              // @TODO rather do the dissection afterwards
+              molecules->DissectMoleculeIntoConnectedSubgraphs(periode, &configuration);
+              mol = NULL;
+              if (molecules->ListOfMolecules.size() != 0) {
+                for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+                  if ((*ListRunner)->ActiveFlag) {
+                    mol = *ListRunner;
+                    break;
+                  }
+              }
+              if ((mol == NULL) && (!molecules->ListOfMolecules.empty())) {
+                mol = *(molecules->ListOfMolecules.begin());
+                if (mol != NULL)
+                  mol->ActiveFlag = true;
+              }
+              ArgcList.insert(argptr-1);
+              argptr+=0;
               break;
             case 'C':
+              {
-                int ranges[3] = {1, 1, 1};
-                bool periodic = (argv[argptr-1][2] =='p');
                 if (ExitFlag == 0) ExitFlag = 1;
                 if ((argptr >= argc)) {
+                if ((argptr+11 >= argc)) {
                   ExitFlag = 255;
                   DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C[p] <type: E/P/S> [more params] <output> <bin output> <BinStart> <BinEnd>" << endl);
 …
                   switch(argv[argptr][0]) {
                     case 'E':
+                      {
+                        if ((argptr+6 >= argc) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (!IsValidNumber(argv[argptr+2])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-') || (argv[argptr+4][0] == '-')) {
+                          ExitFlag = 255;
+                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C E <Z1> <Z2> <output> <bin output>" << endl);
+                          performCriticalExit();
+                        } else {
+                          ofstream output(argv[argptr+3]);
+                          ofstream binoutput(argv[argptr+4]);
+                          const double BinStart = atof(argv[argptr+5]);
+                          const double BinEnd = atof(argv[argptr+6]);
+                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
+                          const element *elemental2 = periode->FindElement((const int) atoi(argv[argptr+2]));
+                          PairCorrelationMap *correlationmap = NULL;
+                          if (periodic)
+                            correlationmap = PeriodicPairCorrelation(molecules, elemental, elemental2, ranges);
+                          else
+                            correlationmap = PairCorrelation(molecules, elemental, elemental2);
+                          //OutputCorrelationToSurface(&output, correlationmap);
+                          BinPairMap *binmap = BinData( correlationmap, 0.5, BinStart, BinEnd );
+                          OutputCorrelation ( &binoutput, binmap );
+                          output.close();
+                          binoutput.close();
+                          delete(binmap);
+                          delete(correlationmap);
+                          argptr+=7;
+                        }
+                      }
+                      ArgcList.insert(argptr-1);
+                      ArgcList.insert(argptr);
+                      ArgcList.insert(argptr+1);
+                      ArgcList.insert(argptr+2);
+                      ArgcList.insert(argptr+3);
+                      ArgcList.insert(argptr+4);
+                      ArgcList.insert(argptr+5);
+                      ArgcList.insert(argptr+6);
+                      ArgcList.insert(argptr+7);
+                      ArgcList.insert(argptr+8);
+                      ArgcList.insert(argptr+9);
+                      ArgcList.insert(argptr+10);
+                      ArgcList.insert(argptr+11);
+                      argptr+=12;
                       break;
                     case 'P':
+                      {
+                        if ((argptr+8 >= argc) || (!IsValidNumber(argv[argptr+1])) ||  (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+7])) || (!IsValidNumber(argv[argptr+8])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-') || (argv[argptr+4][0] == '-') || (argv[argptr+5][0] == '-') || (argv[argptr+6][0] == '-')) {
+                          ExitFlag = 255;
+                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C P <Z1> <x> <y> <z> <output> <bin output>" << endl);
+                          performCriticalExit();
+                        } else {
+                          ofstream output(argv[argptr+5]);
+                          ofstream binoutput(argv[argptr+6]);
+                          const double BinStart = atof(argv[argptr+7]);
+                          const double BinEnd = atof(argv[argptr+8]);
+                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
+                          Vector *Point = new Vector((const double) atof(argv[argptr+1]),(const double) atof(argv[argptr+2]),(const double) atof(argv[argptr+3]));
+                          CorrelationToPointMap *correlationmap = NULL;
+                          if (periodic)
+                            correlationmap  = PeriodicCorrelationToPoint(molecules, elemental, Point, ranges);
+                          else
+                            correlationmap = CorrelationToPoint(molecules, elemental, Point);
+                          //OutputCorrelationToSurface(&output, correlationmap);
+                          BinPairMap *binmap = BinData( correlationmap, 0.5, BinStart, BinEnd );
+                          OutputCorrelation ( &binoutput, binmap );
+                          output.close();
+                          binoutput.close();
+                          delete(Point);
+                          delete(binmap);
+                          delete(correlationmap);
+                          argptr+=9;
+                        }
+                      }
+                      ArgcList.insert(argptr-1);
+                      ArgcList.insert(argptr);
+                      ArgcList.insert(argptr+1);
+                      ArgcList.insert(argptr+2);
+                      ArgcList.insert(argptr+3);
+                      ArgcList.insert(argptr+4);
+                      ArgcList.insert(argptr+5);
+                      ArgcList.insert(argptr+6);
+                      ArgcList.insert(argptr+7);
+                      ArgcList.insert(argptr+8);
+                      ArgcList.insert(argptr+9);
+                      ArgcList.insert(argptr+10);
+                      ArgcList.insert(argptr+11);
+                      ArgcList.insert(argptr+12);
+                      ArgcList.insert(argptr+13);
+                      ArgcList.insert(argptr+14);
+                      argptr+=15;
                       break;
                     case 'S':
+                      {
+                        if ((argptr+6 >= argc) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-')) {
+                          ExitFlag = 255;
+                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C S <Z> <output> <bin output> <BinWidth> <BinStart> <BinEnd>" << endl);
+                          performCriticalExit();
+                        } else {
+                          ofstream output(argv[argptr+2]);
+                          ofstream binoutput(argv[argptr+3]);
+                          const double radius = 4.;
+                          const double BinWidth = atof(argv[argptr+4]);
+                          const double BinStart = atof(argv[argptr+5]);
+                          const double BinEnd = atof(argv[argptr+6]);
+                          double LCWidth = 20.;
+                          if (BinEnd > 0) {
+                            if (BinEnd > 2.*radius)
+                                LCWidth = BinEnd;
+                            else
+                              LCWidth = 2.*radius;
+                          }
+                          // get the boundary
+                          class molecule *Boundary = NULL;
+                          class Tesselation *TesselStruct = NULL;
+                          const LinkedCell *LCList = NULL;
+                          // find biggest molecule
+                          int counter  = 0;
+                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+                            if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
+                              Boundary = *BigFinder;
+                            }
+                            counter++;
+                          }
+                          bool *Actives = Malloc<bool>(counter, "ParseCommandLineOptions() - case C -- *Actives");
+                          counter = 0;
+                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+                            Actives[counter++] = (*BigFinder)->ActiveFlag;
+                            (*BigFinder)->ActiveFlag = (*BigFinder == Boundary) ? false : true;
+                          }
+                          LCList = new LinkedCell(Boundary, LCWidth);
+                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
+                          FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
+                          CorrelationToSurfaceMap *surfacemap = NULL;
+                          if (periodic)
+                            surfacemap = PeriodicCorrelationToSurface( molecules, elemental, TesselStruct, LCList, ranges);
+                          else
+                            surfacemap = CorrelationToSurface( molecules, elemental, TesselStruct, LCList);
+                          OutputCorrelationToSurface(&output, surfacemap);
+                          // check whether radius was appropriate
+                          {
+                            double start; double end;
+                            GetMinMax( surfacemap, start, end);
+                            if (LCWidth < end)
+                              DoeLog(1) && (eLog()<< Verbose(1) << "Linked Cell width is smaller than the found range of values! Bins can only be correct up to: " << radius << "." << endl);
+                          }
+                          BinPairMap *binmap = BinData( surfacemap, BinWidth, BinStart, BinEnd );
+                          OutputCorrelation ( &binoutput, binmap );
+                          output.close();
+                          binoutput.close();
+                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++)
+                            (*BigFinder)->ActiveFlag = Actives[counter++];
+                          Free(&Actives);
+                          delete(LCList);
+                          delete(TesselStruct);
+                          delete(binmap);
+                          delete(surfacemap);
+                          argptr+=7;
+                        }
+                      }
+                      ArgcList.insert(argptr-1);
+                      ArgcList.insert(argptr);
+                      ArgcList.insert(argptr+1);
+                      ArgcList.insert(argptr+2);
+                      ArgcList.insert(argptr+3);
+                      ArgcList.insert(argptr+4);
+                      ArgcList.insert(argptr+5);
+                      ArgcList.insert(argptr+6);
+                      ArgcList.insert(argptr+7);
+                      ArgcList.insert(argptr+8);
+                      ArgcList.insert(argptr+9);
+                      ArgcList.insert(argptr+10);
+                      ArgcList.insert(argptr+11);
+                      ArgcList.insert(argptr+12);
+                      ArgcList.insert(argptr+13);
+                      ArgcList.insert(argptr+14);
+                      argptr+=15;
                       break;
 …
             case 'E':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr+1][0] == '-')) {
+              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr]))) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for changing element: -E <atom nr.> <element>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for changing element: -E <atom nr.> --element <Z>" << endl);
                 performCriticalExit();
               } else {
                 SaveFlag = true;
                 DoLog(1) && (Log() << 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;
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
               break;
             case 'F':
               if (ExitFlag == 0) ExitFlag = 1;
+              MaxDistance = -1;
+              if (argv[argptr-1][2] == 'F') { // option is -FF?
+                // fetch first argument as max distance to surface
+                MaxDistance = atof(argv[argptr++]);
+                DoLog(0) && (Log() << Verbose(0) << "Filling with maximum layer distance of " << MaxDistance << "." << endl);
+              }
+              if ((argptr+7 >=argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (!IsValidNumber(argv[argptr+7]))) {
+              if ((argptr+12 >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for filling box with water: -F <xyz of filler> <dist_x> <dist_y> <dist_z> <boundary> <randatom> <randmol> <DoRotate>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for filling with molecule: -F <filler xyz file> --MaxDistance <distance or -1> --distances <x> <y> <z>  --lengths <surface> <randatm> <randmol> --DoRotate <0/1>" << endl);
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules." << endl);
+                // construct water molecule
+                molecule *filler = World::getInstance().createMolecule();
+                if (!filler->AddXYZFile(argv[argptr])) {
+                  DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << argv[argptr] << "." << endl);
+                }
+                filler->SetNameFromFilename(argv[argptr]);
+                configuration.BG->ConstructBondGraph(filler);
+                molecule *Filling = NULL;
+                atom *second = NULL, *third = NULL;
+                first = World::getInstance().createAtom();
+                first->type = periode->FindElement(1);
+                first->x = Vector(0.441, -0.143, 0.);
+                filler->AddAtom(first);
+                second = World::getInstance().createAtom();
+                second->type = periode->FindElement(1);
+                second->x = Vector(-0.464, 1.137, 0.0);
+                filler->AddAtom(second);
+                third = World::getInstance().createAtom();
+                third->type = periode->FindElement(8);
+                third->x = Vector(-0.464, 0.177, 0.);
+                filler->AddAtom(third);
+                filler->AddBond(first, third, 1);
+                filler->AddBond(second, third, 1);
+                // call routine
+                double distance[NDIM];
+                for (int i=0;i<NDIM;i++)
+                  distance[i] = atof(argv[argptr+i+1]);
+                Filling = FillBoxWithMolecule(molecules, filler, configuration, MaxDistance, distance, atof(argv[argptr+4]), atof(argv[argptr+5]), atof(argv[argptr+6]), atoi(argv[argptr+7]));
+                if (Filling != NULL) {
+                  Filling->ActiveFlag = false;
+                  molecules->insert(Filling);
+                }
+                World::getInstance().destroyMolecule(filler);
+                argptr+=6;
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                ArgcList.insert(argptr+5);
+                ArgcList.insert(argptr+6);
+                ArgcList.insert(argptr+7);
+                ArgcList.insert(argptr+8);
+                ArgcList.insert(argptr+9);
+                ArgcList.insert(argptr+10);
+                ArgcList.insert(argptr+11);
+                ArgcList.insert(argptr+12);
+                argptr+=13;
+              }
               break;
             case 'A':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag =255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Missing source file for bonds in molecule: -A <bond sourcefile> --molecule-by-id <molecule_id>" << endl);
+                performCriticalExit();
+              } else {
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
+              break;
+            case 'J':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag =255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of adjacency file: -J <path> --molecule-by-id <molecule_id>" << endl);
+                performCriticalExit();
+              } else {
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
+              break;
+            case 'j':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag =255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of bonds file: -j <path> --molecule-by-id <molecule_id>" << endl);
                 performCriticalExit();
               } else {
                 DoLog(0) && (Log() << Verbose(0) << "Parsing bonds from " << argv[argptr] << "." << endl);
                 ifstream *input = new ifstream(argv[argptr]);
                 mol->CreateAdjacencyListFromDbondFile(input);
                 input->close();
                 argptr+=1;
+              }
               break;
             case 'J':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag =255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of adjacency file: -j <path>" << endl);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
+              break;
+            case 'N':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')){
+                ExitFlag = 255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for non-convex envelope: -N <molecule_id> --sphere-radius <radius> --nonconvex-file <output prefix>" << endl);
                 performCriticalExit();
               } else {
+                DoLog(0) && (Log() << Verbose(0) << "Storing adjacency to path " << argv[argptr] << "." << endl);
+                configuration.BG->ConstructBondGraph(mol);
+                mol->StoreAdjacencyToFile(NULL, argv[argptr]);
+                argptr+=1;
+              }
+              break;
+            case 'j':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag =255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of bonds file: -j <path>" << endl);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                argptr+=5;
+              }
+              break;
+            case 'S':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
+                ExitFlag = 255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for storing tempature: -S <temperature file> --molecule-by-id 0" << endl);
                 performCriticalExit();
               } else {
                 DoLog(0) && (Log() << Verbose(0) << "Storing bonds to path " << argv[argptr] << "." << endl);
                 configuration.BG->ConstructBondGraph(mol);
                 mol->StoreBondsToFile(NULL, argv[argptr]);
                 argptr+=1;
+              }
               break;
             case 'N':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+1 >= argc) || (argv[argptr+1][0] == '-')){
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
+              break;
+            case 'L':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+8 >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for linear interpolation: -L <prefix> --start-step <step0> --end-step <step1> --molecule-by-id 0 --id-mapping <0/1>" << endl);
                 performCriticalExit();
               } else {
+                class Tesselation *T = NULL;
+                const LinkedCell *LCList = NULL;
+                molecule * Boundary = NULL;
+                //string filename(argv[argptr+1]);
+                //filename.append(".csv");
+                DoLog(0) && (Log() << Verbose(0) << "Evaluating non-convex envelope of biggest molecule.");
+                DoLog(1) && (Log() << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl);
+                // find biggest molecule
+                int counter  = 0;
+                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+                  (*BigFinder)->CountAtoms();
+                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
+                    Boundary = *BigFinder;
+                  }
+                  counter++;
+                }
+                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->AtomCount << " atoms." << endl);
+                start = clock();
+                LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
+                if (!FindNonConvexBorder(Boundary, T, LCList, atof(argv[argptr]), argv[argptr+1]))
+                  ExitFlag = 255;
+                //FindDistributionOfEllipsoids(T, &LCList, N, number, filename.c_str());
+                end = clock();
+                DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
+                delete(LCList);
+                delete(T);
+                argptr+=2;
+              }
+              break;
+            case 'S':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                ArgcList.insert(argptr+5);
+                ArgcList.insert(argptr+6);
+                ArgcList.insert(argptr+7);
+                ArgcList.insert(argptr+8);
+                argptr+=9;
+              }
+              break;
+            case 'P':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for storing tempature: -S <temperature file>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file> --molecule-by-id <molecule_id>" << endl);
                 performCriticalExit();
               } else {
+                DoLog(1) && (Log() << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl);
+                ofstream *output = new ofstream(argv[argptr], ios::trunc);
+                if (!mol->OutputTemperatureFromTrajectories(output, 0, mol->MDSteps))
+                  DoLog(2) && (Log() << Verbose(2) << "File could not be written." << endl);
+                else
+                  DoLog(2) && (Log() << Verbose(2) << "File stored." << endl);
+                output->close();
+                delete(output);
+                argptr+=1;
+              }
+              break;
+            case 'L':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
+              break;
+            case 'R':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+4 >= argc) || (argv[argptr][0] == '-'))  {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for storing tempature: -L <step0> <step1> <prefix> <identity mapping?>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <distance> --position <x> <y> <z>" << endl);
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                DoLog(1) && (Log() << Verbose(1) << "Linear interpolation between configuration " << argv[argptr] << " and " << argv[argptr+1] << "." << endl);
+                if (atoi(argv[argptr+3]) == 1)
+                  DoLog(1) && (Log() << Verbose(1) << "Using Identity for the permutation map." << endl);
+                if (!mol->LinearInterpolationBetweenConfiguration(atoi(argv[argptr]), atoi(argv[argptr+1]), argv[argptr+2], configuration, atoi(argv[argptr+3])) == 1 ? true : false)
+                  DoLog(2) && (Log() << Verbose(2) << "Could not store " << argv[argptr+2] << " files." << endl);
+                else
+                  DoLog(2) && (Log() << Verbose(2) << "Steps created and " << argv[argptr+2] << " files stored." << endl);
+                argptr+=4;
+              }
+              break;
+            case 'P':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                argptr+=5;
+              }
+              break;
+            case 't':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+4 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for translation: -t <x> <y> <z> --molecule-by-id <molecule_id> --periodic <0/1>" << endl);
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                DoLog(1) && (Log() << Verbose(1) << "Parsing forces file and Verlet integrating." << endl);
+                if (!mol->VerletForceIntegration(argv[argptr], configuration))
+                  DoLog(2) && (Log() << Verbose(2) << "File not found." << endl);
+                else
+                  DoLog(2) && (Log() << Verbose(2) << "File found and parsed." << endl);
+                argptr+=1;
+              }
+              break;
+            case 'R':
+              if (ExitFlag == 0) ExitFlag = 1;
+              if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])))  {
+                ExitFlag = 255;
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <id> <distance>" << endl);
+                performCriticalExit();
+              } else {
+                SaveFlag = true;
+                DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << argv[argptr] << " with radius " << argv[argptr+1] << "." << endl);
+                double tmp1 = atof(argv[argptr+1]);
+                atom *third = mol->FindAtom(atoi(argv[argptr]));
+                atom *first = mol->start;
+                if ((third != NULL) && (first != mol->end)) {
+                  atom *second = first->next;
+                  while(second != mol->end) {
+                    first = second;
+                    second = first->next;
+                    if (first->x.DistanceSquared(third->x) > tmp1*tmp1) // distance to first above radius ...
+                      mol->RemoveAtom(first);
+                  }
+                } else {
+                  DoeLog(1) && (eLog()<< Verbose(1) << "Removal failed due to missing atoms on molecule or wrong id." << endl);
+                }
+                argptr+=2;
+              }
+              break;
+            case 't':
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                ArgcList.insert(argptr+5);
+                ArgcList.insert(argptr+6);
+                argptr+=7;
+              }
+              break;
+            case 's':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for translation: -t <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                if (ExitFlag == 0) ExitFlag = 1;
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Translating all ions by given vector." << endl);
-                for (int i=NDIM;i--;)
-                  x[i] = atof(argv[argptr+i]);
-                mol->Translate((const Vector *)&x);
-                argptr+=3;
+              }
-              break;
-            case 'T':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for periodic translation: -T <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                if (ExitFlag == 0) ExitFlag = 1;
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Translating all ions periodically by given vector." << endl);
-                for (int i=NDIM;i--;)
-                  x[i] = atof(argv[argptr+i]);
-                mol->TranslatePeriodically((const Vector *)&x);
-                argptr+=3;
+              }
-              break;
-            case 's':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for scaling: -s <factor_x> [factor_y] [factor_z]" << endl);
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                j = -1;
+                DoLog(1) && (Log() << Verbose(1) << "Scaling all ion positions by factor." << endl);
+                factor = new double[NDIM];
+                factor[0] = atof(argv[argptr]);
+                factor[1] = atof(argv[argptr+1]);
+                factor[2] = atof(argv[argptr+2]);
+                mol->Scale((const double ** const)&factor);
+                double * const cell_size = World::getInstance().getDomain();
+                for (int i=0;i<NDIM;i++) {
+                  j += i+1;
+                  x[i] = atof(argv[NDIM+i]);
+                  cell_size[j]*=factor[i];
+                }
+                delete[](factor);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
                 argptr+=3;
+              }
 …
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                j = -1;
+                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
+                double * const cell_size = World::getInstance().getDomain();
+                for (int i=0;i<6;i++) {
+                  cell_size[i] = atof(argv[argptr+i]);
+                }
+                // center
+                mol->CenterInBox();
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                ArgcList.insert(argptr+5);
                 argptr+=6;
+              }
 …
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                j = -1;
+                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
+                double * const cell_size = World::getInstance().getDomain();
+                for (int i=0;i<6;i++) {
+                  cell_size[i] = atof(argv[argptr+i]);
+                }
+                // center
+                mol->BoundInBox();
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                ArgcList.insert(argptr+5);
                 argptr+=6;
+              }
 …
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                j = -1;
+                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl);
+                // make every coordinate positive
+                mol->CenterEdge(&x);
+                // update Box of atoms by boundary
+                mol->SetBoxDimension(&x);
+                // translate each coordinate by boundary
+                double * const cell_size = World::getInstance().getDomain();
+                j=-1;
+                for (int i=0;i<NDIM;i++) {
+                  j += i+1;
+                  x[i] = atof(argv[argptr+i]);
+                  cell_size[j] += x[i]*2.;
+                }
+                mol->Translate((const Vector *)&x);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
                 argptr+=3;
+              }
 …
             case 'O':
               if (ExitFlag == 0) ExitFlag = 1;
+              SaveFlag = true;
+              DoLog(1) && (Log() << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl);
+              x.Zero();
+              mol->CenterEdge(&x);
+              mol->SetBoxDimension(&x);
+              ArgcList.insert(argptr-1);
               argptr+=0;
               break;
 …
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                DoLog(1) && (Log() << Verbose(1) << "Removing atom " << argv[argptr] << "." << endl);
+                atom *first = mol->FindAtom(atoi(argv[argptr]));
+                mol->RemoveAtom(first);
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
                 argptr+=1;
+              }
 …
             case 'f':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1]))) {
+              if ((argptr+1 >= argc) || (argv[argptr][0] == '-')) {
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for fragmentation: -f <max. bond distance> <bond order>" << endl);
                 performCriticalExit();
               } else {
+                DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "Creating connection matrix..." << endl);
+                start = clock();
+                mol->CreateAdjacencyList(atof(argv[argptr]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+                DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl);
+                if (mol->first->next != mol->last) {
+                  ExitFlag = mol->FragmentMolecule(atoi(argv[argptr+1]), &configuration);
+                }
+                end = clock();
+                DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
+                argptr+=2;
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                argptr+=5;
+              }
               break;
 …
                 SaveFlag = true;
                 DoLog(0) && (Log() << Verbose(0) << "Converting to prinicipal axis system." << endl);
+                mol->PrincipalAxisSystem((bool)j);
               } else
                 DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
               mol->PrincipalAxisSystem((bool)j);
+                ArgcList.insert(argptr-1);
+                argptr+=0;
               break;
             case 'o':
               if (ExitFlag == 0) ExitFlag = 1;
               if ((argptr+1 >= argc) || (argv[argptr][0] == '-')){
+              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')){
                 ExitFlag = 255;
                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for convex envelope: -o <convex output file> <non-convex output file>" << endl);
+                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for convex envelope: -o <molecule_id> --output-file <output file> --output-file <binned output file>" << endl);
                 performCriticalExit();
               } else {
+                class Tesselation *TesselStruct = NULL;
+                const LinkedCell *LCList = NULL;
+                DoLog(0) && (Log() << Verbose(0) << "Evaluating volume of the convex envelope.");
+                DoLog(1) && (Log() << Verbose(1) << "Storing tecplot convex data in " << argv[argptr] << "." << endl);
+                DoLog(1) && (Log() << Verbose(1) << "Storing tecplot non-convex data in " << argv[argptr+1] << "." << endl);
+                LCList = new LinkedCell(mol, 10.);
+                //FindConvexBorder(mol, LCList, argv[argptr]);
+                FindNonConvexBorder(mol, TesselStruct, LCList, 5., argv[argptr+1]);
+//                RemoveAllBoundaryPoints(TesselStruct, mol, argv[argptr]);
+                double volumedifference = ConvexizeNonconvexEnvelope(TesselStruct, mol, argv[argptr]);
+                double clustervolume = VolumeOfConvexEnvelope(TesselStruct, &configuration);
+                DoLog(0) && (Log() << Verbose(0) << "The tesselated volume area is " << clustervolume << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "The non-convex tesselated volume area is " << clustervolume-volumedifference << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl);
+                delete(TesselStruct);
+                delete(LCList);
+                argptr+=2;
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                ArgcList.insert(argptr+3);
+                ArgcList.insert(argptr+4);
+                argptr+=5;
+              }
               break;
 …
                   performCriticalExit();
               } else {
+                double density;
+                SaveFlag = true;
+                DoLog(0) && (Log() << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.");
+                density = atof(argv[argptr++]);
+                if (density < 1.0) {
+                  DoeLog(1) && (eLog()<< Verbose(1) << "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)
+//                    DoeLog(1) && (eLog()<< Verbose(1) << "repetition value must be greater 1!" << endl);
+//                  repetition[i] = 1;
+//                }
+                PrepareClustersinWater(&configuration, mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                argptr+=1;
+              }
               break;
 …
                 performCriticalExit();
               } else {
+                SaveFlag = true;
+                double * const cell_size = World::getInstance().getDomain();
+                for (int axis = 1; axis <= NDIM; axis++) {
+                  int faktor = atoi(argv[argptr++]);
+                  int count;
+                  const element ** Elements;
+                  Vector ** vectors;
+                  if (faktor < 1) {
+                    DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor mus be greater than 1!" << endl);
+                    faktor = 1;
+                  }
+                  mol->CountAtoms();  // 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 const 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)
+                      DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
+                    x.Zero();
+                    y.Zero();
+                    y[abs(axis)-1] = 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 += y; // per factor one cell width further
+                      for (int k=count;k--;) { // go through every atom of the original cell
+                        first = World::getInstance().createAtom(); // create a new body
+                        first->x = (*vectors[k]) + x;
+                        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 =(-(faktor-1)) * y;
+                      mol->Translate(&x);
+                    }
+                    cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+                  }
+                }
+                ArgcList.insert(argptr-1);
+                ArgcList.insert(argptr);
+                ArgcList.insert(argptr+1);
+                ArgcList.insert(argptr+2);
+                argptr+=3;
+              }
               break;
 …
     } while (argptr < argc);
     if (SaveFlag)
       configuration.SaveAll(ConfigFileName, periode, molecules);
+      configuration.SaveAll(*ConfigFileName, periode, molecules);
   } else {  // no arguments, hence scan the elements db
     if (periode->LoadPeriodentafel(configuration.databasepath))
 …
 };
-/***************************************** Functions used to build all menus **********************/
-void populateEditMoleculesMenu(Menu* editMoleculesMenu,MoleculeListClass *molecules, config *configuration, periodentafel *periode){
-  // build the EditMoleculesMenu
-  Action *createMoleculeAction = new MethodAction("createMoleculeAction",boost::bind(&MoleculeListClass::createNewMolecule,molecules,periode));
-  new ActionMenuItem('c',"create new molecule",editMoleculesMenu,createMoleculeAction);
-  Action *loadMoleculeAction = new MethodAction("loadMoleculeAction",boost::bind(&MoleculeListClass::loadFromXYZ,molecules,periode));
-  new ActionMenuItem('l',"load molecule from xyz file",editMoleculesMenu,loadMoleculeAction);
-  Action *changeFilenameAction = new ChangeMoleculeNameAction(molecules);
-  new ActionMenuItem('n',"change molecule's name",editMoleculesMenu,changeFilenameAction);
-  Action *giveFilenameAction = new MethodAction("giveFilenameAction",boost::bind(&MoleculeListClass::setMoleculeFilename,molecules));
-  new ActionMenuItem('N',"give molecules filename",editMoleculesMenu,giveFilenameAction);
-  Action *parseAtomsAction = new MethodAction("parseAtomsAction",boost::bind(&MoleculeListClass::parseXYZIntoMolecule,molecules));
-  new ActionMenuItem('p',"parse atoms in xyz file into molecule",editMoleculesMenu,parseAtomsAction);
-  Action *eraseMoleculeAction = new MethodAction("eraseMoleculeAction",boost::bind(&MoleculeListClass::eraseMolecule,molecules));
-  new ActionMenuItem('r',"remove a molecule",editMoleculesMenu,eraseMoleculeAction);
+}
 /********************************************** Main routine **************************************/
+void cleanUp(config *configuration){
+  UIFactory::purgeInstance();
+void cleanUp(){
   World::purgeInstance();
-  delete(configuration);
-  Log() << Verbose(0) <<  "Maximum of allocated memory: "
-    << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
-  Log() << Verbose(0) <<  "Remaining non-freed memory: "
-    << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
   errorLogger::purgeInstance();
+  UIFactory::purgeInstance();
+  MapOfActions::purgeInstance();
+  CommandLineParser::purgeInstance();
   ActionRegistry::purgeInstance();
   ActionHistory::purgeInstance();
+#ifdef LOG_OBSERVER
+  cout << observerLog().getLog();
+#endif
   Memory::getState();
+}
 …
 int main(int argc, char **argv)
+{
+    config *configuration = World::getInstance().getConfig();
+    // while we are non interactive, we want to abort from asserts
+    //ASSERT_DO(Assert::Abort);
     molecule *mol = NULL;
-    config *configuration = new config;
     Vector x, y, z, n;
     ifstream test;
     ofstream output;
     string line;
+    char *ConfigFileName = NULL;
+    int j;
+    char **Arguments = NULL;
+    int ArgcSize = 0;
+    int ExitFlag = 0;
+    bool ArgumentsCopied = false;
+    char *ConfigFileName = new char[MAXSTRINGSIZE];
+    // print version check whether arguments are present at all
     cout << ESPACKVersion << endl;
+    if (argc < 2) {
+      cout << "Obtain help with " << argv[0] << " -h." << endl;
+      cleanUp();
+      Memory::getState();
+      return(1);
+    }
     setVerbosity(0);
     // need to init the history before any action is created
     ActionHistory::init();
+    /* structure of ParseCommandLineOptions will be refactored later */
+    j = ParseCommandLineOptions(argc, argv,  World::getInstance().getMolecules(), World::getInstance().getPeriode(), *configuration, ConfigFileName);
+    switch (j){
+        case 255:
+        case 2:
+        case 1:
+            cleanUp(configuration);
+            return (j == 1 ? 0 : j);
+        default:
+            break;
+    // In the interactive mode, we can leave the user the choice in case of error
+    ASSERT_DO(Assert::Ask);
+    // from this moment on, we need to be sure to deeinitialize in the correct order
+    // this is handled by the cleanup function
+    atexit(cleanUp);
+    // Parse command line options and if present create respective UI
+    {
+      set<int> ArgcList;
+      ArgcList.insert(0); // push back program!
+      ArgcList.insert(1); // push back config file name
+      // handle arguments by ParseCommandLineOptions()
+      ExitFlag = ParseCommandLineOptions(argc,argv,World::getInstance().getMolecules(),World::getInstance().getPeriode(),*World::getInstance().getConfig(), &ConfigFileName, ArgcList);
+      World::getInstance().setExitFlag(ExitFlag);
+      // copy all remaining arguments to a new argv
+      Arguments = new char *[ArgcList.size()];
+      cout << "The following arguments are handled by CommandLineParser: ";
+      for (set<int>::iterator ArgcRunner = ArgcList.begin(); ArgcRunner != ArgcList.end(); ++ArgcRunner) {
+        Arguments[ArgcSize] = new char[strlen(argv[*ArgcRunner])+2];
+        strcpy(Arguments[ArgcSize], argv[*ArgcRunner]);
+        cout << " " << argv[*ArgcRunner];
+        ArgcSize++;
+      }
+      cout << endl;
+      ArgumentsCopied = true;
+      // handle remaining arguments by CommandLineParser
+      MapOfActions::getInstance().AddOptionsToParser();
+      map <std::string, std::string> ShortFormToActionMap = MapOfActions::getInstance().getShortFormToActionMap();
+      CommandLineParser::getInstance().Run(ArgcSize,Arguments, ShortFormToActionMap);
+      if (!CommandLineParser::getInstance().isEmpty()) {
+        DoLog(0) && (Log() << Verbose(0) << "Setting UI to CommandLine." << endl);
+        UIFactory::registerFactory(new CommandLineUIFactory::description());
+        UIFactory::makeUserInterface("CommandLine");
+      } else {
+        DoLog(0) && (Log() << Verbose(0) << "Setting UI to Text." << endl);
+        UIFactory::registerFactory(new TextUIFactory::description());
+        UIFactory::makeUserInterface("Text");
+      }
+    }
-    if(World::getInstance().numMolecules() == 0){
-        mol = World::getInstance().createMolecule();
-        World::getInstance().getMolecules()->insert(mol);
-        cout << "Molecule created" << endl;
-        if(World::getInstance().getDomain()[0] == 0.){
-            Log() << Verbose(0) << "enter lower tridiagonal form of basis matrix" << endl << endl;
-            for(int i = 0;i < 6;i++){
-                Log() << Verbose(1) << "Cell size" << i << ": ";
-                cin >> World::getInstance().getDomain()[i];
+            }
+        }
-        mol->ActiveFlag = true;
+    }
+    {
+      cout << ESPACKVersion << endl;
+      setVerbosity(0);
+      menuPopulaters populaters;
+      populaters.MakeEditMoleculesMenu = populateEditMoleculesMenu;
+      UIFactory::makeUserInterface(UIFactory::Text);
+      MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow(populaters,World::getInstance().getMolecules(), configuration, World::getInstance().getPeriode(), ConfigFileName);
+      MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow();
       mainWindow->display();
       delete mainWindow;
+    }
+    if(World::getInstance().getPeriode()->StorePeriodentafel(configuration->databasepath))
+        Log() << Verbose(0) << "Saving of elements.db successful." << endl;
+    else
+        Log() << Verbose(0) << "Saving of elements.db failed." << endl;
+  cleanUp(configuration);
+  return (0);
+    Log() << Verbose(0) << "Saving to " << ConfigFileName << "." << endl;
+    World::getInstance().getConfig()->SaveAll(ConfigFileName, World::getInstance().getPeriode(), World::getInstance().getMolecules());
+  // free the new argv
+  if (ArgumentsCopied) {
+    for (int i=0; i<ArgcSize;i++)
+      delete[](Arguments[i]);
+    delete[](Arguments);
+  }
+  delete[](ConfigFileName);
+  ExitFlag = World::getInstance().getExitFlag();
+  return (ExitFlag == 1 ? 0 : ExitFlag);
+}

src/config.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include <stdio.h>
 …
 #include "element.hpp"
 #include "helpers.hpp"
+#include "info.hpp"
 #include "lists.hpp"
 #include "log.hpp"
 …
     return;
   } else
     buffer = Malloc<char*>(NoLines, "ConfigFileBuffer::ConfigFileBuffer: **buffer");
+    buffer = new char *[NoLines];
   // scan each line and put into buffer
 …
   int i;
   do {
     buffer[lines] = Malloc<char>(MAXSTRINGSIZE, "ConfigFileBuffer::ConfigFileBuffer: *buffer[]");
+    buffer[lines] = new char[MAXSTRINGSIZE];
     file->getline(buffer[lines], MAXSTRINGSIZE-1);
     i = strlen(buffer[lines]);
 …
+{
   for(int i=0;i<NoLines;++i)
     Free(&buffer[i]);
   Free(&buffer);
   Free(&LineMapping);
+    delete[](buffer[i]);
+  delete[](buffer);
+  delete[](LineMapping);
+}
 …
 void ConfigFileBuffer::InitMapping()
+{
   LineMapping = Malloc<int>(NoLines, "ConfigFileBuffer::InitMapping: *LineMapping");
+  LineMapping = new int[NoLines];
   for (int i=0;i<NoLines;i++)
     LineMapping[i] = i;
 …
     MaxLevel(5), RiemannTensor(0), LevRFactor(0), RiemannLevel(0), Lev0Factor(2), RTActualUse(0), AddPsis(0), RCut(20.), StructOpt(0), IsAngstroem(1), RelativeCoord(0),
     MaxTypes(0) {
   mainname = Malloc<char>(MAXSTRINGSIZE,"config constructor: mainname");
   defaultpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: defaultpath");
   pseudopotpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: pseudopotpath");
   databasepath = Malloc<char>(MAXSTRINGSIZE,"config constructor: databasepath");
   configpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: configpath");
   configname = Malloc<char>(MAXSTRINGSIZE,"config constructor: configname");
+  mainname = new char[MAXSTRINGSIZE];
+  defaultpath = new char[MAXSTRINGSIZE];
+  pseudopotpath = new char[MAXSTRINGSIZE];
+  databasepath = new char[MAXSTRINGSIZE];
+  configpath = new char[MAXSTRINGSIZE];
+  configname = new char[MAXSTRINGSIZE];
   strcpy(mainname,"pcp");
   strcpy(defaultpath,"not specified");
 …
 config::~config()
+{
   Free(&mainname);
   Free(&defaultpath);
   Free(&pseudopotpath);
   Free(&databasepath);
   Free(&configpath);
   Free(&configname);
   Free(&ThermostatImplemented);
+  delete[](mainname);
+  delete[](defaultpath);
+  delete[](pseudopotpath);
+  delete[](databasepath);
+  delete[](configpath);
+  delete[](configname);
+  delete[](ThermostatImplemented);
   for (int j=0;j<MaxThermostats;j++)
     Free(&ThermostatNames[j]);
   Free(&ThermostatNames);
+    delete[](ThermostatNames[j]);
+  delete[](ThermostatNames);
   if (BG != NULL)
 …
 void config::InitThermostats()
+{
   ThermostatImplemented = Malloc<int>(MaxThermostats, "config constructor: *ThermostatImplemented");
   ThermostatNames = Malloc<char*>(MaxThermostats, "config constructor: *ThermostatNames");
+  ThermostatImplemented = new int[MaxThermostats];
+  ThermostatNames = new char *[MaxThermostats];
   for (int j=0;j<MaxThermostats;j++)
     ThermostatNames[j] = Malloc<char>(12, "config constructor: ThermostatNames[]");
+    ThermostatNames[j] = new char[12];
   strcpy(ThermostatNames[0],"None");
 …
 void config::ParseThermostats(class ConfigFileBuffer * const fb)
+{
   char * const thermo = Malloc<char>(12, "IonsInitRead: thermo");
+  char * const thermo = new char[12];
   const int verbose = 0;
 …
     Thermostat = None;
+  }
   Free(thermo);
+  delete[](thermo);
 };
 …
   int AtomNo = -1;
   int MolNo = 0;
-  atom *Walker = NULL;
   FILE *f = NULL;
 …
   fprintf(f, "# Created by MoleCuilder\n");
+  for (MoleculeList::const_iterator Runner = MolList->ListOfMolecules.begin(); Runner != MolList->ListOfMolecules.end(); Runner++) {
+    Walker = (*Runner)->start;
+    int *elementNo = Calloc<int>(MAX_ELEMENTS, "config::SavePDB - elementNo");
+  for (MoleculeList::const_iterator MolRunner = MolList->ListOfMolecules.begin(); MolRunner != MolList->ListOfMolecules.end(); MolRunner++) {
+    int *elementNo = new int[MAX_ELEMENTS];
+    for (int i=0;i<MAX_ELEMENTS;i++)
+      elementNo[i] = 0;
     AtomNo = 0;
+    while (Walker->next != (*Runner)->end) {
+      Walker = Walker->next;
+      sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
+      elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+    for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
+      sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+      elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
              Walker->nr,                /* atom serial number */
+             (*iter)->nr,                /* atom serial number */
              name,         /* atom name */
              (*Runner)->name,      /* residue name */
+             (*MolRunner)->name,      /* residue name */
              'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
              MolNo,         /* residue sequence number */
              Walker->node->at(0),                 /* position X in Angstroem */
              Walker->node->at(1),                 /* position Y in Angstroem */
              Walker->node->at(2),                 /* position Z in Angstroem */
              (double)Walker->type->Valence,         /* occupancy */
              (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+             (*iter)->node->at(0),                 /* position X in Angstroem */
+             (*iter)->node->at(1),                 /* position Y in Angstroem */
+             (*iter)->node->at(2),                 /* position Z in Angstroem */
+             (double)(*iter)->type->Valence,         /* occupancy */
+             (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
              "0",            /* segment identifier */
              Walker->type->symbol,    /* element symbol */
+             (*iter)->type->symbol,    /* element symbol */
              "0");           /* charge */
       AtomNo++;
+    }
     Free(&elementNo);
+    delete[](elementNo);
     MolNo++;
+  }
 …
+{
   int AtomNo = -1;
-  atom *Walker = NULL;
   FILE *f = NULL;
+  int *elementNo = Calloc<int>(MAX_ELEMENTS, "config::SavePDB - elementNo");
+  int *elementNo = new int[MAX_ELEMENTS];
+  for (int i=0;i<MAX_ELEMENTS;i++)
+    elementNo[i] = 0;
   char name[MAXSTRINGSIZE];
   strncpy(name, filename, MAXSTRINGSIZE-1);
 …
   if (f == NULL) {
     DoeLog(1) && (eLog()<< Verbose(1) << "Cannot open pdb output file:" << name << endl);
     Free(&elementNo);
+    delete[](elementNo);
     return false;
+  }
   fprintf(f, "# Created by MoleCuilder\n");
-  Walker = mol->start;
   AtomNo = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
+    elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+    elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
            Walker->nr,                /* atom serial number */
+           (*iter)->nr,                /* atom serial number */
            name,         /* atom name */
            mol->name,      /* residue name */
            'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
 ,         /* residue sequence number */
            Walker->node->at(0),                 /* position X in Angstroem */
            Walker->node->at(1),                 /* position Y in Angstroem */
            Walker->node->at(2),                 /* position Z in Angstroem */
            (double)Walker->type->Valence,         /* occupancy */
            (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+           (*iter)->node->at(0),                 /* position X in Angstroem */
+           (*iter)->node->at(1),                 /* position Y in Angstroem */
+           (*iter)->node->at(2),                 /* position Z in Angstroem */
+           (double)(*iter)->type->Valence,         /* occupancy */
+           (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
            "0",            /* segment identifier */
            Walker->type->symbol,    /* element symbol */
+           (*iter)->type->symbol,    /* element symbol */
            "0");           /* charge */
     AtomNo++;
+  }
   fclose(f);
   Free(&elementNo);
+  delete[](elementNo);
   return true;
 …
 bool config::SaveTREMOLO(const char * const filename, const molecule * const mol) const
+{
-  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
 …
   // scan maximum number of neighbours
-  Walker = mol->start;
   int MaxNeighbours = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (MaxNeighbours < count)
       MaxNeighbours = count;
+  }
+  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    *output << Walker->nr << "\t";
+    *output << Walker->getName() << "\t";
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    *output << (*iter)->nr << "\t";
+    *output << (*iter)->getName() << "\t";
     *output << mol->name << "\t";
     *output << 0 << "\t";
     *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
     *output << static_cast<double>(Walker->type->Valence) << "\t";
     *output << Walker->type->symbol << "\t";
     for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
       *output << (*runner)->GetOtherAtom(Walker)->nr << "\t";
     for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+    *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+    *output << static_cast<double>((*iter)->type->Valence) << "\t";
+    *output << (*iter)->type->symbol << "\t";
+    for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+      *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
+    for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
       *output << "-\t";
     *output << endl;
 …
 bool config::SaveTREMOLO(const char * const filename, const MoleculeListClass * const MolList) const
+{
   atom *Walker = NULL;
+  Info FunctionInfo(__func__);
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
 …
   int MaxNeighbours = 0;
   for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      const int count = Walker->ListOfBonds.size();
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      const int count = (*iter)->ListOfBonds.size();
       if (MaxNeighbours < count)
         MaxNeighbours = count;
+    }
+  }
   *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
   // create global to local id map
   int **LocalNotoGlobalNoMap = Calloc<int *>(MolList->ListOfMolecules.size(), "config::SaveTREMOLO - **LocalNotoGlobalNoMap");
+  map<int, int> LocalNotoGlobalNoMap;
+  {
     int MolCounter = 0;
     int AtomNo = 0;
+    unsigned int MolCounter = 0;
+    int AtomNo = 1;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+      LocalNotoGlobalNoMap[MolCounter] = Calloc<int>(MolList->CountAllAtoms(), "config::SaveTREMOLO - *LocalNotoGlobalNoMap[]");
+      (*MolWalker)->SetIndexedArrayForEachAtomTo( LocalNotoGlobalNoMap[MolCounter], &atom::nr, IncrementalAbsoluteValue, &AtomNo);
+      for(molecule::iterator AtomRunner = (*MolWalker)->begin(); AtomRunner != (*MolWalker)->end(); ++AtomRunner) {
+        LocalNotoGlobalNoMap.insert( pair<int,int>((*AtomRunner)->getId(), AtomNo++) );
+      }
       MolCounter++;
+    }
+    ASSERT(MolCounter == MolList->ListOfMolecules.size(), "SaveTREMOLO: LocalNotoGlobalNoMap[] has not been correctly initialized for each molecule");
+  }
 …
     int AtomNo = 0;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+      Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *output << AtomNo+1 << "\t";
+        *output << Walker->getName() << "\t";
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        *output << LocalNotoGlobalNoMap[ (*iter)->getId() ] << "\t";
+        *output << (*iter)->getName() << "\t";
         *output << (*MolWalker)->name << "\t";
         *output << MolCounter+1 << "\t";
         *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
         *output << (double)Walker->type->Valence << "\t";
         *output << Walker->type->symbol << "\t";
         for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
           *output << LocalNotoGlobalNoMap[MolCounter][ (*runner)->GetOtherAtom(Walker)->nr ]+1 << "\t";
         for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+        *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+        *output << (double)(*iter)->type->Valence << "\t";
+        *output << (*iter)->type->symbol << "\t";
+        for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";
+        for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
           *output << "-\t";
         *output << endl;
 …
   delete(output);
   delete(fname);
-  for(size_t i=0;i<MolList->ListOfMolecules.size(); i++)
-    Free(&LocalNotoGlobalNoMap[i]);
-  Free(&LocalNotoGlobalNoMap);
   return true;
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as pdb input ";
+  Log() << Verbose(0) << "Saving as pdb input ... " << endl;
   if (SavePDB(filename, molecules))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   // then save as tremolo data file
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as tremolo data input ";
+  Log() << Verbose(0) << "Saving as tremolo data input ... " << endl;
   if (SaveTREMOLO(filename, molecules))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   // translate each to its center and merge all molecules in MoleculeListClass into this molecule
 …
   output.close();
   output.clear();
   Log() << Verbose(0) << "Saving of config file ";
+  Log() << Verbose(0) << "Saving of config file ... " << endl;
   if (Save(filename, periode, mol))
     Log() << Verbose(0) << "successful." << endl;
+    Log() << Verbose(0) << "\t... successful." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   // and save to xyz file
 …
     output.open(filename, ios::trunc);
+  }
   Log() << Verbose(0) << "Saving of XYZ file ";
+  Log() << Verbose(0) << "Saving of XYZ file ... " << endl;
   if (mol->MDSteps <= 1) {
     if (mol->OutputXYZ(&output))
       Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
       Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
   } else {
     if (mol->OutputTrajectoriesXYZ(&output))
       Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
       Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
+  }
   output.close();
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as mpqc input ";
+  Log() << Verbose(0) << "Saving as mpqc input .. " << endl;
   if (SaveMPQC(filename, mol))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   if (!strcmp(configpath, GetDefaultPath())) {
 …
   char *dummy1 = NULL;
   char *dummy = NULL;
   char * const free_dummy = Malloc<char>(256, "config::ParseForParameter: *free_dummy");    // pointers in the line that is read in per step
+  char free_dummy[MAXSTRINGSIZE];    // pointers in the line that is read in per step
   dummy1 = free_dummy;
 …
       if (file->eof()) {
         if ((critical) && (found == 0)) {
-          Free(free_dummy);
           //Error(InitReading, name);
           fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
           file->clear();
           file->seekg(file_position, ios::beg);  // rewind to start position
-          Free(free_dummy);
           return 0;
+        }
 …
         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 {
 …
               if (file->eof()) {
                 if ((critical) && (found == 0)) {
-                  Free(free_dummy);
                   //Error(InitReading, name);
                   fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
                   file->clear();
                   file->seekg(file_position, ios::beg);  // rewind to start position
-                  Free(free_dummy);
                   return 0;
+                }
 …
                   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(free_dummy);
                     //return 0;
                     exit(255);
 …
                     file->clear();
                     file->seekg(file_position, ios::beg);  // rewind to start position
-                    Free(free_dummy);
                     return 0;
+                  }
 …
                   file->seekg(file_position, ios::beg);  // rewind to start position
+                }
-                Free(free_dummy);
                 return 0;
+              }
 …
   if ((type >= row_int) && (verbose))
     fprintf(stderr,"\n");
-  Free(free_dummy);
   if (!sequential) {
     file->clear();
 …
         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(&free_dummy);
         //Error(FileOpenParams, NULL);
       } else {

src/datacreator.cpp

r0c7ed8	r1dc9ec
6	6
7	7	//============================ INCLUDES ===========================
	8
	9	#include "Helpers/MemDebug.hpp"
8	10
9	11	#include "datacreator.hpp"

src/element.cpp

r0c7ed8	r1dc9ec
4	4	*
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	#include <iomanip>

src/elements.db

Property mode changed from 100755 to 100644

-              r0c7ed8
+              r1dc9ec
 #Element        Name    Symbol  Period  Group   Block   Atomic  Number  AtomicWeight    Covalent        Radius  vdW     Radius
 Hydrogen        H       1       1       s       1       1.008   0.23    1.09
 Helium  He      1       18      p       2       4.003   1.50    1.40
+Helium  He      1       18      p       2       4.003   1.5     1.4
 Lithium Li      2       1       s       3       6.941   0.68    1.82
 Beryllium       Be      2       2       s       4       9.012   0.35    2.00
 Boron   B       2       13      p       5       10.811  0.83    2.00
 Carbon  C       2       14      p       6       12.011  0.68    1.70
+Beryllium       Be      2       2       s       4       9.012   0.35    2
+Boron   B       2       13      p       5       10.811  0.83    2
+Carbon  C       2       14      p       6       12.011  0.68    1.7
 Nitrogen        N       2       15      p       7       14.007  0.68    1.55
 Oxygen  O       2       16      p       8       15.999  0.68    1.52
 Fluorine        F       2       17      p       9       18.998  0.64    1.47
 Neon    Ne      2       18      p       10      20.180  1.50    1.54
+Neon    Ne      2       18      p       10      20.18   1.5     1.54
 Sodium  Na      3       1       s       11      22.991  0.97    2.27
 Magnesium       Mg      3       2       s       12      24.305  1.10    1.73
 Aluminium       Al      3       13      p       13      26.982  1.35    2.00
 Silicon Si      3       14      p       14      28.086  1.20    2.10
 Phosphorus      P       3       15      p       15      30.974  1.05    1.80
 Sulphur S       3       16      p       16      32.066  1.02    1.80
+Magnesium       Mg      3       2       s       12      24.305  1.1     1.73
+Aluminium       Al      3       13      p       13      26.982  1.35    2
+Silicon Si      3       14      p       14      28.086  1.2     2.1
+Phosphorus      P       3       15      p       15      30.974  1.05    1.8
+Sulphur S       3       16      p       16      32.066  1.02    1.8
 Chlorine        Cl      3       17      p       17      35.453  0.99    1.75
 Argon   Ar      3       18      p       18      39.948  1.51    1.88
 Potassium       K       4       1       s       19      39.098  1.33    2.75
 Calcium Ca      4       2       s       20      40.078  0.99    2.00
 Scandium        Sc      4       3       d       21      44.956  1.44    2.00
 Titanium        Ti      4       4       d       22      47.867  1.47    2.00
 Vanadium        V       4       5       d       23      50.942  1.33    2.00
 Chromium        Cr      4       6       d       24      51.996  1.35    2.00
 Manganese       Mn      4       7       d       25      54.938  1.35    2.00
 Iron    Fe      4       8       d       26      55.845  1.34    2.00
 Cobalt  Co      4       9       d       27      58.933  1.33    2.00
 Nickel  Ni      4       10      d       28      58.693  1.50    1.63
 Copper  Cu      4       11      d       29      63.546  1.52    1.40
 Zinc    Zn      4       12      d       30      65.390  1.45    1.39
+Calcium Ca      4       2       s       20      40.078  0.99    2
+Scandium        Sc      4       3       d       21      44.956  1.44    2
+Titanium        Ti      4       4       d       22      47.867  1.47    2
+Vanadium        V       4       5       d       23      50.942  1.33    2
+Chromium        Cr      4       6       d       24      51.996  1.35    2
+Manganese       Mn      4       7       d       25      54.938  1.35    2
+Iron    Fe      4       8       d       26      55.845  1.34    2
+Cobalt  Co      4       9       d       27      58.933  1.33    2
+Nickel  Ni      4       10      d       28      58.693  1.5     1.63
+Copper  Cu      4       11      d       29      63.546  1.52    1.4
+Zinc    Zn      4       12      d       30      65.39   1.45    1.39
 Gallium Ga      4       13      p       31      69.723  1.22    1.87
 Germanium       Ge      4       14      p       32      72.610  1.17    2.00
+Germanium       Ge      4       14      p       32      72.61   1.17    2
 Arsenic As      4       15      p       33      74.922  1.21    1.85
 Selenium        Se      4       16      p       34      78.960  1.22    1.90
+Selenium        Se      4       16      p       34      78.96   1.22    1.9
 Bromine Br      4       17      p       35      79.904  1.21    1.85
 Krypton Kr      4       18      p       36      83.800  1.50    2.02
 Rubidium        Rb      5       1       s       37      85.468  1.47    2.00
 Strontium       Sr      5       2       s       38      87.620  1.12    2.00
 Yttrium Y       5       3       d       39      88.906  1.78    2.00
 Zirconium       Zr      5       4       d       40      91.224  1.56    2.00
 Niobium Nb      5       5       d       41      92.906  1.48    2.00
 Molybdenum      Mo      5       6       d       42      95.940  1.47    2.00
 Technetium      Tc      5       7       d       43      98      1.35    2.00
 Ruthenium       Ru      5       8       d       44      101.070 1.40    2.00
 Rhodium Rh      5       9       d       45      102.906 1.45    2.00
 Palladium       Pd      5       10      d       46      106.420 1.50    1.63
+Krypton Kr      4       18      p       36      83.8    1.5     2.02
+Rubidium        Rb      5       1       s       37      85.468  1.47    2
+Strontium       Sr      5       2       s       38      87.62   1.12    2
+Yttrium Y       5       3       d       39      88.906  1.78    2
+Zirconium       Zr      5       4       d       40      91.224  1.56    2
+Niobium Nb      5       5       d       41      92.906  1.48    2
+Molybdenum      Mo      5       6       d       42      95.94   1.47    2
+Technetium      Tc      5       7       d       43      98      1.35    2
+Ruthenium       Ru      5       8       d       44      101.07  1.4     2
+Rhodium Rh      5       9       d       45      102.906 1.45    2
+Palladium       Pd      5       10      d       46      106.42  1.5     1.63
 Silver  Ag      5       11      d       47      107.868 1.59    1.72
 Cadmium Cd      5       12      d       48      112.411 1.69    1.58
 Indium  In      5       13      p       49      114.818 1.63    1.93
 Tin     Sn      5       14      p       50      118.71  1.46    2.17
+Antimony        Sb      5       15      p       51      121.760 1.46    2.00
+Tellurium       Te      5       16      p       52      127.600 1.47    2.06
+Iodine  I       5       17      p       53      126.904 1.40    1.98
+Xenon   Xe      5       18      p       54      131.290 1.50    2.16
+Caesium Cs      6       1       s       55      132.905 1.67    2.00
+Barium  Ba      6       2       s       56      137.327 1.34    2.00
+Lutetium        Lu      6       3       d       71      174.967 1.72    2.00
+Hafnium Hf      6       4       d       72      178.490 1.57    2.00
+Tantalum        Ta      6       5       d       73      180.948 1.43    2.00
+Tungsten        W       6       6       d       74      183.840 1.37    2.00
+Rhenium Re      6       7       d       75      186.207 1.35    2.00
+Osmium  Os      6       8       d       76      190.230 1.37    2.00
+Iridium Ir      6       9       d       77      192.217 1.32    2.00
+Platinum        Pt      6       10      d       78      195.078 1.50    1.72
+Gold    Au      6       11      d       79      196.967 1.50    1.66
+Mercury Hg      6       12      d       80      200.590 1.70    1.55
+Antimony        Sb      5       15      p       51      121.76  1.46    2
+Tellurium       Te      5       16      p       52      127.6   1.47    2.06
+Iodine  I       5       17      p       53      126.904 1.4     1.98
+Xenon   Xe      5       18      p       54      131.29  1.5     2.16
+Caesium Cs      6       1       s       55      132.905 1.67    2
+Barium  Ba      6       2       s       56      137.327 1.34    2
+Lanthanum       La      6Lan    19      f       57      138.906 1.87    2
+Cerium  Ce      6Lan    19      f       58      140.116 1.83    2
+Praseodymium    Pr      6Lan    19      f       59      140.908 1.82    2
+Neodymium       Nd      6Lan    19      f       60      144.24  1.81    2
+Promethium      Pm      6Lan    19      f       61      145     1.8     2
+Samarium        Sm      6Lan    19      f       62      150.36  1.8     2
+Europium        Eu      6Lan    19      f       63      151.964 1.99    2
+Gadolinium      Gd      6Lan    19      f       64      157.25  1.79    2
+Terbium Tb      6Lan    19      f       65      158.925 1.76    2
+Dysprosium      Dy      6Lan    19      f       66      162.5   1.75    2
+Holmium Ho      6Lan    19      f       67      164.93  1.74    2
+Erbium  Er      6Lan    19      f       68      167.26  1.73    2
+Thulium Tm      6Lan    19      f       69      168.934 1.72    2
+Ytterbium       Yb      6Lan    19      f       70      173.04  1.94    2
+Lutetium        Lu      6       3       d       71      174.967 1.72    2
+Hafnium Hf      6       4       d       72      178.49  1.57    2
+Tantalum        Ta      6       5       d       73      180.948 1.43    2
+Tungsten        W       6       6       d       74      183.84  1.37    2
+Rhenium Re      6       7       d       75      186.207 1.35    2
+Osmium  Os      6       8       d       76      190.23  1.37    2
+Iridium Ir      6       9       d       77      192.217 1.32    2
+Platinum        Pt      6       10      d       78      195.078 1.5     1.72
+Gold    Au      6       11      d       79      196.967 1.5     1.66
+Mercury Hg      6       12      d       80      200.59  1.7     1.55
 Thallium        Tl      6       13      p       81      204.383 1.55    1.96
+Lead    Pb      6       14      p       82      207.200 1.54    2.02
+Bismuth Bi      6       15      p       83      208.980 1.54    2.00
+Polonium        Po      6       16      p       84      210     1.68    2.00
+Astatine        At      6       17      p       85      210     1.21    2.00
+Radon   Rn      6       18      p       86      222     1.50    2.00
+Cerium  Ce      6Lan    19      f       58      140.116 1.83    2.00
+Dysprosium      Dy      6Lan    19      f       66      162.500 1.75    2.00
+Erbium  Er      6Lan    19      f       68      167.260 1.73    2.00
+Europium        Eu      6Lan    19      f       63      151.964 1.99    2.00
+Gadolinium      Gd      6Lan    19      f       64      157.250 1.79    2.00
+Holmium Ho      6Lan    19      f       67      164.930 1.74    2.00
+Lanthanum       La      6Lan    19      f       57      138.906 1.87    2.00
+Neodymium       Nd      6Lan    19      f       60      144.240 1.81    2.00
+Promethium      Pm      6Lan    19      f       61      145     1.80    2.00
+Praseodymium    Pr      6Lan    19      f       59      140.908 1.82    2.00
+Samarium        Sm      6Lan    19      f       62      150.360 1.80    2.00
+Terbium Tb      6Lan    19      f       65      158.925 1.76    2.00
+Thulium Tm      6Lan    19      f       69      168.934 1.72    2.00
+Ytterbium       Yb      6Lan    19      f       70      173.040 1.94    2.00
+Francium        Fr      7       1       s       87      223     1.50    2.00
+Radium  Ra      7       2       s       88      226     1.90    2.00
+Lawrencium      Lr      7       3       d       103     262     1.50    2.00
+Rutherfordium   Rf      7       4       d       104     261     1.50    2.00
+Dubnium Db      7       5       d       105     262     1.50    2.00
+Seaborgium      Sg      7       6       d       106     266     1.50    2.00
+Bohrium Bh      7       7       d       107     264     1.50    2.00
+Hassium Hs      7       8       d       108     269     1.50    2.00
+Meitnerium      Mt      7       9       d       109     268     1.50    2.00
+Darmstadtium    Ds      7       10      d       110     271     1.50    2.00
+Actinium        Ac      7Act    20      f       89      227     1.88    2.00
+Americium       Am      7Act    20      f       95      243     1.51    2.00
+Berkelium       Bk      7Act    20      f       97      247     1.54    2.00
+Californium     Cf      7Act    20      f       98      251     1.83    2.00
+Curium  Cm      7Act    20      f       96      247     0.99    2.00
+Einsteinium     Es      7Act    20      f       99      252     1.50    2.00
+Fermium Fm      7Act    20      f       100     257     1.50    2.00
+Mendelevium     Md      7Act    20      f       101     258     1.50    2.00
+Nobelium        No      7Act    20      f       102     259     1.50    2.00
+Neptunium       Np      7Act    20      f       93      237     1.55    2.00
+Protactinium    Pa      7Act    20      f       91      231.036 1.61    2.00
+Plutonium       Pu      7Act    20      f       94      244     1.53    2.00
+Thorium Th      7Act    20      f       90      232.038 1.79    2.00
+Lead    Pb      6       14      p       82      207.2   1.54    2.02
+Bismuth Bi      6       15      p       83      208.98  1.54    2
+Polonium        Po      6       16      p       84      210     1.68    2
+Astatine        At      6       17      p       85      210     1.21    2
+Radon   Rn      6       18      p       86      222     1.5     2
+Francium        Fr      7       1       s       87      223     1.5     2
+Radium  Ra      7       2       s       88      226     1.9     2
+Actinium        Ac      7Act    20      f       89      227     1.88    2
+Thorium Th      7Act    20      f       90      232.038 1.79    2
+Protactinium    Pa      7Act    20      f       91      231.036 1.61    2
 Uranium U       7Act    20      f       92      238.029 1.58    1.86
+Neptunium       Np      7Act    20      f       93      237     1.55    2
+Plutonium       Pu      7Act    20      f       94      244     1.53    2
+Americium       Am      7Act    20      f       95      243     1.51    2
+Curium  Cm      7Act    20      f       96      247     0.99    2
+Berkelium       Bk      7Act    20      f       97      247     1.54    2
+Californium     Cf      7Act    20      f       98      251     1.83    2
+Einsteinium     Es      7Act    20      f       99      252     1.5     2
+Fermium Fm      7Act    20      f       100     257     1.5     2
+Mendelevium     Md      7Act    20      f       101     258     1.5     2
+Nobelium        No      7Act    20      f       102     259     1.5     2
+Lawrencium      Lr      7       3       d       103     262     1.5     2
+Rutherfordium   Rf      7       4       d       104     261     1.5     2
+Dubnium Db      7       5       d       105     262     1.5     2
+Seaborgium      Sg      7       6       d       106     266     1.5     2
+Bohrium Bh      7       7       d       107     264     1.5     2
+Hassium Hs      7       8       d       108     269     1.5     2
+Meitnerium      Mt      7       9       d       109     268     1.5     2
+Darmstadtium    Ds      7       10      d       110     271     1.5     2

src/ellipsoid.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <gsl/gsl_multimin.h>

src/errorlogger.cpp

r0c7ed8	r1dc9ec
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <fstream>

src/graph.cpp

r0c7ed8	r1dc9ec
4	4	*
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	using namespace std;

src/gslmatrix.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	using namespace std;

src/gslvector.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <cassert>

src/helpers.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "helpers.hpp"
 …
 int CountLinesinFile(ifstream &InputFile)
+{
   char *buffer = Malloc<char>(MAXSTRINGSIZE, "CountLinesinFile: *buffer");
+  char *buffer = new char[MAXSTRINGSIZE];
   int lines=0;
 …
+  }
   InputFile.seekg(PositionMarker, ios::beg);
   Free(&buffer);
+  delete[](buffer);
   return lines;
 };
 …
+  }
   // allocate string
   returnstring = Malloc<char>(order + 2, "FixedDigitNumber: *returnstring");
+  returnstring = new char[order + 2];
   // terminate  and fill string array from end backward
   returnstring[order] = '\0';
 …
 double * ReturnFullMatrixforSymmetric(const double * const symm)
+{
   double *matrix = Malloc<double>(NDIM * NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
+  double *matrix = new double[NDIM * NDIM];
   matrix[0] = symm[0];
   matrix[1] = symm[1];
 …
 double * InverseMatrix( const double * const A)
+{
   double *B = Malloc<double>(NDIM * NDIM, "Vector::InverseMatrix: *B");
+  double *B = new double[NDIM * NDIM];
   double detA = RDET3(A);
   double detAReci;
 …
-/** Allocates a memory range using malloc().
- * Prints the provided error message in case of a failure.
+ *
- * \param number of memory slices of type X to allocate
- * \param failure message which is printed if the allocation fails
- * \return pointer to the allocated memory range, will be NULL if a failure occurred
- */
-template <> char* Malloc<char>(size_t size, const char* output)
+{
-  char* buffer = NULL;
-  buffer = (char*) malloc(sizeof(char) * (size + 1));
-  for (size_t i = size; i--;)
-    buffer[i] = (i % 2 == 0) ? 'p': 'c';
-  buffer[size] = '\0';
-  if (buffer != NULL) {
-    MemoryUsageObserver::getInstance()->addMemory(buffer, size);
-  } else {
-    Log() << Verbose(0) << "Malloc for datatype " << typeid(char).name()
-      << " failed - pointer is NULL: " << output << endl;
+  }
-  return buffer;
-};
 /**
  * Frees all memory registered by the memory observer and calls exit(225) afterwards.
+ * Calls exit(255).
  */
 void performCriticalExit() {
-  map<void*, size_t> pointers = MemoryUsageObserver::getInstance()->getPointersToAllocatedMemory();
-  for (map<void*, size_t>::iterator runner = pointers.begin(); runner != pointers.end(); runner++) {
-    Free(((void**) &runner->first));
+  }
   exit(255);
+}

src/helpers.hpp

-              r0c7ed8
+              r1dc9ec
   if (LookupTable != NULL) {
     DoLog(0) && (Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl);
+    DoeLog(0) && (eLog() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl);
     return false;
+  }
 …
+  }
   if (count <= 0) {
     DoLog(0) && (Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl);
+    DoeLog(1) && (eLog() << Verbose(1) << "Count of lookup list is 0 or less." << endl);
     return false;
+  }
   // allocate and fill
   LookupTable = Calloc<T*>(count, "CreateFatherLookupTable - **LookupTable");
+  LookupTable = new T*[count];
   if (LookupTable == NULL) {
     DoeLog(0) && (eLog()<< Verbose(0) << "LookupTable memory allocation failed!" << endl);
 …
         LookupTable[AtomNo] = Walker;
       } else {
         DoLog(0) && (Log() << Verbose(0) << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl);
+        DoeLog(2) && (eLog() << Verbose(2) << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl);
         status = false;
         break;
 …
   return status;
 };
 /** Frees a two-dimensional array.

src/info.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "info.hpp"

src/joiner.cpp

-              r0c7ed8
+              r1dc9ec
 //============================ INCLUDES ===========================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
     return 1;
   } else {
     dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
+    dir = new char[strlen(argv[2]) + 2];
     strcpy(dir, "/");
     strcat(dir, argv[2]);
 …
   // exit
   delete(periode);
   Free(&dir);
+  delete[](dir);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return 0;

src/leastsquaremin.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/linearsystemofequations.cpp

r0c7ed8	r1dc9ec
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "defs.hpp"

src/linkedcell.cpp

r0c7ed8	r1dc9ec
5	5	*/
6	6
	7	#include "Helpers/MemDebug.hpp"
7	8
8	9	#include "atom.hpp"

src/lists.hpp

-              r0c7ed8
+              r1dc9ec
 };
-/** Returns the first marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to first marker
- */
-template <typename X> X *GetFirst(X *me)
+{
-  X *Binder = me;
-  while(Binder->previous != 0)
-    Binder = Binder->previous;
-  return Binder;
-};
-/** Returns the last marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to last marker
- */
-template <typename X> X *GetLast(X *me)
+{
-  X *Binder = me;
-  while(Binder->next != 0)
-    Binder = Binder->next;
-  return Binder;
-};
 #endif /* LISTS_HPP_ */

src/log.cpp

r0c7ed8	r1dc9ec
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "logger.hpp"

src/logger.cpp

r0c7ed8	r1dc9ec
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <fstream>

src/memoryusageobserver.cpp

r0c7ed8	r1dc9ec
4	4	* This class represents a Singleton for observing memory usage.
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	#include <cstdlib>

src/molecule.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
+molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::getInstance().createAtom()), end(World::getInstance().createAtom()),
+  first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0),
+  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.),
+  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this)),
+  last_atom(0),
+  InternalPointer(start)
+{
+  // init atom chain list
+  start->father = NULL;
+  end->father = NULL;
+  link(start,end);
+  // init bond chain list
+  link(first,last);
+molecule::molecule(const periodentafel * const teil) :
+  Observable("molecule"),
+  elemente(teil),  MDSteps(0),  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0),
+  NoCyclicBonds(0), BondDistance(0.),  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this),"formula"),
+  AtomCount(this,boost::bind(&molecule::doCountAtoms,this),"AtomCount"), last_atom(0),  InternalPointer(begin())
+{
   // other stuff
   for(int i=MAX_ELEMENTS;i--;)
     ElementsInMolecule[i] = 0;
   strcpy(name,World::getInstance().getDefaultName());
+  strcpy(name,World::getInstance().getDefaultName().c_str());
 };
 …
+{
   CleanupMolecule();
-  delete(first);
-  delete(last);
-  end->getWorld()->destroyAtom(end);
-  start->getWorld()->destroyAtom(start);
 };
 …
 const std::string molecule::getName(){
   return std::string(name);
+}
+int molecule::getAtomCount() const{
+  return *AtomCount;
+}
 …
   stringstream sstr;
   periodentafel *periode = World::getInstance().getPeriode();
   for(atom *Walker = start; Walker != end; Walker = Walker->next) {
     counts[Walker->type->getNumber()]++;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    counts[(*iter)->type->getNumber()]++;
+  }
   std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
 …
+}
+/************************** Access to the List of Atoms ****************/
+molecule::iterator molecule::begin(){
+  return molecule::iterator(atoms.begin(),this);
+}
+molecule::const_iterator molecule::begin() const{
+  return atoms.begin();
+}
+molecule::iterator molecule::end(){
+  return molecule::iterator(atoms.end(),this);
+}
+molecule::const_iterator molecule::end() const{
+  return atoms.end();
+}
+bool molecule::empty() const
+{
+  return (begin() == end());
+}
+size_t molecule::size() const
+{
+  size_t counter = 0;
+  for (molecule::const_iterator iter = begin(); iter != end (); ++iter)
+    counter++;
+  return counter;
+}
+molecule::const_iterator molecule::erase( const_iterator loc )
+{
+  molecule::const_iterator iter = loc;
+  iter--;
+  atom* atom = *loc;
+  atoms.erase( loc );
+  atom->removeFromMolecule();
+  return iter;
+}
+molecule::const_iterator molecule::erase( atom * key )
+{
+  cout << "trying to erase atom" << endl;
+  molecule::const_iterator iter = find(key);
+  if (iter != end()){
+    atoms.erase( iter++ );
+    key->removeFromMolecule();
+  }
+  return iter;
+}
+molecule::const_iterator molecule::find ( atom * key ) const
+{
+  return atoms.find( key );
+}
+pair<molecule::iterator,bool> molecule::insert ( atom * const key )
+{
+  pair<atomSet::iterator,bool> res = atoms.insert(key);
+  return pair<iterator,bool>(iterator(res.first,this),res.second);
+}
+bool molecule::containsAtom(atom* key){
+  return atoms.count(key);
+}
 /** Adds given atom \a *pointer from molecule list.
 …
 bool molecule::AddAtom(atom *pointer)
+{
-  bool retval = false;
   OBSERVE;
   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)
 …
+      }
+    }
+    retval = add(pointer, end);
+  }
+  return retval;
+    insert(pointer);
+    pointer->setMolecule(this);
+  }
+  return true;
 };
 …
   if (pointer != NULL) {
     atom *walker = pointer->clone();
+    stringstream sstr;
+    sstr << pointer->getName();
+    walker->setName(sstr.str());
+    walker->setName(pointer->getName());
     walker->nr = last_atom++;  // increase number within molecule
     add(walker, end);
+    insert(walker);
     if ((pointer->type != NULL) && (pointer->type->Z != 1))
       NoNonHydrogen++;
-    AtomCount++;
     retval=walker;
+  }
 …
     Orthovector1.MatrixMultiplication(matrix);
     InBondvector -= Orthovector1; // subtract just the additional translation
     Free(&matrix);
+    delete[](matrix);
     bondlength = InBondvector.Norm();
 //    Log() << Verbose(4) << "Corrected InBondvector is now: ";
 …
   InBondvector.Normalize();
   // get typical bond length and store as scale factor for later
+  ASSERT(TopOrigin->type != NULL, "AddHydrogenReplacementAtom: element of TopOrigin is not given.");
   BondRescale = TopOrigin->type->HBondDistance[TopBond->BondDegree-1];
   if (BondRescale == -1) {
 …
       break;
+  }
   Free(&matrix);
+  delete[](matrix);
 //  Log() << Verbose(3) << "End of AddHydrogenReplacementAtom." << endl;
 …
   // copy all bonds
   bond *Binder = first;
+  bond *Binder = NULL;
   bond *NewBond = NULL;
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    // get the pendant atoms of current bond in the copy molecule
+    copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->leftatom, (const atom **)&LeftAtom );
+    copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->rightatom, (const atom **)&RightAtom );
+    NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
+    NewBond->Cyclic = Binder->Cyclic;
+    if (Binder->Cyclic)
+      copy->NoCyclicBonds++;
+    NewBond->Type = Binder->Type;
+  }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        Binder = (*BondRunner);
+        // get the pendant atoms of current bond in the copy molecule
+        copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->leftatom, (const atom **)&LeftAtom );
+        copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->rightatom, (const atom **)&RightAtom );
+        NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
+        NewBond->Cyclic = Binder->Cyclic;
+        if (Binder->Cyclic)
+          copy->NoCyclicBonds++;
+        NewBond->Type = Binder->Type;
+      }
   // correct fathers
   ActOnAllAtoms( &atom::CorrectFather );
   // copy values
-  copy->CountAtoms();
   copy->CountElements();
   if (first->next != last) {  // if adjaceny list is present
+  if (hasBondStructure()) {  // if adjaceny list is present
     copy->BondDistance = BondDistance;
+  }
 …
 bond * molecule::AddBond(atom *atom1, atom *atom2, int degree)
+{
+  OBSERVE;
   bond *Binder = NULL;
+  if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
+    Binder = new bond(atom1, atom2, degree, BondCount++);
+    atom1->RegisterBond(Binder);
+    atom2->RegisterBond(Binder);
+    if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
+      NoNonBonds++;
+    add(Binder, last);
+  } else {
+    DoeLog(1) && (eLog()<< Verbose(1) << "Could not add bond between " << atom1->getName() << " and " << atom2->getName() << " as one or both are not present in the molecule." << endl);
+  }
+  // some checks to make sure we are able to create the bond
+  ASSERT(atom1, "First atom in bond-creation was an invalid pointer");
+  ASSERT(atom2, "Second atom in bond-creation was an invalid pointer");
+  ASSERT(FindAtom(atom1->nr),"First atom in bond-creation was not part of molecule");
+  ASSERT(FindAtom(atom2->nr),"Second atom in bond-creation was not parto of molecule");
+  Binder = new bond(atom1, atom2, degree, BondCount++);
+  atom1->RegisterBond(Binder);
+  atom2->RegisterBond(Binder);
+  if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
+    NoNonBonds++;
   return Binder;
 };
 …
+{
   //DoeLog(1) && (eLog()<< Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl);
+  pointer->leftatom->RegisterBond(pointer);
+  pointer->rightatom->RegisterBond(pointer);
+  removewithoutcheck(pointer);
+  delete(pointer);
   return true;
 };
 …
 bool molecule::RemoveAtom(atom *pointer)
+{
+  ASSERT(pointer, "Null pointer passed to molecule::RemoveAtom().");
+  OBSERVE;
   if (ElementsInMolecule[pointer->type->Z] != 0)  { // this would indicate an error
     ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
-    AtomCount--;
   } else
     DoeLog(1) && (eLog()<< Verbose(1) << "Atom " << pointer->getName() << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl);
 …
     ElementCount--;
   RemoveBonds(pointer);
+  return remove(pointer, start, end);
+  erase(pointer);
+  return true;
 };
 …
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
   unlink(pointer);
+  erase(pointer);
   return true;
 };
 …
 bool molecule::CleanupMolecule()
+{
+  return (cleanup(first,last) && cleanup(start,end));
+  for (molecule::iterator iter = begin(); !empty(); iter = begin())
+      erase(iter);
 };
 …
  * \return pointer to atom or NULL
  */
+atom * molecule::FindAtom(int Nr)  const{
+  atom * walker = find(&Nr, start,end);
+  if (walker != NULL) {
+atom * molecule::FindAtom(int Nr)  const
+{
+  molecule::const_iterator iter = begin();
+  for (; iter != end(); ++iter)
+    if ((*iter)->nr == Nr)
+      break;
+  if (iter != end()) {
     //Log() << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
     return walker;
+    return (*iter);
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Atom not found in list." << endl);
 …
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     for (int step=0;step<MDSteps;step++) {
       *output << AtomCount << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
+      *output << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
       ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
+    }
 …
   if (output != NULL) {
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     *output << AtomCount << "\n\tCreated by molecuilder on " << ctime(&now);
+    *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
     ActOnAllAtoms( &atom::OutputXYZLine, output );
     return true;
 …
  * \param *out output stream for debugging
  */
+void molecule::CountAtoms()
+{
+int molecule::doCountAtoms()
+{
+  int res = size();
   int i = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+  NoNonHydrogen = 0;
+  for (molecule::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
+    (*iter)->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
+    if ((*iter)->type->Z != 1) // count non-hydrogen atoms whilst at it
+      NoNonHydrogen++;
+    stringstream sstr;
+    sstr << (*iter)->type->symbol << (*iter)->nr+1;
+    (*iter)->setName(sstr.str());
+    DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl);
     i++;
+  }
+  if ((AtomCount == 0) || (i != AtomCount)) {
+    DoLog(3) && (Log() << 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++;
+        stringstream sstr;
+        sstr << Walker->type->symbol << Walker->nr+1;
+        Walker->setName(sstr.str());
+        DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << Walker->nr << " " << Walker->getName() << "." << endl);
+        i++;
+      }
+    } else
+      DoLog(3) && (Log() << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl);
+  }
+  return res;
 };
 …
   /// first count both their atoms and elements and update lists thereby ...
   //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
-  CountAtoms();
-  OtherMolecule->CountAtoms();
   CountElements();
   OtherMolecule->CountElements();
 …
   /// -# AtomCount
   if (result) {
     if (AtomCount != OtherMolecule->AtomCount) {
       DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl);
+    if (getAtomCount() != OtherMolecule->getAtomCount()) {
+      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
       result = false;
     } else Log() << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+    } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
+  }
   /// -# ElementCount
 …
   if (result) {
     DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
     Distances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
     OtherDistances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Distances = new double[getAtomCount()];
+    OtherDistances = new double[getAtomCount()];
     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
+    for(int i=0;i<getAtomCount();i++) {
+      Distances[i] = 0.;
+      OtherDistances[i] = 0.;
+    }
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
+    PermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = Calloc<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 = Calloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermMap = new size_t[getAtomCount()];
+    OtherPermMap = new size_t[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++) {
+      PermMap[i] = 0;
+      OtherPermMap[i] = 0;
+    }
+    gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
+    PermutationMap = new int[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++)
+      PermutationMap[i] = 0;
     DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
     for(int i=AtomCount;i--;)
+    for(int i=getAtomCount();i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
 …
     DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
     flag = 0;
     for (int i=0;i<AtomCount;i++) {
+    for (int i=0;i<getAtomCount();i++) {
       DoLog(5) && (Log() << 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)
 …
     // free memory
     Free(&PermMap);
     Free(&OtherPermMap);
     Free(&Distances);
     Free(&OtherDistances);
+    delete[](PermMap);
+    delete[](OtherPermMap);
+    delete[](Distances);
+    delete[](OtherDistances);
     if (flag) { // if not equal
       Free(&PermutationMap);
+      delete[](PermutationMap);
       result = false;
+    }
 …
 int * molecule::GetFatherSonAtomicMap(molecule *OtherMolecule)
+{
-  atom *Walker = NULL, *OtherWalker = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Begin of GetFatherAtomicMap." << endl);
   int *AtomicMap = Malloc<int>(AtomCount, "molecule::GetAtomicMap: *AtomicMap");
   for (int i=AtomCount;i--;)
+  int *AtomicMap = new int[getAtomCount()];
+  for (int i=getAtomCount();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
+    for (int i=getAtomCount();i--;) // no need as -1 means already that there is trivial correspondence
       AtomicMap[i] = i;
     DoLog(4) && (Log() << Verbose(4) << "Map is trivial." << endl);
   } else {
     DoLog(4) && (Log() << Verbose(4) << "Map is ");
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      if (Walker->father == NULL) {
+        AtomicMap[Walker->nr] = -2;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      if ((*iter)->father == NULL) {
+        AtomicMap[(*iter)->nr] = -2;
       } else {
+        OtherWalker = OtherMolecule->start;
+        while (OtherWalker->next != OtherMolecule->end) {
+          OtherWalker = OtherWalker->next;
+        for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
       //for (int i=0;i<AtomCount;i++) { // search atom
         //for (int j=0;j<OtherMolecule->AtomCount;j++) {
           //Log() << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
           if (Walker->father == OtherWalker)
             AtomicMap[Walker->nr] = OtherWalker->nr;
+        //for (int j=0;j<OtherMolecule->getAtomCount();j++) {
+          //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
+          if ((*iter)->father == (*runner))
+            AtomicMap[(*iter)->nr] = (*runner)->nr;
+        }
+      }
       DoLog(0) && (Log() << Verbose(0) << AtomicMap[Walker->nr] << "\t");
+      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->nr] << "\t");
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
 void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = Walker;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = (*iter);
+  }
 };

src/molecule.hpp

-              r0c7ed8
+              r1dc9ec
 #include "tesselation.hpp"
 #include "Patterns/Observer.hpp"
+#include "Patterns/ObservedIterator.hpp"
 #include "Patterns/Cacheable.hpp"
+#include "Descriptors/MoleculeDescriptor_impl.hpp"
 /****************************************** forward declarations *****************************/
 …
   friend molecule *NewMolecule();
   friend void DeleteMolecule(molecule *);
   public:
+    typedef std::set<atom*> atomSet;
+    typedef ObservedIterator<atomSet> iterator;
+    typedef atomSet::const_iterator const_iterator;
     const periodentafel * const 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
+    // old deprecated atom handling
+    //atom *start;        //!< start of atom list
+    //atom *end;          //!< end of atom list
+    //bond *first;        //!< start of bond list
+    //bond *last;         //!< end of bond list
     int MDSteps;        //!< The number of MD steps in Trajectories
     int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
+    //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
 …
   private:
     Cacheable<string> formula;
+    Cacheable<int>    AtomCount;
     moleculeId_t id;
+    atomSet atoms; //<!set of atoms
   protected:
+    //void CountAtoms();
+    /**
+     * this iterator type should be used for internal variables, \
+     * since it will not lock
+     */
+    typedef atomSet::iterator internal_iterator;
     molecule(const periodentafel * const teil);
     virtual ~molecule();
 …
   //getter and setter
   const std::string getName();
+  int getAtomCount() const;
+  int doCountAtoms();
   moleculeId_t getId();
   void setId(moleculeId_t);
 …
   std::string calcFormula();
+  iterator begin();
+  const_iterator begin() const;
+  iterator end();
+  const_iterator end() const;
+  bool empty() const;
+  size_t size() const;
+  const_iterator erase( const_iterator loc );
+  const_iterator erase( atom * key );
+  const_iterator find (  atom * key ) const;
+  pair<iterator,bool> insert ( atom * const key );
+  bool containsAtom(atom* key);
   // re-definition of virtual functions from PointCloud
 …
   Vector *GetCenter() const ;
   TesselPoint *GetPoint() const ;
-  TesselPoint *GetTerminalPoint() const ;
   int GetMaxId() const;
   void GoToNext() const ;
-  void GoToPrevious() const ;
   void GoToFirst() const ;
-  void GoToLast() const ;
   bool IsEmpty() const ;
   bool IsEnd() const ;
 …
   bool RemoveBond(bond *pointer);
   bool RemoveBonds(atom *BondPartner);
+  bool hasBondStructure();
+  unsigned int CountBonds() const;
   /// Find atoms.
 …
   /// Count and change present atoms' coordination.
-  void CountAtoms();
   void CountElements();
   void CalculateOrbitals(class config &configuration);
 …
   Vector * DetermineCenterOfGravity();
   Vector * DetermineCenterOfAll() const;
+  Vector * DetermineCenterOfBox() const;
   void SetNameFromFilename(const char *filename);
   void SetBoxDimension(Vector *dim);
 …
   bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
   bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
+  bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
   void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
   /// -# BOSSANOVA
 …
   private:
   int last_atom;      //!< number given to last atom
   mutable atom *InternalPointer;  //!< internal pointer for PointCloud
+  mutable internal_iterator InternalPointer;  //!< internal pointer for PointCloud
 };
 …
   bool StoreForcesFile(char *path, int *SortIndex);
   void insert(molecule *mol);
+  void erase(molecule *mol);
   molecule * ReturnIndex(int index);
   bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);

src/molecule_dynamics.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "memoryallocator.hpp"
 …
   gsl_matrix *A = gsl_matrix_alloc(NDIM,NDIM);
   gsl_vector *x = gsl_vector_alloc(NDIM);
-  atom * Runner = mol->start;
   atom *Sprinter = NULL;
   Vector trajectory1, trajectory2, normal, TestVector;
   double Norm1, Norm2, tmp, result = 0.;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if (Runner == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter) == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
       break;
     // determine normalized trajectories direction vector (n1, n2)
 …
     trajectory1.Normalize();
     Norm1 = trajectory1.Norm();
     Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
     trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+    Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
+    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
     trajectory2.Normalize();
     Norm2 = trajectory1.Norm();
     // check whether either is zero()
     if ((Norm1 < MYEPSILON) && (Norm2 < MYEPSILON)) {
       tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
     } else if (Norm1 < MYEPSILON) {
       Sprinter = Params.PermutationMap[Walker->nr];   // find first target point
       trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
       trajectory2 *= trajectory1.ScalarProduct(trajectory2); // trajectory2 is scaled to unity, hence we don't need to divide by anything
       trajectory1 -= trajectory2;   // project the part in norm direction away
       tmp = trajectory1.Norm();  // remaining norm is distance
     } else if (Norm2 < MYEPSILON) {
       Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
+      Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
       trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Walker->Trajectory.R.at(Params.startstep);  // copy second offset
       trajectory1 *= trajectory2.ScalarProduct(trajectory1); // trajectory1 is scaled to unity, hence we don't need to divide by anything
 …
   //        Log() << Verbose(0) << " and ";
   //        Log() << Verbose(0) << trajectory2;
       tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
   //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
     } else { // determine distance by finding minimum distance
   //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *(*iter) << " are linear independent ";
   //        Log() << Verbose(0) << endl;
   //        Log() << Verbose(0) << "First Trajectory: ";
 …
         gsl_matrix_set(A, 1, i, trajectory2[i]);
         gsl_matrix_set(A, 2, i, normal[i]);
         gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - Runner->Trajectory.R.at(Params.startstep)[i]));
+        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - (*iter)->Trajectory.R.at(Params.startstep)[i]));
+      }
       // solve the linear system by Householder transformations
 …
       trajectory2.Scale(gsl_vector_get(x,1));
       normal.Scale(gsl_vector_get(x,2));
       TestVector = Runner->Trajectory.R.at(Params.startstep) + trajectory2 + normal
+      TestVector = (*iter)->Trajectory.R.at(Params.startstep) + trajectory2 + normal
                    - (Walker->Trajectory.R.at(Params.startstep) + trajectory1);
       if (TestVector.Norm() < MYEPSILON) {
 …
+{
   double result = 0.;
+  atom * Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[(*iter)->nr]) && (Walker->nr < (*iter)->nr)) {
   //    atom *Sprinter = PermutationMap[Walker->nr];
   //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
+  //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
   //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
   //        Log() << Verbose(0) << ", penalting." << endl;
 …
   // go through every atom
   atom *Runner = NULL;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     // first term: distance to target
     Runner = Params.PermutationMap[Walker->nr];   // find target point
     tmp = (Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
+    Runner = Params.PermutationMap[(*iter)->nr];   // find target point
+    tmp = ((*iter)->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
     result += Params.PenaltyConstants[0] * tmp;
 …
     // second term: sum of distances to other trajectories
     result += SumDistanceOfTrajectories(Walker, this, Params);
+    result += SumDistanceOfTrajectories((*iter), this, Params);
     // third term: penalty for equal targets
     result += PenalizeEqualTargets(Walker, this, Params);
+    result += PenalizeEqualTargets((*iter), this, Params);
+  }
 …
+{
   stringstream zeile1, zeile2;
+  int *DoubleList = Calloc<int>(AtomCount, "PrintPermutationMap: *DoubleList");
+  int *DoubleList = new int[AtomCount];
+  for(int i=0;i<AtomCount;i++)
+    DoubleList[i] = 0;
   int doubles = 0;
   zeile1 << "PermutationMap: ";
 …
   if (doubles >0)
     DoLog(2) && (Log() << Verbose(2) << "Found " << doubles << " Doubles." << endl);
   Free(&DoubleList);
+  delete[](DoubleList);
 //  Log() << Verbose(2) << zeile1.str() << endl << zeile2.str() << endl;
 };
 …
 void FillDistanceList(molecule *mol, struct EvaluatePotential &Params)
+{
   for (int i=mol->AtomCount; i--;) {
+  for (int i=mol->getAtomCount(); i--;) {
     Params.DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
     Params.DistanceList[i]->clear();
+  }
+  atom *Runner = NULL;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Runner = mol->start;
+    while(Runner->next != mol->end) {
+      Runner = Runner->next;
+      Params.DistanceList[Walker->nr]->insert( DistancePair(Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)), Runner) );
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    for (molecule::const_iterator runner = mol->begin(); runner != mol->end(); ++runner) {
+      Params.DistanceList[(*iter)->nr]->insert( DistancePair((*iter)->Trajectory.R.at(Params.startstep).distance((*runner)->Trajectory.R.at(Params.endstep)), (*runner)) );
+    }
+  }
 …
 void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
+{
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Params.StepList[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[Walker->nr] = Params.DistanceList[Walker->nr]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl);
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    Params.StepList[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[(*iter)->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->nr]->begin()->first << "." << endl);
+  }
 };
 …
 void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
+{
   atom *Walker = mol->start;
+  molecule::const_iterator iter = mol->begin();
   DistanceMap::iterator NewBase;
   double Potential = fabs(mol->ConstrainedPotential(Params));
+  if (mol->empty()) {
+    eLog() << Verbose(1) << "Molecule is empty." << endl;
+    return;
+  }
   while ((Potential) > Params.PenaltyConstants[2]) {
     PrintPermutationMap(mol->AtomCount, Params);
     Walker = Walker->next;
     if (Walker == mol->end) // round-robin at the end
       Walker = mol->start->next;
     if (Params.DoubleList[Params.DistanceIterators[Walker->nr]->second->nr] <= 1)  // no need to make those injective that aren't
+    PrintPermutationMap(mol->getAtomCount(), Params);
+    iter++;
+    if (iter == mol->end()) // round-robin at the end
+      iter = mol->begin();
+    if (Params.DoubleList[Params.DistanceIterators[(*iter)->nr]->second->nr] <= 1)  // no need to make those injective that aren't
       continue;
     // now, try finding a new one
     Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
+  }
   for (int i=mol->AtomCount; i--;) // now each single entry in the DoubleList should be <=1
+    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, (*iter), Potential, Params);
+  }
+  for (int i=mol->getAtomCount(); i--;) // now each single entry in the DoubleList should be <=1
     if (Params.DoubleList[i] > 1) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Failed to create an injective PermutationMap!" << endl);
 …
   double Potential, OldPotential, OlderPotential;
   struct EvaluatePotential Params;
   Params.PermutationMap = Calloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
   Params.DistanceList = Malloc<DistanceMap*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**DistanceList");
   Params.DistanceIterators = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DistanceIterators");
   Params.DoubleList = Calloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
   Params.StepList = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*StepList");
+  Params.PermutationMap = new atom *[getAtomCount()];
+  Params.DistanceList = new DistanceMap *[getAtomCount()];
+  Params.DistanceIterators = new DistanceMap::iterator[getAtomCount()];
+  Params.DoubleList = new int[getAtomCount()];
+  Params.StepList = new DistanceMap::iterator[getAtomCount()];
   int round;
   atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   DistanceMap::iterator Rider, Strider;
+  // set to zero
+  for (int i=0;i<getAtomCount();i++) {
+    Params.PermutationMap[i] = NULL;
+    Params.DoubleList[i] = 0;
+  }
   /// Minimise the potential
 …
   DoLog(1) && (Log() << Verbose(1) << "Making the PermutationMap injective ... " << endl);
   MakeInjectivePermutation(this, Params);
   Free(&Params.DoubleList);
+  delete[](Params.DoubleList);
   // argument minimise the constrained potential in this injective PermutationMap
 …
     DoLog(2) && (Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl);
     OlderPotential = OldPotential;
+    molecule::const_iterator iter;
     do {
+      Walker = start;
+      while (Walker->next != end) { // pick one
+        Walker = Walker->next;
+        PrintPermutationMap(AtomCount, Params);
+        Sprinter = Params.DistanceIterators[Walker->nr]->second;   // store initial partner
+        Strider = Params.DistanceIterators[Walker->nr];  //remember old iterator
+        Params.DistanceIterators[Walker->nr] = Params.StepList[Walker->nr];
+        if (Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->begin();
+      iter = begin();
+      for (; iter != end(); ++iter) {
+        PrintPermutationMap(getAtomCount(), Params);
+        Sprinter = Params.DistanceIterators[(*iter)->nr]->second;   // store initial partner
+        Strider = Params.DistanceIterators[(*iter)->nr];  //remember old iterator
+        Params.DistanceIterators[(*iter)->nr] = Params.StepList[(*iter)->nr];
+        if (Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->begin();
           break;
+        }
         //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->nr]->second << "." << endl;
         // find source of the new target
         Runner = start->next;
         while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
           if (Params.PermutationMap[Runner->nr] == Params.DistanceIterators[Walker->nr]->second) {
             //Log() << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
+        molecule::const_iterator runner = begin();
+        for (; runner != end(); ++runner) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
+          if (Params.PermutationMap[(*runner)->nr] == Params.DistanceIterators[(*iter)->nr]->second) {
+            //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->nr] << "." << endl;
             break;
+          }
-          Runner = Runner->next;
+        }
         if (Runner != end) { // we found the other source
+        if (runner != end()) { // we found the other source
           // then look in its distance list for Sprinter
           Rider = Params.DistanceList[Runner->nr]->begin();
           for (; Rider != Params.DistanceList[Runner->nr]->end(); Rider++)
+          Rider = Params.DistanceList[(*runner)->nr]->begin();
+          for (; Rider != Params.DistanceList[(*runner)->nr]->end(); Rider++)
             if (Rider->second == Sprinter)
               break;
           if (Rider != Params.DistanceList[Runner->nr]->end()) { // if we have found one
             //Log() << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
+          if (Rider != Params.DistanceList[(*runner)->nr]->end()) { // if we have found one
+            //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->nr] << "/" << *Rider->second << "." << endl;
             // exchange both
             Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
             Params.PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
             PrintPermutationMap(AtomCount, Params);
+            Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // put next farther distance into PermutationMap
+            Params.PermutationMap[(*runner)->nr] = Sprinter;  // and hand the old target to its respective owner
+            PrintPermutationMap(getAtomCount(), Params);
             // calculate the new potential
             //Log() << Verbose(2) << "Checking new potential ..." << endl;
 …
             if (Potential > OldPotential) { // we made everything worse! Undo ...
               //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
               //Log() << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->nr]->second << "." << endl;
               // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
               Params.PermutationMap[Runner->nr] = Params.DistanceIterators[Runner->nr]->second;
+              Params.PermutationMap[(*runner)->nr] = Params.DistanceIterators[(*runner)->nr]->second;
               // Undo for Walker
               Params.DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
               //Log() << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
               Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
+              Params.DistanceIterators[(*iter)->nr] = Strider;  // take next farther distance target
+              //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->nr]->second << "." << endl;
+              Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second;
             } else {
               Params.DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
+              Params.DistanceIterators[(*runner)->nr] = Rider;  // if successful also move the pointer in the iterator list
               DoLog(3) && (Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl);
               OldPotential = Potential;
 …
             //Log() << Verbose(0) << endl;
           } else {
             DoeLog(1) && (eLog()<< Verbose(1) << *Runner << " was not the owner of " << *Sprinter << "!" << endl);
+            DoeLog(1) && (eLog()<< Verbose(1) << **runner << " was not the owner of " << *Sprinter << "!" << endl);
             exit(255);
+          }
         } else {
           Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // new target has no source!
+          Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // new target has no source!
+        }
         Params.StepList[Walker->nr]++; // take next farther distance target
+        Params.StepList[(*iter)->nr]++; // take next farther distance target
+      }
     } while (Walker->next != end);
+    } while (++iter != end());
   } while ((OlderPotential - OldPotential) > 1e-3);
   DoLog(1) && (Log() << Verbose(1) << "done." << endl);
 …
   /// free memory and return with evaluated potential
   for (int i=AtomCount; i--;)
+  for (int i=getAtomCount(); i--;)
     Params.DistanceList[i]->clear();
   Free(&Params.DistanceList);
   Free(&Params.DistanceIterators);
+  delete[](Params.DistanceList);
+  delete[](Params.DistanceIterators);
   return ConstrainedPotential(Params);
 };
 …
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
   atom *Walker = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   if (!MapByIdentity)
     MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
     PermutationMap = Malloc<atom *>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
+    PermutationMap = new atom *[getAtomCount()];
     SetIndexedArrayForEachAtomTo( PermutationMap, &atom::nr );
+  }
 …
     mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
       // add to molecule list
       Sprinter = mol->AddCopyAtom(Walker);
+      Sprinter = mol->AddCopyAtom((*iter));
       for (int n=NDIM;n--;) {
         Sprinter->x[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+        Sprinter->x[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
         // add to Trajectories
         //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
         if (step < MaxSteps) {
           Walker->Trajectory.R.at(step)[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
           Walker->Trajectory.U.at(step)[n] = 0.;
           Walker->Trajectory.F.at(step)[n] = 0.;
+          (*iter)->Trajectory.R.at(step)[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+          (*iter)->Trajectory.U.at(step)[n] = 0.;
+          (*iter)->Trajectory.F.at(step)[n] = 0.;
+        }
+      }
 …
   // store the list to single step files
   int *SortIndex = Malloc<int>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
   for (int i=AtomCount; i--; )
+  int *SortIndex = new int[getAtomCount()];
+  for (int i=getAtomCount(); i--; )
     SortIndex[i] = i;
   status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
+  delete[](SortIndex);
   // free and return
   Free(&PermutationMap);
+  delete[](PermutationMap);
   delete(MoleculePerStep);
   return status;
 …
 bool molecule::VerletForceIntegration(char *file, config &configuration)
+{
+  Info FunctionInfo(__func__);
   ifstream input(file);
   string token;
 …
       return false;
+    }
     if (Force.RowCounter[0] != AtomCount) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl);
+    if (Force.RowCounter[0] != getAtomCount()) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << getAtomCount() << "." << endl);
       performCriticalExit();
       return false;
 …
     // correct Forces
     Velocity.Zero();
     for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
         Velocity[d] += Force.Matrix[0][i][d+5];
+      }
     for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
         Force.Matrix[0][i][d+5] -= Velocity[d]/(double)AtomCount;
+        Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
+      }
     // solve a constrained potential if we are meant to
 …
       ConstrainedPotentialEnergy = MinimiseConstrainedPotential(PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
       EvaluateConstrainedForces(configuration.DoConstrainedMD, 0, PermutationMap, &Force);
       Free(&PermutationMap);
+      delete[](PermutationMap);
+    }
     // and perform Verlet integration for each atom with position, velocity and force vector
     // check size of vectors
     ActOnAllAtoms( &atom::ResizeTrajectory, MDSteps+10 );
     ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps, &configuration, &Force);
+    //ActOnAllAtoms( &atom::ResizeTrajectory, MDSteps+10 );
+    ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps+1, &configuration, &Force);
+  }
   // correct velocities (rather momenta) so that center of mass remains motionless
   Velocity.Zero();
   IonMass = 0.;
   ActOnAllAtoms ( &atom::SumUpKineticEnergy, MDSteps, &IonMass, &Velocity );
+  ActOnAllAtoms ( &atom::SumUpKineticEnergy, MDSteps+1, &IonMass, &Velocity );
   // correct velocities (rather momenta) so that center of mass remains motionless
   Velocity.Scale(1./IonMass);
   ActualTemp = 0.;
   ActOnAllAtoms ( &atom::CorrectVelocity, &ActualTemp, MDSteps, &Velocity );
+  ActOnAllAtoms ( &atom::CorrectVelocity, &ActualTemp, MDSteps+1, &Velocity );
   Thermostats(configuration, ActualTemp, Berendsen);
   MDSteps++;
 …
       delta_alpha = 0.;
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_init, MDSteps, &delta_alpha );
       delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
+      delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
       configuration.alpha += delta_alpha*configuration.Deltat;
       DoLog(3) && (Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl);

src/molecule_fragmentation.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
   int FragmentCount;
   // get maximum bond degree
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    c = ((*iter)->ListOfBonds.size() > c) ? (*iter)->ListOfBonds.size() : c;
+  }
   FragmentCount = NoNonHydrogen*(1 << (c*order));
 …
   GraphTestPair testGraphInsert;
   int NumberOfFragments = 0;
   char *filename = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
+  char filename[MAXSTRINGSIZE];
   if (FragmentList == NULL) { // check list pointer
 …
   if (InputFile != NULL) {
     // each line represents a new fragment
     char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
+    char buffer[MAXSTRINGSIZE];
     // 1. parse keysets and insert into temp. graph
     while (!InputFile.eof()) {
 …
     InputFile.close();
     InputFile.clear();
+    Free(&buffer);
+    DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "File " << filename << " not found." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... File " << filename << " not found." << endl);
     status = false;
+  }
-  Free(&filename);
   return status;
 };
 …
   int NumberOfFragments = 0;
   double TEFactor;
   char *filename = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseTEFactorsFile - filename");
+  char filename[MAXSTRINGSIZE];
   if (FragmentList == NULL) { // check list pointer
 …
+  }
-  // free memory
-  Free(&filename);
   return status;
 };
 …
   int No = 0, FragOrder = 0;
   double Value = 0.;
   char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
+  char buffer[MAXSTRINGSIZE];
   sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
   ifstream InputFile(buffer, ios::in);
 …
     InputFile.clear();
+  }
-  Free(&buffer);
   return AdaptiveCriteriaList;
 …
 map<double, pair<int,int> >  * ReMapAdaptiveCriteriaListToValue(map<int, pair<double,int> > *AdaptiveCriteriaList, molecule *mol)
+{
   atom *Walker = mol->start;
+  atom *Walker = NULL;
   map<double, pair<int,int> > *FinalRootCandidates = new map<double, pair<int,int> > ;
   DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
 …
 bool MarkUpdateCandidates(bool *AtomMask, map<double, pair<int,int> > &FinalRootCandidates, int Order, molecule *mol)
+{
   atom *Walker = mol->start;
+  atom *Walker = NULL;
   int No = -1;
   bool status = false;
 …
 bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
+{
-  atom *Walker = start;
   bool status = false;
   // initialize mask list
   for(int i=AtomCount;i--;)
+  for(int i=getAtomCount();i--;)
     AtomMask[i] = false;
   if (Order < 0) { // adaptive increase of BondOrder per site
     if (AtomMask[AtomCount] == true)  // break after one step
+    if (AtomMask[getAtomCount()] == true)  // break after one step
       return false;
 …
     if (AdaptiveCriteriaList->empty()) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
+      while (Walker->next != end) {
+        Walker = Walker->next;
+      for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     #ifdef ADDHYDROGEN
         if (Walker->type->Z != 1) // skip hydrogen
+        if ((*iter)->type->Z != 1) // skip hydrogen
     #endif
+        {
           AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+          AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
           status = true;
+        }
 …
     MarkUpdateCandidates(AtomMask, *FinalRootCandidates, Order, this);
     Free(&IndexKeySetList);
     Free(&AdaptiveCriteriaList);
     Free(&FinalRootCandidates);
+    delete[](IndexKeySetList);
+    delete[](AdaptiveCriteriaList);
+    delete[](FinalRootCandidates);
   } else { // global increase of Bond Order
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
   #ifdef ADDHYDROGEN
       if (Walker->type->Z != 1) // skip hydrogen
+      if ((*iter)->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]))
+        AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->nr]))
           status = true;
+      }
+    }
     if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
+    if ((!Order) && (!AtomMask[getAtomCount()]))  // single stepping, just check
       status = true;
 …
+  }
   PrintAtomMask(AtomMask, AtomCount); // for debugging
+  PrintAtomMask(AtomMask, getAtomCount()); // for debugging
   return status;
 …
     return false;
+  }
   SortIndex = Malloc<int>(AtomCount, "molecule::CreateMappingLabelsToConfigSequence: *SortIndex");
   for(int i=AtomCount;i--;)
+  SortIndex = new int[getAtomCount()];
+  for(int i=getAtomCount();i--;)
     SortIndex[i] = -1;
 …
   return true;
+};
+/** Creates a lookup table for true father's Atom::Nr -> atom ptr.
+ * \param *start begin of list (STL iterator, i.e. first item)
+ * \paran *end end of list (STL iterator, i.e. one past last item)
+ * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
+ * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
+ * \return true - success, false - failure
+ */
+bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
+{
+  bool status = true;
+  int AtomNo;
+  if (LookupTable != NULL) {
+    Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
+    return false;
+  }
+  // count them
+  if (count == 0) {
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      count = (count < (*iter)->GetTrueFather()->nr) ? (*iter)->GetTrueFather()->nr : count;
+    }
+  }
+  if (count <= 0) {
+    Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl;
+    return false;
+  }
+  // allocate and fill
+  LookupTable = new atom *[count];
+  if (LookupTable == NULL) {
+    eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
+    performCriticalExit();
+    status = false;
+  } else {
+    for (int i=0;i<count;i++)
+      LookupTable[i] = NULL;
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) {
+      AtomNo = (*iter)->GetTrueFather()->nr;
+      if ((AtomNo >= 0) && (AtomNo < count)) {
+        //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
+        LookupTable[AtomNo] = (*iter);
+      } else {
+        Log() << Verbose(0) << "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << ")." << endl;
+        status = false;
+        break;
+      }
+    }
+  }
+  return status;
 };
 …
+{
   MoleculeListClass *BondFragments = NULL;
+  int *SortIndex = NULL;
+  int *MinimumRingSize = new int[AtomCount];
+  int *MinimumRingSize = new int[getAtomCount()];
   int FragmentCounter;
   MoleculeLeafClass *MolecularWalker = NULL;
 …
   // create lookup table for Atom::nr
   FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(start, end, ListOfAtoms, AtomCount);
+  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(ListOfAtoms, getAtomCount());
   // === compare it with adjacency file ===
   FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(configuration->configpath, ListOfAtoms);
   Free(&ListOfAtoms);
+  delete[](ListOfAtoms);
   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
 …
   // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
   for(int i=AtomCount;i--;)
     MinimumRingSize[i] = AtomCount;
+  for(int i=getAtomCount();i--;)
+    MinimumRingSize[i] = getAtomCount();
   MolecularWalker = Subgraphs;
   FragmentCounter = 0;
 …
 //    // check the list of local atoms for debugging
 //    Log() << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
 //    for (int i=0;i<AtomCount;i++)
+//    for (int i=0;i<getAtomCount();i++)
 //      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
 //        Log() << Verbose(0) << "\tNULL";
 …
   // ===== 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;
+  AtomMask = new bool[getAtomCount()+1];
+  AtomMask[getAtomCount()] = false;
   FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
   while ((CheckOrder = CheckOrderAtSite(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()
+    AtomMask[getAtomCount()] = 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(RootStack, AtomMask, (FragmentCounter = 0));
 …
       DoLog(1) && (Log() << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl);
       //MolecularWalker->Leaf->OutputListOfBonds(out);  // output atom::ListOfBonds for debugging
       if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
+      if (MolecularWalker->Leaf->hasBondStructure()) {
         // call BOSSANOVA method
         DoLog(0) && (Log() << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl);
 …
     delete(Subgraphs);
+  }
   Free(&FragmentList);
+  delete[](FragmentList);
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
 …
   if (BondFragments->ListOfMolecules.size() != 0) {
     // create the SortIndex from BFS labels to order in the config file
+    int *SortIndex = NULL;
     CreateMappingLabelsToConfigSequence(SortIndex);
 …
     StoreKeySetFile(TotalGraph, configuration->configpath);
+    // store Adjacency file
+    char *filename = Malloc<char> (MAXSTRINGSIZE, "molecule::FragmentMolecule - *filename");
+    strcpy(filename, FRAGMENTPREFIX);
+    strcat(filename, ADJACENCYFILE);
+    StoreAdjacencyToFile(configuration->configpath, filename);
+    Free(&filename);
+    {
+      // store Adjacency file
+      char filename[MAXSTRINGSIZE];
+      strcpy(filename, FRAGMENTPREFIX);
+      strcat(filename, ADJACENCYFILE);
+      StoreAdjacencyToFile(configuration->configpath, filename);
+    }
     // store Hydrogen saturation correction file
 …
     // free memory for bond part
     DoLog(1) && (Log() << Verbose(1) << "Freeing bond memory" << endl);
+    Free(&FragmentList); // remove bond molecule from memory
+    Free(&SortIndex);
+    delete[](SortIndex);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl);
 …
 bool molecule::ParseOrderAtSiteFromFile(char *path)
+{
   unsigned char *OrderArray = Calloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
   bool *MaxArray = Calloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  unsigned char *OrderArray = new unsigned char[getAtomCount()];
+  bool *MaxArray = new bool[getAtomCount()];
   bool status;
   int AtomNr, value;
   stringstream line;
   ifstream file;
+  for(int i=0;i<getAtomCount();i++) {
+    OrderArray[i] = 0;
+    MaxArray[i] = false;
+  }
   DoLog(1) && (Log() << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl);
 …
     SetAtomValueToIndexedArray( MaxArray, &atom::nr, &atom::MaxOrder );
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
     status = true;
   } else {
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line.str() << "." << endl);
     status = false;
+  }
   Free(&OrderArray);
   Free(&MaxArray);
+  delete[](OrderArray);
+  delete[](MaxArray);
   DoLog(1) && (Log() << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl);
 …
   atom *OtherFather = NULL;
   atom *FatherOfRunner = NULL;
+  Leaf->CountAtoms();
+  atom *Runner = Leaf->start;
+  while (Runner->next != Leaf->end) {
+    Runner = Runner->next;
+#ifdef ADDHYDROGEN
+  molecule::const_iterator runner;
+#endif
+  // we increment the iter just before skipping the hydrogen
+  for (molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end();) {
     LonelyFlag = true;
+    FatherOfRunner = Runner->father;
+    FatherOfRunner = (*iter)->father;
+    ASSERT(FatherOfRunner,"Atom without father found");
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
 …
 //            Log() << Verbose(3) << "Adding Bond: ";
 //            Log() << Verbose(0) <<
             Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
+            Leaf->AddBond((*iter), SonList[OtherFather->nr], (*BondRunner)->BondDegree);
 //            Log() << Verbose(0) << "." << endl;
             //NumBonds[Runner->nr]++;
+            //NumBonds[(*iter)->nr]++;
           } else {
 //            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
 …
 //          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
 #ifdef ADDHYDROGEN
           //Log() << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
           if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
+          //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
+          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
             exit(1);
 #endif
           //NumBonds[Runner->nr] += Binder->BondDegree;
+          //NumBonds[(*iter)->nr] += Binder->BondDegree;
+        }
+      }
     } else {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Son " << Runner->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
+    }
+    if ((LonelyFlag) && (Leaf->AtomCount > 1)) {
+      DoLog(0) && (Log() << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl);
+    }
+    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
+    }
+    if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
+      DoLog(0) && (Log() << Verbose(0) << **iter << "has got bonds only to hydrogens!" << endl);
+    }
+    ++iter;
 #ifdef ADDHYDROGEN
+    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
+      Runner = Runner->next;
+    while ((iter != Leaf->end()) && ((*iter)->type->Z == 1)){ // skip added hydrogen
+      iter++;
+    }
 #endif
+  }
 …
 molecule * molecule::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
+{
   atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = new atom*[getAtomCount()];
   molecule *Leaf = World::getInstance().createMolecule();
+  for(int i=0;i<getAtomCount();i++)
+    SonList[i] = NULL;
 //  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
 …
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
   Free(&SonList);
+  delete[](SonList);
 //  Log() << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
   return Leaf;
 …
   int bits, TouchedIndex, SubSetDimension, SP, Added;
   int SpaceLeft;
+  int *TouchedList = Malloc<int>(SubOrder + 1, "molecule::SPFragmentGenerator: *TouchedList");
+  bond **BondsList = NULL;
+  int *TouchedList = new int[SubOrder + 1];
   KeySetTestPair TestKeySetInsert;
 …
           // then allocate and fill the list
           BondsList = Malloc<bond*>(SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
+          bond *BondsList[SubSetDimension];
           SubSetDimension = FillBondsList(BondsList, FragmentSearch->BondsPerSPList[2*SP], FragmentSearch->BondsPerSPList[2*SP+1], TouchedList, TouchedIndex);
 …
           Log() << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
           SPFragmentGenerator(FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
-          Free(&BondsList);
+        }
       } else {
 …
+    }
+  }
   Free(&TouchedList);
+  delete[](TouchedList);
   Log() << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
 …
 void InitialiseSPList(int Order, struct UniqueFragments &FragmentSearch)
+{
   FragmentSearch.BondsPerSPList = Malloc<bond*>(Order * 2, "molecule::PowerSetGenerator: ***BondsPerSPList");
   FragmentSearch.BondsPerSPCount = Malloc<int>(Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
+  FragmentSearch.BondsPerSPList = new bond* [Order * 2];
+  FragmentSearch.BondsPerSPCount = new int[Order];
   for (int i=Order;i--;) {
     FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
 …
 void FreeSPList(int Order, struct UniqueFragments &FragmentSearch)
+{
   Free(&FragmentSearch.BondsPerSPCount);
+  delete[](FragmentSearch.BondsPerSPCount);
   for (int i=Order;i--;) {
     delete(FragmentSearch.BondsPerSPList[2*i]);
     delete(FragmentSearch.BondsPerSPList[2*i+1]);
+  }
   Free(&FragmentSearch.BondsPerSPList);
+  delete[](FragmentSearch.BondsPerSPList);
 };
 …
 int molecule::PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet)
+{
-  bond **BondsList = NULL;
   int Counter = FragmentSearch.FragmentCounter; // mark current value of counter
 …
     // prepare the subset and call the generator
+    BondsList = Calloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    bond* BondsList[FragmentSearch.BondsPerSPCount[0]];
+    for(int i=0;i<FragmentSearch.BondsPerSPCount[0];i++)
+      BondsList[i] = NULL;
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
     SPFragmentGenerator(&FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
-    Free(&BondsList);
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl);
 …
+      }
+    }
     Free(&FragmentLowerOrdersList[RootNr]);
+    delete[](FragmentLowerOrdersList[RootNr]);
     RootNr++;
+  }
   Free(&FragmentLowerOrdersList);
+  delete[](FragmentLowerOrdersList);
 };
 …
   // 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 = Calloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = Calloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  NumMoleculesOfOrder = new int[UpgradeCount];
+  FragmentLowerOrdersList = new Graph**[UpgradeCount];
+  for(int i=0;i<UpgradeCount;i++) {
+    NumMoleculesOfOrder[i] = 0;
+    FragmentLowerOrdersList[i] = NULL;
+  }
   // initialise the fragments structure
 …
   FragmentSearch.FragmentSet = new KeySet;
   FragmentSearch.Root = FindAtom(RootKeyNr);
   FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   for (int i=AtomCount;i--;) {
+  FragmentSearch.ShortestPathList = new int[getAtomCount()];
+  for (int i=getAtomCount();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);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    CompleteMolecule.insert((*iter)->GetTrueFather()->nr);
+  }
 …
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
     Walker = FindAtom(RootKeyNr);
+    atom *Walker = FindAtom(RootKeyNr);
     // check cyclic lengths
     //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
 …
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
+      FragmentLowerOrdersList[RootNr] = Calloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      FragmentLowerOrdersList[RootNr] = new Graph*[NumLevels];
+      for (int i=0;i<NumLevels;i++)
+        FragmentLowerOrdersList[RootNr][i] = NULL;
       // create top order where nothing is reduced
 …
   // cleanup FragmentSearch structure
   Free(&FragmentSearch.ShortestPathList);
+  delete[](FragmentSearch.ShortestPathList);
   delete(FragmentSearch.FragmentSet);
 …
   CombineAllOrderListIntoOne(FragmentList, FragmentLowerOrdersList, RootStack, this);
   FreeAllOrdersList(FragmentLowerOrdersList, RootStack, this);
   Free(&NumMoleculesOfOrder);
+  delete[](NumMoleculesOfOrder);
   DoLog(0) && (Log() << Verbose(0) << "End of FragmentBOSSANOVA." << endl);
 …
   Vector Translationvector;
   //class StackClass<atom *> *CompStack = NULL;
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(getAtomCount());
   bool flag = true;
   DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
+  ColorList = Calloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = new enum Shading[getAtomCount()];
+  for (int i=0;i<getAtomCount();i++)
+    ColorList[i] = (enum Shading)0;
   while (flag) {
     // remove bonds that are beyond bonddistance
     Translationvector.Zero();
     // 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[i] - Binder->rightatom->x[i]);
+        //Log() << 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
+          DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
+          flag = true;
+          break;
+    for(molecule::iterator AtomRunner = begin(); (!flag) && (AtomRunner != end()); ++AtomRunner)
+      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); (!flag) && (BondRunner != (*AtomRunner)->ListOfBonds.end()); ++BondRunner) {
+        Binder = (*BondRunner);
+        for (int i=NDIM;i--;) {
+          tmp = fabs(Binder->leftatom->x[i] - Binder->rightatom->x[i]);
+          //Log() << 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
+            DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
+            flag = true;
+            break;
+          }
+        }
+      }
+    }
     if (flag) {
       // create translation vector from their periodically modified distance
 …
       Log() << Verbose(0) << Translationvector <<  endl;
       // apply to all atoms of first component via BFS
       for (int i=AtomCount;i--;)
+      for (int i=getAtomCount();i--;)
         ColorList[i] = white;
       AtomStack->Push(Binder->leftatom);
 …
   // free allocated space from ReturnFullMatrixforSymmetric()
   delete(AtomStack);
   Free(&ColorList);
   Free(&matrix);
+  delete[](ColorList);
+  delete[](matrix);
   DoLog(2) && (Log() << Verbose(2) << "End of ScanForPeriodicCorrection." << endl);
 };

src/molecule_geometry.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 #include "World.hpp"
 #include "Plane.hpp"
+#include <boost/foreach.hpp>
 /************************************* Functions for class molecule *********************************/
 …
   bool status = true;
   const Vector *Center = DetermineCenterOfAll();
+  const Vector *CenterBox = DetermineCenterOfBox();
   double * const cell_size = World::getInstance().getDomain();
   double *M = ReturnFullMatrixforSymmetric(cell_size);
 …
   // go through all atoms
   ActOnAllVectors( &Vector::SubtractVector, *Center);
+  ActOnAllVectors( &Vector::SubtractVector, *CenterBox);
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
   delete(Center);
   return status;
 …
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
   return status;
 };
 …
 //  Log() << Verbose(3) << "Begin of CenterEdge." << endl;
   atom *ptr = start->next;  // start at first in list
   if (ptr != end) {   //list not empty?
+  molecule::const_iterator iter = begin();  // start at first in list
+  if (iter != end()) { //list not empty?
     for (int i=NDIM;i--;) {
+      max->at(i) = ptr->x[i];
+      min->at(i) = ptr->x[i];
+    }
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      //ptr->Output(1,1,out);
+      max->at(i) = (*iter)->x[i];
+      min->at(i) = (*iter)->x[i];
+    }
+    for (; iter != end(); ++iter) {// continue with second if present
+      //(*iter)->Output(1,1,out);
       for (int i=NDIM;i--;) {
         max->at(i) = (max->at(i) < ptr->x[i]) ? ptr->x[i] : max->at(i);
         min->at(i) = (min->at(i) > ptr->x[i]) ? ptr->x[i] : min->at(i);
+        max->at(i) = (max->at(i) < (*iter)->x[i]) ? (*iter)->x[i] : max->at(i);
+        min->at(i) = (min->at(i) > (*iter)->x[i]) ? (*iter)->x[i] : min->at(i);
+      }
+    }
 …
+{
   int Num = 0;
   atom *ptr = start;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
   Center.Zero();
+  if (ptr->next != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
       Num++;
       Center += ptr->x;
+      Center += (*iter)->x;
+    }
     Center.Scale(-1./Num); // divide through total number (and sign for direction)
 …
 Vector * molecule::DetermineCenterOfAll() const
+{
+  atom *ptr = start->next;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
+  Vector *a = new Vector();
+  double Num = 0;
+  a->Zero();
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
+      Num++;
+      (*a) += (*iter)->x;
+    }
+    a->Scale(1./Num); // divide through total mass (and sign for direction)
+  }
+  return a;
+};
+/** Returns vector pointing to center of the domain.
+ * \return pointer to center of the domain
+ */
+Vector * molecule::DetermineCenterOfBox() const
+{
+  Vector *a = new Vector(0.5,0.5,0.5);
+  const double *cell_size = World::getInstance().getDomain();
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  a->MatrixMultiplication(M);
+  delete[](M);
+  return a;
+};
+/** Returns vector pointing to center of gravity.
+ * \param *out output stream for debugging
+ * \return pointer to center of gravity vector
+ */
+Vector * molecule::DetermineCenterOfGravity()
+{
+  molecule::const_iterator iter = begin();  // start at first in list
   Vector *a = new Vector();
   Vector tmp;
 …
   a->Zero();
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      Num += 1.;
+      tmp = ptr->x;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
+      Num += (*iter)->type->mass;
+      tmp = (*iter)->type->mass * (*iter)->x;
       (*a) += tmp;
+    }
     a->Scale(1./Num); // divide through total mass (and sign for direction)
+  }
-  return a;
-};
-/** Returns vector pointing to center of gravity.
- * \param *out output stream for debugging
- * \return pointer to center of gravity vector
- */
-Vector * molecule::DetermineCenterOfGravity()
+{
-  atom *ptr = start->next;  // start at first in list
-  Vector *a = new Vector();
-  Vector tmp;
-  double Num = 0;
-  a->Zero();
-  if (ptr != end) {   //list not empty?
-    while (ptr->next != end) {  // continue with second if present
-      ptr = ptr->next;
-      Num += ptr->type->mass;
-      tmp = ptr->type->mass * ptr->x;
-      (*a) += tmp;
+    }
-    a->Scale(-1./Num); // divide through total mass (and sign for direction)
+  }
 //  Log() << Verbose(1) << "Resulting center of gravity: ";
 …
 void molecule::Scale(const double ** const factor)
+{
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
       ptr->Trajectory.R.at(j).ScaleAll(*factor);
     ptr->x.ScaleAll(*factor);
+      (*iter)->Trajectory.R.at(j).ScaleAll(*factor);
+    (*iter)->x.ScaleAll(*factor);
+  }
 };
 …
 void molecule::Translate(const Vector *trans)
+{
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
       ptr->Trajectory.R.at(j) += (*trans);
     ptr->x += (*trans);
+      (*iter)->Trajectory.R.at(j) += (*trans);
+    (*iter)->x += (*trans);
+  }
 };
 …
   // go through all atoms
   ActOnAllVectors( &Vector::SubtractVector, *trans);
+  ActOnAllVectors( &Vector::AddVector, *trans);
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
 };
 …
 void molecule::Mirror(const Vector *n)
+{
+  OBSERVE;
   Plane p(*n,0);
+  // TODO: replace with simpler construct (e.g. Boost::foreach)
+  // once the structure of the atom list is fully reworked
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Walker->node) = p.mirrorVector(*Walker->node);
+  BOOST_FOREACH( atom* iter, atoms ){
+    (*iter->node) = p.mirrorVector(*iter->node);
+  }
 };
 …
 void molecule::DeterminePeriodicCenter(Vector &center)
+{
-  atom *Walker = start;
   double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
   double *inversematrix = InverseMatrix(cell_size);
+  double *inversematrix = InverseMatrix(matrix);
   double tmp;
   bool flag;
 …
     Center.Zero();
     flag = true;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
 #ifdef ADDHYDROGEN
       if (Walker->type->Z != 1) {
+      if ((*iter)->type->Z != 1) {
 #endif
         Testvector = Walker->x;
+        Testvector = (*iter)->x;
         Testvector.MatrixMultiplication(inversematrix);
         Translationvector.Zero();
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
          if (Walker->nr < (*Runner)->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+         if ((*iter)->nr < (*Runner)->GetOtherAtom((*iter))->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
               tmp = Walker->x[j] - (*Runner)->GetOtherAtom(Walker)->x[j];
+              tmp = (*iter)->x[j] - (*Runner)->GetOtherAtom(*iter)->x[j];
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
                 DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << Walker->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << (*iter)->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
                 if (tmp > 0)
                   Translationvector[j] -= 1.;
 …
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
           if ((*Runner)->GetOtherAtom(Walker)->type->Z == 1) {
             Testvector = (*Runner)->GetOtherAtom(Walker)->x;
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+          if ((*Runner)->GetOtherAtom((*iter))->type->Z == 1) {
+            Testvector = (*Runner)->GetOtherAtom((*iter))->x;
             Testvector.MatrixMultiplication(inversematrix);
             Testvector += Translationvector;
 …
+    }
   } while (!flag);
   Free(&matrix);
   Free(&inversematrix);
   Center.Scale(1./(double)AtomCount);
+  delete[](matrix);
+  delete[](inversematrix);
+  Center.Scale(1./static_cast<double>(getAtomCount()));
 };
 …
 void molecule::PrincipalAxisSystem(bool DoRotate)
+{
-  atom *ptr = start;  // start at first in list
   double InertiaTensor[NDIM*NDIM];
   Vector *CenterOfGravity = DetermineCenterOfGravity();
 …
   // sum up inertia tensor
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    Vector x = ptr->x;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    Vector x = (*iter)->x;
     //x.SubtractVector(CenterOfGravity);
     InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
     InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
     InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
     InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
     InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
     InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
     InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
     InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
     InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+    InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+    InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+    InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+    InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+    InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+    InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+    InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+    InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
+  }
   // print InertiaTensor for debugging
 …
     // sum up inertia tensor
+    ptr = start;
+    while (ptr->next != end) {
+      ptr = ptr->next;
+      Vector x = ptr->x;
+      //x.SubtractVector(CenterOfGravity);
+      InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
+      InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
+      InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
+      InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
+      InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
+      InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
+      InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
+      InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
+      InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      Vector x = (*iter)->x;
+      InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+      InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+      InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+      InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+      InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+      InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+      InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+      InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+      InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    }
     // print InertiaTensor for debugging
 …
 void molecule::Align(Vector *n)
+{
-  atom *ptr = start;
   double alpha, tmp;
   Vector z_axis;
 …
   alpha = atan(-n->at(0)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-X-angle: " << alpha << " ... ");
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x[0];
+    ptr->x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
+    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[0];
+    (*iter)->x[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = ptr->Trajectory.R.at(j)[0];
       ptr->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
       ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[0];
+      (*iter)->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
+    }
+  }
 …
   // rotate on z-y plane
-  ptr = start;
   alpha = atan(-n->at(1)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-Y-angle: " << alpha << " ... ");
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x[1];
+    ptr->x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
+    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[1];
+    (*iter)->x[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = ptr->Trajectory.R.at(j)[1];
       ptr->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
       ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[1];
+      (*iter)->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
+    }
+  }
 …
   Vector a,b,c,d;
   struct lsq_params *par = (struct lsq_params *)params;
-  atom *ptr = par->mol->start;
   // initialize vectors
 …
   b[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 = ptr->x - a;
+  for (molecule::const_iterator iter = par->mol->begin(); iter != par->mol->end(); ++iter) {
+    if ((*iter)->type == ((struct lsq_params *)params)->type) { // for specific type
+      c = (*iter)->x - a;
       t = c.ScalarProduct(b);           // get direction parameter
       d = t*b;       // and create vector

src/molecule_graph.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 #include "element.hpp"
 #include "helpers.hpp"
+#include "info.hpp"
 #include "linkedcell.hpp"
 #include "lists.hpp"
 …
 #include "World.hpp"
 #include "Helpers/fast_functions.hpp"
+#include "Helpers/Assert.hpp"
 struct BFSAccounting
 …
 void molecule::CreateAdjacencyListFromDbondFile(ifstream *input)
+{
+  Info FunctionInfo(__func__);
   // 1 We will parse bonds out of the dbond file created by tremolo.
   int atom1, atom2;
   atom *Walker, *OtherWalker;
+  if (!input) {
+    DoLog(1) && (Log() << Verbose(1) << "Opening silica failed \n");
+  char line[MAXSTRINGSIZE];
+  if (input->fail()) {
+    DoeLog(0) && (eLog() << Verbose(0) << "Opening of bond file failed \n");
+    performCriticalExit();
   };
+  *input >> ws >> atom1;
+  *input >> ws >> atom2;
+  DoLog(1) && (Log() << Verbose(1) << "Scanning file\n");
+  doCountAtoms();
+  // skip header
+  input->getline(line,MAXSTRINGSIZE);
+  DoLog(1) && (Log() << Verbose(1) << "Scanning file ... \n");
   while (!input->eof()) // Check whether we read everything already
+  {
+    *input >> ws >> atom1;
+    *input >> ws >> atom2;
+    input->getline(line,MAXSTRINGSIZE);
+    stringstream zeile(line);
+    zeile >> atom1;
+    zeile >> atom2;
+    DoLog(2) && (Log() << Verbose(2) << "Looking for atoms " << atom1 << " and " << atom2 << "." << endl);
     if (atom2 < atom1) //Sort indices of atoms in order
       flip(atom1, atom2);
     Walker = FindAtom(atom1);
+    ASSERT(Walker,"Could not find an atom with the ID given in dbond file");
     OtherWalker = FindAtom(atom2);
+    ASSERT(OtherWalker,"Could not find an atom with the ID given in dbond file");
     AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+  }
 …
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
-  atom **AtomMap = NULL;
   int n[NDIM];
   double MinDistance, MaxDistance;
 …
   DoLog(0) && (Log() << Verbose(0) << "Begin of CreateAdjacencyList." << endl);
   // remove every bond from the list
+  bond *Binder = NULL;
+  while (last->previous != first) {
+    Binder = last->previous;
+    Binder->leftatom->UnregisterBond(Binder);
+    Binder->rightatom->UnregisterBond(Binder);
+    removewithoutcheck(Binder);
+  }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        delete((*BondRunner));
   BondCount = 0;
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
+  CountAtoms();
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl);
+  if ((AtomCount > 1) && (bonddistance > 1.)) {
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << getAtomCount() << " and bonddistance is " << bonddistance << "." << endl);
+  if ((getAtomCount() > 1) && (bonddistance > 1.)) {
     DoLog(2) && (Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl);
     LC = new LinkedCell(this, bonddistance);
 …
     // create a list to map Tesselpoint::nr to atom *
     DoLog(2) && (Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl);
+    AtomMap = Calloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
     Walker = start;
     while (Walker->next != end) {
       Walker = Walker->next;
       AtomMap[Walker->nr] = Walker;
+    // set numbers for atoms that can later be used
+    int i=0;
+    for(internal_iterator iter = atoms.begin();iter!= atoms.end(); ++iter){
+      (*iter)->nr = i++;
+    }
 …
           if (List != NULL) {
             for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+              Walker = AtomMap[(*Runner)->nr];
+//              Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              Walker = dynamic_cast<atom*>(*Runner);
+              ASSERT(Walker,"Tesselpoint that was not an atom retrieved from LinkedNode");
+              //Log() << 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 (LinkedCell::LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
                         if ((*OtherRunner)->nr > Walker->nr) {
+                          OtherWalker = AtomMap[(*OtherRunner)->nr];
+//                          Log() << Verbose(0) << "Current other Atom is " << *OtherWalker << "." << endl;
+                          const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x, cell_size);
+//                          Log() << Verbose(1) << "Checking distance " << distance << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                          OtherWalker = dynamic_cast<atom*>(*OtherRunner);
+                          ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
+                          //Log() << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                           (BG->*minmaxdistance)(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
+                          const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x,cell_size);
                           const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
 //                          Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
 …
+          }
+        }
-    Free(&AtomMap);
     delete (LC);
     DoLog(1) && (Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl);
 …
     ActOnAllAtoms( &atom::OutputBondOfAtom );
   } else
     DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << getAtomCount() << ", thus no bonds, no connections!." << endl);
   DoLog(0) && (Log() << Verbose(0) << "End of CreateAdjacencyList." << endl);
   if (free_BG)
 …
+;
+/** Checks for presence of bonds within atom list.
+ * TODO: more sophisticated check for bond structure (e.g. connected subgraph, ...)
+ * \return true - bonds present, false - no bonds
+ */
+bool molecule::hasBondStructure()
+{
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    if (!(*AtomRunner)->ListOfBonds.empty())
+      return true;
+  return false;
+}
+/** Counts the number of present bonds.
+ * \return number of bonds
+ */
+unsigned int molecule::CountBonds() const
+{
+  unsigned int counter = 0;
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        counter++;
+  return counter;
+}
 /** Prints a list of all bonds to \a *out.
  * \param output stream
 …
+{
   DoLog(1) && (Log() << Verbose(1) << endl << "From contents of bond chain list:");
   bond *Binder = first;
   while (Binder->next != last) {
     Binder = Binder->next;
     DoLog(0) && (Log() << Verbose(0) << *Binder << "\t" << endl);
+  }
+  for(molecule::const_iterator AtomRunner = molecule::begin(); AtomRunner != molecule::end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        DoLog(0) && (Log() << Verbose(0) << *(*BondRunner) << "\t" << endl);
+      }
   DoLog(0) && (Log() << Verbose(0) << endl);
+}
 …
     DoLog(0) && (Log() << Verbose(0) << " done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << getAtomCount() << " atoms." << endl);
+  }
   DoLog(0) && (Log() << Verbose(0) << No << " bonds could not be corrected." << endl);
 …
   MoleculeLeafClass *Subgraphs = NULL;
   class StackClass<bond *> *BackEdgeStack = NULL;
+  bond *Binder = first;
+  if ((Binder->next != last) && (Binder->next->Type == Undetermined)) {
+    DoLog(0) && (Log() << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl);
+    Subgraphs = DepthFirstSearchAnalysis(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)
+      NoCyclicBonds++;
+  }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    if ((!(*AtomRunner)->ListOfBonds.empty()) && ((*(*AtomRunner)->ListOfBonds.begin())->Type == Undetermined)) {
+      DoLog(0) && (Log() << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl);
+      Subgraphs = DepthFirstSearchAnalysis(BackEdgeStack);
+      while (Subgraphs->next != NULL) {
+        Subgraphs = Subgraphs->next;
+        delete (Subgraphs->previous);
+      }
+      delete (Subgraphs);
+      delete[] (MinimumRingSize);
+      break;
+    }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        if ((*BondRunner)->Cyclic)
+          NoCyclicBonds++;
   delete (BackEdgeStack);
   return NoCyclicBonds;
 …
 void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
+{
   DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
+  DFS.AtomStack = new StackClass<atom *> (mol->getAtomCount());
   DFS.CurrentGraphNr = 0;
   DFS.ComponentNumber = 0;
 …
   bond *Binder = NULL;
   if (AtomCount == 0)
+  if (getAtomCount() == 0)
     return SubGraphs;
   DoLog(0) && (Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl);
   DepthFirstSearchAnalysis_Init(DFS, this);
   DFS.Root = start->next;
   while (DFS.Root != end) { // if there any atoms at all
+  for (molecule::const_iterator iter = begin(); iter != end();) {
+    DFS.Root = *iter;
     // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
     DFS.AtomStack->ClearStack();
 …
     // step on to next root
     while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
       //Log() << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
       if (DFS.Root->GraphNr != -1) // if already discovered, step on
         DFS.Root = DFS.Root->next;
+    while ((iter != end()) && ((*iter)->GraphNr != -1)) {
+      //Log() << Verbose(1) << "Current next subgraph root candidate is " << (*iter)->Name << "." << endl;
+      if ((*iter)->GraphNr != -1) // if already discovered, step on
+        iter++;
+    }
+  }
 …
+{
   NoCyclicBonds = 0;
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
+      Binder->Cyclic = true;
+      NoCyclicBonds++;
+    }
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        if ((*BondRunner)->rightatom->LowpointNr == (*BondRunner)->leftatom->LowpointNr) { // cyclic ??
+          (*BondRunner)->Cyclic = true;
+          NoCyclicBonds++;
+        }
+}
+;
 …
 void molecule::OutputGraphInfoPerBond() const
+{
+  bond *Binder = NULL;
   DoLog(1) && (Log() << Verbose(1) << "Final graph info for each bond is:" << endl);
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    DoLog(2) && (Log() << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <");
+    DoLog(0) && (Log() << Verbose(0) << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.");
+    Binder->leftatom->OutputComponentNumber();
+    DoLog(0) && (Log() << Verbose(0) << " ===  ");
+    DoLog(0) && (Log() << Verbose(0) << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.");
+    Binder->rightatom->OutputComponentNumber();
+    DoLog(0) && (Log() << Verbose(0) << ">." << endl);
+    if (Binder->Cyclic) // cyclic ??
+      DoLog(3) && (Log() << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl);
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        Binder = *BondRunner;
+        DoLog(2) && (Log() << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <");
+        DoLog(0) && (Log() << Verbose(0) << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.");
+        Binder->leftatom->OutputComponentNumber();
+        DoLog(0) && (Log() << Verbose(0) << " ===  ");
+        DoLog(0) && (Log() << Verbose(0) << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.");
+        Binder->rightatom->OutputComponentNumber();
+        DoLog(0) && (Log() << Verbose(0) << ">." << endl);
+        if (Binder->Cyclic) // cyclic ??
+          DoLog(3) && (Log() << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl);
+      }
+}
+;
 …
+{
   BFS.AtomCount = AtomCount;
   BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
   BFS.ShortestPathList = Malloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
   BFS.ColorList = Calloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.PredecessorList = new atom*[AtomCount];
+  BFS.ShortestPathList = new int[AtomCount];
+  BFS.ColorList = new enum Shading[AtomCount];
   BFS.BFSStack = new StackClass<atom *> (AtomCount);
   for (int i = AtomCount; i--;)
+  for (int i = AtomCount; i--;) {
     BFS.ShortestPathList[i] = -1;
+    BFS.PredecessorList[i] = 0;
+  }
 };
 …
 void FinalizeBFSAccounting(struct BFSAccounting &BFS)
+{
   Free(&BFS.PredecessorList);
   Free(&BFS.ShortestPathList);
   Free(&BFS.ColorList);
+  delete[](BFS.PredecessorList);
+  delete[](BFS.ShortestPathList);
+  delete[](BFS.ColorList);
   delete (BFS.BFSStack);
   BFS.AtomCount = 0;
 …
   if (MinRingSize != -1) { // if rings are present
     // go over all atoms
+    Root = mol->start;
+    while (Root->next != mol->end) {
+      Root = Root->next;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      Root = *iter;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
         //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
         CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
+        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->getAtomCount());
+      }
 …
   int MinRingSize = -1;
   InitializeBFSAccounting(BFS, AtomCount);
+  InitializeBFSAccounting(BFS, getAtomCount());
   //Log() << Verbose(1) << "Back edge list - ";
 …
 void molecule::ResetAllBondsToUnused() const
+{
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    Binder->ResetUsed();
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        (*BondRunner)->ResetUsed();
+}
+;
 …
     line << filename;
   AdjacencyFile.open(line.str().c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... ");
+  DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
   if (AdjacencyFile != NULL) {
     AdjacencyFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
     AdjacencyFile.close();
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line.str() << "." << endl);
     status = false;
+  }
 …
     line << filename;
   BondFile.open(line.str().c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... ");
+  DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
   if (BondFile != NULL) {
     BondFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputBonds, &BondFile);
     BondFile.close();
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line.str() << "." << endl);
     status = false;
+  }
 …
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
   File.open(filename.str().c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ");
+  DoLog(1) && (Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... " << endl);
   if (File == NULL)
     return false;
   // allocate storage structure
+  CurrentBonds = Calloc<int> (8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+  CurrentBonds = new int[8]; // contains parsed bonds of current atom
+  for(int i=0;i<8;i++)
+    CurrentBonds[i] = 0;
   return true;
+}
 …
   File.close();
   File.clear();
   Free(&CurrentBonds);
+  delete[](CurrentBonds);
+}
+;
 …
         NonMatchNumber++;
         status = false;
+        DoeLog(2) && (eLog() << Verbose(2) << id << " can not be found in list." << endl);
+      } else {
         //Log() << Verbose(0) << "[" << id << "]\t";
-      } else {
-        //Log() << Verbose(0) << id << "\t";
+      }
+    }
 …
   bool status = true;
   atom *Walker = NULL;
-  char *buffer = NULL;
   int *CurrentBonds = NULL;
   int NonMatchNumber = 0; // will number of atoms with differing bond structure
   size_t CurrentBondsOfAtom = -1;
+  const int AtomCount = getAtomCount();
   if (!CheckAdjacencyFileAgainstMolecule_Init(path, File, CurrentBonds)) {
 …
+  }
   buffer = Malloc<char> (MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  char buffer[MAXSTRINGSIZE];
   // Parse the file line by line and count the bonds
   while (!File.eof()) {
 …
       // compare against present bonds
       CheckAdjacencyFileAgainstMolecule_CompareBonds(status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
+    }
+  }
+  Free(&buffer);
+    } else {
+      if (AtomNr != -1)
+        DoeLog(2) && (eLog() << Verbose(2) << AtomNr << " is not valid in the range of ids [" << 0 << "," << AtomCount << ")." << endl);
+    }
+  }
   CheckAdjacencyFileAgainstMolecule_Finalize(File, CurrentBonds);
 …
   BFS.AtomCount = AtomCount;
   BFS.BondOrder = BondOrder;
   BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
   BFS.ShortestPathList = Calloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
   BFS.ColorList = Malloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.PredecessorList = new atom*[AtomCount];
+  BFS.ShortestPathList = new int[AtomCount];
+  BFS.ColorList = new enum Shading[AtomCount];
   BFS.BFSStack = new StackClass<atom *> (AtomCount);
 …
   // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
   for (int i = AtomCount; i--;) {
+    BFS.PredecessorList[i] = NULL;
     BFS.ShortestPathList[i] = -1;
     if ((AddedAtomList != NULL) && (AddedAtomList[i] != NULL)) // mark already present atoms (i.e. Root and maybe others) as visited
 …
       BFS.ColorList[i] = white;
+  }
   //BFS.ShortestPathList[Root->nr] = 0; //is set due to Calloc()
+  //BFS.ShortestPathList[Root->nr] = 0; // done by Calloc
+}
+;
 …
 void BreadthFirstSearchAdd_Free(struct BFSAccounting &BFS)
+{
   Free(&BFS.PredecessorList);
   Free(&BFS.ShortestPathList);
   Free(&BFS.ColorList);
+  delete[](BFS.PredecessorList);
+  delete[](BFS.ShortestPathList);
+  delete[](BFS.ColorList);
   delete (BFS.BFSStack);
   BFS.AtomCount = 0;
 …
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
   BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
+  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
   // and go on ... Queue always contains all lightgray vertices
 …
+{
   // reset parent list
+  ParentList = Calloc<atom*> (AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
+  ParentList = new atom*[AtomCount];
+  for (int i=0;i<AtomCount;i++)
+    ParentList[i] = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Resetting ParentList." << endl);
+}
 …
   // fill parent list with sons
   DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    ParentList[Walker->father->nr] = Walker;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    ParentList[(*iter)->father->nr] = (*iter);
     // Outputting List for debugging
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl);
+  }
+}
+;
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->nr] << "." << endl);
+  }
+};
 void BuildInducedSubgraph_Finalize(atom **&ParentList)
+{
   Free(&ParentList);
+  delete[](ParentList);
+}
+;
 …
+{
   bool status = true;
-  atom *Walker = NULL;
   atom *OtherAtom = NULL;
   // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
   DoLog(3) && (Log() << 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) {
+  for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
+    if (ParentList[(*iter)->nr] != NULL) {
+      if (ParentList[(*iter)->nr]->father != (*iter)) {
         status = false;
       } else {
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
           OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom((*iter));
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
             DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
             mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
+            mol->AddBond(ParentList[(*iter)->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+          }
+        }
 …
   bool status = true;
   atom **ParentList = NULL;
   DoLog(2) && (Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl);
   BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
+  BuildInducedSubgraph_Init(ParentList, Father->getAtomCount());
   BuildInducedSubgraph_FillParentList(this, Father, ParentList);
   status = BuildInducedSubgraph_CreateBondsFromParent(this, Father, ParentList);

src/molecule_pointcloud.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "config.hpp"
+#include "info.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
 …
 };
+/** Return current atom in the list.
+ * \return pointer to atom or NULL if none present
+/** PointCloud implementation of GoPoint
+ * Uses atoms and STL stuff.
  */
 TesselPoint *molecule::GetPoint() const
+TesselPoint* molecule::GetPoint() const
+{
+  if ((InternalPointer != start) && (InternalPointer != end))
+    return InternalPointer;
+  else
+    return NULL;
+  return (*InternalPointer);
 };
+/** Return pointer to one after last atom in the list.
+ * \return pointer to end marker
+ */
+TesselPoint *molecule::GetTerminalPoint() const
+{
+  return end;
+};
+/** Return the greatest index of all atoms in the list.
+ * \return greatest index
+ */
+int molecule::GetMaxId() const
+{
+  return last_atom;
+};
+/** Go to next atom.
+ * Stops at last one.
+/** PointCloud implementation of GoToNext.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToNext() const
+{
   if (InternalPointer != end)
     InternalPointer = InternalPointer->next;
+  if (InternalPointer != atoms.end())
+    InternalPointer++;
 };
+/** Go to previous atom.
+ * Stops at first one.
+ */
+void molecule::GoToPrevious() const
+{
+  if (InternalPointer->previous != start)
+    InternalPointer = InternalPointer->previous;
+};
+/** Goes to first atom.
+/** PointCloud implementation of GoToFirst.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToFirst() const
+{
   InternalPointer = start->next;
+  InternalPointer = atoms.begin();
 };
+/** Goes to last atom.
+ */
+void molecule::GoToLast() const
+{
+  InternalPointer = end->previous;
+};
+/** Checks whether we have any atoms in molecule.
+ * \return true - no atoms, false - not empty
+/** PointCloud implementation of IsEmpty.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEmpty() const
+{
   return (start->next == end);
+  return (empty());
 };
 /** Checks whether we are at the last atom
  * \return true - current atom is last one, false - is not last one
+/** PointCloud implementation of IsLast.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEnd() const
+{
   return (InternalPointer == end);
+  return (InternalPointer == atoms.end());
 };
+int molecule::GetMaxId() const {
+  return getAtomCount();
+}

src/molecule_template.hpp

-              r0c7ed8
+              r1dc9ec
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
+    {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
+  }
 };
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
+    {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
+  }
 };
 …
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&), T &t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 …
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u);
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u);
+  }
 };
 …
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u, v);
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u, v);
+  }
 };
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
+  }
   return result;
 …
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
+  }
 };
 …
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
+  }
 };
 …
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
+  }
 };
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
+  }
 };
 …
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
+  }
 };
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u);
+  }
 };
 template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v);
+  }
 };
 template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, w);
+  }
 };
 template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, w);
+  }
 };
 …
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
+{
-  atom *Walker = start;
   int inc = 1;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &inc);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &value);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], value);
+  }
 };
 …
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
+{
-  atom *Walker = start;
   int inc = 1;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &inc);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &value);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], value);
+  }
 };
 …
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
+  }
 };
 template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*value = array[(Walker->*index)];
+    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*value = array[((*iter)->*index)];
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
+  }
 };
 …
 template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*ptr = value;
+    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*ptr = value;
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
+  }
 };

src/moleculelist.cpp

-              r0c7ed8
+              r1dc9ec
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
 #include "memoryallocator.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
+#include "Helpers/Assert.hpp"
+#include "Helpers/Assert.hpp"
 /*********************************** Functions for class MoleculeListClass *************************/
 …
  */
 MoleculeListClass::MoleculeListClass(World *_world) :
+  Observable("MoleculeListClass"),
   world(_world)
+{
 …
 MoleculeListClass::~MoleculeListClass()
+{
+  DoLog(3) && (Log() << Verbose(3) << this << ": Freeing ListOfMolcules." << endl);
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+    DoLog(4) && (Log() << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl);
+    world->destroyMolecule(*ListRunner);
+  }
+  DoLog(4) && (Log() << Verbose(4) << "Freeing ListOfMolecules." << endl);
+  DoLog(4) && (Log() << Verbose(4) << "Clearing ListOfMolecules." << endl);
+  for(MoleculeList::iterator MolRunner = ListOfMolecules.begin(); MolRunner != ListOfMolecules.end(); ++MolRunner)
+    (*MolRunner)->signOff(this);
   ListOfMolecules.clear(); // empty list
 };
 …
 /** Insert a new molecule into the list and set its number.
  * \param *mol molecule to add to list.
- * \return true - add successful
  */
 void MoleculeListClass::insert(molecule *mol)
 …
 };
+/** Erases a molecule from the list.
+ * \param *mol molecule to add to list.
+ */
+void MoleculeListClass::erase(molecule *mol)
+{
+  OBSERVE;
+  mol->signOff(this);
+  ListOfMolecules.remove(mol);
+};
 /** Compare whether two molecules are equal.
  * \param *a molecule one
 …
   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
   //Log() << Verbose(0) << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
+  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
+  // Yes those types are awkward... but check it for yourself it checks out this way
+  molecule *const *mol1_ptr= static_cast<molecule *const *>(a);
+  molecule *mol1 = *mol1_ptr;
+  molecule *const *mol2_ptr= static_cast<molecule *const *>(b);
+  molecule *mol2 = *mol2_ptr;
+  if (mol1->getAtomCount() < mol2->getAtomCount()) {
     return -1;
   } else {
     if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
+    if (mol1->getAtomCount() > mol2->getAtomCount())
       return +1;
     else {
       Count = (**(molecule **) a).AtomCount;
+      Count = mol1->getAtomCount();
       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)
+      molecule::const_iterator aiter = mol1->begin();
+      molecule::const_iterator biter = mol2->begin();
+      for (;(aiter != mol1->end()) && (biter != mol2->end());
+          ++aiter, ++biter) {
+        if ((*aiter)->GetTrueFather() == NULL)
           aList[Counter] = Count + (aCounter++);
         else
           aList[Counter] = aWalker->GetTrueFather()->nr;
         if (bWalker->GetTrueFather() == NULL)
+          aList[Counter] = (*aiter)->GetTrueFather()->nr;
+        if ((*biter)->GetTrueFather() == NULL)
           bList[Counter] = Count + (bCounter++);
         else
           bList[Counter] = bWalker->GetTrueFather()->nr;
+          bList[Counter] = (*biter)->GetTrueFather()->nr;
         Counter++;
+      }
       // check if AtomCount was for real
       flag = 0;
       if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
+      if ((aiter == mol1->end()) && (biter != mol2->end())) {
         flag = -1;
       } else {
         if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
+        if ((aiter != mol1->end()) && (biter == mol2->end()))
           flag = 1;
+      }
 …
 void MoleculeListClass::Enumerate(ostream *out)
+{
-  atom *Walker = NULL;
   periodentafel *periode = World::getInstance().getPeriode();
   std::map<atomicNumber_t,unsigned int> counts;
 …
       // count atoms per element and determine size of bounding sphere
       size=0.;
+      Walker = (*ListRunner)->start;
+      while (Walker->next != (*ListRunner)->end) {
+        Walker = Walker->next;
+        counts[Walker->type->getNumber()]++;
+        if (Walker->x.DistanceSquared(Origin) > size)
+          size = Walker->x.DistanceSquared(Origin);
+      for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+        counts[(*iter)->type->getNumber()]++;
+        if ((*iter)->x.DistanceSquared(Origin) > size)
+          size = (*iter)->x.DistanceSquared(Origin);
+      }
       // output Index, Name, number of atoms, chemical formula
       (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->getAtomCount() << "\t";
       std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
 …
   // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    srcmol->UnlinkAtom(Walker);
+    mol->AddAtom(Walker);
+  molecule::iterator runner;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    runner = iter++;
+    srcmol->UnlinkAtom((*runner));
+    mol->AddAtom((*runner));
+  }
 …
   // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    Walker = mol->AddCopyAtom(Walker);
+  atom *Walker = NULL;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    Walker = mol->AddCopyAtom((*iter));
     Walker->father = Walker;
+  }
 …
   // prepare index list for bonds
+  srcmol->CountAtoms();
+  atom ** CopyAtoms = new atom*[srcmol->AtomCount];
+  for(int i=0;i<srcmol->AtomCount;i++)
+  atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
+  for(int i=0;i<srcmol->getAtomCount();i++)
     CopyAtoms[i] = NULL;
   // for each of the source atoms check whether we are in- or outside and add copy atom
-  atom *Walker = srcmol->start;
   int nr=0;
+  while (Walker->next != srcmol->end) {
+    Walker = Walker->next;
+    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl);
+    if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
+      CopyAtoms[Walker->nr] = Walker->clone();
+      mol->AddAtom(CopyAtoms[Walker->nr]);
+  for (molecule::const_iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << **iter << "." << endl);
+    if (!TesselStruct->IsInnerPoint((*iter)->x, LCList)) {
+      CopyAtoms[(*iter)->nr] = (*iter)->clone();
+      mol->AddAtom(CopyAtoms[(*iter)->nr]);
       nr++;
     } else {
 …
+    }
+  }
   DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->AtomCount << " atoms have been merged.");
+  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
   // go through all bonds and add as well
   bond *Binder = srcmol->first;
   while(Binder->next != srcmol->last) {
     Binder = Binder->next;
     DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl);
     mol->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+  }
+  for(molecule::iterator AtomRunner = srcmol->begin(); AtomRunner != srcmol->end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[(*BondRunner)->leftatom->nr] << " and " << *CopyAtoms[(*BondRunner)->rightatom->nr]<< "." << endl);
+        mol->AddBond(CopyAtoms[(*BondRunner)->leftatom->nr], CopyAtoms[(*BondRunner)->rightatom->nr], (*BondRunner)->BondDegree);
+      }
   delete(LCList);
   return true;
 …
 bool MoleculeListClass::AddHydrogenCorrection(char *path)
+{
-  atom *Walker = NULL;
-  atom *Runner = NULL;
   bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = NULL;
 …
   // 0b. allocate memory for constants
   FitConstant = Calloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  FitConstant = new double**[3];
   for (int k = 0; k < 3; k++) {
     FitConstant[k] = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    FitConstant[k] = new double*[a];
     for (int i = a; i--;) {
+      FitConstant[k][i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+      FitConstant[k][i] = new double[b];
+      for (int j = b; j--;) {
+        FitConstant[k][i][j] = 0.;
+      }
+    }
+  }
 …
   // 0d. allocate final correction matrix
   correction = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+  correction = new double*[a];
   for (int i = a; i--;)
     correction[i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+    correction[i] = new double[b];
   // 1a. go through every molecule in the list
 …
         correction[k][j] = 0.;
     // 2. take every hydrogen that is a saturated one
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
+      Walker = Walker->next;
+      //Log() << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
+      if ((Walker->type->Z == 1) && ((Walker->father == NULL)
+          || (Walker->father->type->Z != 1))) { // if it's a hydrogen
+        Runner = (*ListRunner)->start;
+        while (Runner->next != (*ListRunner)->end) {
+          Runner = Runner->next;
+          //Log() << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      //Log() << Verbose(1) << "(*iter): " << *(*iter) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
+      if (((*iter)->type->Z == 1) && (((*iter)->father == NULL)
+          || ((*iter)->father->type->Z != 1))) { // if it's a hydrogen
+        for (molecule::const_iterator runner = (*ListRunner)->begin(); runner != (*ListRunner)->end(); ++runner) {
+          //Log() << Verbose(2) << "Runner: " << *(*runner) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
           // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
           Binder = *(Runner->ListOfBonds.begin());
           if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (Binder->GetOtherAtom(Runner) != Binder->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
+          Binder = *((*runner)->ListOfBonds.begin());
+          if (((*runner)->type->Z == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
             distance = Runner->x.distance(Walker->x);
             //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
+            distance = (*runner)->x.distance((*iter)->x);
+            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *(*runner) << "<= " << distance << "=>" << *(*iter) << ":" << endl;
             for (int k = 0; k < a; k++) {
               for (int j = 0; j < b; j++) {
 …
     FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), (*ListRunner)->IndexNr);
     line += FragmentNumber;
     delete (FragmentNumber);
+    delete[] (FragmentNumber);
     line += HCORRECTIONSUFFIX;
     output.open(line.c_str());
 …
     output.close();
+  }
+  for (int i = a; i--;)
+    delete[](correction[i]);
+  delete[](correction);
   line = path;
   line.append("/");
 …
   for (int k = 0; k < 3; k++) {
     for (int i = a; i--;) {
       Free(&FitConstant[k][i]);
+    }
     Free(&FitConstant[k]);
+  }
   Free(&FitConstant);
+      delete[](FitConstant[k][i]);
+    }
+    delete[](FitConstant[k]);
+  }
+  delete[](FitConstant);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return true;
 …
   ofstream ForcesFile;
   stringstream line;
-  atom *Walker = NULL;
   periodentafel *periode=World::getInstance().getPeriode();
 …
       periodentafel::const_iterator elemIter;
       for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
+          if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
+          Walker = (*ListRunner)->start;
+          while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
+            Walker = Walker->next;
+            if (Walker->type->getNumber() == (*elemIter).first) {
+              if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
+        if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
+          for(molecule::iterator atomIter = (*ListRunner)->begin(); atomIter !=(*ListRunner)->end();++atomIter){
+            if ((*atomIter)->type->getNumber() == (*elemIter).first) {
+              if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
                 ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
+                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->nr] << "\t";
               } else
                 // otherwise a -1 to indicate an added saturation hydrogen
 …
  * \param *configuration standard configuration to attach atoms in fragment molecule to.
  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
- * \param DoPeriodic true - call ScanForPeriodicCorrection, false - don't
- * \param DoCentering true - call molecule::CenterEdge(), false - don't
  * \return true - success (each file was written), false - something went wrong.
  */
 …
   bool result = true;
   bool intermediateResult = true;
-  atom *Walker = NULL;
   Vector BoxDimension;
   char *FragmentNumber = NULL;
 …
     // list atoms in fragment for debugging
     DoLog(2) && (Log() << Verbose(2) << "Contained atoms: ");
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
+      Walker = Walker->next;
+      DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " ");
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      DoLog(0) && (Log() << Verbose(0) << (*iter)->getName() << " ");
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
     //outputFragment.close();
     //outputFragment.clear();
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
+  }
   DoLog(0) && (Log() << Verbose(0) << " done." << endl);
 …
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
+  // 0a. remove all present molecules
+  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
+    erase(*MolRunner);
+    World::getInstance().destroyMolecule(*MolRunner);
+  }
+  // 0b. remove all bonds and construct a molecule with all atoms
   molecule *mol = World::getInstance().createMolecule();
+  atom *Walker = NULL;
+  atom *Advancer = NULL;
+  bond *Binder = NULL;
+  bond *Stepper = NULL;
+  // 0. gather all atoms into single molecule
+  for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
+    // shift all atoms to new molecule
+    Advancer = (*MolRunner)->start->next;
+    while (Advancer != (*MolRunner)->end) {
+      Walker = Advancer;
+      Advancer = Advancer->next;
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      Walker->father = Walker;
+      mol->AddAtom(Walker);    // counting starts at 1
+    }
+    // remove all bonds
+    Stepper = (*MolRunner)->first->next;
+    while (Stepper != (*MolRunner)->last) {
+      Binder = Stepper;
+      Stepper = Stepper->next;
+      delete(Binder);
+    }
+    // remove the molecule
+    World::getInstance().destroyMolecule(*MolRunner);
+    ListOfMolecules.erase(MolRunner);
+  vector <atom *> allatoms = World::getInstance().getAllAtoms();
+  for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+      delete(*BondRunner);
+    mol->AddAtom(*AtomRunner);
+  }
 …
   const int MolCount = Subgraphs->next->Count();
   char number[MAXSTRINGSIZE];
+  molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
+  molecule **molecules = new molecule *[MolCount];
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
   for (int i=0;i<MolCount;i++) {
+    MolecularWalker = MolecularWalker->next;
     molecules[i] = World::getInstance().createMolecule();
     molecules[i]->ActiveFlag = true;
 …
       strncat(molecules[i]->name, number, MAXSTRINGSIZE - strlen(mol->name) - 1);
+    }
+    DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << endl);
+    DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << ", id is " << molecules[i]->getId() << endl);
+    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
+      DoLog(1) && (Log() << Verbose(1) << **iter << endl);
+    }
     insert(molecules[i]);
+  }
 …
   // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
   int FragmentCounter = 0;
+  int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
+  Walker = NULL;
+  map<int, atom *> AtomToFragmentMap;
+  MolecularWalker = Subgraphs;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
+    Walker = MolecularWalker->Leaf->start;
+    while (Walker->next != MolecularWalker->Leaf->end) {
+      Walker = Walker->next;
+      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
+    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); !MolecularWalker->Leaf->empty(); iter = MolecularWalker->Leaf->begin()) {
+      atom * Walker = *iter;
+      DoLog(1) && (Log() << Verbose(1) << "Re-linking " << Walker << "..." << endl);
+      MolecularWalker->Leaf->erase(iter);
+      molecules[FragmentCounter]->AddAtom(Walker);    // counting starts at 1
+    }
     FragmentCounter++;
+  }
+  // 4c. relocate atoms to new molecules and remove from Leafs
+  Walker = NULL;
+  while (mol->start->next != mol->end) {
+    Walker = mol->start->next;
+    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << *Walker << " is invalid!" << endl);
+      performCriticalExit();
+    }
+    FragmentCounter = MolMap[Walker->nr];
+    if (FragmentCounter != 0) {
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
+    } else {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << *Walker << " not associated to molecule!" << endl);
+      performCriticalExit();
+    }
+  }
+  World::getInstance().destroyMolecule(mol);
   // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
+  Binder = mol->first;
+  while (mol->first->next != mol->last) {
+    Binder = mol->first->next;
+    Walker = Binder->leftatom;
+    unlink(Binder);
+    link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
+  }
+  // TODO: check whether this is really not needed anymore
   // 4e. free Leafs
   MolecularWalker = Subgraphs;
 …
+  }
   delete(MolecularWalker);
+  Free(&MolMap);
+  Free(&molecules);
+  delete[](molecules);
   DoLog(1) && (Log() << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl);
 };
 …
 int MoleculeListClass::CountAllAtoms() const
+{
-  atom *Walker = NULL;
   int AtomNo = 0;
   for (MoleculeList::const_iterator MolWalker = ListOfMolecules.begin(); MolWalker != ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      AtomNo++;
+    }
+    AtomNo += (*MolWalker)->size();
+  }
   return AtomNo;
 …
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+{
-  atom *Walker = NULL;
   atom *OtherWalker = NULL;
   atom *Father = NULL;
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
     DoLog(1) && (Log() << Verbose(1) << "Creating adjacency list for subgraph " << Leaf << "." << endl);
     // remove every bond from the list
+    bond *Binder = NULL;
+    while (Leaf->last->previous != Leaf->first) {
+      Binder = Leaf->last->previous;
+      Binder->leftatom->UnregisterBond(Binder);
+      Binder->rightatom->UnregisterBond(Binder);
+      removewithoutcheck(Binder);
+    }
+    Walker = Leaf->start;
+    while (Walker->next != Leaf->end) {
+      Walker = Walker->next;
+      Father = Walker->GetTrueFather();
+    for(molecule::iterator AtomRunner = Leaf->begin(); AtomRunner != Leaf->end(); ++AtomRunner)
+      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+        if ((*BondRunner)->leftatom == *AtomRunner)
+          delete((*BondRunner));
+    for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+      Father = (*iter)->GetTrueFather();
       AtomNo = Father->nr; // global id of the current walker
       for (BondList::const_iterator Runner = Father->ListOfBonds.begin(); Runner != Father->ListOfBonds.end(); (++Runner)) {
         OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
           if (OtherWalker->nr > Walker->nr)
             Leaf->AddBond(Walker, OtherWalker, (*Runner)->BondDegree);
+          if (OtherWalker->nr > (*iter)->nr)
+            Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
         } else {
           DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
           status = false;
+        }
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
     Free(&ListOfLocalAtoms[FragmentCounter]);
+    delete[](ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
       Free(&ListOfLocalAtoms);
+      delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of FillBondStructureFromReference." << endl);
 …
 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
+{
   atom *Walker = NULL, *Father = NULL;
+  atom *Father = NULL;
   if (RootStack != NULL) {
 …
     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();
+      for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+        Father = (*iter)->GetTrueFather();
         if (AtomMask[Father->nr]) // apply mask
 #ifdef ADDHYDROGEN
           if (Walker->type->Z != 1) // skip hydrogen
+          if ((*iter)->type->Z != 1) // skip hydrogen
 #endif
           RootStack[FragmentCounter].push_front(Walker->nr);
+          RootStack[FragmentCounter].push_front((*iter)->nr);
+      }
       if (next != NULL)
 …
     // allocate and set each field to NULL
     const int Counter = Count();
+    ListOfLocalAtoms = Calloc<atom**>(Counter, "MoleculeLeafClass::FillListOfLocalAtoms - ***ListOfLocalAtoms");
+    ASSERT(FragmentCounter < Counter, "FillListOfLocalAtoms: FragmenCounter greater than present fragments.");
+    ListOfLocalAtoms = new atom**[Counter];
     if (ListOfLocalAtoms == NULL) {
       FreeList = FreeList && false;
       status = false;
+    }
+    for (int i=0;i<Counter;i++)
+      ListOfLocalAtoms[i] = NULL;
+  }
   if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
     status = status && CreateFatherLookupTable(Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     FreeList = FreeList && true;
+  }
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
   if (FragmentList == NULL) {
     KeySetCounter = Count();
+    FragmentList = Calloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+    FragmentList = new Graph*[KeySetCounter];
+    for (int i=0;i<KeySetCounter;i++)
+      FragmentList[i] = NULL;
     KeySetCounter = 0;
+  }
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
     Free(&ListOfLocalAtoms[FragmentCounter]);
+    delete[](ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
       Free(&ListOfLocalAtoms);
+      delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of AssignKeySetsToFragment." << endl);

src/parser.cpp

-              r0c7ed8
+              r1dc9ec
 // ======================================= INCLUDES ==========================================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
 MatrixContainer::MatrixContainer() {
   Indices = NULL;
   Header = Malloc<char*>(1, "MatrixContainer::MatrixContainer: **Header");
   Matrix = Malloc<double**>(1, "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
   RowCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *RowCounter");
   ColumnCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *ColumnCounter");
+  Header = new char*[1];
+  Matrix = new double**[1]; // one more each for the total molecule
+  RowCounter = new int[1];
+  ColumnCounter = new int[1];
   Header[0] = NULL;
   Matrix[0] = NULL;
 …
       if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
           for(int j=RowCounter[i]+1;j--;)
             Free(&Matrix[i][j]);
         Free(&Matrix[i]);
+            delete[](Matrix[i][j]);
+          delete[](Matrix[i]);
+      }
+    }
     if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
       for(int j=RowCounter[MatrixCounter]+1;j--;)
         Free(&Matrix[MatrixCounter][j]);
+        delete[](Matrix[MatrixCounter][j]);
     if (MatrixCounter != 0)
       Free(&Matrix[MatrixCounter]);
     Free(&Matrix);
+      delete[](Matrix[MatrixCounter]);
+    delete[](Matrix);
+  }
   if (Indices != NULL)
     for(int i=MatrixCounter+1;i--;) {
       Free(&Indices[i]);
+    }
   Free(&Indices);
+      delete[](Indices[i]);
+    }
+  delete[](Indices);
   if (Header != NULL)
     for(int i=MatrixCounter+1;i--;)
       Free(&Header[i]);
   Free(&Header);
   Free(&RowCounter);
   Free(&ColumnCounter);
+      delete[](Header[i]);
+  delete[](Header);
+  delete[](RowCounter);
+  delete[](ColumnCounter);
 };
 …
   if (Matrix == NULL) {
     DoLog(0) && (Log() << Verbose(0) << " with trivial mapping." << endl);
     Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = new int*[MatrixCounter + 1];
     for(int i=MatrixCounter+1;i--;) {
       Indices[i] = Malloc<int>(RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = new int[RowCounter[i]];
       for(int j=RowCounter[i];j--;)
         Indices[i][j] = j;
 …
     if (MatrixCounter != Matrix->MatrixCounter)
       return false;
     Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = new int*[MatrixCounter + 1];
     for(int i=MatrixCounter+1;i--;) {
       if (RowCounter[i] != Matrix->RowCounter[i])
         return false;
       Indices[i] = Malloc<int>(Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = new int[Matrix->RowCounter[i]];
       for(int j=Matrix->RowCounter[i];j--;) {
         Indices[i][j] = Matrix->Indices[i][j];
 …
   // parse header
   Header[MatrixNr] = Malloc<char>(1024, "MatrixContainer::ParseMatrix: *Header[]");
+  Header[MatrixNr] = new char[1024];
   for (int m=skiplines+1;m--;)
     input.getline(Header[MatrixNr], 1023);
 …
   // allocate matrix if it's not zero dimension in one direction
   if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
     Matrix[MatrixNr] = Malloc<double*>(RowCounter[MatrixNr] + 1, "MatrixContainer::ParseMatrix: **Matrix[]");
+    Matrix[MatrixNr] = new double*[RowCounter[MatrixNr] + 1];
     // parse in each entry for this matrix
 …
     strncpy(Header[MatrixNr], line.str().c_str(), 1023);
     for(int j=0;j<RowCounter[MatrixNr];j++) {
       Matrix[MatrixNr][j] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
+      Matrix[MatrixNr][j] = new double[ColumnCounter[MatrixNr]];
       input.getline(filename, 1023);
       stringstream lines(filename);
 …
         //Log() << Verbose(1) << " " << setprecision(2) << Matrix[MatrixNr][j][k] << endl;
+      }
       Matrix[MatrixNr][ RowCounter[MatrixNr] ] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
+      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = new double[ColumnCounter[MatrixNr]];
       for(int j=ColumnCounter[MatrixNr];j--;)
         Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl);
+  Header = ReAlloc<char*>(Header, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
+  Matrix = ReAlloc<double**>(Matrix, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = ReAlloc<int>(RowCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+  ColumnCounter = ReAlloc<int>(ColumnCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
+  delete[](Header);
+  delete[](Matrix);
+  delete[](RowCounter);
+  delete[](ColumnCounter);
+  Header = new char*[MatrixCounter + 1]; // one more each for the total molecule
+  Matrix = new double**[MatrixCounter + 1]; // one more each for the total molecule
+  RowCounter = new int[MatrixCounter + 1];
+  ColumnCounter = new int[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Matrix[i] = NULL;
 …
     if (!ParseMatrix(file.str().c_str(), skiplines, skipcolumns, i))
       return false;
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
+  }
   return true;
 …
+{
   MatrixCounter = MCounter;
   Header = Malloc<char*>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *Header");
   Matrix = Malloc<double**>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
   RowCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *RowCounter");
   ColumnCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *ColumnCounter");
+  Header = new char*[MatrixCounter + 1];
+  Matrix = new double**[MatrixCounter + 1]; // one more each for the total molecule
+  RowCounter = new int[MatrixCounter + 1];
+  ColumnCounter = new int[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Header[i] = Malloc<char>(1024, "MatrixContainer::AllocateMatrix: *Header[i]");
+    Header[i] = new char[1024];
     strncpy(Header[i], GivenHeader[i], 1023);
     RowCounter[i] = RCounter[i];
     ColumnCounter[i] = CCounter[i];
     Matrix[i] = Malloc<double*>(RowCounter[i] + 1, "MatrixContainer::AllocateMatrix: **Matrix[]");
+    Matrix[i] = new double*[RowCounter[i] + 1];
     for(int j=RowCounter[i]+1;j--;) {
       Matrix[i][j] = Malloc<double>(ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
+      Matrix[i][j] = new double[ColumnCounter[i]];
       for(int k=ColumnCounter[i];k--;)
         Matrix[i][j][k] = 0.;
 …
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     line << name << FRAGMENTPREFIX << FragmentNumber << "/" << prefix;
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     output.open(line.str().c_str(), ios::out);
     if (output == NULL) {
 …
+{
   DoLog(0) && (Log() << Verbose(0) << "Parsing energy indices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "EnergyMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Indices[i] = Malloc<int>(RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     for(int j=RowCounter[i];j--;)
       Indices[i][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global energysuffix file if present
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing force indices for " << MatrixCounter << " matrices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "ForceMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
 …
     line.str(filename);
     // parse the values
     Indices[i] = Malloc<int>(RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
 …
     //Log() << Verbose(0) << endl;
+  }
   Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = new int[RowCounter[MatrixCounter]];
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global forcesuffix file if present
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "HessianMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
 …
     line.str(filename);
     // parse the values
     Indices[i] = Malloc<int>(RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
 …
     //Log() << Verbose(0) << endl;
+  }
   Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = new int[RowCounter[MatrixCounter]];
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global forcesuffix file if present
 …
 KeySetsContainer::~KeySetsContainer() {
   for(int i=FragmentCounter;i--;)
     Free(&KeySets[i]);
+    delete[](KeySets[i]);
   for(int i=Order;i--;)
     Free(&OrderSet[i]);
   Free(&KeySets);
   Free(&OrderSet);
   Free(&AtomCounter);
   Free(&FragmentsPerOrder);
+    delete[](OrderSet[i]);
+  delete[](KeySets);
+  delete[](OrderSet);
+  delete[](AtomCounter);
+  delete[](FragmentsPerOrder);
 };
 …
   FragmentCounter = FCounter;
   DoLog(0) && (Log() << Verbose(0) << "Parsing key sets." << endl);
   KeySets = Malloc<int*>(FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
+  KeySets = new int*[FragmentCounter];
   for(int i=FragmentCounter;i--;)
     KeySets[i] = NULL;
 …
+  }
   AtomCounter = Malloc<int>(FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
+  AtomCounter = new int[FragmentCounter];
   for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
     stringstream line;
     AtomCounter[i] = ACounter[i];
     // parse the values
     KeySets[i] = Malloc<int>(AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
+    KeySets[i] = new int[AtomCounter[i]];
     for(int j=AtomCounter[i];j--;)
       KeySets[i][j] = -1;
     FragmentNumber = FixedDigitNumber(FragmentCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     input.getline(filename, 1023);
     line.str(filename);
 …
   // scan through all to determine fragments per order
   FragmentsPerOrder = Malloc<int>(Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
+  FragmentsPerOrder = new int[Order];
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;
 …
   // scan through all to gather indices to each order set
   OrderSet = Malloc<int*>(Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
+  OrderSet = new int*[Order];
   for(int i=Order;i--;)
     OrderSet[i] = Malloc<int>(FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
+    OrderSet[i] = new int[FragmentsPerOrder[i]];
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;

src/periodentafel.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 using namespace std;
 #include <iomanip>
+#include <iostream>
 #include <fstream>
 #include <cstring>
+#include <cassert>
+#include "Helpers/Assert.hpp"
 #include "element.hpp"
+#include "elements_db.hpp"
 #include "helpers.hpp"
 #include "lists.hpp"
 …
  */
 periodentafel::periodentafel()
+{};
+{
+  bool status = true;
+  status = LoadElementsDatabase(new stringstream(elementsDB,ios_base::in));
+  ASSERT(status,  "General element initialization failed");
+  status = LoadValenceDatabase(new stringstream(valenceDB,ios_base::in));
+  ASSERT(status, "Valence entry of element initialization failed");
+  status = LoadOrbitalsDatabase(new stringstream(orbitalsDB,ios_base::in));
+  ASSERT(status, "Orbitals entry of element initialization failed");
+  status = LoadHBondAngleDatabase(new stringstream(HbondangleDB,ios_base::in));
+  ASSERT(status, "HBond angle entry of element initialization failed");
+  status = LoadHBondLengthsDatabase(new stringstream(HbonddistanceDB,ios_base::in));
+  ASSERT(status, "HBond distance entry of element initialization failed");
+};
 /** destructor for class periodentafel
  * Removes every element and afterwards deletes start and end of list.
+ * TODO: Handle when elements have changed and store databases then
  */
 periodentafel::~periodentafel()
 …
 /** Adds element to period table list
  * \param *pointer element to be added
  * \return true - succeeded, false - does not occur
+ * \return iterator to added element
  */
 periodentafel::iterator periodentafel::AddElement(element * const pointer)
+{
   atomicNumber_t Z = pointer->getNumber();
   assert(!elements.count(Z));
+  ASSERT(!elements.count(Z), "Element is already present.");
   pointer->sort = &pointer->Z;
   if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
 …
 /** Removes element from list.
  * \param *pointer element to be removed
+ * \return true - succeeded, false - element not found
+ */
+void periodentafel::RemoveElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  elements.erase(Z);
+ */
+size_t periodentafel::RemoveElement(element * const pointer)
+{
+  return RemoveElement(pointer->getNumber());
+};
+/** Removes element from list.
+ * \param Z element to be removed
+ */
+size_t periodentafel::RemoveElement(atomicNumber_t Z)
+{
+  return elements.erase(Z);
 };
 /** Removes every element from the period table.
- * \return true - succeeded, false - does not occur
  */
 void periodentafel::CleanupPeriodtable()
 …
  * \return pointer to element or NULL if not found
  */
 const element * periodentafel::FindElement(atomicNumber_t Z) const
+element * const periodentafel::FindElement(atomicNumber_t Z) const
+{
   const_iterator res = elements.find(Z);
 …
  * \return pointer to element
  */
 const element * periodentafel::FindElement(const char * const shorthand) const
+element * const periodentafel::FindElement(const char * const shorthand) const
+{
   element *res = 0;
 …
 /** Asks for element number and returns pointer to element
+ */
+const element * periodentafel::AskElement() const
+{
+  const element *walker = NULL;
+ * \return desired element or NULL
+ */
+element * const periodentafel::AskElement() const
+{
+  element * walker = NULL;
   int Z;
   do {
 …
  * \return pointer to either present or newly created element
  */
+const element * periodentafel::EnterElement()
+{
+  const element *res = NULL;
+element * const periodentafel::EnterElement()
+{
   atomicNumber_t Z = 0;
   DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
   cin >> Z;
   res = FindElement(Z);
+  element * const res = FindElement(Z);
   if (!res) {
     // TODO: make this using the constructor
-    element *tmp;
     DoLog(0) && (Log() << Verbose(0) << "Element not found in database, please enter." << endl);
     tmp = new element;
+    element *tmp = new element;
     tmp->Z = Z;
     DoLog(0) && (Log() << Verbose(0) << "Mass: " << endl);
 …
     cin >> tmp->symbol;
     AddElement(tmp);
     res = tmp;
+    return tmp;
+  }
   return res;
 …
 bool periodentafel::LoadPeriodentafel(const char *path)
+{
+  ifstream infile;
+  element *ptr;
+  map<atomicNumber_t,element*> parsedElems;
+  ifstream input;
   bool status = true;
   bool otherstatus = true;
 …
   // fill elements DB
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDELEMENTSDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    infile.getline(header1, MAXSTRINGSIZE);
+    infile.getline(header2, MAXSTRINGSIZE); // skip first two header lines
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as elements database." << endl);
+  status = status && LoadElementsDatabase(&input);
+  input.close();
+  input.clear();
+  // fill valence DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDVALENCEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as valence database." << endl);
+  otherstatus = otherstatus && LoadValenceDatabase(&input);
+  input.close();
+  input.clear();
+  // fill orbitals DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as orbitals database." << endl);
+  otherstatus = otherstatus && LoadOrbitalsDatabase(&input);
+  input.close();
+  input.clear();
+  // fill H-BondAngle DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDANGLEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as H bond angle database." << endl);
+  otherstatus = otherstatus && LoadHBondAngleDatabase(&input);
+  input.close();
+  input.clear();
+  // fill H-BondDistance DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDDISTANCEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as H bond length database." << endl);
+  otherstatus = otherstatus && LoadHBondLengthsDatabase(&input);
+  input.close();
+  input.clear();
+  if (!otherstatus){
+    DoeLog(2) && (eLog()<< Verbose(2) << "Something went wrong while parsing the other databases!" << endl);
+  }
+  return status;
+};
+/** load the element info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadElementsDatabase(istream *input)
+{
+  bool status = true;
+  int counter = 0;
+  pair< std::map<atomicNumber_t,element*>::iterator, bool > InserterTest;
+  if (!(*input).fail()) {
+    (*input).getline(header1, MAXSTRINGSIZE);
+    (*input).getline(header2, MAXSTRINGSIZE); // skip first two header lines
     DoLog(0) && (Log() << Verbose(0) <<  "Parsed elements:");
     while (!infile.eof()) {
+    while (!(*input).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;
+      DoLog(0) && (Log() << Verbose(0) << " " << neues->symbol);
+      (*input) >> neues->name;
+      //(*input) >> ws;
+      (*input) >> neues->symbol;
+      //(*input) >> ws;
+      (*input) >> neues->period;
+      //(*input) >> ws;
+      (*input) >> neues->group;
+      //(*input) >> ws;
+      (*input) >> neues->block;
+      //(*input) >> ws;
+      (*input) >> neues->Z;
+      //(*input) >> ws;
+      (*input) >> neues->mass;
+      //(*input) >> ws;
+      (*input) >> neues->CovalentRadius;
+      //(*input) >> ws;
+      (*input) >> neues->VanDerWaalsRadius;
+      //(*input) >> ws;
+      (*input) >> ws;
       //neues->Output((ofstream *)&cout);
+      if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
+        parsedElems[neues->getNumber()] = neues;
+      else {
+        DoLog(0) && (Log() << Verbose(0) << "Could not parse element: ");
+        neues->Output((ofstream *)&cout);
+      if ((neues->getNumber() > 0) && (neues->getNumber() < MAX_ELEMENTS)) {
+        if (elements.count(neues->getNumber())) {// if element already present, remove and delete old one (i.e. replace it)
+          //cout << neues->symbol << " is present already." << endl;
+          element * const Elemental = FindElement(neues->getNumber());
+          ASSERT(Elemental != NULL, "element should be present but is not??");
+          *Elemental = *neues;
+        } else {
+          InserterTest = elements.insert(pair <atomicNumber_t,element*> (neues->getNumber(), neues));
+          ASSERT(InserterTest.second, "Could not insert new element into periodentafel on LoadElementsDatabase().");
+        }
+        DoLog(0) && (Log() << Verbose(0) << " " << elements[neues->getNumber()]->symbol);
+        counter++;
+      } else {
+        DoeLog(2) && (eLog() << Verbose(2) << "Detected empty line or invalid element in elements db, discarding." << endl);
+        DoLog(0) && (Log() << Verbose(0) << " <?>");
         delete(neues);
+      }
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
+    infile.close();
+    infile.clear();
+  } else
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Could not open the database." << endl);
     status = false;
+  // fill valence DB per element
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDVALENCEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+  }
+  if (counter == 0)
+    status = false;
+  return status;
+}
+/** load the valence info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadValenceDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->Valence;
+      infile >> ws;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->Valence;
+      (*input) >> ws;
       //Log() << 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
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDORBITALDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+    return true;
+  } else
+                return false;
+}
+/** load the orbitals info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadOrbitalsDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->NoValenceOrbitals;
+      infile >> ws;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->NoValenceOrbitals;
+      (*input) >> ws;
       //Log() << 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
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDHBONDDISTANCEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+    return true;
+  } else
+    return false;
+}
+/** load the hbond angles info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadHBondAngleDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
+      infile >> ws;
+      infile >> ptr->HBondDistance[0];
+      infile >> ptr->HBondDistance[1];
+      infile >> ptr->HBondDistance[2];
+      infile >> ws;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->HBondAngle[0];
+      (*input) >> elements[Z]->HBondAngle[1];
+      (*input) >> elements[Z]->HBondAngle[2];
+      (*input) >> ws;
+      //Log() << 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;
+    }
+    return true;
+  } else
+                return false;
+}
+/** load the hbond lengths info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadHBondLengthsDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
+      atomicNumber_t Z;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->HBondDistance[0];
+      (*input) >> elements[Z]->HBondDistance[1];
+      (*input) >> elements[Z]->HBondDistance[2];
+      (*input) >> ws;
       //Log() << 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
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDHBONDANGLEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
+      infile >> ws;
+      infile >> ptr->HBondAngle[0];
+      infile >> ptr->HBondAngle[1];
+      infile >> ptr->HBondAngle[2];
+      infile >> ws;
+      //Log() << 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){
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
+  else{
+    DoeLog(2) && (eLog()<< Verbose(2) << "Something went wrong while parsing the other databases!" << endl);
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
+  return status;
+};
+    return true;
+  } else
+                return false;
+}
 /** Stores element list to file.
 …
   char filename[MAXSTRINGSIZE];
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDELEMENTSDB);
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
   f.open(filename);
   if (f != NULL) {
 …
+    }
     f.close();
   } else
     result = false;
   return result;
 };
+    return true;
+  } else
+    return result;
+};

src/periodentafel.hpp

-              r0c7ed8
+              r1dc9ec
 #include <iterator>
+#include "unittests/periodentafelTest.hpp"
 #include "defs.hpp"
 #include "types.hpp"
 …
 class periodentafel {
   /******* Types *********/
+  friend class periodentafelTest;
   private:
     typedef std::map<atomicNumber_t,element*> elementSet;
 …
   iterator AddElement(element * const pointer);
+  void RemoveElement(element * const pointer);
+  size_t RemoveElement(element * const pointer);
+  size_t RemoveElement(atomicNumber_t);
   void CleanupPeriodtable();
   const element *FindElement(atomicNumber_t) const;
   const element *FindElement(const char * const shorthand) const;
   const element *AskElement() const;
   const element *EnterElement();
+  element * const FindElement(atomicNumber_t) const;
+  element * const FindElement(const char * const shorthand) const;
+  element * const AskElement() const;
+  element * const EnterElement();
   const_iterator begin();
 …
   private:
+  bool LoadElementsDatabase(std::istream *input);
+  bool LoadValenceDatabase(std::istream *input);
+  bool LoadOrbitalsDatabase(std::istream *input);
+  bool LoadHBondAngleDatabase(std::istream *input);
+  bool LoadHBondLengthsDatabase(std::istream *input);
     elementSet elements;
 };

src/stackclass.hpp

-              r0c7ed8
+              r1dc9ec
 template <typename T> StackClass<T>::StackClass(int dimension) : StackList(NULL), EntryCount(dimension), CurrentLastEntry(0), CurrentFirstEntry(0), NextFreeField(0)
+{
+  StackList = Calloc<T>(EntryCount, "StackClass::StackClass: **StackList");
+  StackList = new T[EntryCount];
+  for (int i=0;i<EntryCount;i++)
+    StackList[i] = NULL;
 };
 …
 template <typename T> StackClass<T>::~StackClass()
+{
   Free(&StackList);
+  delete[](StackList);
 };

src/tesselation.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <fstream>
 …
 #include "Plane.hpp"
 #include "Exceptions/LinearDependenceException.hpp"
+#include "Helpers/Assert.hpp"
 #include "Helpers/Assert.hpp"
 …
   // get ascending order of endpoints
   PointMap OrderMap;
   for (int i = 0; i < 3; i++)
+  for (int i = 0; i < 3; i++) {
     // for all three lines
     for (int j = 0; j < 2; j++) { // for both endpoints
 …
       // and we don't care whether insertion fails
+    }
+  }
   // set endpoints
   int Counter = 0;
 …
     Counter++;
+  }
+  if (Counter < 3) {
+    DoeLog(0) && (eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl);
+    performCriticalExit();
+  }
+}
+;
+  ASSERT(Counter >= 3,"We have a triangle with only two distinct endpoints!");
+};
 /** Destructor of BoundaryTriangleSet.
 …
+;
-/** PointCloud implementation of GetTerminalPoint.
- * Uses PointsOnBoundary and STL stuff.
- */
-TesselPoint * Tesselation::GetTerminalPoint() const
+{
-  Info FunctionInfo(__func__);
-  PointMap::const_iterator Runner = PointsOnBoundary.end();
-  Runner--;
-  return (Runner->second->node);
+}
+;
 /** PointCloud implementation of GoToNext.
  * Uses PointsOnBoundary and STL stuff.
 …
+;
-/** PointCloud implementation of GoToPrevious.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToPrevious() const
+{
-  Info FunctionInfo(__func__);
-  if (InternalPointer != PointsOnBoundary.begin())
-    InternalPointer--;
+}
+;
 /** PointCloud implementation of GoToFirst.
  * Uses PointsOnBoundary and STL stuff.
 …
   Info FunctionInfo(__func__);
   InternalPointer = PointsOnBoundary.begin();
+}
+;
-/** PointCloud implementation of GoToLast.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToLast() const
+{
-  Info FunctionInfo(__func__);
-  InternalPointer = PointsOnBoundary.end();
-  InternalPointer--;
+}
+;
 …
         RemoveTesselationLine(triangle->lines[i]);
       } else {
         DoLog(0) && (Log() << Verbose(0) << *triangle->lines[i] << " is still attached to another triangle: ");
+        DoLog(0) && (Log() << Verbose(0) << *triangle->lines[i] << " is still attached to another triangle: " << endl);
         OpenLines.insert(pair<BoundaryLineSet *, CandidateForTesselation *> (triangle->lines[i], NULL));
         for (TriangleMap::iterator TriangleRunner = triangle->lines[i]->triangles.begin(); TriangleRunner != triangle->lines[i]->triangles.end(); TriangleRunner++)
           DoLog(0) && (Log() << Verbose(0) << "[" << (TriangleRunner->second)->Nr << "|" << *((TriangleRunner->second)->endpoints[0]) << ", " << *((TriangleRunner->second)->endpoints[1]) << ", " << *((TriangleRunner->second)->endpoints[2]) << "] \t");
+          DoLog(0) && (Log() << Verbose(0) << "\t[" << (TriangleRunner->second)->Nr << "|" << *((TriangleRunner->second)->endpoints[0]) << ", " << *((TriangleRunner->second)->endpoints[1]) << ", " << *((TriangleRunner->second)->endpoints[2]) << "] \t");
         DoLog(0) && (Log() << Verbose(0) << endl);
         //        for (int j=0;j<2;j++) {
 …
   // fill the set of neighbours
   TesselPointSet SetOfNeighbours;
   SetOfNeighbours.insert(CandidateLine.BaseLine->endpoints[1]->node);
   for (TesselPointList::iterator Runner = CandidateLine.pointlist.begin(); Runner != CandidateLine.pointlist.end(); Runner++)
 …
   OldBaseLineNr = Base->Nr;
   m = 0;
+  for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++) {
+    DoLog(0) && (Log() << Verbose(0) << "INFO: Deleting triangle " << *(runner->second) << "." << endl);
+    OldTriangleNrs[m++] = runner->second->Nr;
+    RemoveTesselationTriangle(runner->second);
+  // first obtain all triangle to delete ... (otherwise we pull the carpet (Base) from under the for-loop's feet)
+  list <BoundaryTriangleSet *> TrianglesOfBase;
+  for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); ++runner)
+    TrianglesOfBase.push_back(runner->second);
+  // .. then delete each triangle (which deletes the line as well)
+  for (list <BoundaryTriangleSet *>::iterator runner = TrianglesOfBase.begin(); !TrianglesOfBase.empty(); runner = TrianglesOfBase.begin()) {
+    DoLog(0) && (Log() << Verbose(0) << "INFO: Deleting triangle " << *(*runner) << "." << endl);
+    OldTriangleNrs[m++] = (*runner)->Nr;
+    RemoveTesselationTriangle((*runner));
+    TrianglesOfBase.erase(runner);
+  }

src/tesselation.hpp

-              r0c7ed8
+              r1dc9ec
   virtual Vector *GetCenter() const { return NULL; };
   virtual TesselPoint *GetPoint() const { return NULL; };
-  virtual TesselPoint *GetTerminalPoint() const { return NULL; };
   virtual int GetMaxId() const { return 0; };
   virtual void GoToNext() const {};
-  virtual void GoToPrevious() const {};
   virtual void GoToFirst() const {};
-  virtual void GoToLast() const {};
   virtual bool IsEmpty() const { return true; };
   virtual bool IsEnd() const { return true; };
 …
     virtual Vector *GetCenter(ofstream *out) const;
     virtual TesselPoint *GetPoint() const;
-    virtual TesselPoint *GetTerminalPoint() const;
     virtual void GoToNext() const;
-    virtual void GoToPrevious() const;
     virtual void GoToFirst() const;
-    virtual void GoToLast() const;
     virtual bool IsEmpty() const;
     virtual bool IsEnd() const;

src/tesselationhelpers.cpp

-              r0c7ed8
+              r1dc9ec
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <fstream>
 …
       Walker = cloud->GetPoint();
       *rasterfile << "2" << endl << "  ";  // 2 is sphere type
+      for (i=0;i<NDIM;i++)
+        *rasterfile << Walker->node->at(i)-center->at(i) << " ";
+      for (int j=0;j<NDIM;j++) { // and for each node all NDIM coordinates
+        const double tmp = Walker->node->at(j)-center->at(j);
+        *rasterfile << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+      }
       *rasterfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
       cloud->GoToNext();
 …
       *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->node->at(j)-center->at(j) << " ";
+        for (int j=0;j<NDIM;j++) { // and for each node all NDIM coordinates
+          const double tmp = TriangleRunner->second->endpoints[i]->node->node->at(j)-center->at(j);
+          *rasterfile << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+        }
         *rasterfile << "\t";
+      }
 …
+    }
     *tecplot << "\", N=" << TesselStruct->PointsOnBoundary.size() << ", E=" << TesselStruct->TrianglesOnBoundary.size() << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
     int i=cloud->GetMaxId();
     int *LookupList = new int[i];
     for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++)
+    const int MaxId=cloud->GetMaxId();
+    int *LookupList = new int[MaxId];
+    for (int i=0; i< MaxId ; i++){
       LookupList[i] = -1;
+    }
     // print atom coordinates
     int Counter = 1;
     TesselPoint *Walker = NULL;
     for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); target++) {
+    for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); ++target) {
       Walker = target->second->node;
       LookupList[Walker->nr] = Counter++;
+      *tecplot << Walker->node->at(0) << " " << Walker->node->at(1) << " " << Walker->node->at(2) << " " << target->second->value << endl;
+      for (int i=0;i<NDIM;i++) {
+        const double tmp = Walker->node->at(i);
+        *tecplot << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+      }
+      *tecplot << target->second->value << endl;
+    }
     *tecplot << endl;

src/triangleintersectionlist.cpp

r0c7ed8	r1dc9ec
8	8	* Author: heber
9	9	*/
	10
	11	#include "Helpers/MemDebug.hpp"
10	12
11	13	#include "triangleintersectionlist.hpp"

src/unittests/ActOnAllUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
   // Ref was copy constructed, hence has to be cleaned, too!
   Ref.EmptyList();
-  MemoryUsageObserver::purgeInstance();
 };
 …
   // scaling by three values
   double *factors = Malloc<double>(NDIM, "ActOnAllTest::ScaleTest - factors");
   double *inverses = Malloc<double>(NDIM, "ActOnAllTest::ScaleTest - inverses");
+  double *factors = new double[NDIM];
+  double *inverses = new double[NDIM];
   for (int i=0;i<NDIM;++i) {
     factors[i] = 2.;
 …
   VL.ActOnAll<Vector,void,const double*>(&Vector::ScaleAll, inverses );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
   Free(factors);
   Free(inverses);
+  delete[](factors);
+  delete[](inverses);
 };

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
 #include "AnalysisCorrelationToPointUnitTest.hpp"
-#include "World.hpp"
 #include "atom.hpp"
-#include "boundary.hpp"
 #include "element.hpp"
 #include "molecule.hpp"
 #include "linkedcell.hpp"
 #include "periodentafel.hpp"
-#include "tesselation.hpp"
 #include "World.hpp"
 …
   TestList = NULL;
   TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   pointmap = NULL;
   binmap = NULL;
   point = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  // construct element list
+  std::vector<element *> elements;
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.push_back(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // init maps
   pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, (const element * const)hydrogen, (const Vector *)point );
+  pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, elements, (const Vector *)point );
   binmap = NULL;
 …
   delete(point);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

-              r0c7ed8
+              r1dc9ec
 class element;
-class LinkedCell;
 class molecule;
 class MoleculeListClass;
-class periodentafel;
-class Tesselation;
 class Vector;
 …
       molecule *TestMolecule;
       element *hydrogen;
-      periodentafel *tafel;
       CorrelationToPointMap *pointmap;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
-#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
 …
 #include "tesselation.hpp"
 #include "World.hpp"
+#include "Helpers/Assert.hpp"
 #include "Helpers/Assert.hpp"
 …
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
+{
   //ASSERT_DO(Assert::Throw);
+  ASSERT_DO(Assert::Throw);
   atom *Walker = NULL;
 …
   TestList = NULL;
   TestSurfaceMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   surfacemap = NULL;
   binmap = NULL;
 …
   LC = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 6;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  // prepare element list
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.clear();
   // construct molecule (tetraeder of hydrogens) base
   TestSurfaceMolecule = World::getInstance().createMolecule();
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 0., 1. );
+  TestSurfaceMolecule->AddAtom(Walker);
+  TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1., 1. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 1., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // add outer atoms
+  carbon = World::getInstance().getPeriode()->FindElement(6);
   TestSurfaceMolecule = World::getInstance().createMolecule();
   Walker = World::getInstance().createAtom();
 …
   *Walker->node = Vector(4., 0., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(0., 4., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(4., 4., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
   // add inner atoms
   Walker = World::getInstance().createAtom();
 …
   *Walker->node = Vector(0.5, 0.5, 0.5 );
   TestSurfaceMolecule->AddAtom(Walker);
   TestSurfaceMolecule->ActiveFlag = true;
   TestList->insert(TestSurfaceMolecule);
 …
   delete(LC);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };
 …
 void AnalysisCorrelationToSurfaceUnitTest::SurfaceTest()
+{
   CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->AtomCount );
+  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );
 …
+{
   // do the pair correlation
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   CPPUNIT_ASSERT( surfacemap != NULL );
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
   // put pair correlation into bins and check with no range
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, carbon, Surface, LC );
+  elements.push_back(carbon);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // put pair correlation into bins and check with no range
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, carbon, Surface, LC );
+  elements.push_back(carbon);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

r0c7ed8	r1dc9ec
47	47	element *hydrogen;
48	48	element *carbon;
49		~~periodentafel *tafel~~;
	49	std::vector<element *> elements;
50	50
51	51	CorrelationToSurfaceMap *surfacemap;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
   TestList = NULL;
   TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   correlationmap = NULL;
   binmap = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  // construct element list
+  std::vector<element *> elements;
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.push_back(hydrogen);
+  elements.push_back(hydrogen);
   // construct molecule (tetraeder of hydrogens)
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // init maps
   correlationmap = PairCorrelation( TestList, hydrogen, hydrogen );
+  correlationmap = PairCorrelation( TestList, elements);
   binmap = NULL;
 …
   // note that all the atoms are cleaned by TestMolecule
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
   errorLogger::purgeInstance();

src/unittests/AnalysisPairCorrelationUnitTest.hpp

-              r0c7ed8
+              r1dc9ec
 class element;
-class LinkedCell;
 class molecule;
 class MoleculeListClass;
-class periodentafel;
-class Tesselation;
 class Vector;
 …
       molecule *TestMolecule;
       element *hydrogen;
-      periodentafel *tafel;
       PairCorrelationMap *correlationmap;

src/unittests/CacheableTest.cpp

-              r0c7ed8
+              r1dc9ec
   threeNumbers(int _x,int _y, int _z) :
+    Observable("threeNumbers"),
     x(_x),y(_y),z(_z),
     sum(this,boost::bind(&threeNumbers::calcSum,this)),
+    sum(this,boost::bind(&threeNumbers::calcSum,this),"sum"),
     hasRecalced(false)
   {}
 …
   CPPUNIT_ASSERT_EQUAL( 9, *(numbers->sum));
   CPPUNIT_ASSERT_EQUAL( true, numbers->hasRecalced);
+  numbers->hasRecalced=false;
+  CPPUNIT_ASSERT_EQUAL( 9, *(numbers->sum));
+#ifndef NO_CACHING
+  CPPUNIT_ASSERT_EQUAL( false, numbers->hasRecalced);
+#else
+  CPPUNIT_ASSERT_EQUAL( true, numbers->hasRecalced);
+#endif
+}

src/unittests/CountBondsUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
 #include <stdio.h>
 #include <cstring>
+#include "Helpers/Assert.hpp"
 #include "analysis_bonds.hpp"
 …
+{
   atom *Walker = NULL;
-  BG = NULL;
-  filename = NULL;
-  // init private all pointers to zero
-  molecules = NULL;
-  TestMolecule1 = NULL;
-  TestMolecule2 = NULL;
-  hydrogen = NULL;
-  oxygen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  oxygen = new element;
+  oxygen->Z = 8;
+  oxygen->CovalentRadius = 0.68;
+  strcpy(oxygen->name, "oxygen");
+  strcpy(oxygen->symbol, "O");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(oxygen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  oxygen = World::getInstance().getPeriode()->FindElement(8);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(oxygen != NULL && "could not find element oxygen");
   // construct molecule (water molecule)
   TestMolecule1 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule1 != NULL && "could not create first molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(-0.2418, 0.9350, 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0.9658, 0., 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = oxygen;
   *Walker->node = Vector(0., 0., 0. );
 …
   TestMolecule2 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule2 != NULL && "could not create second molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(-0.2418, 0.9350, 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0.9658, 0., 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = oxygen;
   *Walker->node = Vector(0., 0., 0. );
 …
   molecules = World::getInstance().getMolecules();
+  CPPUNIT_ASSERT(molecules != NULL && "could not obtain list of molecules");
   molecules->insert(TestMolecule1);
   molecules->insert(TestMolecule2);
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule1->AtomCount, 3 );
+  Walker = TestMolecule1->start->next;
+  CPPUNIT_ASSERT( TestMolecule1->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule2->AtomCount, 3 );
+  Walker = TestMolecule2->start->next;
+  CPPUNIT_ASSERT( TestMolecule2->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule1->getAtomCount(), 3 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule2->getAtomCount(), 3 );
   // create a small file with table
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
   // construct bond graphs
 …
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
 };
 …
+{
   double *mirror = new double[3];
+  CPPUNIT_ASSERT(mirror != NULL && "could not create array of doubles");
   for (int i=0;i<3;i++)
     mirror[i] = -1.;

src/unittests/CountBondsUnitTest.hpp

-              r0c7ed8
+              r1dc9ec
       molecule *TestMolecule1;
       molecule *TestMolecule2;
+      element *hydrogen;
+      element *oxygen;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *oxygen;
       BondGraph *BG;

src/unittests/LinkedCellUnitTest.cpp

-              r0c7ed8
+              r1dc9ec
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
   // construct molecule (water molecule)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   for (double x=0.5;x<3;x+=1.)
     for (double y=0.5;y<3;y+=1.)
       for (double z=0.5;z<3;z+=1.) {
         Walker = World::getInstance().createAtom();
+        CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
         Walker->type = hydrogen;
         *Walker->node = Vector(x, y, z );
 …
   // construct linked cell
   LC = new LinkedCell (TestMolecule, 1.);
+  CPPUNIT_ASSERT(LC != NULL && "could not create LinkedCell");
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 3*3*3 );
+  Walker = TestMolecule->start->next;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 3*3*3 );
 };
 …
   delete(LC);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
 };
 …
+{
   // check all atoms
+  atom *Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(Walker) );
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end();++iter){
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(*iter) );
+  }
   // check internal vectors, returns false, because this atom is not in LC-list!
   Walker = World::getInstance().createAtom();
   Walker->setName("test");
   Walker->x= Vector(1,1,1);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   World::getInstance().destroyAtom(Walker);
+  atom *newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x= Vector(1,1,1);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
   // check out of bounds vectors
   Walker = World::getInstance().createAtom();
   Walker->setName("test");
   Walker->x = Vector(0,-1,0);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   World::getInstance().destroyAtom(Walker);
+  newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x = Vector(0,-1,0);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
 };
 …
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
+  Walker = TestMolecule->start;
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    ListOfPoints->remove((*iter));
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)8, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    if ((Walker->x[0] <2) && (Walker->x[1] <2) && (Walker->x[2] <2)) {
+      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    if (((*iter)->x[0] <2) && ((*iter)->x[1] <2) && ((*iter)->x[2] <2)) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    ListOfPoints->remove(*iter);
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)7, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    if ((Walker->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    if (((*iter)->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );

src/unittests/LinkedCellUnitTest.hpp

-              r0c7ed8
+              r1dc9ec
       molecule *TestMolecule;
+      element *hydrogen;
+      periodentafel *tafel;
+      const element *hydrogen;
       LinkedCell *LC;
 };

src/unittests/Makefile.am

-              r0c7ed8
+              r1dc9ec
+# PLEASE adhere to the alphabetical ordering in this Makefile!
+# Also indentation by a single tab
 INCLUDES = -I$(top_srcdir)/src
 …
   MemoryAllocatorUnitTest \
   MoleculeDescriptorTest \
+  ObserverTest \
+  ParserUnitTest \
+  periodentafelTest \
   PlaneUnittest \
-  ObserverTest \
   SingletonTest \
   StackClassUnitTest \
 …
   memoryusageobserverunittest.cpp \
   MoleculeDescriptorTest.cpp \
+  ObserverTest.cpp \
+  ParserUnitTest.cpp \
+  periodentafelTest.cpp \
   PlaneUnittest.cpp \
-  ObserverTest.cpp \
   SingletonTest.cpp \
   stackclassunittest.cpp \
 …
   memoryusageobserverunittest.hpp \
   MoleculeDescriptorTest.hpp \
+  periodentafelTest.hpp \
   PlaneUnittest.hpp \
   ObserverTest.hpp \
 …
+ActionSequenceTest_SOURCES = UnitTestMain.cpp ../../../TestRunnerClient.hpp ActionSequenceTest.cpp ActionSequenceTest.hpp
+ActionSequenceTest_LDADD = ${ALLLIBS}
 ActOnAllUnitTest_SOURCES = UnitTestMain.cpp ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
 ActOnAllUnitTest_LDADD = ${ALLLIBS}
 …
 atomsCalculationTest_LDADD = ${ALLLIBS}
+AtomDescriptorTest_SOURCES = UnitTestMain.cpp AtomDescriptorTest.cpp AtomDescriptorTest.hpp
+AtomDescriptorTest_LDADD = ${ALLLIBS}
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 BondGraphUnitTest_LDADD = ${ALLLIBS}
+CacheableTest_SOURCES = UnitTestMain.cpp CacheableTest.cpp CacheableTest.hpp
+CacheableTest_LDADD = ${ALLLIBS}
 CountBondsUnitTest_SOURCES = UnitTestMain.cpp CountBondsUnitTest.cpp CountBondsUnitTest.hpp
 CountBondsUnitTest_LDADD = ${ALLLIBS}
 …
 LogUnitTest_LDADD = ${ALLLIBS}
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
+manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp
+manipulateAtomsTest_LDADD = ${ALLLIBS}
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
 MemoryAllocatorUnitTest_LDADD = ${ALLLIBS}
 MemoryUsageObserverUnitTest_SOURCES = UnitTestMain.cpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
+MemoryUsageObserverUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
 MemoryUsageObserverUnitTest_LDADD = ${ALLLIBS}
 …
 MoleculeDescriptorTest_LDADD = ${ALLLIBS}
+ObserverTest_SOURCES = UnitTestMain.cpp ObserverTest.cpp ObserverTest.hpp
+ObserverTest_LDADD = ${ALLLIBS}
+ParserUnitTest_SOURCES = UnitTestMain.cpp ParserUnitTest.cpp ParserUnitTest.hpp
+ParserUnitTest_LDADD = ${ALLLIBS}
+periodentafelTest_SOURCES = UnitTestMain.cpp periodentafelTest.cpp periodentafelTest.hpp
+periodentafelTest_LDADD = ${ALLLIBS}
 PlaneUnittest_SOURCES = UnitTestMain.cpp PlaneUnittest.cpp PlaneUnittest.hpp
 PlaneUnittest_LDADD = ${ALLLIBS}
 …
 Tesselation_InOutsideUnitTest_LDADD = ${ALLLIBS}
+TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
+TestRunner_LDADD = ${ALLLIBS}
 VectorUnitTest_SOURCES = UnitTestMain.cpp vectorunittest.cpp vectorunittest.hpp
 VectorUnitTest_LDADD = ${ALLLIBS}
-ActionSequenceTest_SOURCES = UnitTestMain.cpp ../../../TestRunnerClient.hpp ActionSequenceTest.cpp ActionSequenceTest.hpp
-ActionSequenceTest_LDADD = ${ALLLIBS}
-ObserverTest_SOURCES = UnitTestMain.cpp ObserverTest.cpp ObserverTest.hpp
-ObserverTest_LDADD = ${ALLLIBS}
-CacheableTest_SOURCES = UnitTestMain.cpp CacheableTest.cpp CacheableTest.hpp
-CacheableTest_LDADD = ${ALLLIBS}
-AtomDescriptorTest_SOURCES = UnitTestMain.cpp AtomDescriptorTest.cpp AtomDescriptorTest.hpp
-AtomDescriptorTest_LDADD = ${ALLLIBS}
-manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp
-manipulateAtomsTest_LDADD = ${ALLLIBS}
-TestRunner_SOURCES = TestRunnerMain.cpp $(TESTSOURCES) $(TESTHEADERS)
-TestRunner_LDADD = ${ALLLIBS}
 #AUTOMAKE_OPTIONS = parallel-tests

src/unittests/ObserverTest.cpp

-              r0c7ed8
+              r1dc9ec
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <set>
 #include "Patterns/Observer.hpp"
+#include "Patterns/ObservedIterator.hpp"
 #include "Helpers/Assert.hpp"
 …
 public:
   UpdateCountObserver() :
+    Observer("UpdateCountObserver"),
     updates(0)
   {};
 …
 class SimpleObservable : public Observable {
 public:
+  SimpleObservable() :
+    Observable("SimpleObservable")
+  {}
   void changeMethod() {
     OBSERVE;
 …
 class CallObservable : public Observable {
 public:
+  CallObservable() :
+    Observable("CallObservable")
+  {}
   void changeMethod1() {
     OBSERVE;
 …
 class BlockObservable : public Observable {
 public:
+  BlockObservable() :
+    Observable("BlockObservable")
+  {}
   void changeMethod1(){
     OBSERVE;
 …
 class SuperObservable : public Observable {
 public:
+  SuperObservable(){
+  SuperObservable():
+    Observable("SuperObservable")
+  {
     subObservable = new SimpleObservable();
     subObservable->signOn(this);
 …
 public:
   NotificationObservable() :
+      notification1(new Notification(this)),
+      notification2(new Notification(this))
+    Observable("NotificationObservable"),
+    notification1(new Notification(this)),
+    notification2(new Notification(this))
   {}
 …
 public:
   NotificationObserver(Notification_ptr notification) :
+    Observer("NotificationObserver"),
     requestedNotification(notification),
     wasNotified(false)
 …
   bool wasNotified;
 };
+class ObservableCollection : public Observable {
+public:
+  typedef std::set<SimpleObservable*> set;
+  typedef ObservedIterator<set> iterator;
+  typedef set::const_iterator const_iterator;
+  ObservableCollection(int _num) :
+    Observable("ObservableCollection"),
+    num(_num)
+  {
+    for(int i=0; i<num; ++i){
+      SimpleObservable *content = new SimpleObservable();
+      content->signOn(this);
+      theSet.insert(content);
+    }
+  }
+  ~ObservableCollection(){
+    set::iterator iter;
+    for(iter=theSet.begin(); iter!=theSet.end(); ++iter ){
+      delete (*iter);
+    }
+  }
+  iterator begin(){
+    return iterator(theSet.begin(),this);
+  }
+  iterator end(){
+    return iterator(theSet.end(),this);
+  }
+  const int num;
+private:
+  set theSet;
+};
 /******************* actuall tests ***************/
 …
   blockObservable = new BlockObservable();
   notificationObservable = new NotificationObservable();
+  collection = new ObservableCollection(5);
   observer1 = new UpdateCountObserver();
 …
   notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
   notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
+}
 …
   delete blockObservable;
   delete notificationObservable;
+  delete collection;
   delete observer1;
 …
   blockObservable->changeMethod2();
   blockObservable->noChangeMethod();
+}
+void ObserverTest::iteratorTest(){
+  int i = 0;
+  // test the general iterator methods
+  for(ObservableCollection::iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i< collection->num);
+    i++;
+  }
+  i=0;
+  for(ObservableCollection::const_iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i<collection->num);
+    i++;
+  }
+  collection->signOn(observer1);
+  {
+    // we construct this out of the loop, so the iterator dies at the end of
+    // the scope and not the end of the loop (allows more testing)
+    ObservableCollection::iterator iter;
+    for(iter=collection->begin(); iter!=collection->end(); ++iter){
+      (*iter)->changeMethod();
+    }
+    // At this point no change should have been propagated
+    CPPUNIT_ASSERT_EQUAL( 0, observer1->updates);
+  }
+  // After the Iterator has died the propagation should take place
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  // when using a const_iterator no changes should be propagated
+  for(ObservableCollection::const_iterator iter = collection->begin(); iter!=collection->end();++iter);
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  collection->signOff(observer1);
+}

src/unittests/ObserverTest.hpp

-              r0c7ed8
+              r1dc9ec
 class CallObservable;
 class SuperObservable;
+class ObservableCollection;
 class BlockObservable;
 class NotificationObservable;
 class ObserverTest :  public CppUnit::TestFixture
 …
   CPPUNIT_TEST ( doesNotifyTest );
   CPPUNIT_TEST ( doesReportTest );
+  CPPUNIT_TEST ( iteratorTest );
   CPPUNIT_TEST ( CircleDetectionTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void doesNotifyTest();
   void doesReportTest();
+  void iteratorTest();
   void CircleDetectionTest();
 …
   SuperObservable *superObservable;
   NotificationObservable *notificationObservable;
+  ObservableCollection *collection;
 };

src/unittests/SingletonTest.cpp

r0c7ed8	r1dc9ec
52	52	count1++;
53	53	}
54		// explicit copy constructor to catch if thsi is ever called
	54	// explicit copy constructor to catch if this is ever called
55	55	SingletonStub2(const SingletonStub2&){
56	56	CPPUNIT_FAIL ( "Copy constructor of Singleton called" );

src/unittests/TestRunnerMain.cpp

-              r0c7ed8
+              r1dc9ec
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifdef HAVE_ECUT
 // give the main function its correct name
 #define CPPUNIT_MAIN main
 // include the TestRunnerClient file containing the main class
 #include "../../../TestRunnerClient.h"
 #include "../../../TestRunnerClient.cpp"
+#else
+#include "UnitTestMain.cpp"
+#endif

src/unittests/analysisbondsunittest.cpp

-              r0c7ed8
+              r1dc9ec
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   atom *Walker = NULL;
+  // init private all pointers to zero
+  TestMolecule = NULL;
+  hydrogen = NULL;
+  tafel = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->Valence = 1;
+  hydrogen->NoValenceOrbitals = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 2;
+  carbon->Valence = 4;
+  carbon->NoValenceOrbitals = 4;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  // get elements
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  carbon = World::getInstance().getPeriode()->FindElement(6);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(carbon != NULL && "could not find element carbon");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0.5, 0.5, 0.5 );
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 5 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 5 );
   // create a small file with table
   filename = new string("test.dat");
+  CPPUNIT_ASSERT(filename != NULL && "could not create string");
   ofstream test(filename->c_str());
+  test << ".\tH\tC\n";
+  test << "H\t1.\t1.2\n";
+  test << "C\t1.2\t1.5\n";
+  test << ".\tH\tHe\tLi\tBe\tB\tC\n";
+  test << "H\t1.\t1.\t1.\t1.\t1.\t1.2\n";
+  test << "He\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Li\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Be\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "B\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "C\t1.2\t1.\t1.\t1.\t1.\t1.5\n";
   test.close();
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( 1., BG->GetBondLength(0,0) );
   CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,1) );
   CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(1,1) );
+  CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,5) );
+  CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(5,5) );
   BG->ConstructBondGraph(TestMolecule);

src/unittests/analysisbondsunittest.hpp

-              r0c7ed8
+              r1dc9ec
       molecule *TestMolecule;
+      element *hydrogen;
+      element *carbon;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *carbon;
       BondGraph *BG;

src/unittests/bondgraphunittest.cpp

-              r0c7ed8
+              r1dc9ec
 #include <stdio.h>
 #include <cstring>
+#include "Helpers/Assert.hpp"
 #include "World.hpp"
 …
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  hydrogen->VanDerWaalsRadius = 1.09;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 2;
+  carbon->CovalentRadius = 0.68;
+  carbon->VanDerWaalsRadius = 1.7;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  carbon = World::getInstance().getPeriode()->FindElement(6);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(carbon != NULL && "could not find element carbon");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(1., 0., 1. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0., 1., 1. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(1., 1., 0. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0., 0., 0. );
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   // create a small file with table
   dummyname = new string("dummy.dat");
+  CPPUNIT_ASSERT(dummyname != NULL && "could not create string");
   filename = new string("test.dat");
+  CPPUNIT_ASSERT(filename != NULL && "could not create string");
   ofstream test(filename->c_str());
+  test << ".\tH\tC\n";
+  test << "H\t1.\t1.2\n";
+  test << "C\t1.2\t1.5\n";
+  test << ".\tH\tHe\tLi\tBe\tB\tC\n";
+  test << "H\t1.\t1.\t1.\t1.\t1.\t1.2\n";
+  test << "He\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Li\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Be\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "B\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "C\t1.2\t1.\t1.\t1.\t1.\t1.5\n";
   test.close();
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
 };
 …
   // are all cleaned when the world is destroyed
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
+};
+/** Tests whether setup worked.
+ */
+void BondGraphTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL (false, TestMolecule->empty());
+  CPPUNIT_ASSERT_EQUAL ((size_t)4, TestMolecule->size());
 };
 …
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( 1., BG->GetBondLength(0,0) );
   CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,1) );
   CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(1,1) );
+  CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,5) );
+  CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(5,5) );
 };
 …
 void BondGraphTest::ConstructGraphFromTableTest()
+{
   atom *Walker = TestMolecule->start->next;
   atom *Runner = TestMolecule->end->previous;
   CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  molecule::iterator Walker = TestMolecule->begin();
+  molecule::iterator Runner = TestMolecule->begin();
+  Runner++;
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
   CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  CPPUNIT_ASSERT_EQUAL( true , (*Walker)->IsBondedTo((*Runner)) );
 };
 …
 void BondGraphTest::ConstructGraphFromCovalentRadiiTest()
+{
+  atom *Walker = TestMolecule->start->next;
+  atom *Runner = TestMolecule->end->previous;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  //atom *Walker = TestMolecule->start->next;
+  //atom *Runner = TestMolecule->end->previous;
+  //CPPUNIT_ASSERT( TestMolecule->end != Walker );
   CPPUNIT_ASSERT_EQUAL( false , BG->LoadBondLengthTable(*dummyname) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
+  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  // this cannot be assured using dynamic IDs
+  //CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
 };

src/unittests/bondgraphunittest.hpp

-              r0c7ed8
+              r1dc9ec
+{
     CPPUNIT_TEST_SUITE( BondGraphTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( LoadTableTest );
     CPPUNIT_TEST ( ConstructGraphFromTableTest );
 …
       void setUp();
       void tearDown();
+      void SetupTest();
       void LoadTableTest();
       void ConstructGraphFromTableTest();
 …
       molecule *TestMolecule;
+      element *hydrogen;
+      element *carbon;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *carbon;
       BondGraph *BG;

src/unittests/listofbondsunittest.cpp

-              r0c7ed8
+              r1dc9ec
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 0., 0. );
 …
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 };
 …
   // are all cleaned when the world is destroyed
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };
+/** Tests whether setup worked correctly.
+ *
+ */
+void ListOfBondsTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->empty() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)4, TestMolecule->size() );
+};
 /** Unit Test of molecule::AddBond()
+ *
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  bond *TestBond = TestMolecule->first->next;
+  CPPUNIT_ASSERT_EQUAL ( TestBond, Binder );
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  CPPUNIT_ASSERT_EQUAL ( true, TestMolecule->hasBondStructure() );
   // check that bond contains the two atoms
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  atom *atom3 = atom2->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
+  iter++;
+  atom *atom3 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, Binder );
   CPPUNIT_ASSERT_EQUAL( Binder->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( true, TestMolecule->hasBondStructure() );
+  CPPUNIT_ASSERT_EQUAL( (unsigned int)1, TestMolecule->CountBonds() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
 void ListOfBondsTest::DeleteAtomTest()
+{
+  bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  atom *atom1 = NULL;
+  atom *atom2 = NULL;
+  bond *Binder = NULL;
+  {
+    molecule::iterator iter = TestMolecule->begin();
+    atom1 = *iter;
+    iter++;
+    atom2 = *iter;
+  }
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, atom1->ListOfBonds.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, atom2->ListOfBonds.size() );
+  CPPUNIT_ASSERT_EQUAL( true, TestMolecule->hasBondStructure() );
   // remove atom2
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
 };
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
+};

src/unittests/listofbondsunittest.hpp

-              r0c7ed8
+              r1dc9ec
+{
     CPPUNIT_TEST_SUITE( ListOfBondsTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( AddingBondTest );
     CPPUNIT_TEST ( RemovingBondTest );
 …
       void setUp();
       void tearDown();
+      void SetupTest();
       void AddingBondTest();
       void RemovingBondTest();
 …
       molecule *TestMolecule;
+      element *hydrogen;
+      periodentafel *tafel;
+      const element *hydrogen;
 };

src/unittests/manipulateAtomsTest.cpp

r0c7ed8	r1dc9ec
55	55	public:
56	56	countObserver() :
	57	Observer("countObserver"),
57	58	count(0)
58	59	{}

src/unittests/memoryallocatorunittest.cpp

r0c7ed8	r1dc9ec
12	12	#include "memoryallocator.hpp"
13	13	#include "memoryallocatorunittest.hpp"
	14	#include "memoryusageobserver.hpp"
14	15	#include "helpers.hpp"
15	16	#include "log.hpp"

src/unittests/stackclassunittest.cpp

r0c7ed8	r1dc9ec
37	37	Stack->ClearStack();
38	38	delete(Stack);
39		~~MemoryUsageObserver::purgeInstance();~~
40	39	logger::purgeInstance();
41	40	};

src/unittests/tesselation_boundarytriangleunittest.cpp

r0c7ed8	r1dc9ec
70	70	delete tesselpoints[i];
71	71	}
72		~~MemoryUsageObserver::purgeInstance();~~
73	72	logger::purgeInstance();
74	73	errorLogger::purgeInstance();

src/unittests/tesselation_insideoutsideunittest.cpp

r0c7ed8	r1dc9ec
134	134	}
135	135	Corners.clear();
136		~~MemoryUsageObserver::purgeInstance();~~
137	136	logger::purgeInstance();
138	137	errorLogger::purgeInstance();

src/unittests/tesselationunittest.cpp

r0c7ed8	r1dc9ec
106	106	}
107	107	Corners.clear();
108		~~MemoryUsageObserver::purgeInstance();~~
109	108	logger::purgeInstance();
110	109	errorLogger::purgeInstance();

src/unittests/vectorunittest.cpp

r0c7ed8	r1dc9ec
49	49	void VectorTest::tearDown()
50	50	{
51		~~MemoryUsageObserver::purgeInstance();~~
52	51	logger::purgeInstance();
53	52	errorLogger::purgeInstance();

src/vector.cpp

-              r0c7ed8
+              r1dc9ec
  */
+#include "Helpers/MemDebug.hpp"
 #include "vector.hpp"
 …
   // truncate to [0,1] for each axis
   for (int i=0;i<NDIM;i++) {
     at(i) += 0.5;  // set to center of box
+    //at(i) += 0.5;  // set to center of box
     while (at(i) >= 1.)
       at(i) -= 1.;

src/vector_ops.cpp

r0c7ed8	r1dc9ec
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "vector.hpp"

src/verbose.cpp

r0c7ed8	r1dc9ec
1	1	using namespace std;
	2
	3	#include "Helpers/MemDebug.hpp"
2	4
3	5	#include "info.hpp"

tests/Makefile.am

-              r0c7ed8
+              r1dc9ec
+AUTOM4TE = autom4te
+EXTRA_DIST = testsuite.at $(TESTSUITE) atlocal.in regression
+TESTSUITE = $(srcdir)/testsuite
+SUBDIRS = regression Tesselations
-SUBDIRS = Tesselations
-check-local: atconfig atlocal package.m4 $(TESTSUITE)
-                $(SHELL) '$(TESTSUITE)' $(TESTSUITEFLAGS)
-installcheck-local: atconfig atlocal $(TESTSUITE)
-                $(SHELL) '$(TESTSUITE)' AUTOTEST_PATH='$(bindir)' \
-                $(TESTSUITEFLAGS)
-clean-local:
-                test ! -f '$(TESTSUITE)' || \
-                $(SHELL) '$(TESTSUITE)' --clean
-AUTOTEST = $(AUTOM4TE) --language=autotest
-$(TESTSUITE): $(srcdir)/testsuite.at
-                $(AUTOTEST) -I '$(srcdir)' -o $@.tmp $@.at
-                mv $@.tmp $@
-# The `:;' works around a Bash 3.2 bug when the output is not writeable.
-$(srcdir)/package.m4: $(top_srcdir)/configure.ac
-                        :;{ \
-                                        echo '# Signature of the current package.' && \
-                                        echo 'm4_define([AT_PACKAGE_NAME],      [@PACKAGE_NAME@])' && \
-                                        echo 'm4_define([AT_PACKAGE_TARNAME],   [@PACKAGE_TARNAME@])' && \
-                                        echo 'm4_define([AT_PACKAGE_VERSION],   [@PACKAGE_VERSION@])' && \
-                                        echo 'm4_define([AT_PACKAGE_STRING],    [@PACKAGE_STRING@])' && \
-                                        echo 'm4_define([AT_PACKAGE_BUGREPORT], [@PACKAGE_BUGREPORT@])'; \
-                                } >'$(srcdir)/package.m4'

tests/Tesselations/defs.in

-              r0c7ed8
+              r1dc9ec
         CLEANUP="$CLEANUP; rm -rf $testdir"
         cp -r @srcdir@/$testdir/* $testdir/
-        cd $testdir
         CLEANUP="rm -f stderr stdout diffstderr diffstdout; cd ..; $CLEANUP"
         CLEANUP="rm -f *.conf*; rm -f NonConvexEnvelope*; rm -f ${testdir}.xyz; rm -f ${testdir}.dbond; $CLEANUP"
 …
         FILENAME="NonConvexEnvelope"
         exitcode=0
         cd $RADIUS
+        cd $testdir/$RADIUS
         #echo "Current dir is `pwd`, calling $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N $RADIUS $FILENAME."
         if [ -e $mol.dbond ]; then
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond -N $RADIUS $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         else
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N $RADIUS $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         fi
         #echo "Molecuilder done with exitcode $exitcode."
         #cat stderr
         #cat stdout
+        diff ${FILENAME}.dat ../@srcdir@/$mol/$2/${FILENAME}-$mol.dat 2>diffstderr >diffstdout || exitcode=$?
+        grep -E "^[0-9]* [0-9]* [0-9]*$" ../../../../../molecuilder/tests/Tesselations/$mol/$2/${FILENAME}-$mol.dat | sort -n >reference-triangles.dat
+        grep -E "^[0-9]* [0-9]* [0-9]*$" ${FILENAME}.dat | sort -n >new-triangles.dat
+        diff reference-triangles.dat new-triangles.dat 2>diffstderr >diffstdout || exitcode=$?
         #echo "Diff done with exitcode $exitcode."
         #cat diffstderr
         #cat diffstdout
         cd ..
+        cd ../..
         test $exitcode = $expected_exitcode || exit 1
+}

tests/regression/Tesselation/1/post/NonConvexEnvelope.r3d

r0c7ed8	r1dc9ec
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

tests/regression/Tesselation/2/post/ConvexEnvelope.r3d

r0c7ed8	r1dc9ec
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

tests/regression/Tesselation/2/post/NonConvexEnvelope.r3d

r0c7ed8	r1dc9ec
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

tests/regression/Tesselation/3/post/NonConvexEnvelope.dat

-              r0c7ed8
+              r1dc9ec
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
-.9077 1.1106 0.1214 1
 .3612 -3.628 1.323 1
 .4884 -3.5983 -0.4521 3
 …
 -6.8554 1.8134 -0.9499 1
 .1391 2.0447 0.0264 0
+.9077 1.1106 0.1214 1
 32 44
+32 35
+34 35
 32 35
 23 35
+17 35
+10 17
+8 10
+8 35
+4 35
+29 35
 34 35
+3 4
+4 29
+15 29
 28 29
 29 34
+7 15
+14 15
 15 28
 25 28
 28 37
 34 37
+34 37
 37 44
 26 37
 26 27
 27 33
 33 44
 37 44
 25 27
 27 30
+14 30
+24 30
 30 36
+36 39
 30 39
 30 39
 27 30
 18 30
 18 27
 27 33
 23 33
+7 24
+7 14
+11 24
 20 24
+24 41
 36 41
 41 42
 20 22
+11 22
+7 11
+5 7
 38 39
 38 42
 30 31
+31 39
 39 40
+18 31
+17 18
 18 23
+19 31
+13 19
 19 31
 21 31
 31 43
 40 43
+12 13
+10 12
+10 17
 13 21
 21 22
+12 22
+5 12
+3 5
+10 12
+21 22
+21 41
 41 43
 42 43
 32 33
 33 44
+42 43
 40 42
 39 40
+43 44
+34 44
+34 44
+31 34
+22 34
+16 34
+9 16
+7 9
+7 34
+3 34
+28 34
+33 34
+2 3
+3 28
+14 28
+27 28
+28 33
+6 14
+13 14
+14 27
+24 27
+27 36
+33 36
+36 44
+43 44
+25 36
+25 26
+26 32
+32 43
+36 43
+24 26
+26 29
+13 29
+23 29
+29 35
+35 38
+29 38
+29 38
+26 29
+17 29
+17 26
+26 32
+22 32
+6 23
+6 13
+10 23
+19 23
+23 40
+35 40
+40 41
+19 21
+10 21
+6 10
+4 6
+37 38
+37 41
+29 30
+30 38
+38 39
+17 30
+16 17
+17 22
+18 30
+12 18
+18 30
+20 30
+30 42
+39 42
+11 12
+9 11
+9 16
+12 20
+20 21
+11 21
+4 11
+2 4
+9 11
+20 21
+20 40
+40 42
+41 42
+31 32
+32 43
+41 42
+39 41
+38 39

tests/regression/Tesselation/3/post/NonConvexEnvelope.r3d

-              r0c7ed8
+              r1dc9ec
 # All atoms as spheres
 .952534 -3.05798 0.420171    0.1     1. 1. 1.
   -0.139866 -1.98848 0.359771   0.1     1. 1. 1.
 .0788342 -1.07508 -0.875229  0.1     1. 1. 1.
   -1.49147 -2.63828 0.0780712   0.1     1. 1. 1.
   -0.0588658 -1.09478 1.58347   0.1     1. 1. 1.
 .53473 -0.644479 -0.868129   0.1     1. 1. 1.
   -0.333166 -2.00128 -2.02443   0.1     1. 1. 1.
   -2.62147 -1.78218 0.653571    0.1     1. 1. 1.
   -1.60077 -2.70398 -1.46563    0.1     1. 1. 1.
 .37913 -0.560579 1.65607     0.1     1. 1. 1.
 .75933 0.205421 0.395371     0.1     1. 1. 1.
 .79893 0.246421 -2.08883     0.1     1. 1. 1.
   -2.64037 -0.423279 -0.0491288         0.1     1. 1. 1.
   -3.96017 -2.48928 0.432671    0.1     1. 1. 1.
 .23013 0.593821 0.484471     0.1     1. 1. 1.
 .14803 0.889821 -1.96833     0.1     1. 1. 1.
   -3.79507 0.418021 0.498371    0.1     1. 1. 1.
 .36023 1.76962 1.45487       0.1     1. 1. 1.
 .78273 1.01752 -0.849429     0.1     1. 1. 1.
 .07093 -0.563879 1.01767     0.1     1. 1. 1.
   -3.81397 1.77692 -0.204329    0.1     1. 1. 1.
 .17783 1.62112 -0.842829     0.1     1. 1. 1.
 .49863 -0.464179 0.482071    0.1     1. 1. 1.
   -4.96867 2.61822 0.343171     0.1     1. 1. 1.
 .93083 0.990421 0.337371     0.1     1. 1. 1.
   -4.98757 3.97722 -0.359529    0.1     1. 1. 1.
   -6.29237 1.89422 0.0890712    0.1     1. 1. 1.
 .33693 1.04442 0.0886712     0.1     1. 1. 1.
 .790434 -3.69418 1.29027     0.1     1. 1. 1.
 .917634 -3.66448 -0.484829   0.1     1. 1. 1.
 .92773 -2.57738 0.498071     0.1     1. 1. 1.
   -0.574266 -0.203779 -0.824729         0.1     1. 1. 1.
   -1.52417 -3.64138 0.503471    0.1     1. 1. 1.
   -0.759066 -0.265179 1.48487   0.1     1. 1. 1.
   -0.287266 -1.67078 2.48017    0.1     1. 1. 1.
 .19193 -1.51408 -0.867629    0.1     1. 1. 1.
   -0.573766 -1.42458 -2.91753   0.1     1. 1. 1.
 .450934 -2.72908 -2.23353    0.1     1. 1. 1.
   -2.45927 -1.63678 1.72157     0.1     1. 1. 1.
   -1.62867 -3.74268 -1.79493    0.1     1. 1. 1.
   -2.49667 -2.18078 -1.79993    0.1     1. 1. 1.
 .46453 0.112321 2.50927      0.1     1. 1. 1.
 .06173 -1.39848 1.79787      0.1     1. 1. 1.
 .15633 1.11082 0.326671      0.1     1. 1. 1.
 .76663 -0.360379 -2.99373    0.1     1. 1. 1.
 .03283 1.01972 -2.14533      0.1     1. 1. 1.
   -1.69727 0.0925205 0.131971   0.1     1. 1. 1.
   -2.77417 -0.570279 -1.12083   0.1     1. 1. 1.
   -4.75167 -1.93408 0.935971    0.1     1. 1. 1.
   -4.17327 -2.53828 -0.635229   0.1     1. 1. 1.
   -3.90927 -3.49908 0.839771    0.1     1. 1. 1.
 .62023 1.25552 -2.86813      0.1     1. 1. 1.
   -4.73807 -0.0977795 0.317371  0.1     1. 1. 1.
   -3.66127 0.565021 1.57007     0.1     1. 1. 1.
 .24233 1.41142 2.47757       0.1     1. 1. 1.
 .34293 2.22742 1.34117       0.1     1. 1. 1.
 .58823 2.50762 1.23707       0.1     1. 1. 1.
 .08983 -0.525479 2.10687     0.1     1. 1. 1.
 .62993 -1.50808 0.698371     0.1     1. 1. 1.
   -2.87097 2.29272 -0.0233288   0.1     1. 1. 1.
   -3.94777 1.63002 -1.27603     0.1     1. 1. 1.
 .68853 1.38852 -1.77723      0.1     1. 1. 1.
 .11553 2.70122 -0.710229     0.1     1. 1. 1.
 .17523 -0.969279 1.17127     0.1     1. 1. 1.
 .55043 -0.952879 -0.490929   0.1     1. 1. 1.
   -4.83487 2.76522 1.41487      0.1     1. 1. 1.
 .70193 1.54062 1.25007       0.1     1. 1. 1.
   -5.81017 4.57652 0.0304712    0.1     1. 1. 1.
   -4.04457 4.49292 -0.178529    0.1     1. 1. 1.
   -5.12137 3.83022 -1.43123     0.1     1. 1. 1.
   -6.27887 0.926121 0.589671    0.1     1. 1. 1.
   -7.11497 2.49352 0.479071     0.1     1. 1. 1.
   -6.42617 1.74722 -0.982629    0.1     1. 1. 1.
 .56833 1.97852 -0.00632877   0.1     1. 1. 1.
+.777562 -3.65286 1.28459     0.1     1. 1. 1.
+.904762 -3.62316 -0.490507   0.1     1. 1. 1.
+.91486 -2.53606 0.492393     0.1     1. 1. 1.
+  -0.587138 -0.162455 -0.830407         0.1     1. 1. 1.
+  -1.53704 -3.60006 0.497793    0.1     1. 1. 1.
+  -0.771938 -0.223855 1.47919   0.1     1. 1. 1.
+  -0.300138 -1.62946 2.47449    0.1     1. 1. 1.
+.17906 -1.47276 -0.873307    0.1     1. 1. 1.
+  -0.586638 -1.38326 -2.92321   0.1     1. 1. 1.
+.438062 -2.68776 -2.23921    0.1     1. 1. 1.
+  -2.47214 -1.59546 1.71589     0.1     1. 1. 1.
+  -1.64154 -3.70136 -1.80061    0.1     1. 1. 1.
+  -2.50954 -2.13946 -1.80561    0.1     1. 1. 1.
+.45166 0.153645 2.50359      0.1     1. 1. 1.
+.04886 -1.35716 1.79219      0.1     1. 1. 1.
+.14346 1.15214 0.320993      0.1     1. 1. 1.
+.75376 -0.319055 -2.99941    0.1     1. 1. 1.
+.01996 1.06104 -2.15101      0.1     1. 1. 1.
+  -1.71014 0.133845 0.126293    0.1     1. 1. 1.
+  -2.78704 -0.528955 -1.12651   0.1     1. 1. 1.
+  -4.76454 -1.89276 0.930293    0.1     1. 1. 1.
+  -4.18614 -2.49696 -0.640907   0.1     1. 1. 1.
+  -3.92214 -3.45776 0.834093    0.1     1. 1. 1.
+.60736 1.29684 -2.87381      0.1     1. 1. 1.
+  -4.75094 -0.0564554 0.311693  0.1     1. 1. 1.
+  -3.67414 0.606345 1.56439     0.1     1. 1. 1.
+.22946 1.45274 2.47189       0.1     1. 1. 1.
+.33006 2.26874 1.33549       0.1     1. 1. 1.
+.57536 2.54894 1.23139       0.1     1. 1. 1.
+.07696 -0.484155 2.10119     0.1     1. 1. 1.
+.61706 -1.46676 0.692693     0.1     1. 1. 1.
+  -2.88384 2.33404 -0.0290068   0.1     1. 1. 1.
+  -3.96064 1.67134 -1.28171     0.1     1. 1. 1.
+.67566 1.42984 -1.78291      0.1     1. 1. 1.
+.10266 2.74254 -0.715907     0.1     1. 1. 1.
+.16236 -0.927955 1.16559     0.1     1. 1. 1.
+.53756 -0.911555 -0.496607   0.1     1. 1. 1.
+  -4.84774 2.80654 1.40919      0.1     1. 1. 1.
+.68906 1.58194 1.24439       0.1     1. 1. 1.
+  -5.82304 4.61784 0.0247932    0.1     1. 1. 1.
+  -4.05744 4.53424 -0.184207    0.1     1. 1. 1.
+  -5.13424 3.87154 -1.43691     0.1     1. 1. 1.
+  -6.29174 0.967445 0.583993    0.1     1. 1. 1.
+  -7.12784 2.53484 0.473393     0.1     1. 1. 1.
+  -6.43904 1.78854 -0.988307    0.1     1. 1. 1.
+.55546 2.01984 -0.0120068    0.1     1. 1. 1.
+.939662 -3.01666 0.414493    0.1     1. 1. 1.
+  -0.152738 -1.94716 0.354093   0.1     1. 1. 1.
+.0659622 -1.03376 -0.880907  0.1     1. 1. 1.
+  -1.50434 -2.59696 0.0723932   0.1     1. 1. 1.
+  -0.0717378 -1.05346 1.57779   0.1     1. 1. 1.
+.52186 -0.603155 -0.873807   0.1     1. 1. 1.
+  -0.346038 -1.95996 -2.03011   0.1     1. 1. 1.
+  -2.63434 -1.74086 0.647893    0.1     1. 1. 1.
+  -1.61364 -2.66266 -1.47131    0.1     1. 1. 1.
+.36626 -0.519255 1.65039     0.1     1. 1. 1.
+.74646 0.246745 0.389693     0.1     1. 1. 1.
+.78606 0.287745 -2.09451     0.1     1. 1. 1.
+  -2.65324 -0.381955 -0.0548068         0.1     1. 1. 1.
+  -3.97304 -2.44796 0.426993    0.1     1. 1. 1.
+.21726 0.635145 0.478793     0.1     1. 1. 1.
+.13516 0.931145 -1.97401     0.1     1. 1. 1.
+  -3.80794 0.459345 0.492693    0.1     1. 1. 1.
+.34736 1.81094 1.44919       0.1     1. 1. 1.
+.76986 1.05884 -0.855107     0.1     1. 1. 1.
+.05806 -0.522555 1.01199     0.1     1. 1. 1.
+  -3.82684 1.81824 -0.210007    0.1     1. 1. 1.
+.16496 1.66244 -0.848507     0.1     1. 1. 1.
+.48576 -0.422855 0.476393    0.1     1. 1. 1.
+  -4.98154 2.65954 0.337493     0.1     1. 1. 1.
+.91796 1.03174 0.331693      0.1     1. 1. 1.
+  -5.00044 4.01854 -0.365207    0.1     1. 1. 1.
+  -6.30524 1.93554 0.0833932    0.1     1. 1. 1.
+.32406 1.08574 0.0829932     0.1     1. 1. 1.
 # All tesselation triangles
 …
   BACKFACE  0.3 0.3 1.0   0 0
 .33693 1.04442 0.0886712     5.68853 1.38852 -1.77723        7.56833 1.97852 -0.00632877     1. 0. 0.
 .33693 1.04442 0.0886712     5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
 .33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
 .62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
 .76663 -0.360379 -2.99373    3.62023 1.25552 -2.86813        5.55043 -0.952879 -0.490929     1. 0. 0.
 .19193 -1.51408 -0.867629    1.76663 -0.360379 -2.99373      5.55043 -0.952879 -0.490929     1. 0. 0.
 .19193 -1.51408 -0.867629    0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
 .917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      0.450934 -2.72908 -2.23353      1. 0. 0.
 .917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      5.55043 -0.952879 -0.490929     1. 0. 0.
 .917634 -3.66448 -0.484829   1.92773 -2.57738 0.498071       5.55043 -0.952879 -0.490929     1. 0. 0.
 .92773 -2.57738 0.498071     3.62993 -1.50808 0.698371       5.55043 -0.952879 -0.490929     1. 0. 0.
 .62993 -1.50808 0.698371     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
 .790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     1.92773 -2.57738 0.498071       1. 0. 0.
 .790434 -3.69418 1.29027     1.92773 -2.57738 0.498071       3.62993 -1.50808 0.698371       1. 0. 0.
 .790434 -3.69418 1.29027     2.06173 -1.39848 1.79787        3.62993 -1.50808 0.698371       1. 0. 0.
 .06173 -1.39848 1.79787      4.08983 -0.525479 2.10687       3.62993 -1.50808 0.698371       1. 0. 0.
 .08983 -0.525479 2.10687     3.62993 -1.50808 0.698371       6.17523 -0.969279 1.17127       1. 0. 0.
 .790434 -3.69418 1.29027     -0.287266 -1.67078 2.48017      2.06173 -1.39848 1.79787        1. 0. 0.
   -0.287266 -1.67078 2.48017    1.46453 0.112321 2.50927        2.06173 -1.39848 1.79787        1. 0. 0.
 .46453 0.112321 2.50927      2.06173 -1.39848 1.79787        4.08983 -0.525479 2.10687       1. 0. 0.
 .46453 0.112321 2.50927      3.24233 1.41142 2.47757         4.08983 -0.525479 2.10687       1. 0. 0.
 .24233 1.41142 2.47757       4.08983 -0.525479 2.10687       5.70193 1.54062 1.25007         1. 0. 0.
 .08983 -0.525479 2.10687     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
 .33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
 .33693 1.04442 0.0886712     5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
 .24233 1.41142 2.47757       4.34293 2.22742 1.34117         5.70193 1.54062 1.25007         1. 0. 0.
 .24233 1.41142 2.47757       4.34293 2.22742 1.34117         2.58823 2.50762 1.23707         1. 0. 0.
 .34293 2.22742 1.34117       2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
 .34293 2.22742 1.34117       5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
 .34293 2.22742 1.34117       5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
 .46453 0.112321 2.50927      3.24233 1.41142 2.47757         2.58823 2.50762 1.23707         1. 0. 0.
 .46453 0.112321 2.50927      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
   -0.759066 -0.265179 1.48487   1.46453 0.112321 2.50927        -2.87097 2.29272 -0.0233288     1. 0. 0.
   -0.759066 -0.265179 1.48487   -3.66127 0.565021 1.57007       -2.87097 2.29272 -0.0233288     1. 0. 0.
   -3.66127 0.565021 1.57007     -2.87097 2.29272 -0.0233288     -4.83487 2.76522 1.41487        1. 0. 0.
   -2.87097 2.29272 -0.0233288   -4.83487 2.76522 1.41487        -4.04457 4.49292 -0.178529      1. 0. 0.
 .58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
 .58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
 .15633 1.11082 0.326671      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
 .15633 1.11082 0.326671      1.03283 1.01972 -2.14533        -2.87097 2.29272 -0.0233288     1. 0. 0.
 .15633 1.11082 0.326671      1.03283 1.01972 -2.14533        2.58823 2.50762 1.23707         1. 0. 0.
 .03283 1.01972 -2.14533      2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
 .03283 1.01972 -2.14533      3.62023 1.25552 -2.86813        5.11553 2.70122 -0.710229       1. 0. 0.
   -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      -3.66127 0.565021 1.57007       1. 0. 0.
   -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      1.46453 0.112321 2.50927        1. 0. 0.
   -0.287266 -1.67078 2.48017    -2.45927 -1.63678 1.72157       -3.66127 0.565021 1.57007       1. 0. 0.
   -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.66127 0.565021 1.57007       1. 0. 0.
   -4.75167 -1.93408 0.935971    -3.66127 0.565021 1.57007       -6.27887 0.926121 0.589671      1. 0. 0.
   -3.66127 0.565021 1.57007     -4.83487 2.76522 1.41487        -6.27887 0.926121 0.589671      1. 0. 0.
   -4.83487 2.76522 1.41487      -6.27887 0.926121 0.589671      -7.11497 2.49352 0.479071       1. 0. 0.
   -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -2.45927 -1.63678 1.72157       -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -0.287266 -1.67078 2.48017      -2.45927 -1.63678 1.72157       1. 0. 0.
 .790434 -3.69418 1.29027     -1.52417 -3.64138 0.503471      -0.287266 -1.67078 2.48017      1. 0. 0.
   -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -4.04457 4.49292 -0.178529      1. 0. 0.
   -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -7.11497 2.49352 0.479071       1. 0. 0.
 .03283 1.01972 -2.14533      -2.87097 2.29272 -0.0233288     -3.94777 1.63002 -1.27603       1. 0. 0.
   -2.87097 2.29272 -0.0233288   -3.94777 1.63002 -1.27603       -4.04457 4.49292 -0.178529      1. 0. 0.
   -3.94777 1.63002 -1.27603     -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
   -0.573766 -1.42458 -2.91753   1.03283 1.01972 -2.14533        -3.94777 1.63002 -1.27603       1. 0. 0.
   -0.573766 -1.42458 -2.91753   1.76663 -0.360379 -2.99373      1.03283 1.01972 -2.14533        1. 0. 0.
 .76663 -0.360379 -2.99373    1.03283 1.01972 -2.14533        3.62023 1.25552 -2.86813        1. 0. 0.
   -0.573766 -1.42458 -2.91753   -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
   -0.573766 -1.42458 -2.91753   -2.49667 -2.18078 -1.79993      -2.77417 -0.570279 -1.12083     1. 0. 0.
   -2.49667 -2.18078 -1.79993    -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
   -2.49667 -2.18078 -1.79993    -4.17327 -2.53828 -0.635229     -3.94777 1.63002 -1.27603       1. 0. 0.
   -4.17327 -2.53828 -0.635229   -3.94777 1.63002 -1.27603       -6.42617 1.74722 -0.982629      1. 0. 0.
   -3.94777 1.63002 -1.27603     -5.12137 3.83022 -1.43123       -6.42617 1.74722 -0.982629      1. 0. 0.
   -0.573766 -1.42458 -2.91753   -1.62867 -3.74268 -1.79493      -2.49667 -2.18078 -1.79993      1. 0. 0.
   -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
   -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
   -1.62867 -3.74268 -1.79493    -2.49667 -2.18078 -1.79993      -4.17327 -2.53828 -0.635229     1. 0. 0.
   -1.62867 -3.74268 -1.79493    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -1.62867 -3.74268 -1.79493      -3.90927 -3.49908 0.839771      1. 0. 0.
 .917634 -3.66448 -0.484829   -1.52417 -3.64138 0.503471      -1.62867 -3.74268 -1.79493      1. 0. 0.
 .790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     -1.52417 -3.64138 0.503471      1. 0. 0.
 .917634 -3.66448 -0.484829   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
   -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
   -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -6.27887 0.926121 0.589671      1. 0. 0.
   -4.17327 -2.53828 -0.635229   -6.27887 0.926121 0.589671      -6.42617 1.74722 -0.982629      1. 0. 0.
   -6.27887 0.926121 0.589671    -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
 .62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.11553 2.70122 -0.710229       1. 0. 0.
 .68853 1.38852 -1.77723      5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
   -5.12137 3.83022 -1.43123     -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
   -5.81017 4.57652 0.0304712    -5.12137 3.83022 -1.43123       -7.11497 2.49352 0.479071       1. 0. 0.
   -5.81017 4.57652 0.0304712    -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
+.67566 1.42984 -1.78291      7.55546 2.01984 -0.0120068      7.32406 1.08574 0.0829932       1. 0. 0.
+.67566 1.42984 -1.78291      5.53756 -0.911555 -0.496607     7.32406 1.08574 0.0829932       1. 0. 0.
+.16236 -0.927955 1.16559     5.53756 -0.911555 -0.496607     7.32406 1.08574 0.0829932       1. 0. 0.
+.60736 1.29684 -2.87381      5.67566 1.42984 -1.78291        5.53756 -0.911555 -0.496607     1. 0. 0.
+.75376 -0.319055 -2.99941    3.60736 1.29684 -2.87381        5.53756 -0.911555 -0.496607     1. 0. 0.
+.17906 -1.47276 -0.873307    1.75376 -0.319055 -2.99941      5.53756 -0.911555 -0.496607     1. 0. 0.
+.17906 -1.47276 -0.873307    0.438062 -2.68776 -2.23921      1.75376 -0.319055 -2.99941      1. 0. 0.
+.904762 -3.62316 -0.490507   2.17906 -1.47276 -0.873307      0.438062 -2.68776 -2.23921      1. 0. 0.
+.904762 -3.62316 -0.490507   2.17906 -1.47276 -0.873307      5.53756 -0.911555 -0.496607     1. 0. 0.
+.904762 -3.62316 -0.490507   1.91486 -2.53606 0.492393       5.53756 -0.911555 -0.496607     1. 0. 0.
+.91486 -2.53606 0.492393     3.61706 -1.46676 0.692693       5.53756 -0.911555 -0.496607     1. 0. 0.
+.61706 -1.46676 0.692693     6.16236 -0.927955 1.16559       5.53756 -0.911555 -0.496607     1. 0. 0.
+.777562 -3.65286 1.28459     0.904762 -3.62316 -0.490507     1.91486 -2.53606 0.492393       1. 0. 0.
+.777562 -3.65286 1.28459     1.91486 -2.53606 0.492393       3.61706 -1.46676 0.692693       1. 0. 0.
+.777562 -3.65286 1.28459     2.04886 -1.35716 1.79219        3.61706 -1.46676 0.692693       1. 0. 0.
+.04886 -1.35716 1.79219      4.07696 -0.484155 2.10119       3.61706 -1.46676 0.692693       1. 0. 0.
+.07696 -0.484155 2.10119     3.61706 -1.46676 0.692693       6.16236 -0.927955 1.16559       1. 0. 0.
+.777562 -3.65286 1.28459     -0.300138 -1.62946 2.47449      2.04886 -1.35716 1.79219        1. 0. 0.
+  -0.300138 -1.62946 2.47449    1.45166 0.153645 2.50359        2.04886 -1.35716 1.79219        1. 0. 0.
+.45166 0.153645 2.50359      2.04886 -1.35716 1.79219        4.07696 -0.484155 2.10119       1. 0. 0.
+.45166 0.153645 2.50359      3.22946 1.45274 2.47189         4.07696 -0.484155 2.10119       1. 0. 0.
+.22946 1.45274 2.47189       4.07696 -0.484155 2.10119       5.68906 1.58194 1.24439         1. 0. 0.
+.07696 -0.484155 2.10119     6.16236 -0.927955 1.16559       5.68906 1.58194 1.24439         1. 0. 0.
+.16236 -0.927955 1.16559     5.68906 1.58194 1.24439         7.32406 1.08574 0.0829932       1. 0. 0.
+.68906 1.58194 1.24439       7.55546 2.01984 -0.0120068      7.32406 1.08574 0.0829932       1. 0. 0.
+.22946 1.45274 2.47189       4.33006 2.26874 1.33549         5.68906 1.58194 1.24439         1. 0. 0.
+.22946 1.45274 2.47189       4.33006 2.26874 1.33549         2.57536 2.54894 1.23139         1. 0. 0.
+.33006 2.26874 1.33549       2.57536 2.54894 1.23139         5.10266 2.74254 -0.715907       1. 0. 0.
+.33006 2.26874 1.33549       5.10266 2.74254 -0.715907       7.55546 2.01984 -0.0120068      1. 0. 0.
+.33006 2.26874 1.33549       5.68906 1.58194 1.24439         7.55546 2.01984 -0.0120068      1. 0. 0.
+.45166 0.153645 2.50359      3.22946 1.45274 2.47189         2.57536 2.54894 1.23139         1. 0. 0.
+.45166 0.153645 2.50359      2.57536 2.54894 1.23139         -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -0.771938 -0.223855 1.47919   1.45166 0.153645 2.50359        -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -0.771938 -0.223855 1.47919   -3.67414 0.606345 1.56439       -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -3.67414 0.606345 1.56439     -2.88384 2.33404 -0.0290068     -4.84774 2.80654 1.40919        1. 0. 0.
+  -2.88384 2.33404 -0.0290068   -4.84774 2.80654 1.40919        -4.05744 4.53424 -0.184207      1. 0. 0.
+.57536 2.54894 1.23139       -2.88384 2.33404 -0.0290068     -4.05744 4.53424 -0.184207      1. 0. 0.
+.57536 2.54894 1.23139       -2.88384 2.33404 -0.0290068     -4.05744 4.53424 -0.184207      1. 0. 0.
+.14346 1.15214 0.320993      2.57536 2.54894 1.23139         -2.88384 2.33404 -0.0290068     1. 0. 0.
+.14346 1.15214 0.320993      1.01996 1.06104 -2.15101        -2.88384 2.33404 -0.0290068     1. 0. 0.
+.14346 1.15214 0.320993      1.01996 1.06104 -2.15101        2.57536 2.54894 1.23139         1. 0. 0.
+.01996 1.06104 -2.15101      2.57536 2.54894 1.23139         5.10266 2.74254 -0.715907       1. 0. 0.
+.01996 1.06104 -2.15101      3.60736 1.29684 -2.87381        5.10266 2.74254 -0.715907       1. 0. 0.
+  -0.771938 -0.223855 1.47919   -0.300138 -1.62946 2.47449      -3.67414 0.606345 1.56439       1. 0. 0.
+  -0.771938 -0.223855 1.47919   -0.300138 -1.62946 2.47449      1.45166 0.153645 2.50359        1. 0. 0.
+  -0.300138 -1.62946 2.47449    -2.47214 -1.59546 1.71589       -3.67414 0.606345 1.56439       1. 0. 0.
+  -2.47214 -1.59546 1.71589     -4.76454 -1.89276 0.930293      -3.67414 0.606345 1.56439       1. 0. 0.
+  -4.76454 -1.89276 0.930293    -3.67414 0.606345 1.56439       -6.29174 0.967445 0.583993      1. 0. 0.
+  -3.67414 0.606345 1.56439     -4.84774 2.80654 1.40919        -6.29174 0.967445 0.583993      1. 0. 0.
+  -4.84774 2.80654 1.40919      -6.29174 0.967445 0.583993      -7.12784 2.53484 0.473393       1. 0. 0.
+  -2.47214 -1.59546 1.71589     -4.76454 -1.89276 0.930293      -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -2.47214 -1.59546 1.71589       -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -0.300138 -1.62946 2.47449      -2.47214 -1.59546 1.71589       1. 0. 0.
+.777562 -3.65286 1.28459     -1.53704 -3.60006 0.497793      -0.300138 -1.62946 2.47449      1. 0. 0.
+  -4.84774 2.80654 1.40919      -5.82304 4.61784 0.0247932      -4.05744 4.53424 -0.184207      1. 0. 0.
+  -4.84774 2.80654 1.40919      -5.82304 4.61784 0.0247932      -7.12784 2.53484 0.473393       1. 0. 0.
+.01996 1.06104 -2.15101      -2.88384 2.33404 -0.0290068     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -2.88384 2.33404 -0.0290068   -3.96064 1.67134 -1.28171       -4.05744 4.53424 -0.184207      1. 0. 0.
+  -3.96064 1.67134 -1.28171     -4.05744 4.53424 -0.184207      -5.13424 3.87154 -1.43691       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   1.01996 1.06104 -2.15101        -3.96064 1.67134 -1.28171       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   1.75376 -0.319055 -2.99941      1.01996 1.06104 -2.15101        1. 0. 0.
+.75376 -0.319055 -2.99941    1.01996 1.06104 -2.15101        3.60736 1.29684 -2.87381        1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -2.78704 -0.528955 -1.12651     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -2.50954 -2.13946 -1.80561      -2.78704 -0.528955 -1.12651     1. 0. 0.
+  -2.50954 -2.13946 -1.80561    -2.78704 -0.528955 -1.12651     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -2.50954 -2.13946 -1.80561    -4.18614 -2.49696 -0.640907     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -4.18614 -2.49696 -0.640907   -3.96064 1.67134 -1.28171       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -3.96064 1.67134 -1.28171     -5.13424 3.87154 -1.43691       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -1.64154 -3.70136 -1.80061      -2.50954 -2.13946 -1.80561      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   0.438062 -2.68776 -2.23921      -1.64154 -3.70136 -1.80061      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   0.438062 -2.68776 -2.23921      1.75376 -0.319055 -2.99941      1. 0. 0.
+  -1.64154 -3.70136 -1.80061    -2.50954 -2.13946 -1.80561      -4.18614 -2.49696 -0.640907     1. 0. 0.
+  -1.64154 -3.70136 -1.80061    -4.18614 -2.49696 -0.640907     -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -1.64154 -3.70136 -1.80061      -3.92214 -3.45776 0.834093      1. 0. 0.
+.904762 -3.62316 -0.490507   -1.53704 -3.60006 0.497793      -1.64154 -3.70136 -1.80061      1. 0. 0.
+.777562 -3.65286 1.28459     0.904762 -3.62316 -0.490507     -1.53704 -3.60006 0.497793      1. 0. 0.
+.904762 -3.62316 -0.490507   0.438062 -2.68776 -2.23921      -1.64154 -3.70136 -1.80061      1. 0. 0.
+  -4.76454 -1.89276 0.930293    -4.18614 -2.49696 -0.640907     -3.92214 -3.45776 0.834093      1. 0. 0.
+  -4.76454 -1.89276 0.930293    -4.18614 -2.49696 -0.640907     -6.29174 0.967445 0.583993      1. 0. 0.
+  -4.18614 -2.49696 -0.640907   -6.29174 0.967445 0.583993      -6.43904 1.78854 -0.988307      1. 0. 0.
+  -6.29174 0.967445 0.583993    -7.12784 2.53484 0.473393       -6.43904 1.78854 -0.988307      1. 0. 0.
+.60736 1.29684 -2.87381      5.67566 1.42984 -1.78291        5.10266 2.74254 -0.715907       1. 0. 0.
+.67566 1.42984 -1.78291      5.10266 2.74254 -0.715907       7.55546 2.01984 -0.0120068      1. 0. 0.
+  -5.13424 3.87154 -1.43691     -7.12784 2.53484 0.473393       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -5.82304 4.61784 0.0247932    -5.13424 3.87154 -1.43691       -7.12784 2.53484 0.473393       1. 0. 0.
+  -5.82304 4.61784 0.0247932    -4.05744 4.53424 -0.184207      -5.13424 3.87154 -1.43691       1. 0. 0.
 #  terminating special property
 …
 .0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0
   -4.99203 4.29989 -0.526429    5       1 0 0
+  -5.0049 4.34121 -0.532107     5       1 0 0
   terminating special property

Context Navigation

Changes in / [0c7ed8:1dc9ec]

Legend:

Download in other formats: