Index: src/BoundaryPointSet.cpp
===================================================================
--- src/BoundaryPointSet.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/BoundaryPointSet.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -57,5 +57,5 @@
   node(Walker),
   value(0.),
-  Nr(Walker->ParticleInfo_nr)
+  Nr(Walker->getNr())
 {
   Info FunctionInfo(__func__);
@@ -108,5 +108,5 @@
 {
   ASSERT(node != NULL, "BoundaryPointSet::getPosition() - internal node is NULL.");
-  return node->ParticleInfo_nr;
+  return node->getNr();
 }
 
Index: src/BoundaryPointSet.hpp
===================================================================
--- src/BoundaryPointSet.hpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/BoundaryPointSet.hpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -52,5 +52,5 @@
     /** Getter for \a node's ParticleInfo_nr.
      *
-     * @return ParticleInfo_nr of \a node
+     * @return getNr() of \a node
      */
     const int& getNr() const;
Index: src/analysis_bonds.cpp
===================================================================
--- src/analysis_bonds.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/analysis_bonds.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -239,5 +239,5 @@
             BondRunner++) {
           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
-          if (((OtherAtom->getType() == first) || (OtherAtom->getType() == second)) && (theAtom->ParticleInfo_nr < OtherAtom->ParticleInfo_nr)) {
+          if (((OtherAtom->getType() == first) || (OtherAtom->getType() == second)) && (theAtom->getNr() < OtherAtom->getNr())) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << *first << "-" << *second << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
Index: src/atom.cpp
===================================================================
--- src/atom.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/atom.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -152,5 +152,5 @@
       *out << " # " << comment << endl;
     else
-      *out << " # molecule nr " << ParticleInfo_nr << endl;
+      *out << " # molecule nr " << getNr() << endl;
     return true;
   } else
@@ -179,5 +179,5 @@
       *out << " # " << comment << endl;
     else
-      *out << " # molecule nr " << ParticleInfo_nr << endl;
+      *out << " # molecule nr " << getNr() << endl;
     return true;
   } else
@@ -218,5 +218,5 @@
     if (getAtomicForceAtStep(step).Norm() > MYEPSILON)
       *out << "\t" << scientific << setprecision(6) << getAtomicForceAtStep(step)[0] << "\t" << getAtomicForceAtStep(step)[1] << "\t" << getAtomicForceAtStep(step)[2] << "\t";
-    *out << "\t# Number in molecule " << ParticleInfo_nr << endl;
+    *out << "\t# Number in molecule " << getNr() << endl;
     return true;
   } else
@@ -259,5 +259,5 @@
 bool atom::Compare(const atom &ptr) const
 {
-  if (ParticleInfo_nr < ptr.ParticleInfo_nr)
+  if (getNr() < ptr.getNr())
     return true;
   else
@@ -379,5 +379,5 @@
 
 int atom::getNr() const{
-  return ParticleInfo_nr;
+  return ParticleInfo::getNr();
 }
 
Index: src/atom_bondedparticle.cpp
===================================================================
--- src/atom_bondedparticle.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/atom_bondedparticle.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -50,6 +50,6 @@
 void BondedParticle::OutputOrder(ofstream *file) const
 {
-  *file << ParticleInfo_nr << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << endl;
-  //Log() << Verbose(2) << "Storing: " << ParticleInfo_nr << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << "." << endl;
+  *file << getNr() << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << endl;
+  //Log() << Verbose(2) << "Storing: " << getNr() << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << "." << endl;
 };
 
@@ -59,5 +59,5 @@
 {
   const BondList& ListOfBonds = getListOfBonds();
-  DoLog(4) && (Log() << Verbose(4) << "Atom " << getName() << "/" << ParticleInfo_nr << " with " << ListOfBonds.size() << " bonds: " << endl);
+  DoLog(4) && (Log() << Verbose(4) << "Atom " << getName() << "/" << getNr() << " with " << ListOfBonds.size() << " bonds: " << endl);
   int TotalDegree = 0;
   for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); ++Runner) {
@@ -74,7 +74,7 @@
 {
   const BondList& ListOfBonds = getListOfBonds();
-  *AdjacencyFile << ParticleInfo_nr << "\t";
+  *AdjacencyFile << getNr() << "\t";
   for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
-    *AdjacencyFile << (*Runner)->GetOtherAtom(this)->ParticleInfo_nr << "\t";
+    *AdjacencyFile << (*Runner)->GetOtherAtom(this)->getNr() << "\t";
   *AdjacencyFile << endl;
 };
@@ -88,6 +88,6 @@
   const BondList& ListOfBonds = getListOfBonds();
   for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
-    if (ParticleInfo_nr < (*Runner)->GetOtherAtom(this)->ParticleInfo_nr)
-      *BondFile << ParticleInfo_nr << "\t" << (*Runner)->GetOtherAtom(this)->ParticleInfo_nr << "\n";
+    if (getNr() < (*Runner)->GetOtherAtom(this)->getNr())
+      *BondFile << getNr() << "\t" << (*Runner)->GetOtherAtom(this)->getNr() << "\n";
 };
 
Index: src/atom_particleinfo.hpp
===================================================================
--- src/atom_particleinfo.hpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/atom_particleinfo.hpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -28,6 +28,4 @@
 class ParticleInfo {
 public:
-  int ParticleInfo_nr;       // index to easierly identify
-
   ParticleInfo();
   ParticleInfo(ParticleInfo*);
@@ -57,4 +55,7 @@
   ostream & operator << (ostream &ost) const;
 
+protected:
+  int ParticleInfo_nr;       // index to easierly identify, only protected as used in atom::sort
+
 private:
   std::string name;   // some name to reference to on output
Index: src/bond.cpp
===================================================================
--- src/bond.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/bond.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -120,5 +120,5 @@
 bool bond::Contains(const int number)
 {
-  return ((leftatom->ParticleInfo_nr == number) || (rightatom->ParticleInfo_nr == number));
+  return ((leftatom->getNr() == number) || (rightatom->getNr() == number));
 };
 
Index: src/boundary.cpp
===================================================================
--- src/boundary.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/boundary.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -909,11 +909,11 @@
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
-            CopyAtoms[(*iter)->ParticleInfo_nr] = (*iter)->clone();
-            (*CopyAtoms[(*iter)->ParticleInfo_nr]).setPosition(Inserter);
-            Filling->AddAtom(CopyAtoms[(*iter)->ParticleInfo_nr]);
-            DoLog(1) && (Log() << Verbose(1) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->ParticleInfo_nr]->getPosition()) << "." << endl);
+            CopyAtoms[(*iter)->getNr()] = (*iter)->clone();
+            (*CopyAtoms[(*iter)->getNr()]).setPosition(Inserter);
+            Filling->AddAtom(CopyAtoms[(*iter)->getNr()]);
+            DoLog(1) && (Log() << Verbose(1) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->getNr()]->getPosition()) << "." << endl);
           } else {
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
-            CopyAtoms[(*iter)->ParticleInfo_nr] = NULL;
+            CopyAtoms[(*iter)->getNr()] = NULL;
             continue;
           }
@@ -927,7 +927,7 @@
             if ((*BondRunner)->leftatom == *AtomRunner) {
               Binder = (*BondRunner);
-              if ((CopyAtoms[Binder->leftatom->ParticleInfo_nr] != NULL) && (CopyAtoms[Binder->rightatom->ParticleInfo_nr] != NULL)) {
-                Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->ParticleInfo_nr] << " and " << *CopyAtoms[Binder->rightatom->ParticleInfo_nr]<< "." << endl;
-                Filling->AddBond(CopyAtoms[Binder->leftatom->ParticleInfo_nr], CopyAtoms[Binder->rightatom->ParticleInfo_nr], Binder->BondDegree);
+              if ((CopyAtoms[Binder->leftatom->getNr()] != NULL) && (CopyAtoms[Binder->rightatom->getNr()] != NULL)) {
+                Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->getNr()] << " and " << *CopyAtoms[Binder->rightatom->getNr()]<< "." << endl;
+                Filling->AddBond(CopyAtoms[Binder->leftatom->getNr()], CopyAtoms[Binder->rightatom->getNr()], Binder->BondDegree);
               }
             }
Index: src/config.cpp
===================================================================
--- src/config.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/config.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -845,5 +845,5 @@
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-             (*iter)->ParticleInfo_nr,                /* atom serial number */
+             (*iter)->getNr(),                /* atom serial number */
              name,         /* atom name */
              (*MolRunner)->name,      /* residue name */
@@ -898,5 +898,5 @@
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
-           (*iter)->ParticleInfo_nr,                /* atom serial number */
+           (*iter)->getNr(),                /* atom serial number */
            name,         /* atom name */
            mol->name,      /* residue name */
@@ -948,5 +948,5 @@
 
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    *output << (*iter)->ParticleInfo_nr << "\t";
+    *output << (*iter)->getNr() << "\t";
     *output << (*iter)->getName() << "\t";
     *output << mol->name << "\t";
@@ -959,5 +959,5 @@
         runner != ListOfBonds.end();
         runner++) {
-      *output << (*runner)->GetOtherAtom(*iter)->ParticleInfo_nr << "\t";
+      *output << (*runner)->GetOtherAtom(*iter)->getNr() << "\t";
     }
     for(int i = ListOfBonds.size(); i < MaxNeighbours; i++)
