Diff [c695c94acd7f6fb7cff4a57d3acd27a99260ce7b:5f612eea044e919bffc18a83cd7ddd35f981c765] for / – MoleCuilder

Makefile.am

rc695c9	r5f612ee
3	3
4	4	EXTRA_DIST = autogen.sh
	5
	6	.PHONY: doc
	7	doc:
	8	cd doc && make doxygen-docs

configure.ac

-              rc695c9
+              r5f612ee
 # Boost libraries
 #AX_BOOST_BASE([1.33.1])
+AX_BOOST_BASE([1.33.1])
 #AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_FOREACH
 #AX_BOOST_FILESYSTEM
 #AX_BOOST_THREAD
+AX_BOOST_THREAD
 #AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_SERIALIZATION
 …
 fi
+# add replacement/saturation hydrogen or not
+AC_ARG_ENABLE([ecut],AS_HELP_STRING([--enable-ecut],[Use ECut TestRunnerClient (default is yes)]),
+              [enable_ecut=$enableval], [enable_ecut=yes])
+if test x"$enable_ecut" = xyes; then
+  AC_DEFINE(HAVE_ECUT,1, ["Use ECut TestRunnerClient instead of our own."])
+  AC_SUBST(HAVE_ECUT)
+fi
 # Check for "extern inline", using a modified version
 # of the test for AC_C_INLINE from acspecific.mt

doc/Doxyfile

-              rc695c9
+              r5f612ee
 EXCLUDE                =
 EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_PATTERNS       = */unittests/* \
+                                                 */test/*
 EXAMPLE_PATH           =
 EXAMPLE_PATTERNS       = *
 …
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
 SOURCE_BROWSER         = NO
 INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+STRIP_CODE_COMMENTS    = NO
 REFERENCED_BY_RELATION = NO
 REFERENCES_RELATION    = NO

src/Makefile.am

-              rc695c9
+              r5f612ee
 ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
+SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.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 tesselation.cpp tesselationhelpers.cpp triangleintersectionlist.cpp vector.cpp verbose.cpp World.cpp
+HEADER = ${ANALYSISHEADER} ${ATOMHEADER} bond.hpp bondgraph.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp errorlogger.hpp graph.hpp helpers.hpp info.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp log.hpp logger.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp triangleintersectionlist.cpp vector.hpp verbose.hpp World.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
+# all these files are only used for legacy reasons while the transition is in progress
+# they are only needed to keep the program usable at any point of the transition and will be
+# deleted once everything is fully refactored
+LEGACYSOURCE = Legacy/oldmenu.cpp
+LEGACYHEADER = Legacy/oldmenu.hpp
+DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp \
+                                   Descriptors/AtomIdDescriptor.cpp \
+                                   Descriptors/AtomTypeDescriptor.cpp \
+                                   Descriptors/MoleculeDescriptor.cpp \
+                                   Descriptors/MoleculeIdDescriptor.cpp
+DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
+                                   Descriptors/AtomIdDescriptor.hpp \
+                                   Descriptors/AtomTypeDescriptor.hpp \
+                                   Descriptors/MoleculeDescriptor.hpp \
+                                   Descriptors/MoleculeIdDescriptor.hpp
+SOURCE = ${ANALYSISSOURCE} \
+                 ${ATOMSOURCE} \
+                 ${PATTERNSOURCE} \
+                 ${UISOURCE} \
+                 ${DESCRIPTORSOURCE} \
+                 ${LEGACYSOURCE} \
+                 bond.cpp \
+                 bondgraph.cpp \
+                 boundary.cpp \
+                 config.cpp \
+                 element.cpp \
+                 ellipsoid.cpp \
+                 errorlogger.cpp \
+                 graph.cpp \
+                 helpers.cpp \
+                 Helpers/Assert.cpp \
+                 info.cpp \
+                 leastsquaremin.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 \
+                 tesselation.cpp \
+                 tesselationhelpers.cpp \
+                 triangleintersectionlist.cpp \
+                 vector.cpp \
+                 verbose.cpp \
+                 World.cpp
+HEADER = \
+  ${ANALYSISHEADER} \
+  ${ATOMHEADER} \
+  ${PATTERNHEADER} \
+  ${UIHEADER} \
+  ${DESCRIPTORHEADER} \
+  ${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 \
+  linkedcell.hpp \
+  lists.hpp \
+  log.hpp \
+  logger.hpp \
+  memoryallocator.hpp \
+  memoryusageobserver.hpp \
+  molecule.hpp \
+  molecule_template.hpp \
+  parser.hpp \
+  periodentafel.hpp \
+  stackclass.hpp \
+  tesselation.hpp \
+  tesselationhelpers.hpp \
+  triangleintersectionlist.hpp \
+  vector.hpp \
+  verbose.hpp \
+  World.hpp
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
 …
 libgslwrapper_a_SOURCES = ${LINALGSOURCE} ${LINALGHEADER}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_LDFLAGS = $(BOOST_LIB)
+molecuilder_LDFLAGS = $(BOOST_LDFLAGS)
 molecuilder_SOURCES = builder.cpp
 molecuilder_LDADD = libmolecuilder.a libgslwrapper.a
+molecuilder_LDADD = libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 joiner_SOURCES = joiner.cpp datacreator.cpp parser.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp
 joiner_LDADD = libmolecuilder.a
+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
+analyzer_LDADD = libmolecuilder.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 #EXTRA_DIST = ${molecuilder_DATA}

src/World.cpp

-              rc695c9
+              r5f612ee
 /*
  * world.cpp
+ * World.cpp
+ *
  *  Created on: Mar 3, 2010
+ *  Created on: Feb 3, 2010
  *      Author: crueger
  */
-#include <string.h>
-#include "defs.hpp"
 #include "World.hpp"
+double *World::cell_size = 0;
+char *World::DefaultName = 0;
+/** Constructor of World.
+ *
+ */
+World::World()
+#include "atom.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "Descriptors/AtomDescriptor.hpp"
+#include "Descriptors/AtomDescriptor_impl.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
+#include "Descriptors/MoleculeDescriptor_impl.hpp"
+#include "Descriptors/SelectiveIterator_impl.hpp"
+#include "Actions/ManipulateAtomsProcess.hpp"
+#include "Patterns/Singleton_impl.hpp"
+using namespace std;
+/******************************* getter and setter ************************/
+periodentafel *&World::getPeriode(){
+  return periode;
+}
+// Atoms
+atom* World::getAtom(AtomDescriptor descriptor){
+  return descriptor.find();
+}
+vector<atom*> World::getAllAtoms(AtomDescriptor descriptor){
+  return descriptor.findAll();
+}
+vector<atom*> World::getAllAtoms(){
+  return getAllAtoms(AllAtoms());
+}
+int World::numAtoms(){
+  return atoms.size();
+}
+// Molecules
+molecule *World::getMolecule(MoleculeDescriptor descriptor){
+  return descriptor.find();
+}
+std::vector<molecule*> World::getAllMolecules(MoleculeDescriptor descriptor){
+  return descriptor.findAll();
+}
+int World::numMolecules(){
+  return molecules_deprecated->ListOfMolecules.size();
+}
+// system
+double * World::getDomain() {
+  return cell_size;
+}
+void World::setDomain(double * matrix)
+{
+}
+char * World::getDefaultName() {
+  return defaultName;
+}
+void World::setDefaultName(char * name)
+{
+  delete[](defaultName);
+  const int length = strlen(name);
+  defaultName = new char[length+2];
+  if (length < MAXSTRINGSIZE)
+    strncpy(defaultName, name, length);
+  else
+    strcpy(defaultName, "none");
+};
+/******************** Methods to change World state *********************/
+molecule* World::createMolecule(){
+  OBSERVE;
+  molecule *mol = NULL;
+  mol = NewMolecule();
+  assert(!molecules.count(currMoleculeId));
+  mol->setId(currMoleculeId++);
+  // store the molecule by ID
+  molecules[mol->getId()] = mol;
+  mol->signOn(this);
+  return mol;
+}
+void World::destroyMolecule(molecule* mol){
+  OBSERVE;
+  destroyMolecule(mol->getId());
+}
+void World::destroyMolecule(moleculeId_t id){
+  OBSERVE;
+  molecule *mol = molecules[id];
+  assert(mol);
+  DeleteMolecule(mol);
+  molecules.erase(id);
+}
+double *World::cell_size = NULL;
+char *World::defaultName = NULL;
+atom *World::createAtom(){
+  OBSERVE;
+  atomId_t id = getNextAtomId();
+  atom *res = NewAtom(id);
+  res->setWorld(this);
+  // store the atom by ID
+  atoms[res->getId()] = res;
+  return res;
+}
+int World::registerAtom(atom *atom){
+  OBSERVE;
+  atomId_t id = getNextAtomId();
+  atom->setId(id);
+  atom->setWorld(this);
+  atoms[atom->getId()] = atom;
+  return atom->getId();
+}
+void World::destroyAtom(atom* atom){
+  OBSERVE;
+  int id = atom->getId();
+  destroyAtom(id);
+}
+void World::destroyAtom(atomId_t id) {
+  OBSERVE;
+  atom *atom = atoms[id];
+  assert(atom);
+  DeleteAtom(atom);
+  atoms.erase(id);
+  releaseAtomId(id);
+}
+bool World::changeAtomId(atomId_t oldId, atomId_t newId, atom* target){
+  OBSERVE;
+  // in case this call did not originate from inside the atom, we redirect it,
+  // to also let it know that it has changed
+  if(!target){
+    target = atoms[oldId];
+    assert(target && "Atom with that ID not found");
+    return target->changeId(newId);
+  }
+  else{
+    if(reserveAtomId(newId)){
+      atoms.erase(oldId);
+      atoms.insert(pair<atomId_t,atom*>(newId,target));
+      return true;
+    }
+    else{
+      return false;
+    }
+  }
+}
+ManipulateAtomsProcess* World::manipulateAtoms(boost::function<void(atom*)> op,std::string name,AtomDescriptor descr){
+  return new ManipulateAtomsProcess(op, descr,name,true);
+}
+ManipulateAtomsProcess* World::manipulateAtoms(boost::function<void(atom*)> op,std::string name){
+  return manipulateAtoms(op,name,AllAtoms());
+}
+/********************* Internal Change methods for double Callback and Observer mechanism ********/
+void World::doManipulate(ManipulateAtomsProcess *proc){
+  proc->signOn(this);
+  {
+    OBSERVE;
+    proc->doManipulate(this);
+  }
+  proc->signOff(this);
+}
+/******************************* IDManagement *****************************/
+// Atoms
+atomId_t World::getNextAtomId(){
+  // see if we can reuse some Id
+  if(atomIdPool.empty()){
+    return currAtomId++;
+  }
+  else{
+    // we give out the first ID from the pool
+    atomId_t id = *(atomIdPool.begin());
+    atomIdPool.erase(id);
+    return id;
+  }
+}
+void World::releaseAtomId(atomId_t id){
+  atomIdPool.insert(id);
+  // defragmentation of the pool
+  set<atomId_t>::reverse_iterator iter;
+  // go through all Ids in the pool that lie immediately below the border
+  while(!atomIdPool.empty() && *(atomIdPool.rbegin())==(currAtomId-1)){
+    atomIdPool.erase(--currAtomId);
+  }
+}
+bool World::reserveAtomId(atomId_t id){
+  if(id>=currAtomId ){
+    // add all ids between the new one and current border as available
+    for(atomId_t pos=currAtomId; pos<id; ++pos){
+      atomIdPool.insert(pos);
+    }
+    currAtomId=id+1;
+    return true;
+  }
+  else if(atomIdPool.count(id)){
+    atomIdPool.erase(id);
+    return true;
+  }
+  else{
+    // this ID could not be reserved
+    return false;
+  }
+}
+// Molecules
+/******************************* Iterators ********************************/
+// Build the AtomIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet,AtomDescriptor);
+World::AtomIterator World::getAtomIter(AtomDescriptor descr){
+  return AtomIterator(descr,atoms);
+}
+World::AtomIterator World::atomEnd(){
+  return AtomIterator(AllAtoms(),atoms,atoms.end());
+}
+// build the MoleculeIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet,MoleculeDescriptor);
+World::MoleculeIterator World::getMoleculeIter(MoleculeDescriptor descr){
+  return MoleculeIterator(descr,molecules);
+}
+World::MoleculeIterator World::moleculeEnd(){
+  return MoleculeIterator(AllMolecules(),molecules,molecules.end());
+}
+/******************************* Singleton Stuff **************************/
+World::World() :
+    periode(new periodentafel),
+    atoms(),
+    currAtomId(0),
+    molecules(),
+    currMoleculeId(0),
+    molecules_deprecated(new MoleculeListClass(this))
+{
   cell_size = new double[6];
 …
   cell_size[4] = 0.;
   cell_size[5] = 20.;
+  DefaultName = new char[MAXSTRINGSIZE];
+  strcpy(DefaultName, "none");
+};
+/** Destructor of World.
+ *
+ */
+  defaultName = new char[MAXSTRINGSIZE];
+  strcpy(defaultName, "none");
+  molecules_deprecated->signOn(this);
+}
 World::~World()
+{
+  delete[](cell_size);
+  delete[](DefaultName);
+};
+// TODO: Hide boost-thread using Autotools stuff when no threads are used
+World* World::theWorld = 0;
+World* World::get(){
+  // boost supports RAII-Style locking, so we don't need to unlock
+  if(!theWorld) {
+    theWorld = new World();
+  }
+  return theWorld;
+}
+void World::destroy(){
+  delete theWorld;
+  theWorld = 0;
+}
+World* World::reset(){
+  World* oldWorld = 0;
+  {
+    oldWorld = theWorld;
+    theWorld = new World();
+    // oldworld does not need protection any more,
+    // since we should have the only reference
+    // worldLock handles access to the pointer,
+    // not to the object
+  } // scope-end releases the lock
+  // we have to let all the observers know that the
+  // oldWorld was destroyed. oldWorld calls subjectKilled
+  // upon destruction. Every Observer getting that signal
+  // should see that it gets the updated new world
+  delete oldWorld;
+}
+  molecules_deprecated->signOff(this);
+  delete[] cell_size;
+  delete[] defaultName;
+  delete molecules_deprecated;
+  delete periode;
+  MoleculeSet::iterator molIter;
+  for(molIter=molecules.begin();molIter!=molecules.end();++molIter){
+    DeleteMolecule((*molIter).second);
+  }
+  molecules.clear();
+  AtomSet::iterator atIter;
+  for(atIter=atoms.begin();atIter!=atoms.end();++atIter){
+    DeleteAtom((*atIter).second);
+  }
+  atoms.clear();
+}
+// Explicit instantiation of the singleton mechanism at this point
+CONSTRUCT_SINGLETON(World)
+/******************************* deprecated Legacy Stuff ***********************/
+MoleculeListClass *&World::getMolecules() {
+  return molecules_deprecated;
+}

src/World.hpp

-              rc695c9
+              r5f612ee
 /*
  * world.hpp
+ * World.hpp
+ *
  *  Created on: Mar 3, 2010
  *      Author: heber
+ *  Created on: Feb 3, 2010
+ *      Author: crueger
  */
 …
 #define WORLD_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
+#include <string>
+#include <map>
+#include <vector>
+#include <set>
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include "types.hpp"
+#include "Descriptors/SelectiveIterator.hpp"
+#include "Patterns/Observer.hpp"
+#include "Patterns/Cacheable.hpp"
+#include "Patterns/Singleton.hpp"
 // include config.h
 …
 #endif
