Changes in / [326a43b:cbf01e]

Files:

• doc/Doxyfile (modified) (2 diffs)
• src/Actions/AtomsCalculation.hpp (added)
• src/Actions/AtomsCalculation_impl.hpp (added)
• src/Actions/Calculation.hpp (added)
• src/Actions/Calculation_impl.hpp (added)
• src/Actions/ManipulateAtomsProcess.cpp (added)
• src/Actions/ManipulateAtomsProcess.hpp (added)
• src/Actions/Process.cpp (modified) (3 diffs)
• src/Actions/Process.hpp (modified) (1 diff)
• src/Descriptors/AtomDescriptor.hpp (modified) (2 diffs)
• src/Descriptors/AtomDescriptor_impl.hpp (modified) (2 diffs)
• src/Descriptors/AtomIdDescriptor.cpp (modified) (3 diffs)
• src/Descriptors/AtomIdDescriptor_impl.hpp (modified) (2 diffs)
• src/Descriptors/AtomTypeDescriptor.cpp (added)
• src/Descriptors/AtomTypeDescriptor.hpp (added)
• src/Descriptors/AtomTypeDescriptor_impl.hpp (added)
• src/Legacy/oldmenu.cpp (modified) (9 diffs)
• src/Makefile.am (modified) (4 diffs)
• src/UIElements/Dialog.cpp (modified) (1 diff)
• src/UIElements/Dialog.hpp (modified) (9 diffs)
• src/UIElements/QT4/QTDialog.cpp (modified) (5 diffs)
• src/UIElements/QT4/QTDialog.hpp (modified) (13 diffs)
• src/UIElements/TextDialog.cpp (modified) (3 diffs)
• src/UIElements/TextDialog.hpp (modified) (6 diffs)
• src/UIElements/TextStatusIndicator.cpp (added)
• src/UIElements/TextStatusIndicator.hpp (added)
• src/UIElements/TextWindow.cpp (modified) (3 diffs)
• src/UIElements/TextWindow.hpp (modified) (2 diffs)
• src/World.cpp (modified) (9 diffs)
• src/World.hpp (modified) (3 diffs)
• src/WorldIterators.cpp (added)
• src/World_calculations.hpp (added)
• src/atom.cpp (modified) (5 diffs)
• src/atom.hpp (modified) (4 diffs)
• src/atom_atominfo.cpp (modified) (2 diffs)
• src/atom_atominfo.hpp (modified) (1 diff)
• src/atom_particleinfo.cpp (modified) (2 diffs)
• src/atom_particleinfo.hpp (modified) (1 diff)
• src/boundary.cpp (modified) (1 diff)
• src/builder.cpp (modified) (3 diffs)
• src/config.cpp (modified) (4 diffs)
• src/lists.cpp (added)
• src/lists.hpp (modified) (11 diffs)
• src/molecule.cpp (modified) (8 diffs)
• src/moleculelist.cpp (modified) (1 diff)
• src/unittests/AnalysisCorrelationToPointUnitTest.cpp (modified) (2 diffs)
• src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp (modified) (3 diffs)
• src/unittests/AnalysisPairCorrelationUnitTest.cpp (modified) (2 diffs)
• src/unittests/DescriptorUnittest.cpp (modified) (8 diffs)
• src/unittests/DescriptorUnittest.hpp (modified) (1 diff)
• src/unittests/Makefile.am (modified) (2 diffs)
• src/unittests/analysisbondsunittest.cpp (modified) (2 diffs)
• src/unittests/atomsCalculationTest.cpp (added)
• src/unittests/atomsCalculationTest.hpp (added)
• src/unittests/bondgraphunittest.cpp (modified) (2 diffs)
• src/unittests/listofbondsunittest.cpp (modified) (3 diffs)
• src/unittests/manipulateAtomsTest.cpp (added)
• src/unittests/manipulateAtomsTest.hpp (added)

doc/Doxyfile

@@ -114 +114 @@
 EXCLUDE                = 
 EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
+EXCLUDE_PATTERNS       = */unittests/* \
+                                                 */test/*
 EXAMPLE_PATH           = 
 EXAMPLE_PATTERNS       = *
@@ -126 +127 @@
 #---------------------------------------------------------------------------
 SOURCE_BROWSER         = YES
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
+INLINE_SOURCES         = YES
+STRIP_CODE_COMMENTS    = NO
 REFERENCED_BY_RELATION = NO
 REFERENCES_RELATION    = NO

src/Actions/Process.cpp

@@ -41 +41 @@
 }
 
+void Process::setCurrStep(int _currStep){
+  OBSERVE;
+  currStep = _currStep;
+}
+
 float Process::getDoneRatio() {
   if(getMaxSteps())
@@ -51 +56 @@
 }
 
+void Process::setMaxSteps(int _maxSteps){
+  maxSteps = _maxSteps;
+}
 
 void Process::start(){
@@ -69 +77 @@
   starts = false;
 }
+
 void Process::step(){
   OBSERVE;
   currStep++;
 }
+
 void Process::stop(){
   stops = true;

src/Actions/Process.hpp

@@ -29 +29 @@
   bool  doesStop();
   int   getCurrStep();
+  void  setCurrStep(int _currStep);
   float getDoneRatio();
   int   getMaxSteps();
+  void  setMaxSteps(int _maxSteps);
 
 protected:

src/Descriptors/AtomDescriptor.hpp

@@ -15 +15 @@
 #include "World.hpp"
 
+class World;
 class atom;
 
@@ -21 +22 @@
 
 class AtomDescriptor {
+  // close coupling to the world to allow access
   friend atom* World::getAtom(AtomDescriptor descriptor);
   friend std::vector<atom*> World::getAllAtoms(AtomDescriptor descriptor);
+  friend class World::AtomIterator;
 
   friend AtomDescriptor operator&&(const AtomDescriptor &lhs, const AtomDescriptor &rhs);

src/Descriptors/AtomDescriptor_impl.hpp

@@ -1 @@
-#include "Descriptors/AtomDescriptor.hpp"
+#ifndef ATOMDESCRIPTOR_IMPL_HPP
+#define ATOMDESCRIPTOR_IMPL_HPP
 
 /************************ Declarations of implementation Objects ************************/