Index: src/molecule.cpp
===================================================================
--- src/molecule.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/molecule.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -230,5 +230,4 @@
   OBSERVE;
   if (pointer != NULL) {
-    pointer->sort = &pointer->ParticleInfo_nr;
     if (pointer->getType() != NULL) {
       if (pointer->getType()->getAtomicNumber() != 1)
@@ -236,5 +235,5 @@
       if(pointer->getName() == "Unknown"){
         stringstream sstr;
-        sstr << pointer->getType()->getSymbol() << pointer->ParticleInfo_nr+1;
+        sstr << pointer->getType()->getSymbol() << pointer->getNr()+1;
         pointer->setName(sstr.str());
       }
@@ -723,6 +722,6 @@
   ASSERT(atom1, "First atom in bond-creation was an invalid pointer");
   ASSERT(atom2, "Second atom in bond-creation was an invalid pointer");
-  ASSERT(FindAtom(atom1->ParticleInfo_nr),"First atom in bond-creation was not part of molecule");
-  ASSERT(FindAtom(atom2->ParticleInfo_nr),"Second atom in bond-creation was not part of molecule");
+  ASSERT(FindAtom(atom1->getNr()),"First atom in bond-creation was not part of molecule");
+  ASSERT(FindAtom(atom2->getNr()),"Second atom in bond-creation was not part of molecule");
 
   Binder = new bond(atom1, atom2, degree, BondCount++);
@@ -839,8 +838,8 @@
   molecule::const_iterator iter = begin();
   for (; iter != end(); ++iter)
-    if ((*iter)->ParticleInfo_nr == Nr)
+    if ((*iter)->getNr() == Nr)
       break;
   if (iter != end()) {
-    //Log() << Verbose(0) << "Found Atom Nr. " << walker->ParticleInfo_nr << endl;
+    //Log() << Verbose(0) << "Found Atom Nr. " << walker->getNr() << endl;
     return (*iter);
   } else {
@@ -988,7 +987,7 @@
       NoNonHydrogen++;
     stringstream sstr;
-    sstr << (*iter)->getType()->getSymbol() << (*iter)->ParticleInfo_nr+1;
+    sstr << (*iter)->getType()->getSymbol() << (*iter)->getNr()+1;
     (*iter)->setName(sstr.str());
-    DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->ParticleInfo_nr << " " << (*iter)->getName() << "." << endl);
+    DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->getNr() << " " << (*iter)->getName() << "." << endl);
     i++;
   }
@@ -1017,5 +1016,5 @@
     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
       if ((*iter)->father == NULL) {
-        AtomicMap[(*iter)->ParticleInfo_nr] = -2;
+        AtomicMap[(*iter)->getNr()] = -2;
       } else {
         for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
@@ -1024,8 +1023,8 @@
           //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
           if ((*iter)->father == (*runner))
-            AtomicMap[(*iter)->ParticleInfo_nr] = (*runner)->ParticleInfo_nr;
+            AtomicMap[(*iter)->getNr()] = (*runner)->getNr();
         }
       }
-      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->ParticleInfo_nr] << "\t");
+      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->getNr()] << "\t");
     }
     DoLog(0) && (Log() << Verbose(0) << endl);
Index: src/molecule_dynamics.cpp
===================================================================
--- src/molecule_dynamics.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/molecule_dynamics.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -59,9 +59,9 @@
       break;
     // determine normalized trajectories direction vector (n1, n2)
-    Sprinter = Params.PermutationMap[Walker->ParticleInfo_nr];   // find first target point
+    Sprinter = Params.PermutationMap[Walker->getNr()];   // find first target point
     trajectory1 = Sprinter->getPositionAtStep(Params.endstep) - Walker->getPositionAtStep(Params.startstep);
     trajectory1.Normalize();
     Norm1 = trajectory1.Norm();
-    Sprinter = Params.PermutationMap[(*iter)->ParticleInfo_nr];   // find second target point
+    Sprinter = Params.PermutationMap[(*iter)->getNr()];   // find second target point
     trajectory2 = Sprinter->getPositionAtStep(Params.endstep) - (*iter)->getPositionAtStep(Params.startstep);
     trajectory2.Normalize();
@@ -71,5 +71,5 @@
       tmp = Walker->getPositionAtStep(Params.startstep).distance((*iter)->getPositionAtStep(Params.startstep));
     } else if (Norm1 < MYEPSILON) {
-      Sprinter = Params.PermutationMap[Walker->ParticleInfo_nr];   // find first target point
+      Sprinter = Params.PermutationMap[Walker->getNr()];   // find first target point
       trajectory1 = Sprinter->getPositionAtStep(Params.endstep) - (*iter)->getPositionAtStep(Params.startstep);
       trajectory2 *= trajectory1.ScalarProduct(trajectory2); // trajectory2 is scaled to unity, hence we don't need to divide by anything
@@ -77,5 +77,5 @@
       tmp = trajectory1.Norm();  // remaining norm is distance
     } else if (Norm2 < MYEPSILON) {
-      Sprinter = Params.PermutationMap[(*iter)->ParticleInfo_nr];   // find second target point
+      Sprinter = Params.PermutationMap[(*iter)->getNr()];   // find second target point
       trajectory2 = Sprinter->getPositionAtStep(Params.endstep) - Walker->getPositionAtStep(Params.startstep);  // copy second offset
       trajectory1 *= trajectory2.ScalarProduct(trajectory1); // trajectory1 is scaled to unity, hence we don't need to divide by anything
@@ -147,6 +147,6 @@
   double result = 0.;
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    if ((Params.PermutationMap[Walker->ParticleInfo_nr] == Params.PermutationMap[(*iter)->ParticleInfo_nr]) && (Walker->ParticleInfo_nr < (*iter)->ParticleInfo_nr)) {
-  //    atom *Sprinter = PermutationMap[Walker->ParticleInfo_nr];
+    if ((Params.PermutationMap[Walker->getNr()] == Params.PermutationMap[(*iter)->getNr()]) && (Walker->getNr() < (*iter)->getNr())) {
+  //    atom *Sprinter = PermutationMap[Walker->getNr()];
   //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
   //        Log() << Verbose(0) << Sprinter->getPosition(endstep);
@@ -182,5 +182,5 @@
   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     // first term: distance to target
-    Runner = Params.PermutationMap[(*iter)->ParticleInfo_nr];   // find target point
+    Runner = Params.PermutationMap[(*iter)->getNr()];   // find target point
     tmp = ((*iter)->getPositionAtStep(Params.startstep).distance(Runner->getPositionAtStep(Params.endstep)));
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
@@ -213,7 +213,7 @@
   zeile2 << "                ";
   for (int i=0;i<AtomCount;i++) {
-    Params.DoubleList[Params.PermutationMap[i]->ParticleInfo_nr]++;
+    Params.DoubleList[Params.PermutationMap[i]->getNr()]++;
     zeile1 << i << " ";
-    zeile2 << Params.PermutationMap[i]->ParticleInfo_nr << " ";
+    zeile2 << Params.PermutationMap[i]->getNr() << " ";
   }
   for (int i=0;i<AtomCount;i++)
@@ -239,5 +239,5 @@
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     for (molecule::const_iterator runner = mol->begin(); runner != mol->end(); ++runner) {
-      Params.DistanceList[(*iter)->ParticleInfo_nr]->insert( DistancePair((*iter)->getPositionAtStep(Params.startstep).distance((*runner)->getPositionAtStep(Params.endstep)), (*runner)) );
+      Params.DistanceList[(*iter)->getNr()]->insert( DistancePair((*iter)->getPositionAtStep(Params.startstep).distance((*runner)->getPositionAtStep(Params.endstep)), (*runner)) );
     }
   }
@@ -252,9 +252,9 @@
 {
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    Params.StepList[(*iter)->ParticleInfo_nr] = Params.DistanceList[(*iter)->ParticleInfo_nr]->begin();    // stores the step to the next iterator that could be a possible next target
-    Params.PermutationMap[(*iter)->ParticleInfo_nr] = Params.DistanceList[(*iter)->ParticleInfo_nr]->begin()->second;   // always pick target with the smallest distance
-    Params.DoubleList[Params.DistanceList[(*iter)->ParticleInfo_nr]->begin()->second->ParticleInfo_nr]++;            // increase this target's source count (>1? not injective)
-    Params.DistanceIterators[(*iter)->ParticleInfo_nr] = Params.DistanceList[(*iter)->ParticleInfo_nr]->begin();    // and remember which one we picked
-    DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->ParticleInfo_nr]->begin()->first << "." << endl);
+    Params.StepList[(*iter)->getNr()] = Params.DistanceList[(*iter)->getNr()]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[(*iter)->getNr()] = Params.DistanceList[(*iter)->getNr()]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[(*iter)->getNr()]->begin()->second->getNr()]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[(*iter)->getNr()] = Params.DistanceList[(*iter)->getNr()]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->getNr()]->begin()->first << "." << endl);
   }
 };
