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

File:

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

src/World.cpp

@@ -9 +9 @@
 
 #include "World.hpp"
-
-#include <functional>
 
 #include "atom.hpp"
@@ -24 +22 @@
 #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;
@@ -80 +74 @@
 // system
 
-Box& World::getDomain() {
-  return *cell_size;
-}
-
-void World::setDomain(const Matrix &mat){
-  *cell_size = mat;
+double * World::getDomain() {
+  return cell_size;
 }
 
 void World::setDomain(double * matrix)
 {
-  Matrix M = ReturnFullMatrixforSymmetric(matrix);
-  cell_size->setM(M);
+  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];
 }
 
@@ -124 +119 @@
   molecule *mol = NULL;
   mol = NewMolecule();
-  moleculeId_t id = getNextMoleculeId();
-  ASSERT(!molecules.count(id),"proposed id did not specify an unused ID");
-  mol->setId(id);
+  ASSERT(!molecules.count(currMoleculeId),"currMoleculeId did not specify an unused ID");
+  mol->setId(currMoleculeId++);
   // store the molecule by ID
   molecules[mol->getId()] = mol;
@@ -144 +138 @@
   DeleteMolecule(mol);
   molecules.erase(id);
-  releaseMoleculeId(id);
-}
+}
+
+double *World::cell_size = NULL;
 
 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);
@@ -227 +221 @@
 
 atomId_t World::getNextAtomId(){
-  // 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);
-    }
+  // 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;
   }
-  // Nothing in the pool... we are out of luck
-  return currAtomId++;
 }
 
 void World::releaseAtomId(atomId_t id){
-  atomIdPool.insert(make_pair(id,id+1));
-  defragAtomIdPool();
+  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 ){
-    pair<atomId_t,atomId_t> newRange = make_pair(currAtomId,id);
-    if(newRange.first<newRange.second){
-      atomIdPool.insert(newRange);
+    // 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;
-    defragAtomIdPool();
     return true;
   }
-  // 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;
+  else if(atomIdPool.count(id)){
+    atomIdPool.erase(id);
+    return true;
+  }
+  else{
+    // this ID could not be reserved
+    return false;
+  }
 }
 
 // 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;
-  }
-  // 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
-
+// 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::getAtomIter(){
-    return AtomIterator(AllAtoms(),atoms);
-}
-
-World::AtomIterator
-World::atomEnd(){
+
+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::getMoleculeIter(){
-    return MoleculeIterator(AllMolecules(),molecules);
-}
-
-World::MoleculeIterator
-World::moleculeEnd(){
+World::MoleculeIterator World::getMoleculeIter(MoleculeDescriptor descr){
+  return MoleculeIterator(descr,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
-
-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();
 }
 
@@ -649 +297 @@
     Thermostats(new ThermoStatContainer),
     ExitFlag(0),
-    atoms(this),
-    selectedAtoms(this),
+    atoms(),
     currAtomId(0),
-    lastAtomPoolSize(0),
-    numAtomDefragSkips(0),
-    molecules(this),
-    selectedMolecules(this),
+    molecules(),
     currMoleculeId(0),
     molecules_deprecated(new MoleculeListClass(this))
 {
-  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);
+  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.;
   defaultName = "none";
   molecules_deprecated->signOn(this);
@@ -672 +317 @@
 {
   molecules_deprecated->signOff(this);
-  delete cell_size;
+  delete[] cell_size;
   delete molecules_deprecated;
   delete periode;