@@ -72 +73 @@
   AtomDescriptor::impl_ptr arg;
 };
+
+#endif //ATOMDESCRIPTOR_IMPL_HPP

src/Descriptors/AtomIdDescriptor.cpp

@@ -22 +22 @@
 
 bool AtomIdDescriptor_impl::predicate(std::pair<int,atom*> atom) {
-  return atom.second->getId()==id;
+  return atom.first==id;
 }
 
@@ -29 +29 @@
 }
 
-#if 0
-
-// so far the lookuptable for Atoms-by-id does not work, since atoms don't get an ID upon creation.
-// instead of this we rely on walking through all atoms.
-
-atom *AtomIdDescriptor::find(){
+atom *AtomIdDescriptor_impl::find(){
   map<int,atom*> atoms = getAtoms();
   map<int,atom*>::iterator res = atoms.find(id);
@@ -40 +35 @@
 }
 
-vector<atom*> AtomIdDescriptor::findAll(){
+vector<atom*> AtomIdDescriptor_impl::findAll(){
   atom *res = find();
   return (res)?(vector<atom*>(1,res)):(vector<atom*>());
 }
-
-#endif

src/Descriptors/AtomIdDescriptor_impl.hpp

@@ -1 @@
-#include "Descriptors/AtomIdDescriptor.hpp"
+#ifndef ATOMIDDESCRIPTOR_IMPL_HPP
+#define ATOMIDDESCRIPTOR_IMPL_HPP
+
 #include "Descriptors/AtomDescriptor_impl.hpp"
 
@@ -11 +13 @@
 
 protected:
-#if 0
-  atom *find();
-  std::vector<atom*> findAll();
-#endif
+  virtual atom *find();
+  virtual std::vector<atom*> findAll();
 private:
   int id;
 };
+
+#endif //ATOMIDDESCRIPTOR_IMPL_HPP

src/Legacy/oldmenu.cpp

@@ -9 +9 @@
 #include "Legacy/oldmenu.hpp"
 #include "analysis_correlation.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -77 +78 @@
       case 'a': // absolute coordinates of atom
         Log() << Verbose(0) << "Enter absolute coordinates." << endl;
-        first = new atom;
+        first = World::get()->createAtom();
         first->x.AskPosition(mol->cell_size, false);
         first->type = periode->AskElement();  // give type
@@ -84 +85 @@
 
       case 'b': // relative coordinates of atom wrt to reference point
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -100 +101 @@
 
       case 'c': // relative coordinates of atom wrt to already placed atom
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -116 +117 @@
 
     case 'd': // two atoms, two angles and a distance
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -216 +217 @@
 
       case 'e': // least square distance position to a set of atoms
-        first = new atom;
+        first = World::get()->createAtom();
         atoms = new (Vector*[128]);
         valid = true;
@@ -238 +239 @@
           mol->AddAtom(first);  // add to molecule
         } else {
-          delete first;
+          World::get()->destroyAtom(first);
           Log() << Verbose(0) << "Please enter at least two vectors!\n";
         }
@@ -736 +737 @@
         Log() << Verbose(0) << "New element by atomic number Z: ";
         cin >> Z;
-        first->type = periode->FindElement(Z);
+        first->setType(Z);
         Log() << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
       }
@@ -781 +782 @@
         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::get()->createAtom(); // create a new body
           first->x.CopyVector(vectors[k]);  // use coordinate of original atom
           first->x.AddVector(&x);     // translate the coordinates

src/Makefile.am

@@ -8 +8 @@
 ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
 
-ACTIONSSOURCE = Actions/Action.cpp Actions/Process.cpp Actions/MethodAction.cpp Actions/ActionSequence.cpp Actions/MakroAction.cpp Actions/ErrorAction.cpp Actions/small_actions.cpp Actions/ActionRegistry.cpp 
-ACTIONSHEADER = Actions/Action.hpp Actions/Process.hpp Actions/MethodAction.hpp Actions/ActionSequence.hpp Actions/MakroAction.hpp Actions/ErrorAction.hpp Actions/small_actions.hpp Actions/ActionRegistry.hpp
+# only include Actions that are free of user interaction at this point
+# the UIFactory et. al. wont be known for the libmolecuilder, so the user interaction cannot be done.
+ACTIONSSOURCE = Actions/Action.cpp Actions/Process.cpp Actions/MethodAction.cpp Actions/ActionSequence.cpp Actions/MakroAction.cpp Actions/ManipulateAtomsProcess.cpp Actions/ActionRegistry.cpp 
+ACTIONSHEADER = Actions/Action.hpp Actions/Process.hpp Actions/Calculation.hpp Actions/Calculation_impl.hpp Actions/MethodAction.hpp Actions/ActionSequence.hpp Actions/MakroAction.hpp Actions/ManipulateAtomsProcess.hpp Actions/ActionRegistry.hpp
+
+# All actions that need user interaction go here
+MENUACTIONSSOURCE = Actions/ErrorAction.cpp Actions/small_actions.cpp
+MENUACTIONSHEADER = Actions/ErrorAction.hpp Actions/small_actions.hpp
 
 PATTERNSOURCE = Patterns/Observer.cpp
@@ -20 +26 @@
 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/TextUIFactory.cpp UIElements/MainWindow.cpp UIElements/TextWindow.cpp UIElements/Dialog.cpp UIElements/TextDialog.cpp
-UIHEADER = ${ACTIONSHEADER} ${VIEWHEADER} ${MENUHEADER} UIElements/TextUIFactory.hpp UIElements/MainWindow.hpp UIElements/TextWindow.hpp UIElements/Dialog.hpp UIElements/TextDialog.hpp
-
+UISOURCE = ${MENUACTIONSSOURCE} ${VIEWSOURCE} ${MENUSOURCE} UIElements/TextUIFactory.cpp UIElements/MainWindow.cpp UIElements/TextWindow.cpp UIElements/Dialog.cpp UIElements/TextDialog.cpp UIElements/TextStatusIndicator.cpp
+UIHEADER = ${MENUACTIONSHEADER} ${VIEWHEADER} ${MENUHEADER} UIElements/TextUIFactory.hpp UIElements/MainWindow.hpp UIElements/TextWindow.hpp UIElements/Dialog.hpp UIElements/TextDialog.hpp UIElements/TextStatusIndicator.hpp
 
 FACTORYSOURCE = UIElements/UIFactory.cpp