@@ -270,17 +270,17 @@
 {
   double Potential = 0;
-  DistanceMap::iterator NewBase = Params.DistanceIterators[Walker->ParticleInfo_nr];  // store old base
+  DistanceMap::iterator NewBase = Params.DistanceIterators[Walker->getNr()];  // store old base
   do {
     NewBase++;  // take next further distance in distance to targets list that's a target of no one
-  } while ((Params.DoubleList[NewBase->second->ParticleInfo_nr] != 0) && (NewBase != Params.DistanceList[Walker->ParticleInfo_nr]->end()));
-  if (NewBase != Params.DistanceList[Walker->ParticleInfo_nr]->end()) {
-    Params.PermutationMap[Walker->ParticleInfo_nr] = NewBase->second;
+  } while ((Params.DoubleList[NewBase->second->getNr()] != 0) && (NewBase != Params.DistanceList[Walker->getNr()]->end()));
+  if (NewBase != Params.DistanceList[Walker->getNr()]->end()) {
+    Params.PermutationMap[Walker->getNr()] = NewBase->second;
     Potential = fabs(mol->ConstrainedPotential(Params));
     if (Potential > OldPotential) { // undo
-      Params.PermutationMap[Walker->ParticleInfo_nr] = Params.DistanceIterators[Walker->ParticleInfo_nr]->second;
+      Params.PermutationMap[Walker->getNr()] = Params.DistanceIterators[Walker->getNr()]->second;
     } else {  // do
-      Params.DoubleList[Params.DistanceIterators[Walker->ParticleInfo_nr]->second->ParticleInfo_nr]--;  // decrease the old entry in the doubles list
-      Params.DoubleList[NewBase->second->ParticleInfo_nr]++;    // increase the old entry in the doubles list
-      Params.DistanceIterators[Walker->ParticleInfo_nr] = NewBase;
+      Params.DoubleList[Params.DistanceIterators[Walker->getNr()]->second->getNr()]--;  // decrease the old entry in the doubles list
+      Params.DoubleList[NewBase->second->getNr()]++;    // increase the old entry in the doubles list
+      Params.DistanceIterators[Walker->getNr()] = NewBase;
       OldPotential = Potential;
       DoLog(3) && (Log() << Verbose(3) << "Found a new permutation, new potential is " << OldPotential << "." << endl);
@@ -310,5 +310,5 @@
     if (iter == mol->end()) // round-robin at the end
       iter = mol->begin();
-    if (Params.DoubleList[Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second->ParticleInfo_nr] <= 1)  // no need to make those injective that aren't
+    if (Params.DoubleList[Params.DistanceIterators[(*iter)->getNr()]->second->getNr()] <= 1)  // no need to make those injective that aren't
       continue;
     // now, try finding a new one
@@ -398,17 +398,17 @@
       for (; iter != end(); ++iter) {
         PrintPermutationMap(getAtomCount(), Params);
-        Sprinter = Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second;   // store initial partner
-        Strider = Params.DistanceIterators[(*iter)->ParticleInfo_nr];  //remember old iterator
-        Params.DistanceIterators[(*iter)->ParticleInfo_nr] = Params.StepList[(*iter)->ParticleInfo_nr];
-        if (Params.DistanceIterators[(*iter)->ParticleInfo_nr] == Params.DistanceList[(*iter)->ParticleInfo_nr]->end()) {// stop, before we run through the list and still on
-          Params.DistanceIterators[(*iter)->ParticleInfo_nr] == Params.DistanceList[(*iter)->ParticleInfo_nr]->begin();
+        Sprinter = Params.DistanceIterators[(*iter)->getNr()]->second;   // store initial partner
+        Strider = Params.DistanceIterators[(*iter)->getNr()];  //remember old iterator
+        Params.DistanceIterators[(*iter)->getNr()] = Params.StepList[(*iter)->getNr()];
+        if (Params.DistanceIterators[(*iter)->getNr()] == Params.DistanceList[(*iter)->getNr()]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[(*iter)->getNr()] == Params.DistanceList[(*iter)->getNr()]->begin();
           break;
         }
-        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->ParticleInfo_nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->getNr()]->second << "." << endl;
         // find source of the new target
         molecule::const_iterator runner = begin();
         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)
-          if (Params.PermutationMap[(*runner)->ParticleInfo_nr] == Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second) {
-            //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->ParticleInfo_nr] << "." << endl;
+          if (Params.PermutationMap[(*runner)->getNr()] == Params.DistanceIterators[(*iter)->getNr()]->second) {
+            //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->getNr()] << "." << endl;
             break;
           }
@@ -416,13 +416,13 @@
         if (runner != end()) { // we found the other source
           // then look in its distance list for Sprinter
-          Rider = Params.DistanceList[(*runner)->ParticleInfo_nr]->begin();
-          for (; Rider != Params.DistanceList[(*runner)->ParticleInfo_nr]->end(); Rider++)
+          Rider = Params.DistanceList[(*runner)->getNr()]->begin();
+          for (; Rider != Params.DistanceList[(*runner)->getNr()]->end(); Rider++)
             if (Rider->second == Sprinter)
               break;
-          if (Rider != Params.DistanceList[(*runner)->ParticleInfo_nr]->end()) { // if we have found one
-            //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->ParticleInfo_nr] << "/" << *Rider->second << "." << endl;
+          if (Rider != Params.DistanceList[(*runner)->getNr()]->end()) { // if we have found one
+            //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->getNr()] << "/" << *Rider->second << "." << endl;
             // exchange both
-            Params.PermutationMap[(*iter)->ParticleInfo_nr] = Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second; // put next farther distance into PermutationMap
-            Params.PermutationMap[(*runner)->ParticleInfo_nr] = Sprinter;  // and hand the old target to its respective owner
+            Params.PermutationMap[(*iter)->getNr()] = Params.DistanceIterators[(*iter)->getNr()]->second; // put next farther distance into PermutationMap
+            Params.PermutationMap[(*runner)->getNr()] = Sprinter;  // and hand the old target to its respective owner
             PrintPermutationMap(getAtomCount(), Params);
             // calculate the new potential
@@ -431,13 +431,13 @@
             if (Potential > OldPotential) { // we made everything worse! Undo ...
               //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
-              //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->ParticleInfo_nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->getNr()]->second << "." << endl;
               // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
-              Params.PermutationMap[(*runner)->ParticleInfo_nr] = Params.DistanceIterators[(*runner)->ParticleInfo_nr]->second;
+              Params.PermutationMap[(*runner)->getNr()] = Params.DistanceIterators[(*runner)->getNr()]->second;
               // Undo for Walker
-              Params.DistanceIterators[(*iter)->ParticleInfo_nr] = Strider;  // take next farther distance target
-              //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second << "." << endl;
-              Params.PermutationMap[(*iter)->ParticleInfo_nr] = Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second;
+              Params.DistanceIterators[(*iter)->getNr()] = Strider;  // take next farther distance target
+              //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->getNr()]->second << "." << endl;
+              Params.PermutationMap[(*iter)->getNr()] = Params.DistanceIterators[(*iter)->getNr()]->second;
             } else {
-              Params.DistanceIterators[(*runner)->ParticleInfo_nr] = Rider;  // if successful also move the pointer in the iterator list
+              Params.DistanceIterators[(*runner)->getNr()] = Rider;  // if successful also move the pointer in the iterator list
               DoLog(3) && (Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl);
               OldPotential = Potential;
@@ -453,7 +453,7 @@
           }
         } else {
-          Params.PermutationMap[(*iter)->ParticleInfo_nr] = Params.DistanceIterators[(*iter)->ParticleInfo_nr]->second; // new target has no source!
+          Params.PermutationMap[(*iter)->getNr()] = Params.DistanceIterators[(*iter)->getNr()]->second; // new target has no source!
         }
-        Params.StepList[(*iter)->ParticleInfo_nr]++; // take next farther distance target
+        Params.StepList[(*iter)->getNr()]++; // take next farther distance target
       }
     } while (++iter != end());
@@ -486,8 +486,8 @@
   DoLog(1) && (Log() << Verbose(1) << "Calculating forces and adding onto ForceMatrix ... " << endl);
   BOOST_FOREACH(atom *_atom, atoms) {
-    atom *Sprinter = PermutationMap[_atom->ParticleInfo_nr];
+    atom *Sprinter = PermutationMap[_atom->getNr()];
     // set forces
     for (int i=NDIM;i++;)
-      Force->Matrix[0][_atom->ParticleInfo_nr][5+i] += 2.*constant*sqrt(_atom->getPositionAtStep(startstep).distance(Sprinter->getPositionAtStep(endstep)));
+      Force->Matrix[0][_atom->getNr()][5+i] += 2.*constant*sqrt(_atom->getPositionAtStep(startstep).distance(Sprinter->getPositionAtStep(endstep)));
   }
   DoLog(1) && (Log() << Verbose(1) << "done." << endl);
@@ -520,5 +520,5 @@
     PermutationMap = new atom *[getAtomCount()];
     for(internal_iterator iter = atoms.begin(); iter != atoms.end();++iter){
-      PermutationMap[(*iter)->ParticleInfo_nr] = (*iter);
+      PermutationMap[(*iter)->getNr()] = (*iter);
     }
   }
@@ -540,5 +540,5 @@
       Sprinter = mol->AddCopyAtom((*iter));
       // add to Trajectories
-      Vector temp = (*iter)->getPositionAtStep(startstep) + (PermutationMap[(*iter)->ParticleInfo_nr]->getPositionAtStep(endstep) - (*iter)->getPositionAtStep(startstep))*((double)step/(double)MaxSteps);
+      Vector temp = (*iter)->getPositionAtStep(startstep) + (PermutationMap[(*iter)->getNr()]->getPositionAtStep(endstep) - (*iter)->getPositionAtStep(startstep))*((double)step/(double)MaxSteps);
       Sprinter->setPosition(temp);
       (*iter)->setAtomicVelocityAtStep(step, zeroVec);
@@ -618,5 +618,5 @@
   // check size of vectors
   BOOST_FOREACH(atom *_atom, atoms) {
-    _atom->VelocityVerletUpdate(_atom->ParticleInfo_nr, MDSteps+1, &configuration, &Force, (const size_t) 0);
+    _atom->VelocityVerletUpdate(_atom->getNr(), MDSteps+1, &configuration, &Force, (const size_t) 0);
   }
 
Index: src/molecule_fragmentation.cpp
===================================================================
--- src/molecule_fragmentation.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/molecule_fragmentation.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -425,10 +425,10 @@
     No = (*runner).second.first;
     Walker = mol->FindAtom(No);
-    //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->ParticleInfo_nr]) {
+    //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->getNr()]) {
       DoLog(2) && (Log() << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl);
       AtomMask[No] = true;
       status = true;
     //} else
-      //Log() << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->ParticleInfo_nr] << " does not allow further adaptive increase." << endl;
+      //Log() << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->getNr()] << " does not allow further adaptive increase." << endl;
   }
   return status;
@@ -488,5 +488,5 @@
     #endif
         {
-          AtomMask[(*iter)->ParticleInfo_nr] = true;  // include all (non-hydrogen) atoms
+          AtomMask[(*iter)->getNr()] = true;  // include all (non-hydrogen) atoms
           status = true;
         }
@@ -508,6 +508,6 @@
   #endif
       {
-        AtomMask[(*iter)->ParticleInfo_nr] = true;  // include all (non-hydrogen) atoms
-        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->ParticleInfo_nr]))
+        AtomMask[(*iter)->getNr()] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->getNr()]))
           status = true;
       }
@@ -546,6 +546,6 @@
   int AtomNo = 0;
   for(internal_iterator iter=atoms.begin();iter!=atoms.end();++iter){
-    ASSERT(SortIndex[(*iter)->ParticleInfo_nr]==-1,"Same SortIndex set twice");
-    SortIndex[(*iter)->ParticleInfo_nr] = AtomNo++;
+    ASSERT(SortIndex[(*iter)->getNr()]==-1,"Same SortIndex set twice");
+    SortIndex[(*iter)->getNr()] = AtomNo++;
   }
 
@@ -575,5 +575,5 @@
   if (count == 0) {
     for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::ParticleInfo_nr -> atom) used as a marker table lateron
-      count = (count < (*iter)->GetTrueFather()->ParticleInfo_nr) ? (*iter)->GetTrueFather()->ParticleInfo_nr : count;
+      count = (count < (*iter)->GetTrueFather()->getNr()) ? (*iter)->GetTrueFather()->getNr() : count;
     }
   }
