Changes in src/World.cpp [b9c847:3839e5]

File:

• src/World.cpp (modified) (8 diffs)

src/World.cpp

@@ -9 +9 @@
 
 #include "World.hpp"
+
+#include <functional>
 
 #include "atom.hpp"
@@ -22 +24 @@
 #include "Actions/ManipulateAtomsProcess.hpp"
 #include "Helpers/Assert.hpp"
+#include "Box.hpp"
+#include "Matrix.hpp"
+#include "defs.hpp"
 
 #include "Patterns/Singleton_impl.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 
 using namespace std;
@@ -74 +80 @@
 // system
 
-double * World::getDomain() {
-  return cell_size;
+Box& World::getDomain() {
+  return *cell_size;
+}
+
+void World::setDomain(const Matrix &mat){
+  *cell_size = mat;
 }
 
 void World::setDomain(double * matrix)
 {
-  OBSERVE;
-  cell_size[0] = matrix[0];
-  cell_size[1] = matrix[1];
-  cell_size[2] = matrix[2];
-  cell_size[3] = matrix[3];
-  cell_size[4] = matrix[4];
-  cell_size[5] = matrix[5];
+  Matrix M = ReturnFullMatrixforSymmetric(matrix);
+  cell_size->setM(M);
 }
 
@@ -119 +124 @@
   molecule *mol = NULL;
   mol = NewMolecule();
-  ASSERT(!molecules.count(currMoleculeId),"currMoleculeId did not specify an unused ID");
-  mol->setId(currMoleculeId++);
+  moleculeId_t id = getNextMoleculeId();
+  ASSERT(!molecules.count(id),"proposed id did not specify an unused ID");
+  mol->setId(id);
   // store the molecule by ID
   molecules[mol->getId()] = mol;
@@ -138 +144 @@
   DeleteMolecule(mol);
   molecules.erase(id);
-}
-
-double *World::cell_size = NULL;
+  releaseMoleculeId(id);
+}
 
 atom *World::createAtom(){
   OBSERVE;
   atomId_t id = getNextAtomId();
+  ASSERT(!atoms.count(id),"proposed id did not specify an unused ID");
   atom *res = NewAtom(id);
   res->setWorld(this);
@@ -221 +227 @@
 
 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);
+  // try to find an Id in the pool;
+  if(!atomIdPool.empty()){
+    atomIdPool_t::iterator iter=atomIdPool.begin();
+    atomId_t id = iter->first;
+    pair<atomId_t,atomId_t> newRange = make_pair(id+1,iter->second);
+    // we wont use this iterator anymore, so we don't care about invalidating
+    atomIdPool.erase(iter);
+    if(newRange.first<newRange.second){
+      atomIdPool.insert(newRange);
+    }
     return id;
   }
+  // Nothing in the pool... we are out of luck
+  return currAtomId++;
 }
 
 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);
-  }
+  atomIdPool.insert(make_pair(id,id+1));
+  defragAtomIdPool();
 }
 
 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);
+    pair<atomId_t,atomId_t> newRange = make_pair(currAtomId,id);
+    if(newRange.first<newRange.second){
+      atomIdPool.insert(newRange);
     }
     currAtomId=id+1;
+    defragAtomIdPool();
     return true;
   }
-  else if(atomIdPool.count(id)){
-    atomIdPool.erase(id);
+  // look for a range that matches the request
+  for(atomIdPool_t::iterator iter=atomIdPool.begin();iter!=atomIdPool.end();++iter){
+    if(iter->first>id){
+      // we have coverd all available ranges... nothing to be found here
+      break;
+    }
+    // no need to check first, since it has to be <=id, since otherwise we would have broken out
+    if(iter->second > id){
+      // we found a matching range... get the id from this range
+
+      // split up this range at the point of id
+      pair<atomId_t,atomId_t> bottomRange = make_pair(iter->first,id);
+      pair<atomId_t,atomId_t> topRange = make_pair(id+1,iter->second);
+      // remove this range
+      atomIdPool.erase(iter);
+      if(bottomRange.first<bottomRange.second){
+        atomIdPool.insert(bottomRange);
+      }
+      if(topRange.first<topRange.second){
+        atomIdPool.insert(topRange);
+      }
+      defragAtomIdPool();
+      return true;
+    }
+  }
+  // this ID could not be reserved
+  return false;
+}
+
+void World::defragAtomIdPool(){
+  // check if the situation is bad enough to make defragging neccessary
+  if((numAtomDefragSkips<MAX_FRAGMENTATION_SKIPS) &&
+     (atomIdPool.size()<lastAtomPoolSize+MAX_POOL_FRAGMENTATION)){
+    ++numAtomDefragSkips;
+    return;
+  }
+  for(atomIdPool_t::iterator iter = atomIdPool.begin();iter!=atomIdPool.end();){
+    // see if this range is adjacent to the next one
+    atomIdPool_t::iterator next = iter;
+    next++;
+    if(next!=atomIdPool.end() && (next->first==iter->second)){
+      // merge the two ranges
+      pair<atomId_t,atomId_t> newRange = make_pair(iter->first,next->second);
+      atomIdPool.erase(iter);
+      atomIdPool.erase(next);
+      pair<atomIdPool_t::iterator,bool> res = atomIdPool.insert(newRange);
+      ASSERT(res.second,"Id-Pool was confused");
+      iter=res.first;
+      continue;
+    }
+    ++iter;
+  }
+  if(!atomIdPool.empty()){
+    // check if the last range is at the border
+    atomIdPool_t::iterator iter = atomIdPool.end();
+    iter--;
+    if(iter->second==currAtomId){
+      currAtomId=iter->first;
+      atomIdPool.erase(iter);
+    }
+  }
+  lastAtomPoolSize=atomIdPool.size();
+  numAtomDefragSkips=0;
+}
+
+// Molecules
+
+moleculeId_t World::getNextMoleculeId(){
+  // try to find an Id in the pool;
+  if(!moleculeIdPool.empty()){
+    moleculeIdPool_t::iterator iter=moleculeIdPool.begin();
+    moleculeId_t id = iter->first;
+    pair<moleculeId_t,moleculeId_t> newRange = make_pair(id+1,iter->second);
+    // we wont use this iterator anymore, so we don't care about invalidating
+    moleculeIdPool.erase(iter);
+    if(newRange.first<newRange.second){
+      moleculeIdPool.insert(newRange);
+    }
+    return id;
+  }
+  // Nothing in the pool... we are out of luck
+  return currMoleculeId++;
+}
+
+void World::releaseMoleculeId(moleculeId_t id){
+  moleculeIdPool.insert(make_pair(id,id+1));
+  defragMoleculeIdPool();
+}
+
+bool World::reserveMoleculeId(moleculeId_t id){
+  if(id>=currMoleculeId ){
+    pair<moleculeId_t,moleculeId_t> newRange = make_pair(currMoleculeId,id);
+    if(newRange.first<newRange.second){
+      moleculeIdPool.insert(newRange);
+    }
+    currMoleculeId=id+1;
+    defragMoleculeIdPool();
     return true;
   }
-  else{
-    // this ID could not be reserved
-    return false;
-  }
+  // look for a range that matches the request
+  for(moleculeIdPool_t::iterator iter=moleculeIdPool.begin();iter!=moleculeIdPool.end();++iter){
+    if(iter->first>id){
+      // we have coverd all available ranges... nothing to be found here
+      break;
+    }
+    // no need to check first, since it has to be <=id, since otherwise we would have broken out
+    if(iter->second > id){
+      // we found a matching range... get the id from this range
+
+      // split up this range at the point of id
+      pair<moleculeId_t,moleculeId_t> bottomRange = make_pair(iter->first,id);
+      pair<moleculeId_t,moleculeId_t> topRange = make_pair(id+1,iter->second);
+      // remove this range
+      moleculeIdPool.erase(iter);
+      if(bottomRange.first<bottomRange.second){
+        moleculeIdPool.insert(bottomRange);
+      }
+      if(topRange.first<topRange.second){
+        moleculeIdPool.insert(topRange);
+      }
+      defragMoleculeIdPool();
+      return true;
+    }
+  }
+  // this ID could not be reserved
+  return false;
+}
+
+void World::defragMoleculeIdPool(){
+  // check if the situation is bad enough to make defragging neccessary
+  if((numMoleculeDefragSkips<MAX_FRAGMENTATION_SKIPS) &&
+     (moleculeIdPool.size()<lastMoleculePoolSize+MAX_POOL_FRAGMENTATION)){
+    ++numMoleculeDefragSkips;
+    return;
+  }
+  for(moleculeIdPool_t::iterator iter = moleculeIdPool.begin();iter!=moleculeIdPool.end();){
+    // see if this range is adjacent to the next one
+    moleculeIdPool_t::iterator next = iter;
+    next++;
+    if(next!=moleculeIdPool.end() && (next->first==iter->second)){
+      // merge the two ranges
+      pair<moleculeId_t,moleculeId_t> newRange = make_pair(iter->first,next->second);
+      moleculeIdPool.erase(iter);
+      moleculeIdPool.erase(next);
+      pair<moleculeIdPool_t::iterator,bool> res = moleculeIdPool.insert(newRange);
+      ASSERT(res.second,"Id-Pool was confused");
+      iter=res.first;
+      continue;
+    }
+    ++iter;
+  }
+  if(!moleculeIdPool.empty()){
+    // check if the last range is at the border
+    moleculeIdPool_t::iterator iter = moleculeIdPool.end();
+    iter--;
+    if(iter->second==currMoleculeId){
+      currMoleculeId=iter->first;
+      moleculeIdPool.erase(iter);
+    }
+  }
+  lastMoleculePoolSize=moleculeIdPool.size();
+  numMoleculeDefragSkips=0;
+}
+
+/******************************* Iterators ********************************/
+
+// external parts with observers
+
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet,AtomDescriptor);
+
+World::AtomIterator
+World::getAtomIter(AtomDescriptor descr){
+    return AtomIterator(descr,atoms);
+}
+
+World::AtomIterator
+World::getAtomIter(){
+    return AtomIterator(AllAtoms(),atoms);
+}
+
+World::AtomIterator
+World::atomEnd(){
+  return AtomIterator(AllAtoms(),atoms,atoms.end());
+}
+
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet,MoleculeDescriptor);
+
+World::MoleculeIterator
+World::getMoleculeIter(MoleculeDescriptor descr){
+    return MoleculeIterator(descr,molecules);
+}
+
+World::MoleculeIterator
+World::getMoleculeIter(){
+    return MoleculeIterator(AllMolecules(),molecules);
+}
+
+World::MoleculeIterator
+World::moleculeEnd(){
+  return MoleculeIterator(AllMolecules(),molecules,molecules.end());
+}
+
+// Internal parts, without observers
+
+// Build the AtomIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet::set_t,AtomDescriptor);
+
+
+World::internal_AtomIterator
+World::getAtomIter_internal(AtomDescriptor descr){
+  return internal_AtomIterator(descr,atoms.getContent());
+}
+
+World::internal_AtomIterator
+World::atomEnd_internal(){
+  return internal_AtomIterator(AllAtoms(),atoms.getContent(),atoms.end_internal());
+}
+
+// build the MoleculeIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet::set_t,MoleculeDescriptor);
+
+World::internal_MoleculeIterator World::getMoleculeIter_internal(MoleculeDescriptor descr){
+  return internal_MoleculeIterator(descr,molecules.getContent());
+}
+
+World::internal_MoleculeIterator World::moleculeEnd_internal(){
+  return internal_MoleculeIterator(AllMolecules(),molecules.getContent(),molecules.end_internal());
+}
+
+/************************** Selection of Atoms and molecules ******************/
+
+// Atoms
+
+void World::clearAtomSelection(){
+  selectedAtoms.clear();
+}
+
+void World::selectAtom(atom *atom){
+  ASSERT(atom,"Invalid pointer in selection of atom");
+  selectedAtoms[atom->getId()]=atom;
+}
+
+void World::selectAtom(atomId_t id){
+  ASSERT(atoms.count(id),"Atom Id selected that was not in the world");
+  selectedAtoms[id]=atoms[id];
+}
+
+void World::selectAllAtoms(AtomDescriptor descr){
+  internal_AtomIterator begin = getAtomIter_internal(descr);
+  internal_AtomIterator end = atomEnd_internal();
+  void (World::*func)(atom*) = &World::selectAtom; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is select... see above
+}
+
+void World::selectAtomsOfMolecule(molecule *_mol){
+  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
+  // need to make it const to get the fast iterators
+  const molecule *mol = _mol;
+  void (World::*func)(atom*) = &World::selectAtom; // needed for type resolution of overloaded function
+  for_each(mol->begin(),mol->end(),bind1st(mem_fun(func),this)); // func is select... see above
+}
+
+void World::selectAtomsOfMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
+  selectAtomsOfMolecule(molecules[id]);
+}
+
+void World::unselectAtom(atom *atom){
+  ASSERT(atom,"Invalid pointer in unselection of atom");
+  unselectAtom(atom->getId());
+}
+
+void World::unselectAtom(atomId_t id){
+  ASSERT(atoms.count(id),"Atom Id unselected that was not in the world");
+  selectedAtoms.erase(id);
+}
+
+void World::unselectAllAtoms(AtomDescriptor descr){
+  internal_AtomIterator begin = getAtomIter_internal(descr);
+  internal_AtomIterator end = atomEnd_internal();
+  void (World::*func)(atom*) = &World::unselectAtom; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is unselect... see above
+}
+
+void World::unselectAtomsOfMolecule(molecule *_mol){
+  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
+  // need to make it const to get the fast iterators
+  const molecule *mol = _mol;
+  void (World::*func)(atom*) = &World::unselectAtom; // needed for type resolution of overloaded function
+  for_each(mol->begin(),mol->end(),bind1st(mem_fun(func),this)); // func is unsselect... see above
+}
+
+void World::unselectAtomsOfMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
+  unselectAtomsOfMolecule(molecules[id]);
 }
 
 // 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());
+void World::clearMoleculeSelection(){
+  selectedMolecules.clear();
+}
+
+void World::selectMolecule(molecule *mol){
+  ASSERT(mol,"Invalid pointer to molecule in selection");
+  selectedMolecules[mol->getId()]=mol;
+}
+
+void World::selectMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"Molecule Id selected that was not in the world");
+  selectedMolecules[id]=molecules[id];
+}
+
+void World::selectAllMoleculess(MoleculeDescriptor descr){
+  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
+  internal_MoleculeIterator end = moleculeEnd_internal();
+  void (World::*func)(molecule*) = &World::selectMolecule; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is select... see above
+}
+
+void World::selectMoleculeOfAtom(atom *atom){
+  ASSERT(atom,"Invalid atom pointer in selection of MoleculeOfAtom");
+  molecule *mol=atom->getMolecule();
+  // the atom might not be part of a molecule
+  if(mol){
+    selectMolecule(mol);
+  }
+}
+
+void World::selectMoleculeOfAtom(atomId_t id){
+  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
+  selectMoleculeOfAtom(atoms[id]);
+}
+
+void World::unselectMolecule(molecule *mol){
+  ASSERT(mol,"invalid pointer in unselection of molecule");
+  unselectMolecule(mol->getId());
+}
+
+void World::unselectMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No such molecule with ID in unselection");
+  selectedMolecules.erase(id);
+}
+
+void World::unselectAllMoleculess(MoleculeDescriptor descr){
+  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
+  internal_MoleculeIterator end = moleculeEnd_internal();
+  void (World::*func)(molecule*) = &World::unselectMolecule; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is unselect... see above
+}
+
+void World::unselectMoleculeOfAtom(atom *atom){
+  ASSERT(atom,"Invalid atom pointer in selection of MoleculeOfAtom");
+  molecule *mol=atom->getMolecule();
+  // the atom might not be part of a molecule
+  if(mol){
+    unselectMolecule(mol);
+  }
+}
+
+void World::unselectMoleculeOfAtom(atomId_t id){
+  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
+  unselectMoleculeOfAtom(atoms[id]);
+}
+
+/******************* Iterators over Selection *****************************/
+World::AtomSelectionIterator World::beginAtomSelection(){
+  return selectedAtoms.begin();
+}
+
+World::AtomSelectionIterator World::endAtomSelection(){
+  return selectedAtoms.end();
+}
+
+
+World::MoleculeSelectionIterator World::beginMoleculeSelection(){
+  return selectedMolecules.begin();
+}
+
+World::MoleculeSelectionIterator World::endMoleculeSelection(){
+  return selectedMolecules.end();
 }
 
@@ -297 +649 @@
     Thermostats(new ThermoStatContainer),
     ExitFlag(0),
-    atoms(),
+    atoms(this),
+    selectedAtoms(this),
     currAtomId(0),
-    molecules(),
+    lastAtomPoolSize(0),
+    numAtomDefragSkips(0),
+    molecules(this),
+    selectedMolecules(this),
     currMoleculeId(0),
     molecules_deprecated(new MoleculeListClass(this))
 {
-  cell_size = new double[6];
-  cell_size[0] = 20.;
-  cell_size[1] = 0.;
-  cell_size[2] = 20.;
-  cell_size[3] = 0.;
-  cell_size[4] = 0.;
-  cell_size[5] = 20.;
+  cell_size = new Box;
+  Matrix domain;
+  domain.at(0,0) = 20;
+  domain.at(1,1) = 20;
+  domain.at(2,2) = 20;
+  cell_size->setM(domain);
   defaultName = "none";
   molecules_deprecated->signOn(this);
@@ -317 +672 @@
 {
   molecules_deprecated->signOff(this);
-  delete[] cell_size;
+  delete cell_size;
   delete molecules_deprecated;
   delete periode;