@@ -36 +41 @@
 QTUIMOC_TARGETS = QTMainWindow.moc.cpp QTMenu.moc.cpp QTDialog.moc.cpp QTMoleculesView.moc.cpp GLMoleculeView.moc.cpp QTStatusBar.moc.cpp
 
-DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp Descriptors/AtomIdDescriptor.cpp
-DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp Descriptors/AtomIdDescriptor.hpp
+DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp Descriptors/AtomIdDescriptor.cpp Descriptors/AtomTypeDescriptor.cpp
+DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp Descriptors/AtomIdDescriptor.hpp Descriptors/AtomTypeDescriptor.hpp
 
 QTUISOURCE = ${QTUIMOC_TARGETS} UIElements/QT4/QTMainWindow.cpp UIElements/QT4/QTDialog.cpp UIElements/QT4/QTUIFactory.cpp Menu/QT4/QTMenu.cpp Views/QT4/QTMoleculesView.cpp Views/QT4/GLMoleculeView.cpp Views/QT4/QTStatusBar.cpp
@@ -44 +49 @@
 QTUI_DEFS = 
 
-SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} ${DESCRIPTORSOURCE} 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 vector.cpp verbose.cpp World.cpp 
-HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} ${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 vector.hpp verbose.hpp World.hpp 
-
+SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} ${ACTIONSSOURCE} ${DESCRIPTORSOURCE}  bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.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 vector.cpp verbose.cpp World.cpp WorldIterators.cpp
+HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} ${ACTIONSHEADER} ${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 vector.hpp verbose.hpp World.hpp 
 
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)

src/UIElements/Dialog.cpp

@@ -142 +142 @@
   *target = *tmp;
 }
+
+// Element Queries
+Dialog::ElementQuery::ElementQuery(std::string title, element **_target) :
+  Query(title),
+  target(_target),
+  tmp(0)
+  {}
+
+Dialog::ElementQuery::~ElementQuery(){}
+
+void Dialog::ElementQuery::setResult(){
+  *target=tmp;
+}

src/UIElements/Dialog.hpp

@@ -15 +15 @@
 class molecule;
 class Vector;
+class element;
 
 class Dialog
@@ -27 +28 @@
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*)=0;
   virtual void queryVector(const char*,Vector *,const double *const,bool)=0;
+  virtual void queryElement(const char*,element **)=0;
 
   virtual bool display();
@@ -48 +50 @@
   public:
     Query(std::string _title);
-    ~Query();
+    virtual ~Query();
     virtual bool handle()=0;
     virtual void setResult()=0;
@@ -61 +63 @@
   public:
     IntQuery(std::string title,int *_target);
-    ~IntQuery();
+    virtual ~IntQuery();
     virtual bool handle()=0;
     virtual void setResult();
@@ -73 +75 @@
   public:
     DoubleQuery(std::string title,double *_target);
-    ~DoubleQuery();
+    virtual ~DoubleQuery();
     virtual bool handle()=0;
     virtual void setResult();
@@ -85 +87 @@
   public:
     StringQuery(std::string title,std::string *_target);
-    ~StringQuery();
+    virtual ~StringQuery();
     virtual bool handle()=0;
     virtual void setResult();
@@ -98 +100 @@
   public:
     MoleculeQuery(std::string title, molecule **_target, MoleculeListClass *_molecules);
-    ~MoleculeQuery();
+    virtual ~MoleculeQuery();
     virtual bool handle()=0;
     virtual void setResult();
@@ -111 +113 @@
   public:
       VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
-      ~VectorQuery();
+      virtual ~VectorQuery();
       virtual bool handle()=0;
       virtual void setResult();
@@ -122 +124 @@
   };
 
+  class ElementQuery : public Query {
+  public:
+    ElementQuery(std::string title, element**_target);
+    virtual ~ElementQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    element *tmp;
+  private:
+    element **target;
+  };
+
 void registerQuery(Query* query);
 

src/UIElements/QT4/QTDialog.cpp

@@ -21 +21 @@
 #include <Qt/qcombobox.h>
 
+#include "World.hpp"
+#include "periodentafel.hpp"
 #include "atom.hpp"
+#include "element.hpp"
 #include "molecule.hpp"
 
@@ -95 +98 @@
 }
 
+void QTDialog::queryElement(const char* title, element **target){
+  registerQuery(new ElementQTQuery(title,target,inputLayout,this));
+}
+
 /************************** Query Objects *******************************/
 
@@ -192 +199 @@
   for(iter  = molecules->ListOfMolecules.begin();
       iter != molecules->ListOfMolecules.end();
-      iter++) {
+      ++iter) {
     stringstream sstr;
     sstr << (*iter)->IndexNr << "\t" << (*iter)->getName();
@@ -255 +262 @@
 
 
+QTDialog::ElementQTQuery::ElementQTQuery(std::string _title, element **_target, QBoxLayout *_parent, QTDialog *_dialog) :
+    Dialog::ElementQuery(_title,_target),
+    parent(_parent)
+{
+  periodentafel *periode = World::get()->getPeriode();
+  thisLayout = new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  inputBox = new QComboBox();
+  element* Elemental = 0;
+  for(Elemental = periode->start->next;
+      Elemental!=periode->end;
+      Elemental = Elemental->next)
+  {
+    stringstream sstr;
+    sstr << Elemental->Z << "\t" << Elemental->name;
+    inputBox->addItem(QString(sstr.str().c_str()),QVariant(Elemental->Z));
+  }
+  parent->addLayout(thisLayout);
+  thisLayout->addWidget(titleLabel);
+  thisLayout->addWidget(inputBox);
+
+  pipe = new ElementQTQueryPipe(&tmp,_dialog,inputBox);
+  pipe->update(inputBox->currentIndex());
+  connect(inputBox,SIGNAL(currentIndexChanged(int)),pipe,SLOT(update(int)));
+}
+
+QTDialog::ElementQTQuery::~ElementQTQuery()
+{
+  delete pipe;
+}
+
+bool QTDialog::ElementQTQuery::handle(){
+  return true;
+}
+
 /*************************** Plumbing *******************************/
 
@@ -313 +355 @@
 }
 
+ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
+  content(_content),
+  dialog(_dialog),
+  theBox(_theBox)
+{}
+
+ElementQTQueryPipe::~ElementQTQueryPipe()
+{}
+
+void ElementQTQueryPipe::update(int newIndex) {
+  QVariant data = theBox->itemData(newIndex);
+  int idx = data.toInt();
+  (*content) = World::get()->getPeriode()->FindElement(idx);
+  dialog->update();
+}
+

src/UIElements/QT4/QTDialog.hpp

@@ -26 +26 @@
 class DoubleQTQueryPipe;
 class MoleculeQTQueryPipe;
+class ElementQTQueryPipe;
 
 class QTDialog : public QDialog, public Dialog
@@ -39 +40 @@
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
   virtual void queryVector(const char*,Vector *,const double *const,bool);
+  virtual void queryElement(const char*,element **);
 
   virtual bool display();
@@ -48 +50 @@
     public:
       IntQTQuery(std::string _title, int *_target,QBoxLayout *_parent,QTDialog *_dialog);
-      ~IntQTQuery();
+      virtual ~IntQTQuery();
       virtual bool handle();
     private:
@@ -62 +64 @@
     public:
       DoubleQTQuery(std::string title, double *_target,QBoxLayout *_parent,QTDialog *_dialog);
-      ~DoubleQTQuery();
+      virtual ~DoubleQTQuery();
       virtual bool handle();
     private:
@@ -76 +78 @@
     public:
       StringQTQuery(std::string _title, std::string *_target, QBoxLayout *_parent,QTDialog *_dialog);
-      ~StringQTQuery();
+      virtual ~StringQTQuery();
       virtual bool handle();
     private:
@@ -90 +92 @@
     public:
       MoleculeQTQuery(std::string _title, molecule **_target, MoleculeListClass *_molecules, QBoxLayout *_parent,QTDialog *_dialog);
-      ~MoleculeQTQuery();
+      virtual ~MoleculeQTQuery();
       virtual bool handle();
     private:
@@ -104 +106 @@
     public:
       VectorQTQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check,QBoxLayout *,QTDialog *);
-      ~VectorQTQuery();
+      virtual ~VectorQTQuery();
       virtual bool handle();
     private:
@@ -118 +120 @@
     };
 
+    class ElementQTQuery : public Dialog::ElementQuery {
+    public:
+      ElementQTQuery(std::string _title, element **_target, QBoxLayout *_parent, QTDialog *_dialog);
+      virtual ~ElementQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QComboBox *inputBox;
+
+      ElementQTQueryPipe *pipe;
+    };
+
 private:
   QBoxLayout *mainLayout;
@@ -133 +149 @@
 public:
   StringQTQueryPipe(std::string *_content, QTDialog *_dialog);
-  ~StringQTQueryPipe();
+  virtual ~StringQTQueryPipe();
 
 public slots:
@@ -148 +164 @@
 public:
   IntQTQueryPipe(int *_content, QTDialog *_dialog);
-  ~IntQTQueryPipe();
+  virtual ~IntQTQueryPipe();
 
 public slots:
@@ -163 +179 @@
 public:
   DoubleQTQueryPipe(double *_content, QTDialog *_dialog);
-  ~DoubleQTQueryPipe();
+  virtual ~DoubleQTQueryPipe();
 
 public slots:
@@ -178 +194 @@
 public:
   MoleculeQTQueryPipe(molecule **_content, QTDialog *_dialog, QComboBox *_theBox, MoleculeListClass *_molecules);
-  ~MoleculeQTQueryPipe();
+  virtual ~MoleculeQTQueryPipe();
 
 public slots:
@@ -190 +206 @@
 
 };
+
+class ElementQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox);
+  virtual ~ElementQTQueryPipe();
+
+public slots:
+  void update(int);
+
+private:
+  element **content;
+  QTDialog *dialog;
+  QComboBox *theBox;
+};
 #endif /* QTDIALOG_HPP_ */

src/UIElements/TextDialog.cpp

@@ -10 +10 @@
 #include "UIElements/TextDialog.hpp"
 
+#include "World.hpp"
+#include "periodentafel.hpp"
 #include "atom.hpp"
 #include "molecule.hpp"
@@ -45 +47 @@
 void TextDialog::queryVector(const char* title, Vector *target,const double *const cellSize, bool check) {
   registerQuery(new VectorTextQuery(title,target,cellSize,check));
+}
+
+void TextDialog::queryElement(const char* title, element **target){
+  registerQuery(new ElementTextQuery(title,target));
 }
 
@@ -113 +119 @@
 
 bool TextDialog::VectorTextQuery::handle() {
+ Log() << Verbose(0) << getTitle();
  tmp->AskPosition(cellSize,check);
  return true;
 }
+
+
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, element **target) :
+    Dialog::ElementQuery(title,target)
+{}
+
+TextDialog::ElementTextQuery::~ElementTextQuery()
+{}
+
+bool TextDialog::ElementTextQuery::handle() {
+  int Z;
+  Log() << Verbose(0) << getTitle();
+  cin >> Z;
+  tmp = World::get()->getPeriode()->FindElement(Z);
+  return tmp;
+}

src/UIElements/TextDialog.hpp

@@ -24 +24 @@
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
   virtual void queryVector(const char*,Vector *,const double * const,bool);
+  virtual void queryElement(const char*,element **);
 
 protected:
@@ -30 +31 @@
   public:
     IntTextQuery(std::string title, int *_target);
-    ~IntTextQuery();
+    virtual ~IntTextQuery();
     virtual bool handle();
   };
@@ -37 +38 @@
   public:
     DoubleTextQuery(std::string title, double *_target);
-    ~DoubleTextQuery();
+    virtual ~DoubleTextQuery();
     virtual bool handle();
   };
@@ -44 +45 @@
   public:
     StringTextQuery(std::string title, std::string *_target);
-    ~StringTextQuery();
+    virtual ~StringTextQuery();
     virtual bool handle();
   };