@@ -593,5 +593,5 @@
       LookupTable[i] = NULL;
     for (molecule::iterator iter = begin(); iter != end(); ++iter) {
-      AtomNo = (*iter)->GetTrueFather()->ParticleInfo_nr;
+      AtomNo = (*iter)->GetTrueFather()->getNr();
       if ((AtomNo >= 0) && (AtomNo < count)) {
         //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
@@ -917,9 +917,9 @@
     // set atom values
     for(internal_iterator iter=atoms.begin();iter!=atoms.end();++iter){
-      (*iter)->AdaptiveOrder = OrderArray[(*iter)->ParticleInfo_nr];
-      (*iter)->MaxOrder = MaxArray[(*iter)->ParticleInfo_nr];
-    }
-    //SetAtomValueToIndexedArray( OrderArray, &atom::ParticleInfo_nr, &atom::AdaptiveOrder );
-    //SetAtomValueToIndexedArray( MaxArray, &atom::ParticleInfo_nr, &atom::MaxOrder );
+      (*iter)->AdaptiveOrder = OrderArray[(*iter)->getNr()];
+      (*iter)->MaxOrder = MaxArray[(*iter)->getNr()];
+    }
+    //SetAtomValueToIndexedArray( OrderArray, &atom::getNr(), &atom::AdaptiveOrder );
+    //SetAtomValueToIndexedArray( MaxArray, &atom::getNr(), &atom::MaxOrder );
 
     DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
@@ -981,5 +981,5 @@
   for(KeySet::iterator runner = Leaflet.begin(); runner != Leaflet.end(); runner++) {
     FatherOfRunner = mol->FindAtom((*runner));  // find the id
-    SonList[FatherOfRunner->ParticleInfo_nr] = Leaf->AddCopyAtom(FatherOfRunner);
+    SonList[FatherOfRunner->getNr()] = Leaf->AddCopyAtom(FatherOfRunner);
     size++;
   }
@@ -1008,5 +1008,5 @@
     FatherOfRunner = (*iter)->father;
     ASSERT(FatherOfRunner,"Atom without father found");
-    if (SonList[FatherOfRunner->ParticleInfo_nr] != NULL)  {  // check if this, our father, is present in list
+    if (SonList[FatherOfRunner->getNr()] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
       const BondList& ListOfBonds = FatherOfRunner->getListOfBonds();
@@ -1015,13 +1015,13 @@
           ++BondRunner) {
         OtherFather = (*BondRunner)->GetOtherAtom(FatherOfRunner);
-//        Log() << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->ParticleInfo_nr] << " is bound to " << *OtherFather;
-        if (SonList[OtherFather->ParticleInfo_nr] != NULL) {
-//          Log() << Verbose(0) << ", whose son is " << *SonList[OtherFather->ParticleInfo_nr] << "." << endl;
-          if (OtherFather->ParticleInfo_nr > FatherOfRunner->ParticleInfo_nr) { // add bond (ParticleInfo_nr check is for adding only one of both variants: ab, ba)
+//        Log() << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()] << " is bound to " << *OtherFather;
+        if (SonList[OtherFather->getNr()] != NULL) {
+//          Log() << Verbose(0) << ", whose son is " << *SonList[OtherFather->getNr()] << "." << endl;
+          if (OtherFather->getNr() > FatherOfRunner->getNr()) { // add bond (ParticleInfo_nr check is for adding only one of both variants: ab, ba)
 //            Log() << Verbose(3) << "Adding Bond: ";
 //            Log() << Verbose(0) <<
-            Leaf->AddBond((*iter), SonList[OtherFather->ParticleInfo_nr], (*BondRunner)->BondDegree);
+            Leaf->AddBond((*iter), SonList[OtherFather->getNr()], (*BondRunner)->BondDegree);
 //            Log() << Verbose(0) << "." << endl;
-            //NumBonds[(*iter)->ParticleInfo_nr]++;
+            //NumBonds[(*iter)->getNr()]++;
           } else {
 //            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
@@ -1035,9 +1035,9 @@
             exit(1);
 #endif
-          //NumBonds[(*iter)->ParticleInfo_nr] += Binder->BondDegree;
+          //NumBonds[(*iter)->getNr()] += Binder->BondDegree;
         }
       }
     } else {
-    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->ParticleInfo_nr] << "!" << endl);
+    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->getNr()] << "!" << endl);
     }
     if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
@@ -1121,8 +1121,8 @@
       OtherWalker = BondsSet[j]->rightatom;  // rightatom is always the one more distant, i.e. the one to add
       //Log() << Verbose(1+verbosity) << "Current Bond is " << BondsSet[j] << ", checking on " << *OtherWalker << "." << endl;
