Changes in src/World.hpp [43dad6:cf0ca1]

File:

• src/World.hpp (modified) (12 diffs)

src/World.hpp

@@ -23 +23 @@
 #include "Patterns/Cacheable.hpp"
 #include "Patterns/Singleton.hpp"
+#include "Patterns/ObservedContainer.hpp"
 
 // include config.h
@@ -34 +35 @@
 class AtomDescriptor_impl;
 template<typename T> class AtomsCalculation;
+class Box;
 class config;
 class ManipulateAtomsProcess;
+class Matrix;
 class molecule;
 class MoleculeDescriptor;
@@ -43 +46 @@
 class ThermoStatContainer;
 
+
 /****************************************** forward declarations *****************************/
 
@@ -58 +62 @@
 friend class MoleculeDescriptor_impl;
 friend class MoleculeDescriptor;
+// coupling with descriptors over selection
+friend class AtomSelectionDescriptor_impl;
+friend class MoleculeSelectionDescriptor_impl;
 
 // Actions, calculations etc associated with the World
@@ -65 +72 @@
 
   // Types for Atom and Molecule structures
-  typedef std::map<atomId_t,atom*> AtomSet;
-  typedef std::map<moleculeId_t,molecule*> MoleculeSet;
+  typedef ObservedContainer<std::map<atomId_t,atom*> > AtomSet;
+  typedef ObservedContainer<std::map<moleculeId_t,molecule*> > MoleculeSet;
 
   /***** getter and setter *****/
@@ -125 +132 @@
    * get the domain size as a symmetric matrix (6 components)
    */
-  double * getDomain();
+  Box& getDomain();
+
+  /**
+   * Set the domain size from a matrix object
+   *
+   * Matrix needs to be symmetric
+   */
+  void setDomain(const Matrix &mat);
 
   /**
@@ -207 +221 @@
   ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
 
+  /****
+   * Iterators to use internal data structures
+   * All these iterators are observed to track changes.
+   * There is a corresponding protected section with unobserved iterators,
+   * which can be used internally when the extra speed is needed
+   */
+
+  typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor>       AtomIterator;
+
+  /**
+   * returns an iterator over all Atoms matching a given descriptor.
+   * This iterator is observed, so don't keep it around unnecessary to
+   * avoid unintended blocking.
+   */
+  AtomIterator getAtomIter(AtomDescriptor descr);
+  AtomIterator getAtomIter();
+
+  AtomIterator atomEnd();
+
+  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor>   MoleculeIterator;
+
+  /**
+   * returns an iterator over all Molecules matching a given descriptor.
+   * This iterator is observed, so don't keep it around unnecessary to
+   * avoid unintended blocking.
+   */
+  MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
+  MoleculeIterator getMoleculeIter();
+
+  MoleculeIterator moleculeEnd();
+
+  /******** Selections of molecules and Atoms *************/
+  void clearAtomSelection();
+  void selectAtom(atom*);
+  void selectAtom(atomId_t);
+  void selectAllAtoms(AtomDescriptor);
+  void selectAtomsOfMolecule(molecule*);
+  void selectAtomsOfMolecule(moleculeId_t);
+  void unselectAtom(atom*);
+  void unselectAtom(atomId_t);
+  void unselectAllAtoms(AtomDescriptor);
+  void unselectAtomsOfMolecule(molecule*);
+  void unselectAtomsOfMolecule(moleculeId_t);
+
+  void clearMoleculeSelection();
+  void selectMolecule(molecule*);
+  void selectMolecule(moleculeId_t);
+  void selectAllMoleculess(MoleculeDescriptor);
+  void selectMoleculeOfAtom(atom*);
+  void selectMoleculeOfAtom(atomId_t);
+  void unselectMolecule(molecule*);
+  void unselectMolecule(moleculeId_t);
+  void unselectAllMoleculess(MoleculeDescriptor);
+  void unselectMoleculeOfAtom(atom*);
+  void unselectMoleculeOfAtom(atomId_t);
+
+  /******************** Iterators to selections *****************/
+  typedef AtomSet::iterator AtomSelectionIterator;
+  AtomSelectionIterator beginAtomSelection();
+  AtomSelectionIterator endAtomSelection();
+
+  typedef MoleculeSet::iterator MoleculeSelectionIterator;
+  MoleculeSelectionIterator beginMoleculeSelection();
+  MoleculeSelectionIterator endMoleculeSelection();
+
 protected:
-  /**** Iterators to use internal data structures */
+  /****
+   * Iterators to use internal data structures
+   * All these iterators are unobserved for speed reasons.
+   * There is a corresponding public section to these methods,
+   * which produce observed iterators.*/
 
   // Atoms
-  typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
+  typedef SelectiveIterator<atom*,AtomSet::set_t,AtomDescriptor>        internal_AtomIterator;
 
   /**
@@ -217 +300 @@
    * used for internal purposes, like AtomProcesses and AtomCalculations.
    */
-  AtomIterator getAtomIter(AtomDescriptor descr);
+  internal_AtomIterator getAtomIter_internal(AtomDescriptor descr);
 
   /**
@@ -225 +308 @@
    * used for internal purposes, like AtomProcesses and AtomCalculations.
    */
-  AtomIterator atomEnd();
+  internal_AtomIterator atomEnd_internal();
 
   // Molecules
-
-  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
+  typedef SelectiveIterator<molecule*,MoleculeSet::set_t,MoleculeDescriptor>   internal_MoleculeIterator;
+
 
   /**
@@ -235 +318 @@
    * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
    */
-  MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
+  internal_MoleculeIterator getMoleculeIter_internal(MoleculeDescriptor descr);
 
   /**
@@ -243 +326 @@
    * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
    */
-  MoleculeIterator moleculeEnd();
+  internal_MoleculeIterator moleculeEnd_internal();
 
 
@@ -254 +337 @@
   void releaseAtomId(atomId_t);
   bool reserveAtomId(atomId_t);
+  void defragAtomIdPool();
+
+  moleculeId_t getNextMoleculeId();
+  void releaseMoleculeId(moleculeId_t);
+  bool reserveMoleculeId(moleculeId_t);
+  void defragMoleculeIdPool();
 
   periodentafel *periode;
   config *configuration;
-  static double *cell_size;
+  Box *cell_size;
   std::string defaultName;
   class ThermoStatContainer *Thermostats;
   int ExitFlag;
-public:
+private:
+
   AtomSet atoms;
-private:
-  std::set<atomId_t> atomIdPool; //<!stores the pool for all available AtomIds below currAtomId
+  AtomSet selectedAtoms;
+  typedef std::set<std::pair<atomId_t, atomId_t> > atomIdPool_t;
+  /**
+   * stores the pool for all available AtomIds below currAtomId
+   *
+   * The pool contains ranges of free ids in the form [bottom,top).
+   */
+  atomIdPool_t atomIdPool;
   atomId_t currAtomId; //!< stores the next available Id for atoms
+  size_t lastAtomPoolSize; //!< size of the pool after last defrag, to skip some defrags
+  unsigned int numAtomDefragSkips;
+
   MoleculeSet molecules;
+  MoleculeSet selectedMolecules;
+  typedef std::set<std::pair<moleculeId_t, moleculeId_t> > moleculeIdPool_t;
+  /**
+   * stores the pool for all available AtomIds below currAtomId
+   *
+   * The pool contains ranges of free ids in the form [bottom,top).
+   */
+  moleculeIdPool_t moleculeIdPool;
   moleculeId_t currMoleculeId;
+  size_t lastMoleculePoolSize; //!< size of the pool after last defrag, to skip some defrags
+  unsigned int numMoleculeDefragSkips;
 private:
   /**