@@ -51 +52 @@
   public:
     MoleculeTextQuery(std::string title, molecule **_target, MoleculeListClass *_molecules);
-    ~MoleculeTextQuery();
+    virtual ~MoleculeTextQuery();
     virtual bool handle();
   };
@@ -58 +59 @@
   public:
     VectorTextQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
-    ~VectorTextQuery();
+    virtual ~VectorTextQuery();
+    virtual bool handle();
+  };
+
+  class ElementTextQuery : public Dialog::ElementQuery {
+  public:
+    ElementTextQuery(std::string title, element **_target);
+    virtual ~ElementTextQuery();
     virtual bool handle();
   };

src/UIElements/TextWindow.cpp

@@ -36 +36 @@
 #include "Menu/DisplayMenuItem.hpp"
 #include "Menu/SubMenuItem.hpp"
+#include "UIElements/TextStatusIndicator.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/ErrorAction.hpp"
@@ -97 +98 @@
 
   editMoleculesMenu->addDefault(returnItem);
+
+  // Add status indicators etc...
+
+  statusIndicator = new TextStatusIndicator();
 }
 
@@ -105 +110 @@
   delete returnFromEditMoleculeAction;
   delete moleculeView;
+  delete statusIndicator;
   delete main_menu;
 }

src/UIElements/TextWindow.hpp

@@ -15 +15 @@
 class oldmenu;
 class StringView;
+class TextStatusIndicator;
 
 class TextWindow : public MainWindow
@@ -31 +32 @@
   // all views that are contained in the main Menu
   StringView *moleculeView;
+  TextStatusIndicator *statusIndicator;
 
   // This class still contains a lot of scattered functionality

src/World.cpp

@@ -12 +12 @@
 #include "periodentafel.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
+#include "Descriptors/AtomDescriptor_impl.hpp"
+#include "Actions/ManipulateAtomsProcess.hpp"
 
 using namespace std;
@@ -28 +30 @@
 }
 
+vector<atom*> World::getAllAtoms(){
+  return getAllAtoms(AllAtoms());
+}
+
 int World::numAtoms(){
   return atoms.size();
@@ -36 +42 @@
 }
 
+/******************** Methods to change World state *********************/
+
 molecule* World::createMolecule(){
   OBSERVE;
@@ -41 +49 @@
   mol = new molecule(periode);
   molecules_deprecated->insert(mol);
-  molecules.insert(mol);
+  assert(!molecules.count(currMoleculeId));
+  // store the molecule by ID
+  molecules[currMoleculeId++] = mol;
   mol->signOn(this);
   return mol;
 }
 
+
+atom *World::createAtom(){
+  OBSERVE;
+  atom *res = NewAtom();
+  assert(!atoms.count(currAtomId));
+  res->setId(currAtomId++);
+  res->setWorld(this);
+  // store the atom by ID
+  atoms[res->getId()] = res;
+  return res;
+}
+
+int World::registerAtom(atom *atom){
+  OBSERVE;
+  assert(!atoms.count(currAtomId));
+  atom->setId(currAtomId++);
+  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(int id) {
+  OBSERVE;
+  atom *atom = atoms[id];
+  assert(atom);
+  DeleteAtom(atom);
+  atoms.erase(id);
+}
+
+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);
+}
+
+/******************************* Iterators ********************************/
+
+/*
+ * Actual Implementation of the iterators can be found in WorldIterators.cpp
+ */
+
+World::AtomIterator World::getAtomIter(AtomDescriptor descr){
+  return AtomIterator(descr,this);
+}
+
+World::AtomSet::iterator World::atomEnd(){
+  return atoms.end();
+}
 
 /******************************* Singleton Stuff **************************/
@@ -53 +130 @@
 boost::mutex World::worldLock;
 
-
-
 World::World() :
-    dummyId(0),
+    currAtomId(0),
+    currMoleculeId(0),
     periode(new periodentafel),