+// forward declarations
+class periodentafel;
+class MoleculeListClass;
+class atom;
+class molecule;
+class AtomDescriptor;
+class AtomDescriptor_impl;
+class MoleculeDescriptor;
+class MoleculeDescriptor_impl;
+class ManipulateAtomsProcess;
+template<typename T>
+class AtomsCalculation;
 /****************************************** forward declarations *****************************/
 …
 /********************************************** Class World *******************************/
 class World
+class World : public Singleton<World>, public Observable
+{
+  /***** singleton Stuff *****/
+// Make access to constructor and destructor possible from inside the singleton
+friend class Singleton<World>;
+// necessary for coupling with descriptors
+friend class AtomDescriptor_impl;
+friend class AtomDescriptor;
+friend class MoleculeDescriptor_impl;
+friend class MoleculeDescriptor;
+// Actions, calculations etc associated with the World
+friend class ManipulateAtomsProcess;
+template<typename> friend class AtomsCalculation;
 public:
+  static World* get();
+  static void destroy();
+  static World* reset();
+  // Types for Atom and Molecule structures
+  typedef std::map<atomId_t,atom*> AtomSet;
+  typedef std::map<moleculeId_t,molecule*> MoleculeSet;
+  /***** getter and setter *****/
+  // reference to pointer is used for legacy reason... reference will be removed latter to keep encapsulation of World object
+  /**
+   * returns the periodentafel for the world.
+   */
+  periodentafel *&getPeriode();
+  /**
+   * returns the first atom that matches a given descriptor.
+   * Do not rely on ordering for descriptors that match more than one atom.
+   */
+  atom* getAtom(AtomDescriptor descriptor);
+  /**
+   * returns a vector containing all atoms that match a given descriptor
+   */
+  std::vector<atom*> getAllAtoms(AtomDescriptor descriptor);
+  std::vector<atom*> getAllAtoms();
+  /**
+   * returns a calculation that calls a given function on all atoms matching a descriptor.
+   * the calculation is not called at this point and can be used as an action, i.e. be stored in
+   * menus, be kept around for later use etc.
+   */
+  template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string,AtomDescriptor);
+  template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string);
+  /**
+   * get the number of atoms in the World
+   */
+  int numAtoms();
+  /**
+   * returns the first molecule that matches a given descriptor.
+   * Do not rely on ordering for descriptors that match more than one molecule.
+   */
+  molecule *getMolecule(MoleculeDescriptor descriptor);
+  /**
+   * returns a vector containing all molecules that match a given descriptor
+   */
+  std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
+  /**
+   * get the number of molecules in the World
+   */
+  int numMolecules();
+  /**
+   * get the domain size as a symmetric matrix (6 components)
+   */
+  double * getDomain();
+  /**
+   * set the domain size as a symmetric matrix (6 components)
+   */
+  void setDomain(double * matrix);
+  /**
+   * get the default name
+   */
+  char * getDefaultName();
+  /**
+   * set the default name
+   */
+  void setDefaultName(char * name);
+  /***** Methods to work with the World *****/
+  /**
+   * create a new molecule. This method should be used whenever any kind of molecule is needed. Assigns a unique
+   * ID to the molecule and stores it in the World for later retrieval. Do not create molecules directly.
+   */
+  molecule *createMolecule();
+  void destroyMolecule(molecule*);
+  void destroyMolecule(moleculeId_t);
+  /**
+   * Create a new atom. This method should be used whenever any atom is needed. Assigns a unique ID and stores
+   * the atom in the World. If the atom is not destroyed it will automatically be destroyed when the world ends.
+   */
+  atom *createAtom();
+  /**
+   * Registers a Atom unknown to world. Needed in some rare cases, e.g. when cloning atoms, or in some unittests.
+   * Do not re-register Atoms already known to the world since this will cause double-frees.
+   */
+  int registerAtom(atom*);
+  /**
+     * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
+     * atom directly since this will leave the pointer inside the world.
+   */
+  void destroyAtom(atom*);
+  /**
+   * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
+   * atom directly since this will leave the pointer inside the world.
+   */
+  void destroyAtom(atomId_t);
+  /**
+   * used when changing an atom Id.
+   * Unless you are calling this method from inside an atom don't fiddle with the third parameter.
+   *
+   * Return value indicates wether the change could be done or not.
+   */
+  bool changeAtomId(atomId_t oldId, atomId_t newId, atom* target=0);
+  /**
+   * Produces a process that calls a function on all Atoms matching a given descriptor. The process is not
+   * called at this time, so it can be passed around, stored inside menuItems etc.
+   */
+  ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string,AtomDescriptor);
+  ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
+protected:
+  /**** Iterators to use internal data structures */
+  // Atoms
+  typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
+  /**
+   * returns an iterator over all Atoms matching a given descriptor.
+   * used for internal purposes, like AtomProcesses and AtomCalculations.
+   */
+  AtomIterator getAtomIter(AtomDescriptor descr);
+  /**
+   * returns an iterator to the end of the AtomSet. Due to overloading this iterator
+   * can be compared to iterators produced by getAtomIter (see the mis-matching types).
+   * Thus it can be used to detect when such an iterator is at the end of the list.
+   * used for internal purposes, like AtomProcesses and AtomCalculations.
+   */
+  AtomIterator atomEnd();
+  // Molecules
+  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
+  /**
+   * returns an iterator over all Molecules matching a given descriptor.
+   * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
+   */
+  MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
+  /**
+   * returns an iterator to the end of the MoleculeSet. Due to overloading this iterator
+   * can be compared to iterators produced by getMoleculeIter (see the mis-matching types).
+   * Thus it can be used to detect when such an iterator is at the end of the list.
+   * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
+   */
+  MoleculeIterator moleculeEnd();
+  /******* Internal manipulation routines for double callback and Observer mechanism ******/
+  void doManipulate(ManipulateAtomsProcess *);
+private:
+  atomId_t getNextAtomId();
+  void releaseAtomId(atomId_t);
+  bool reserveAtomId(atomId_t);
+  periodentafel *periode;
   static double *cell_size;
+  static char *DefaultName;
+private:
+  static char *defaultName;
+public:
+  AtomSet atoms;
+private:
+  std::set<atomId_t> atomIdPool; //<!stores the pool for all available AtomIds below currAtomId
+  atomId_t currAtomId; //!< stores the next available Id for atoms
+  MoleculeSet molecules;
+  moleculeId_t currMoleculeId;
+private:
+  /**
+   * private constructor to ensure creation of the world using
+   * the singleton pattern.
+   */
   World();
+  /**
+   * private destructor to ensure destruction of the world using the
+   * singleton pattern.
+   */
   virtual ~World();
+  static World *theWorld;
+  /*****
+   * some legacy stuff that is include for now but will be removed later
+   *****/
+public:
+  MoleculeListClass *&getMolecules();
+private:
+  MoleculeListClass *molecules_deprecated;
 };

src/analysis_correlation.cpp

-              rc695c9
+              r5f612ee
                 if (Walker->nr < OtherWalker->nr)
                   if ((type2 == NULL) || (OtherWalker->type == type2)) {
                     distance = Walker->node->PeriodicDistance(OtherWalker->node, World::get()->cell_size);
+                    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) ) );
 …
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
       double * FullMatrix = ReturnFullMatrixforSymmetric(World::get()->cell_size);
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
 …
         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
         if ((type == NULL) || (Walker->type == type)) {
           distance = Walker->node->PeriodicDistance(point, World::get()->cell_size);
+          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 (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
       double * FullMatrix = ReturnFullMatrixforSymmetric(World::get()->cell_size);
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
 …
       DoLog(1) && (Log() << Verbose(1) << "molecule " << (*MolWalker)->name << " is not active." << endl);
   return outmap;
 };
 …
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
       double * FullMatrix = ReturnFullMatrixforSymmetric(World::get()->cell_size);
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);

src/atom.cpp

-              rc695c9
+              r5f612ee
 #include "parser.hpp"
 #include "vector.hpp"
+#include "World.hpp"
 /************************************* Functions for class atom *************************************/
 …
 /** Constructor of class atom.
  */
+atom::atom() : previous(NULL), next(NULL), father(this), sort(&nr)
+atom::atom() :
+  previous(NULL), next(NULL), father(this), sort(&nr)
+{
   node = &x;  // TesselPoint::x can only be referenced from here
 …
 /** Constructor of class atom.
  */
+atom::atom(atom *pointer) : previous(NULL), next(NULL), father(pointer), sort(&nr)
+atom::atom(atom *pointer) :
+    ParticleInfo(pointer),
+    previous(NULL), next(NULL), father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
 …
   node = &x;
 };
+atom *atom::clone(){
+  atom *res = new atom();
+  res->previous=0;
+  res->next=0;
+  res->father = this;
+  res->sort = &res->nr;
+  res->type = type;
+  res->x.CopyVector(&this->x);
+  res->v.CopyVector(&this->v);
+  res->FixedIon = FixedIon;
+  res->node = &x;
+  World::getInstance().registerAtom(res);
+  return res;
+}
 …
 };
+World *atom::getWorld(){
+  return world;
+}
+void atom::setWorld(World* _world){
+  world = _world;
+}
+bool atom::changeId(atomId_t newId){
+  // first we move ourselves in the world
+  // the world lets us know if that succeeded
+  if(world->changeAtomId(id,newId,this)){
+    id = newId;
+    return true;
+  }
+  else{
+    return false;
+  }
+}
+void atom::setId(atomId_t _id) {
+  id=_id;
+}
+atomId_t atom::getId() {
+  return id;
+}
+atom* NewAtom(atomId_t _id){
+  atom * res =new atom();
+  res->setId(_id);
+  return res;
+}
+void DeleteAtom(atom* atom){
+  delete atom;
+}

src/atom.hpp

-              rc695c9
+              r5f612ee
 #include "atom_trajectoryparticle.hpp"
 #include "tesselation.hpp"
+#include "types.hpp"
 /****************************************** forward declarations *****************************/
 class Vector;
+class World;
 /********************************************** declarations *******************************/
 …
  */
 class atom : public TesselPoint, public TrajectoryParticle, public GraphNode, public BondedParticle, public virtual ParticleInfo, public virtual AtomInfo {
+  friend atom* NewAtom(atomId_t);
+  friend void  DeleteAtom(atom*);
   public:
     atom *previous; //!< previous atom in molecule list
 …
     int *sort;      //!< sort criteria
+  atom();
+  atom(class atom *pointer);
+  virtual ~atom();
+  virtual atom *clone();
   bool OutputIndexed(ofstream * const out, const int ElementNo, const int AtomNo, const char *comment = NULL) const;
 …
   bool IsInParallelepiped(const Vector offset, const double *parallelepiped) const;
+  // getter and setter
+  /**
+   * returns the World that contains this atom.
+   * Use this if you need to get the world without locking
+   * the singleton for example.
+   *
+   */
+  World *getWorld();
+  void setWorld(World*);
+  virtual atomId_t getId();
+  virtual bool changeId(atomId_t newId);
+  /**
+   * this function sets the Id without notifying the world. Only use it, if the world has already
+   * gotten an ID for this Atom.
+   */
+   virtual void setId(atomId_t);
+  protected:
+    /**
+     * Protected constructor to ensure construction of atoms through the world.
+     * see World::createAtom()
+     */
+    atom();
+    /**
+     * Protected copy-constructor to ensure construction of atoms by cloning.
+     * see atom::clone()
+     */
+    atom(class atom *pointer);
+    /**
+     * Protected destructor to ensure destruction of atoms through the world.
+     * see World::destroyAtom()
+     */
+    virtual ~atom();
   private:
+    World* world;
+    atomId_t id;
 };
+/**
+ * internal method used by the world. Do not use if you don't know what you are doing.
+ * You might get burned...
+ * Use World::createAtom() instead.
+ */
+atom* NewAtom(atomId_t _id);
+/**
+* internal method used by the world. Do not use if you don't know what you are doing.
+ * You might get burned...
+ * Use World::destroyAtom() instead.
+ */
+void  DeleteAtom(atom*);
 #endif /* ATOM_HPP_ */

src/atom_atominfo.cpp

-              rc695c9
+              r5f612ee
  */
+#include "periodentafel.hpp"
+#include "World.hpp"
 #include "atom_atominfo.hpp"
 …
 };
+const element *AtomInfo::getType(){
+  return type;
+}
+void AtomInfo::setType(const element* _type) {
+  type = _type;
+}
+void AtomInfo::setType(int Z) {
+  const element *elem = World::getInstance().getPeriode()->FindElement(Z);
+  setType(elem);
+}

src/atom_atominfo.hpp

-              rc695c9
+              r5f612ee
   Vector v;       //!< velocity vector of atom, giving last velocity within cell
   Vector F;       //!< Force vector of atom, giving last force within cell
   element *type;  //!< pointing to element
+  const element *type;  //!< pointing to element
   AtomInfo();
   ~AtomInfo();
+  const element *getType();
+  void setType(const element *);
+  void setType(int);
 private:

src/atom_particleinfo.cpp

-              rc695c9
+              r5f612ee
  */
 ParticleInfo::ParticleInfo() : nr(-1), Name(NULL) {};