-      Log() << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->ParticleInfo_nr << "." << endl;
-      TestKeySetInsert = FragmentSet->insert(OtherWalker->ParticleInfo_nr);
+      Log() << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->getNr() << "." << endl;
+      TestKeySetInsert = FragmentSet->insert(OtherWalker->getNr());
       if (TestKeySetInsert.second) {
-        TouchedList[TouchedIndex++] = OtherWalker->ParticleInfo_nr;  // note as added
+        TouchedList[TouchedIndex++] = OtherWalker->getNr();  // note as added
         Added++;
       } else {
@@ -1172,5 +1172,5 @@
       ++Binder) {
     for (int k=0;k<TouchedIndex;k++) {
-      if ((*Binder)->leftatom->ParticleInfo_nr == TouchedList[k])   // leftatom is always the closer one
+      if ((*Binder)->leftatom->getNr() == TouchedList[k])   // leftatom is always the closer one
         BondsList[SetDimension++] = (*Binder);
     }
@@ -1330,5 +1330,5 @@
 {
   // prepare Label and SP arrays of the BFS search
-  FragmentSearch.ShortestPathList[FragmentSearch.Root->ParticleInfo_nr] = 0;
+  FragmentSearch.ShortestPathList[FragmentSearch.Root->getNr()] = 0;
 
   // prepare root level (SP = 0) and a loop bond denoting Root
@@ -1354,7 +1354,7 @@
         iter != FragmentSearch.BondsPerSPList[i].end();
         ++iter) {
-      // Log() << Verbose(0) << "Removing atom " << Binder->leftatom->ParticleInfo_nr << " and " << Binder->rightatom->ParticleInfo_nr << "." << endl; // make sure numbers are local
-      FragmentSearch.ShortestPathList[(*iter)->leftatom->ParticleInfo_nr] = -1;
-      FragmentSearch.ShortestPathList[(*iter)->rightatom->ParticleInfo_nr] = -1;
+      // Log() << Verbose(0) << "Removing atom " << Binder->leftatom->getNr() << " and " << Binder->rightatom->getNr() << "." << endl; // make sure numbers are local
+      FragmentSearch.ShortestPathList[(*iter)->leftatom->getNr()] = -1;
+      FragmentSearch.ShortestPathList[(*iter)->rightatom->getNr()] = -1;
     }
     // delete added bonds
@@ -1391,5 +1391,5 @@
   atom *Predecessor = NULL;
   bond *Binder = NULL;
-  int RootKeyNr = FragmentSearch.Root->GetTrueFather()->ParticleInfo_nr;
+  int RootKeyNr = FragmentSearch.Root->GetTrueFather()->getNr();
   int RemainingWalkers = -1;
   int SP = -1;
@@ -1411,6 +1411,6 @@
       Walker = (*CurrentEdge)->rightatom;    // rightatom is always the one more distant
       Predecessor = (*CurrentEdge)->leftatom;    // ... and leftatom is predecessor
-      AtomKeyNr = Walker->ParticleInfo_nr;
-      DoLog(0) && (Log() << Verbose(0) << "Current Walker is: " << *Walker << " with nr " << Walker->ParticleInfo_nr << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level." << endl);
+      AtomKeyNr = Walker->getNr();
+      DoLog(0) && (Log() << Verbose(0) << "Current Walker is: " << *Walker << " with nr " << Walker->getNr() << " and SP of " << SP << ", with " << RemainingWalkers << " remaining walkers on this level." << endl);
       // check for new sp level
       // go through all its bonds
@@ -1421,14 +1421,14 @@
           ++Runner) {
         OtherWalker = (*Runner)->GetOtherAtom(Walker);
-        if ((RestrictedKeySet.find(OtherWalker->ParticleInfo_nr) != RestrictedKeySet.end())
+        if ((RestrictedKeySet.find(OtherWalker->getNr()) != RestrictedKeySet.end())
   #ifdef ADDHYDROGEN
          && (OtherWalker->getType()->getAtomicNumber() != 1)
   #endif
                                                               ) {  // skip hydrogens and restrict to fragment
-          DoLog(2) && (Log() << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->ParticleInfo_nr << " in bond " << *(*Runner) << "." << endl);
+          DoLog(2) && (Log() << Verbose(2) << "Current partner is " << *OtherWalker << " with nr " << OtherWalker->getNr() << " in bond " << *(*Runner) << "." << endl);
           // set the label if not set (and push on root stack as well)
-          if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->ParticleInfo_nr > RootKeyNr)) { // only pass through those with label bigger than Root's
-            FragmentSearch.ShortestPathList[OtherWalker->ParticleInfo_nr] = SP+1;
-            DoLog(3) && (Log() << Verbose(3) << "Set Shortest Path to " << FragmentSearch.ShortestPathList[OtherWalker->ParticleInfo_nr] << "." << endl);
+          if ((OtherWalker != Predecessor) && (OtherWalker->GetTrueFather()->getNr() > RootKeyNr)) { // only pass through those with label bigger than Root's
+            FragmentSearch.ShortestPathList[OtherWalker->getNr()] = SP+1;
+            DoLog(3) && (Log() << Verbose(3) << "Set Shortest Path to " << FragmentSearch.ShortestPathList[OtherWalker->getNr()] << "." << endl);
             // add the bond in between to the SP list
             Binder = new bond(Walker, OtherWalker); // create a new bond in such a manner, that bond::rightatom is always the one more distant
@@ -1438,5 +1438,5 @@
           } else {
             if (OtherWalker != Predecessor)
-              DoLog(3) && (Log() << Verbose(3) << "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->ParticleInfo_nr << " is smaller than that of Root " << RootKeyNr << "." << endl);
+              DoLog(3) && (Log() << Verbose(3) << "Not passing on, as index of " << *OtherWalker << " " << OtherWalker->GetTrueFather()->getNr() << " is smaller than that of Root " << RootKeyNr << "." << endl);
             else
               DoLog(3) && (Log() << Verbose(3) << "This is my predecessor " << *Predecessor << "." << endl);
@@ -1519,5 +1519,5 @@
   if (SP >= (Order-1)) {
     // start with root (push on fragment stack)
-    DoLog(0) && (Log() << Verbose(0) << "Starting fragment generation with " << *FragmentSearch.Root << ", local nr is " << FragmentSearch.Root->ParticleInfo_nr << "." << endl);
+    DoLog(0) && (Log() << Verbose(0) << "Starting fragment generation with " << *FragmentSearch.Root << ", local nr is " << FragmentSearch.Root->getNr() << "." << endl);
     FragmentSearch.FragmentSet->clear();
     DoLog(0) && (Log() << Verbose(0) << "Preparing subset for this root and calling generator." << endl);
@@ -1538,5 +1538,5 @@
   // remove root from stack
   DoLog(0) && (Log() << Verbose(0) << "Removing root again from stack." << endl);
-  FragmentSearch.FragmentSet->erase(FragmentSearch.Root->ParticleInfo_nr);
+  FragmentSearch.FragmentSet->erase(FragmentSearch.Root->getNr());
 
   // free'ing the bonds lists
@@ -1609,5 +1609,5 @@
       }
     }
-    RootStack.push_back(Walker->ParticleInfo_nr);
+    RootStack.push_back(Walker->getNr());
     RootNr++;
   } while (RootKeyNr != StartNr);
@@ -1700,5 +1700,5 @@
   KeySet CompleteMolecule;
   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    CompleteMolecule.insert((*iter)->GetTrueFather()->ParticleInfo_nr);
+    CompleteMolecule.insert((*iter)->GetTrueFather()->getNr());
   }
 
@@ -1713,5 +1713,5 @@
     atom *Walker = FindAtom(RootKeyNr);
     // check cyclic lengths
-    //if ((MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr])) {
+    //if ((MinimumRingSize[Walker->GetTrueFather()->getNr()] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->getNr()])) {
     //  Log() << Verbose(0) << "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed." << endl;
     //} else
@@ -1849,5 +1849,5 @@
         AtomStack->pop_front();
         //Log() << Verbose (3) << "Current Walker is: " << *Walker << "." << endl;
-        ColorList[Walker->ParticleInfo_nr] = black;    // mark as explored
+        ColorList[Walker->getNr()] = black;    // mark as explored
         *Walker += Translationvector; // translate
         const BondList& ListOfBonds = Walker->getListOfBonds();
@@ -1857,5 +1857,5 @@
           if ((*Runner) != Binder) {
             OtherWalker = (*Runner)->GetOtherAtom(Walker);
-            if (ColorList[OtherWalker->ParticleInfo_nr] == white) {
+            if (ColorList[OtherWalker->getNr()] == white) {
               AtomStack->push_front(OtherWalker); // push if yet unexplored
             }
Index: src/molecule_geometry.cpp
===================================================================
--- src/molecule_geometry.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/molecule_geometry.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -388,5 +388,5 @@
             Runner != ListOfBonds.end();
             ++Runner) {
-         if ((*iter)->ParticleInfo_nr < (*Runner)->GetOtherAtom((*iter))->ParticleInfo_nr) // otherwise we shift one to, the other fro and gain nothing
+         if ((*iter)->getNr() < (*Runner)->GetOtherAtom((*iter))->getNr()) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
               tmp = (*iter)->at(j) - (*Runner)->GetOtherAtom(*iter)->at(j);
Index: src/molecule_graph.cpp
===================================================================
--- src/molecule_graph.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/molecule_graph.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -194,5 +194,5 @@
                       Log() << Verbose(2) << "Current relative cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << " containing " << List->size() << " points." << endl;
                       for (TesselPointSTLList::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
-                        if ((*OtherRunner)->ParticleInfo_nr > Walker->ParticleInfo_nr) {
+                        if ((*OtherRunner)->getNr() > Walker->getNr()) {
                           OtherWalker = dynamic_cast<atom*>(*OtherRunner);
                           ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
@@ -202,5 +202,5 @@
                           const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
                           Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
-                          if (OtherWalker->father->ParticleInfo_nr > Walker->father->ParticleInfo_nr) {
+                          if (OtherWalker->father->getNr() > Walker->father->getNr()) {
                             if (status) { // create bond if distance is smaller
                               Log() << Verbose(1) << "Adding Bond between " << *Walker << " and " << *OtherWalker << " in distance " << sqrt(distance) << "." << endl;
@@ -740,7 +740,7 @@
     Walker = BFS.TouchedStack->front();
     BFS.TouchedStack->pop_front();
-    BFS.PredecessorList[Walker->ParticleInfo_nr] = NULL;
-    BFS.ShortestPathList[Walker->ParticleInfo_nr] = -1;
-    BFS.ColorList[Walker->ParticleInfo_nr] = white;
+    BFS.PredecessorList[Walker->getNr()] = NULL;
+    BFS.ShortestPathList[Walker->getNr()] = -1;
+    BFS.ColorList[Walker->getNr()] = white;
   }
 };
@@ -752,5 +752,5 @@
 void ResetBFSAccounting(atom *&Walker, struct BFSAccounting &BFS)
 {
-  BFS.ShortestPathList[Walker->ParticleInfo_nr] = 0;
+  BFS.ShortestPathList[Walker->getNr()] = 0;
   BFS.BFSStack->clear(); // start with empty BFS stack
   BFS.BFSStack->push_front(Walker);
@@ -781,11 +781,11 @@
 #endif
         DoLog(2) && (Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->getName() << " for bond " << *(*Runner) << "." << endl);
-        if (BFS.ColorList[OtherAtom->ParticleInfo_nr] == white) {
+        if (BFS.ColorList[OtherAtom->getNr()] == white) {
           BFS.TouchedStack->push_front(OtherAtom);
-          BFS.ColorList[OtherAtom->ParticleInfo_nr] = lightgray;
-          BFS.PredecessorList[OtherAtom->ParticleInfo_nr] = Walker; // Walker is the predecessor
-          BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] = BFS.ShortestPathList[Walker->ParticleInfo_nr] + 1;
-          DoLog(2) && (Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->getName() << " lightgray, its predecessor is " << Walker->getName() << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] << " egde(s) long." << endl);
-          //if (BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
+          BFS.ColorList[OtherAtom->getNr()] = lightgray;
+          BFS.PredecessorList[OtherAtom->getNr()] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->getNr()] = BFS.ShortestPathList[Walker->getNr()] + 1;
+          DoLog(2) && (Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->getName() << " lightgray, its predecessor is " << Walker->getName() << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->getNr()] << " egde(s) long." << endl);
+          //if (BFS.ShortestPathList[OtherAtom->getNr()] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
           DoLog(3) && (Log() << Verbose(3) << "Putting OtherAtom into queue." << endl);
           BFS.BFSStack->push_front(OtherAtom);
@@ -799,5 +799,5 @@
       } else {
         DoLog(2) && (Log() << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl);
-        BFS.ColorList[OtherAtom->ParticleInfo_nr] = black;
+        BFS.ColorList[OtherAtom->getNr()] = black;
       }
 #endif
@@ -806,5 +806,5 @@
       }
     }
-    BFS.ColorList[Walker->ParticleInfo_nr] = black;
+    BFS.ColorList[Walker->getNr()] = black;
     DoLog(1) && (Log() << Verbose(1) << "Coloring Walker " << Walker->getName() << " black." << endl);
     if (OtherAtom == BFS.Root) { // if we have found the root, check whether this cycle wasn't already found beforehand
@@ -814,5 +814,5 @@
           break;
         else
-          OtherAtom = BFS.PredecessorList[OtherAtom->ParticleInfo_nr];
+          OtherAtom = BFS.PredecessorList[OtherAtom->getNr()];
       }
       if (OtherAtom == BackEdge->rightatom) { // if each atom in found cycle is cyclic, loop's been found before already
@@ -822,9 +822,9 @@
           OtherAtom = BFS.TouchedStack->front();
           BFS.TouchedStack->pop_front();
-          if (BFS.PredecessorList[OtherAtom->ParticleInfo_nr] == Walker) {
+          if (BFS.PredecessorList[OtherAtom->getNr()] == Walker) {
             DoLog(4) && (Log() << Verbose(4) << "Removing " << *OtherAtom << " from lists and stacks." << endl);
-            BFS.PredecessorList[OtherAtom->ParticleInfo_nr] = NULL;
-            BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] = -1;
-            BFS.ColorList[OtherAtom->ParticleInfo_nr] = white;
+            BFS.PredecessorList[OtherAtom->getNr()] = NULL;
+            BFS.ShortestPathList[OtherAtom->getNr()] = -1;
+            BFS.ColorList[OtherAtom->getNr()] = white;
             // rats ... deque has no find()
             std::deque<atom *>::iterator iter = find(
@@ -836,5 +836,5 @@
             BFS.BFSStack->erase(iter);
           }
-        } while ((!BFS.TouchedStack->empty()) && (BFS.PredecessorList[OtherAtom->ParticleInfo_nr] == NULL));
+        } while ((!BFS.TouchedStack->empty()) && (BFS.PredecessorList[OtherAtom->getNr()] == NULL));
         BFS.TouchedStack->push_front(OtherAtom); // last was wrongly popped
         OtherAtom = BackEdge->rightatom; // set to not Root
@@ -842,5 +842,5 @@
         OtherAtom = BFS.Root;
     }
-  } while ((!BFS.BFSStack->empty()) && (OtherAtom != BFS.Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->ParticleInfo_nr] < MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr])));
+  } while ((!BFS.BFSStack->empty()) && (OtherAtom != BFS.Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->getNr()] < MinimumRingSize[Walker->GetTrueFather()->getNr()])));
 };
 
@@ -867,5 +867,5 @@
     while (Walker != BackEdge->rightatom) {
       DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " <-> ");
-      Walker = BFS.PredecessorList[Walker->ParticleInfo_nr];
+      Walker = BFS.PredecessorList[Walker->getNr()];
       Walker->GetTrueFather()->IsCyclic = true;
       RingSize++;
@@ -874,14 +874,14 @@
     // walk through all and set MinimumRingSize
     Walker = BFS.Root;