-    molecules_deprecated(new MoleculeListClass)
+    molecules_deprecated(new MoleculeListClass),
+    atoms(),
+    molecules()
 {
   molecules_deprecated->signOn(this);
@@ -65 +143 @@
 World::~World()
 {
+  delete molecules_deprecated;
   delete periode;
+  AtomSet::iterator iter;
+  for(iter=atoms.begin();iter!=atoms.end();++iter){
+    DeleteAtom((*iter).second);
+  }
+  atoms.clear();
 }
 
@@ -78 +162 @@
 
 void World::destroy(){
-  // For legacy reasons all atoms have to be destroyed first, since unregistering would cause deadlocks otherwise
-  theWorld->destroyLegacy();
-  //WARNING: at this point we have a small race condition, when sombody now tries to access the world.
-
   // boost supports RAII-Style locking, so we don't need to unlock
   boost::mutex::scoped_lock guard(worldLock);
@@ -89 +169 @@
 
 World* World::reset(){
-  // For legacy reasons all atoms have to be destroyed first, since unregistering would cause deadlocks otherwise
-  theWorld->destroyLegacy();
-  //WARNING: at this point we have a small race condition, when sombody now tries to access the world.
-
   World* oldWorld = 0;
   {
@@ -119 +195 @@
   return molecules_deprecated;
 }
-
-// some legacy stuff to let the World know about items created outside
-void World::registerAtom(atom *theAtom){
-  OBSERVE;
-  atoms[dummyId++] = theAtom;
-}
-
-void World::destroyLegacy(){
-  //delete molecules_deprecated;
-}
-
-void World::unregisterAtom(atom *theAtom){
-  OBSERVE;
-  atoms.erase(theAtom->getId());
-}

src/World.hpp

@@ -9 +9 @@
 #define WORLD_HPP_
 
-#include <boost/thread.hpp>
+#include <string>
 #include <map>
 #include <vector>
 #include <set>
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+
 
 #include "Patterns/Observer.hpp"
@@ -24 +27 @@
 class AtomDescriptor;
 class AtomDescriptor_impl;
+class ManipulateAtomsProcess;
+template<typename T>
+class AtomsCalculation;
 
 class World : public Observable
 {
+// necessary for coupling with descriptors
 friend class AtomDescriptor_impl;
+friend class AtomDescriptor;
+
+// Actions, calculations etc associated with the World
+friend class ManipulateAtomsProcess;
+template<typename> friend class AtomsCalculation;
+
+typedef std::map<int,atom*> AtomSet;
+typedef std::map<int,molecule*> MoleculeSet;
 public:
 
   /***** 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();
+
+  /**
+   * get the number of molecules in the World
+   */
   int numMolecules();
 
   /***** 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();
+
+  /**
+   * 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(int);
+
+  /**
+   * 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 */
+  class AtomIterator {
+  public:
+    AtomIterator();
+    AtomIterator(AtomDescriptor, World*);
+    AtomIterator(const AtomIterator&);
+    AtomIterator& operator=(const AtomIterator&);
+    AtomIterator& operator++();     // prefix
+    AtomIterator  operator++(int);  // postfix with dummy parameter
+    bool operator==(const AtomIterator&);
+    bool operator==(const AtomSet::iterator&);
+    bool operator!=(const AtomIterator&);
+    bool operator!=(const AtomSet::iterator&);
+    atom* operator*();
+
+    int getCount();
+  protected:
+    void advanceState();
+    World* world;
+    AtomSet::iterator state;
+    boost::shared_ptr<AtomDescriptor_impl>  descr;
+    int index;
+  };
+
+  /**
+   * 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.
+   */
+  AtomSet::iterator atomEnd();
+
+  /******* Internal manipulation routines for double callback and Observer mechanism ******/
+  void doManipulate(ManipulateAtomsProcess *);
+
 private:
   periodentafel *periode;
-  std::map<int,atom*> atoms;
-  std::set<molecule*> molecules;
+  AtomSet atoms;
+  int currAtomId; //!< stores the next available Id for atoms
+  MoleculeSet molecules;
+  int currMoleculeId;
 
 
   /***** singleton Stuff *****/
 public:
+
+  /**
+   * get the currently active instance of the World.
+   */
   static World* get();
+
+  /**
+   * destroy the currently active instance of the World.
+   */
   static void destroy();
+
+  /**
+   * destroy the currently active instance of the World and immidiately
+   * create a new one. Use this to reset while somebody is still Observing
+   * the world and should reset the observed instance. All observers will be
+   * sent the subjectKille() message from the old world.
+   */
   static World* reset();
 
 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();
 
@@ -68 +217 @@
   MoleculeListClass *&getMolecules();
 
-  // functions used for the WorldContent template mechanism
-  void registerAtom(atom *theAtom);
-  void unregisterAtom(atom *theAtom);
 private:
-  // this function cleans up anything that cannot be cleaned while the lock is active
-  // at a later point all these cleanups have to be moved to the World Class so the deadlock and
-  // race condition can both be avoided.
-  void destroyLegacy();
-
   MoleculeListClass *molecules_deprecated;
-
-  // this is needed to assign unique IDs to atoms... so far
-  // IDs are not assigned upon Atom creation, so we cannot query the ID
-  // during construction. By using the dummy ID we can make sure all atoms
-  // are actually stored in the map and don't overwrite each other.
-  int dummyId;
 };
 

src/atom.cpp

@@ -20 +20 @@
 /** Constructor of class atom.
  */
-atom::atom() : previous(NULL), next(NULL), father(this), sort(&nr)
-{
-  World::get()->registerAtom(this);
+atom::atom() :
+  previous(NULL), next(NULL), father(this), sort(&nr)
+{
   node = &x;  // TesselPoint::x can only be referenced from here
 };
@@ -28 +28 @@
 /** Constructor of class atom.
  */
-atom::atom(atom *pointer) : previous(NULL), next(NULL), father(pointer), sort(&nr)
-{
-  World::get()->registerAtom(this);
+atom::atom(atom *pointer) :
+    ParticleInfo(pointer),
+    previous(NULL), next(NULL), father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
   x.CopyVector(&pointer->x); // copy coordination
@@ -38 +39 @@
 };
 
+atom *atom::clone(){
+  atom *res = new atom();
+  res->previous=0;
+  res->next=0;
+  res->father = this;
+  res->sort = &nr;
+  res->type = type;
+  res->x.CopyVector(&this->x);
+  res->v.CopyVector(&this->v);
+  res->FixedIon = FixedIon;
+  res->node = &x;
+  World::get()->registerAtom(res);
+  return res;
+}
+
 
 /** Destructor of class atom.
@@ -43 +59 @@
 atom::~atom()
 {
-  World::get()->unregisterAtom(this);
   unlink(this);
 };
@@ -267 +282 @@
 };
 
+World *atom::getWorld(){
+  return world;
+}
+
+void atom::setWorld(World* _world){
+  world = _world;
+}
+
+void atom::setId(int _id) {
+  id=_id;
+}
+
+int atom::getId() {
+  return id;
+}
+
+atom* NewAtom(){
+  return new atom();
+}
+
+void  DeleteAtom(atom* atom){
+  delete atom;
+}

src/atom.hpp

@@ -32 +32 @@
 
 class Vector;
+class World;
 
 /********************************************** declarations *******************************/
@@ -39 +40 @@
  */
 class atom : public TesselPoint, public TrajectoryParticle, public GraphNode, public BondedParticle, public virtual ParticleInfo, public virtual AtomInfo {
+  friend atom* NewAtom();
+  friend void  DeleteAtom(atom*);
   public:
     atom *previous; //!< previous atom in molecule list
@@ -45 +48 @@
     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;
@@ -67 +68 @@
   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 int getId();
+  virtual void setId(int);
+  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;
+    int 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();
+
+/**
+* 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

@@ -6 +6 @@
  */
 
+#include "periodentafel.hpp"
+#include "World.hpp"
 #include "atom_atominfo.hpp"
 
@@ -18 +20 @@
 };
 
+element *AtomInfo::getType(){
+  return type;
+}
+
+void AtomInfo::setType(element* _type) {
+  type = _type;
+}
+
+void AtomInfo::setType(int Z) {
+  element *elem = World::get()->getPeriode()->FindElement(Z);
+  setType(elem);
+}

src/atom_atominfo.hpp

@@ -37 +37 @@
   ~AtomInfo();
 
+  element *getType();
+  void setType(element *);
+  void setType(int);
+
 private:
 };

src/atom_particleinfo.cpp

@@ -13 +13 @@
 ParticleInfo::ParticleInfo() : nr(-1), Name(NULL) {};
 
+ParticleInfo::ParticleInfo(ParticleInfo *pointer) :
+    Name(pointer->Name),
+    nr(pointer->nr)
+    {}
+
+
 /** Destructor of ParticleInfo.
  */
@@ -19 +25 @@
   Free(&Name);
 };
-
-int ParticleInfo::getId() {
-  return nr;
-}
 
 ostream & operator << (ostream &ost, const ParticleInfo &a)

src/atom_particleinfo.hpp

@@ -31 +31 @@
 
   ParticleInfo();
+  ParticleInfo(ParticleInfo*);
   ~ParticleInfo();
 
   ostream & operator << (ostream &ost) const;
-
-  virtual int getId();
 
 private:

src/boundary.cpp

@@ -887 +887 @@
             Walker = Walker->next;
             // copy atom ...
-            CopyAtoms[Walker->nr] = new atom(Walker);
+            CopyAtoms[Walker->nr] = Walker->clone();
 
             // create atomic random translation vector ...

src/builder.cpp

@@ -1482 +1482 @@
                 SaveFlag = true;
                 Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
-                first = new atom;
+                first = World::get()->createAtom();
                 first->type = periode->FindElement(atoi(argv[argptr]));
                 if (first->type != NULL)
@@ -1642 +1642 @@
 //                first->x.Zero();
 //                filler->AddAtom(first);
-                first = new atom();
+                first = World::get()->createAtom();
                 first->type = periode->FindElement(1);
                 first->x.Init(0.441, -0.143, 0.);
                 filler->AddAtom(first);
-                second = new atom();
+                second = World::get()->createAtom();
                 second->type = periode->FindElement(1);
                 second->x.Init(-0.464, 1.137, 0.0);
                 filler->AddAtom(second);
-                third = new atom();
+                third = World::get()->createAtom();
                 third->type = periode->FindElement(8);
                 third->x.Init(-0.464, 0.177, 0.);
@@ -2098 +2098 @@
                       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::get()->createAtom(); // create a new body
                         first->x.CopyVector(vectors[k]);  // use coordinate of original atom
                         first->x.AddVector(&x);      // translate the coordinates

src/config.cpp

@@ -8 +8 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -732 +733 @@
             sprintf(keyword,"%s_%i",name, j+1);
             if (repetition == 0) {
-              neues = new atom();
+              neues = World::get()->createAtom();
               AtomList[i][j] = neues;
               LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
@@ -811 +812 @@
           sprintf(keyword,"%s_%i",name, j+1);
           if (repetition == 0) {
-            neues = new atom();
+            neues = World::get()->createAtom();
             AtomList[i][j] = neues;
             LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
@@ -1287 +1288 @@
         }
         istringstream input2(zeile);
-        atom *neues = new atom();
+        atom *neues = World::get()->createAtom();
         input2 >> neues->x.x[0]; // x
         input2 >> neues->x.x[1]; // y

src/lists.hpp

@@ -9 +9 @@
 #define LISTS_HPP_
 
+class atom;
+
 /******************************** Some templates for list management ***********************************/
 
@@ -18 +20 @@
 {
   X *vorher = end->previous;
-  if (vorher != NULL)
+  if (vorher != 0)
     vorher->next = walker;
   end->previous = walker;
@@ -31 +33 @@
 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;
 };
 
@@ -46 +48 @@
 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;
@@ -59 +61 @@
  * \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)
@@ -68 +70 @@
     if (*walker->sort == *suche) return (walker);
   }
-  return NULL;
+  return 0;
 };
 