+ParticleInfo::ParticleInfo(ParticleInfo *pointer) :
+    nr(pointer->nr),
+    Name(pointer->Name)
+    {}
 /** Destructor of ParticleInfo.

src/atom_particleinfo.hpp

rc695c9	r5f612ee
31	31
32	32	ParticleInfo();
	33	ParticleInfo(ParticleInfo*);
33	34	~ParticleInfo();
34	35

src/boundary.cpp

-              rc695c9
+              r5f612ee
  */
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
+{
         Info FunctionInfo(__func__);
   molecule *Filling = new molecule(filler->elemente);
+  molecule *Filling = World::getInstance().createMolecule();
   Vector CurrentPosition;
   int N[NDIM];
   int n[NDIM];
   double *M =  ReturnFullMatrixforSymmetric(World::get()->cell_size);
+  double *M =  ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
   double Rotations[NDIM*NDIM];
   double *MInverse = InverseMatrix(M);
 …
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
             CopyAtoms[Walker->nr] = new atom(Walker);
+            CopyAtoms[Walker->nr] = Walker->clone();
             CopyAtoms[Walker->nr]->x.CopyVector(&Inserter);
             Filling->AddAtom(CopyAtoms[Walker->nr]);

src/builder.cpp

-              rc695c9
+              r5f612ee
+#include <boost/bind.hpp>
 using namespace std;
 …
 #include "linkedcell.hpp"
 #include "log.hpp"
 #include "memoryusageobserverunittest.hpp"
+#include "memoryusageobserver.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "UIElements/UIFactory.hpp"
+#include "UIElements/MainWindow.hpp"
+#include "UIElements/Dialog.hpp"
+#include "Menu/ActionMenuItem.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
+#include "Actions/MethodAction.hpp"
+#include "Actions/small_actions.hpp"
+#include "World.hpp"
 #include "version.h"
 #include "World.hpp"
 /********************************************* Subsubmenu routine ************************************/
+#if 0
 /** Submenu for adding atoms to the molecule.
  * \param *periode periodentafel
 …
         cout << Verbose(0) << "Enter absolute coordinates." << endl;
         first = new atom;
         first->x.AskPosition(World::get()->cell_size, false);
+        first->x.AskPosition(World::getInstance().getDomain(), false);
         first->type = periode->AskElement();  // give type
         mol->AddAtom(first);  // add to molecule
 …
           if (!valid) DoeLog(2) && (eLog()<< Verbose(2) << "Resulting position out of cell." << endl);
           cout << Verbose(0) << "Enter reference coordinates." << endl;
           x.AskPosition(World::get()->cell_size, true);
+          x.AskPosition(World::getInstance().getDomain(), true);
           cout << Verbose(0) << "Enter relative coordinates." << endl;
           first->x.AskPosition(World::get()->cell_size, false);
+          first->x.AskPosition(World::getInstance().getDomain(), false);
           first->x.AddVector((const Vector *)&x);
           cout << Verbose(0) << "\n";
 …
           second = mol->AskAtom("Enter atom number: ");
           DoLog(0) && (Log() << Verbose(0) << "Enter relative coordinates." << endl);
           first->x.AskPosition(World::get()->cell_size, false);
+          first->x.AskPosition(World::getInstance().getDomain(), false);
           for (int i=NDIM;i--;) {
             first->x.x[i] += second->x.x[i];
 …
         if (i >= 2) {
           first->x.LSQdistance((const Vector **)atoms, i);
           first->x.Output();
           first->type = periode->AskElement();  // give type
 …
     case 'b': // normal vector of mirror plane
       cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
       n.AskPosition(World::get()->cell_size,0);
+      n.AskPosition(World::getInstance().getDomain(),0);
       n.Normalize();
       break;
 …
     case 'b': // normal vector of mirror plane
       DoLog(0) && (Log() << Verbose(0) << "Enter normal vector of mirror plane." << endl);
       n.AskPosition(World::get()->cell_size,0);
+      n.AskPosition(World::getInstance().getDomain(),0);
       n.Normalize();
       break;
 …
           x.Zero();
           y.Zero();
           y.x[abs(axis)-1] = World::get()->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
+          y.x[abs(axis)-1] = World::getInstance().getDomain()[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
           for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
             x.AddVector(&y); // per factor one cell width further
 …
             mol->Translate(&x);
+          }
           World::get()->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+          World::getInstance().getDomain()[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+        }
+      }
 …
         DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
         DoLog(0) && (Log() << Verbose(0) << "Enter translation vector." << endl);
         x.AskPosition(World::get()->cell_size,0);
+        x.AskPosition(World::getInstance().getDomain(),0);
         mol->Center.AddVector((const Vector *)&x);
+     }
 …
       break;
     case 'c':
       mol = new molecule(periode);
+      mol = World::getInstance().createMolecule();
       molecules->insert(mol);
       break;
 …
         char filename[MAXSTRINGSIZE];
         DoLog(0) && (Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl);
         mol = new molecule(periode);
+        mol = World::getInstance().createMolecule();
         do {
           DoLog(0) && (Log() << Verbose(0) << "Enter file name: ");
 …
         // center at set box dimensions
         mol->CenterEdge(&center);
         double * const cell_size = World::get()->cell_size;
+        double * const cell_size = World::getInstance().getDomain();
         cell_size[0] = center.x[0];
         cell_size[1] = 0;
 …
 };
 /********************************************** Test routine **************************************/
 …
 };
+#endif
 /** Tries given filename or standard on saving the config file.
  * \param *ConfigFileName name of file
 …
   char filename[MAXSTRINGSIZE];
   ofstream output;
   molecule *mol = new molecule(periode);
+  molecule *mol = World::getInstance().createMolecule();
   mol->SetNameFromFilename(ConfigFileName);
 …
+  }
   delete(mol);
+  World::getInstance().destroyMolecule(mol);
 };
 …
  * \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)
+{
   Vector x,y,z,n;  // coordinates for absolute point in cell volume
 …
               j = -1;
               DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
               double * const cell_size = World::get()->cell_size;
+              double * const cell_size = World::getInstance().getDomain();
               for (int i=0;i<6;i++) {
                 cell_size[i] = atof(argv[argptr+i]);
 …
           case 'X':
+            {
+              char **name = &(World::get()->DefaultName);
+              delete[](*name);
+              const int length = strlen(argv[argptr]);
+              *name = new char[length+2];
+              strncpy(*name, argv[argptr], length);
+              DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << *name << "." << endl);
+              World::getInstance().setDefaultName(argv[argptr]);
+              DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << *World::getInstance().getDefaultName() << "." << endl);
+            }
             break;
 …
+     }
      if (mol == NULL) {
        mol = new molecule(periode);
+       mol = World::getInstance().createMolecule();
        mol->ActiveFlag = true;
        if (ConfigFileName != NULL)
 …
               } else {
                 SaveFlag = true;
                 DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ");
                 first = new atom;
+                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)
 …
                           const double BinEnd = atof(argv[argptr+6]);
                           element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
                           element *elemental2 = periode->FindElement((const int) atoi(argv[argptr+2]));
+                          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)
 …
                           const double BinEnd = atof(argv[argptr+8]);
                           element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
+                          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;
 …
+                          }
                           LCList = new LinkedCell(Boundary, LCWidth);
                           element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
+                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
                           FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
                           CorrelationToSurfaceMap *surfacemap = NULL;
 …
                 DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules." << endl);
                 // construct water molecule
                 molecule *filler = new molecule(periode);
+                molecule *filler = World::getInstance().createMolecule();
                 if (!filler->AddXYZFile(argv[argptr])) {
                   DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << argv[argptr] << "." << endl);
 …
                 configuration.BG->ConstructBondGraph(filler);
                 molecule *Filling = NULL;
+                atom *second = NULL, *third = NULL;
+                first = World::getInstance().createAtom();
+                first->type = periode->FindElement(1);
+                first->x.Init(0.441, -0.143, 0.);
+                filler->AddAtom(first);
+                second = World::getInstance().createAtom();
+                second->type = periode->FindElement(1);
+                second->x.Init(-0.464, 1.137, 0.0);
+                filler->AddAtom(second);
+                third = World::getInstance().createAtom();
+                third->type = periode->FindElement(8);
+                third->x.Init(-0.464, 0.177, 0.);
+                filler->AddAtom(third);
+                filler->AddBond(first, third, 1);
+                filler->AddBond(second, third, 1);
                 // call routine
                 double distance[NDIM];
 …
                   molecules->insert(Filling);
+                }
                 delete(filler);
+                World::getInstance().destroyMolecule(filler);
                 argptr+=6;
+              }
 …
                 factor[2] = atof(argv[argptr+2]);
                 mol->Scale((const double ** const)&factor);
                 double * const cell_size = World::get()->cell_size;
+                double * const cell_size = World::getInstance().getDomain();
                 for (int i=0;i<NDIM;i++) {
                   j += i+1;
 …
                 j = -1;
                 DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
                 double * const cell_size = World::get()->cell_size;
+                double * const cell_size = World::getInstance().getDomain();
                 for (int i=0;i<6;i++) {
                   cell_size[i] = atof(argv[argptr+i]);
 …
                 j = -1;
                 DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
                 double * const cell_size = World::get()->cell_size;
+                double * const cell_size = World::getInstance().getDomain();
                 for (int i=0;i<6;i++) {
                   cell_size[i] = atof(argv[argptr+i]);
 …
                 mol->SetBoxDimension(&x);
                 // translate each coordinate by boundary
                 double * const cell_size = World::get()->cell_size;
+                double * const cell_size = World::getInstance().getDomain();
                 j=-1;
                 for (int i=0;i<NDIM;i++) {
 …
                 DoLog(0) && (Log() << Verbose(0) << "Creating connection matrix..." << endl);
                 start = clock();
                 mol->CreateAdjacencyList(atof(argv[argptr++]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+                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]), &configuration);
+                  ExitFlag = mol->FragmentMolecule(atoi(argv[argptr+1]), &configuration);
+                }
                 end = clock();
 …
               } else {
                 SaveFlag = true;
                 double * const cell_size = World::get()->cell_size;
+                double * const cell_size = World::getInstance().getDomain();
                 for (int axis = 1; axis <= NDIM; axis++) {
                   int faktor = atoi(argv[argptr++]);
                   int count;
                   element ** Elements;
+                  const element ** Elements;
                   Vector ** vectors;
                   if (faktor < 1) {
 …
                   if (mol->AtomCount != 0) {  // if there is more than none
                     count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
                     Elements = new element *[count];
+                    Elements = new const element *[count];
                     vectors = new Vector *[count];
                     j = 0;
 …
                       x.AddVector(&y); // per factor one cell width further
                       for (int k=count;k--;) { // go through every atom of the original cell
                         first = new atom(); // create a new body
+                        first = World::getInstance().createAtom(); // create a new body
                         first->x.CopyVector(vectors[k]);  // use coordinate of original atom
                         first->x.AddVector(&x);      // translate the coordinates
 …
     } while (argptr < argc);
     if (SaveFlag)
       SaveConfig(ConfigFileName, &configuration, 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 **************************************/
+int main(int argc, char **argv)
+{
+  periodentafel *periode = new periodentafel; // and a period table of all elements
+  MoleculeListClass *molecules = new MoleculeListClass;  // list of all molecules
+  molecule *mol = NULL;
+  config *configuration = new config;
+  char choice;  // menu choice char
+  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+  ifstream test;
+  ofstream output;
+  string line;
+  char *ConfigFileName = NULL;
+  int j;
+  cout << ESPACKVersion << endl;
+  DoLog(1) && (Log() << Verbose(1) << "test" << endl);
+  DoLog(3) && (Log() << Verbose(1) << "test");
+  setVerbosity(0);
+  // =========================== PARSE COMMAND LINE OPTIONS ====================================
+  j = ParseCommandLineOptions(argc, argv, molecules, periode, *configuration, ConfigFileName);
+  switch(j) {
+    case 255:  // something went wrong
+    case 2:  // just for -f option
+    case 1:  // just for -v and -h options
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      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::getInstance()->purgeInstance();
+      logger::purgeInstance();
+      errorLogger::purgeInstance();
+     return (j == 1 ? 0 : j);
+    default:
+      break;
+  }
+  // General stuff
+  if (molecules->ListOfMolecules.size() == 0) {
+    mol = new molecule(periode);
+    double * const cell_size = World::get()->cell_size;
+    if (cell_size[0] == 0.) {
+      DoLog(0) && (Log() << Verbose(0) << "enter lower tridiagonal form of basis matrix" << endl << endl);
+      for (int i=0;i<6;i++) {
+        DoLog(1) && (Log() << Verbose(1) << "Cell size" << i << ": ");
+        cin >> cell_size[i];
+      }
+    }
+    mol->ActiveFlag = true;
+    molecules->insert(mol);
+  }
+  // =========================== START INTERACTIVE SESSION ====================================
+  // now the main construction loop
+  DoLog(0) && (Log() << Verbose(0) << endl << "Now comes the real construction..." << endl);
+  do {
+    DoLog(0) && (Log() << Verbose(0) << endl << endl);
+    DoLog(0) && (Log() << Verbose(0) << "============Molecule list=======================" << endl);
+    molecules->Enumerate((ofstream *)&cout);
+    DoLog(0) && (Log() << Verbose(0) << "============Menu===============================" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "a - set molecule (in)active" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "e - edit molecules (load, parse, save)" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "g - globally manipulate atoms in molecule" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "M - Merge molecules" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "m - manipulate atoms" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "-----------------------------------------------" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "c - edit the current configuration" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "-----------------------------------------------" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "s - save current setup to config file" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "T - call the current test routine" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "q - quit" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
+    DoLog(0) && (Log() << Verbose(0) << "Input: ");
+    cin >> choice;
+    switch (choice) {
+      case 'a':  // (in)activate molecule
+        {
+          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule: ");
+          cin >> j;
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr == j)
+              (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
+        }
+        break;
+      case 'c': // edit each field of the configuration
+       configuration->Edit();
+       break;
+      case 'e': // create molecule
+        EditMolecules(periode, molecules);
+        break;
+      case 'g': // manipulate molecules
+        ManipulateMolecules(periode, molecules, configuration);
+        break;
+      case 'M':  // merge molecules
+        MergeMolecules(periode, molecules);
+        break;
+      case 'm': // manipulate atoms
+        ManipulateAtoms(periode, molecules, configuration);
+        break;
+      case 'q': // quit
+        break;
+      case 's': // save to config file
+        SaveConfig(ConfigFileName, configuration, periode, molecules);
+        break;
+      case 'T':
+        testroutine(molecules);
+        break;
+      default:
+        break;
+    };
+  } while (choice != 'q');
+  // save element data base
+  if (periode->StorePeriodentafel(configuration->databasepath)) //ElementsFileName
+    DoLog(0) && (Log() << Verbose(0) << "Saving of elements.db successful." << endl);
+  else
+    DoLog(0) && (Log() << Verbose(0) << "Saving of elements.db failed." << endl);
+  delete(molecules); // also free's all molecules contained
+  delete(periode);
+void cleanUp(config *configuration){
+  UIFactory::purgeInstance();
+  World::purgeInstance();
   delete(configuration);
   Log() << Verbose(0) <<  "Maximum of allocated memory: "
     << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
 …
   logger::purgeInstance();
   errorLogger::purgeInstance();
+  ActionRegistry::purgeInstance();
+}
+int main(int argc, char **argv)
+{
+    molecule *mol = NULL;
+    config *configuration = new config;
+    Vector x, y, z, n;
+    ifstream test;
+    ofstream output;
+    string line;
+    char *ConfigFileName = NULL;
+    int j;
+    cout << ESPACKVersion << endl;
+    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;
+    }
+    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->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);
+}

src/config.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
 //        case 'j': // BoxLength
 //          Log() << Verbose(0) << "enter lower triadiagonalo form of basis matrix" << endl << endl;
 //          double * const cell_size = World::get()->cell_size;
+//          double * const cell_size = World::getInstance().getDomain();
 //          for (int i=0;i<6;i++) {
 //            Log() << Verbose(0) << "Cell size" << i << ": ";
 …