-    MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr] = RingSize;
+    MinimumRingSize[Walker->GetTrueFather()->getNr()] = RingSize;
     while (Walker != BackEdge->rightatom) {
-      Walker = BFS.PredecessorList[Walker->ParticleInfo_nr];
-      if (RingSize < MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr])
-        MinimumRingSize[Walker->GetTrueFather()->ParticleInfo_nr] = RingSize;
+      Walker = BFS.PredecessorList[Walker->getNr()];
+      if (RingSize < MinimumRingSize[Walker->GetTrueFather()->getNr()])
+        MinimumRingSize[Walker->GetTrueFather()->getNr()] = RingSize;
     }
     if ((RingSize < MinRingSize) || (MinRingSize == -1))
       MinRingSize = RingSize;
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[BFS.Root->GetTrueFather()->ParticleInfo_nr] << " found." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[BFS.Root->GetTrueFather()->getNr()] << " found." << endl);
   }
 };
@@ -913,12 +913,12 @@
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
         //Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
-        if (BFS.ColorList[OtherAtom->ParticleInfo_nr] == white) {
+        if (BFS.ColorList[OtherAtom->getNr()] == white) {
           BFS.TouchedStack->push_front(OtherAtom);
-          BFS.ColorList[OtherAtom->ParticleInfo_nr] = lightgray;
-          BFS.PredecessorList[OtherAtom->ParticleInfo_nr] = Walker; // Walker is the predecessor
-          BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] = BFS.ShortestPathList[Walker->ParticleInfo_nr] + 1;
-          //Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->ParticleInfo_nr] << " egde(s) long." << endl;
+          BFS.ColorList[OtherAtom->getNr()] = lightgray;
+          BFS.PredecessorList[OtherAtom->getNr()] = Walker; // Walker is the predecessor
+          BFS.ShortestPathList[OtherAtom->getNr()] = BFS.ShortestPathList[Walker->getNr()] + 1;
+          //Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->getNr()] << " egde(s) long." << endl;
           if (OtherAtom->GetTrueFather()->IsCyclic) { // if the other atom is connected to a ring
-            MinimumRingSize[Root->GetTrueFather()->ParticleInfo_nr] = BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] + MinimumRingSize[OtherAtom->GetTrueFather()->ParticleInfo_nr];
+            MinimumRingSize[Root->GetTrueFather()->getNr()] = BFS.ShortestPathList[OtherAtom->getNr()] + MinimumRingSize[OtherAtom->GetTrueFather()->getNr()];
             OtherAtom = NULL; //break;
             break;
@@ -932,5 +932,5 @@
       }
     }
-    BFS.ColorList[Walker->ParticleInfo_nr] = black;
+    BFS.ColorList[Walker->getNr()] = black;
     //Log() << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
@@ -956,5 +956,5 @@
       Root = *iter;
 
-      if (MinimumRingSize[Root->GetTrueFather()->ParticleInfo_nr] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
+      if (MinimumRingSize[Root->GetTrueFather()->getNr()] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
 
@@ -963,5 +963,5 @@
 
       }
-      DoLog(1) && (Log() << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->ParticleInfo_nr] << "." << endl);
+      DoLog(1) && (Log() << Verbose(1) << "Minimum ring size of " << *Root << " is " << MinimumRingSize[Root->GetTrueFather()->getNr()] << "." << endl);
     }
     DoLog(1) && (Log() << Verbose(1) << "Minimum ring size is " << MinRingSize << ", over " << NumCycles << " cycles total." << endl);
@@ -1194,5 +1194,5 @@
         Runner != ListOfBonds.end();
         ++Runner) {
-      id = (*Runner)->GetOtherAtom(Walker)->ParticleInfo_nr;
+      id = (*Runner)->GetOtherAtom(Walker)->getNr();
       j = 0;
       for (; (j < CurrentBondsOfAtom) && (CurrentBonds[j++] != id);)
@@ -1292,5 +1292,5 @@
 
   do { // go through all bonds and push local ones
-    Walker = ListOfLocalAtoms[Binder->leftatom->ParticleInfo_nr]; // get one atom in the reference molecule
+    Walker = ListOfLocalAtoms[Binder->leftatom->getNr()]; // get one atom in the reference molecule
     if (Walker != NULL) { // if this Walker exists in the subgraph ...
       const BondList& ListOfBonds = Walker->getListOfBonds();
@@ -1299,5 +1299,5 @@
           ++Runner) {
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
-        if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->ParticleInfo_nr]) { // found the bond
+        if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->getNr()]) { // found the bond
           LocalStack->push_front((*Runner));
           DoLog(3) && (Log() << Verbose(3) << "Found local edge " << *(*Runner) << "." << endl);
@@ -1339,5 +1339,5 @@
       BFS.ColorList[i] = white;
   }
-  //BFS.ShortestPathList[Root->ParticleInfo_nr] = 0; // done by Calloc
+  //BFS.ShortestPathList[Root->getNr()] = 0; // done by Calloc
 }
 ;
@@ -1356,19 +1356,19 @@
 {
   if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
-    BFS.ColorList[OtherAtom->ParticleInfo_nr] = lightgray;
-  BFS.PredecessorList[OtherAtom->ParticleInfo_nr] = Walker; // Walker is the predecessor
-  BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] = BFS.ShortestPathList[Walker->ParticleInfo_nr] + 1;
-  DoLog(2) && (Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->getName() << " " << ((BFS.ColorList[OtherAtom->ParticleInfo_nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->getName() << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] << " egde(s) long." << endl);
-  if ((((BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] < BFS.BondOrder) && (Binder != Bond)))) { // Check for maximum distance
+    BFS.ColorList[OtherAtom->getNr()] = lightgray;
+  BFS.PredecessorList[OtherAtom->getNr()] = Walker; // Walker is the predecessor
+  BFS.ShortestPathList[OtherAtom->getNr()] = BFS.ShortestPathList[Walker->getNr()] + 1;
+  DoLog(2) && (Log() << Verbose(2) << "Coloring OtherAtom " << OtherAtom->getName() << " " << ((BFS.ColorList[OtherAtom->getNr()] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->getName() << " and its Shortest Path is " << BFS.ShortestPathList[OtherAtom->getNr()] << " egde(s) long." << endl);
+  if ((((BFS.ShortestPathList[OtherAtom->getNr()] < BFS.BondOrder) && (Binder != Bond)))) { // Check for maximum distance
     DoLog(3) && (Log() << Verbose(3));
-    if (AddedAtomList[OtherAtom->ParticleInfo_nr] == NULL) { // add if it's not been so far
-      AddedAtomList[OtherAtom->ParticleInfo_nr] = Mol->AddCopyAtom(OtherAtom);
+    if (AddedAtomList[OtherAtom->getNr()] == NULL) { // add if it's not been so far
+      AddedAtomList[OtherAtom->getNr()] = Mol->AddCopyAtom(OtherAtom);
       DoLog(0) && (Log() << Verbose(0) << "Added OtherAtom " << OtherAtom->getName());
-      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->ParticleInfo_nr], AddedAtomList[OtherAtom->ParticleInfo_nr], Binder);
+      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
       DoLog(0) && (Log() << Verbose(0) << " and bond " << *(AddedBondList[Binder->nr]) << ", ");
     } else { // this code should actually never come into play (all white atoms are not yet present in BondMolecule, that's why they are white in the first place)
       DoLog(0) && (Log() << Verbose(0) << "Not adding OtherAtom " << OtherAtom->getName());
       if (AddedBondList[Binder->nr] == NULL) {
-        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->ParticleInfo_nr], AddedAtomList[OtherAtom->ParticleInfo_nr], Binder);
+        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
         DoLog(0) && (Log() << Verbose(0) << ", added Bond " << *(AddedBondList[Binder->nr]));
       } else
@@ -1378,18 +1378,18 @@
     BFS.BFSStack->push_front(OtherAtom);
   } else { // out of bond order, then replace
-    if ((AddedAtomList[OtherAtom->ParticleInfo_nr] == NULL) && (Binder->Cyclic))
-      BFS.ColorList[OtherAtom->ParticleInfo_nr] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
+    if ((AddedAtomList[OtherAtom->getNr()] == NULL) && (Binder->Cyclic))
+      BFS.ColorList[OtherAtom->getNr()] = white; // unmark if it has not been queued/added, to make it available via its other bonds (cyclic)
     if (Binder == Bond)
       DoLog(3) && (Log() << Verbose(3) << "Not Queueing, is the Root bond");
-    else if (BFS.ShortestPathList[OtherAtom->ParticleInfo_nr] >= BFS.BondOrder)
+    else if (BFS.ShortestPathList[OtherAtom->getNr()] >= BFS.BondOrder)
       DoLog(3) && (Log() << Verbose(3) << "Not Queueing, is out of Bond Count of " << BFS.BondOrder);
     if (!Binder->Cyclic)
       DoLog(0) && (Log() << Verbose(0) << ", is not part of a cyclic bond, saturating bond with Hydrogen." << endl);
     if (AddedBondList[Binder->nr] == NULL) {
-      if ((AddedAtomList[OtherAtom->ParticleInfo_nr] != NULL)) { // .. whether we add or saturate
-        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->ParticleInfo_nr], AddedAtomList[OtherAtom->ParticleInfo_nr], Binder);
+      if ((AddedAtomList[OtherAtom->getNr()] != NULL)) { // .. whether we add or saturate
+        AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
       } else {
 #ifdef ADDHYDROGEN
-        if (!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->ParticleInfo_nr], Walker, OtherAtom, IsAngstroem))
+        if (!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
         exit(1);
 #endif
@@ -1405,9 +1405,9 @@
   // This has to be a cyclic bond, check whether it's present ...
   if (AddedBondList[Binder->nr] == NULL) {
-    if ((Binder != Bond) && (Binder->Cyclic) && (((BFS.ShortestPathList[Walker->ParticleInfo_nr] + 1) < BFS.BondOrder))) {
-      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->ParticleInfo_nr], AddedAtomList[OtherAtom->ParticleInfo_nr], Binder);
+    if ((Binder != Bond) && (Binder->Cyclic) && (((BFS.ShortestPathList[Walker->getNr()] + 1) < BFS.BondOrder))) {
+      AddedBondList[Binder->nr] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
     } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
 #ifdef ADDHYDROGEN
-      if(!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->ParticleInfo_nr], Walker, OtherAtom, IsAngstroem))
+      if(!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
       exit(1);
 #endif
@@ -1435,6 +1435,6 @@
 
   // add Root if not done yet
-  if (AddedAtomList[Root->ParticleInfo_nr] == NULL) // add Root if not yet present
-    AddedAtomList[Root->ParticleInfo_nr] = Mol->AddCopyAtom(Root);
+  if (AddedAtomList[Root->getNr()] == NULL) // add Root if not yet present
+    AddedAtomList[Root->getNr()] = Mol->AddCopyAtom(Root);
 
   BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
@@ -1457,5 +1457,5 @@
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
         DoLog(2) && (Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->getName() << " for bond " << *(*Runner) << "." << endl);
-        if (BFS.ColorList[OtherAtom->ParticleInfo_nr] == white) {
+        if (BFS.ColorList[OtherAtom->getNr()] == white) {
           BreadthFirstSearchAdd_UnvisitedNode(Mol, BFS, Walker, OtherAtom, Binder, Bond, AddedAtomList, AddedBondList, IsAngstroem);
         } else {
@@ -1464,5 +1464,5 @@
       }
     }
-    BFS.ColorList[Walker->ParticleInfo_nr] = black;
+    BFS.ColorList[Walker->getNr()] = black;
     DoLog(1) && (Log() << Verbose(1) << "Coloring Walker " << Walker->getName() << " black." << endl);
   }
@@ -1501,7 +1501,7 @@
   DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
-    ParentList[(*iter)->father->ParticleInfo_nr] = (*iter);
+    ParentList[(*iter)->father->getNr()] = (*iter);
     // Outputting List for debugging
-    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->ParticleInfo_nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->ParticleInfo_nr] << "." << endl);
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->getNr() << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->getNr()] << "." << endl);
   }
 };
@@ -1520,6 +1520,6 @@
   DoLog(3) && (Log() << Verbose(3) << "Creating bonds." << endl);
   for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
-    if (ParentList[(*iter)->ParticleInfo_nr] != NULL) {
-      if (ParentList[(*iter)->ParticleInfo_nr]->father != (*iter)) {
+    if (ParentList[(*iter)->getNr()] != NULL) {
+      if (ParentList[(*iter)->getNr()]->father != (*iter)) {
         status = false;
       } else {
@@ -1529,7 +1529,7 @@
             ++Runner) {
           OtherAtom = (*Runner)->GetOtherAtom((*iter));
-          if (ParentList[OtherAtom->ParticleInfo_nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
-            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->ParticleInfo_nr]->getName() << " and " << ParentList[OtherAtom->ParticleInfo_nr]->getName() << "." << endl);
-            mol->AddBond(ParentList[(*iter)->ParticleInfo_nr], ParentList[OtherAtom->ParticleInfo_nr], (*Runner)->BondDegree);
+          if (ParentList[OtherAtom->getNr()] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
+            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->getNr()]->getName() << " and " << ParentList[OtherAtom->getNr()]->getName() << "." << endl);
+            mol->AddBond(ParentList[(*iter)->getNr()], ParentList[OtherAtom->getNr()], (*Runner)->BondDegree);
           }
         }
Index: src/moleculelist.cpp
===================================================================
--- src/moleculelist.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/moleculelist.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -140,9 +140,9 @@
           aList[Counter] = Count + (aCounter++);
         else
-          aList[Counter] = (*aiter)->GetTrueFather()->ParticleInfo_nr;
+          aList[Counter] = (*aiter)->GetTrueFather()->getNr();
         if ((*biter)->GetTrueFather() == NULL)
           bList[Counter] = Count + (bCounter++);
         else
-          bList[Counter] = (*biter)->GetTrueFather()->ParticleInfo_nr;
+          bList[Counter] = (*biter)->GetTrueFather()->getNr();
         Counter++;
       }
@@ -367,5 +367,5 @@
           // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
           Binder = *((*runner)->getListOfBonds().begin());
-          if (((*runner)->getType()->getAtomicNumber() == 1) && ((*runner)->ParticleInfo_nr > (*iter)->ParticleInfo_nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
+          if (((*runner)->getType()->getAtomicNumber() == 1) && ((*runner)->getNr() > (*iter)->getNr()) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
             distance = (*runner)->distance(*(*iter));
@@ -462,5 +462,5 @@
               if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
-                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->ParticleInfo_nr] << "\t";
+                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->getNr()] << "\t";
               } else
                 // otherwise a -1 to indicate an added saturation hydrogen
@@ -808,15 +808,15 @@
     for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
       Father = (*iter)->GetTrueFather();
-      AtomNo = Father->ParticleInfo_nr; // global id of the current walker
+      AtomNo = Father->getNr(); // global id of the current walker
       const BondList& ListOfBonds = Father->getListOfBonds();
       for (BondList::const_iterator Runner = ListOfBonds.begin();
           Runner != ListOfBonds.end();
           ++Runner) {
-        OtherWalker = ListOfLocalAtoms[(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->ParticleInfo_nr]; // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->getNr()]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
-          if (OtherWalker->ParticleInfo_nr > (*iter)->ParticleInfo_nr)
+          if (OtherWalker->getNr() > (*iter)->getNr())
             Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
         } else {
-          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->ParticleInfo_nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->getNr() << "] is NULL!" << endl);
           status = false;
         }
@@ -851,9 +851,9 @@
       for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
         Father = (*iter)->GetTrueFather();
-        if (AtomMask[Father->ParticleInfo_nr]) // apply mask
+        if (AtomMask[Father->getNr()]) // apply mask
 #ifdef ADDHYDROGEN
           if ((*iter)->getType()->getAtomicNumber() != 1) // skip hydrogen
 #endif
-          RootStack[FragmentCounter].push_front((*iter)->ParticleInfo_nr);
+          RootStack[FragmentCounter].push_front((*iter)->getNr());
       }
       if (next != NULL)
@@ -928,8 +928,8 @@
     KeySet *TempSet = new KeySet;
     for (Graph::iterator runner = KeySetList->begin(); runner != KeySetList->end(); runner++) { // key sets contain global numbers!
-      if (ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->ParticleInfo_nr] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
+      if (ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->getNr()] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
         // translate keyset to local numbers
         for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
-          TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->ParticleInfo_nr]->ParticleInfo_nr);
+          TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->getNr()]->getNr());
         // insert into FragmentList
         FragmentList[FragmentCounter]->insert(GraphPair(*TempSet, pair<int, double> (KeySetCounter++, (*runner).second.second)));
@@ -972,5 +972,5 @@
     for (Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
       for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
-        TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->ParticleInfo_nr);
+        TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->getNr());
       TotalGraph.insert(GraphPair(*TempSet, pair<int, double> (TotalNumberOfKeySets++, (*runner).second.second)));
       TempSet->clear();
Index: src/parser.cpp
===================================================================
--- src/parser.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/parser.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -760,5 +760,5 @@
       while (!zeile.eof()) {
         zeile >> nr;
-        //Log() << Verbose(0) << "Current index: " << ParticleInfo_nr << "." << endl;
+        //Log() << Verbose(0) << "Current index: " << getNr() << "." << endl;
         if (nr > RowCounter[MatrixCounter])
           RowCounter[MatrixCounter] = nr;
@@ -993,5 +993,5 @@
       while (!zeile.eof()) {
         zeile >> nr;
-        //Log() << Verbose(0) << "Current index: " << ParticleInfo_nr << "." << endl;
+        //Log() << Verbose(0) << "Current index: " << getNr() << "." << endl;
         if (nr > RowCounter[MatrixCounter]) {
           RowCounter[MatrixCounter] = nr;
Index: src/tesselation.cpp
===================================================================
--- src/tesselation.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/tesselation.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -536,5 +536,5 @@
   PointTestPair InsertUnique;
   BPS[n] = new class BoundaryPointSet(Walker);
-  InsertUnique = PointsOnBoundary.insert(PointPair(Walker->ParticleInfo_nr, BPS[n]));
+  InsertUnique = PointsOnBoundary.insert(PointPair(Walker->getNr(), BPS[n]));
   if (InsertUnique.second) { // if new point was not present before, increase counter
     PointsOnBoundaryCount++;
@@ -558,5 +558,5 @@
   PointTestPair InsertUnique;
   TPS[n] = new class BoundaryPointSet(Candidate);
-  InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->ParticleInfo_nr, TPS[n]));
+  InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->getNr(), TPS[n]));
   if (InsertUnique.second) { // if new point was not present before, increase counter
     PointsOnBoundaryCount++;
@@ -577,5 +577,5 @@
 {
   Info FunctionInfo(__func__);
-  PointMap::const_iterator FindPoint = PointsOnBoundary.find(Candidate->ParticleInfo_nr);
+  PointMap::const_iterator FindPoint = PointsOnBoundary.find(Candidate->getNr());
   if (FindPoint != PointsOnBoundary.end())
     TPS[n] = FindPoint->second;
@@ -597,5 +597,5 @@
 {
   bool insertNewLine = true;
-  LineMap::iterator FindLine = a->lines.find(b->node->ParticleInfo_nr);
+  LineMap::iterator FindLine = a->lines.find(b->node->getNr());
   BoundaryLineSet *WinningLine = NULL;
   if (FindLine != a->lines.end()) {
@@ -603,5 +603,5 @@
 
     pair<LineMap::iterator, LineMap::iterator> FindPair;
-    FindPair = a->lines.equal_range(b->node->ParticleInfo_nr);
+    FindPair = a->lines.equal_range(b->node->getNr());
 
     for (FindLine = FindPair.first; (FindLine != FindPair.second) && (insertNewLine); FindLine++) {
@@ -709,5 +709,5 @@
 /** Function adds triangle to global list.
  * Furthermore, the triangle number is set to \a ParticleInfo_nr.
- * \param ParticleInfo_nr triangle number
+ * \param getNr() triangle number
  */
 void Tesselation::AddTesselationTriangle(const int nr)
@@ -902,5 +902,5 @@
   // builds a triangle point set (Points) of the end points
   for (int i = 0; i < 3; i++) {
-    PointMap::const_iterator FindPoint = PointsOnBoundary.find(Candidates[i]->ParticleInfo_nr);
+    PointMap::const_iterator FindPoint = PointsOnBoundary.find(Candidates[i]->getNr());
     if (FindPoint != PointsOnBoundary.end()) {
       Points[i] = FindPoint->second;
@@ -915,6 +915,6 @@
       for (int j = i; j < 3; j++) {
         if (Points[j] != NULL) {
-          LineMap::const_iterator FindLine = Points[i]->lines.find(Points[j]->node->ParticleInfo_nr);
-          for (; (FindLine != Points[i]->lines.end()) && (FindLine->first == Points[j]->node->ParticleInfo_nr); FindLine++) {
+          LineMap::const_iterator FindLine = Points[i]->lines.find(Points[j]->node->getNr());
+          for (; (FindLine != Points[i]->lines.end()) && (FindLine->first == Points[j]->node->getNr()); FindLine++) {
             TriangleMap *triangles = &FindLine->second->triangles;
             DoLog(1) && (Log() << Verbose(1) << "Current line is " << FindLine->first << ": " << *(FindLine->second) << " with triangles " << triangles << "." << endl);
@@ -955,5 +955,5 @@
   // builds a triangle point set (Points) of the end points
   for (int i = 0; i < 3; i++) {
-    PointMap::iterator FindPoint = PointsOnBoundary.find(Candidates[i]->ParticleInfo_nr);
+    PointMap::iterator FindPoint = PointsOnBoundary.find(Candidates[i]->getNr());
     if (FindPoint != PointsOnBoundary.end()) {
       Points[i] = FindPoint->second;
@@ -968,6 +968,6 @@
       for (int j = i; j < 3; j++) {
         if (Points[j] != NULL) {
-          LineMap::iterator FindLine = Points[i]->lines.find(Points[j]->node->ParticleInfo_nr);
-          for (; (FindLine != Points[i]->lines.end()) && (FindLine->first == Points[j]->node->ParticleInfo_nr); FindLine++) {
+          LineMap::iterator FindLine = Points[i]->lines.find(Points[j]->node->getNr());
+          for (; (FindLine != Points[i]->lines.end()) && (FindLine->first == Points[j]->node->getNr()); FindLine++) {
             TriangleMap *triangles = &FindLine->second->triangles;
             for (TriangleMap::iterator FindTriangle = triangles->begin(); FindTriangle != triangles->end(); FindTriangle++) {
@@ -1145,8 +1145,8 @@
 //
 //  // check both other lines
-//  PointMap::const_iterator FindPoint = PointsOnBoundary.find(ThirdNode->ParticleInfo_nr);
+//  PointMap::const_iterator FindPoint = PointsOnBoundary.find(ThirdNode->getNr());
 //  if (FindPoint != PointsOnBoundary.end()) {
 //    for (int i=0;i<2;i++) {
-//      LineMap::const_iterator FindLine = (FindPoint->second)->lines.find(BaseRay->endpoints[0]->node->ParticleInfo_nr);
+//      LineMap::const_iterator FindLine = (FindPoint->second)->lines.find(BaseRay->endpoints[0]->node->getNr());
 //      if (FindLine != (FindPoint->second)->lines.end()) {
 //        Line = FindLine->second;
@@ -1440,5 +1440,5 @@
   Info FunctionInfo(__func__);
 
-  pair<LineMap::iterator, LineMap::iterator> FindPair = TPS[0]->lines.equal_range(TPS[2]->node->ParticleInfo_nr);
+  pair<LineMap::iterator, LineMap::iterator> FindPair = TPS[0]->lines.equal_range(TPS[2]->node->getNr());
   for (LineMap::const_iterator FindLine = FindPair.first; FindLine != FindPair.second; FindLine++) {
     DoLog(1) && (Log() << Verbose(1) << "INFO: Checking line " << *(FindLine->second) << " ..." << endl);
@@ -2223,5 +2223,5 @@
         if (List != NULL) {
           for (TesselPointSTLList::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
-            FindPoint = PointsOnBoundary.find((*Runner)->ParticleInfo_nr);
+            FindPoint = PointsOnBoundary.find((*Runner)->getNr());
             if (FindPoint != PointsOnBoundary.end()) {
               points->insert(DistanceToPointPair(FindPoint->second->node->DistanceSquared(x), FindPoint->second));
@@ -2557,5 +2557,5 @@
   bool takePoint = false;
   // find the respective boundary point
-  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->ParticleInfo_nr);
+  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->getNr());
   if (PointRunner != PointsOnBoundary.end()) {
     ReferencePoint = PointRunner->second;
@@ -2577,8 +2577,8 @@
     takePoint = false;
 
-    if (findLines->second->endpoints[0]->Nr == Point->ParticleInfo_nr) {
+    if (findLines->second->endpoints[0]->Nr == Point->getNr()) {
       takePoint = true;
       current = findLines->second->endpoints[1]->node;
-    } else if (findLines->second->endpoints[1]->Nr == Point->ParticleInfo_nr) {
+    } else if (findLines->second->endpoints[1]->Nr == Point->getNr()) {
       takePoint = true;
       current = findLines->second->endpoints[0]->node;
@@ -2813,5 +2813,5 @@
   class BoundaryLineSet *StartLine = NULL;
   // find the respective boundary point
-  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->ParticleInfo_nr);
+  PointMap::const_iterator PointRunner = PointsOnBoundary.find(Point->getNr());
   if (PointRunner != PointsOnBoundary.end()) {
     ReferencePoint = PointRunner->second;
@@ -3233,5 +3233,5 @@
       TrianglePoints[i] = NULL;
     } else {
-      PointMap::const_iterator FindPoint = PointsOnBoundary.find(Points[i]->ParticleInfo_nr);
+      PointMap::const_iterator FindPoint = PointsOnBoundary.find(Points[i]->getNr());
       if (FindPoint != PointsOnBoundary.end()) {
         TrianglePoints[i] = FindPoint->second;
@@ -3248,6 +3248,6 @@
           for (int j = i + 1; j < 3; j++) {
             if (TrianglePoints[j] != NULL) {
-              for (FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->ParticleInfo_nr); // is a multimap!
-              (FindLine != TrianglePoints[i]->lines.end()) && (FindLine->first == TrianglePoints[j]->node->ParticleInfo_nr); FindLine++) {
+              for (FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->getNr()); // is a multimap!
+              (FindLine != TrianglePoints[i]->lines.end()) && (FindLine->first == TrianglePoints[j]->node->getNr()); FindLine++) {
                 for (FindTriangle = FindLine->second->triangles.begin(); FindTriangle != FindLine->second->triangles.end(); FindTriangle++) {
                   if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
@@ -3269,6 +3269,6 @@
         if (TrianglePoints[i] == NULL)
           break;
-      for (FindLine = TrianglePoints[(i + 1) % 3]->lines.find(TrianglePoints[(i + 2) % 3]->node->ParticleInfo_nr); // is a multimap!
-      (FindLine != TrianglePoints[(i + 1) % 3]->lines.end()) && (FindLine->first == TrianglePoints[(i + 2) % 3]->node->ParticleInfo_nr); FindLine++) {
+      for (FindLine = TrianglePoints[(i + 1) % 3]->lines.find(TrianglePoints[(i + 2) % 3]->node->getNr()); // is a multimap!
+      (FindLine != TrianglePoints[(i + 1) % 3]->lines.end()) && (FindLine->first == TrianglePoints[(i + 2) % 3]->node->getNr()); FindLine++) {
         for (FindTriangle = FindLine->second->triangles.begin(); FindTriangle != FindLine->second->triangles.end(); FindTriangle++) {
           if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
@@ -3531,5 +3531,5 @@
   if (NearestPoint == point)
     NearestPoint = BackupPoint;
-  PointRunner = PointsOnBoundary.find(NearestPoint->ParticleInfo_nr);
+  PointRunner = PointsOnBoundary.find(NearestPoint->getNr());
   if (PointRunner != PointsOnBoundary.end()) {
     NearestBoundaryPoint = PointRunner->second;
Index: src/tesselationhelpers.cpp
===================================================================
--- src/tesselationhelpers.cpp	(revision a479fa6f7cb1bddf84d6c12af3c09dc810b66580)
+++ src/tesselationhelpers.cpp	(revision 735b1c1514f0f9ac27c1a3ef683b9fa6ea2cf010)
@@ -331,8 +331,8 @@
         DoLog(1) && (Log() << Verbose(1) << "Node nr. " << i << " is not yet present." << endl);
         result = true;
-      } else if (nodes[i]->lines.find(nodes[j]->node->ParticleInfo_nr) != nodes[i]->lines.end()) {  // there already is a line
+      } else if (nodes[i]->lines.find(nodes[j]->node->getNr()) != nodes[i]->lines.end()) {  // there already is a line
         LineMap::const_iterator FindLine;
         pair<LineMap::const_iterator,LineMap::const_iterator> FindPair;
-        FindPair = nodes[i]->lines.equal_range(nodes[j]->node->ParticleInfo_nr);
+        FindPair = nodes[i]->lines.equal_range(nodes[j]->node->getNr());
         for (FindLine = FindPair.first; FindLine != FindPair.second; ++FindLine) {
           // If there is a line with less than two attached triangles, we don't need a new line.
@@ -724,6 +724,6 @@
     for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); ++target) {
       Walker = target->second->node;
-      ASSERT(Walker->ParticleInfo_nr <= MaxId, "WriteTecplotFile() - Id of particle greater than MaxId.");
-      LookupList[Walker->ParticleInfo_nr] = Counter++;
+      ASSERT(Walker->getNr() <= MaxId, "WriteTecplotFile() - Id of particle greater than MaxId.");
+      LookupList[Walker->getNr()] = Counter++;
       for (int i=0;i<NDIM;i++) {
         const double tmp = Walker->at(i);
@@ -737,5 +737,5 @@
     for (TriangleMap::const_iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++) {
       DoLog(1) && (Log() << Verbose(1) << " " << runner->second->endpoints[0]->node->getName() << "<->" << runner->second->endpoints[1]->node->getName() << "<->" << runner->second->endpoints[2]->node->getName() << endl);
-      *tecplot << LookupList[runner->second->endpoints[0]->node->ParticleInfo_nr] << " " << LookupList[runner->second->endpoints[1]->node->ParticleInfo_nr] << " " << LookupList[runner->second->endpoints[2]->node->ParticleInfo_nr] << endl;
+      *tecplot << LookupList[runner->second->endpoints[0]->node->getNr()] << " " << LookupList[runner->second->endpoints[1]->node->getNr()] << " " << LookupList[runner->second->endpoints[2]->node->getNr()] << endl;
     }
     delete[] (LookupList);