@@ -77 +79 @@
 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.
@@ -99 +109 @@
   }*/
   // atom found, now unlink
-  if (walker != NULL)
+  if (walker != 0)
     removewithoutcheck(walker);
   else
@@ -114 +124 @@
 {
   X *pointer = start->next;
-  X *walker = NULL;
+  X *walker = 0;
   while (pointer != end) { // go through list
     walker = pointer; // mark current
@@ -131 +141 @@
 {
   X *Binder = me;
-  while(Binder->previous != NULL)
+  while(Binder->previous != 0)
     Binder = Binder->previous;
   return Binder;
@@ -143 +153 @@
 {
   X *Binder = me;
-  while(Binder->next != NULL)
+  while(Binder->next != 0)
     Binder = Binder->next;
   return Binder;

src/molecule.cpp

@@ -8 +8 @@
 #include <boost/bind.hpp>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -30 +31 @@
  * 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::get()->createAtom()), end(World::get()->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.), 
@@ -60 +61 @@
   delete(first);
   delete(last);
-  delete(end);
-  delete(start);
+  end->getWorld()->destroyAtom(end);
+  start->getWorld()->destroyAtom(start);
 };
 
@@ -135 +136 @@
   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);
@@ -242 +243 @@
   switch(TopBond->BondDegree) {
     case 1:
-      FirstOtherAtom = new atom();    // new atom
+      FirstOtherAtom = World::get()->createAtom();    // new atom
       FirstOtherAtom->type = elemente->FindElement(1);  // element is Hydrogen
       FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
@@ -299 +300 @@
 
       // create the two Hydrogens ...
-      FirstOtherAtom = new atom();
-      SecondOtherAtom = new atom();
+      FirstOtherAtom = World::get()->createAtom();
+      SecondOtherAtom = World::get()->createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
@@ -354 +355 @@
     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::get()->createAtom();
+      SecondOtherAtom = World::get()->createAtom();
+      ThirdOtherAtom = World::get()->createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
@@ -475 +476 @@
     MDSteps++;
   for(i=0;i<NumberOfAtoms;i++){
-    Walker = new atom;
+    Walker = World::get()->createAtom();
     getline(xyzfile,line,'\n');
     istringstream *item = new istringstream(line);

src/moleculelist.cpp

@@ -342 +342 @@
     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++;

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisCorrelationToPointUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -56 +57 @@
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -61 +62 @@
   // construct molecule (tetraeder of hydrogens) base
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -94 +95 @@
 
   // add outer atoms
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 0., 4. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 4., 4. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 4., 0. );
   TestMolecule->AddAtom(Walker);
   // add inner atoms
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );

src/unittests/AnalysisPairCorrelationUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisPairCorrelationUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -55 +56 @@
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );

src/unittests/DescriptorUnittest.cpp

@@ -22 +22 @@
 CPPUNIT_TEST_SUITE_REGISTRATION( DescriptorUnittest );
 
-// some stubs
-class AtomStub : public atom {
-public:
-  AtomStub(int _id) :
-  atom(),
-  id(_id)
-  {}
-
-  virtual int getId(){
-    return id;
-  }
-
-private:
-  int id;
-};
-
-
 // set up and tear down
 void DescriptorUnittest::setUp(){
   World::get();
   for(int i=0;i<ATOM_COUNT;++i){
-    atoms[i]= new AtomStub(i);
+    atoms[i]= World::get()->createAtom();
+    atomIds[i] = atoms[i]->getId();
   }
 }
 void DescriptorUnittest::tearDown(){
   World::destroy();
-  for(int i=0;i<ATOM_COUNT;++i){
-    delete atoms[i];
-  }
 }
 
 // some helper functions
-bool hasAll(std::vector<atom*> atoms,int min, int max, std::set<int> excluded = std::set<int>()){
-  for(int i=min;i<max;++i){
-    if(!excluded.count(i)){
+bool hasAll(std::vector<atom*> atoms,int ids[ATOM_COUNT], std::set<int> excluded = std::set<int>()){
+  for(int i=0;i<ATOM_COUNT;++i){
+    int id = ids[i];
+    if(!excluded.count(id)){
       std::vector<atom*>::iterator iter;
       bool res=false;
       for(iter=atoms.begin();iter!=atoms.end();++iter){
-        res |= (*iter)->getId() == i;
+        res |= (*iter)->getId() == id;
       }
       if(!res) {
-        cout << "Atom " << i << " missing in returned list" << endl;
+        cout << "Atom " << id << " missing in returned list" << endl;
         return false;
       }
@@ -86 +68 @@
 void DescriptorUnittest::AtomBaseSetsTest(){
   std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
-  CPPUNIT_ASSERT_EQUAL( true , hasAll(allAtoms,0,ATOM_COUNT));
+  CPPUNIT_ASSERT_EQUAL( true , hasAll(allAtoms,atomIds));
   CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(allAtoms));
 
@@ -95 +77 @@
   // test Atoms from boundaries and middle of the set
   atom* testAtom;
-  testAtom = World::get()->getAtom(AtomById(0));
-  CPPUNIT_ASSERT_EQUAL( 0, testAtom->getId());
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT/2));
-  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtom->getId());
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT-1));
-  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT-1, testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[0]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[0], testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[ATOM_COUNT/2]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT/2], testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[ATOM_COUNT-1]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT-1], testAtom->getId());
 
+  // find some ID that has not been created
+  int outsideId =-1;
+  bool res = false;
+  while(!res) {
+    ++outsideId;
+    res = true;
+    for(int i = 0; i < ATOM_COUNT; ++i){
+      res &= atomIds[i]!=outsideId;
+    }
+  }
   // test from outside of set
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT));
+  testAtom = World::get()->getAtom(AtomById(outsideId));
   CPPUNIT_ASSERT(!testAtom);
 }
@@ -110 +105 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()||NoAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -116 +111 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||AllAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -137 +132 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(!NoAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -143 +138 @@
   // exclude and include some atoms
   {
-    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(ATOM_COUNT/2)));
+    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(atomIds[ATOM_COUNT/2])));
     std::set<int> excluded;
-    excluded.insert(ATOM_COUNT/2);
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT,excluded));
+    excluded.insert(atomIds[ATOM_COUNT/2]);
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds,excluded));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
     CPPUNIT_ASSERT_EQUAL( (size_t)(ATOM_COUNT-1), testAtoms.size());
@@ -152 +147 @@
 
   {
-    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(ATOM_COUNT/2)));
+    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(atomIds[ATOM_COUNT/2])));
     CPPUNIT_ASSERT_EQUAL( (size_t)1, testAtoms.size());
-    CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtoms[0]->getId());
+    CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT/2], testAtoms[0]->getId());
   }
 }

src/unittests/DescriptorUnittest.hpp

@@ -33 +33 @@
 private:
   atom *atoms [ATOM_COUNT];
+  int atomIds [ATOM_COUNT];
 };
 

src/unittests/Makefile.am

@@ -31 +31 @@
   CacheableTest \
   DescriptorUnittest \
-  ${MENUTESTS}  
-    
+  manipulateAtomsTest \
+  atomsCalculationTest \
+  ${MENUTESTS}
+  
+ 
 check_PROGRAMS = $(TESTS) 
 noinst_PROGRAMS = $(TESTS)
@@ -109 +112 @@
 
 DescriptorUnittest_SOURCES = DescriptorUnittest.cpp DescriptorUnittest.hpp
-DescriptorUnittest_LDADD = ${ALLLIBS} 
+DescriptorUnittest_LDADD = ${ALLLIBS}
+
+manipulateAtomsTest_SOURCES = manipulateAtomsTest.cpp manipulateAtomsTest.hpp
+manipulateAtomsTest_LDADD = ${ALLLIBS}
+
+atomsCalculationTest_SOURCES = atomsCalculationTest.cpp atomsCalculationTest.hpp
+atomsCalculationTest_LDADD = ${ALLLIBS}
 
 #AUTOMAKE_OPTIONS = parallel-tests

src/unittests/analysisbondsunittest.cpp

@@ -16 +16 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "analysis_bonds.hpp"
 #include "analysisbondsunittest.hpp"
@@ -62 +63 @@
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );

src/unittests/bondgraphunittest.cpp

@@ -16 +16 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -57 +58 @@
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );

src/unittests/listofbondsunittest.cpp

@@ -16 +16 @@
 #include "listofbondsunittest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -50 +51 @@
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -242 +243 @@
 
   // remove atom2
-  delete(atom2);
+  World::get()->destroyAtom(atom2);
 
   // check bond if removed from other atom