+{
   int MaxTypes = 0;
   element *elementhash[MAX_ELEMENTS];
+  const element *elementhash[MAX_ELEMENTS];
   char name[MAX_ELEMENTS];
   char keyword[MAX_ELEMENTS];
 …
             sprintf(keyword,"%s_%i",name, j+1);
             if (repetition == 0) {
               neues = new atom();
+              neues = World::getInstance().createAtom();
               AtomList[i][j] = neues;
               LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
 …
           sprintf(keyword,"%s_%i",name, j+1);
           if (repetition == 0) {
             neues = new atom();
+            neues = World::getInstance().createAtom();
             AtomList[i][j] = neues;
             LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
 …
 void config::Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
   molecule *mol = new molecule(periode);
+  molecule *mol = World::getInstance().createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
 …
   // Unit cell and magnetic field
   ParseForParameter(verbose,FileBuffer, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   cell_size[0] = BoxLength[0];
   cell_size[1] = BoxLength[3];
 …
 void config::LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
   molecule *mol = new molecule(periode);
+  molecule *mol = World::getInstance().createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
 …
   string zeile;
   string dummy;
   element *elementhash[128];
+  const element *elementhash[128];
   int Z = -1;
   int No = -1;
 …
   ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   cell_size[0] = BoxLength[0];
   cell_size[1] = BoxLength[3];
 …
+        }
         istringstream input2(zeile);
         atom *neues = new atom();
+        atom *neues = World::getInstance().createAtom();
         input2 >> neues->x.x[0]; // x
         input2 >> neues->x.x[1]; // y
 …
   // bring MaxTypes up to date
   mol->CountElements();
   const double * const cell_size = World::get()->cell_size;
+  const double * const cell_size = World::getInstance().getDomain();
   ofstream * const output = new ofstream(filename, ios::out);
   if (output != NULL) {
 …
 };
+/** Tries given filename or standard on saving the config file.
+ * \param *ConfigFileName name of file
+ * \param *periode pointer to periodentafel structure with all the elements
+ * \param *molecules list of molecules structure with all the atoms and coordinates
+ */
+void config::SaveAll(char *ConfigFileName, periodentafel *periode, MoleculeListClass *molecules)
+{
+  char filename[MAXSTRINGSIZE];
+  ofstream output;
+  molecule *mol = World::getInstance().createMolecule();
+  mol->SetNameFromFilename(ConfigFileName);
+  if (!strcmp(configpath, GetDefaultPath())) {
+    eLog() << Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl;
+  }
+  // first save as PDB data
+  if (ConfigFileName != NULL)
+    strcpy(filename, ConfigFileName);
+  if (output == NULL)
+    strcpy(filename,"main_pcp_linux");
+  Log() << Verbose(0) << "Saving as pdb input ";
+  if (SavePDB(filename, molecules))
+    Log() << Verbose(0) << "done." << endl;
+  else
+    Log() << Verbose(0) << "failed." << endl;
+  // then save as tremolo data file
+  if (ConfigFileName != NULL)
+    strcpy(filename, ConfigFileName);
+  if (output == NULL)
+    strcpy(filename,"main_pcp_linux");
+  Log() << Verbose(0) << "Saving as tremolo data input ";
+  if (SaveTREMOLO(filename, molecules))
+    Log() << Verbose(0) << "done." << endl;
+  else
+    Log() << Verbose(0) << "failed." << endl;
+  // translate each to its center and merge all molecules in MoleculeListClass into this molecule
+  int N = molecules->ListOfMolecules.size();
+  int *src = new int[N];
+  N=0;
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    src[N++] = (*ListRunner)->IndexNr;
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+  }
+  molecules->SimpleMultiAdd(mol, src, N);
+  delete[](src);
+  // ... and translate back
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    (*ListRunner)->Center.Scale(-1.);
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+    (*ListRunner)->Center.Scale(-1.);
+  }
+  Log() << Verbose(0) << "Storing configuration ... " << endl;
+  // get correct valence orbitals
+  mol->CalculateOrbitals(*this);
+  InitMaxMinStopStep = MaxMinStopStep = MaxPsiDouble;
+  if (ConfigFileName != NULL) { // test the file name
+    strcpy(filename, ConfigFileName);
+    output.open(filename, ios::trunc);
+  } else if (strlen(configname) != 0) {
+    strcpy(filename, configname);
+    output.open(configname, ios::trunc);
+    } else {
+      strcpy(filename, DEFAULTCONFIG);
+      output.open(DEFAULTCONFIG, ios::trunc);
+    }
+  output.close();
+  output.clear();
+  Log() << Verbose(0) << "Saving of config file ";
+  if (Save(filename, periode, mol))
+    Log() << Verbose(0) << "successful." << endl;
+  else
+    Log() << Verbose(0) << "failed." << endl;
+  // and save to xyz file
+  if (ConfigFileName != NULL) {
+    strcpy(filename, ConfigFileName);
+    strcat(filename, ".xyz");
+    output.open(filename, ios::trunc);
+  }
+  if (output == NULL) {
+    strcpy(filename,"main_pcp_linux");
+    strcat(filename, ".xyz");
+    output.open(filename, ios::trunc);
+  }
+  Log() << Verbose(0) << "Saving of XYZ file ";
+  if (mol->MDSteps <= 1) {
+    if (mol->OutputXYZ(&output))
+      Log() << Verbose(0) << "successful." << endl;
+    else
+      Log() << Verbose(0) << "failed." << endl;
+  } else {
+    if (mol->OutputTrajectoriesXYZ(&output))
+      Log() << Verbose(0) << "successful." << endl;
+    else
+      Log() << Verbose(0) << "failed." << endl;
+  }
+  output.close();
+  output.clear();
+  // and save as MPQC configuration
+  if (ConfigFileName != NULL)
+    strcpy(filename, ConfigFileName);
+  if (output == NULL)
+    strcpy(filename,"main_pcp_linux");
+  Log() << Verbose(0) << "Saving as mpqc input ";
+  if (SaveMPQC(filename, mol))
+    Log() << Verbose(0) << "done." << endl;
+  else
+    Log() << Verbose(0) << "failed." << endl;
+  if (!strcmp(configpath, GetDefaultPath())) {
+    eLog() << Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl;
+  }
+  World::getInstance().destroyMolecule(mol);
+};
 /** Reads parameter from a parsed file.
  * The file is either parsed for a certain keyword or if null is given for

src/config.hpp

rc695c9	r5f612ee
146	146	bool SaveTREMOLO(const char * const filename, const MoleculeListClass * const MolList) const;
147	147
	148	void SaveAll(char ConfigFileName, periodentafel periode, MoleculeListClass *molecules);
	149
148	150	void Edit();
149	151	bool GetIsAngstroem() const;

src/datacreator.cpp

-              rc695c9
+              r5f612ee
+{
   stringstream line(Force.Header[Force.MatrixCounter]);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  const char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
 …
+{
   stringstream line(Force.Header[Force.MatrixCounter]);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  const char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;

src/defs.hpp

-              rc695c9
+              r5f612ee
 enum Shading { white, lightgray, darkgray, black };  //!< color in Breadth-First-Search analysis
 //enum CutCyclicBond { KeepBond,  SaturateBond }; //!< Saturation scheme either atom- or bondwise
 …
 #define UPDATECOUNT 10  //!< update ten sites per BOSSANOVA interval
+#define STD_MENU_LENGTH 60
+#define STD_MENU_TITLE_SPACER '='
+#define STD_SEPERATOR_SPACER '-'
 #endif /*DEFS_HPP_*/

src/element.cpp

-              rc695c9
+              r5f612ee
 #include "element.hpp"
+using namespace std;
 /************************************* Functions for class element **********************************/
 /** Constructor of class element.
  */
+element::element() {
+  Z = -1;
+  No = -1;
+  previous = NULL;
+  next = NULL;
+  sort = NULL;
+element::element() :
+  mass(0),
+  CovalentRadius(0),
+  VanDerWaalsRadius(0),
+        Z(-1),
+        previous(NULL),
+        next(NULL),
+        sort(NULL),
+        No(-1),
+        Valence(0),
+        NoValenceOrbitals(0)
+{
 };
 …
  * \param *out outstream
  */
 bool element::Output(ofstream * const out) const
+bool element::Output(ostream * const out) const
+{
   if (out != NULL) {
 …
  * \param NoOfAtoms total number of atom of this element type
  */
 bool element::Checkout(ofstream * const out, const int Number, const int NoOfAtoms) const
+bool element::Checkout(ostream * const out, const int Number, const int NoOfAtoms) const
+{
   if (out != NULL) {
 …
     return false;
 };
+atomicNumber_t element::getNumber() const{
+  return Z;
+}
+string element::getSymbol() const{
+  return string(symbol);
+}

src/element.hpp

-              rc695c9
+              r5f612ee
 #define ELEMENT_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
 …
 #include <iostream>
+#include <string>
 #include "defs.hpp"
+#include "types.hpp"
 /********************************************** declarations *******************************/
 …
   ~element();
+  // accessor functions
+  atomicNumber_t getNumber() const;
+  std::string getSymbol() const;
   //> print element entries to screen
   bool Output(ofstream * const out) const;
   bool Checkout(ofstream * const out, const int No, const int NoOfAtoms) const;
+  bool Output(std::ostream * const out) const;
+  bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
   private:

src/errorlogger.cpp

-              rc695c9
+              r5f612ee
 #include "errorlogger.hpp"
 #include "verbose.hpp"
+#include "Patterns/Singleton_impl.hpp"
 ofstream null("/dev/null");
-errorLogger* errorLogger::instance = NULL;
 int errorLogger::verbosity = 2;
 ostream* errorLogger::nix = &null;
 …
 errorLogger::errorLogger()
+{
-  instance = NULL;
   verbosity = 2;
 };
 …
+}
+/**
+ * Returns the singleton errorLogger instance.
+ *
+ * \return errorLogger instance
+ */
+errorLogger* errorLogger::getInstance() {
+  if (instance == NULL) {
+    instance = new errorLogger();
+  }
+  return instance;
+}
+/**
+ * Purges the current errorLogger instance.
+ */
+void errorLogger::purgeInstance() {
+  if (instance != NULL) {
+    delete instance;
+  }
+  instance = NULL;
+}
+CONSTRUCT_SINGLETON(errorLogger)
 /**

src/errorlogger.hpp

-              rc695c9
+              r5f612ee
 #include <iostream>
+#include "Patterns/Singleton.hpp"
 using namespace std;
 class Verbose;
+class errorLogger {
+class errorLogger : public Singleton<errorLogger>{
+  friend class Singleton<errorLogger>;
 public :
   static ostream *nix;
   static int verbosity;
-  static errorLogger* getInstance();
-  static void purgeInstance();
   static bool DoOutput();
   static void setVerbosity(int verbosityLevel);
 …
   ~errorLogger();
-private:
-  static errorLogger* instance;
 };

src/gslmatrix.cpp

rc695c9	r5f612ee
178	178	gsl_matrix_set(dest, j,i, gsl_matrix_get(matrix, i,j) );
179	179	}
180		~~delet~~e(matrix);
	180	gsl_matrix_free(matrix);
181	181	matrix = dest;
182	182	flip(rows, columns);

src/helpers.hpp

-              rc695c9
+              r5f612ee
 };
+#define PLURAL_S(v) (((v)==1)?"":"s")
+// this is to allow different modes of access for
+// maps and sets
+template<typename Res,typename T>
+struct _take{
+  Res get(T value) const;
+};
+// if we have a set,vector etc we can directly access the result
+template<typename Res>
+struct _take<Res,Res>{
+  static inline Res get(Res value){
+    return value;
+  }
+};
+// if we have a map we have to access the second part of
+// the pair
+template<typename Res,typename T1>
+struct _take<Res,std::pair<T1,Res> >{
+  static inline Res get(std::pair<T1,Res> value){
+    return value.second;
+  }
+};
 #endif /*HELPERS_HPP_*/

src/leastsquaremin.hpp

rc695c9	r5f612ee
42	42	gsl_vector *x;
43	43	const molecule *mol;
44		element *type;
	44	const element *type;
45	45	};
46	46

src/lists.hpp

-              rc695c9
+              r5f612ee
 #define LISTS_HPP_
+class atom;
 /******************************** Some templates for list management ***********************************/
 …
+{
   X *vorher = end->previous;
   if (vorher != NULL)
+  if (vorher != 0)
     vorher->next = walker;
   end->previous = walker;
 …
 template <typename X> void unlink(X *walker)
+{
   if (walker->next != NULL)
+  if (walker->next != 0)
     walker->next->previous = walker->previous;
   if (walker->previous != NULL)
+  if (walker->previous != 0)
     walker->previous->next = walker->next;
   walker->next = NULL;
   walker->previous= NULL;
+  walker->next = 0;
+  walker->previous= 0;
 };
 …
 template <typename X>  bool add(X *pointer, X *end)
+{
   if (end != NULL) {
+  if (end != 0) {
     link(pointer, end);
   } else {
     pointer->previous = NULL;
     pointer->next = NULL;
+    pointer->previous = 0;
+    pointer->next = 0;
+  }
   return true;
 …
  * \param *start  begin of list
  * \param *end  end of list
  * \return X - if found, NULL - if not found
+ * \return X - if found, 0 - if not found
  */
 template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
 …
     if (*walker->sort == *suche) return (walker);
+  }
   return NULL;
+  return 0;
 };
 …
 template <typename X> void removewithoutcheck(X *walker)
+{
   if (walker != NULL) {
+  if (walker != 0) {
     unlink(walker);
     delete(walker);
     walker = NULL;
+    walker = 0;
+  }
 };
+/** Removes an item from the list without check.
+ *  specialized for atoms, because these have to be removed from the world as well
+ *  the implementation for this declaration is in lists.cpp
+ * \param *walker item to be removed
+ * \return true - removing succeeded, false - given item not found in list
+ */
+template <> void removewithoutcheck<atom>(atom *walker);
 /** Removes an item from the list, checks if exists.
 …
   }*/
   // atom found, now unlink
   if (walker != NULL)
+  if (walker != 0)
     removewithoutcheck(walker);
   else
 …
+{
   X *pointer = start->next;
   X *walker = NULL;
+  X *walker = 0;
   while (pointer != end) { // go through list
     walker = pointer; // mark current
 …
+{
   X *Binder = me;
   while(Binder->previous != NULL)
+  while(Binder->previous != 0)
     Binder = Binder->previous;
   return Binder;
 …
+{
   X *Binder = me;
   while(Binder->next != NULL)
+  while(Binder->next != 0)
     Binder = Binder->next;
   return Binder;

src/log.cpp

-              rc695c9
+              r5f612ee
  */
 void setVerbosity(int verbosityLevel) {
   logger::getInstance()->setVerbosity(verbosityLevel);
+  logger::getInstance().setVerbosity(verbosityLevel);
+}
 …
  * \param indentation level of the message to log
  */
 class logger * Log() {
+class logger& Log() {
   return logger::getInstance();
+}
 …
  */
 bool DoLog(int verbose) {
   return (verbose <= logger::getInstance()->verbosity);
+  return (verbose <= logger::getInstance().verbosity);
+}
 …
  */
 bool DoeLog(int verbose) {
   return (verbose <= errorLogger::getInstance()->verbosity);
+  return (verbose <= errorLogger::getInstance().verbosity);
+}
 …
  * \param indentation level of the message to log
  */
 class errorLogger * eLog() {
+class errorLogger & eLog() {
   return errorLogger::getInstance();
+}

src/logger.cpp

-              rc695c9
+              r5f612ee
 #include "logger.hpp"
 #include "verbose.hpp"
+#include "Patterns/Singleton_impl.hpp"
 ofstream nullStream("/dev/null");
-logger* logger::instance = NULL;
 int logger::verbosity = 2;
 ostream* logger::nix = &nullStream;
 …
 logger::logger()
+{
-  instance = NULL;
   verbosity = 2;
 };
 …
+}
+/**
+ * Returns the singleton logger instance.
+ *
+ * \return logger instance
+ */
+logger* logger::getInstance() {
+  if (instance == NULL) {
+    instance = new logger();
+  }
+  return instance;
+}
+/**
+ * Purges the current logger instance.
+ */
+void logger::purgeInstance() {
+  if (instance != NULL) {
+    delete instance;
+  }
+  instance = NULL;
+}
+CONSTRUCT_SINGLETON(logger)
 /**

src/logger.hpp

-              rc695c9
+              r5f612ee
 #include <iostream>
+#include "Patterns/Singleton.hpp"
 using namespace std;
 class Verbose;
+class logger {
+class logger : public Singleton<logger> {
+  friend class Singleton<logger>;
 public :
   static ostream *nix;
   static int verbosity;
-  static logger* getInstance();
-  static void purgeInstance();
   static bool DoOutput();
   static void setVerbosity(int verbosityLevel);
 …
   /** Do not call this destructor directly, use purgeInstance() instead. */
   ~logger();
-private:
-  static logger* instance;
 };

src/molecule.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include <boost/bind.hpp>
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
  * 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(new atom), end(new atom),
+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), last_atom(0), InternalPointer(start)
+  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this)),
+  last_atom(0),
+  InternalPointer(start)
+{
   // init atom chain list
 …
   for(int i=MAX_ELEMENTS;i--;)
     ElementsInMolecule[i] = 0;
+  strcpy(name,World::get()->DefaultName);
+};
+  strcpy(name,World::getInstance().getDefaultName());
+};
+molecule *NewMolecule(){
+  return new molecule(World::getInstance().getPeriode());
+}
 /** Destructor of class molecule.
 …
   delete(first);
   delete(last);
+  delete(end);
+  delete(start);
+};
+  end->getWorld()->destroyAtom(end);
+  start->getWorld()->destroyAtom(start);
+};
+void DeleteMolecule(molecule *mol){
+  delete mol;
+}
+// getter and setter
+const std::string molecule::getName(){
+  return std::string(name);
+}
+void molecule::setName(const std::string _name){
+  OBSERVE;
+  strncpy(name,_name.c_str(),MAXSTRINGSIZE);
+}
+moleculeId_t molecule::getId(){
+  return id;
+}
+void molecule::setId(moleculeId_t _id){
+  id =_id;
+}
+const std::string molecule::getFormula(){
+  return *formula;
+}
+std::string molecule::calcFormula(){
+  std::map<atomicNumber_t,unsigned int> counts;
+  stringstream sstr;
+  periodentafel *periode = World::getInstance().getPeriode();
+  for(atom *Walker = start; Walker != end; Walker = Walker->next) {
+    counts[Walker->type->getNumber()]++;
+  }
+  std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
+  for(iter = counts.rbegin(); iter != counts.rend(); ++iter) {
+    atomicNumber_t Z = (*iter).first;
+    sstr << periode->FindElement(Z)->symbol << (*iter).second;
+  }
+  return sstr.str();
+}
 …
 bool molecule::AddAtom(atom *pointer)
+{
+  bool retval = false;
+  OBSERVE;
   if (pointer != NULL) {
     pointer->sort = &pointer->nr;
 …
+      }
+    }
     return add(pointer, end);
   } else
     return false;
+    retval = add(pointer, end);
+  }
+  return retval;
 };
 …
 atom * molecule::AddCopyAtom(atom *pointer)
+{
+  atom *retval = NULL;
+  OBSERVE;
   if (pointer != NULL) {
     atom *walker = new atom(pointer);
+    atom *walker = pointer->clone();
     walker->Name = Malloc<char>(strlen(pointer->Name) + 1, "atom::atom: *Name");
     strcpy (walker->Name, pointer->Name);
 …
       NoNonHydrogen++;
     AtomCount++;
     return walker;
   } else
     return NULL;
+    retval=walker;
+  }
+  return retval;
 };
 …
 bool molecule::AddHydrogenReplacementAtom(bond *TopBond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem)
+{
+  bool AllWentWell = true;    // flag gathering the boolean return value of molecule::AddAtom and other functions, as return value on exit
+  OBSERVE;
   double bondlength;  // bond length of the bond to be replaced/cut
   double bondangle;  // bond angle of the bond to be replaced/cut
   double BondRescale;   // rescale value for the hydrogen bond length
-  bool AllWentWell = true;    // flag gathering the boolean return value of molecule::AddAtom and other functions, as return value on exit
   bond *FirstBond = NULL, *SecondBond = NULL; // Other bonds in double bond case to determine "other" plane
   atom *FirstOtherAtom = NULL, *SecondOtherAtom = NULL, *ThirdOtherAtom = NULL; // pointer to hydrogen atoms to be added
 …
   double *matrix = NULL;
   bond *Binder = NULL;
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
 //  Log() << Verbose(3) << "Begin of AddHydrogenReplacementAtom." << endl;
 …
   switch(TopBond->BondDegree) {
     case 1:
       FirstOtherAtom = new atom();    // new atom
+      FirstOtherAtom = World::getInstance().createAtom();    // new atom
       FirstOtherAtom->type = elemente->FindElement(1);  // element is Hydrogen
       FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
 …
       // create the two Hydrogens ...
       FirstOtherAtom = new atom();
       SecondOtherAtom = new atom();
+      FirstOtherAtom = World::getInstance().createAtom();
+      SecondOtherAtom = World::getInstance().createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
 …
     case 3:
       // take the "usual" tetraoidal angle and add the three Hydrogen in direction of the bond (height of the tetraoid)
       FirstOtherAtom = new atom();
       SecondOtherAtom = new atom();
       ThirdOtherAtom = new atom();
+      FirstOtherAtom = World::getInstance().createAtom();
+      SecondOtherAtom = World::getInstance().createAtom();
+      ThirdOtherAtom = World::getInstance().createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
 …
 bool molecule::AddXYZFile(string filename)
+{
   istringstream *input = NULL;
   int NumberOfAtoms = 0; // atom number in xyz read
 …
     return false;
+  OBSERVE;
   getline(xyzfile,line,'\n'); // Read numer of atoms in file
   input = new istringstream(line);
 …
     MDSteps++;
   for(i=0;i<NumberOfAtoms;i++){
     Walker = new atom;
+    Walker = World::getInstance().createAtom();
     getline(xyzfile,line,'\n');
     istringstream *item = new istringstream(line);
 …
 molecule *molecule::CopyMolecule()
+{
   molecule *copy = new molecule(elemente);
+  molecule *copy = World::getInstance().createMolecule();
   atom *LeftAtom = NULL, *RightAtom = NULL;
 …
  */
 molecule* molecule::CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const {
   molecule *copy = new molecule(elemente);
+  molecule *copy = World::getInstance().createMolecule();
   ActOnCopyWithEachAtomIfTrue ( &molecule::AddCopyAtom, copy, &atom::IsInParallelepiped, offset, parallelepiped );
 …
 void molecule::SetBoxDimension(Vector *dim)
+{
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   cell_size[0] = dim->x[0];
   cell_size[1] = 0.;
 …
 bool molecule::CheckBounds(const Vector *x) const
+{
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   bool result = true;
   int j =-1;
 …
+  }
 };
+void molecule::flipActiveFlag(){
+  ActiveFlag = !ActiveFlag;
+}

src/molecule.hpp

-              rc695c9
+              r5f612ee
 #include <vector>
+#include <string>
+#include "defs.hpp"
 #include "graph.hpp"
 #include "stackclass.hpp"
 #include "tesselation.hpp"
+#include "Patterns/Observer.hpp"
+#include "Patterns/Cacheable.hpp"
 /****************************************** forward declarations *****************************/
 …
  * Class incorporates number of types
  */
+class molecule : public PointCloud {
+class molecule : public PointCloud , public Observable {
+  friend molecule *NewMolecule();
+  friend void DeleteMolecule(molecule *);
   public:
     const periodentafel * const elemente; //!< periodic table with each element
 …
     bool ActiveFlag;    //!< in a MoleculeListClass used to discern active from inactive molecules
     Vector Center;      //!< Center of molecule in a global box
+    int IndexNr;        //!< index of molecule in a MoleculeListClass
     char name[MAXSTRINGSIZE];         //!< arbitrary name
+    int IndexNr;        //!< index of molecule in a MoleculeListClass
+  molecule(const periodentafel * const teil);
+  virtual ~molecule();
+  private:
+    Cacheable<string> formula;
+    moleculeId_t id;
+  protected:
+    molecule(const periodentafel * const teil);
+    virtual ~molecule();
+public:
+  //getter and setter
+  const std::string getName();
+  moleculeId_t getId();
+  void setId(moleculeId_t);
+  void setName(const std::string);
+  const std::string getFormula();
+  std::string calcFormula();
   // re-definition of virtual functions from PointCloud
 …
   bool OutputTemperatureFromTrajectories(ofstream * const output, int startstep, int endstep);
+  // Manipulation routines
+  void flipActiveFlag();
   private:
   int last_atom;      //!< number given to last atom
 …
 };
+molecule *NewMolecule();
+void DeleteMolecule(molecule* mol);
 #include "molecule_template.hpp"
 /** A list of \a molecule classes.
  */
 class MoleculeListClass {
+class MoleculeListClass : public Observable {
   public:
     MoleculeList ListOfMolecules; //!< List of the contained molecules
     int MaxIndex;
   MoleculeListClass();
+  MoleculeListClass(World *world);
   ~MoleculeListClass();
 …
   bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);
   int NumberOfActiveMolecules();
   void Enumerate(ofstream *out);
+  void Enumerate(ostream *out);
   void Output(ofstream *out);
   void DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration);
   int CountAllAtoms() const;
+  // Methods moved here from the menus
+  // TODO: more refactoring needed on these methods
+  void flipChosen();
+  void createNewMolecule(periodentafel *periode);
+  void loadFromXYZ(periodentafel *periode);
+  void setMoleculeFilename();
+  void parseXYZIntoMolecule();
+  void eraseMolecule();
   // merging of molecules
 …
   private:
+  World *world; //!< The world this List belongs to. Needed to avoid deadlocks in the destructor
 };

src/molecule_dynamics.cpp

-              rc695c9
+              r5f612ee
  */
+#include "World.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 …
 double molecule::ConstrainedPotential(struct EvaluatePotential &Params)
+{
   double tmp, result;
+  double tmp = 0.;
+  double result = 0.;
   // go through every atom
   atom *Runner = NULL;
 …
   bool status = true;
   int MaxSteps = configuration.MaxOuterStep;
   MoleculeListClass *MoleculePerStep = new MoleculeListClass();
+  MoleculeListClass *MoleculePerStep = new MoleculeListClass(World::getPointer());
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
 …
   DoLog(1) && (Log() << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl);
   for (int step = 0; step <= MaxSteps; step++) {
     mol = new molecule(elemente);
+    mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
     Walker = start;

src/molecule_fragmentation.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
   //if (FragmentationToDo) {    // we should always store the fragments again as coordination might have changed slightly without changing bond structure
   // allocate memory for the pointer array and transmorph graphs into full molecular fragments
   BondFragments = new MoleculeListClass();
+  BondFragments = new MoleculeListClass(World::getPointer());
   int k=0;
   for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
 …
+{
   atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = new molecule(elemente);
+  molecule *Leaf = World::getInstance().createMolecule();
 //  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
 …
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
   enum Shading *ColorList = NULL;

src/molecule_geometry.cpp

-              rc695c9
+              r5f612ee
   bool status = true;
   const Vector *Center = DetermineCenterOfAll();
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = InverseMatrix(M);
 …
+{
   bool status = true;
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = InverseMatrix(M);
 …
 void molecule::TranslatePeriodically(const Vector *trans)
+{
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   double *M = ReturnFullMatrixforSymmetric(cell_size);
   double *Minv = InverseMatrix(M);
 …
+{
   atom *Walker = start;
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
   double *inversematrix = InverseMatrix(cell_size);

src/molecule_graph.cpp

-              rc695c9
+              r5f612ee
   LinkedCell *LC = NULL;
   bool free_BG = false;
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   if (BG == NULL) {
 …
     // put into new subgraph molecule and add this to list of subgraphs
     LeafWalker = new MoleculeLeafClass(LeafWalker);
     LeafWalker->Leaf = new molecule(elemente);
+    LeafWalker->Leaf = World::getInstance().createMolecule();
     LeafWalker->Leaf->AddCopyAtom(DFS.Root);

src/molecule_template.hpp

rc695c9	r5f612ee
16	16	#endif
17	17
	18	#include "atom.hpp"
18	19	/******************************************** declarations *****************************/
19	20

src/moleculelist.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
 /** Constructor for MoleculeListClass.
  */
+MoleculeListClass::MoleculeListClass()
+MoleculeListClass::MoleculeListClass(World *_world) :
+  world(_world)
+{
   // empty lists
 …
   for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
     DoLog(4) && (Log() << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl);
     delete (*ListRunner);
+    world->destroyMolecule(*ListRunner);
+  }
   DoLog(4) && (Log() << Verbose(4) << "Freeing ListOfMolecules." << endl);
 …
 void MoleculeListClass::insert(molecule *mol)
+{
+  OBSERVE;
   mol->IndexNr = MaxIndex++;
   ListOfMolecules.push_back(mol);
+  mol->signOn(this);
 };
 …
  * \param *out output stream
  */
+void MoleculeListClass::Enumerate(ofstream *out)
+{
+  element* Elemental = NULL;
+void MoleculeListClass::Enumerate(ostream *out)
+{
   atom *Walker = NULL;
+  int Counts[MAX_ELEMENTS];
+  periodentafel *periode = World::getInstance().getPeriode();
+  std::map<atomicNumber_t,unsigned int> counts;
   double size=0;
   Vector Origin;
   // header
   DoLog(0) && (Log() << Verbose(0) << "Index\tName\t\tAtoms\tFormula\tCenter\tSize" << endl);
   DoLog(0) && (Log() << Verbose(0) << "-----------------------------------------------" << endl);
+  (*out) << "Index\tName\t\tAtoms\tFormula\tCenter\tSize" << endl;
+  (*out) << "-----------------------------------------------" << endl;
   if (ListOfMolecules.size() == 0)
     DoLog(0) && (Log() << Verbose(0) << "\tNone" << endl);
+    (*out) << "\tNone" << endl;
   else {
     Origin.Zero();
     for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
-      // reset element counts
-      for (int j = 0; j<MAX_ELEMENTS;j++)
-        Counts[j] = 0;
       // count atoms per element and determine size of bounding sphere
       size=0.;
 …
       while (Walker->next != (*ListRunner)->end) {
         Walker = Walker->next;
         Counts[Walker->type->Z]++;
+        counts[Walker->type->getNumber()]++;
         if (Walker->x.DistanceSquared(&Origin) > size)
           size = Walker->x.DistanceSquared(&Origin);
+      }
       // output Index, Name, number of atoms, chemical formula
       DoLog(0) && (Log() << Verbose(0) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t");
+      Elemental = (*ListRunner)->elemente->end;
       while(Elemental->previous != (*ListRunner)->elemente->start) {
         Elemental = Elemental->previous;
         if (Counts[Elemental->Z] != 0)
           DoLog(0) && (Log() << Verbose(0) << Elemental->symbol << Counts[Elemental->Z]);
+      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
+      for(iter=counts.rbegin(); iter!=counts.rend();++iter){
+        atomicNumber_t Z =(*iter).first;
+        (*out) << periode->FindElement(Z)->getSymbol() << (*iter).second;
+      }
       // Center and size
       DoLog(0) && (Log() << Verbose(0) << "\t" << (*ListRunner)->Center << "\t" << sqrt(size) << endl);
+      (*out) << "\t" << (*ListRunner)->Center << "\t" << sqrt(size) << endl;
+    }
+  }
 …
   // remove src
   ListOfMolecules.remove(srcmol);
   delete(srcmol);
+  World::getInstance().destroyMolecule(srcmol);
   return true;
 };
 …
     DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl);
     if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
       CopyAtoms[Walker->nr] = new atom(Walker);
+      CopyAtoms[Walker->nr] = Walker->clone();
       mol->AddAtom(CopyAtoms[Walker->nr]);
       nr++;
 …
   stringstream line;
   atom *Walker = NULL;
   element *runner = NULL;
+  periodentafel *periode=World::getInstance().getPeriode();
   // open file for the force factors
 …
     //output << prefix << "Forces" << endl;
     for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+      runner = (*ListRunner)->elemente->start;
+      while (runner->next != (*ListRunner)->elemente->end) { // go through every element
+        runner = runner->next;
+        if ((*ListRunner)->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      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->Z == runner->Z) {
+            if (Walker->type->getNumber() == (*elemIter).first) {
               if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
 …
   ofstream output;
   double cell_size_backup[6];
   double * const cell_size = World::get()->cell_size;
+  double * const cell_size = World::getInstance().getDomain();
   // backup cell_size
 …
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
   molecule *mol = new molecule(periode);
+  molecule *mol = World::getInstance().createMolecule();
   atom *Walker = NULL;
   atom *Advancer = NULL;
 …
+    }
     // remove the molecule
     delete(*MolRunner);
+    World::getInstance().destroyMolecule(*MolRunner);
     ListOfMolecules.erase(MolRunner);
+  }
 …
   // 1. dissect the molecule into connected subgraphs
   if (!configuration->BG->ConstructBondGraph(mol)) {
     delete (mol);
+    World::getInstance().destroyMolecule(mol);
     DoeLog(1) && (eLog()<< Verbose(1) << "There are no bonds." << endl);
     return;
 …
   delete(BackEdgeStack);
   if ((Subgraphs == NULL) || (Subgraphs->next == NULL)) {
     delete (mol);
+    World::getInstance().destroyMolecule(mol);
     DoeLog(1) && (eLog()<< Verbose(1) << "There are no atoms." << endl);
     return;
 …
   molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
   for (int i=0;i<MolCount;i++) {
     molecules[i] = (molecule*) new molecule(mol->elemente);
+    molecules[i] = World::getInstance().createMolecule();
     molecules[i]->ActiveFlag = true;
     strncpy(molecules[i]->name, mol->name, MAXSTRINGSIZE);
 …
   return AtomNo;
+}
+/***********
+ * Methods Moved here from the menus
+ */
+void MoleculeListClass::flipChosen() {
+  int j;
+  Log() << Verbose(0) << "Enter index of molecule: ";
+  cin >> j;
+  for(MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    if ((*ListRunner)->IndexNr == j)
+      (*ListRunner)->ActiveFlag = !(*ListRunner)->ActiveFlag;
+}
+void MoleculeListClass::createNewMolecule(periodentafel *periode) {
+  OBSERVE;
+  molecule *mol = NULL;
+  mol = World::getInstance().createMolecule();
+  insert(mol);
+};
+void MoleculeListClass::loadFromXYZ(periodentafel *periode){
+  molecule *mol = NULL;
+  Vector center;
+  char filename[MAXSTRINGSIZE];
+  Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+  mol = World::getInstance().createMolecule();
+  do {
+    Log() << Verbose(0) << "Enter file name: ";
+    cin >> filename;
+  } while (!mol->AddXYZFile(filename));
+  mol->SetNameFromFilename(filename);
+  // center at set box dimensions
+  mol->CenterEdge(&center);
+  World::getInstance().getDomain()[0] = center.x[0];
+  World::getInstance().getDomain()[1] = 0;
+  World::getInstance().getDomain()[2] = center.x[1];
+  World::getInstance().getDomain()[3] = 0;
+  World::getInstance().getDomain()[4] = 0;
+  World::getInstance().getDomain()[5] = center.x[2];
+  insert(mol);
+}
+void MoleculeListClass::setMoleculeFilename() {
+  char filename[MAXSTRINGSIZE];
+  int nr;
+  molecule *mol = NULL;
+  do {
+    Log() << Verbose(0) << "Enter index of molecule: ";
+    cin >> nr;
+    mol = ReturnIndex(nr);
+  } while (mol == NULL);
+  Log() << Verbose(0) << "Enter name: ";
+  cin >> filename;
+  mol->SetNameFromFilename(filename);
+}
+void MoleculeListClass::parseXYZIntoMolecule(){
+  char filename[MAXSTRINGSIZE];
+  int nr;
+  molecule *mol = NULL;
+  mol = NULL;
+  do {
+   Log() << Verbose(0) << "Enter index of molecule: ";
+   cin >> nr;
+   mol = ReturnIndex(nr);
+  } while (mol == NULL);
+  Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+  do {
+   Log() << Verbose(0) << "Enter file name: ";
+   cin >> filename;
+  } while (!mol->AddXYZFile(filename));
+  mol->SetNameFromFilename(filename);
+};
+void MoleculeListClass::eraseMolecule(){
+  int nr;
+  molecule *mol = NULL;
+  Log() << Verbose(0) << "Enter index of molecule: ";
+  cin >> nr;
+  for(MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++)
+    if (nr == (*ListRunner)->IndexNr) {
+      mol = *ListRunner;
+      ListOfMolecules.erase(ListRunner);
+      World::getInstance().destroyMolecule(mol);
+      break;
+    }
+};
 …
   // remove the leaf itself
   if (Leaf != NULL) {
     delete (Leaf);
+    World::getInstance().destroyMolecule(Leaf);
     Leaf = NULL;
+  }

src/periodentafel.cpp

-              rc695c9
+              r5f612ee
 #include <fstream>
 #include <cstring>
+#include <cassert>
 #include "element.hpp"
 …
 #include "verbose.hpp"
+using namespace std;
 /************************************* Functions for class periodentafel ***************************/
 …
  * Initialises start and end of list and resets periodentafel::checkliste to false.
  */
+periodentafel::periodentafel() : start(new element), end(new element)
+{
+  start->previous = NULL;
+  start->next = end;
+  end->previous = start;
+  end->next = NULL;
+};
+periodentafel::periodentafel()
+{};
 /** destructor for class periodentafel
 …
+{
   CleanupPeriodtable();
-  delete(end);
-  delete(start);
 };
 …
  * \return true - succeeded, false - does not occur
  */
+bool periodentafel::AddElement(element * const pointer)
+{
+periodentafel::iterator periodentafel::AddElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  assert(!elements.count(Z));
   pointer->sort = &pointer->Z;
+  if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
+    DoLog(0) && (Log() << Verbose(0) << "Invalid Z number!\n");
+  return add(pointer, end);
+  if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
+    DoeLog(0) && (eLog() << Verbose(0) << "Invalid Z number!\n");
+  pair<iterator,bool> res = elements.insert(pair<atomicNumber_t,element*>(Z,pointer));
+  return res.first;
 };
 …
  * \return true - succeeded, false - element not found
  */
+bool periodentafel::RemoveElement(element * const pointer)
+{
+  return remove(pointer, start, end);
+void periodentafel::RemoveElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  elements.erase(Z);
 };
 …
  * \return true - succeeded, false - does not occur
  */
+bool periodentafel::CleanupPeriodtable()
+{
+  return cleanup(start,end);
+void periodentafel::CleanupPeriodtable()
+{
+  for(iterator iter=elements.begin();iter!=elements.end();++iter){
+    delete(*iter).second;
+  }
+  elements.clear();
 };
 …
  * \return pointer to element or NULL if not found
  */
 element * const periodentafel::FindElement(const int Z) const
+{
   element *walker = find(&Z, start,end);
   return(walker);
+const element * periodentafel::FindElement(atomicNumber_t Z) const
+{
+  const_iterator res = elements.find(Z);
+  return res!=elements.end()?((*res).second):0;
 };
 …
  * \return pointer to element
  */
+element * const periodentafel::FindElement(const char * const shorthand) const
+{
+  element *walker =  periodentafel::start;
+  while (walker->next != periodentafel::end) {
+    walker = walker->next;
+    if (strncmp(walker->symbol, shorthand, 3) == 0)
+      return(walker);
+  }
+  return (NULL);
+const element * periodentafel::FindElement(const char * const shorthand) const
+{
+  element *res = 0;
+  for(const_iterator iter=elements.begin();iter!=elements.end();++iter) {
+    if((*iter).second->getSymbol() == shorthand){
+      res = (*iter).second;
+      break;
+    }
+  }
+  return res;
 };
 /** Asks for element number and returns pointer to element
  */
 element * const periodentafel::AskElement() const
+{
   element *walker = NULL;
+const element * periodentafel::AskElement() const
+{
+  const element *walker = NULL;
   int Z;
   do {
 …
  * \return pointer to either present or newly created element
  */
 element * const periodentafel::EnterElement()
+{
   element *walker = NULL;
   int Z = -1;
+const element * periodentafel::EnterElement()
+{
+  const element *res = NULL;
+  atomicNumber_t Z = 0;
   DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
   cin >> Z;
+  walker = FindElement(Z);
+  if (walker == NULL) {
+  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);
     walker = new element;
     walker->Z = Z;
+    tmp = new element;
+    tmp->Z = Z;
     DoLog(0) && (Log() << Verbose(0) << "Mass: " << endl);
     cin >> walker->mass;
+    cin >> tmp->mass;
     DoLog(0) && (Log() << Verbose(0) << "Name [max 64 chars]: " << endl);
     cin >> walker->name;
+    cin >> tmp->name;
     DoLog(0) && (Log() << Verbose(0) << "Short form [max 3 chars]: " << endl);
+    cin >> walker->symbol;
+    periodentafel::AddElement(walker);
+  }
+  return(walker);
+};
+    cin >> tmp->symbol;
+    AddElement(tmp);
+    res = tmp;
+  }
+  return res;
+};
+/******************** Access to iterators ****************************/
+periodentafel::const_iterator periodentafel::begin(){
+  return elements.begin();
+}
+periodentafel::const_iterator periodentafel::end(){
+  return elements.end();
+}
+periodentafel::reverse_iterator periodentafel::rbegin(){
+  return reverse_iterator(elements.end());
+}
+periodentafel::reverse_iterator periodentafel::rend(){
+  return reverse_iterator(elements.begin());
+}
 /** Prints period table to given stream.
  * \param output stream
  */
 bool periodentafel::Output(ofstream * const output) const
+bool periodentafel::Output(ostream * const output) const
+{
   bool result = true;
-  element *walker = start;
   if (output != NULL) {
+    while (walker->next != end) {
+      walker = walker->next;
+      result = result && walker->Output(output);
+    for(const_iterator iter=elements.begin(); iter !=elements.end();++iter){
+      result = result && (*iter).second->Output(output);
+    }
     return result;
 …
  * \param *checkliste elements table for this molecule
  */
+bool periodentafel::Checkout(ofstream * const output, const int * const checkliste) const
+{
+  element *walker = start;
+bool periodentafel::Checkout(ostream * const output, const int * const checkliste) const
+{
   bool result = true;
   int No = 1;
 …
     *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
     *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
+    while (walker->next != end) {
+      walker = walker->next;
+      if ((walker != NULL) && (walker->Z > 0) && (walker->Z < MAX_ELEMENTS) && (checkliste[walker->Z])) {
+        walker->No = No;
+        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);
+    for(const_iterator iter=elements.begin(); iter!=elements.end();++iter){
+      if (((*iter).first < MAX_ELEMENTS) && (checkliste[(*iter).first])) {
+        (*iter).second->No = No;
+        result = result && (*iter).second->Checkout(output, No++, checkliste[(*iter).first]);
+      }
+    }
 …
+{
   ifstream infile;
-  double tmp;
   element *ptr;
+  map<atomicNumber_t,element*> parsedElems;
   bool status = true;
   bool otherstatus = true;
 …
       //neues->Output((ofstream *)&cout);
       if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
         periodentafel::AddElement(neues);
+        parsedElems[neues->getNumber()] = neues;
       else {
         DoLog(0) && (Log() << Verbose(0) << "Could not parse element: ");
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->Valence;
+      atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->Valence;
       infile >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->NoValenceOrbitals;
+      atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->NoValenceOrbitals;
       infile >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
       infile >> ws;
       infile >> ptr->HBondDistance[0];
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
       infile >> ws;
       infile >> ptr->HBondAngle[0];
 …
     otherstatus = false;
+  if (!otherstatus)
+  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;
 …
     f << header1 << endl;
     f << header2 << endl;
+    element *walker = periodentafel::start;
+    while (walker->next != periodentafel::end) {
+      walker = walker->next;
+      result = result && walker->Output(&f);
+    for(const_iterator iter=elements.begin();iter!=elements.end();++iter){
+         result = result && (*iter).second->Output(&f);
+    }
     f.close();

src/periodentafel.hpp

-              rc695c9
+              r5f612ee
 #ifndef PERIODENTAFEL_HPP_
 #define PERIODENTAFEL_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
 …
 #include <iostream>
+#include <map>
+#include <iterator>
 #include "defs.hpp"
+#include "types.hpp"
 /****************************************** forward declarations *****************************/
 …
  */
 class periodentafel {
+  /******* Types *********/
+  private:
+    typedef std::map<atomicNumber_t,element*> elementSet;
   public:
+    element *start; //!< start of element list
+    element *end;   //!< end of element list
+    typedef elementSet::iterator iterator;
+    typedef elementSet::const_iterator const_iterator;
+    typedef std::reverse_iterator<const_iterator> reverse_iterator;
+  public:
     char header1[MAXSTRINGSIZE]; //!< store first header line
     char header2[MAXSTRINGSIZE]; //!< store second header line
 …
   ~periodentafel();
+  bool AddElement(element * const pointer);
+  bool RemoveElement(element * const pointer);
+  bool CleanupPeriodtable();
+  element * const FindElement(const int Z) const;
+  element * const FindElement(const char * const shorthand) const;
+  element * const AskElement() const;
+  element * const EnterElement();
+  bool Output(ofstream * const output) const;
+  bool Checkout(ofstream * const output, const int * const checkliste) const;
+  iterator AddElement(element * const pointer);
+  void RemoveElement(element * const pointer);
+  void CleanupPeriodtable();
+  const element *FindElement(atomicNumber_t) const;
+  const element *FindElement(const char * const shorthand) const;
+  const element *AskElement() const;
+  const element *EnterElement();
+  const_iterator begin();
+  const_iterator end();
+  reverse_iterator rbegin();
+  reverse_iterator rend();
+  bool Output(std::ostream * const output) const;
+  bool Checkout(std::ostream * const output, const int * const checkliste) const;
   bool LoadPeriodentafel(const char * const path);
   bool StorePeriodentafel(const char * const path) const;
   private:
+    elementSet elements;
 };

src/tesselation.cpp

rc695c9	r5f612ee
4938	4938	}
4939	4939	}
4940		delete (DegeneratedTriangles);
	4940	delete DegeneratedTriangles;
	4941
4941	4942	/// 3. Find connected endpoint candidates and put them into a polygon
4942	4943	UniquePolygonSet ListofDegeneratedPolygons;

src/tesselationhelpers.cpp

rc695c9	r5f612ee
27	27	int signum;
28	28	gsl_permutation *p = gsl_permutation_alloc(A->size1);
29		gsl_matrix *tmpA;
	29	gsl_matrix *tmpA=0;
30	30
31	31	if (inPlace)

src/unittests/ActOnAllUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "memoryallocator.hpp"
 #include "vector.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
+{
   VL.EmptyList();
+  // Ref was copy constructed, hence has to be cleaned, too!
+  Ref.EmptyList();
+  MemoryUsageObserver::purgeInstance();
 };
 …
   VL.ActOnAll( (void (Vector::*)(const double ** const)) &Vector::Scale, (const double ** const)&inverses );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
+  Free(factors);
+  Free(inverses);
 };
 …
+  }
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "AnalysisCorrelationToPointUnitTest.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
 …
 #include "periodentafel.hpp"
 #include "tesselation.hpp"
+#include "World.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  TestList = new MoleculeListClass;
+  TestList = World::getInstance().getMolecules();
+  TestList->insert(TestMolecule);
   TestMolecule->ActiveFlag = true;
-  TestList->insert(TestMolecule);
   // init point
 …
     delete(binmap);
-  // remove
-  delete(TestList);
-  // note that all the atoms are cleaned by TestMolecule
   delete(point);
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
 };
 …
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
 …
 #include "periodentafel.hpp"
 #include "tesselation.hpp"
+#include "World.hpp"
+#include "Helpers/Assert.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
+{
+  ASSERT_DO(Assert::Throw);
   atom *Walker = NULL;
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens) base
   TestSurfaceMolecule = new molecule(tafel);
   Walker = new atom();
+  TestSurfaceMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
   TestList = new MoleculeListClass;
+  TestList = World::getInstance().getMolecules();
   TestSurfaceMolecule->ActiveFlag = true;
   TestList->insert(TestSurfaceMolecule);
 …
   // add outer atoms
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 0., 4. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 4., 4. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 4., 0. );
   TestMolecule->AddAtom(Walker);
   // add inner atoms
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
 …
     delete(binmap);
-  // remove
-  delete(TestList);
   delete(Surface);
   // note that all the atoms are cleaned by TestMolecule
   delete(LC);
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
 };
 …
   CPPUNIT_ASSERT_EQUAL( 1, tester->second );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "AnalysisPairCorrelationUnitTest.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
 …
 #include "periodentafel.hpp"
 #include "tesselation.hpp"
+#include "World.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
   TestList = new MoleculeListClass;
+  TestList = World::getInstance().getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
 …
     delete(binmap);
-  // remove
-  delete(TestList);
   // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
+  errorLogger::purgeInstance();
 };
 …
   CPPUNIT_ASSERT_EQUAL( 6, tester->second );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/CountBondsUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
 #include "CountBondsUnitTest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
+{
   atom *Walker = NULL;
+  BG = NULL;
+  filename = NULL;
   // init private all pointers to zero
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(oxygen);
   // construct molecule (water molecule)
+  molecules = new MoleculeListClass;
+  TestMolecule1 = new molecule(tafel);
+  Walker = new atom();
+  TestMolecule1 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(-0.2418, 0.9350, 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0.9658, 0., 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = oxygen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule1->AddAtom(Walker);
+  molecules->insert(TestMolecule1);
+  TestMolecule2 = new molecule(tafel);
+  Walker = new atom();
+  TestMolecule2 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(-0.2418, 0.9350, 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0.9658, 0., 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = oxygen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule2->AddAtom(Walker);
+  molecules = World::getInstance().getMolecules();
+  molecules->insert(TestMolecule1);
   molecules->insert(TestMolecule2);
 …
   delete(BG);
+  // remove molecule
+  delete(molecules);
+  // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
 };
 …
   TestMolecule2->Scale((const double ** const)&mirror);
+  delete(mirror);
+};
+/********************************************** Main routine **************************************/
+int main(int argc, char **argv)
+{
+  // Get the top level suite from the registry
+  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
+  // Adds the test to the list of test to run
+  CppUnit::TextUi::TestRunner runner;
+  runner.addTest( suite );
+  // Change the default outputter to a compiler error format outputter
+  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
+                                                       std::cerr ) );
+  // Run the tests.
+  bool wasSucessful = runner.run();
+  // Return error code 1 if the one of test failed.
+  return wasSucessful ? 0 : 1;
+};
+  delete[](mirror);
+};

src/unittests/LinkedCellUnitTest.cpp

-              rc695c9
+              r5f612ee
 #include "periodentafel.hpp"
 #include "LinkedCellUnitTest.hpp"
+#include "World.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (water molecule)
   TestMolecule = new molecule(tafel);
+  TestMolecule = World::getInstance().createMolecule();
   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 = new atom();
+        Walker = World::getInstance().createAtom();
         Walker->type = hydrogen;
         Walker->node->Init(x, y, z );
 …
+{
   delete(LC);
+  delete(TestMolecule);
+  // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
 };
 …
   // check internal vectors, returns false, because this atom is not in LC-list!
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->Name = Malloc<char>(6, "LinkedCellTest::SetIndexToNodeTest - Walker");
   strcpy(Walker->Name, "test");
   Walker->x.Init(1,1,1);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   delete(Walker);
+  World::getInstance().destroyAtom(Walker);
   // check out of bounds vectors
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->Name = Malloc<char>(6, "LinkedCellTest::SetIndexToNodeTest - Walker");
   strcpy(Walker->Name, "test");
   Walker->x.Init(0,-1,0);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   delete(Walker);
+  World::getInstance().destroyAtom(Walker);
 };
 …
   delete(ListOfPoints);
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/Makefile.am

-              rc695c9
+              r5f612ee
 AM_LDFLAGS = $(CPPUNIT_LIBS) -ldl
 AM_CXXFLAGS = $(CPPUNIT_CFLAGS)
+MENUTESTS = \
+  ActionSequenceTest
 TESTS = \
 …
   AnalysisCorrelationToSurfaceUnitTest \
   AnalysisPairCorrelationUnitTest \
+  atomsCalculationTest \
+  AtomDescriptorTest \
   BondGraphUnitTest \
+  CacheableTest \
   CountBondsUnitTest \
   GSLMatrixSymmetricUnitTest \
 …
   ListOfBondsUnitTest \
   LogUnitTest \
+  manipulateAtomsTest \
   MemoryUsageObserverUnitTest \
   MemoryAllocatorUnitTest \
+  MoleculeDescriptorTest \
+  ObserverTest \
+  SingletonTest \
   StackClassUnitTest \
   TesselationUnitTest \
   Tesselation_BoundaryTriangleUnitTest \
   Tesselation_InOutsideUnitTest \
+  VectorUnitTest
+  VectorUnitTest \
+  ${MENUTESTS}
+check_PROGRAMS = $(TESTS)
+noinst_PROGRAMS = $(TESTS)
+ActOnAllUnitTest_SOURCES = ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
+ActOnAllUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+AnalysisBondsUnitTests_SOURCES = analysisbondsunittest.cpp analysisbondsunittest.hpp
+AnalysisBondsUnitTests_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+AnalysisCorrelationToPointUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToPointUnitTest.cpp AnalysisCorrelationToPointUnitTest.hpp
+AnalysisCorrelationToPointUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+AnalysisCorrelationToSurfaceUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToSurfaceUnitTest.cpp AnalysisCorrelationToSurfaceUnitTest.hpp
+AnalysisCorrelationToSurfaceUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+AnalysisPairCorrelationUnitTest_SOURCES = analysis_correlation.hpp AnalysisPairCorrelationUnitTest.cpp AnalysisPairCorrelationUnitTest.hpp
+AnalysisPairCorrelationUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+BondGraphUnitTest_SOURCES = bondgraphunittest.cpp bondgraphunittest.hpp
+BondGraphUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+CountBondsUnitTest_SOURCES = CountBondsUnitTest.cpp CountBondsUnitTest.hpp
+CountBondsUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+GSLMatrixSymmetricUnitTest_SOURCES = gslmatrixsymmetricunittest.cpp gslmatrixsymmetricunittest.hpp
+GSLMatrixSymmetricUnitTest_LDADD = ../libgslwrapper.a
+GSLMatrixUnitTest_SOURCES = gslmatrixunittest.cpp gslmatrixunittest.hpp
+GSLMatrixUnitTest_LDADD = ../libgslwrapper.a
+GSLVectorUnitTest_SOURCES = gslvectorunittest.cpp gslvectorunittest.hpp
+GSLVectorUnitTest_LDADD = ../libgslwrapper.a
+InfoUnitTest_SOURCES = infounittest.cpp infounittest.hpp
+InfoUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+LinearSystemOfEquationsUnitTest_SOURCES = linearsystemofequationsunittest.cpp linearsystemofequationsunittest.hpp
+LinearSystemOfEquationsUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+LinkedCellUnitTest_SOURCES = LinkedCellUnitTest.cpp LinkedCellUnitTest.hpp
+LinkedCellUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+ListOfBondsUnitTest_SOURCES = listofbondsunittest.cpp listofbondsunittest.hpp
+ListOfBondsUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+LogUnitTest_SOURCES = logunittest.cpp logunittest.hpp
+LogUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+MemoryAllocatorUnitTest_SOURCES = memoryallocatorunittest.cpp memoryallocatorunittest.hpp
+MemoryAllocatorUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+MemoryUsageObserverUnitTest_SOURCES = memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
+MemoryUsageObserverUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+StackClassUnitTest_SOURCES = stackclassunittest.cpp stackclassunittest.hpp
+StackClassUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+TesselationUnitTest_SOURCES = tesselationunittest.cpp tesselationunittest.hpp
+TesselationUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+Tesselation_BoundaryTriangleUnitTest_SOURCES = tesselation_boundarytriangleunittest.cpp tesselation_boundarytriangleunittest.hpp
+Tesselation_BoundaryTriangleUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+Tesselation_InOutsideUnitTest_SOURCES = tesselation_insideoutsideunittest.cpp tesselation_insideoutsideunittest.hpp
+Tesselation_InOutsideUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+VectorUnitTest_SOURCES = vectorunittest.cpp vectorunittest.hpp
+VectorUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+check_PROGRAMS = $(TESTS)
+noinst_PROGRAMS = $(TESTS) TestRunner
+GSLLIBS = ../libgslwrapper.a
+ALLLIBS = ../libmolecuilder.a ${GSLLIBS} $(BOOST_LIB) ${BOOST_THREAD_LIB}
+TESTSOURCES = \
+  ActOnAllUnitTest.cpp \
+  ActionSequenceTest.cpp \
+  analysisbondsunittest.cpp \
+  AnalysisCorrelationToPointUnitTest.cpp \
+  AnalysisCorrelationToSurfaceUnitTest.cpp  \
+  AnalysisPairCorrelationUnitTest.cpp \
+  AtomDescriptorTest.cpp \
+  atomsCalculationTest.cpp \
+  bondgraphunittest.cpp \
+  CacheableTest.cpp \
+  CountBondsUnitTest.cpp \
+  gslmatrixsymmetricunittest.cpp \
+  gslmatrixunittest.cpp \
+  gslvectorunittest.cpp \
+  infounittest.cpp \
+  linearsystemofequationsunittest.cpp \
+  LinkedCellUnitTest.cpp \
+  listofbondsunittest.cpp \
+  logunittest.cpp \
+  manipulateAtomsTest.cpp \
+  memoryallocatorunittest.cpp  \
+  memoryusageobserverunittest.cpp \
+  MoleculeDescriptorTest.cpp \
+  ObserverTest.cpp \
+  SingletonTest.cpp \
+  stackclassunittest.cpp \
+  tesselationunittest.cpp \
+  tesselation_boundarytriangleunittest.cpp \
+  tesselation_insideoutsideunittest.cpp \
+  vectorunittest.cpp
+TESTHEADERS = \
+  ActOnAllUnitTest.hpp \
+  ActionSequenceTest.hpp \
+  analysisbondsunittest.hpp \
+  AnalysisCorrelationToPointUnitTest.hpp \
+  AnalysisCorrelationToSurfaceUnitTest.hpp  \
+  AnalysisPairCorrelationUnitTest.hpp \
+  AtomDescriptorTest.hpp \
+  atomsCalculationTest.hpp \
+  bondgraphunittest.hpp \
+  CacheableTest.hpp \
+  CountBondsUnitTest.hpp \
+  gslmatrixsymmetricunittest.hpp \
+  gslmatrixunittest.hpp \
+  gslvectorunittest.hpp \
+  infounittest.hpp \
+  linearsystemofequationsunittest.hpp \
+  LinkedCellUnitTest.hpp \
+  listofbondsunittest.hpp \
+  logunittest.hpp \
+  manipulateAtomsTest.hpp \
+  memoryallocatorunittest.hpp  \
+  memoryusageobserverunittest.hpp \
+  MoleculeDescriptorTest.hpp \
+  ObserverTest.hpp \
+  SingletonTest.hpp \
+  stackclassunittest.hpp \
+  tesselationunittest.hpp \
+  tesselation_boundarytriangleunittest.hpp \
+  tesselation_insideoutsideunittest.hpp \
+  vectorunittest.hpp
+ActOnAllUnitTest_SOURCES = UnitTestMain.cpp ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
+ActOnAllUnitTest_LDADD = ${ALLLIBS}
+AnalysisBondsUnitTests_SOURCES = UnitTestMain.cpp analysisbondsunittest.cpp analysisbondsunittest.hpp
+AnalysisBondsUnitTests_LDADD = ${ALLLIBS}
+AnalysisCorrelationToPointUnitTest_SOURCES = UnitTestMain.cpp analysis_correlation.hpp AnalysisCorrelationToPointUnitTest.cpp AnalysisCorrelationToPointUnitTest.hpp
+AnalysisCorrelationToPointUnitTest_LDADD = ${ALLLIBS}
+AnalysisCorrelationToSurfaceUnitTest_SOURCES = UnitTestMain.cpp analysis_correlation.hpp AnalysisCorrelationToSurfaceUnitTest.cpp AnalysisCorrelationToSurfaceUnitTest.hpp
+AnalysisCorrelationToSurfaceUnitTest_LDADD = ${ALLLIBS}
+AnalysisPairCorrelationUnitTest_SOURCES = UnitTestMain.cpp analysis_correlation.hpp AnalysisPairCorrelationUnitTest.cpp AnalysisPairCorrelationUnitTest.hpp
+AnalysisPairCorrelationUnitTest_LDADD = ${ALLLIBS}
+atomsCalculationTest_SOURCES = UnitTestMain.cpp atomsCalculationTest.cpp atomsCalculationTest.hpp
+atomsCalculationTest_LDADD = ${ALLLIBS}
+BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
+BondGraphUnitTest_LDADD = ${ALLLIBS}
+CountBondsUnitTest_SOURCES = UnitTestMain.cpp CountBondsUnitTest.cpp CountBondsUnitTest.hpp
+CountBondsUnitTest_LDADD = ${ALLLIBS}
+GSLMatrixSymmetricUnitTest_SOURCES = UnitTestMain.cpp gslmatrixsymmetricunittest.cpp gslmatrixsymmetricunittest.hpp
+GSLMatrixSymmetricUnitTest_LDADD = ${GSLLIBS}
+GSLMatrixUnitTest_SOURCES = UnitTestMain.cpp gslmatrixunittest.cpp gslmatrixunittest.hpp
+GSLMatrixUnitTest_LDADD = ${GSLLIBS}
+GSLVectorUnitTest_SOURCES = UnitTestMain.cpp gslvectorunittest.cpp gslvectorunittest.hpp
+GSLVectorUnitTest_LDADD = ${GSLLIBS}
+InfoUnitTest_SOURCES = UnitTestMain.cpp infounittest.cpp infounittest.hpp
+InfoUnitTest_LDADD = ${ALLLIBS}
+LinearSystemOfEquationsUnitTest_SOURCES = UnitTestMain.cpp linearsystemofequationsunittest.cpp linearsystemofequationsunittest.hpp
+LinearSystemOfEquationsUnitTest_LDADD = ${ALLLIBS}
+LinkedCellUnitTest_SOURCES = UnitTestMain.cpp LinkedCellUnitTest.cpp LinkedCellUnitTest.hpp
+LinkedCellUnitTest_LDADD = ${ALLLIBS}
+ListOfBondsUnitTest_SOURCES = UnitTestMain.cpp listofbondsunittest.cpp listofbondsunittest.hpp
+ListOfBondsUnitTest_LDADD = ${ALLLIBS}
+LogUnitTest_SOURCES = UnitTestMain.cpp logunittest.cpp logunittest.hpp
+LogUnitTest_LDADD = ${ALLLIBS}
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
+MemoryAllocatorUnitTest_LDADD = ${ALLLIBS}
+MemoryUsageObserverUnitTest_SOURCES = UnitTestMain.cpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
+MemoryUsageObserverUnitTest_LDADD = ${ALLLIBS}
+MoleculeDescriptorTest_SOURCES = UnitTestMain.cpp MoleculeDescriptorTest.cpp MoleculeDescriptorTest.hpp
+MoleculeDescriptorTest_LDADD = ${ALLLIBS}
+SingletonTest_SOURCES = UnitTestMain.cpp SingletonTest.cpp SingletonTest.hpp
+SingletonTest_LDADD = $(BOOST_LIB) ${BOOST_THREAD_LIB}
+StackClassUnitTest_SOURCES = UnitTestMain.cpp stackclassunittest.cpp stackclassunittest.hpp
+StackClassUnitTest_LDADD = ${ALLLIBS}
+TesselationUnitTest_SOURCES = UnitTestMain.cpp tesselationunittest.cpp tesselationunittest.hpp
+TesselationUnitTest_LDADD = ${ALLLIBS}
+Tesselation_BoundaryTriangleUnitTest_SOURCES = UnitTestMain.cpp tesselation_boundarytriangleunittest.cpp tesselation_boundarytriangleunittest.hpp
+Tesselation_BoundaryTriangleUnitTest_LDADD = ${ALLLIBS}
+Tesselation_InOutsideUnitTest_SOURCES = UnitTestMain.cpp tesselation_insideoutsideunittest.cpp tesselation_insideoutsideunittest.hpp
+Tesselation_InOutsideUnitTest_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/analysisbondsunittest.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include "World.hpp"
 #include "analysis_bonds.hpp"
 #include "analysisbondsunittest.hpp"
 …
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
 …
   // remove molecule
   delete(TestMolecule);
+  World::getInstance().destroyMolecule(TestMolecule);
   // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::purgeInstance();
 };
 …
   CPPUNIT_ASSERT_EQUAL( 0. , Max );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/bondgraphunittest.cpp

-              rc695c9
+              r5f612ee
 #include <cstring>
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
 #include "periodentafel.hpp"
 #include "bondgraphunittest.hpp"
+#include "World.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 0., 0. );
 …
   // remove molecule
+  delete(TestMolecule);
+  // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::getInstance().destroyMolecule(TestMolecule);
+  // note that all the atoms, molecules, the tafel and the elements
+  // are all cleaned when the world is destroyed
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
 };
 …
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/gslmatrixsymmetricunittest.cpp

-              rc695c9
+              r5f612ee
 #include "gslmatrixsymmetricunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   CPPUNIT_ASSERT_EQUAL( -26.5, m->Determinant() );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/gslmatrixunittest.cpp

-              rc695c9
+              r5f612ee
 #include "gslmatrixunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   CPPUNIT_ASSERT_EQUAL( false, m->IsPositiveDefinite() );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/gslvectorunittest.cpp

-              rc695c9
+              r5f612ee
 #include "gslvectorunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
 };
 /** UnitTest for operators.
  */
 …
   CPPUNIT_ASSERT_EQUAL( true, unit.IsOne() );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/infounittest.cpp

-              rc695c9
+              r5f612ee
 #include "info.hpp"
 #include "infounittest.hpp"
+#include "log.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
 void InfoTest::tearDown()
+{
+  logger::purgeInstance();
 };
 …
   CPPUNIT_ASSERT_EQUAL( 1, test.verbosity );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/linearsystemofequationsunittest.cpp

-              rc695c9
+              r5f612ee
 #include "linearsystemofequationsunittest.hpp"
 #include "vector.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   delete[](array);
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/listofbondsunittest.cpp

-              rc695c9
+              r5f612ee
 #include "listofbondsunittest.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
   // construct periodentafel
   tafel = new periodentafel;
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
   Walker = new atom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = new atom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
+{
   // remove
+  delete(TestMolecule);
+  // note that all the atoms are cleaned by TestMolecule
+  delete(tafel);
+  // note that element is cleaned by periodentafel
+  World::getInstance().destroyMolecule(TestMolecule);
+  // note that all the atoms, molecules, the tafel and the elements
+  // are all cleaned when the world is destroyed
+  World::purgeInstance();
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
 };
 …
   // remove atom2
   delete(atom2);
+  World::getInstance().destroyAtom(atom2);
   // check bond if removed from other atom
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/logunittest.cpp

-              rc695c9
+              r5f612ee
 #include "verbose.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
 void LogTest::tearDown()
+{
+  logger::purgeInstance();
+  errorLogger::purgeInstance();
 };
 …
 void LogTest::logTest()
+{
   logger::getInstance()->setVerbosity(2);
+  logger::getInstance().setVerbosity(2);
   DoLog(0) && (Log() << Verbose(0) << "Verbosity level is set to 2." << endl);
   DoLog(0) && (Log() << Verbose(0) << "Test level 0" << endl);
 …
   DoeLog(4) && (eLog()<< Verbose(4) << "This should not be printed." << endl);
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/memoryallocatorunittest.cpp

-              rc695c9
+              r5f612ee
 #include "memoryallocatorunittest.hpp"
 #include "helpers.hpp"
+#include "log.hpp"
 #include "defs.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
+{
   MemoryUsageObserver::getInstance()->purgeInstance();
+  logger::purgeInstance();
 };
 …
   Free(buffer2);
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/memoryusageobserverunittest.cpp

-              rc695c9
+              r5f612ee
 #include "memoryusageobserverunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 // Registers the fixture into the 'registry'
 …
+{
   MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
+  errorLogger::purgeInstance();
 };
 …
   MemoryUsageObserver::getInstance()->removeMemory(i);
   CPPUNIT_ASSERT_EQUAL((size_t) 0, MemoryUsageObserver::getInstance()->getUsedMemorySize());
+  Free(i);
 };
 …
   MemoryUsageObserver::getInstance()->removeMemory(i);
   CPPUNIT_ASSERT_EQUAL((size_t) 0, MemoryUsageObserver::getInstance()->getUsedMemorySize());
+  Free(i);
 };
 …
   MemoryUsageObserver::getInstance()->addMemory(j, sizeof(int));
   CPPUNIT_ASSERT_EQUAL(2 * sizeof(int), MemoryUsageObserver::getInstance()->getUsedMemorySize());
+  Free(i);
+  Free(j);
 };
 …
   MemoryUsageObserver::getInstance()->addMemory(i, sizeof(int));
   CPPUNIT_ASSERT_EQUAL(sizeof(int), MemoryUsageObserver::getInstance()->getUsedMemorySize());
+  Free(i);
 };
 …
   MemoryUsageObserver::getInstance()->addMemory(i, sizeof(int));
   CPPUNIT_ASSERT_EQUAL(2 * sizeof(int), MemoryUsageObserver::getInstance()->getMaximumUsedMemory());
+  Free(i);
 };
 …
   MemoryUsageObserver::getInstance()->removeMemory(i);
   CPPUNIT_ASSERT_EQUAL(sizeof(int), MemoryUsageObserver::getInstance()->getMaximumUsedMemory());
+  Free(i);
 };
 …
   MemoryUsageObserver::getInstance()->addMemory(i, sizeof(int));
   CPPUNIT_ASSERT_EQUAL(i, (int*) MemoryUsageObserver::getInstance()->getPointersToAllocatedMemory().begin()->first);
+  Free(i);
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/stackclassunittest.cpp

-              rc695c9
+              r5f612ee
 #include "stackclassunittest.hpp"
 #include "log.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 enum { testdimension=3 };
 …
   Stack->ClearStack();
   delete(Stack);
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
 };
 …
   CPPUNIT_ASSERT_EQUAL(0, Stack->ItemCount());
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/tesselation_boundarytriangleunittest.cpp

-              rc695c9
+              r5f612ee
 #include "tesselation_boundarytriangleunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 #define SPHERERADIUS 2.
 …
   // create nodes
+  TesselPoint *Walker = NULL;
+  Walker = new TesselPoint;
+  Walker->node = new Vector(0., 0., 0.);
+  Walker->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(Walker->Name, "1");
+  Walker->nr = 1;
+  points[0] = new BoundaryPointSet(Walker);
+  Walker = new TesselPoint;
+  Walker->node = new Vector(0., 1., 0.);
+  Walker->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(Walker->Name, "2");
+  Walker->nr = 2;
+  points[1] = new BoundaryPointSet(Walker);
+  Walker = new TesselPoint;
+  Walker->node = new Vector(1., 0., 0.);
+  Walker->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(Walker->Name, "3");
+  Walker->nr = 3;
+  points[2] = new BoundaryPointSet(Walker);
+  tesselpoints[0] = new TesselPoint;
+  tesselpoints[0]->node = new Vector(0., 0., 0.);
+  tesselpoints[0]->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(tesselpoints[0]->Name, "1");
+  tesselpoints[0]->nr = 1;
+  points[0] = new BoundaryPointSet(tesselpoints[0]);
+  tesselpoints[1] = new TesselPoint;
+  tesselpoints[1]->node = new Vector(0., 1., 0.);
+  tesselpoints[1]->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(tesselpoints[1]->Name, "2");
+  tesselpoints[1]->nr = 2;
+  points[1] = new BoundaryPointSet(tesselpoints[1]);
+  tesselpoints[2] = new TesselPoint;
+  tesselpoints[2] ->node = new Vector(1., 0., 0.);
+  tesselpoints[2] ->Name = Malloc<char>(3, "TesselationBoundaryTriangleTest::setUp - *Name");
+  strcpy(tesselpoints[2] ->Name, "3");
+  tesselpoints[2] ->nr = 3;
+  points[2] = new BoundaryPointSet(tesselpoints[2] );
   // create line
 …
+{
   delete(triangle);
+  for (int i=0;i<3;++i) {
+    // TesselPoint does not delete its vector as it only got a reference
+    delete tesselpoints[i]->node;
+    delete tesselpoints[i];
+  }
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 …
   CPPUNIT_ASSERT_EQUAL( true , Point == TestIntersection );
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/tesselation_boundarytriangleunittest.hpp

rc695c9	r5f612ee
35	35	class BoundaryLineSet *lines[3];
36	36	class BoundaryPointSet *points[3];
	37	class TesselPoint *tesselpoints[3];
37	38	LinkedCell::LinkedNodes Corners;
38	39	};

src/unittests/tesselation_insideoutsideunittest.cpp

-              rc695c9
+              r5f612ee
 #include "tesselation.hpp"
 #include "tesselation_insideoutsideunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 #define SPHERERADIUS 2.
 …
+      }
 };
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/tesselationunittest.cpp

-              rc695c9
+              r5f612ee
 #include "tesselation.hpp"
 #include "tesselationunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 #define SPHERERADIUS 2.
 …
+  }
+}
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/unittests/vectorunittest.cpp

-              rc695c9
+              r5f612ee
 #include "defs.hpp"
+#include "log.hpp"
+#include "memoryusageobserver.hpp"
 #include "vector.hpp"
 #include "vectorunittest.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 /********************************************** Test classes **************************************/
 …
 void VectorTest::tearDown()
+{
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
+  errorLogger::purgeInstance();
 };
 …
+}
-/********************************************** Main routine **************************************/
-int main(int argc, char **argv)
+{
-  // Get the top level suite from the registry
-  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
-  // Adds the test to the list of test to run
-  CppUnit::TextUi::TestRunner runner;
-  runner.addTest( suite );
-  // Change the default outputter to a compiler error format outputter
-  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
-                                                       std::cerr ) );
-  // Run the tests.
-  bool wasSucessful = runner.run();
-  // Return error code 1 if the one of test failed.
-  return wasSucessful ? 0 : 1;
-};

src/vector.cpp

-              rc695c9
+              r5f612ee
     return false;
+  }
+  delete(M);
   DoLog(1) && (Log() << Verbose(1) << "INFO: Line1a = " << *Line1a << ", Line1b = " << *Line1b << ", Line2a = " << *Line2a << ", Line2b = " << *Line2b << "." << endl);
 …
  * \return lhs + a
  */
 Vector& operator+=(Vector& a, const Vector& b)
+const Vector& operator+=(Vector& a, const Vector& b)
+{
   a.AddVector(&b);
 …
  * \return lhs - a
  */
 Vector& operator-=(Vector& a, const Vector& b)
+const Vector& operator-=(Vector& a, const Vector& b)
+{
   a.SubtractVector(&b);
 …
  * \return lhs.x[i] * m
  */
 Vector& operator*=(Vector& a, const double m)
+const Vector& operator*=(Vector& a, const double m)
+{
   a.Scale(m);
 …
  * \return a + b
  */
+Vector& operator+(const Vector& a, const Vector& b)
+{
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->AddVector(&b);
+  return *x;
+Vector const operator+(const Vector& a, const Vector& b)
+{
+  Vector x(a);
+  x.AddVector(&b);
+  return x;
 };
 …
  * \return a - b
  */
+Vector& operator-(const Vector& a, const Vector& b)
+{
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->SubtractVector(&b);
+  return *x;
+Vector const operator-(const Vector& a, const Vector& b)
+{
+  Vector x(a);
+  x.SubtractVector(&b);
+  return x;
 };
 …
  * \return m * a
  */
+Vector& operator*(const Vector& a, const double m)
+{
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->Scale(m);
+  return *x;
+Vector const operator*(const Vector& a, const double m)
+{
+  Vector x(a);
+  x.Scale(m);
+  return x;
 };
 …
  * \return m * a
  */
+Vector& operator*(const double m, const Vector& a )
+{
+  Vector *x = new Vector;
+  x->CopyVector(&a);
+  x->Scale(m);
+  return *x;
+Vector const operator*(const double m, const Vector& a )
+{
+  Vector x(a);
+  x.Scale(m);
+  return x;
 };
 …
 void Vector::CopyVector(const Vector * const y)
+{
+  for (int i=NDIM;i--;)
+    this->x[i] = y->x[i];
+  // check for self assignment
+  if(y!=this){
+    for (int i=NDIM;i--;)
+      this->x[i] = y->x[i];
+  }
+}
 …
 void Vector::CopyVector(const Vector &y)
+{
+  for (int i=NDIM;i--;)
+    this->x[i] = y.x[i];
+  // check for self assignment
+  if(&y!=this) {
+    for (int i=NDIM;i--;)
+      this->x[i] = y.x[i];
+  }
+}

src/vector.hpp

-              rc695c9
+              r5f612ee
   bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
   void WrapPeriodically(const double * const M, const double * const Minv);
 };
 ostream & operator << (ostream& ost, const Vector &m);
 bool operator==(const Vector& a, const Vector& b);
 Vector& operator+=(Vector& a, const Vector& b);
 Vector& operator-=(Vector& a, const Vector& b);
 Vector& operator*=(Vector& a, const double m);
 Vector& operator*(const Vector& a, const double m);
 Vector& operator*(const double m, const Vector& a);
 Vector& operator+(const Vector& a, const Vector& b);
 Vector& operator-(const Vector& a, const Vector& b);
+const Vector& operator+=(Vector& a, const Vector& b);
+const Vector& operator-=(Vector& a, const Vector& b);
+const Vector& operator*=(Vector& a, const double m);
+Vector const operator*(const Vector& a, const double m);
+Vector const operator*(const double m, const Vector& a);
+Vector const operator+(const Vector& a, const Vector& b);
+Vector const operator-(const Vector& a, const Vector& b);

Context Navigation

Changes in / [c695c9:5f612ee]

Legend:

Download in other formats: