Changes in / [1024cb:42af9e]


Ignore:
Files:
6 added
6 deleted
55 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/FragmentationAction/DepthFirstSearchAction.cpp

    r1024cb r42af9e  
    4646    molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
    4747    MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
    48     int *MinimumRingSize = new int[mol->getAtomCount()];
     48    int *MinimumRingSize = new int[mol->AtomCount];
    4949    atom ***ListOfLocalAtoms = NULL;
    5050    class StackClass<bond *> *BackEdgeStack = NULL;

  • src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp

    r1024cb r42af9e  
    6565    DoLog(0) && (Log() << Verbose(0) << "Evaluating non-convex envelope of molecule." << Boundary->getId() << endl);
    6666    DoLog(1) && (Log() << Verbose(1) << "Using rolling ball of radius " << SphereRadius << " and storing tecplot data in " << filename << "." << endl);
    67     DoLog(1) && (Log() << Verbose(1) << "Specified molecule has " << Boundary->getAtomCount() << " atoms." << endl);
     67    DoLog(1) && (Log() << Verbose(1) << "Specified molecule has " << Boundary->AtomCount << " atoms." << endl);
    6868    start = clock();
    6969    LCList = new LinkedCell(Boundary, SphereRadius*2.);

  • src/Actions/WorldAction/RepeatBoxAction.cpp

    r1024cb r42af9e  
    4040  molecule *mol = NULL;
    4141  int j = 0;
    42   atom *Walker = NULL;
    4342
    4443  dialog->queryVector(NAME, &Repeater, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
    … …  
    5554        Repeater[axis] = 1;
    5655      }
    57       if (mol->getAtomCount() != 0) {  // if there is more than none
    58         count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
     56      mol->CountAtoms();  // recount atoms
     57      if (mol->AtomCount != 0) {  // if there is more than none
     58        count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
    5959        Elements = new const element *[count];
    6060        vectors = new Vector *[count];
    6161        j = 0;
    62         for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
    63           Elements[j] = (*AtomRunner)->type;
    64           vectors[j] = &(*AtomRunner)->x;
     62        atom *first = mol->start;
     63        while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
     64          first = first->next;
     65          Elements[j] = first->type;
     66          vectors[j] = &first->x;
    6567          j++;
    6668        }
    … …  
    7375          x += y; // per factor one cell width further
    7476          for (int k=count;k--;) { // go through every atom of the original cell
    75             Walker = World::getInstance().createAtom(); // create a new body
    76             Walker->x = (*vectors[k]) + x;
    77             Walker->type = Elements[k];  // insert original element
    78             mol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
     77            first = World::getInstance().createAtom(); // create a new body
     78            first->x = (*vectors[k]) + x;
     79            first->type = Elements[k];  // insert original element
     80            mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
    7981          }
    8082        }

  • src/Helpers/Assert.cpp

    r1024cb r42af9e  
    5454
    5555
     56
    5657bool _my_assert::check(const bool res,
    5758                       const char* condition,
    … …  
    6263{
    6364  if(!res){
    64     cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
     65    cout << "Assertion " << condition << " failed in file " << filename << " at line " << line << endl;
    6566    cout << "Assertion Message: " << message << std::endl;
    6667    while(true){

  • src/Helpers/MemDebug.cpp

    r1024cb r42af9e  
    99#include <cstdlib>
    1010#include <cstring>
    11 #include <boost/thread.hpp>
    1211
    1312using namespace std;
    14 
    15 #ifndef NDBEGUG
    16 #ifndef NO_MEMDEBUG
    1713
    1814namespace Memory {
    … …  
    4440  };
    4541
    46   boost::mutex memorylock;
    47 
    4842  // start and end of the doubly-linked list
    4943  entry_t *begin=0;
    … …  
    133127
    134128void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
    135 
    136   // we need to lock, so that no one changes the linked list while we are here
    137   boost::mutex::scoped_lock guard(Memory::memorylock);
    138129
    139130  // to avoid allocations of 0 bytes if someone screws up
    … …  
    213204
    214205void operator delete(void *ptr) throw() {
    215   if(!ptr){
    216     cerr << "Warning: Deleting NULL pointer" << endl;
    217     return;
    218   }
    219 
    220   // we need to lock, so the linked list does not changed while we are in here
    221   boost::mutex::scoped_lock guard(Memory::memorylock);
    222 
    223206  // get the size for the entry, including alignment
    224207  static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
    … …  
    229212  // let's see if the checksum is still matching
    230213  if(Memory::calcChecksum(&entry->info)!=entry->checksum){
    231     cerr << "Possible memory corruption detected!" << endl;
    232     cerr << "Trying to recover allocation information..." << endl;
    233     cerr << "Memory was allocated at " << entry->info.file << ":" << entry->info.line << endl;
     214    cout << "Possible memory corruption detected!" << endl;
     215    cout << "Trying to recover allocation information..." << endl;
     216    cout << "Memory was allocated at " << entry->info.file << ":" << entry->info.line << endl;
    234217    terminate();
    235218  }
    … …  
    258241  operator delete(ptr);
    259242}
    260 #endif
    261 #endif

  • src/Helpers/MemDebug.hpp

    r1024cb r42af9e  
    2121 * your sourcefiles.
    2222 */
    23 #ifndef NDEBUG
    24 #ifndef NO_MEMDEBUG
    25 
    26 #ifndef MEMDEBUG
    27 #define MEMDEBUG
    28 #endif
    2923
    3024namespace Memory {
    … …  
    6256#define new new(__FILE__,__LINE__)
    6357
    64 #endif
    65 #endif
    66 
    67 
    68 #ifndef MEMDEBUG
    69 // memory debugging was disabled
    70 
    71 namespace Memory {
    72   inline void getState(){}
    73 
    74   template <typename T>
    75   inline T *ignore(T* ptr){
    76     return ptr;
    77   }
    78 }
    79 
    80 #endif
    8158#endif /* MEMDEBUG_HPP_ */

  • src/Legacy/oldmenu.cpp

    r1024cb r42af9e  
    424424void oldmenu::RemoveAtoms(molecule *mol)
    425425{
    426   atom *second;
     426  atom *first, *second;
    427427  int axis;
    428428  double tmp1, tmp2;
    … …  
    447447      break;
    448448    case 'b':
    449       {
    450         second = mol->AskAtom("Enter number of atom as reference point: ");
    451         Log() << Verbose(0) << "Enter radius: ";
    452         cin >> tmp1;
    453         molecule::iterator runner;
    454         for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
    455           runner = iter++;
    456           if ((*runner)->x.DistanceSquared((*runner)->x) > tmp1*tmp1) // distance to first above radius ...
    457             mol->RemoveAtom((*runner));
    458         }
     449      second = mol->AskAtom("Enter number of atom as reference point: ");
     450      Log() << Verbose(0) << "Enter radius: ";
     451      cin >> tmp1;
     452      first = mol->start;
     453      second = first->next;
     454      while(second != mol->end) {
     455        first = second;
     456        second = first->next;
     457        if (first->x.DistanceSquared(second->x) > tmp1*tmp1) // distance to first above radius ...
     458          mol->RemoveAtom(first);
    459459      }
    460460      break;
    … …  
    466466      Log() << Verbose(0) << "Upper boundary: ";
    467467      cin >> tmp2;
    468       molecule::iterator runner;
    469       for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
    470         runner = iter++;
    471         if (((*runner)->x[axis] < tmp1) || ((*runner)->x[axis] > tmp2)) {// out of boundary ...
    472           //Log() << Verbose(0) << "Atom " << *(*runner) << " with " << (*runner)->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
    473           mol->RemoveAtom((*runner));
     468      first = mol->start;
     469      second = first->next;
     470      while(second != mol->end) {
     471        first = second;
     472        second = first->next;
     473        if ((first->x[axis] < tmp1) || (first->x[axis] > tmp2)) {// out of boundary ...
     474          //Log() << Verbose(0) << "Atom " << *first << " with " << first->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
     475          mol->RemoveAtom(first);
    474476        }
    475477      }
    … …  
    514516        min[i] = 0.;
    515517
    516       for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    517         Z = (*iter)->type->Z;
     518      second = mol->start;
     519      while ((second->next != mol->end)) {
     520        second = second->next; // advance
     521        Z = second->type->Z;
    518522        tmp1 = 0.;
    519         if (first != (*iter)) {
    520           x = first->x - (*iter)->x;
     523        if (first != second) {
     524          x = first->x - second->x;
    521525          tmp1 = x.Norm();
    522526        }
    523527        if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
    524         //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << ((*iter)->nr << ": " << tmp1 << " a.u." << endl;
     528        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
    525529      }
    526530      for (int i=MAX_ELEMENTS;i--;)
    … …  
    751755    Log() << Verbose(0) << "State the factor: ";
    752756    cin >> faktor;
    753     if (mol->getAtomCount() != 0) {  // if there is more than none
    754       count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
     757
     758    mol->CountAtoms(); // recount atoms
     759    if (mol->AtomCount != 0) {  // if there is more than none
     760      count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
    755761      Elements = new const element *[count];
    756762      vectors = new Vector *[count];
    757763      j = 0;
    758       for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    759         Elements[j] = (*iter)->type;
    760         vectors[j] = &(*iter)->x;
     764      first = mol->start;
     765      while (first->next != mol->end) { // make a list of all atoms with coordinates and element
     766        first = first->next;
     767        Elements[j] = first->type;
     768        vectors[j] = &first->x;
    761769        j++;
    762770      }
    … …  
    10171025    return;
    10181026  }
     1027  atom *Walker = mol->start;
    10191028
    10201029  // generate some KeySets
    10211030  Log() << Verbose(0) << "Generating KeySets." << endl;
    1022   KeySet TestSets[mol->getAtomCount()+1];
     1031  KeySet TestSets[mol->AtomCount+1];
    10231032  i=1;
    1024   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     1033  while (Walker->next != mol->end) {
     1034    Walker = Walker->next;
    10251035    for (int j=0;j<i;j++) {
    1026       TestSets[j].insert((*iter)->nr);
     1036      TestSets[j].insert(Walker->nr);
    10271037    }
    10281038    i++;
    … …  
    10301040  Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
    10311041  KeySetTestPair test;
    1032   molecule::const_iterator iter = mol->begin();
    1033   if (iter != mol->end()) {
    1034     test = TestSets[mol->getAtomCount()-1].insert((*iter)->nr);
    1035     if (test.second) {
    1036       Log() << Verbose(1) << "Insertion worked?!" << endl;
    1037     } else {
    1038       Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
    1039     }
     1042  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
     1043  if (test.second) {
     1044    Log() << Verbose(1) << "Insertion worked?!" << endl;
    10401045  } else {
    1041     eLog() << Verbose(1) << "No atoms to test double insertion." << endl;
    1042   }
     1046    Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
     1047  }
     1048  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
     1049  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
    10431050
    10441051  // constructing Graph structure
    … …  
    10481055  // insert KeySets into Subgraphs
    10491056  Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
    1050   for (int j=0;j<mol->getAtomCount();j++) {
     1057  for (int j=0;j<mol->AtomCount;j++) {
    10511058    Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
    10521059  }
    10531060  Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl;
    10541061  GraphTestPair test2;
    1055   test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
     1062  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
    10561063  if (test2.second) {
    10571064    Log() << Verbose(1) << "Insertion worked?!" << endl;

  • src/Makefile.am

    r1024cb r42af9e  
    115115  Descriptors/MoleculeIdDescriptor.cpp
    116116                                   
    117 
     117                                   
    118118DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
    119119  Descriptors/AtomIdDescriptor.hpp \
    … …  
    157157  Line.cpp \
    158158  linkedcell.cpp \
     159  lists.cpp \
    159160  log.cpp \
    160161  logger.cpp \
    … …  
    169170  periodentafel.cpp \
    170171  Plane.cpp \
    171   Space.cpp \
    172172  tesselation.cpp \
    173173  tesselationhelpers.cpp \
    174174  triangleintersectionlist.cpp \
    175   vector.cpp \
     175  verbose.cpp \
    176176  vector_ops.cpp \
    177   verbose.cpp \
    178177  World.cpp
    179178
    … …  
    221220# the following files are no longer used:
    222221#  memoryallocator.hpp \
    223 #  memoryallocator.cpp \
    224222#  memoryusageobserver.hpp \
    225223#  memoryusageobserver.cpp

  • src/Patterns/Cacheable.hpp

    r1024cb r42af9e  
    2828        owner(_owner)
    2929        {}
    30       virtual T& getValue()=0;
     30      virtual T getValue()=0;
    3131      virtual void invalidate()=0;
    3232      virtual bool isValid()=0;
    … …  
    4646        {}
    4747
    48       virtual T& getValue(){
     48      virtual T getValue(){
    4949        // set the state to valid
    5050        State::owner->switchState(State::owner->validState);
    … …  
    7272        {}
    7373
    74       virtual T& getValue(){
     74      virtual T getValue(){
    7575        return content;
    7676      }
    … …  
    100100        {}
    101101
    102       virtual T& getValue(){
     102      virtual T getValue(){
    103103        ASSERT(0,"Cannot get a value from a Cacheable after it's Observable has died");
    104104        // we have to return a grossly invalid reference, because no value can be produced anymore
    … …  
    134134    void subjectKilled(Observable *subject);
    135135  private:
     136
    136137    void switchState(state_ptr newState);
    137138
    … …  
    143144
    144145    Observable *owner;
     146
    145147    boost::function<T()> recalcMethod;
    146148
    … …  
    219221
    220222    const bool isValid() const;
    221     const T& operator*() const;
     223    const T operator*() const;
    222224
    223225    // methods implemented for base-class Observer
    … …  
    235237
    236238  template<typename T>
    237   const T& Cacheable<T>::operator*() const{
     239  const T Cacheable<T>::operator*() const{
    238240    return recalcMethod();
    239241  }

  • src/Patterns/Observer.cpp

    r1024cb r42af9e  
    8282Observable::_Observable_protector::_Observable_protector(Observable *_protege) :
    8383  protege(_protege)
    84 {
    85   start_observer_internal(protege);
    86 }
    87 
    88 Observable::_Observable_protector::_Observable_protector(const _Observable_protector &dest) :
    89     protege(dest.protege)
    9084{
    9185  start_observer_internal(protege);
    … …  
    195189  ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
    196190  callees_t &callees = callTable[this];
    197 
    198191  callees_t::iterator iter;
    199192  callees_t::iterator deliter;

  • src/Patterns/Observer.hpp

    r1024cb r42af9e  
    3636typedef Notification *const Notification_ptr;
    3737
    38 template<class _Set>
    39 class ObservedIterator;
    40 
    4138/**
    4239 * An Observer is notified by all Observed objects, when anything changes.
    … …  
    5653  friend class Observable;
    5754  friend class Notification;
    58   template<class> friend class ObservedIterator;
    59 
    6055public:
    6156  Observer();
    … …  
    157152  static std::set<Observable*> busyObservables;
    158153
     154
    159155  //! @cond
    160156  // Structure for RAII-Style notification
    … …  
    168164  public:
    169165    _Observable_protector(Observable *);
    170     _Observable_protector(const _Observable_protector&);
    171166    ~_Observable_protector();
    172167  private:

  • src/Plane.cpp

    r1024cb r42af9e  
    9191  offset = normalVector->ScalarProduct(_offsetVector);
    9292}
    93 
    94 /**
    95  * copy constructor
    96  */
    97 Plane::Plane(const Plane& plane) :
    98   normalVector(new Vector(*plane.normalVector)),
    99   offset(plane.offset)
    100 {}
    101 
    10293
    10394Plane::~Plane()

  • src/Plane.hpp

    r1024cb r42af9e  
    2626  Plane(const Vector &_normalVector, double _offset)  throw(ZeroVectorException);
    2727  Plane(const Vector &_normalVector, const Vector &_offsetVector) throw(ZeroVectorException);
    28   Plane(const Plane& plane);
    2928  virtual ~Plane();
    3029

  • src/analysis_bonds.cpp

    r1024cb r42af9e  
    2626  Mean = 0.;
    2727
     28  atom *Walker = mol->start;
    2829  int AtomCount = 0;
    29   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    30     const int count = (*iter)->ListOfBonds.size();
     30  while (Walker->next != mol->end) {
     31    Walker = Walker->next;
     32    const int count = Walker->ListOfBonds.size();
    3133    if (Max < count)
    3234      Max = count;
    … …  
    5658
    5759  int AtomNo = 0;
    58   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    59     if ((*iter)->type == type1)
    60       for (BondList::const_iterator BondRunner = (*iter)->ListOfBonds.begin(); BondRunner != (*iter)->ListOfBonds.end(); BondRunner++)
    61         if ((*BondRunner)->GetOtherAtom((*iter))->type == type2) {
     60  atom *Walker = mol->start;
     61  while (Walker->next != mol->end) {
     62    Walker = Walker->next;
     63    if (Walker->type == type1)
     64      for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++)
     65        if ((*BondRunner)->GetOtherAtom(Walker)->type == type2) {
    6266          const double distance = (*BondRunner)->GetDistanceSquared();
    6367          if (Min > distance)
    … …  
    122126int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL)
    123127{
     128  atom *Walker = NULL;
     129  atom *Runner = NULL;
    124130  int count = 0;
    125131  int OtherHydrogens = 0;
    … …  
    127133  bool InterfaceFlag = false;
    128134  bool OtherHydrogenFlag = true;
    129   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); ++MolWalker) {
    130     molecule::iterator Walker = (*MolWalker)->begin();
    131     for(;Walker!=(*MolWalker)->end();++Walker){
    132       for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); ++MolRunner) {
    133         molecule::iterator Runner = (*MolRunner)->begin();
    134         for(;Runner!=(*MolRunner)->end();++Runner){
    135           if (((*Walker)->type->Z  == 8) && ((*Runner)->type->Z  == 8)) {
     135  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
     136    Walker = (*MolWalker)->start;
     137    while (Walker->next != (*MolWalker)->end) {
     138      Walker = Walker->next;
     139      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); MolRunner++) {
     140        Runner = (*MolRunner)->start;
     141        while (Runner->next != (*MolRunner)->end) {
     142          Runner = Runner->next;
     143          if ((Walker->type->Z  == 8) && (Runner->type->Z  == 8)) {
    136144            // check distance
    137             const double distance = (*Runner)->x.DistanceSquared((*Walker)->x);
     145            const double distance = Runner->x.DistanceSquared(Walker->x);
    138146            if ((distance > MYEPSILON) && (distance < HBRIDGEDISTANCE*HBRIDGEDISTANCE)) { // distance >0 means  different atoms
    139147              // on other atom(Runner) we check for bond to interface element and
    … …  
    143151              OtherHydrogens = 0;
    144152              InterfaceFlag = (InterfaceElement == NULL);
    145               for (BondList::const_iterator BondRunner = (*Runner)->ListOfBonds.begin(); BondRunner != (*Runner)->ListOfBonds.end(); BondRunner++) {
    146                 atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
     153              for (BondList::const_iterator BondRunner = Runner->ListOfBonds.begin(); BondRunner != Runner->ListOfBonds.end(); BondRunner++) {
     154                atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Runner);
    147155                // if hydrogen, check angle to be greater(!) than 30 degrees
    148156                if (OtherAtom->type->Z == 1) {
    149                   const double angle = CalculateAngle(&OtherAtom->x, &(*Runner)->x, &(*Walker)->x);
     157                  const double angle = CalculateAngle(&OtherAtom->x, &Runner->x, &Walker->x);
    150158                  OtherHydrogenFlag = OtherHydrogenFlag && (angle > M_PI*(30./180.) + MYEPSILON);
    151159                  Otherangle += angle;
    … …  
    168176              if (InterfaceFlag && OtherHydrogenFlag) {
    169177                // on this element (Walker) we check for bond to hydrogen, i.e. part of water molecule
    170                 for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {
    171                   atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Walker);
     178                for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
     179                  atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
    172180                  if (OtherAtom->type->Z == 1) {
    173181                    // check angle
    174                     if (CheckHydrogenBridgeBondAngle(*Walker, OtherAtom, *Runner)) {
    175                       DoLog(1) && (Log() << Verbose(1) << (*Walker)->getName() << ", " << OtherAtom->getName() << " and " << (*Runner)->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &(*Walker)->x, &(*Runner)->x)*(180./M_PI) << "." << endl);
     182                    if (CheckHydrogenBridgeBondAngle(Walker, OtherAtom, Runner)) {
     183                      DoLog(1) && (Log() << Verbose(1) << Walker->getName() << ", " << OtherAtom->getName() << " and " << Runner->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &Walker->x, &Runner->x)*(180./M_PI) << "." << endl);
    176184                      count++;
    177185                      break;
    … …  
    197205int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second)
    198206{
     207  atom *Walker = NULL;
    199208  int count = 0;
    200209
    201210  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
    202     molecule::iterator Walker = (*MolWalker)->begin();
    203     for(;Walker!=(*MolWalker)->end();++Walker){
    204       atom * theAtom = *Walker;
    205       if ((theAtom->type == first) || (theAtom->type == second)) {  // first element matches
    206         for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
    207           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
    208           if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (theAtom->nr < OtherAtom->nr)) {
     211    Walker = (*MolWalker)->start;
     212    while (Walker->next != (*MolWalker)->end) {
     213      Walker = Walker->next;
     214      if ((Walker->type == first) || (Walker->type == second)) {  // first element matches
     215        for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
     216          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
     217          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (Walker->nr < OtherAtom->nr)) {
    209218            count++;
    210219            DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
    … …  
    231240  bool MatchFlag[2];
    232241  bool result = false;
     242  atom *Walker = NULL;
    233243  const element * ElementArray[2];
    234244  ElementArray[0] = first;
    … …  
    236246
    237247  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
    238     molecule::iterator Walker = (*MolWalker)->begin();
    239     for(;Walker!=(*MolWalker)->end();++Walker){
    240       atom *theAtom = *Walker;
    241       if (theAtom->type == second) {  // first element matches
     248    Walker = (*MolWalker)->start;
     249    while (Walker->next != (*MolWalker)->end) {
     250      Walker = Walker->next;
     251      if (Walker->type == second) {  // first element matches
    242252        for (int i=0;i<2;i++)
    243253          MatchFlag[i] = false;
    244         for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
    245           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
     254        for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
     255          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
    246256          for (int i=0;i<2;i++)
    247257            if ((!MatchFlag[i]) && (OtherAtom->type == ElementArray[i])) {

  • src/analysis_correlation.cpp

    r1024cb r42af9e  
    4040  }
    4141  outmap = new PairCorrelationMap;
    42   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
     42  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
    4343    if ((*MolWalker)->ActiveFlag) {
    4444      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    45       eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
    46       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    47         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    48         if ((type1 == NULL) || ((*iter)->type == type1)) {
    49           for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
     45      atom *Walker = (*MolWalker)->start;
     46      while (Walker->next != (*MolWalker)->end) {
     47        Walker = Walker->next;
     48        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
     49        if ((type1 == NULL) || (Walker->type == type1)) {
     50          for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++)
    5051            if ((*MolOtherWalker)->ActiveFlag) {
    5152              DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
    52               for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
    53                 DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    54                 if ((*iter)->getId() < (*runner)->getId()){
    55                   if ((type2 == NULL) || ((*runner)->type == type2)) {
    56                     distance = (*iter)->node->PeriodicDistance(*(*runner)->node,  World::getInstance().getDomain());
    57                     //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
    58                     outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
     53              atom *OtherWalker = (*MolOtherWalker)->start;
     54              while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
     55                OtherWalker = OtherWalker->next;
     56                DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
     57                if (Walker->nr < OtherWalker->nr)
     58                  if ((type2 == NULL) || (OtherWalker->type == type2)) {
     59                    distance = Walker->node->PeriodicDistance(*OtherWalker->node, World::getInstance().getDomain());
     60                    //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
     61                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
    5962                  }
    60                 }
    6163              }
    62             }
    6364          }
    6465        }
    6566      }
    6667    }
    67   }
     68
    6869  return outmap;
    6970};
    … …  
    100101      double * FullInverseMatrix = InverseMatrix(FullMatrix);
    101102      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    102       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    103         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    104         if ((type1 == NULL) || ((*iter)->type == type1)) {
    105           periodicX = *(*iter)->node;
     103      atom *Walker = (*MolWalker)->start;
     104      while (Walker->next != (*MolWalker)->end) {
     105        Walker = Walker->next;
     106        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
     107        if ((type1 == NULL) || (Walker->type == type1)) {
     108          periodicX = *(Walker->node);
    106109          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
    107110          // go through every range in xyz and get distance
    … …  
    114117                  if ((*MolOtherWalker)->ActiveFlag) {
    115118                    DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
    116                     for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
    117                       DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    118                       if ((*iter)->nr < (*runner)->nr)
    119                         if ((type2 == NULL) || ((*runner)->type == type2)) {
    120                           periodicOtherX = *(*runner)->node;
     119                    atom *OtherWalker = (*MolOtherWalker)->start;
     120                    while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
     121                      OtherWalker = OtherWalker->next;
     122                      DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
     123                      if (Walker->nr < OtherWalker->nr)
     124                        if ((type2 == NULL) || (OtherWalker->type == type2)) {
     125                          periodicOtherX = *(OtherWalker->node);
    121126                          periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
    122127                          // go through every range in xyz and get distance
    … …  
    127132                                checkOtherX.MatrixMultiplication(FullMatrix);
    128133                                distance = checkX.distance(checkOtherX);
    129                                 //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
    130                                 outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
     134                                //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
     135                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
    131136                              }
    132137                        }
    … …  
    164169    if ((*MolWalker)->ActiveFlag) {
    165170      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    166       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    167         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    168         if ((type == NULL) || ((*iter)->type == type)) {
    169           distance = (*iter)->node->PeriodicDistance(*point, World::getInstance().getDomain());
     171      atom *Walker = (*MolWalker)->start;
     172      while (Walker->next != (*MolWalker)->end) {
     173        Walker = Walker->next;
     174        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
     175        if ((type == NULL) || (Walker->type == type)) {
     176          distance = Walker->node->PeriodicDistance(*point, World::getInstance().getDomain());
    170177          DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
    171           outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
     178          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
    172179        }
    173180      }
    … …  
    204211      double * FullInverseMatrix = InverseMatrix(FullMatrix);
    205212      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    206       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    207         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    208         if ((type == NULL) || ((*iter)->type == type)) {
    209           periodicX = *(*iter)->node;
     213      atom *Walker = (*MolWalker)->start;
     214      while (Walker->next != (*MolWalker)->end) {
     215        Walker = Walker->next;
     216        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
     217        if ((type == NULL) || (Walker->type == type)) {
     218          periodicX = *(Walker->node);
    210219          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
    211220          // go through every range in xyz and get distance
    … …  
    217226                distance = checkX.distance(*point);
    218227                DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
    219                 outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
     228                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
    220229              }
    221230        }
    … …  
    252261    if ((*MolWalker)->ActiveFlag) {
    253262      DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
    254       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    255         //Log() << Verbose(3) << "Current atom is " << *(*iter) << "." << endl;
    256         if ((type == NULL) || ((*iter)->type == type)) {
    257           TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
     263      atom *Walker = (*MolWalker)->start;
     264      while (Walker->next != (*MolWalker)->end) {
     265        Walker = Walker->next;
     266        //Log() << Verbose(1) << "Current atom is " << *Walker << "." << endl;
     267        if ((type == NULL) || (Walker->type == type)) {
     268          TriangleIntersectionList Intersections(Walker->node,Surface,LC);
    258269          distance = Intersections.GetSmallestDistance();
    259270          triangle = Intersections.GetClosestTriangle();
    260           outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
     271          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
    261272        }
    262273      }
    … …  
    303314      double * FullInverseMatrix = InverseMatrix(FullMatrix);
    304315      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    305       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    306         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    307         if ((type == NULL) || ((*iter)->type == type)) {
    308           periodicX = *(*iter)->node;
     316      atom *Walker = (*MolWalker)->start;
     317      while (Walker->next != (*MolWalker)->end) {
     318        Walker = Walker->next;
     319        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
     320        if ((type == NULL) || (Walker->type == type)) {
     321          periodicX = *(Walker->node);
    309322          periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
    310323          // go through every range in xyz and get distance
    … …  
    324337              }
    325338          // insert
    326           outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
     339          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, ShortestTriangle) ) );
    327340          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
    328341        }

  • src/atom.cpp

    r1024cb r42af9e  
    5959atom::~atom()
    6060{
     61  unlink(this);
    6162};
    6263

  • src/bondgraph.cpp

    r1024cb r42af9e  
    9090bool status = true;
    9191
    92   if (mol->empty()) // only construct if molecule is not empty
     92  if (mol->start->next == mol->end) // only construct if molecule is not empty
    9393    return false;
    9494
    … …  
    124124  max_distance = 0.;
    125125
    126   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    127     if ((*iter)->type->CovalentRadius > max_distance)
    128       max_distance = (*iter)->type->CovalentRadius;
     126  atom *Runner = mol->start;
     127  while (Runner->next != mol->end) {
     128    Runner = Runner->next;
     129    if (Runner->type->CovalentRadius > max_distance)
     130      max_distance = Runner->type->CovalentRadius;
    129131  }
    130132  max_distance *= 2.;

  • src/boundary.cpp

    r1024cb r42af9e  
    139139{
    140140        Info FunctionInfo(__func__);
     141  atom *Walker = NULL;
    141142  PointMap PointsOnBoundary;
    142143  LineMap LinesOnBoundary;
    … …  
    164165
    165166    // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
    166     for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    167       ProjectedVector = (*iter)->x - (*MolCenter);
     167    Walker = mol->start;
     168    while (Walker->next != mol->end) {
     169      Walker = Walker->next;
     170      ProjectedVector = Walker->x - (*MolCenter);
    168171      ProjectedVector.ProjectOntoPlane(AxisVector);
    169172
    … …  
    179182        angle = 2. * M_PI - angle;
    180183      }
    181     DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
    182       BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
     184      DoLog(1) && (Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
     185      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
    183186      if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
    184187        DoLog(2) && (Log() << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl);
    185188        DoLog(2) && (Log() << Verbose(2) << "Present vector: " << *BoundaryTestPair.first->second.second << endl);
    186         DoLog(2) && (Log() << Verbose(2) << "New vector: " << **iter << endl);
     189        DoLog(2) && (Log() << Verbose(2) << "New vector: " << *Walker << endl);
    187190        const double ProjectedVectorNorm = ProjectedVector.NormSquared();
    188191        if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
    189192          BoundaryTestPair.first->second.first = ProjectedVectorNorm;
    190           BoundaryTestPair.first->second.second = (*iter);
     193          BoundaryTestPair.first->second.second = Walker;
    191194          DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger projected distance " << ProjectedVectorNorm << "." << endl);
    192195        } else if (fabs(ProjectedVectorNorm - BoundaryTestPair.first->second.first) < MYEPSILON) {
    193           helper = (*iter)->x;
    194           helper -= *MolCenter;
     196          helper = Walker->x - (*MolCenter);
    195197          const double oldhelperNorm = helper.NormSquared();
    196198          helper = BoundaryTestPair.first->second.second->x - (*MolCenter);
    197199          if (helper.NormSquared() < oldhelperNorm) {
    198             BoundaryTestPair.first->second.second = (*iter);
     200            BoundaryTestPair.first->second.second = Walker;
    199201            DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl);
    200202          } else {
    … …  
    618620  for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++)
    619621    { // go through every triangle, calculate volume of its pyramid with CoG as peak
    620       x = runner->second->getEndpoint(0) - runner->second->getEndpoint(1);
    621       y = runner->second->getEndpoint(0) - runner->second->getEndpoint(2);
    622       const double a = x.Norm();
    623       const double b = y.Norm();
    624       const double c = runner->second->getEndpoint(2).distance(runner->second->getEndpoint(1));
     622      x = (*runner->second->endpoints[0]->node->node) - (*runner->second->endpoints[1]->node->node);
     623      y = (*runner->second->endpoints[0]->node->node) - (*runner->second->endpoints[2]->node->node);
     624      const double a = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(*runner->second->endpoints[1]->node->node));
     625      const double b = sqrt(runner->second->endpoints[0]->node->node->DistanceSquared(*runner->second->endpoints[2]->node->node));
     626      const double c = sqrt(runner->second->endpoints[2]->node->node->DistanceSquared(*runner->second->endpoints[1]->node->node));
    625627      const double G = sqrt(((a + b + c) * (a + b + c) - 2 * (a * a + b * b + c * c)) / 16.); // area of tesselated triangle
    626       x = runner->second->getPlane().getNormal();
    627       x.Scale(runner->second->getEndpoint(1).ScalarProduct(x));
     628      x = Plane(*(runner->second->endpoints[0]->node->node),
     629                *(runner->second->endpoints[1]->node->node),
     630                *(runner->second->endpoints[2]->node->node)).getNormal();
     631      x.Scale(runner->second->endpoints[1]->node->node->ScalarProduct(x));
    628632      const double h = x.Norm(); // distance of CoG to triangle
    629633      const double PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
    … …  
    693697  int repetition[NDIM] = { 1, 1, 1 };
    694698  int TotalNoClusters = 1;
     699  atom *Walker = NULL;
    695700  double totalmass = 0.;
    696701  double clustervolume = 0.;
    … …  
    716721
    717722  // sum up the atomic masses
    718   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    719       totalmass += (*iter)->type->mass;
     723  Walker = mol->start;
     724  while (Walker->next != mol->end) {
     725      Walker = Walker->next;
     726      totalmass += Walker->type->mass;
    720727  }
    721728  DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
    … …  
    799806  Vector Inserter;
    800807  double FillIt = false;
     808  atom *Walker = NULL;
    801809  bond *Binder = NULL;
    802810  double phi[NDIM];
    … …  
    805813
    806814  for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++)
    807     if ((*ListRunner)->getAtomCount() > 0) {
     815    if ((*ListRunner)->AtomCount > 0) {
    808816      DoLog(1) && (Log() << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl);
    809817      LCList[(*ListRunner)] = new LinkedCell((*ListRunner), 10.); // get linked cell list
    … …  
    823831  }
    824832
    825   atom * CopyAtoms[filler->getAtomCount()];
     833  filler->CountAtoms();
     834  atom * CopyAtoms[filler->AtomCount];
    826835
    827836  // calculate filler grid in [0,1]^3
    … …  
    848857
    849858        // go through all atoms
    850         for (int i=0;i<filler->getAtomCount();i++)
     859        for (int i=0;i<filler->AtomCount;i++)
    851860          CopyAtoms[i] = NULL;
    852         for(molecule::iterator iter = filler->begin(); iter !=filler->end();++filler){
     861        Walker = filler->start;
     862        while (Walker->next != filler->end) {
     863          Walker = Walker->next;
    853864
    854865          // create atomic random translation vector ...
    … …  
    874885
    875886          // ... and put at new position
    876           Inserter = (*iter)->x;
     887          Inserter = Walker->x;
    877888          if (DoRandomRotation)
    878889            Inserter.MatrixMultiplication(Rotations);
    … …  
    898909            DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
    899910            // copy atom ...
    900             CopyAtoms[(*iter)->nr] = (*iter)->clone();
    901             CopyAtoms[(*iter)->nr]->x = Inserter;
    902             Filling->AddAtom(CopyAtoms[(*iter)->nr]);
    903             DoLog(4) && (Log() << Verbose(4) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->nr]->x) << "." << endl);
     911            CopyAtoms[Walker->nr] = Walker->clone();
     912            CopyAtoms[Walker->nr]->x = Inserter;
     913            Filling->AddAtom(CopyAtoms[Walker->nr]);
     914            DoLog(4) && (Log() << Verbose(4) << "Filling atom " << *Walker << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[Walker->nr]->x) << "." << endl);
    904915          } else {
    905916            DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
    906             CopyAtoms[(*iter)->nr] = NULL;
     917            CopyAtoms[Walker->nr] = NULL;
    907918            continue;
    908919          }
    … …  
    943954  bool TesselationFailFlag = false;
    944955
    945   mol->getAtomCount();
    946 
    947956  if (TesselStruct == NULL) {
    948957    DoLog(1) && (Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl);
    … …  
    10161025//  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
    10171026//  //->InsertStraddlingPoints(mol, LCList);
    1018 //  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     1027//  mol->GoToFirst();
    10191028//  class TesselPoint *Runner = NULL;
    1020 //    Runner = *iter;
     1029//  while (!mol->IsEnd()) {
     1030//    Runner = mol->GetPoint();
    10211031//    Log() << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
    10221032//    if (!->IsInnerPoint(Runner, LCList)) {
    … …  
    10261036//      Log() << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
    10271037//    }
     1038//    mol->GoToNext();
    10281039//  }
    10291040
    … …  
    10341045  status = CheckListOfBaselines(TesselStruct);
    10351046
    1036   cout << "before correction" << endl;
    1037 
    10381047  // store before correction
    1039   StoreTrianglesinFile(mol, TesselStruct, filename, "");
     1048  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
    10401049
    10411050//  // correct degenerated polygons
    … …  
    10471056  // write final envelope
    10481057  CalculateConcavityPerBoundaryPoint(TesselStruct);
    1049   cout << "after correction" << endl;
    1050   StoreTrianglesinFile(mol, TesselStruct, filename, "");
     1058  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
    10511059
    10521060  if (freeLC)

  • src/builder.cpp

    r1024cb r42af9e  
    865865
    866866        mol->CountAtoms(); // recount atoms
    867         if (mol->getAtomCount() != 0) {  // if there is more than none
    868           count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
     867        if (mol->AtomCount != 0) {  // if there is more than none
     868          count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
    869869          Elements = new element *[count];
    870870          vectors = new Vector *[count];
    … …  
    12961296  // generate some KeySets
    12971297  DoLog(0) && (Log() << Verbose(0) << "Generating KeySets." << endl);
    1298   KeySet TestSets[mol->getAtomCount()+1];
     1298  KeySet TestSets[mol->AtomCount+1];
    12991299  i=1;
    13001300  while (Walker->next != mol->end) {
    … …  
    13071307  DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl);
    13081308  KeySetTestPair test;
    1309   test = TestSets[mol->getAtomCount()-1].insert(Walker->nr);
     1309  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
    13101310  if (test.second) {
    13111311    DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
    … …  
    13131313    DoLog(1) && (Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl);
    13141314  }
    1315   TestSets[mol->getAtomCount()].insert(mol->end->previous->nr);
    1316   TestSets[mol->getAtomCount()].insert(mol->end->previous->previous->previous->nr);
     1315  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
     1316  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
    13171317
    13181318  // constructing Graph structure
    … …  
    13221322  // insert KeySets into Subgraphs
    13231323  DoLog(0) && (Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl);
    1324   for (int j=0;j<mol->getAtomCount();j++) {
     1324  for (int j=0;j<mol->AtomCount;j++) {
    13251325    Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
    13261326  }
    13271327  DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl);
    13281328  GraphTestPair test2;
    1329   test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
     1329  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
    13301330  if (test2.second) {
    13311331    DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
    … …  
    17141714                if (first->type != NULL) {
    17151715                  mol->AddAtom(first);  // add to molecule
    1716                   if ((configPresent == empty) && (mol->getAtomCount() != 0))
     1716                  if ((configPresent == empty) && (mol->AtomCount != 0))
    17171717                    configPresent = present;
    17181718                } else
    … …  
    17321732                DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
    17331733                MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
    1734                 int *MinimumRingSize = new int[mol->getAtomCount()];
     1734                int *MinimumRingSize = new int[mol->AtomCount];
    17351735                atom ***ListOfLocalAtoms = NULL;
    17361736                class StackClass<bond *> *BackEdgeStack = NULL;
    … …  
    18801880                          int counter  = 0;
    18811881                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
    1882                             if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
     1882                            if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
    18831883                              Boundary = *BigFinder;
    18841884                            }
    … …  
    19391939                performCriticalExit();
    19401940              } else {
    1941                 mol->getAtomCount();
    19421941                SaveFlag = true;
    19431942                DoLog(1) && (Log() << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl);
    … …  
    20432042                int counter  = 0;
    20442043                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
    2045                   if ((Boundary == NULL) || (Boundary->getAtomCount() < (*BigFinder)->getAtomCount())) {
     2044                  (*BigFinder)->CountAtoms();
     2045                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
    20462046                    Boundary = *BigFinder;
    20472047                  }
    20482048                  counter++;
    20492049                }
    2050                 DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->getAtomCount() << " atoms." << endl);
     2050                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->AtomCount << " atoms." << endl);
    20512051                start = clock();
    20522052                LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
    … …  
    21152115            case 'R':
    21162116              if (ExitFlag == 0) ExitFlag = 1;
    2117               if ((argptr+3 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])))  {
     2117              if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])))  {
    21182118                ExitFlag = 255;
    2119                 DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <x> <y> <z> <distance>" << endl);
     2119                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <id> <distance>" << endl);
    21202120                performCriticalExit();
    21212121              } else {
    21222122                SaveFlag = true;
    2123                 const double radius = atof(argv[argptr+3]);
    2124                 Vector point(atof(argv[argptr]),atof(argv[argptr+1]),atof(argv[argptr+2]));
    2125                 DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
    2126                 atom *Walker = NULL;
    2127                 molecule::iterator advancer = mol->begin();
    2128                 for(molecule::iterator iter = advancer; advancer != mol->end();) {
    2129                   iter = advancer++;
    2130                   if ((*iter)->x.DistanceSquared(point) > radius*radius){ // distance to first above radius ...
    2131                     Walker = (*iter);
    2132                     DoLog(1) && (Log() << Verbose(1) << "Removing atom " << *Walker << "." << endl);
    2133                     mol->RemoveAtom(*(iter));
    2134                     World::getInstance().destroyAtom(Walker);
     2123                DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << argv[argptr] << " with radius " << argv[argptr+1] << "." << endl);
     2124                double tmp1 = atof(argv[argptr+1]);
     2125                atom *third = mol->FindAtom(atoi(argv[argptr]));
     2126                atom *first = mol->start;
     2127                if ((third != NULL) && (first != mol->end)) {
     2128                  atom *second = first->next;
     2129                  while(second != mol->end) {
     2130                    first = second;
     2131                    second = first->next;
     2132                    if (first->x.DistanceSquared(third->x) > tmp1*tmp1) {// distance to first above radius ...
     2133                      mol->RemoveAtom(first);
     2134                    }
    21352135                  }
     2136                } else {
     2137                  DoeLog(1) && (eLog()<< Verbose(1) << "Removal failed due to missing atoms on molecule or wrong id." << endl);
    21362138                }
    2137                 argptr+=4;
     2139                argptr+=2;
    21382140              }
    21392141              break;
    … …  
    22602262                performCriticalExit();
    22612263              } else {
    2262                 mol->getAtomCount();
    22632264                SaveFlag = true;
    22642265                DoLog(1) && (Log() << Verbose(1) << "Removing atom " << argv[argptr] << "." << endl);
    … …  
    23802381                    faktor = 1;
    23812382                  }
    2382                   if (mol->getAtomCount() != 0) {  // if there is more than none
    2383                     count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
     2383                  mol->CountAtoms();  // recount atoms
     2384                  if (mol->AtomCount != 0) {  // if there is more than none
     2385                    count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
    23842386                    Elements = new const element *[count];
    23852387                    vectors = new Vector *[count];
    23862388                    j = 0;
    2387                     for(molecule::iterator iter = mol->begin();iter!=mol->end();++iter){
    2388                       Elements[j] = (*iter)->type;
    2389                       vectors[j] = &(*iter)->x;
     2389                    first = mol->start;
     2390                    while (first->next != mol->end) {  // make a list of all atoms with coordinates and element
     2391                      first = first->next;
     2392                      Elements[j] = first->type;
     2393                      vectors[j] = &first->x;
    23902394                      j++;
    23912395                    }
    … …  
    24542458{
    24552459    config *configuration = World::getInstance().getConfig();
    2456     // while we are non interactive, we want to abort from asserts
    2457     //ASSERT_DO(Assert::Abort);
    2458     molecule *mol = NULL;
    24592460    Vector x, y, z, n;
    24602461    ifstream test;
    … …  
    24802481    // need to init the history before any action is created
    24812482    ActionHistory::init();
    2482 
    2483     // In the interactive mode, we can leave the user the choice in case of error
    2484     ASSERT_DO(Assert::Ask);
    24852483
    24862484    // from this moment on, we need to be sure to deeinitialize in the correct order

  • src/config.cpp

    r1024cb r42af9e  
    15481548  int AtomNo = -1;
    15491549  int MolNo = 0;
     1550  atom *Walker = NULL;
    15501551  FILE *f = NULL;
    15511552
    … …  
    15601561  fprintf(f, "# Created by MoleCuilder\n");
    15611562
    1562   for (MoleculeList::const_iterator MolRunner = MolList->ListOfMolecules.begin(); MolRunner != MolList->ListOfMolecules.end(); MolRunner++) {
     1563  for (MoleculeList::const_iterator Runner = MolList->ListOfMolecules.begin(); Runner != MolList->ListOfMolecules.end(); Runner++) {
     1564    Walker = (*Runner)->start;
    15631565    int *elementNo = new int[MAX_ELEMENTS];
    15641566    for (int i=0;i<MAX_ELEMENTS;i++)
    15651567      elementNo[i] = 0;
    15661568    AtomNo = 0;
    1567     for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
    1568       sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
    1569       elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
     1569    while (Walker->next != (*Runner)->end) {
     1570      Walker = Walker->next;
     1571      sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
     1572      elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
    15701573      fprintf(f,
    15711574             "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
    1572              (*iter)->nr,                /* atom serial number */
     1575             Walker->nr,                /* atom serial number */
    15731576             name,         /* atom name */
    1574              (*MolRunner)->name,      /* residue name */
     1577             (*Runner)->name,      /* residue name */
    15751578             'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
    15761579             MolNo,         /* residue sequence number */
    1577              (*iter)->node->at(0),                 /* position X in Angstroem */
    1578              (*iter)->node->at(1),                 /* position Y in Angstroem */
    1579              (*iter)->node->at(2),                 /* position Z in Angstroem */
    1580              (double)(*iter)->type->Valence,         /* occupancy */
    1581              (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
     1580             Walker->node->at(0),                 /* position X in Angstroem */
     1581             Walker->node->at(1),                 /* position Y in Angstroem */
     1582             Walker->node->at(2),                 /* position Z in Angstroem */
     1583             (double)Walker->type->Valence,         /* occupancy */
     1584             (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
    15821585             "0",            /* segment identifier */
    1583              (*iter)->type->symbol,    /* element symbol */
     1586             Walker->type->symbol,    /* element symbol */
    15841587             "0");           /* charge */
    15851588      AtomNo++;
    … …  
    16011604{
    16021605  int AtomNo = -1;
     1606  atom *Walker = NULL;
    16031607  FILE *f = NULL;
    16041608
    … …  
    16171621  fprintf(f, "# Created by MoleCuilder\n");
    16181622
     1623  Walker = mol->start;
    16191624  AtomNo = 0;
    1620   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1621     sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
    1622     elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
     1625  while (Walker->next != mol->end) {
     1626    Walker = Walker->next;
     1627    sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
     1628    elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
    16231629    fprintf(f,
    16241630           "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
    1625            (*iter)->nr,                /* atom serial number */
     1631           Walker->nr,                /* atom serial number */
    16261632           name,         /* atom name */
    16271633           mol->name,      /* residue name */
    16281634           'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
    16291635           0,         /* residue sequence number */
    1630            (*iter)->node->at(0),                 /* position X in Angstroem */
    1631            (*iter)->node->at(1),                 /* position Y in Angstroem */
    1632            (*iter)->node->at(2),                 /* position Z in Angstroem */
    1633            (double)(*iter)->type->Valence,         /* occupancy */
    1634            (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
     1636           Walker->node->at(0),                 /* position X in Angstroem */
     1637           Walker->node->at(1),                 /* position Y in Angstroem */
     1638           Walker->node->at(2),                 /* position Z in Angstroem */
     1639           (double)Walker->type->Valence,         /* occupancy */
     1640           (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
    16351641           "0",            /* segment identifier */
    1636            (*iter)->type->symbol,    /* element symbol */
     1642           Walker->type->symbol,    /* element symbol */
    16371643           "0");           /* charge */
    16381644    AtomNo++;
    … …  
    16521658bool config::SaveTREMOLO(const char * const filename, const molecule * const mol) const
    16531659{
     1660  atom *Walker = NULL;
    16541661  ofstream *output = NULL;
    16551662  stringstream * const fname = new stringstream;
    … …  
    16641671
    16651672  // scan maximum number of neighbours
     1673  Walker = mol->start;
    16661674  int MaxNeighbours = 0;
    1667   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1668     const int count = (*iter)->ListOfBonds.size();
     1675  while (Walker->next != mol->end) {
     1676    Walker = Walker->next;
     1677    const int count = Walker->ListOfBonds.size();
    16691678    if (MaxNeighbours < count)
    16701679      MaxNeighbours = count;
    16711680  }
    1672   *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
    1673 
    1674   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1675     *output << (*iter)->nr << "\t";
    1676     *output << (*iter)->getName() << "\t";
     1681  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
     1682
     1683  Walker = mol->start;
     1684  while (Walker->next != mol->end) {
     1685    Walker = Walker->next;
     1686    *output << Walker->nr << "\t";
     1687    *output << Walker->getName() << "\t";
    16771688    *output << mol->name << "\t";
    16781689    *output << 0 << "\t";
    1679     *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
    1680     *output << static_cast<double>((*iter)->type->Valence) << "\t";
    1681     *output << (*iter)->type->symbol << "\t";
    1682     for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    1683       *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
    1684     for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
     1690    *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
     1691    *output << static_cast<double>(Walker->type->Valence) << "\t";
     1692    *output << Walker->type->symbol << "\t";
     1693    for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
     1694      *output << (*runner)->GetOtherAtom(Walker)->nr << "\t";
     1695    for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
    16851696      *output << "-\t";
    16861697    *output << endl;
    … …  
    17031714{
    17041715  Info FunctionInfo(__func__);
     1716  atom *Walker = NULL;
    17051717  ofstream *output = NULL;
    17061718  stringstream * const fname = new stringstream;
    … …  
    17171729  int MaxNeighbours = 0;
    17181730  for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
    1719     for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    1720       const int count = (*iter)->ListOfBonds.size();
     1731    Walker = (*MolWalker)->start;
     1732    while (Walker->next != (*MolWalker)->end) {
     1733      Walker = Walker->next;
     1734      const int count = Walker->ListOfBonds.size();
    17211735      if (MaxNeighbours < count)
    17221736        MaxNeighbours = count;
    17231737    }
    17241738  }
    1725   *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
     1739  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
    17261740
    17271741  // create global to local id map
    … …  
    17311745    int AtomNo = 1;
    17321746    for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
    1733       for(molecule::iterator AtomRunner = (*MolWalker)->begin(); AtomRunner != (*MolWalker)->end(); ++AtomRunner) {
    1734         LocalNotoGlobalNoMap.insert( pair<int,int>((*AtomRunner)->getId(), AtomNo++) );
     1747      atom *Walker = (*MolWalker)->start;
     1748      while (Walker->next != (*MolWalker)->end) {
     1749        Walker = Walker->next;
     1750        LocalNotoGlobalNoMap.insert( pair<int,int>(Walker->getId(), AtomNo++) );
    17351751      }
    17361752      MolCounter++;
    … …  
    17441760    int AtomNo = 0;
    17451761    for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
    1746       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    1747         *output << LocalNotoGlobalNoMap[ (*iter)->getId() ] << "\t";
    1748         *output << (*iter)->getName() << "\t";
     1762      Walker = (*MolWalker)->start;
     1763      while (Walker->next != (*MolWalker)->end) {
     1764        Walker = Walker->next;
     1765        *output << LocalNotoGlobalNoMap[ Walker->getId() ] << "\t";
     1766        *output << Walker->getName() << "\t";
    17491767        *output << (*MolWalker)->name << "\t";
    17501768        *output << MolCounter+1 << "\t";
    1751         *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
    1752         *output << (double)(*iter)->type->Valence << "\t";
    1753         *output << (*iter)->type->symbol << "\t";
    1754         for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    1755           *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";
    1756         for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
     1769        *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
     1770        *output << (double)Walker->type->Valence << "\t";
     1771        *output << Walker->type->symbol << "\t";
     1772        for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
     1773          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom(Walker)->getId() ] << "\t";
     1774        for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
    17571775          *output << "-\t";
    17581776        *output << endl;
    … …  
    17951813  if (output == NULL)
    17961814    strcpy(filename,"main_pcp_linux");
    1797   Log() << Verbose(0) << "Saving as pdb input ... " << endl;
     1815  Log() << Verbose(0) << "Saving as pdb input ";
    17981816  if (SavePDB(filename, molecules))
    1799     Log() << Verbose(0) << "\t... done." << endl;
     1817    Log() << Verbose(0) << "done." << endl;
    18001818  else
    1801     Log() << Verbose(0) << "\t... failed." << endl;
     1819    Log() << Verbose(0) << "failed." << endl;
    18021820
    18031821  // then save as tremolo data file
    … …  
    18061824  if (output == NULL)
    18071825    strcpy(filename,"main_pcp_linux");
    1808   Log() << Verbose(0) << "Saving as tremolo data input ... " << endl;
     1826  Log() << Verbose(0) << "Saving as tremolo data input ";
    18091827  if (SaveTREMOLO(filename, molecules))
    1810     Log() << Verbose(0) << "\t... done." << endl;
     1828    Log() << Verbose(0) << "done." << endl;
    18111829  else
    1812     Log() << Verbose(0) << "\t... failed." << endl;
     1830    Log() << Verbose(0) << "failed." << endl;
    18131831
    18141832  // translate each to its center and merge all molecules in MoleculeListClass into this molecule
    … …  
    18461864  output.close();
    18471865  output.clear();
    1848   Log() << Verbose(0) << "Saving of config file ... " << endl;
     1866  Log() << Verbose(0) << "Saving of config file ";
    18491867  if (Save(filename, periode, mol))
    1850     Log() << Verbose(0) << "\t... successful." << endl;
     1868    Log() << Verbose(0) << "successful." << endl;
    18511869  else
    1852     Log() << Verbose(0) << "\t... failed." << endl;
     1870    Log() << Verbose(0) << "failed." << endl;
    18531871
    18541872  // and save to xyz file
    … …  
    18631881    output.open(filename, ios::trunc);
    18641882  }
    1865   Log() << Verbose(0) << "Saving of XYZ file ... " << endl;
     1883  Log() << Verbose(0) << "Saving of XYZ file ";
    18661884  if (mol->MDSteps <= 1) {
    18671885    if (mol->OutputXYZ(&output))
    1868       Log() << Verbose(0) << "\t... successful." << endl;
     1886      Log() << Verbose(0) << "successful." << endl;
    18691887    else
    1870       Log() << Verbose(0) << "\t... failed." << endl;
     1888      Log() << Verbose(0) << "failed." << endl;
    18711889  } else {
    18721890    if (mol->OutputTrajectoriesXYZ(&output))
    1873       Log() << Verbose(0) << "\t... successful." << endl;
     1891      Log() << Verbose(0) << "successful." << endl;
    18741892    else
    1875       Log() << Verbose(0) << "\t... failed." << endl;
     1893      Log() << Verbose(0) << "failed." << endl;
    18761894  }
    18771895  output.close();
    … …  
    18831901  if (output == NULL)
    18841902    strcpy(filename,"main_pcp_linux");
    1885   Log() << Verbose(0) << "Saving as mpqc input .. " << endl;
     1903  Log() << Verbose(0) << "Saving as mpqc input ";
    18861904  if (SaveMPQC(filename, mol))
    1887     Log() << Verbose(0) << "\t... done." << endl;
     1905    Log() << Verbose(0) << "done." << endl;
    18881906  else
    1889     Log() << Verbose(0) << "\t... failed." << endl;
     1907    Log() << Verbose(0) << "failed." << endl;
    18901908
    18911909  if (!strcmp(configpath, GetDefaultPath())) {

  • src/helpers.cpp

    r1024cb r42af9e  
    180180
    181181
     182/** Allocates a memory range using malloc().
     183 * Prints the provided error message in case of a failure.
     184 *
     185 * \param number of memory slices of type X to allocate
     186 * \param failure message which is printed if the allocation fails
     187 * \return pointer to the allocated memory range, will be NULL if a failure occurred
     188 */
     189template <> char* Malloc<char>(size_t size, const char* output)
     190{
     191  char* buffer = NULL;
     192  buffer = (char*) malloc(sizeof(char) * (size + 1));
     193  for (size_t i = size; i--;)
     194    buffer[i] = (i % 2 == 0) ? 'p': 'c';
     195  buffer[size] = '\0';
     196
     197  if (buffer != NULL) {
     198    //MemoryUsageObserver::getInstance()->addMemory(buffer, size);
     199  } else {
     200    Log() << Verbose(0) << "Malloc for datatype " << typeid(char).name()
     201      << " failed - pointer is NULL: " << output << endl;
     202  }
     203
     204  return buffer;
     205};
     206
    182207/**
    183208 * Calls exit(255).

  • src/helpers.hpp

    r1024cb r42af9e  
    139139};
    140140
    141 
    142141/** Frees a two-dimensional array.
    143142 * \param *ptr pointer to array

  • src/lists.hpp

    r1024cb r42af9e  
    134134};
    135135
     136/** Returns the first marker in a chain list.
     137 * \param *me one arbitrary item in chain list
     138 * \return poiner to first marker
     139 */
     140template <typename X> X *GetFirst(X *me)
     141{
     142  X *Binder = me;
     143  while(Binder->previous != 0)
     144    Binder = Binder->previous;
     145  return Binder;
     146};
     147
     148/** Returns the last marker in a chain list.
     149 * \param *me one arbitrary item in chain list
     150 * \return poiner to last marker
     151 */
     152template <typename X> X *GetLast(X *me)
     153{
     154  X *Binder = me;
     155  while(Binder->next != 0)
     156    Binder = Binder->next;
     157  return Binder;
     158};
     159
    136160#endif /* LISTS_HPP_ */

  • src/molecule.cpp

    r1024cb r42af9e  
    3535 * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
    3636 */
    37 molecule::molecule(const periodentafel * const teil) : elemente(teil),
    38   first(new bond(0, 0, 1, -1)), last(new bond(0, 0, 1, -1)), MDSteps(0),
     37molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::getInstance().createAtom()), end(World::getInstance().createAtom()),
     38  first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0),
    3939  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.),
    4040  ActiveFlag(false), IndexNr(-1),
    4141  formula(this,boost::bind(&molecule::calcFormula,this)),
    42   AtomCount(this,boost::bind(&molecule::doCountAtoms,this)), last_atom(0),  InternalPointer(begin())
    43 {
     42  last_atom(0),
     43  InternalPointer(start)
     44{
     45  // init atom chain list
     46  start->father = NULL;
     47  end->father = NULL;
     48  link(start,end);
     49
    4450  // init bond chain list
    4551  link(first,last);
    … …  
    6369  delete(first);
    6470  delete(last);
     71  end->getWorld()->destroyAtom(end);
     72  start->getWorld()->destroyAtom(start);
    6573};
    6674
    … …  
    7583}
    7684
    77 int molecule::getAtomCount() const{
    78   return *AtomCount;
    79 }
    80 
    8185void molecule::setName(const std::string _name){
    8286  OBSERVE;
    … …  
    100104  stringstream sstr;
    101105  periodentafel *periode = World::getInstance().getPeriode();
    102   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    103     counts[(*iter)->type->getNumber()]++;
     106  for(atom *Walker = start; Walker != end; Walker = Walker->next) {
     107    counts[Walker->type->getNumber()]++;
    104108  }
    105109  std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
    … …  
    111115}
    112116
    113 /************************** Access to the List of Atoms ****************/
    114 
    115 
    116 molecule::iterator molecule::begin(){
    117   return molecule::iterator(atoms.begin(),this);
    118 }
    119 
    120 molecule::const_iterator molecule::begin() const{
    121   return atoms.begin();
    122 }
    123 
    124 molecule::iterator molecule::end(){
    125   return molecule::iterator(atoms.end(),this);
    126 }
    127 
    128 molecule::const_iterator molecule::end() const{
    129   return atoms.end();
    130 }
    131 
    132 bool molecule::empty() const
    133 {
    134   return (begin() == end());
    135 }
    136 
    137 size_t molecule::size() const
    138 {
    139   size_t counter = 0;
    140   for (molecule::const_iterator iter = begin(); iter != end (); ++iter)
    141     counter++;
    142   return counter;
    143 }
    144 
    145 molecule::const_iterator molecule::erase( const_iterator loc )
    146 {
    147   molecule::const_iterator iter = loc;
    148   iter--;
    149   atoms.erase( loc );
    150   return iter;
    151 }
    152 
    153 molecule::const_iterator molecule::erase( atom *& key )
    154 {
    155   cout << "trying to erase atom" << endl;
    156   molecule::const_iterator iter = find(key);
    157   if (iter != end()){
    158     // remove this position and step forward (post-increment)
    159     atoms.erase( iter++ );
    160   }
    161   return iter;
    162 }
    163 
    164 molecule::const_iterator molecule::find ( atom *& key ) const
    165 {
    166   return atoms.find( key );
    167 }
    168 
    169 pair<molecule::iterator,bool> molecule::insert ( atom * const key )
    170 {
    171   pair<atomSet::iterator,bool> res = atoms.insert(key);
    172   return pair<iterator,bool>(iterator(res.first,this),res.second);
    173 }
    174117
    175118/** Adds given atom \a *pointer from molecule list.
    … …  
    180123bool molecule::AddAtom(atom *pointer)
    181124{
     125  bool retval = false;
    182126  OBSERVE;
    183127  if (pointer != NULL) {
    184128    pointer->sort = &pointer->nr;
     129    pointer->nr = last_atom++;  // increase number within molecule
     130    AtomCount++;
    185131    if (pointer->type != NULL) {
    186132      if (ElementsInMolecule[pointer->type->Z] == 0)
    … …  
    195141      }
    196142    }
    197     insert(pointer);
    198   }
    199   return true;
     143    retval = add(pointer, end);
     144  }
     145  return retval;
    200146};
    201147
    … …  
    211157  if (pointer != NULL) {
    212158    atom *walker = pointer->clone();
    213     walker->setName(pointer->getName());
     159    stringstream sstr;
     160    sstr << pointer->getName();
     161    walker->setName(sstr.str());
    214162    walker->nr = last_atom++;  // increase number within molecule
    215     insert(walker);
     163    add(walker, end);
    216164    if ((pointer->type != NULL) && (pointer->type->Z != 1))
    217165      NoNonHydrogen++;
     166    AtomCount++;
    218167    retval=walker;
    219168  }
    … …  
    626575
    627576  // copy values
     577  copy->CountAtoms();
    628578  copy->CountElements();
    629579  if (first->next != last) {  // if adjaceny list is present
    … …  
    660610{
    661611  bond *Binder = NULL;
    662 
    663   // some checks to make sure we are able to create the bond
    664   ASSERT(atom1, "First atom in bond-creation was an invalid pointer");
    665   ASSERT(atom2, "Second atom in bond-creation was an invalid pointer");
    666   ASSERT(FindAtom(atom1->nr),"First atom in bond-creation was not part of molecule");
    667   ASSERT(FindAtom(atom2->nr),"Second atom in bond-creation was not parto of molecule");
    668 
    669   Binder = new bond(atom1, atom2, degree, BondCount++);
    670   atom1->RegisterBond(Binder);
    671   atom2->RegisterBond(Binder);
    672   if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
    673     NoNonBonds++;
    674   add(Binder, last);
    675 
     612  if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
     613    Binder = new bond(atom1, atom2, degree, BondCount++);
     614    atom1->RegisterBond(Binder);
     615    atom2->RegisterBond(Binder);
     616    if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
     617      NoNonBonds++;
     618    add(Binder, last);
     619  } else {
     620    DoeLog(1) && (eLog()<< Verbose(1) << "Could not add bond between " << atom1->getName() << " and " << atom2->getName() << " as one or both are not present in the molecule." << endl);
     621  }
    676622  return Binder;
    677623};
    … …  
    747693bool molecule::RemoveAtom(atom *pointer)
    748694{
    749   ASSERT(pointer, "Null pointer passed to molecule::RemoveAtom().");
    750   OBSERVE;
    751695  if (ElementsInMolecule[pointer->type->Z] != 0)  { // this would indicate an error
    752696    ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
     697    AtomCount--;
    753698  } else
    754699    DoeLog(1) && (eLog()<< Verbose(1) << "Atom " << pointer->getName() << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl);
    … …  
    756701    ElementCount--;
    757702  RemoveBonds(pointer);
    758   erase(pointer);
    759   return true;
     703  return remove(pointer, start, end);
    760704};
    761705
    … …  
    774718  if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
    775719    ElementCount--;
    776   erase(pointer);
     720  unlink(pointer);
    777721  return true;
    778722};
    … …  
    783727bool molecule::CleanupMolecule()
    784728{
    785   for (molecule::iterator iter = begin(); !empty(); iter = begin())
    786       erase(iter);
    787   return (cleanup(first,last));
     729  return (cleanup(first,last) && cleanup(start,end));
    788730};
    789731
    … …  
    792734 * \return pointer to atom or NULL
    793735 */
    794 atom * molecule::FindAtom(int Nr)  const
    795 {
    796   molecule::const_iterator iter = begin();
    797   for (; iter != end(); ++iter)
    798     if ((*iter)->nr == Nr)
    799       break;
    800   if (iter != end()) {
     736atom * molecule::FindAtom(int Nr)  const{
     737  atom * walker = find(&Nr, start,end);
     738  if (walker != NULL) {
    801739    //Log() << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
    802     return (*iter);
     740    return walker;
    803741  } else {
    804742    DoLog(0) && (Log() << Verbose(0) << "Atom not found in list." << endl);
    … …  
    930868    now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
    931869    for (int step=0;step<MDSteps;step++) {
    932       *output << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
     870      *output << AtomCount << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
    933871      ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
    934872    }
    … …  
    947885  if (output != NULL) {
    948886    now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
    949     *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
     887    *output << AtomCount << "\n\tCreated by molecuilder on " << ctime(&now);
    950888    ActOnAllAtoms( &atom::OutputXYZLine, output );
    951889    return true;
    … …  
    957895 * \param *out output stream for debugging
    958896 */
    959 int molecule::doCountAtoms()
    960 {
    961   int res = size();
     897void molecule::CountAtoms()
     898{
    962899  int i = 0;
    963   NoNonHydrogen = 0;
    964   for (molecule::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
    965     (*iter)->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
    966     if ((*iter)->type->Z != 1) // count non-hydrogen atoms whilst at it
    967       NoNonHydrogen++;
    968     stringstream sstr;
    969     sstr << (*iter)->type->symbol << (*iter)->nr+1;
    970     (*iter)->setName(sstr.str());
    971     Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl;
     900  atom *Walker = start;
     901  while (Walker->next != end) {
     902    Walker = Walker->next;
    972903    i++;
    973904  }
    974   return res;
     905  if ((AtomCount == 0) || (i != AtomCount)) {
     906    DoLog(3) && (Log() << Verbose(3) << "Mismatch in AtomCount " << AtomCount << " and recounted number " << i << ", renaming all." << endl);
     907    AtomCount = i;
     908
     909    // count NonHydrogen atoms and give each atom a unique name
     910    if (AtomCount != 0) {
     911      i=0;
     912      NoNonHydrogen = 0;
     913      Walker = start;
     914      while (Walker->next != end) {
     915        Walker = Walker->next;
     916        Walker->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
     917        if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
     918          NoNonHydrogen++;
     919        stringstream sstr;
     920        sstr << Walker->type->symbol << Walker->nr+1;
     921        Walker->setName(sstr.str());
     922        DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << Walker->nr << " " << Walker->getName() << "." << endl);
     923        i++;
     924      }
     925    } else
     926      DoLog(3) && (Log() << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl);
     927  }
    975928};
    976929
    … …  
    1034987  /// first count both their atoms and elements and update lists thereby ...
    1035988  //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
     989  CountAtoms();
     990  OtherMolecule->CountAtoms();
    1036991  CountElements();
    1037992  OtherMolecule->CountElements();
    … …  
    1040995  /// -# AtomCount
    1041996  if (result) {
    1042     if (getAtomCount() != OtherMolecule->getAtomCount()) {
    1043       DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
     997    if (AtomCount != OtherMolecule->AtomCount) {
     998      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl);
    1044999      result = false;
    1045     } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
     1000    } else Log() << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
    10461001  }
    10471002  /// -# ElementCount
    … …  
    10801035  if (result) {
    10811036    DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
    1082     Distances = new double[getAtomCount()];
    1083     OtherDistances = new double[getAtomCount()];
     1037    Distances = new double[AtomCount];
     1038    OtherDistances = new double[AtomCount];
    10841039    SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
    10851040    SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
    1086     for(int i=0;i<getAtomCount();i++) {
     1041    for(int i=0;i<AtomCount;i++) {
    10871042      Distances[i] = 0.;
    10881043      OtherDistances[i] = 0.;
    … …  
    10911046    /// ... sort each list (using heapsort (o(N log N)) from GSL)
    10921047    DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
    1093     PermMap = new size_t[getAtomCount()];
    1094     OtherPermMap = new size_t[getAtomCount()];
    1095     for(int i=0;i<getAtomCount();i++) {
     1048    PermMap = new size_t[AtomCount];
     1049    OtherPermMap = new size_t[AtomCount];
     1050    for(int i=0;i<AtomCount;i++) {
    10961051      PermMap[i] = 0;
    10971052      OtherPermMap[i] = 0;
    10981053    }
    1099     gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
    1100     gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
    1101     PermutationMap = new int[getAtomCount()];
    1102     for(int i=0;i<getAtomCount();i++)
     1054    gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
     1055    gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
     1056    PermutationMap = new int[AtomCount];
     1057    for(int i=0;i<AtomCount;i++)
    11031058      PermutationMap[i] = 0;
    11041059    DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
    1105     for(int i=getAtomCount();i--;)
     1060    for(int i=AtomCount;i--;)
    11061061      PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
    11071062
    … …  
    11091064    DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
    11101065    flag = 0;
    1111     for (int i=0;i<getAtomCount();i++) {
     1066    for (int i=0;i<AtomCount;i++) {
    11121067      DoLog(5) && (Log() << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl);
    11131068      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
    … …  
    11451100int * molecule::GetFatherSonAtomicMap(molecule *OtherMolecule)
    11461101{
     1102  atom *Walker = NULL, *OtherWalker = NULL;
    11471103  DoLog(3) && (Log() << Verbose(3) << "Begin of GetFatherAtomicMap." << endl);
    1148   int *AtomicMap = new int[getAtomCount()];
    1149   for (int i=getAtomCount();i--;)
     1104  int *AtomicMap = new int[AtomCount];
     1105  for (int i=AtomCount;i--;)
    11501106    AtomicMap[i] = -1;
    11511107  if (OtherMolecule == this) {  // same molecule
    1152     for (int i=getAtomCount();i--;) // no need as -1 means already that there is trivial correspondence
     1108    for (int i=AtomCount;i--;) // no need as -1 means already that there is trivial correspondence
    11531109      AtomicMap[i] = i;
    11541110    DoLog(4) && (Log() << Verbose(4) << "Map is trivial." << endl);
    11551111  } else {
    11561112    DoLog(4) && (Log() << Verbose(4) << "Map is ");
    1157     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    1158       if ((*iter)->father == NULL) {
    1159         AtomicMap[(*iter)->nr] = -2;
     1113    Walker = start;
     1114    while (Walker->next != end) {
     1115      Walker = Walker->next;
     1116      if (Walker->father == NULL) {
     1117        AtomicMap[Walker->nr] = -2;
    11601118      } else {
    1161         for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
     1119        OtherWalker = OtherMolecule->start;
     1120        while (OtherWalker->next != OtherMolecule->end) {
     1121          OtherWalker = OtherWalker->next;
    11621122      //for (int i=0;i<AtomCount;i++) { // search atom
    1163         //for (int j=0;j<OtherMolecule->getAtomCount();j++) {
    1164           //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
    1165           if ((*iter)->father == (*runner))
    1166             AtomicMap[(*iter)->nr] = (*runner)->nr;
     1123        //for (int j=0;j<OtherMolecule->AtomCount;j++) {
     1124          //Log() << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
     1125          if (Walker->father == OtherWalker)
     1126            AtomicMap[Walker->nr] = OtherWalker->nr;
    11671127        }
    11681128      }
    1169       DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->nr] << "\t");
     1129      DoLog(0) && (Log() << Verbose(0) << AtomicMap[Walker->nr] << "\t");
    11701130    }
    11711131    DoLog(0) && (Log() << Verbose(0) << endl);
    … …  
    12011161void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
    12021162{
    1203   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    1204     array[((*iter)->*index)] = (*iter);
     1163  atom *Walker = start;
     1164  while (Walker->next != end) {
     1165    Walker = Walker->next;
     1166    array[(Walker->*index)] = Walker;
    12051167  }
    12061168};

  • src/molecule.hpp

    r1024cb r42af9e  
    3434#include "tesselation.hpp"
    3535#include "Patterns/Observer.hpp"
    36 #include "Patterns/ObservedIterator.hpp"
    3736#include "Patterns/Cacheable.hpp"
    3837
    … …  
    9190  friend molecule *NewMolecule();
    9291  friend void DeleteMolecule(molecule *);
    93 
    9492  public:
    95     typedef std::set<atom*> atomSet;
    96     typedef ObservedIterator<atomSet> iterator;
    97     typedef atomSet::const_iterator const_iterator;
    98 
    9993    const periodentafel * const elemente; //!< periodic table with each element
    100     // old deprecated atom handling
    101     //atom *start;        //!< start of atom list
    102     //atom *end;          //!< end of atom list
     94    atom *start;        //!< start of atom list
     95    atom *end;          //!< end of atom list
    10396    bond *first;        //!< start of bond list
    10497    bond *last;         //!< end of bond list
    10598    int MDSteps;        //!< The number of MD steps in Trajectories
    106     //int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
     99    int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
    107100    int BondCount;          //!< number of atoms, brought up-to-date by CountBonds()
    108101    int ElementCount;       //!< how many unique elements are therein
    … …  
    119112  private:
    120113    Cacheable<string> formula;
    121     Cacheable<int>    AtomCount;
    122114    moleculeId_t id;
    123     atomSet atoms; //<!set of atoms
    124115  protected:
    125     //void CountAtoms();
    126     /**
    127      * this iterator type should be used for internal variables, \
    128      * since it will not lock
    129      */
    130     typedef atomSet::iterator internal_iterator;
    131 
    132 
    133116    molecule(const periodentafel * const teil);
    134117    virtual ~molecule();
    … …  
    138121  //getter and setter
    139122  const std::string getName();
    140   int getAtomCount() const;
    141   int doCountAtoms();
    142123  moleculeId_t getId();
    143124  void setId(moleculeId_t);
    … …  
    146127  std::string calcFormula();
    147128
    148   iterator begin();
    149   const_iterator begin() const;
    150   iterator end();
    151   const_iterator end() const;
    152   bool empty() const;
    153   size_t size() const;
    154   const_iterator erase( const_iterator loc );
    155   const_iterator erase( atom *& key );
    156   const_iterator find (  atom *& key ) const;
    157   pair<iterator,bool> insert ( atom * const key );
    158 
    159129
    160130  // re-definition of virtual functions from PointCloud
    … …  
    162132  Vector *GetCenter() const ;
    163133  TesselPoint *GetPoint() const ;
     134  TesselPoint *GetTerminalPoint() const ;
    164135  int GetMaxId() const;
    165136  void GoToNext() const ;
     137  void GoToPrevious() const ;
    166138  void GoToFirst() const ;
     139  void GoToLast() const ;
    167140  bool IsEmpty() const ;
    168141  bool IsEnd() const ;
    … …  
    259232
    260233  /// Count and change present atoms' coordination.
     234  void CountAtoms();
    261235  void CountElements();
    262236  void CalculateOrbitals(class config &configuration);
    … …  
    328302  bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
    329303  bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
    330   bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
    331304  void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
    332305  /// -# BOSSANOVA
    … …  
    357330  private:
    358331  int last_atom;      //!< number given to last atom
    359   mutable internal_iterator InternalPointer;  //!< internal pointer for PointCloud
     332  mutable atom *InternalPointer;  //!< internal pointer for PointCloud
    360333};
    361334

  • src/molecule_dynamics.cpp

    r1024cb r42af9e  
    2929  gsl_matrix *A = gsl_matrix_alloc(NDIM,NDIM);
    3030  gsl_vector *x = gsl_vector_alloc(NDIM);
     31  atom * Runner = mol->start;
    3132  atom *Sprinter = NULL;
    3233  Vector trajectory1, trajectory2, normal, TestVector;
    3334  double Norm1, Norm2, tmp, result = 0.;
    3435
    35   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    36     if ((*iter) == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
     36  while (Runner->next != mol->end) {
     37    Runner = Runner->next;
     38    if (Runner == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
    3739      break;
    3840    // determine normalized trajectories direction vector (n1, n2)
    … …  
    4143    trajectory1.Normalize();
    4244    Norm1 = trajectory1.Norm();
    43     Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
    44     trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
     45    Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
     46    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
    4547    trajectory2.Normalize();
    4648    Norm2 = trajectory1.Norm();
    4749    // check whether either is zero()
    4850    if ((Norm1 < MYEPSILON) && (Norm2 < MYEPSILON)) {
    49       tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
     51      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
    5052    } else if (Norm1 < MYEPSILON) {
    5153      Sprinter = Params.PermutationMap[Walker->nr];   // find first target point
    52       trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
     54      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
    5355      trajectory2 *= trajectory1.ScalarProduct(trajectory2); // trajectory2 is scaled to unity, hence we don't need to divide by anything
    5456      trajectory1 -= trajectory2;   // project the part in norm direction away
    5557      tmp = trajectory1.Norm();  // remaining norm is distance
    5658    } else if (Norm2 < MYEPSILON) {
    57       Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
     59      Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
    5860      trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Walker->Trajectory.R.at(Params.startstep);  // copy second offset
    5961      trajectory1 *= trajectory2.ScalarProduct(trajectory1); // trajectory1 is scaled to unity, hence we don't need to divide by anything
    … …  
    6567  //        Log() << Verbose(0) << " and ";
    6668  //        Log() << Verbose(0) << trajectory2;
    67       tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
     69      tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
    6870  //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
    6971    } else { // determine distance by finding minimum distance
    70   //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *(*iter) << " are linear independent ";
     72  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
    7173  //        Log() << Verbose(0) << endl;
    7274  //        Log() << Verbose(0) << "First Trajectory: ";
    … …  
    8486        gsl_matrix_set(A, 1, i, trajectory2[i]);
    8587        gsl_matrix_set(A, 2, i, normal[i]);
    86         gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - (*iter)->Trajectory.R.at(Params.startstep)[i]));
     88        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - Runner->Trajectory.R.at(Params.startstep)[i]));
    8789      }
    8890      // solve the linear system by Householder transformations
    … …  
    9597      trajectory2.Scale(gsl_vector_get(x,1));
    9698      normal.Scale(gsl_vector_get(x,2));
    97       TestVector = (*iter)->Trajectory.R.at(Params.startstep) + trajectory2 + normal
     99      TestVector = Runner->Trajectory.R.at(Params.startstep) + trajectory2 + normal
    98100                   - (Walker->Trajectory.R.at(Params.startstep) + trajectory1);
    99101      if (TestVector.Norm() < MYEPSILON) {
    … …  
    124126{
    125127  double result = 0.;
    126   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    127     if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[(*iter)->nr]) && (Walker->nr < (*iter)->nr)) {
     128  atom * Runner = mol->start;
     129  while (Runner->next != mol->end) {
     130    Runner = Runner->next;
     131    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
    128132  //    atom *Sprinter = PermutationMap[Walker->nr];
    129   //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
     133  //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
    130134  //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
    131135  //        Log() << Verbose(0) << ", penalting." << endl;
    … …  
    158162  // go through every atom
    159163  atom *Runner = NULL;
    160   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     164  atom *Walker = start;
     165  while (Walker->next != end) {
     166    Walker = Walker->next;
    161167    // first term: distance to target
    162     Runner = Params.PermutationMap[(*iter)->nr];   // find target point
    163     tmp = ((*iter)->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
     168    Runner = Params.PermutationMap[Walker->nr];   // find target point
     169    tmp = (Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
    164170    tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
    165171    result += Params.PenaltyConstants[0] * tmp;
    … …  
    167173
    168174    // second term: sum of distances to other trajectories
    169     result += SumDistanceOfTrajectories((*iter), this, Params);
     175    result += SumDistanceOfTrajectories(Walker, this, Params);
    170176
    171177    // third term: penalty for equal targets
    172     result += PenalizeEqualTargets((*iter), this, Params);
     178    result += PenalizeEqualTargets(Walker, this, Params);
    173179  }
    174180
    … …  
    210216void FillDistanceList(molecule *mol, struct EvaluatePotential &Params)
    211217{
    212   for (int i=mol->getAtomCount(); i--;) {
     218  for (int i=mol->AtomCount; i--;) {
    213219    Params.DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
    214220    Params.DistanceList[i]->clear();
    215221  }
    216222
    217   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    218     for (molecule::const_iterator runner = mol->begin(); runner != mol->end(); ++runner) {
    219       Params.DistanceList[(*iter)->nr]->insert( DistancePair((*iter)->Trajectory.R.at(Params.startstep).distance((*runner)->Trajectory.R.at(Params.endstep)), (*runner)) );
     223  atom *Runner = NULL;
     224  atom *Walker = mol->start;
     225  while (Walker->next != mol->end) {
     226    Walker = Walker->next;
     227    Runner = mol->start;
     228    while(Runner->next != mol->end) {
     229      Runner = Runner->next;
     230      Params.DistanceList[Walker->nr]->insert( DistancePair(Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)), Runner) );
    220231    }
    221232  }
    … …  
    229240void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
    230241{
    231   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    232     Params.StepList[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // stores the step to the next iterator that could be a possible next target
    233     Params.PermutationMap[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin()->second;   // always pick target with the smallest distance
    234     Params.DoubleList[Params.DistanceList[(*iter)->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
    235     Params.DistanceIterators[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // and remember which one we picked
    236     DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->nr]->begin()->first << "." << endl);
     242  atom *Walker = mol->start;
     243  while (Walker->next != mol->end) {
     244    Walker = Walker->next;
     245    Params.StepList[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // stores the step to the next iterator that could be a possible next target
     246    Params.PermutationMap[Walker->nr] = Params.DistanceList[Walker->nr]->begin()->second;   // always pick target with the smallest distance
     247    Params.DoubleList[Params.DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
     248    Params.DistanceIterators[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // and remember which one we picked
     249    DoLog(2) && (Log() << Verbose(2) << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl);
    237250  }
    238251};
    … …  
    275288void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
    276289{
    277   molecule::const_iterator iter = mol->begin();
     290  atom *Walker = mol->start;
    278291  DistanceMap::iterator NewBase;
    279292  double Potential = fabs(mol->ConstrainedPotential(Params));
    280293
    281   if (mol->empty()) {
    282     eLog() << Verbose(1) << "Molecule is empty." << endl;
    283     return;
    284   }
    285294  while ((Potential) > Params.PenaltyConstants[2]) {
    286     PrintPermutationMap(mol->getAtomCount(), Params);
    287     iter++;
    288     if (iter == mol->end()) // round-robin at the end
    289       iter = mol->begin();
    290     if (Params.DoubleList[Params.DistanceIterators[(*iter)->nr]->second->nr] <= 1)  // no need to make those injective that aren't
     295    PrintPermutationMap(mol->AtomCount, Params);
     296    Walker = Walker->next;
     297    if (Walker == mol->end) // round-robin at the end
     298      Walker = mol->start->next;
     299    if (Params.DoubleList[Params.DistanceIterators[Walker->nr]->second->nr] <= 1)  // no need to make those injective that aren't
    291300      continue;
    292301    // now, try finding a new one
    293     Potential = TryNextNearestNeighbourForInjectivePermutation(mol, (*iter), Potential, Params);
    294   }
    295   for (int i=mol->getAtomCount(); i--;) // now each single entry in the DoubleList should be <=1
     302    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
     303  }
     304  for (int i=mol->AtomCount; i--;) // now each single entry in the DoubleList should be <=1
    296305    if (Params.DoubleList[i] > 1) {
    297306      DoeLog(0) && (eLog()<< Verbose(0) << "Failed to create an injective PermutationMap!" << endl);
    … …  
    332341  double Potential, OldPotential, OlderPotential;
    333342  struct EvaluatePotential Params;
    334   Params.PermutationMap = new atom *[getAtomCount()];
    335   Params.DistanceList = new DistanceMap *[getAtomCount()];
    336   Params.DistanceIterators = new DistanceMap::iterator[getAtomCount()];
    337   Params.DoubleList = new int[getAtomCount()];
    338   Params.StepList = new DistanceMap::iterator[getAtomCount()];
     343  Params.PermutationMap = new atom *[AtomCount];
     344  Params.DistanceList = new DistanceMap *[AtomCount];
     345  Params.DistanceIterators = new DistanceMap::iterator[AtomCount];
     346  Params.DoubleList = new int[AtomCount];
     347  Params.StepList = new DistanceMap::iterator[AtomCount];
    339348  int round;
    340   atom *Sprinter = NULL;
     349  atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
    341350  DistanceMap::iterator Rider, Strider;
    342351
    343352  // set to zero
    344   for (int i=0;i<getAtomCount();i++) {
     353  for (int i=0;i<AtomCount;i++) {
    345354    Params.PermutationMap[i] = NULL;
    346355    Params.DoubleList[i] = 0;
    … …  
    371380    DoLog(2) && (Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl);
    372381    OlderPotential = OldPotential;
    373     molecule::const_iterator iter;
    374382    do {
    375       iter = begin();
    376       for (; iter != end(); ++iter) {
    377         PrintPermutationMap(getAtomCount(), Params);
    378         Sprinter = Params.DistanceIterators[(*iter)->nr]->second;   // store initial partner
    379         Strider = Params.DistanceIterators[(*iter)->nr];  //remember old iterator
    380         Params.DistanceIterators[(*iter)->nr] = Params.StepList[(*iter)->nr];
    381         if (Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->end()) {// stop, before we run through the list and still on
    382           Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->begin();
     383      Walker = start;
     384      while (Walker->next != end) { // pick one
     385        Walker = Walker->next;
     386        PrintPermutationMap(AtomCount, Params);
     387        Sprinter = Params.DistanceIterators[Walker->nr]->second;   // store initial partner
     388        Strider = Params.DistanceIterators[Walker->nr];  //remember old iterator
     389        Params.DistanceIterators[Walker->nr] = Params.StepList[Walker->nr];
     390        if (Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->end()) {// stop, before we run through the list and still on
     391          Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->begin();
    383392          break;
    384393        }
    385         //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->nr]->second << "." << endl;
     394        //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
    386395        // find source of the new target
    387         molecule::const_iterator runner = begin();
    388         for (; runner != end(); ++runner) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
    389           if (Params.PermutationMap[(*runner)->nr] == Params.DistanceIterators[(*iter)->nr]->second) {
    390             //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->nr] << "." << endl;
     396        Runner = start->next;
     397        while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
     398          if (Params.PermutationMap[Runner->nr] == Params.DistanceIterators[Walker->nr]->second) {
     399            //Log() << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
    391400            break;
    392401          }
     402          Runner = Runner->next;
    393403        }
    394         if (runner != end()) { // we found the other source
     404        if (Runner != end) { // we found the other source
    395405          // then look in its distance list for Sprinter
    396           Rider = Params.DistanceList[(*runner)->nr]->begin();
    397           for (; Rider != Params.DistanceList[(*runner)->nr]->end(); Rider++)
     406          Rider = Params.DistanceList[Runner->nr]->begin();
     407          for (; Rider != Params.DistanceList[Runner->nr]->end(); Rider++)
    398408            if (Rider->second == Sprinter)
    399409              break;
    400           if (Rider != Params.DistanceList[(*runner)->nr]->end()) { // if we have found one
    401             //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->nr] << "/" << *Rider->second << "." << endl;
     410          if (Rider != Params.DistanceList[Runner->nr]->end()) { // if we have found one
     411            //Log() << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
    402412            // exchange both
    403             Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // put next farther distance into PermutationMap
    404             Params.PermutationMap[(*runner)->nr] = Sprinter;  // and hand the old target to its respective owner
    405             PrintPermutationMap(getAtomCount(), Params);
     413            Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
     414            Params.PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
     415            PrintPermutationMap(AtomCount, Params);
    406416            // calculate the new potential
    407417            //Log() << Verbose(2) << "Checking new potential ..." << endl;
    … …  
    409419            if (Potential > OldPotential) { // we made everything worse! Undo ...
    410420              //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
    411               //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->nr]->second << "." << endl;
     421              //Log() << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
    412422              // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
    413               Params.PermutationMap[(*runner)->nr] = Params.DistanceIterators[(*runner)->nr]->second;
     423              Params.PermutationMap[Runner->nr] = Params.DistanceIterators[Runner->nr]->second;
    414424              // Undo for Walker
    415               Params.DistanceIterators[(*iter)->nr] = Strider;  // take next farther distance target
    416               //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->nr]->second << "." << endl;
    417               Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second;
     425              Params.DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
     426              //Log() << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
     427              Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
    418428            } else {
    419               Params.DistanceIterators[(*runner)->nr] = Rider;  // if successful also move the pointer in the iterator list
     429              Params.DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
    420430              DoLog(3) && (Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl);
    421431              OldPotential = Potential;
    … …  
    427437            //Log() << Verbose(0) << endl;
    428438          } else {
    429             DoeLog(1) && (eLog()<< Verbose(1) << **runner << " was not the owner of " << *Sprinter << "!" << endl);
     439            DoeLog(1) && (eLog()<< Verbose(1) << *Runner << " was not the owner of " << *Sprinter << "!" << endl);
    430440            exit(255);
    431441          }
    432442        } else {
    433           Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // new target has no source!
     443          Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // new target has no source!
    434444        }
    435         Params.StepList[(*iter)->nr]++; // take next farther distance target
     445        Params.StepList[Walker->nr]++; // take next farther distance target
    436446      }
    437     } while (++iter != end());
     447    } while (Walker->next != end);
    438448  } while ((OlderPotential - OldPotential) > 1e-3);
    439449  DoLog(1) && (Log() << Verbose(1) << "done." << endl);
    … …  
    441451
    442452  /// free memory and return with evaluated potential
    443   for (int i=getAtomCount(); i--;)
     453  for (int i=AtomCount; i--;)
    444454    Params.DistanceList[i]->clear();
    445455  delete[](Params.DistanceList);
    … …  
    482492  // Get the Permutation Map by MinimiseConstrainedPotential
    483493  atom **PermutationMap = NULL;
    484   atom *Sprinter = NULL;
     494  atom *Walker = NULL, *Sprinter = NULL;
    485495  if (!MapByIdentity)
    486496    MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
    487497  else {
    488     PermutationMap = new atom *[getAtomCount()];
     498    PermutationMap = new atom *[AtomCount];
    489499    SetIndexedArrayForEachAtomTo( PermutationMap, &atom::nr );
    490500  }
    … …  
    501511    mol = World::getInstance().createMolecule();
    502512    MoleculePerStep->insert(mol);
    503     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     513    Walker = start;
     514    while (Walker->next != end) {
     515      Walker = Walker->next;
    504516      // add to molecule list
    505       Sprinter = mol->AddCopyAtom((*iter));
     517      Sprinter = mol->AddCopyAtom(Walker);
    506518      for (int n=NDIM;n--;) {
    507         Sprinter->x[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
     519        Sprinter->x[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
    508520        // add to Trajectories
    509521        //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
    510522        if (step < MaxSteps) {
    511           (*iter)->Trajectory.R.at(step)[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
    512           (*iter)->Trajectory.U.at(step)[n] = 0.;
    513           (*iter)->Trajectory.F.at(step)[n] = 0.;
     523          Walker->Trajectory.R.at(step)[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
     524          Walker->Trajectory.U.at(step)[n] = 0.;
     525          Walker->Trajectory.F.at(step)[n] = 0.;
    514526        }
    515527      }
    … …  
    519531
    520532  // store the list to single step files
    521   int *SortIndex = new int[getAtomCount()];
    522   for (int i=getAtomCount(); i--; )
     533  int *SortIndex = new int[AtomCount];
     534  for (int i=AtomCount; i--; )
    523535    SortIndex[i] = i;
    524536  status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
    … …  
    566578      return false;
    567579    }
    568     if (Force.RowCounter[0] != getAtomCount()) {
    569       DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << getAtomCount() << "." << endl);
     580    if (Force.RowCounter[0] != AtomCount) {
     581      DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl);
    570582      performCriticalExit();
    571583      return false;
    … …  
    573585    // correct Forces
    574586    Velocity.Zero();
    575     for(int i=0;i<getAtomCount();i++)
     587    for(int i=0;i<AtomCount;i++)
    576588      for(int d=0;d<NDIM;d++) {
    577589        Velocity[d] += Force.Matrix[0][i][d+5];
    578590      }
    579     for(int i=0;i<getAtomCount();i++)
     591    for(int i=0;i<AtomCount;i++)
    580592      for(int d=0;d<NDIM;d++) {
    581         Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
     593        Force.Matrix[0][i][d+5] -= Velocity[d]/(double)AtomCount;
    582594      }
    583595    // solve a constrained potential if we are meant to
    … …  
    682694      delta_alpha = 0.;
    683695      ActOnAllAtoms( &atom::Thermostat_NoseHoover_init, MDSteps, &delta_alpha );
    684       delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
     696      delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
    685697      configuration.alpha += delta_alpha*configuration.Deltat;
    686698      DoLog(3) && (Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl);

  • src/molecule_fragmentation.cpp

    r1024cb r42af9e  
    3939  int FragmentCount;
    4040  // get maximum bond degree
    41   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    42     c = ((*iter)->ListOfBonds.size() > c) ? (*iter)->ListOfBonds.size() : c;
     41  atom *Walker = start;
     42  while (Walker->next != end) {
     43    Walker = Walker->next;
     44    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
    4345  }
    4446  FragmentCount = NoNonHydrogen*(1 << (c*order));
    … …  
    351353map<double, pair<int,int> >  * ReMapAdaptiveCriteriaListToValue(map<int, pair<double,int> > *AdaptiveCriteriaList, molecule *mol)
    352354{
    353   atom *Walker = NULL;
     355  atom *Walker = mol->start;
    354356  map<double, pair<int,int> > *FinalRootCandidates = new map<double, pair<int,int> > ;
    355357  DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
    … …  
    383385bool MarkUpdateCandidates(bool *AtomMask, map<double, pair<int,int> > &FinalRootCandidates, int Order, molecule *mol)
    384386{
    385   atom *Walker = NULL;
     387  atom *Walker = mol->start;
    386388  int No = -1;
    387389  bool status = false;
    … …  
    427429bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
    428430{
     431  atom *Walker = start;
    429432  bool status = false;
    430433
    431434  // initialize mask list
    432   for(int i=getAtomCount();i--;)
     435  for(int i=AtomCount;i--;)
    433436    AtomMask[i] = false;
    434437
    435438  if (Order < 0) { // adaptive increase of BondOrder per site
    436     if (AtomMask[getAtomCount()] == true)  // break after one step
     439    if (AtomMask[AtomCount] == true)  // break after one step
    437440      return false;
    438441
    … …  
    448451    if (AdaptiveCriteriaList->empty()) {
    449452      DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
    450       for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     453      while (Walker->next != end) {
     454        Walker = Walker->next;
    451455    #ifdef ADDHYDROGEN
    452         if ((*iter)->type->Z != 1) // skip hydrogen
     456        if (Walker->type->Z != 1) // skip hydrogen
    453457    #endif
    454458        {
    455           AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
     459          AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
    456460          status = true;
    457461        }
    … …  
    468472    delete[](FinalRootCandidates);
    469473  } else { // global increase of Bond Order
    470     for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     474    while (Walker->next != end) {
     475      Walker = Walker->next;
    471476  #ifdef ADDHYDROGEN
    472       if ((*iter)->type->Z != 1) // skip hydrogen
     477      if (Walker->type->Z != 1) // skip hydrogen
    473478  #endif
    474479      {
    475         AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
    476         if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->nr]))
     480        AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
     481        if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
    477482          status = true;
    478483      }
    479484    }
    480     if ((!Order) && (!AtomMask[getAtomCount()]))  // single stepping, just check
     485    if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
    481486      status = true;
    482487
    … …  
    489494  }
    490495
    491   PrintAtomMask(AtomMask, getAtomCount()); // for debugging
     496  PrintAtomMask(AtomMask, AtomCount); // for debugging
    492497
    493498  return status;
    … …  
    505510    return false;
    506511  }
    507   SortIndex = new int[getAtomCount()];
    508   for(int i=getAtomCount();i--;)
     512  SortIndex = new int[AtomCount];
     513  for(int i=AtomCount;i--;)
    509514    SortIndex[i] = -1;
    510515
    … …  
    513518
    514519  return true;
    515 };
    516 
    517 
    518 
    519 /** Creates a lookup table for true father's Atom::Nr -> atom ptr.
    520  * \param *start begin of list (STL iterator, i.e. first item)
    521  * \paran *end end of list (STL iterator, i.e. one past last item)
    522  * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
    523  * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
    524  * \return true - success, false - failure
    525  */
    526 bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
    527 {
    528   bool status = true;
    529   int AtomNo;
    530 
    531   if (LookupTable != NULL) {
    532     Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
    533     return false;
    534   }
    535 
    536   // count them
    537   if (count == 0) {
    538     for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
    539       count = (count < (*iter)->GetTrueFather()->nr) ? (*iter)->GetTrueFather()->nr : count;
    540     }
    541   }
    542   if (count <= 0) {
    543     Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl;
    544     return false;
    545   }
    546 
    547   // allocate and fill
    548   LookupTable = new atom *[count];
    549   if (LookupTable == NULL) {
    550     eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
    551     performCriticalExit();
    552     status = false;
    553   } else {
    554     for (int i=0;i<count;i++)
    555       LookupTable[i] = NULL;
    556     for (molecule::iterator iter = begin(); iter != end(); ++iter) {
    557       AtomNo = (*iter)->GetTrueFather()->nr;
    558       if ((AtomNo >= 0) && (AtomNo < count)) {
    559         //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
    560         LookupTable[AtomNo] = (*iter);
    561       } else {
    562         Log() << Verbose(0) << "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << ")." << endl;
    563         status = false;
    564         break;
    565       }
    566     }
    567   }
    568 
    569   return status;
    570520};
    571521
    … …  
    591541{
    592542  MoleculeListClass *BondFragments = NULL;
    593   int *MinimumRingSize = new int[getAtomCount()];
     543  int *MinimumRingSize = new int[AtomCount];
    594544  int FragmentCounter;
    595545  MoleculeLeafClass *MolecularWalker = NULL;
    … …  
    619569
    620570  // create lookup table for Atom::nr
    621   FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(ListOfAtoms, getAtomCount());
     571  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(start, end, ListOfAtoms, AtomCount);
    622572
    623573  // === compare it with adjacency file ===
    … …  
    629579
    630580  // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
    631   for(int i=getAtomCount();i--;)
    632     MinimumRingSize[i] = getAtomCount();
     581  for(int i=AtomCount;i--;)
     582    MinimumRingSize[i] = AtomCount;
    633583  MolecularWalker = Subgraphs;
    634584  FragmentCounter = 0;
    … …  
    636586    MolecularWalker = MolecularWalker->next;
    637587    // fill the bond structure of the individually stored subgraphs
    638     MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
     588  MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
    639589    DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
    640590    LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
    641591//    // check the list of local atoms for debugging
    642592//    Log() << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
    643 //    for (int i=0;i<getAtomCount();i++)
     593//    for (int i=0;i<AtomCount;i++)
    644594//      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
    645595//        Log() << Verbose(0) << "\tNULL";
    … …  
    667617  // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
    668618  KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
    669   AtomMask = new bool[getAtomCount()+1];
    670   AtomMask[getAtomCount()] = false;
     619  AtomMask = new bool[AtomCount+1];
     620  AtomMask[AtomCount] = false;
    671621  FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
    672622  while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
    673623    FragmentationToDo = FragmentationToDo || CheckOrder;
    674     AtomMask[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
     624    AtomMask[AtomCount] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
    675625    // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
    676626    Subgraphs->next->FillRootStackForSubgraphs(RootStack, AtomMask, (FragmentCounter = 0));
    … …  
    812762bool molecule::ParseOrderAtSiteFromFile(char *path)
    813763{
    814   unsigned char *OrderArray = new unsigned char[getAtomCount()];
    815   bool *MaxArray = new bool[getAtomCount()];
     764  unsigned char *OrderArray = new unsigned char[AtomCount];
     765  bool *MaxArray = new bool[AtomCount];
    816766  bool status;
    817767  int AtomNr, value;
    … …  
    819769  ifstream file;
    820770
    821   for(int i=0;i<getAtomCount();i++) {
     771  for(int i=0;i<AtomCount;i++) {
    822772    OrderArray[i] = 0;
    823773    MaxArray[i] = false;
    … …  
    921871  atom *OtherFather = NULL;
    922872  atom *FatherOfRunner = NULL;
    923 
    924 #ifdef ADDHYDROGEN
    925   molecule::const_iterator runner;
    926 #endif
    927   // we increment the iter just before skipping the hydrogen
    928   for (molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end();) {
     873  Leaf->CountAtoms();
     874
     875  atom *Runner = Leaf->start;
     876  while (Runner->next != Leaf->end) {
     877    Runner = Runner->next;
    929878    LonelyFlag = true;
    930     FatherOfRunner = (*iter)->father;
    931     ASSERT(FatherOfRunner,"Atom without father found");
     879    FatherOfRunner = Runner->father;
    932880    if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
    933881      // create all bonds
    … …  
    940888//            Log() << Verbose(3) << "Adding Bond: ";
    941889//            Log() << Verbose(0) <<
    942             Leaf->AddBond((*iter), SonList[OtherFather->nr], (*BondRunner)->BondDegree);
     890            Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
    943891//            Log() << Verbose(0) << "." << endl;
    944             //NumBonds[(*iter)->nr]++;
     892            //NumBonds[Runner->nr]++;
    945893          } else {
    946894//            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
    … …  
    950898//          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
    951899#ifdef ADDHYDROGEN
    952           //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
    953           if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
     900          //Log() << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
     901          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
    954902            exit(1);
    955903#endif
    956           //NumBonds[(*iter)->nr] += Binder->BondDegree;
     904          //NumBonds[Runner->nr] += Binder->BondDegree;
    957905        }
    958906      }
    959907    } else {
    960     DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
    961     }
    962     if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
    963       DoLog(0) && (Log() << Verbose(0) << **iter << "has got bonds only to hydrogens!" << endl);
    964     }
    965     ++iter;
     908      DoeLog(1) && (eLog()<< Verbose(1) << "Son " << Runner->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
     909    }
     910    if ((LonelyFlag) && (Leaf->AtomCount > 1)) {
     911      DoLog(0) && (Log() << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl);
     912    }
    966913#ifdef ADDHYDROGEN
    967     while ((iter != Leaf->end()) && ((*iter)->type->Z == 1)){ // skip added hydrogen
    968       iter++;
    969     }
     914    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
     915      Runner = Runner->next;
    970916#endif
    971917  }
    … …  
    982928molecule * molecule::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
    983929{
    984   atom **SonList = new atom*[getAtomCount()];
     930  atom **SonList = new atom*[AtomCount];
    985931  molecule *Leaf = World::getInstance().createMolecule();
    986932
    987   for(int i=0;i<getAtomCount();i++)
     933  for(int i=0;i<AtomCount;i++)
    988934    SonList[i] = NULL;
    989935
    … …  
    16151561  FragmentSearch.FragmentSet = new KeySet;
    16161562  FragmentSearch.Root = FindAtom(RootKeyNr);
    1617   FragmentSearch.ShortestPathList = new int[getAtomCount()];
    1618   for (int i=getAtomCount();i--;) {
     1563  FragmentSearch.ShortestPathList = new int[AtomCount];
     1564  for (int i=AtomCount;i--;) {
    16191565    FragmentSearch.ShortestPathList[i] = -1;
    16201566  }
    16211567
    16221568  // Construct the complete KeySet which we need for topmost level only (but for all Roots)
     1569  atom *Walker = start;
    16231570  KeySet CompleteMolecule;
    1624   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    1625     CompleteMolecule.insert((*iter)->GetTrueFather()->nr);
     1571  while (Walker->next != end) {
     1572    Walker = Walker->next;
     1573    CompleteMolecule.insert(Walker->GetTrueFather()->nr);
    16261574  }
    16271575
    … …  
    16341582    RootKeyNr = RootStack.front();
    16351583    RootStack.pop_front();
    1636     atom *Walker = FindAtom(RootKeyNr);
     1584    Walker = FindAtom(RootKeyNr);
    16371585    // check cyclic lengths
    16381586    //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
    … …  
    17231671  Vector Translationvector;
    17241672  //class StackClass<atom *> *CompStack = NULL;
    1725   class StackClass<atom *> *AtomStack = new StackClass<atom *>(getAtomCount());
     1673  class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
    17261674  bool flag = true;
    17271675
    17281676  DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
    17291677
    1730   ColorList = new enum Shading[getAtomCount()];
    1731   for (int i=0;i<getAtomCount();i++)
     1678  ColorList = new enum Shading[AtomCount];
     1679  for (int i=0;i<AtomCount;i++)
    17321680    ColorList[i] = (enum Shading)0;
    17331681  while (flag) {
    17341682    // remove bonds that are beyond bonddistance
    1735     Translationvector.Zero();
     1683    for(int i=NDIM;i--;)
     1684      Translationvector[i] = 0.;
    17361685    // scan all bonds
    17371686    Binder = first;
    … …  
    17621711      Log() << Verbose(0) << Translationvector <<  endl;
    17631712      // apply to all atoms of first component via BFS
    1764       for (int i=getAtomCount();i--;)
     1713      for (int i=AtomCount;i--;)
    17651714        ColorList[i] = white;
    17661715      AtomStack->Push(Binder->leftatom);
    … …  
    17861735    //delete(CompStack);
    17871736  }
     1737
    17881738  // free allocated space from ReturnFullMatrixforSymmetric()
    17891739  delete(AtomStack);

  • src/molecule_geometry.cpp

    r1024cb r42af9e  
    7171
    7272//  Log() << Verbose(3) << "Begin of CenterEdge." << endl;
    73   molecule::const_iterator iter = begin();  // start at first in list
    74   if (iter != end()) { //list not empty?
     73  atom *ptr = start->next;  // start at first in list
     74  if (ptr != end) {  //list not empty?
    7575    for (int i=NDIM;i--;) {
    76       max->at(i) = (*iter)->x[i];
    77       min->at(i) = (*iter)->x[i];
    78     }
    79     for (; iter != end(); ++iter) {// continue with second if present
    80       //(*iter)->Output(1,1,out);
     76      max->at(i) = ptr->x[i];
     77      min->at(i) = ptr->x[i];
     78    }
     79    while (ptr->next != end) {  // continue with second if present
     80      ptr = ptr->next;
     81      //ptr->Output(1,1,out);
    8182      for (int i=NDIM;i--;) {
    82         max->at(i) = (max->at(i) < (*iter)->x[i]) ? (*iter)->x[i] : max->at(i);
    83         min->at(i) = (min->at(i) > (*iter)->x[i]) ? (*iter)->x[i] : min->at(i);
     83        max->at(i) = (max->at(i) < ptr->x[i]) ? ptr->x[i] : max->at(i);
     84        min->at(i) = (min->at(i) > ptr->x[i]) ? ptr->x[i] : min->at(i);
    8485      }
    8586    }
    … …  
    105106{
    106107  int Num = 0;
    107   molecule::const_iterator iter = begin();  // start at first in list
     108  atom *ptr = start;  // start at first in list
    108109
    109110  Center.Zero();
    110111
    111   if (iter != end()) {   //list not empty?
    112     for (; iter != end(); ++iter) {  // continue with second if present
     112  if (ptr->next != end) {   //list not empty?
     113    while (ptr->next != end) {
     114      ptr = ptr->next;
    113115      Num++;
    114       Center += (*iter)->x;
     116      Center += ptr->x;
    115117    }
    116118    Center.Scale(-1./Num); // divide through total number (and sign for direction)
    … …  
    125127Vector * molecule::DetermineCenterOfAll() const
    126128{
    127   molecule::const_iterator iter = begin();  // start at first in list
     129  atom *ptr = start;  // start at first in list
    128130  Vector *a = new Vector();
    129131  double Num = 0;
    … …  
    131133  a->Zero();
    132134
    133   if (iter != end()) {   //list not empty?
    134     for (; iter != end(); ++iter) {  // continue with second if present
     135  if (ptr->next != end) {   //list not empty?
     136    while (ptr->next != end) {
     137      ptr = ptr->next;
    135138      Num += 1.;
    136       (*a) += (*iter)->x;
     139      (*a) += ptr->x;
    137140    }
    138141    a->Scale(1./Num); // divide through total mass (and sign for direction)
    … …  
    162165Vector * molecule::DetermineCenterOfGravity()
    163166{
    164   molecule::const_iterator iter = begin();  // start at first in list
     167  atom *ptr = start->next;  // start at first in list
    165168  Vector *a = new Vector();
    166169  Vector tmp;
    … …  
    169172  a->Zero();
    170173
    171   if (iter != end()) {   //list not empty?
    172     for (; iter != end(); ++iter) {  // continue with second if present
    173       Num += (*iter)->type->mass;
    174       tmp = (*iter)->type->mass * (*iter)->x;
     174  if (ptr != end) {   //list not empty?
     175    while (ptr->next != end) {  // continue with second if present
     176      ptr = ptr->next;
     177      Num += ptr->type->mass;
     178      tmp = ptr->type->mass * ptr->x;
    175179      (*a) += tmp;
    176180    }
    … …  
    213217void molecule::Scale(const double ** const factor)
    214218{
    215   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     219  atom *ptr = start;
     220
     221  while (ptr->next != end) {
     222    ptr = ptr->next;
    216223    for (int j=0;j<MDSteps;j++)
    217       (*iter)->Trajectory.R.at(j).ScaleAll(*factor);
    218     (*iter)->x.ScaleAll(*factor);
     224      ptr->Trajectory.R.at(j).ScaleAll(*factor);
     225    ptr->x.ScaleAll(*factor);
    219226  }
    220227};
    … …  
    225232void molecule::Translate(const Vector *trans)
    226233{
    227   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     234  atom *ptr = start;
     235
     236  while (ptr->next != end) {
     237    ptr = ptr->next;
    228238    for (int j=0;j<MDSteps;j++)
    229       (*iter)->Trajectory.R.at(j) += (*trans);
    230     (*iter)->x += (*trans);
     239      ptr->Trajectory.R.at(j) += (*trans);
     240    ptr->x += (*trans);
    231241  }
    232242};
    … …  
    264274void molecule::DeterminePeriodicCenter(Vector &center)
    265275{
     276  atom *Walker = start;
    266277  double * const cell_size = World::getInstance().getDomain();
    267278  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
    … …  
    274285    Center.Zero();
    275286    flag = true;
    276     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     287    while (Walker->next != end) {
     288      Walker = Walker->next;
    277289#ifdef ADDHYDROGEN
    278       if ((*iter)->type->Z != 1) {
     290      if (Walker->type->Z != 1) {
    279291#endif
    280         Testvector = (*iter)->x;
     292        Testvector = Walker->x;
    281293        Testvector.MatrixMultiplication(inversematrix);
    282294        Translationvector.Zero();
    283         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
    284          if ((*iter)->nr < (*Runner)->GetOtherAtom((*iter))->nr) // otherwise we shift one to, the other fro and gain nothing
     295        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
     296         if (Walker->nr < (*Runner)->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
    285297            for (int j=0;j<NDIM;j++) {
    286               tmp = (*iter)->x[j] - (*Runner)->GetOtherAtom(*iter)->x[j];
     298              tmp = Walker->x[j] - (*Runner)->GetOtherAtom(Walker)->x[j];
    287299              if ((fabs(tmp)) > BondDistance) {
    288300                flag = false;
    289                 DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << (*iter)->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
     301                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << Walker->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
    290302                if (tmp > 0)
    291303                  Translationvector[j] -= 1.;
    … …  
    301313#ifdef ADDHYDROGEN
    302314        // now also change all hydrogens
    303         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
    304           if ((*Runner)->GetOtherAtom((*iter))->type->Z == 1) {
    305             Testvector = (*Runner)->GetOtherAtom((*iter))->x;
     315        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
     316          if ((*Runner)->GetOtherAtom(Walker)->type->Z == 1) {
     317            Testvector = (*Runner)->GetOtherAtom(Walker)->x;
    306318            Testvector.MatrixMultiplication(inversematrix);
    307319            Testvector += Translationvector;
    … …  
    318330  delete[](inversematrix);
    319331
    320   Center.Scale(1./static_cast<double>(getAtomCount()));
     332  Center.Scale(1./(double)AtomCount);
    321333};
    322334
    … …  
    328340void molecule::PrincipalAxisSystem(bool DoRotate)
    329341{
     342  atom *ptr = start;  // start at first in list
    330343  double InertiaTensor[NDIM*NDIM];
    331344  Vector *CenterOfGravity = DetermineCenterOfGravity();
    … …  
    338351
    339352  // sum up inertia tensor
    340   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    341     Vector x = (*iter)->x;
     353  while (ptr->next != end) {
     354    ptr = ptr->next;
     355    Vector x = ptr->x;
    342356    //x.SubtractVector(CenterOfGravity);
    343     InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
    344     InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
    345     InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
    346     InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
    347     InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
    348     InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
    349     InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
    350     InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
    351     InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
     357    InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
     358    InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
     359    InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
     360    InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
     361    InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
     362    InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
     363    InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
     364    InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
     365    InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
    352366  }
    353367  // print InertiaTensor for debugging
    … …  
    387401
    388402    // sum up inertia tensor
    389     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    390       Vector x = (*iter)->x;
    391       InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
    392       InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
    393       InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
    394       InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
    395       InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
    396       InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
    397       InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
    398       InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
    399       InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
     403    ptr = start;
     404    while (ptr->next != end) {
     405      ptr = ptr->next;
     406      Vector x = ptr->x;
     407      //x.SubtractVector(CenterOfGravity);
     408      InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
     409      InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
     410      InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
     411      InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
     412      InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
     413      InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
     414      InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
     415      InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
     416      InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
    400417    }
    401418    // print InertiaTensor for debugging
    … …  
    421438void molecule::Align(Vector *n)
    422439{
     440  atom *ptr = start;
    423441  double alpha, tmp;
    424442  Vector z_axis;
    … …  
    431449  alpha = atan(-n->at(0)/n->at(2));
    432450  DoLog(1) && (Log() << Verbose(1) << "Z-X-angle: " << alpha << " ... ");
    433   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    434     tmp = (*iter)->x[0];
    435     (*iter)->x[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
    436     (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     451  while (ptr->next != end) {
     452    ptr = ptr->next;
     453    tmp = ptr->x[0];
     454    ptr->x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
     455    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
    437456    for (int j=0;j<MDSteps;j++) {
    438       tmp = (*iter)->Trajectory.R.at(j)[0];
    439       (*iter)->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
    440       (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
     457      tmp = ptr->Trajectory.R.at(j)[0];
     458      ptr->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
     459      ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
    441460    }
    442461  }
    … …  
    448467
    449468  // rotate on z-y plane
     469  ptr = start;
    450470  alpha = atan(-n->at(1)/n->at(2));
    451471  DoLog(1) && (Log() << Verbose(1) << "Z-Y-angle: " << alpha << " ... ");
    452   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    453     tmp = (*iter)->x[1];
    454     (*iter)->x[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
    455     (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     472  while (ptr->next != end) {
     473    ptr = ptr->next;
     474    tmp = ptr->x[1];
     475    ptr->x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
     476    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
    456477    for (int j=0;j<MDSteps;j++) {
    457       tmp = (*iter)->Trajectory.R.at(j)[1];
    458       (*iter)->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
    459       (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
     478      tmp = ptr->Trajectory.R.at(j)[1];
     479      ptr->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
     480      ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
    460481    }
    461482  }
    … …  
    481502  Vector a,b,c,d;
    482503  struct lsq_params *par = (struct lsq_params *)params;
     504  atom *ptr = par->mol->start;
    483505
    484506  // initialize vectors
    … …  
    490512  b[2] = gsl_vector_get(x,5);
    491513  // go through all atoms
    492   for (molecule::const_iterator iter = par->mol->begin(); iter != par->mol->end(); ++iter) {
    493     if ((*iter)->type == ((struct lsq_params *)params)->type) { // for specific type
    494       c = (*iter)->x - a;
     514  while (ptr != par->mol->end) {
     515    ptr = ptr->next;
     516    if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
     517      c = ptr->x - a;
    495518      t = c.ScalarProduct(b);           // get direction parameter
    496519      d = t*b;       // and create vector

  • src/molecule_graph.cpp

    r1024cb r42af9e  
    2020#include "World.hpp"
    2121#include "Helpers/fast_functions.hpp"
    22 #include "Helpers/Assert.hpp"
    23 
    2422
    2523struct BFSAccounting
    … …  
    8280      flip(atom1, atom2);
    8381    Walker = FindAtom(atom1);
    84     ASSERT(Walker,"Could not find an atom with the ID given in dbond file");
    8582    OtherWalker = FindAtom(atom2);
    86     ASSERT(OtherWalker,"Could not find an atom with the ID given in dbond file");
    8783    AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
    8884  }
    … …  
    113109  atom *Walker = NULL;
    114110  atom *OtherWalker = NULL;
     111  atom **AtomMap = NULL;
    115112  int n[NDIM];
    116113  double MinDistance, MaxDistance;
    … …  
    137134
    138135  // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
    139   DoLog(1) && (Log() << Verbose(1) << "AtomCount " << getAtomCount() << " and bonddistance is " << bonddistance << "." << endl);
    140 
    141   if ((getAtomCount() > 1) && (bonddistance > 1.)) {
     136  CountAtoms();
     137  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl);
     138
     139  if ((AtomCount > 1) && (bonddistance > 1.)) {
    142140    DoLog(2) && (Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl);
    143141    LC = new LinkedCell(this, bonddistance);
    … …  
    145143    // create a list to map Tesselpoint::nr to atom *
    146144    DoLog(2) && (Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl);
    147 
    148     // set numbers for atoms that can later be used
    149     int i=0;
    150     for(internal_iterator iter = atoms.begin();iter!= atoms.end(); ++iter){
    151       (*iter)->nr = i++;
     145    AtomMap = new atom *[AtomCount];
     146    for (int i=0;i<AtomCount;i++)
     147      AtomMap[i] = NULL;
     148    Walker = start;
     149    while (Walker->next != end) {
     150      Walker = Walker->next;
     151      AtomMap[Walker->nr] = Walker;
    152152    }
    153153
    … …  
    161161          if (List != NULL) {
    162162            for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
    163               Walker = dynamic_cast<atom*>(*Runner);
    164               ASSERT(Walker,"Tesselpoint that was not an atom retrieved from LinkedNode");
    165               //Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
     163              Walker = AtomMap[(*Runner)->nr];
     164//              Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
    166165              // 3c. check for possible bond between each atom in this and every one in the 27 cells
    167166              for (n[0] = -1; n[0] <= 1; n[0]++)
    … …  
    173172                      for (LinkedCell::LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
    174173                        if ((*OtherRunner)->nr > Walker->nr) {
    175                           OtherWalker = dynamic_cast<atom*>(*OtherRunner);
    176                           ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
    177                           //Log() << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
     174                          OtherWalker = AtomMap[(*OtherRunner)->nr];
     175//                          Log() << Verbose(0) << "Current other Atom is " << *OtherWalker << "." << endl;
     176                          const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x, cell_size);
     177//                          Log() << Verbose(1) << "Checking distance " << distance << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
    178178                          (BG->*minmaxdistance)(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
    179                           const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x,cell_size);
    180179                          const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
    181180//                          Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
    … …  
    197196          }
    198197        }
     198    delete[](AtomMap);
    199199    delete (LC);
    200200    DoLog(1) && (Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl);
    … …  
    207207    ActOnAllAtoms( &atom::OutputBondOfAtom );
    208208  } else
    209     DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << getAtomCount() << ", thus no bonds, no connections!." << endl);
     209    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl);
    210210  DoLog(0) && (Log() << Verbose(0) << "End of CreateAdjacencyList." << endl);
    211211  if (free_BG)
    … …  
    249249    DoLog(0) && (Log() << Verbose(0) << " done." << endl);
    250250  } else {
    251     DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << getAtomCount() << " atoms." << endl);
     251    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl);
    252252  }
    253253  DoLog(0) && (Log() << Verbose(0) << No << " bonds could not be corrected." << endl);
    … …  
    469469void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
    470470{
    471   DFS.AtomStack = new StackClass<atom *> (mol->getAtomCount());
     471  DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
    472472  DFS.CurrentGraphNr = 0;
    473473  DFS.ComponentNumber = 0;
    … …  
    510510  bond *Binder = NULL;
    511511
    512   if (getAtomCount() == 0)
     512  if (AtomCount == 0)
    513513    return SubGraphs;
    514514  DoLog(0) && (Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl);
    515515  DepthFirstSearchAnalysis_Init(DFS, this);
    516516
    517   for (molecule::const_iterator iter = begin(); iter != end();) {
    518     DFS.Root = *iter;
     517  DFS.Root = start->next;
     518  while (DFS.Root != end) { // if there any atoms at all
    519519    // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
    520520    DFS.AtomStack->ClearStack();
    … …  
    556556
    557557    // step on to next root
    558     while ((iter != end()) && ((*iter)->GraphNr != -1)) {
    559       //Log() << Verbose(1) << "Current next subgraph root candidate is " << (*iter)->Name << "." << endl;
    560       if ((*iter)->GraphNr != -1) // if already discovered, step on
    561         iter++;
     558    while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
     559      //Log() << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
     560      if (DFS.Root->GraphNr != -1) // if already discovered, step on
     561        DFS.Root = DFS.Root->next;
    562562    }
    563563  }
    … …  
    864864  if (MinRingSize != -1) { // if rings are present
    865865    // go over all atoms
    866     for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    867       Root = *iter;
    868 
    869       if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
     866    Root = mol->start;
     867    while (Root->next != mol->end) {
     868      Root = Root->next;
     869
     870      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
    870871        Walker = Root;
    871872
    872873        //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
    873         CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->getAtomCount());
     874        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
    874875
    875876      }
    … …  
    901902  int MinRingSize = -1;
    902903
    903   InitializeBFSAccounting(BFS, getAtomCount());
     904  InitializeBFSAccounting(BFS, AtomCount);
    904905
    905906  //Log() << Verbose(1) << "Back edge list - ";
    … …  
    11441145    CurrentBondsOfAtom = -1; // we count one too far due to line end
    11451146    // parse into structure
    1146     if ((AtomNr >= 0) && (AtomNr < getAtomCount())) {
     1147    if ((AtomNr >= 0) && (AtomNr < AtomCount)) {
    11471148      Walker = ListOfAtoms[AtomNr];
    11481149      while (!line.eof())
    … …  
    13231324    AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
    13241325
    1325   BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
     1326  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
    13261327
    13271328  // and go on ... Queue always contains all lightgray vertices
    … …  
    13811382  // fill parent list with sons
    13821383  DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
    1383   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1384     ParentList[(*iter)->father->nr] = (*iter);
     1384  atom *Walker = mol->start;
     1385  while (Walker->next != mol->end) {
     1386    Walker = Walker->next;
     1387    ParentList[Walker->father->nr] = Walker;
    13851388    // Outputting List for debugging
    1386     DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->nr] << "." << endl);
    1387   }
    1388 };
     1389    DoLog(4) && (Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl);
     1390  }
     1391
     1392}
     1393;
    13891394
    13901395void BuildInducedSubgraph_Finalize(atom **&ParentList)
    … …  
    13971402{
    13981403  bool status = true;
     1404  atom *Walker = NULL;
    13991405  atom *OtherAtom = NULL;
    14001406  // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
    14011407  DoLog(3) && (Log() << Verbose(3) << "Creating bonds." << endl);
    1402   for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
    1403     if (ParentList[(*iter)->nr] != NULL) {
    1404       if (ParentList[(*iter)->nr]->father != (*iter)) {
     1408  Walker = Father->start;
     1409  while (Walker->next != Father->end) {
     1410    Walker = Walker->next;
     1411    if (ParentList[Walker->nr] != NULL) {
     1412      if (ParentList[Walker->nr]->father != Walker) {
    14051413        status = false;
    14061414      } else {
    1407         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
    1408           OtherAtom = (*Runner)->GetOtherAtom((*iter));
     1415        for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
     1416          OtherAtom = (*Runner)->GetOtherAtom(Walker);
    14091417          if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
    1410             DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
    1411             mol->AddBond(ParentList[(*iter)->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
     1418            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
     1419            mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
    14121420          }
    14131421        }
    … …  
    14321440  bool status = true;
    14331441  atom **ParentList = NULL;
     1442
    14341443  DoLog(2) && (Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl);
    1435   BuildInducedSubgraph_Init(ParentList, Father->getAtomCount());
     1444  BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
    14361445  BuildInducedSubgraph_FillParentList(this, Father, ParentList);
    14371446  status = BuildInducedSubgraph_CreateBondsFromParent(this, Father, ParentList);

  • src/molecule_pointcloud.cpp

    r1024cb r42af9e  
    88#include "atom.hpp"
    99#include "config.hpp"
    10 #include "info.hpp"
    1110#include "memoryallocator.hpp"
    1211#include "molecule.hpp"
    … …  
    3231};
    3332
    34 
    35 /** PointCloud implementation of GoPoint
    36  * Uses atoms and STL stuff.
     33/** Return current atom in the list.
     34 * \return pointer to atom or NULL if none present
    3735 */
    38 TesselPoint* molecule::GetPoint() const
     36TesselPoint *molecule::GetPoint() const
    3937{
    40   Info FunctionInfo(__func__);
    41   return (*InternalPointer);
     38  if ((InternalPointer != start) && (InternalPointer != end))
     39    return InternalPointer;
     40  else
     41    return NULL;
    4242};
    4343
    44 /** PointCloud implementation of GoToNext.
    45  * Uses atoms and STL stuff.
     44/** Return pointer to one after last atom in the list.
     45 * \return pointer to end marker
     46 */
     47TesselPoint *molecule::GetTerminalPoint() const
     48{
     49  return end;
     50};
     51
     52/** Return the greatest index of all atoms in the list.
     53 * \return greatest index
     54 */
     55int molecule::GetMaxId() const
     56{
     57  return last_atom;
     58};
     59
     60/** Go to next atom.
     61 * Stops at last one.
    4662 */
    4763void molecule::GoToNext() const
    4864{
    49   Info FunctionInfo(__func__);
    50   if (InternalPointer != atoms.end())
    51     InternalPointer++;
     65  if (InternalPointer != end)
     66    InternalPointer = InternalPointer->next;
    5267};
    5368
    54 /** PointCloud implementation of GoToFirst.
    55  * Uses atoms and STL stuff.
     69/** Go to previous atom.
     70 * Stops at first one.
     71 */
     72void molecule::GoToPrevious() const
     73{
     74  if (InternalPointer->previous != start)
     75    InternalPointer = InternalPointer->previous;
     76};
     77
     78/** Goes to first atom.
    5679 */
    5780void molecule::GoToFirst() const
    5881{
    59   Info FunctionInfo(__func__);
    60   InternalPointer = atoms.begin();
     82  InternalPointer = start->next;
    6183};
    6284
    63 /** PointCloud implementation of IsEmpty.
    64  * Uses atoms and STL stuff.
     85/** Goes to last atom.
     86 */
     87void molecule::GoToLast() const
     88{
     89  InternalPointer = end->previous;
     90};
     91
     92/** Checks whether we have any atoms in molecule.
     93 * \return true - no atoms, false - not empty
    6594 */
    6695bool molecule::IsEmpty() const
    6796{
    68   Info FunctionInfo(__func__);
    69   return (empty());
     97  return (start->next == end);
    7098};
    7199
    72 /** PointCloud implementation of IsLast.
    73  * Uses atoms and STL stuff.
     100/** Checks whether we are at the last atom
     101 * \return true - current atom is last one, false - is not last one
    74102 */
    75103bool molecule::IsEnd() const
    76104{
    77   Info FunctionInfo(__func__);
    78   return (InternalPointer == atoms.end());
     105  return (InternalPointer == end);
    79106};
    80 
    81 int molecule::GetMaxId() const {
    82   return getAtomCount();
    83 }

  • src/molecule_template.hpp

    r1024cb r42af9e  
    2424template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
    2525    {
    26   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    27     (((*iter)->node)->*f)();
     26  atom *Walker = start;
     27  while (Walker->next != end) {
     28    Walker = Walker->next;
     29    ((Walker->node)->*f)();
    2830  }
    2931};
    3032template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
    3133    {
    32   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    33     (((*iter)->node)->*f)();
     34  atom *Walker = start;
     35  while (Walker->next != end) {
     36    Walker = Walker->next;
     37    ((Walker->node)->*f)();
    3438  }
    3539};
    … …  
    3741template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
    3842{
    39   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    40     (((*iter)->node)->*f)(t);
     43  atom *Walker = start;
     44  while (Walker->next != end) {
     45    Walker = Walker->next;
     46    ((Walker->node)->*f)(t);
    4147  }
    4248};
    4349template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
    4450{
    45   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    46     (((*iter)->node)->*f)(t);
     51  atom *Walker = start;
     52  while (Walker->next != end) {
     53    Walker = Walker->next;
     54    ((Walker->node)->*f)(t);
    4755  }
    4856};
    4957template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&), T &t ) const
    5058{
    51   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    52     (((*iter)->node)->*f)(t);
     59  atom *Walker = start;
     60  while (Walker->next != end) {
     61    Walker = Walker->next;
     62    ((Walker->node)->*f)(t);
    5363  }
    5464};
    5565template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const
    5666{
    57   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    58     (((*iter)->node)->*f)(t);
     67  atom *Walker = start;
     68  while (Walker->next != end) {
     69    Walker = Walker->next;
     70    ((Walker->node)->*f)(t);
    5971  }
    6072};
    … …  
    6274template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
    6375{
    64   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    65     (((*iter)->node)->*f)(t, u);
     76  atom *Walker = start;
     77  while (Walker->next != end) {
     78    Walker = Walker->next;
     79    ((Walker->node)->*f)(t, u);
    6680  }
    6781};
    6882template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
    6983{
    70   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    71     (((*iter)->node)->*f)(t, u);
     84  atom *Walker = start;
     85  while (Walker->next != end) {
     86    Walker = Walker->next;
     87    ((Walker->node)->*f)(t, u);
    7288  }
    7389};
    … …  
    7591template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
    7692{
    77   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    78     (((*iter)->node)->*f)(t, u, v);
     93  atom *Walker = start;
     94  while (Walker->next != end) {
     95    Walker = Walker->next;
     96    ((Walker->node)->*f)(t, u, v);
    7997  }
    8098};
    8199template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
    82100{
    83   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    84     (((*iter)->node)->*f)(t, u, v);
     101  atom *Walker = start;
     102  while (Walker->next != end) {
     103    Walker = Walker->next;
     104    ((Walker->node)->*f)(t, u, v);
    85105  }
    86106};
    … …  
    92112{
    93113  res result = 0;
    94   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    95     result += ((*iter)->*f)();
     114  atom *Walker = start;
     115  while (Walker->next != end) {
     116    Walker = Walker->next;
     117    result += (Walker->*f)();
    96118  }
    97119  return result;
    … …  
    100122{
    101123  res result = 0;
    102   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    103     result += ((*iter)->*f)();
     124  atom *Walker = start;
     125  while (Walker->next != end) {
     126    Walker = Walker->next;
     127    result += (Walker->*f)();
    104128  }
    105129  return result;
    … …  
    109133{
    110134  res result = 0;
    111   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    112     result += ((*iter)->*f)(t);
     135  atom *Walker = start;
     136  while (Walker->next != end) {
     137    Walker = Walker->next;
     138    result += (Walker->*f)(t);
    113139  }
    114140  return result;
    … …  
    117143{
    118144  res result = 0;
    119   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    120     result += ((*iter)->*f)(t);
     145  atom *Walker = start;
     146  while (Walker->next != end) {
     147    Walker = Walker->next;
     148    result += (Walker->*f)(t);
    121149  }
    122150  return result;
    … …  
    129157template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
    130158{
    131   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    132     (*f)((*iter));
     159  atom *Walker = start;
     160  while (Walker->next != end) {
     161    Walker = Walker->next;
     162    (*f)(Walker);
    133163  }
    134164};
    135165template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
    136166{
    137   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    138     (*f)((*iter));
     167  atom *Walker = start;
     168  while (Walker->next != end) {
     169    Walker = Walker->next;
     170    (*f)(Walker);
    139171  }
    140172};
    … …  
    145177template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
    146178{
    147   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    148     (copy->*f)((*iter));
     179  atom *Walker = start;
     180  while (Walker->next != end) {
     181    Walker = Walker->next;
     182    (copy->*f)(Walker);
    149183  }
    150184};
    151185template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
    152186{
    153   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    154     (copy->*f)((*iter));
     187  atom *Walker = start;
     188  while (Walker->next != end) {
     189    Walker = Walker->next;
     190    (copy->*f)(Walker);
    155191  }
    156192};
    … …  
    161197template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
    162198{
    163   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    164     if (((*iter)->*condition)())
    165       (copy->*f)((*iter));
     199  atom *Walker = start;
     200  while (Walker->next != end) {
     201    Walker = Walker->next;
     202    if ((Walker->*condition)())
     203      (copy->*f)(Walker);
    166204  }
    167205};
    168206template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
    169207{
    170   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    171     if (((*iter)->*condition)())
    172       (copy->*f)((*iter));
     208  atom *Walker = start;
     209  while (Walker->next != end) {
     210    Walker = Walker->next;
     211    if ((Walker->*condition)())
     212      (copy->*f)(Walker);
    173213  }
    174214};
    175215template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
    176216{
    177   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    178     if (((*iter)->*condition)())
    179       (copy->*f)((*iter));
     217  atom *Walker = start;
     218  while (Walker->next != end) {
     219    Walker = Walker->next;
     220    if ((Walker->*condition)())
     221      (copy->*f)(Walker);
    180222  }
    181223};
    182224template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
    183225{
    184   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    185     if (((*iter)->*condition)())
    186       (copy->*f)((*iter));
     226  atom *Walker = start;
     227  while (Walker->next != end) {
     228    Walker = Walker->next;
     229    if ((Walker->*condition)())
     230      (copy->*f)(Walker);
    187231  }
    188232};
    … …  
    190234template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
    191235{
    192   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    193     if (((*iter)->*condition)(t))
    194       (copy->*f)((*iter));
     236  atom *Walker = start;
     237  while (Walker->next != end) {
     238    Walker = Walker->next;
     239    if ((Walker->*condition)(t))
     240      (copy->*f)(Walker);
    195241  }
    196242};
    197243template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
    198244{
    199   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    200     if (((*iter)->*condition)(t))
    201       (copy->*f)((*iter));
     245  atom *Walker = start;
     246  while (Walker->next != end) {
     247    Walker = Walker->next;
     248    if ((Walker->*condition)(t))
     249      (copy->*f)(Walker);
    202250  }
    203251};
    204252template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
    205253{
    206   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    207     if (((*iter)->*condition)(t))
    208       (copy->*f)((*iter));
     254  atom *Walker = start;
     255  while (Walker->next != end) {
     256    Walker = Walker->next;
     257    if ((Walker->*condition)(t))
     258      (copy->*f)(Walker);
    209259  }
    210260};
    211261template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
    212262{
    213   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    214     if (((*iter)->*condition)(t))
    215       (copy->*f)((*iter));
     263  atom *Walker = start;
     264  while (Walker->next != end) {
     265    Walker = Walker->next;
     266    if ((Walker->*condition)(t))
     267      (copy->*f)(Walker);
    216268  }
    217269};
    … …  
    219271template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
    220272{
    221   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    222     if (((*iter)->*condition)(t,u))
    223       (copy->*f)((*iter));
     273  atom *Walker = start;
     274  while (Walker->next != end) {
     275    Walker = Walker->next;
     276    if ((Walker->*condition)(t,u))
     277      (copy->*f)(Walker);
    224278  }
    225279};
    226280template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
    227281{
    228   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    229     if (((*iter)->*condition)(t,u))
    230       (copy->*f)((*iter));
     282  atom *Walker = start;
     283  while (Walker->next != end) {
     284    Walker = Walker->next;
     285    if ((Walker->*condition)(t,u))
     286      (copy->*f)(Walker);
    231287  }
    232288};
    233289template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
    234290{
    235   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    236     if (((*iter)->*condition)(t,u))
    237       (copy->*f)((*iter));
     291  atom *Walker = start;
     292  while (Walker->next != end) {
     293    Walker = Walker->next;
     294    if ((Walker->*condition)(t,u))
     295      (copy->*f)(Walker);
    238296  }
    239297};
    240298template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
    241299{
    242   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    243     if (((*iter)->*condition)(t,u))
    244       (copy->*f)((*iter));
     300  atom *Walker = start;
     301  while (Walker->next != end) {
     302    Walker = Walker->next;
     303    if ((Walker->*condition)(t,u))
     304      (copy->*f)(Walker);
    245305  }
    246306};
    … …  
    248308template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
    249309{
    250   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    251     if (((*iter)->*condition)(t,u,v))
    252       (copy->*f)((*iter));
     310  atom *Walker = start;
     311  while (Walker->next != end) {
     312    Walker = Walker->next;
     313    if ((Walker->*condition)(t,u,v))
     314      (copy->*f)(Walker);
    253315  }
    254316};
    255317template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
    256318{
    257   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    258     if (((*iter)->*condition)(t,u,v))
    259       (copy->*f)((*iter));
     319  atom *Walker = start;
     320  while (Walker->next != end) {
     321    Walker = Walker->next;
     322    if ((Walker->*condition)(t,u,v))
     323      (copy->*f)(Walker);
    260324  }
    261325};
    262326template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
    263327{
    264   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    265     if (((*iter)->*condition)(t,u,v))
    266       (copy->*f)((*iter));
     328  atom *Walker = start;
     329  while (Walker->next != end) {
     330    Walker = Walker->next;
     331    if ((Walker->*condition)(t,u,v))
     332      (copy->*f)(Walker);
    267333  }
    268334};
    269335template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
    270336{
    271   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    272     if (((*iter)->*condition)(t,u,v))
    273       (copy->*f)((*iter));
     337  atom *Walker = start;
     338  while (Walker->next != end) {
     339    Walker = Walker->next;
     340    if ((Walker->*condition)(t,u,v))
     341      (copy->*f)(Walker);
    274342  }
    275343};
    … …  
    280348template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
    281349{
    282   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    283     ((*iter)->*f)();
     350  atom *Walker = start;
     351  while (Walker->next != end) {
     352    Walker = Walker->next;
     353    (Walker->*f)();
    284354  }
    285355};
    286356template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
    287357{
    288   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    289     ((*iter)->*f)();
     358  atom *Walker = start;
     359  while (Walker->next != end) {
     360    Walker = Walker->next;
     361    (Walker->*f)();
    290362  }
    291363};
    … …  
    293365template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
    294366{
    295   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    296     ((*iter)->*f)(t);
     367  atom *Walker = start;
     368  while (Walker->next != end) {
     369    Walker = Walker->next;
     370    (Walker->*f)(t);
    297371  }
    298372};
    299373template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
    300374{
    301   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    302     ((*iter)->*f)(t);
     375  atom *Walker = start;
     376  while (Walker->next != end) {
     377    Walker = Walker->next;
     378    (Walker->*f)(t);
    303379  }
    304380};
    … …  
    306382template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
    307383{
    308   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    309     ((*iter)->*f)(t, u);
     384  atom *Walker = start;
     385  while (Walker->next != end) {
     386    Walker = Walker->next;
     387    (Walker->*f)(t, u);
    310388  }
    311389};
    312390template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
    313391{
    314   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    315     ((*iter)->*f)(t, u);
     392  atom *Walker = start;
     393  while (Walker->next != end) {
     394    Walker = Walker->next;
     395    (Walker->*f)(t, u);
    316396  }
    317397};
    … …  
    319399template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
    320400{
    321   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    322     ((*iter)->*f)(t, u, v);
     401  atom *Walker = start;
     402  while (Walker->next != end) {
     403    Walker = Walker->next;
     404    (Walker->*f)(t, u, v);
    323405  }
    324406};
    325407template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
    326408{
    327   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    328     ((*iter)->*f)(t, u, v);
     409  atom *Walker = start;
     410  while (Walker->next != end) {
     411    Walker = Walker->next;
     412    (Walker->*f)(t, u, v);
    329413  }
    330414};
    … …  
    332416template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
    333417{
    334   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    335     ((*iter)->*f)(t, u, v, w);
     418  atom *Walker = start;
     419  while (Walker->next != end) {
     420    Walker = Walker->next;
     421    (Walker->*f)(t, u, v, w);
    336422  }
    337423};
    338424template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
    339425{
    340   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    341     ((*iter)->*f)(t, u, v, w);
     426  atom *Walker = start;
     427  while (Walker->next != end) {
     428    Walker = Walker->next;
     429    (Walker->*f)(t, u, v, w);
    342430  }
    343431};
    … …  
    348436template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
    349437{
     438  atom *Walker = start;
    350439  int inc = 1;
    351   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    352     (*Setor) (&array[((*iter)->*index)], &inc);
     440  while (Walker->next != end) {
     441    Walker = Walker->next;
     442    (*Setor) (&array[(Walker->*index)], &inc);
    353443  }
    354444};
    355445template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
    356446{
    357   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    358     (*Setor) (&array[((*iter)->*index)], &value);
     447  atom *Walker = start;
     448  while (Walker->next != end) {
     449    Walker = Walker->next;
     450    (*Setor) (&array[(Walker->*index)], &value);
    359451  }
    360452};
    361453template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
    362454{
    363   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    364     (*Setor) (&array[((*iter)->*index)], value);
     455  atom *Walker = start;
     456  while (Walker->next != end) {
     457    Walker = Walker->next;
     458    (*Setor) (&array[(Walker->*index)], value);
    365459  }
    366460};
    … …  
    368462template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
    369463{
     464  atom *Walker = start;
    370465  int inc = 1;
    371   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    372     (*Setor) (&array[((*iter)->type->*index)], &inc);
     466  while (Walker->next != end) {
     467    Walker = Walker->next;
     468    (*Setor) (&array[(Walker->type->*index)], &inc);
    373469  }
    374470};
    375471template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
    376472{
    377   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    378     (*Setor) (&array[((*iter)->type->*index)], &value);
     473  atom *Walker = start;
     474  while (Walker->next != end) {
     475    Walker = Walker->next;
     476    (*Setor) (&array[(Walker->type->*index)], &value);
    379477  }
    380478};
    381479template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
    382480{
    383   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    384     (*Setor) (&array[((*iter)->type->*index)], value);
     481  atom *Walker = start;
     482  while (Walker->next != end) {
     483    Walker = Walker->next;
     484    (*Setor) (&array[(Walker->type->*index)], value);
    385485  }
    386486};
    … …  
    388488template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
    389489{
    390   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    391     array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
     490  atom *Walker = start;
     491  while (Walker->next != end) {
     492    Walker = Walker->next;
     493    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
    392494  }
    393495};
    394496template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
    395497{
    396   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    397     array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
     498  atom *Walker = start;
     499  while (Walker->next != end) {
     500    Walker = Walker->next;
     501    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
    398502  }
    399503};
    400504template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
    401505{
    402   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    403     array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
     506  atom *Walker = start;
     507  while (Walker->next != end) {
     508    Walker = Walker->next;
     509    array[(Walker->*index)] = (Walker->*Setor) (vect);
    404510  }
    405511};
    406512template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
    407513{
    408   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    409     array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
     514  atom *Walker = start;
     515  while (Walker->next != end) {
     516    Walker = Walker->next;
     517    array[(Walker->*index)] = (Walker->*Setor) (vect);
    410518  }
    411519};
    412520template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
    413521{
    414   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    415     (*iter)->*value = array[((*iter)->*index)];
    416     //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
     522  atom *Walker = start;
     523  while (Walker->next != end) {
     524    Walker = Walker->next;
     525    Walker->*value = array[(Walker->*index)];
     526    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
    417527  }
    418528};
    … …  
    420530template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
    421531{
    422   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    423     (*iter)->*ptr = value;
    424     //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
     532  atom *Walker = start;
     533  while (Walker->next != end) {
     534    Walker = Walker->next;
     535    Walker->*ptr = value;
     536    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
    425537  }
    426538};

  • src/moleculelist.cpp

    r1024cb r42af9e  
    2020#include "memoryallocator.hpp"
    2121#include "periodentafel.hpp"
    22 #include "Helpers/Assert.hpp"
     22#include "World.hpp"
    2323
    2424#include "Helpers/Assert.hpp"
    … …  
    7171  int Count, Counter, aCounter, bCounter;
    7272  int flag;
     73  atom *aWalker = NULL;
     74  atom *bWalker = NULL;
    7375
    7476  // sort each atom list and put the numbers into a list, then go through
    7577  //Log() << Verbose(0) << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
    76   // Yes those types are awkward... but check it for yourself it checks out this way
    77   molecule *const *mol1_ptr= static_cast<molecule *const *>(a);
    78   molecule *mol1 = *mol1_ptr;
    79   molecule *const *mol2_ptr= static_cast<molecule *const *>(b);
    80   molecule *mol2 = *mol2_ptr;
    81   if (mol1->getAtomCount() < mol2->getAtomCount()) {
     78  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
    8279    return -1;
    8380  } else {
    84     if (mol1->getAtomCount() > mol2->getAtomCount())
     81    if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
    8582      return +1;
    8683    else {
    87       Count = mol1->getAtomCount();
     84      Count = (**(molecule **) a).AtomCount;
    8885      aList = new int[Count];
    8986      bList = new int[Count];
    9087
    9188      // fill the lists
     89      aWalker = (**(molecule **) a).start;
     90      bWalker = (**(molecule **) b).start;
    9291      Counter = 0;
    9392      aCounter = 0;
    9493      bCounter = 0;
    95       molecule::const_iterator aiter = mol1->begin();
    96       molecule::const_iterator biter = mol2->begin();
    97       for (;(aiter != mol1->end()) && (biter != mol2->end());
    98           ++aiter, ++biter) {
    99         if ((*aiter)->GetTrueFather() == NULL)
     94      while ((aWalker->next != (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
     95        aWalker = aWalker->next;
     96        bWalker = bWalker->next;
     97        if (aWalker->GetTrueFather() == NULL)
    10098          aList[Counter] = Count + (aCounter++);
    10199        else
    102           aList[Counter] = (*aiter)->GetTrueFather()->nr;
    103         if ((*biter)->GetTrueFather() == NULL)
     100          aList[Counter] = aWalker->GetTrueFather()->nr;
     101        if (bWalker->GetTrueFather() == NULL)
    104102          bList[Counter] = Count + (bCounter++);
    105103        else
    106           bList[Counter] = (*biter)->GetTrueFather()->nr;
     104          bList[Counter] = bWalker->GetTrueFather()->nr;
    107105        Counter++;
    108106      }
    109107      // check if AtomCount was for real
    110108      flag = 0;
    111       if ((aiter == mol1->end()) && (biter != mol2->end())) {
     109      if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
    112110        flag = -1;
    113111      } else {
    114         if ((aiter != mol1->end()) && (biter == mol2->end()))
     112        if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
    115113          flag = 1;
    116114      }
    … …  
    146144void MoleculeListClass::Enumerate(ostream *out)
    147145{
     146  atom *Walker = NULL;
    148147  periodentafel *periode = World::getInstance().getPeriode();
    149148  std::map<atomicNumber_t,unsigned int> counts;
    … …  
    161160      // count atoms per element and determine size of bounding sphere
    162161      size=0.;
    163       for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
    164         counts[(*iter)->type->getNumber()]++;
    165         if ((*iter)->x.DistanceSquared(Origin) > size)
    166           size = (*iter)->x.DistanceSquared(Origin);
     162      Walker = (*ListRunner)->start;
     163      while (Walker->next != (*ListRunner)->end) {
     164        Walker = Walker->next;
     165        counts[Walker->type->getNumber()]++;
     166        if (Walker->x.DistanceSquared(Origin) > size)
     167          size = Walker->x.DistanceSquared(Origin);
    167168      }
    168169      // output Index, Name, number of atoms, chemical formula
    169       (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->getAtomCount() << "\t";
     170      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
    170171
    171172      std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
    … …  
    203204
    204205  // put all molecules of src into mol
    205   molecule::iterator runner;
    206   for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
    207     runner = iter++;
    208     srcmol->UnlinkAtom((*runner));
    209     mol->AddAtom((*runner));
     206  atom *Walker = srcmol->start;
     207  atom *NextAtom = Walker->next;
     208  while (NextAtom != srcmol->end) {
     209    Walker = NextAtom;
     210    NextAtom = Walker->next;
     211    srcmol->UnlinkAtom(Walker);
     212    mol->AddAtom(Walker);
    210213  }
    211214
    … …  
    227230
    228231  // put all molecules of src into mol
    229   atom *Walker = NULL;
    230   for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
    231     Walker = mol->AddCopyAtom((*iter));
     232  atom *Walker = srcmol->start;
     233  atom *NextAtom = Walker->next;
     234  while (NextAtom != srcmol->end) {
     235    Walker = NextAtom;
     236    NextAtom = Walker->next;
     237    Walker = mol->AddCopyAtom(Walker);
    232238    Walker->father = Walker;
    233239  }
    … …  
    326332
    327333  // prepare index list for bonds
    328   atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
    329   for(int i=0;i<srcmol->getAtomCount();i++)
     334  srcmol->CountAtoms();
     335  atom ** CopyAtoms = new atom*[srcmol->AtomCount];
     336  for(int i=0;i<srcmol->AtomCount;i++)
    330337    CopyAtoms[i] = NULL;
    331338
    332339  // for each of the source atoms check whether we are in- or outside and add copy atom
     340  atom *Walker = srcmol->start;
    333341  int nr=0;
    334   for (molecule::const_iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
    335     DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << **iter << "." << endl);
    336     if (!TesselStruct->IsInnerPoint((*iter)->x, LCList)) {
    337       CopyAtoms[(*iter)->nr] = (*iter)->clone();
    338       mol->AddAtom(CopyAtoms[(*iter)->nr]);
     342  while (Walker->next != srcmol->end) {
     343    Walker = Walker->next;
     344    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl);
     345    if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
     346      CopyAtoms[Walker->nr] = Walker->clone();
     347      mol->AddAtom(CopyAtoms[Walker->nr]);
    339348      nr++;
    340349    } else {
    … …  
    342351    }
    343352  }
    344   DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
     353  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->AtomCount << " atoms have been merged.");
    345354
    346355  // go through all bonds and add as well
    … …  
    375384bool MoleculeListClass::AddHydrogenCorrection(char *path)
    376385{
     386  atom *Walker = NULL;
     387  atom *Runner = NULL;
    377388  bond *Binder = NULL;
    378389  double ***FitConstant = NULL, **correction = NULL;
    … …  
    482493        correction[k][j] = 0.;
    483494    // 2. take every hydrogen that is a saturated one
    484     for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
    485       //Log() << Verbose(1) << "(*iter): " << *(*iter) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
    486       if (((*iter)->type->Z == 1) && (((*iter)->father == NULL)
    487           || ((*iter)->father->type->Z != 1))) { // if it's a hydrogen
    488         for (molecule::const_iterator runner = (*ListRunner)->begin(); runner != (*ListRunner)->end(); ++runner) {
    489           //Log() << Verbose(2) << "Runner: " << *(*runner) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
     495    Walker = (*ListRunner)->start;
     496    while (Walker->next != (*ListRunner)->end) {
     497      Walker = Walker->next;
     498      //Log() << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
     499      if ((Walker->type->Z == 1) && ((Walker->father == NULL)
     500          || (Walker->father->type->Z != 1))) { // if it's a hydrogen
     501        Runner = (*ListRunner)->start;
     502        while (Runner->next != (*ListRunner)->end) {
     503          Runner = Runner->next;
     504          //Log() << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
    490505          // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
    491           Binder = *((*runner)->ListOfBonds.begin());
    492           if (((*runner)->type->Z == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
     506          Binder = *(Runner->ListOfBonds.begin());
     507          if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (Binder->GetOtherAtom(Runner) != Binder->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
    493508            // 4. evaluate the morse potential for each matrix component and add up
    494             distance = (*runner)->x.distance((*iter)->x);
    495             //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *(*runner) << "<= " << distance << "=>" << *(*iter) << ":" << endl;
     509            distance = Runner->x.distance(Walker->x);
     510            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
    496511            for (int k = 0; k < a; k++) {
    497512              for (int j = 0; j < b; j++) {
    … …  
    571586  ofstream ForcesFile;
    572587  stringstream line;
     588  atom *Walker = NULL;
    573589  periodentafel *periode=World::getInstance().getPeriode();
    574590
    … …  
    583599      periodentafel::const_iterator elemIter;
    584600      for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
    585         if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
    586           for(molecule::iterator atomIter = (*ListRunner)->begin(); atomIter !=(*ListRunner)->end();++atomIter){
    587             if ((*atomIter)->type->getNumber() == (*elemIter).first) {
    588               if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
     601          if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
     602          Walker = (*ListRunner)->start;
     603          while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
     604            Walker = Walker->next;
     605            if (Walker->type->getNumber() == (*elemIter).first) {
     606              if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
    589607                //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
    590                 ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->nr] << "\t";
     608                ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
    591609              } else
    592610                // otherwise a -1 to indicate an added saturation hydrogen
    … …  
    622640  bool result = true;
    623641  bool intermediateResult = true;
     642  atom *Walker = NULL;
    624643  Vector BoxDimension;
    625644  char *FragmentNumber = NULL;
    … …  
    662681    // list atoms in fragment for debugging
    663682    DoLog(2) && (Log() << Verbose(2) << "Contained atoms: ");
    664     for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
    665       DoLog(0) && (Log() << Verbose(0) << (*iter)->getName() << " ");
     683    Walker = (*ListRunner)->start;
     684    while (Walker->next != (*ListRunner)->end) {
     685      Walker = Walker->next;
     686      DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " ");
    666687    }
    667688    DoLog(0) && (Log() << Verbose(0) << endl);
    … …  
    743764{
    744765  molecule *mol = World::getInstance().createMolecule();
     766  atom *Walker = NULL;
     767  atom *Advancer = NULL;
    745768  bond *Binder = NULL;
    746769  bond *Stepper = NULL;
    … …  
    748771  for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
    749772    // shift all atoms to new molecule
    750     for (molecule::iterator iter = (*MolRunner)->begin(); (*MolRunner)->empty(); iter = (*MolRunner)->begin()) {
    751       DoLog(3) && (Log() << Verbose(3) << "Re-linking " << (*iter) << "..." << endl);
    752       (*iter)->father = (*iter);
    753       mol->AddAtom((*iter));    // counting starts at 1
    754       (*MolRunner)->erase(iter);
     773    Advancer = (*MolRunner)->start->next;
     774    while (Advancer != (*MolRunner)->end) {
     775      Walker = Advancer;
     776      Advancer = Advancer->next;
     777      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
     778      unlink(Walker);
     779      Walker->father = Walker;
     780      mol->AddAtom(Walker);    // counting starts at 1
    755781    }
    756782    // remove all bonds
    … …  
    806832  // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
    807833  int FragmentCounter = 0;
    808   int *MolMap = new int[mol->getAtomCount()];
    809   for (int i=0;i<mol->getAtomCount();i++)
     834  int *MolMap = new int[mol->AtomCount];
     835  for (int i=0;i<mol->AtomCount;i++)
    810836    MolMap[i] = 0;
    811837  MoleculeLeafClass *MolecularWalker = Subgraphs;
     838  Walker = NULL;
    812839  while (MolecularWalker->next != NULL) {
    813840    MolecularWalker = MolecularWalker->next;
    814     for (molecule::const_iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
    815       MolMap[(*iter)->GetTrueFather()->nr] = FragmentCounter+1;
     841    Walker = MolecularWalker->Leaf->start;
     842    while (Walker->next != MolecularWalker->Leaf->end) {
     843      Walker = Walker->next;
     844      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
    816845    }
    817846    FragmentCounter++;
    … …  
    819848
    820849  // 4c. relocate atoms to new molecules and remove from Leafs
    821   for (molecule::iterator iter = mol->begin(); !mol->empty(); iter = mol->begin()) {
    822     if (((*iter)->nr <0) || ((*iter)->nr >= mol->getAtomCount())) {
    823       DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << **iter << " is invalid!" << endl);
     850  Walker = NULL;
     851  while (mol->start->next != mol->end) {
     852    Walker = mol->start->next;
     853    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
     854      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << *Walker << " is invalid!" << endl);
    824855      performCriticalExit();
    825856    }
    826     FragmentCounter = MolMap[(*iter)->nr];
     857    FragmentCounter = MolMap[Walker->nr];
    827858    if (FragmentCounter != 0) {
    828       DoLog(3) && (Log() << Verbose(3) << "Re-linking " << **iter << "..." << endl);
    829       molecules[FragmentCounter-1]->AddAtom((*iter));    // counting starts at 1
    830       mol->erase(iter);
     859      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
     860      unlink(Walker);
     861      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
    831862    } else {
    832       DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << **iter << " not associated to molecule!" << endl);
     863      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << *Walker << " not associated to molecule!" << endl);
    833864      performCriticalExit();
    834865    }
    … …  
    838869  while (mol->first->next != mol->last) {
    839870    Binder = mol->first->next;
    840     const atom * const Walker = Binder->leftatom;
     871    Walker = Binder->leftatom;
    841872    unlink(Binder);
    842873    link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
    … …  
    860891int MoleculeListClass::CountAllAtoms() const
    861892{
     893  atom *Walker = NULL;
    862894  int AtomNo = 0;
    863895  for (MoleculeList::const_iterator MolWalker = ListOfMolecules.begin(); MolWalker != ListOfMolecules.end(); MolWalker++) {
    864     AtomNo += (*MolWalker)->size();
     896    Walker = (*MolWalker)->start;
     897    while (Walker->next != (*MolWalker)->end) {
     898      Walker = Walker->next;
     899      AtomNo++;
     900    }
    865901  }
    866902  return AtomNo;
    … …  
    10371073bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
    10381074{
     1075  atom *Walker = NULL;
    10391076  atom *OtherWalker = NULL;
    10401077  atom *Father = NULL;
    … …  
    10441081  DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
    10451082  // fill ListOfLocalAtoms if NULL was given
    1046   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     1083  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
    10471084    DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
    10481085    return false;
    … …  
    10601097    }
    10611098
    1062     for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
    1063       Father = (*iter)->GetTrueFather();
     1099    Walker = Leaf->start;
     1100    while (Walker->next != Leaf->end) {
     1101      Walker = Walker->next;
     1102      Father = Walker->GetTrueFather();
    10641103      AtomNo = Father->nr; // global id of the current walker
    10651104      for (BondList::const_iterator Runner = Father->ListOfBonds.begin(); Runner != Father->ListOfBonds.end(); (++Runner)) {
    1066         OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
     1105        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
    10671106        if (OtherWalker != NULL) {
    1068           if (OtherWalker->nr > (*iter)->nr)
    1069             Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
     1107          if (OtherWalker->nr > Walker->nr)
     1108            Leaf->AddBond(Walker, OtherWalker, (*Runner)->BondDegree);
    10701109        } else {
    1071           DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
     1110          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl);
    10721111          status = false;
    10731112        }
    … …  
    10961135bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
    10971136{
    1098   atom *Father = NULL;
     1137  atom *Walker = NULL, *Father = NULL;
    10991138
    11001139  if (RootStack != NULL) {
    … …  
    11021141    if (&(RootStack[FragmentCounter]) != NULL) {
    11031142      RootStack[FragmentCounter].clear();
    1104       for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
    1105         Father = (*iter)->GetTrueFather();
     1143      Walker = Leaf->start;
     1144      while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
     1145        Walker = Walker->next;
     1146        Father = Walker->GetTrueFather();
    11061147        if (AtomMask[Father->nr]) // apply mask
    11071148#ifdef ADDHYDROGEN
    1108           if ((*iter)->type->Z != 1) // skip hydrogen
     1149          if (Walker->type->Z != 1) // skip hydrogen
    11091150#endif
    1110           RootStack[FragmentCounter].push_front((*iter)->nr);
     1151          RootStack[FragmentCounter].push_front(Walker->nr);
    11111152      }
    11121153      if (next != NULL)
    … …  
    11501191
    11511192  if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
    1152     status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     1193    status = status && CreateFatherLookupTable(Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
    11531194    FreeList = FreeList && true;
    11541195  }
    … …  
    11741215  DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
    11751216  // fill ListOfLocalAtoms if NULL was given
    1176   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     1217  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
    11771218    DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
    11781219    return false;

  • src/tesselation.cpp

    r1024cb r42af9e  
    2121#include "Plane.hpp"
    2222#include "Exceptions/LinearDependenceException.hpp"
    23 #include "Helpers/Assert.hpp"
    24 
    25 #include "Helpers/Assert.hpp"
    2623
    2724class molecule;
    … …  
    360357  // get ascending order of endpoints
    361358  PointMap OrderMap;
    362   for (int i = 0; i < 3; i++) {
     359  for (int i = 0; i < 3; i++)
    363360    // for all three lines
    364361    for (int j = 0; j < 2; j++) { // for both endpoints
    … …  
    366363      // and we don't care whether insertion fails
    367364    }
    368   }
    369365  // set endpoints
    370366  int Counter = 0;
    … …  
    375371    Counter++;
    376372  }
    377   ASSERT(Counter >= 3,"We have a triangle with only two distinct endpoints!");
    378 };
    379 
     373  if (Counter < 3) {
     374    DoeLog(0) && (eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl);
     375    performCriticalExit();
     376  }
     377}
     378;
    380379
    381380/** Destructor of BoundaryTriangleSet.
    … …  
    683682}
    684683
    685 /**
    686  * gets the Plane defined by the three triangle Basepoints
    687  */
    688 Plane BoundaryTriangleSet::getPlane() const{
    689   ASSERT(endpoints[0] && endpoints[1] && endpoints[2], "Triangle not fully defined");
    690 
    691   return Plane(*endpoints[0]->node->node,
    692                *endpoints[1]->node->node,
    693                *endpoints[2]->node->node);
    694 }
    695 
    696 Vector BoundaryTriangleSet::getEndpoint(int i) const{
    697   ASSERT(i>=0 && i<3,"Index of Endpoint out of Range");
    698 
    699   return *endpoints[i]->node->node;
    700 }
    701 
    702 string BoundaryTriangleSet::getEndpointName(int i) const{
    703   ASSERT(i>=0 && i<3,"Index of Endpoint out of Range");
    704 
    705   return endpoints[i]->node->getName();
    706 }
    707 
    708684/** output operator for BoundaryTriangleSet.
    709685 * \param &ost output stream
    … …  
    712688ostream &operator <<(ostream &ost, const BoundaryTriangleSet &a)
    713689{
    714   ost << "[" << a.Nr << "|" << a.getEndpointName(0) << "," << a.getEndpointName(1) << "," << a.getEndpointName(2) << "]";
     690  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->getName() << "," << a.endpoints[1]->node->getName() << "," << a.endpoints[2]->node->getName() << "]";
    715691  //  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << " at " << *a.endpoints[0]->node->node << ","
    716692  //      << a.endpoints[1]->node->Name << " at " << *a.endpoints[1]->node->node << "," << a.endpoints[2]->node->Name << " at " << *a.endpoints[2]->node->node << "]";
    … …  
    12321208;
    12331209
     1210/** PointCloud implementation of GetTerminalPoint.
     1211 * Uses PointsOnBoundary and STL stuff.
     1212 */
     1213TesselPoint * Tesselation::GetTerminalPoint() const
     1214{
     1215  Info FunctionInfo(__func__);
     1216  PointMap::const_iterator Runner = PointsOnBoundary.end();
     1217  Runner--;
     1218  return (Runner->second->node);
     1219}
     1220;
     1221
    12341222/** PointCloud implementation of GoToNext.
    12351223 * Uses PointsOnBoundary and STL stuff.
    … …  
    12431231;
    12441232
     1233/** PointCloud implementation of GoToPrevious.
     1234 * Uses PointsOnBoundary and STL stuff.
     1235 */
     1236void Tesselation::GoToPrevious() const
     1237{
     1238  Info FunctionInfo(__func__);
     1239  if (InternalPointer != PointsOnBoundary.begin())
     1240    InternalPointer--;
     1241}
     1242;
     1243
    12451244/** PointCloud implementation of GoToFirst.
    12461245 * Uses PointsOnBoundary and STL stuff.
    … …  
    12501249  Info FunctionInfo(__func__);
    12511250  InternalPointer = PointsOnBoundary.begin();
     1251}
     1252;
     1253
     1254/** PointCloud implementation of GoToLast.
     1255 * Uses PointsOnBoundary and STL stuff.
     1256 */
     1257void Tesselation::GoToLast() const
     1258{
     1259  Info FunctionInfo(__func__);
     1260  InternalPointer = PointsOnBoundary.end();
     1261  InternalPointer--;
    12521262}
    12531263;
    … …  
    14451455        CenterVector.Zero();
    14461456        for (int i = 0; i < 3; i++)
    1447           CenterVector += BTS->getEndpoint(i);
     1457          CenterVector += (*BTS->endpoints[i]->node->node);
    14481458        CenterVector.Scale(1. / 3.);
    14491459        DoLog(2) && (Log() << Verbose(2) << "CenterVector of base triangle is " << CenterVector << endl);
    … …  
    25592569  // fill the set of neighbours
    25602570  TesselPointSet SetOfNeighbours;
    2561 
    25622571  SetOfNeighbours.insert(CandidateLine.BaseLine->endpoints[1]->node);
    25632572  for (TesselPointList::iterator Runner = CandidateLine.pointlist.begin(); Runner != CandidateLine.pointlist.end(); Runner++)
    … …  
    47934802  if (LastTriangle != NULL) {
    47944803    stringstream sstr;
    4795     sstr << "-"<< TrianglesOnBoundary.size() << "-" << LastTriangle->getEndpointName(0) << "_" << LastTriangle->getEndpointName(1) << "_" << LastTriangle->getEndpointName(2);
     4804    sstr << "-"<< TrianglesOnBoundary.size() << "-" << LastTriangle->endpoints[0]->node->getName() << "_" << LastTriangle->endpoints[1]->node->getName() << "_" << LastTriangle->endpoints[2]->node->getName();
    47964805    NumberName = sstr.str();
    47974806    if (DoTecplotOutput) {

  • src/tesselation.hpp

    r1024cb r42af9e  
    3838class PointCloud;
    3939class Tesselation;
    40 class Plane;
    4140
    4241/********************************************** definitions *********************************/
    … …  
    167166    bool IsPresentTupel(const BoundaryTriangleSet * const T) const;
    168167
    169     Plane getPlane() const;
    170     Vector getEndpoint(int) const;
    171     std::string getEndpointName(int) const;
    172 
    173168    class BoundaryPointSet *endpoints[3];
    174169    class BoundaryLineSet *lines[3];
    … …  
    176171    Vector SphereCenter;
    177172    int Nr;
    178 
    179   private:
    180 
    181173};
    182174
    … …  
    244236  virtual Vector *GetCenter() const { return NULL; };
    245237  virtual TesselPoint *GetPoint() const { return NULL; };
     238  virtual TesselPoint *GetTerminalPoint() const { return NULL; };
    246239  virtual int GetMaxId() const { return 0; };
    247240  virtual void GoToNext() const {};
     241  virtual void GoToPrevious() const {};
    248242  virtual void GoToFirst() const {};
     243  virtual void GoToLast() const {};
    249244  virtual bool IsEmpty() const { return true; };
    250245  virtual bool IsEnd() const { return true; };
    … …  
    360355    virtual Vector *GetCenter(ofstream *out) const;
    361356    virtual TesselPoint *GetPoint() const;
     357    virtual TesselPoint *GetTerminalPoint() const;
    362358    virtual void GoToNext() const;
     359    virtual void GoToPrevious() const;
    363360    virtual void GoToFirst() const;
     361    virtual void GoToLast() const;
    364362    virtual bool IsEmpty() const;
    365363    virtual bool IsEnd() const;

  • src/tesselationhelpers.cpp

    r1024cb r42af9e  
    1616#include "vector_ops.hpp"
    1717#include "verbose.hpp"
    18 #include "Plane.hpp"
    1918
    2019double DetGet(gsl_matrix * const A, const int inPlace)
    … …  
    688687    return -1;
    689688  }
    690   distance = x->DistanceToSpace(triangle->getPlane());
     689  distance = x->DistanceToPlane(triangle->NormalVector, *triangle->endpoints[0]->node->node);
    691690  return distance;
    692691};
    … …  
    838837    int i=cloud->GetMaxId();
    839838    int *LookupList = new int[i];
    840     for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++){
     839    for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++)
    841840      LookupList[i] = -1;
    842     }
    843841
    844842    // print atom coordinates
    845843    int Counter = 1;
    846844    TesselPoint *Walker = NULL;
    847     for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); ++target) {
     845    for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); target++) {
    848846      Walker = target->second->node;
    849847      LookupList[Walker->nr] = Counter++;

  • src/unittests/AnalysisCorrelationToPointUnitTest.cpp

    r1024cb r42af9e  
    6666
    6767  // check that TestMolecule was correctly constructed
    68   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
     68  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
    6969
    7070  TestList = World::getInstance().getMolecules();

  • src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

    r1024cb r42af9e  
    2525#include "tesselation.hpp"
    2626#include "World.hpp"
    27 #include "Helpers/Assert.hpp"
    2827
    2928#include "Helpers/Assert.hpp"
    … …  
    4039void AnalysisCorrelationToSurfaceUnitTest::setUp()
    4140{
    42   ASSERT_DO(Assert::Throw);
     41  //ASSERT_DO(Assert::Throw);
    4342
    4443  atom *Walker = NULL;
    … …  
    5554  hydrogen = World::getInstance().getPeriode()->FindElement(1);
    5655  TestSurfaceMolecule = World::getInstance().createMolecule();
    57 
    5856  Walker = World::getInstance().createAtom();
    5957  Walker->type = hydrogen;
    6058  *Walker->node = Vector(1., 0., 1. );
    61   TestSurfaceMolecule->AddAtom(Walker);
    62 
     59
     60  TestSurfaceMolecule->AddAtom(Walker);
    6361  Walker = World::getInstance().createAtom();
    6462  Walker->type = hydrogen;
    6563  *Walker->node = Vector(0., 1., 1. );
    6664  TestSurfaceMolecule->AddAtom(Walker);
    67 
    6865  Walker = World::getInstance().createAtom();
    6966  Walker->type = hydrogen;
    7067  *Walker->node = Vector(1., 1., 0. );
    7168  TestSurfaceMolecule->AddAtom(Walker);
    72 
    7369  Walker = World::getInstance().createAtom();
    7470  Walker->type = hydrogen;
    … …  
    7773
    7874  // check that TestMolecule was correctly constructed
    79   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
     75  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
    8076
    8177  TestList = World::getInstance().getMolecules();
    … …  
    9591  *Walker->node = Vector(4., 0., 4. );
    9692  TestSurfaceMolecule->AddAtom(Walker);
    97 
    9893  Walker = World::getInstance().createAtom();
    9994  Walker->type = carbon;
    10095  *Walker->node = Vector(0., 4., 4. );
    10196  TestSurfaceMolecule->AddAtom(Walker);
    102 
    10397  Walker = World::getInstance().createAtom();
    10498  Walker->type = carbon;
    10599  *Walker->node = Vector(4., 4., 0. );
    106100  TestSurfaceMolecule->AddAtom(Walker);
    107 
    108101  // add inner atoms
    109102  Walker = World::getInstance().createAtom();
    … …  
    111104  *Walker->node = Vector(0.5, 0.5, 0.5 );
    112105  TestSurfaceMolecule->AddAtom(Walker);
    113 
    114106  TestSurfaceMolecule->ActiveFlag = true;
    115107  TestList->insert(TestSurfaceMolecule);
    … …  
    141133void AnalysisCorrelationToSurfaceUnitTest::SurfaceTest()
    142134{
    143   CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
     135  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->AtomCount );
    144136  CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
    145137  CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );

  • src/unittests/AnalysisPairCorrelationUnitTest.cpp

    r1024cb r42af9e  
    6868
    6969  // check that TestMolecule was correctly constructed
    70   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
     70  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
    7171
    7272  TestList = World::getInstance().getMolecules();

  • src/unittests/CountBondsUnitTest.cpp

    r1024cb r42af9e  
    9292
    9393  // check that TestMolecule was correctly constructed
    94   CPPUNIT_ASSERT_EQUAL( TestMolecule1->getAtomCount(), 3 );
    95   CPPUNIT_ASSERT_EQUAL( TestMolecule2->getAtomCount(), 3 );
     94  CPPUNIT_ASSERT_EQUAL( TestMolecule1->AtomCount, 3 );
     95  Walker = TestMolecule1->start->next;
     96  CPPUNIT_ASSERT( TestMolecule1->end != Walker );
     97  CPPUNIT_ASSERT_EQUAL( TestMolecule2->AtomCount, 3 );
     98  Walker = TestMolecule2->start->next;
     99  CPPUNIT_ASSERT( TestMolecule2->end != Walker );
    96100
    97101  // create a small file with table

  • src/unittests/LinkedCellUnitTest.cpp

    r1024cb r42af9e  
    6060
    6161  // check that TestMolecule was correctly constructed
    62   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 3*3*3 );
     62  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 3*3*3 );
     63  Walker = TestMolecule->start->next;
     64  CPPUNIT_ASSERT( TestMolecule->end != Walker );
    6365};
    6466
    … …  
    185187{
    186188  // check all atoms
    187   for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end();++iter){
    188     CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(*iter) );
     189  atom *Walker = TestMolecule->start;
     190  while (Walker->next != TestMolecule->end) {
     191    Walker = Walker->next;
     192    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(Walker) );
    189193  }
    190194
    191195  // check internal vectors, returns false, because this atom is not in LC-list!
    192   atom *newAtom = World::getInstance().createAtom();
    193   newAtom->setName("test");
    194   newAtom->x= Vector(1,1,1);
    195   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
    196   World::getInstance().destroyAtom(newAtom);
     196  Walker = World::getInstance().createAtom();
     197  Walker->setName("test");
     198  Walker->x= Vector(1,1,1);
     199  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
     200  World::getInstance().destroyAtom(Walker);
    197201
    198202  // check out of bounds vectors
    199   newAtom = World::getInstance().createAtom();
    200   newAtom->setName("test");
    201   newAtom->x = Vector(0,-1,0);
    202   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
    203   World::getInstance().destroyAtom(newAtom);
     203  Walker = World::getInstance().createAtom();
     204  Walker->setName("test");
     205  Walker->x = Vector(0,-1,0);
     206  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
     207  World::getInstance().destroyAtom(Walker);
    204208};
    205209
    … …  
    273277  size = ListOfPoints->size();
    274278  CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
    275 
    276   for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
    277     ListOfPoints->remove((*iter));
     279  Walker = TestMolecule->start;
     280  Walker = TestMolecule->start;
     281  while (Walker->next != TestMolecule->end) {
     282    Walker = Walker->next;
     283    ListOfPoints->remove(Walker);
    278284    size--;
    279285    CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
    … …  
    290296  size=ListOfPoints->size();
    291297  CPPUNIT_ASSERT_EQUAL( (size_t)8, size );
    292   for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
    293     if (((*iter)->x[0] <2) && ((*iter)->x[1] <2) && ((*iter)->x[2] <2)) {
    294       ListOfPoints->remove(*iter);
     298  Walker = TestMolecule->start;
     299  while (Walker->next != TestMolecule->end) {
     300    Walker = Walker->next;
     301    if ((Walker->x[0] <2) && (Walker->x[1] <2) && (Walker->x[2] <2)) {
     302      ListOfPoints->remove(Walker);
    295303      size--;
    296304      CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
    … …  
    308316  size=ListOfPoints->size();
    309317  CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
    310   for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
    311     ListOfPoints->remove(*iter);
     318  Walker = TestMolecule->start;
     319  while (Walker->next != TestMolecule->end) {
     320    Walker = Walker->next;
     321    ListOfPoints->remove(Walker);
    312322    size--;
    313323    CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
    … …  
    335345  size = ListOfPoints->size();
    336346  CPPUNIT_ASSERT_EQUAL( (size_t)7, size );
    337   for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
    338     if (((*iter)->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
    339       ListOfPoints->remove(*iter);
     347  Walker = TestMolecule->start;
     348  while (Walker->next != TestMolecule->end) {
     349    Walker = Walker->next;
     350    if ((Walker->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
     351      ListOfPoints->remove(Walker);
    340352      size--;
    341353      CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );

  • src/unittests/Makefile.am

    r1024cb r42af9e  
    4949noinst_PROGRAMS = $(TESTS) TestRunner
    5050
    51 GSLLIBS = ../libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
    52 ALLLIBS = ../libmolecuilder.a ${GSLLIBS}
     51GSLLIBS = ../libgslwrapper.a
     52ALLLIBS = ../libmolecuilder.a ${GSLLIBS} $(BOOST_LIB) ${BOOST_THREAD_LIB}
    5353
    5454TESTSOURCES = \
    … …  
    182182manipulateAtomsTest_LDADD = ${ALLLIBS}
    183183
    184 MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
     184MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
    185185MemoryAllocatorUnitTest_LDADD = ${ALLLIBS}
    186186
    … …  
    218218Tesselation_InOutsideUnitTest_LDADD = ${ALLLIBS}
    219219
    220 TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
     220TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
    221221TestRunner_LDADD = ${ALLLIBS}
    222222

  • src/unittests/ObserverTest.cpp

    r1024cb r42af9e  
    1111#include <cppunit/extensions/TestFactoryRegistry.h>
    1212#include <cppunit/ui/text/TestRunner.h>
    13 #include <set>
    1413
    1514#include "Patterns/Observer.hpp"
    16 #include "Patterns/ObservedIterator.hpp"
    1715#include "Helpers/Assert.hpp"
    1816
    … …  
    164162  bool wasNotified;
    165163};
    166 
    167 class ObservableCollection : public Observable {
    168 public:
    169   typedef std::set<SimpleObservable*> set;
    170   typedef ObservedIterator<set> iterator;
    171   typedef set::const_iterator const_iterator;
    172 
    173   ObservableCollection(int _num) :
    174   num(_num)
    175   {
    176     for(int i=0; i<num; ++i){
    177       SimpleObservable *content = new SimpleObservable();
    178       content->signOn(this);
    179       theSet.insert(content);
    180     }
    181   }
    182 
    183   ~ObservableCollection(){
    184     set::iterator iter;
    185     for(iter=theSet.begin(); iter!=theSet.end(); ++iter ){
    186       delete (*iter);
    187     }
    188   }
    189 
    190   iterator begin(){
    191     return iterator(theSet.begin(),this);
    192   }
    193 
    194   iterator end(){
    195     return iterator(theSet.end(),this);
    196   }
    197 
    198   const int num;
    199 
    200 private:
    201   set theSet;
    202 };
    203 
    204164
    205165/******************* actuall tests ***************/
    … …  
    213173  blockObservable = new BlockObservable();
    214174  notificationObservable = new NotificationObservable();
    215   collection = new ObservableCollection(5);
    216175
    217176  observer1 = new UpdateCountObserver();
    … …  
    222181  notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
    223182  notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
     183
    224184}
    225185
    … …  
    231191  delete blockObservable;
    232192  delete notificationObservable;
    233   delete collection;
    234193
    235194  delete observer1;
    … …  
    318277  blockObservable->changeMethod2();
    319278  blockObservable->noChangeMethod();
    320 }
    321 
    322 void ObserverTest::iteratorTest(){
    323   int i = 0;
    324   // test the general iterator methods
    325   for(ObservableCollection::iterator iter=collection->begin(); iter!=collection->end();++iter){
    326     CPPUNIT_ASSERT(i< collection->num);
    327     i++;
    328   }
    329 
    330   i=0;
    331   for(ObservableCollection::const_iterator iter=collection->begin(); iter!=collection->end();++iter){
    332     CPPUNIT_ASSERT(i<collection->num);
    333     i++;
    334   }
    335 
    336   collection->signOn(observer1);
    337   {
    338     // we construct this out of the loop, so the iterator dies at the end of
    339     // the scope and not the end of the loop (allows more testing)
    340     ObservableCollection::iterator iter;
    341     for(iter=collection->begin(); iter!=collection->end(); ++iter){
    342       (*iter)->changeMethod();
    343     }
    344     // At this point no change should have been propagated
    345     CPPUNIT_ASSERT_EQUAL( 0, observer1->updates);
    346   }
    347   // After the Iterator has died the propagation should take place
    348   CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
    349 
    350   // when using a const_iterator no changes should be propagated
    351   for(ObservableCollection::const_iterator iter = collection->begin(); iter!=collection->end();++iter);
    352   CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
    353   collection->signOff(observer1);
    354279}
    355280

  • src/unittests/ObserverTest.hpp

    r1024cb r42af9e  
    1717class CallObservable;
    1818class SuperObservable;
    19 class ObservableCollection;
    2019class BlockObservable;
    2120class NotificationObservable;
     21
    2222
    2323class ObserverTest :  public CppUnit::TestFixture
    … …  
    2929  CPPUNIT_TEST ( doesNotifyTest );
    3030  CPPUNIT_TEST ( doesReportTest );
    31   CPPUNIT_TEST ( iteratorTest );
    3231  CPPUNIT_TEST ( CircleDetectionTest );
    3332  CPPUNIT_TEST_SUITE_END();
    … …  
    4241  void doesNotifyTest();
    4342  void doesReportTest();
    44   void iteratorTest();
    4543  void CircleDetectionTest();
    4644
    … …  
    6058  SuperObservable *superObservable;
    6159  NotificationObservable *notificationObservable;
    62   ObservableCollection *collection;
    63 
    6460};
    6561

  • src/unittests/analysisbondsunittest.cpp

    r1024cb r42af9e  
    2525#include "molecule.hpp"
    2626#include "periodentafel.hpp"
    27 #include "World.hpp"
    2827
    2928#ifdef HAVE_TESTRUNNER
    … …  
    7776
    7877  // check that TestMolecule was correctly constructed
    79   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 5 );
     78  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 5 );
    8079
    8180  // create a small file with table

  • src/unittests/bondgraphunittest.cpp

    r1024cb r42af9e  
    7777
    7878  // check that TestMolecule was correctly constructed
    79   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
     79  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
    8080
    8181  // create a small file with table
    … …  
    114114};
    115115
    116 /** Tests whether setup worked.
    117  */
    118 void BondGraphTest::SetupTest()
    119 {
    120   CPPUNIT_ASSERT_EQUAL (false, TestMolecule->empty());
    121   CPPUNIT_ASSERT_EQUAL ((size_t)4, TestMolecule->size());
    122 };
    123 
    124116/** UnitTest for BondGraphTest::LoadBondLengthTable().
    125117 */
    … …  
    136128void BondGraphTest::ConstructGraphFromTableTest()
    137129{
    138   molecule::iterator Walker = TestMolecule->begin();
    139   molecule::iterator Runner = TestMolecule->begin();
    140   Runner++;
     130  atom *Walker = TestMolecule->start->next;
     131  atom *Runner = TestMolecule->end->previous;
     132  CPPUNIT_ASSERT( TestMolecule->end != Walker );
    141133  CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
    142134  CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
    143   CPPUNIT_ASSERT_EQUAL( true , (*Walker)->IsBondedTo((*Runner)) );
     135  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
    144136};
    145137
    … …  
    148140void BondGraphTest::ConstructGraphFromCovalentRadiiTest()
    149141{
    150 
    151   //atom *Walker = TestMolecule->start->next;
    152   //atom *Runner = TestMolecule->end->previous;
    153   //CPPUNIT_ASSERT( TestMolecule->end != Walker );
     142  atom *Walker = TestMolecule->start->next;
     143  atom *Runner = TestMolecule->end->previous;
     144  CPPUNIT_ASSERT( TestMolecule->end != Walker );
    154145  CPPUNIT_ASSERT_EQUAL( false , BG->LoadBondLengthTable(*dummyname) );
    155146  CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
    156 
    157   // this cannot be assured using dynamic IDs
    158   //CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
     147  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
    159148};
    160149

  • src/unittests/bondgraphunittest.hpp

    r1024cb r42af9e  
    2222{
    2323    CPPUNIT_TEST_SUITE( BondGraphTest) ;
    24     CPPUNIT_TEST ( SetupTest );
    2524    CPPUNIT_TEST ( LoadTableTest );
    2625    CPPUNIT_TEST ( ConstructGraphFromTableTest );
    … …  
    3130      void setUp();
    3231      void tearDown();
    33       void SetupTest();
    3432      void LoadTableTest();
    3533      void ConstructGraphFromTableTest();

  • src/unittests/listofbondsunittest.cpp

    r1024cb r42af9e  
    6767
    6868  // check that TestMolecule was correctly constructed
    69   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
     69  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
    7070};
    7171
    … …  
    8181};
    8282
    83 /** Tests whether setup worked correctly.
    84  *
    85  */
    86 void ListOfBondsTest::SetupTest()
    87 {
    88   CPPUNIT_ASSERT_EQUAL( false, TestMolecule->empty() );
    89   CPPUNIT_ASSERT_EQUAL( (size_t)4, TestMolecule->size() );
    90 };
    91 
    9283/** Unit Test of molecule::AddBond()
    9384 *
    … …  
    9687{
    9788  bond *Binder = NULL;
    98   molecule::iterator iter = TestMolecule->begin();
    99   atom *atom1 = *iter;
    100   iter++;
    101   atom *atom2 = *iter;
     89  atom *atom1 = TestMolecule->start->next;
     90  atom *atom2 = atom1->next;
    10291  CPPUNIT_ASSERT( atom1 != NULL );
    10392  CPPUNIT_ASSERT( atom2 != NULL );
    … …  
    126115{
    127116  bond *Binder = NULL;
    128   molecule::iterator iter = TestMolecule->begin();
    129   atom *atom1 = *iter;
    130   iter++;
    131   atom *atom2 = *iter;
     117  atom *atom1 = TestMolecule->start->next;
     118  atom *atom2 = atom1->next;
    132119  CPPUNIT_ASSERT( atom1 != NULL );
    133120  CPPUNIT_ASSERT( atom2 != NULL );
    … …  
    154141{
    155142  bond *Binder = NULL;
    156   molecule::iterator iter = TestMolecule->begin();
    157   atom *atom1 = *iter;
    158   iter++;
    159   atom *atom2 = *iter;
    160   iter++;
    161   atom *atom3 = *iter;
     143  atom *atom1 = TestMolecule->start->next;
     144  atom *atom2 = atom1->next;
     145  atom *atom3 = atom2->next;
    162146  CPPUNIT_ASSERT( atom1 != NULL );
    163147  CPPUNIT_ASSERT( atom2 != NULL );
    … …  
    196180{
    197181  bond *Binder = NULL;
    198   molecule::iterator iter = TestMolecule->begin();
    199   atom *atom1 = *iter;
    200   iter++;
    201   atom *atom2 = *iter;
     182  atom *atom1 = TestMolecule->start->next;
     183  atom *atom2 = atom1->next;
    202184  CPPUNIT_ASSERT( atom1 != NULL );
    203185  CPPUNIT_ASSERT( atom2 != NULL );
    … …  
    224206{
    225207  bond *Binder = NULL;
    226   molecule::iterator iter = TestMolecule->begin();
    227   atom *atom1 = *iter;
    228   iter++;
    229   atom *atom2 = *iter;
     208  atom *atom1 = TestMolecule->start->next;
     209  atom *atom2 = atom1->next;
    230210  CPPUNIT_ASSERT( atom1 != NULL );
    231211  CPPUNIT_ASSERT( atom2 != NULL );
    … …  
    251231{
    252232  bond *Binder = NULL;
    253   molecule::iterator iter = TestMolecule->begin();
    254   atom *atom1 = *iter;
    255   iter++;
    256   atom *atom2 = *iter;
     233  atom *atom1 = TestMolecule->start->next;
     234  atom *atom2 = atom1->next;
    257235  CPPUNIT_ASSERT( atom1 != NULL );
    258236  CPPUNIT_ASSERT( atom2 != NULL );

  • src/unittests/listofbondsunittest.hpp

    r1024cb r42af9e  
    2020{
    2121    CPPUNIT_TEST_SUITE( ListOfBondsTest) ;
    22     CPPUNIT_TEST ( SetupTest );
    2322    CPPUNIT_TEST ( AddingBondTest );
    2423    CPPUNIT_TEST ( RemovingBondTest );
    … …  
    3231      void setUp();
    3332      void tearDown();
    34       void SetupTest();
    3533      void AddingBondTest();
    3634      void RemovingBondTest();

  • src/vector.cpp

    r1024cb r42af9e  
    266266 * \return distance to plane
    267267 */
    268 double Vector::DistanceToSpace(const Space &space) const
    269 {
    270   return space.distance(*this);
     268double Vector::DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const
     269{
     270  return GetDistanceVectorToPlane(PlaneNormal,PlaneOffset).Norm();
    271271};
    272272

  • src/vector.hpp

    r1024cb r42af9e  
    4040  double DistanceSquared(const Vector &y) const;
    4141  Vector GetDistanceVectorToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
    42   double DistanceToSpace(const Space& space) const;
     42  double DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
    4343  double PeriodicDistance(const Vector &y, const double * const cell_size) const;
    4444  double PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const;

  • tests/regression/Domain/5/post/test.conf

    r1024cb r42af9e  
    7171Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
    7272#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
    73 Ion_Type1_1     4.891042973     2.645886050     2.381297445     0 # molecule nr 0
    74 Ion_Type1_2     4.891042973     2.645886050     3.983297422     0 # molecule nr 1
    75 Ion_Type1_3     5.336019804     3.904536878     3.182297433     0 # molecule nr 2
    76 Ion_Type1_4     4.266392982     4.787886018     2.381297445     0 # molecule nr 3
    77 Ion_Type1_5     4.266392982     4.787886018     3.983297422     0 # molecule nr 4
    78 Ion_Type1_6     3.196816159     3.904536877     3.182297433     0 # molecule nr 5
    79 Ion_Type1_7     3.641792991     2.645886050     2.381297445     0 # molecule nr 6
    80 Ion_Type1_8     3.641792991     2.645886050     3.983297422     0 # molecule nr 7
    81 Ion_Type2_1     4.891042973     3.275186040     3.182297433     0 # molecule nr 8
    82 Ion_Type2_2     4.266392982     4.158586027     3.182297433     0 # molecule nr 9
    83 Ion_Type2_3     3.641792991     3.275186040     3.182297433     0 # molecule nr 10
     73Ion_Type2_1     4.891042973     3.275186040     3.182297433     0 # molecule nr 0
     74Ion_Type2_2     4.266392982     4.158586027     3.182297433     0 # molecule nr 1
     75Ion_Type2_3     3.641792991     3.275186040     3.182297433     0 # molecule nr 2
     76Ion_Type1_1     4.891042973     2.645886050     2.381297445     0 # molecule nr 3
     77Ion_Type1_2     4.891042973     2.645886050     3.983297422     0 # molecule nr 4
     78Ion_Type1_3     5.336019804     3.904536878     3.182297433     0 # molecule nr 5
     79Ion_Type1_4     4.266392982     4.787886018     2.381297445     0 # molecule nr 6
     80Ion_Type1_5     4.266392982     4.787886018     3.983297422     0 # molecule nr 7
     81Ion_Type1_6     3.196816159     3.904536877     3.182297433     0 # molecule nr 8
     82Ion_Type1_7     3.641792991     2.645886050     2.381297445     0 # molecule nr 9
     83Ion_Type1_8     3.641792991     2.645886050     3.983297422     0 # molecule nr 10

  • tests/regression/Domain/5/pre/test.conf

    r1024cb r42af9e  
    7171Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
    7272#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
    73 Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
    74 Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
    75 Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
    76 Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
    77 Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
    78 Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
    79 Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
    80 Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
    81 Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
    82 Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
    83 Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10
     73Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
     74Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
     75Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
     76Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
     77Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
     78Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
     79Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
     80Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
     81Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
     82Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
     83Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10

  • tests/regression/Domain/6/pre/test.conf

    r1024cb r42af9e  
    7171Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
    7272#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
    73 Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
    74 Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
    75 Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
    76 Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
    77 Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
    78 Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
    79 Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
    80 Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
    81 Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
    82 Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
    83 Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10
     73Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
     74Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
     75Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
     76Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
     77Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
     78Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
     79Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
     80Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
     81Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
     82Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
     83Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10

  • tests/regression/testsuite-domain.at

    r1024cb r42af9e  
    4545AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
    4646AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 1 1], 0, [stdout], [stderr])
    47 AT_CHECK([file=test.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
    48 AT_CHECK([file=test.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
    49 AT_CHECK([file=test.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
    50 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-x.conf], 0)
    51 AT_CHECK([../../molecuilder test-x.conf -e ${abs_top_srcdir}/src/ -d 2 1 1], 0, [stdout], [stderr])
    52 AT_CHECK([file=test-x.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
    53 AT_CHECK([file=test-x.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
    54 AT_CHECK([file=test-x.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
    55 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-y.conf], 0)
    56 AT_CHECK([../../molecuilder test-y.conf -e ${abs_top_srcdir}/src/ -d 1 2 1], 0, [stdout], [stderr])
    57 AT_CHECK([file=test-y.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
    58 AT_CHECK([file=test-y.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
    59 AT_CHECK([file=test-y.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
    60 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-z.conf], 0)
    61 AT_CHECK([../../molecuilder test-z.conf -e ${abs_top_srcdir}/src/ -d 1 1 2], 0, [stdout], [stderr])
    62 AT_CHECK([file=test-z.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
    63 AT_CHECK([file=test-z.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
    64 AT_CHECK([file=test-z.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
    65 #AT_CHECK([/bin/false], 12, [ignore], [ignore])
     47AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test.conf], 0, [stdout], [stderr])
     48AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
     49AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 2 1 1], 0, [stdout], [stderr])
     50AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-x.conf], 0, [stdout], [stderr])
     51AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
     52AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 2 1], 0, [stdout], [stderr])
     53AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-y.conf], 0, [stdout], [stderr])
     54AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
     55AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 1 2], 0, [stdout], [stderr])
     56AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/test-z.conf], 0, [stdout], [stderr])
    6657AT_CLEANUP

  • tests/regression/testsuite-simple_configuration.at

    r1024cb r42af9e  
    8787AT_KEYWORDS([configuration])
    8888AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.* .], 0)
    89 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -R 7.283585982 3.275186040 3.535886037 7.], 0, [stdout], [stderr])
    90 AT_CHECK([sort -n test.conf.xyz | grep -v "Created by" >test.conf.xyz-sorted], 0, [ignore], [ignore])
    91 AT_CHECK([sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz  | grep -v "Created by" >${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz-sorted], 0, [ignore], [ignore])
    92 AT_CHECK([file=test.conf.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
     89AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -R 2 7.], 0, [stdout], [stderr])
     90AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
    9391AT_CLEANUP
Note: See TracChangeset for help on using the changeset viewer.