Index: src/Atom/atom_bondedparticle.cpp
===================================================================
--- src/Atom/atom_bondedparticle.cpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Atom/atom_bondedparticle.cpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -71,6 +71,6 @@
 void BondedParticle::OutputOrder(ofstream *file) const
 {
-  *file << getNr() << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << endl;
-  //LOG(2, "Storing: " << getNr() << "\t" << (int)AdaptiveOrder << "\t" << MaxOrder << ".");
+  *file << getNr() << "\t" << (int)getAdaptiveOrder() << "\t" << (int)getMaxOrder() << endl;
+  //LOG(2, "Storing: " << getNr() << "\t" << (int)getAdaptiveOrder() << "\t" << getMaxOrder() << ".");
 };
 
Index: src/Atom/atom_bondedparticleinfo.cpp
===================================================================
--- src/Atom/atom_bondedparticleinfo.cpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Atom/atom_bondedparticleinfo.cpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -45,16 +45,4 @@
 BondList BondedParticleInfo::emptyList;
 
-/** Constructor of class BondedParticleInfo.
- */
-BondedParticleInfo::BondedParticleInfo() :
-  AdaptiveOrder(0),
-  MaxOrder(0)
-{}
-
-/** Destructor of class BondedParticleInfo.
- */
-BondedParticleInfo::~BondedParticleInfo()
-{}
-
 void BondedParticleInfo::AppendTrajectoryStep(const unsigned int _step)
 {
@@ -74,10 +62,76 @@
 }
 
+template <class List_t>
+void setEntryInList(
+    List_t &_list,
+    const typename List_t::key_type _step,
+    const typename List_t::mapped_type &_value)
+{
+  typename List_t::iterator iter =
+    _list.find(_step);
+  if (iter != _list.end())
+    iter->second = _value;
+  else
+    _list.insert( std::make_pair(_step, _value) );
+}
+
+template <class List_t>
+const typename List_t::mapped_type& getEntryInList(
+    const List_t &_list,
+    const typename List_t::key_type _step,
+    const typename List_t::mapped_type &_empty)
+{
+  typename List_t::const_iterator iter =
+    _list.find(_step);
+  if (iter != _list.end())
+    return iter->second;
+  return _empty;
+}
+
 const BondList& BondedParticleInfo::getListOfBondsAtStep(unsigned int _step) const
 {
-  BondTrajectory_t::const_iterator iter =
-    ListOfBonds.find(_step);
-  if (iter != ListOfBonds.end())
-    return iter->second;
-  return emptyList;
+  return getEntryInList<BondTrajectory_t>(ListOfBonds, _step, emptyList);
 }
+
+const unsigned char& BondedParticleInfo::getMaxOrder() const
+{
+  return getMaxOrder(WorldTime::getTime());
+}
+
+const unsigned char& BondedParticleInfo::getMaxOrder(unsigned int _step) const
+{
+  static unsigned char emptyOrder=0;
+  return getEntryInList<OrderTrajectory_t>(MaxOrder, _step, emptyOrder);
+}
+
+void BondedParticleInfo::setMaxOrder(unsigned char _value)
+{
+  setMaxOrder(WorldTime::getTime(), _value);
+}
+
+void BondedParticleInfo::setMaxOrder(unsigned int _step, const unsigned char _value)
+{
+  setEntryInList<OrderTrajectory_t>(MaxOrder, _step, _value);
+}
+
+const unsigned char& BondedParticleInfo::getAdaptiveOrder() const
+{
+  return getAdaptiveOrder(WorldTime::getTime());
+}
+
+const unsigned char& BondedParticleInfo::getAdaptiveOrder(unsigned int _step) const
+{
+  static unsigned char emptyOrder=0;
+  return getEntryInList<OrderTrajectory_t>(AdaptiveOrder, _step, emptyOrder);
+}
+
+void BondedParticleInfo::setAdaptiveOrder(unsigned char _value)
+{
+  setAdaptiveOrder(WorldTime::getTime(), _value);
+}
+
+void BondedParticleInfo::setAdaptiveOrder(unsigned int _step, const unsigned char _value)
+{
+  setEntryInList<OrderTrajectory_t>(AdaptiveOrder, _step, _value);
+}
+
Index: src/Atom/atom_bondedparticleinfo.hpp
===================================================================
--- src/Atom/atom_bondedparticleinfo.hpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Atom/atom_bondedparticleinfo.hpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -37,9 +37,6 @@
   friend class BondedParticle;
 public:
-  unsigned char AdaptiveOrder;  //!< current present bond order at site (0 means "not set")
-  unsigned char MaxOrder;  //!< desired maximum order of this atom (0 means "not set")
 
-  BondedParticleInfo();
-  virtual ~BondedParticleInfo();
+  virtual ~BondedParticleInfo() {}
 
   /** Pushes back another step in all trajectory vectors.
@@ -65,13 +62,4 @@
   const BondList& getListOfBonds() const;
 
-  /** Accessor to ListOfBonds of WorldTime::CurrentTime.
-   *
-   * Note, new empty BondList is returned if array entry at upper boundary is
-   * accessed. Beyond std will issue exception due to out-of-range access.
-   *
-   * @return ListOfBonds[WorldTime::CurrentTime]
-   */
-//  BondList& getListOfBonds();
-
   /** Const Accessor ListOfBonds of any present time step.
    *
@@ -81,13 +69,57 @@
   const BondList& getListOfBondsAtStep(unsigned int _step) const;
 
-  /** Accessor ListOfBonds of any present time step.
+  /** Const getter for the MaxOrder property at current time step.
    *
-   * Note, new empty BondList is returned if array entry at upper boundary is
-   * accessed. Beyond std will issue exception due to out-of-range access.
+   * @return MaxOrder[Current world time step].
+   */
+  const unsigned char& getMaxOrder() const;
+
+  /** Const getter for the MaxOrder property at given \a _step.
    *
    * @param _step time step to access
-   * @return ListOfBonds[_step].
+   * @return MaxOrder[_step].
    */
-//  BondList& getListOfBondsAtStep(unsigned int _step);
+  const unsigned char& getMaxOrder(const unsigned int _step) const;
+
+  /** Setter for the MaxOrder property at current time step.
+   *
+   * @param _value value to set for MaxOrder at current time step
+   */
+  void setMaxOrder(const unsigned char _value);
+
+  /**Setter for the MaxOrder property at given \a _step.
+   *
+   * @param _step time step to access
+   * @param _value value to set for MaxOrder at the desired time step
+   * @return MaxOrder[_step].
+   */
+  void setMaxOrder(const unsigned int _step, const unsigned char _value);
+
+  /** Const getter for the AdaptiveOrder property at current time step.
+   *
+   * @return AdaptiveOrder[Current world time step].
+   */
+  const unsigned char& getAdaptiveOrder() const;
+
+  /** Const getter for the AdaptiveOrder property at given \a _step.
+   *
+   * @param _step time step to access
+   * @return AdaptiveOrder[_step].
+   */
+  const unsigned char& getAdaptiveOrder(const unsigned int _step) const;
+
+  /** Setter for the AdaptiveOrder property at current time step.
+   *
+   * @param _value value to set for AdaptiveOrder at current time step
+   */
+  void setAdaptiveOrder(const unsigned char _value);
+
+  /** Setter for the AdaptiveOrder property at given \a _step.
+   *
+   * @param _step time step to access
+   * @param _value value to set for AdaptiveOrder at the desired time step
+   * @return AdaptiveOrder[_step].
+   */
+  void setAdaptiveOrder(const unsigned int _step, const unsigned char _value);
 
 protected:
@@ -105,4 +137,8 @@
   BondTrajectory_t ListOfBonds; //!< list of all bonds
   static BondList emptyList;  //!< empty list to return when step is not present
+
+  typedef std::map<unsigned int, unsigned char> OrderTrajectory_t;
+  OrderTrajectory_t AdaptiveOrder;  //!< current present bond order at site (0 means "not set")
+  OrderTrajectory_t MaxOrder;  //!< desired maximum order of this atom (0 means "not set")
 };
 
Index: src/Fragmentation/AdaptivityMap.cpp
===================================================================
--- src/Fragmentation/AdaptivityMap.cpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Fragmentation/AdaptivityMap.cpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -154,6 +154,6 @@
     Walker = mol->FindAtom((*runner).first);
     if (Walker != NULL) {
-      //if ((*runner).second.second >= Walker->AdaptiveOrder) { // only insert if this is an "active" root site for the current order
-      if (Walker->MaxOrder > Walker->AdaptiveOrder) {
+      //if ((*runner).second.second >= Walker->getAdaptiveOrder()) { // only insert if this is an "active" root site for the current order
+      if (Walker->getMaxOrder() > Walker->getAdaptiveOrder()) {
         LOG(2, "(" << (*runner).first << ",[" << (*runner).second.first << "," << (*runner).second.second << "])");
         FinalRootCandidates->insert( make_pair( (*runner).second.first, pair<int,int>((*runner).first, (*runner).second.second) ) );
Index: src/Fragmentation/Fragmentation.cpp
===================================================================
--- src/Fragmentation/Fragmentation.cpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Fragmentation/Fragmentation.cpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -286,11 +286,12 @@
     atom *Walker = mol->FindAtom(RootKeyNr);
     // check cyclic lengths
-    //if ((MinimumRingSize[Walker->GetTrueFather()->getNr()] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->getNr()])) {
-    //  LOG(0, "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed.");
+    //if ((MinimumRingSize[Walker->GetTrueFather()->getNr()] != -1) && (Walker->GetTrueFather()->getAdaptiveOrder()+1 > MinimumRingSize[Walker->GetTrueFather()->getNr()])) {
+    //  LOG(0, "Bond order " << Walker->GetTrueFather()->getAdaptiveOrder() << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed.");
     //} else
     {
       // set adaptive order to desired max order
-      Walker->GetTrueFather()->AdaptiveOrder = Walker->GetTrueFather()->MaxOrder;
-      Order = Walker->AdaptiveOrder = Walker->GetTrueFather()->AdaptiveOrder;
+      Walker->GetTrueFather()->setAdaptiveOrder(Walker->GetTrueFather()->getMaxOrder());
+      Order = Walker->GetTrueFather()->getAdaptiveOrder();
+      Walker->setAdaptiveOrder(Order);
 
       // allocate memory for all lower level orders
@@ -302,5 +303,5 @@
       // initialise Order-dependent entries of UniqueFragments structure
       UniqueFragments FragmentSearch(1., FragmentLowerOrdersList[RootNr], Walker);
-      PowerSetGenerator PSG(&FragmentSearch, Walker->AdaptiveOrder);
+      PowerSetGenerator PSG(&FragmentSearch, Walker->getAdaptiveOrder());
 
       // create top order where nothing is reduced
@@ -316,8 +317,8 @@
 //        NumMolecules = 0;
 //      }
-      // now, we have completely filled each cell of FragmentLowerOrdersList[] for the current Walker->AdaptiveOrder
-      //NumMoleculesOfOrder[Walker->AdaptiveOrder-1] = NumMolecules;
+      // now, we have completely filled each cell of FragmentLowerOrdersList[] for the current Walker->getAdaptiveOrder()
+      //NumMoleculesOfOrder[Walker->getAdaptiveOrder()-1] = NumMolecules;
       TotalNumMolecules += NumMoleculesOfOrder[RootNr];
-//      LOG(1, "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->AdaptiveOrder << " is: " << NumMoleculesOfOrder[RootNr] << ".");
+//      LOG(1, "Number of resulting molecules for Order " << (int)Walker->GetTrueFather()->getAdaptiveOrder() << " is: " << NumMoleculesOfOrder[RootNr] << ".");
       RootStack.push_back(RootKeyNr); // put back on stack
       RootNr++;
@@ -407,7 +408,7 @@
       atom * const Walker = *iter;
       if (AtomMask.isTrue(Walker->getNr())) { // skip masked out
-        Walker->MaxOrder = (Order != 0 ? Order : Walker->MaxOrder+1);
+        Walker->setMaxOrder((Order != 0 ? Order : Walker->getMaxOrder()+1));
         // remove all that have reached desired order
-        if (Walker->AdaptiveOrder >= Walker->MaxOrder) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->getNr()]))
+        if (Walker->getAdaptiveOrder() >= Walker->getMaxOrder()) // && (Walker->getAdaptiveOrder() < MinimumRingSize[Walker->getNr()]))
           AtomMask.setFalse(Walker->getNr());
         else
@@ -451,6 +452,6 @@
         ++iter) {
       file << (*iter)->getId()
-          << "\t" << (int)(*iter)->AdaptiveOrder
-          << "\t" << (int)(*iter)->MaxOrder << std::endl;
+          << "\t" << (int)(*iter)->getAdaptiveOrder()
+          << "\t" << (int)(*iter)->getMaxOrder() << std::endl;
     }
     file.close();
@@ -513,6 +514,6 @@
     // set atom values
     for(molecule::iterator iter=mol->begin();iter!=mol->end();++iter){
-      (*iter)->AdaptiveOrder = OrderArray[(*iter)->getNr()];
-      (*iter)->MaxOrder = OrderArray[(*iter)->getNr()]; //MaxArray.isTrue((*iter)->getNr());
+      (*iter)->setAdaptiveOrder(OrderArray[(*iter)->getNr()]);
+      (*iter)->setMaxOrder(OrderArray[(*iter)->getNr()]); //MaxArray.isTrue((*iter)->getNr());
     }
     //SetAtomValueToIndexedArray( OrderArray, &atom::getNr(), &atom::AdaptiveOrder );
Index: src/Fragmentation/fragmentation_helpers.cpp
===================================================================
--- src/Fragmentation/fragmentation_helpers.cpp	(revision 064b34fc7b38cb1cef611930e6a1c69a2d1473cd)
+++ src/Fragmentation/fragmentation_helpers.cpp	(revision a1c8fa5b0a1b29c0241e7d4e4bcaf3caa6eac36e)
@@ -45,5 +45,4 @@
 
 #include "Atom/atom.hpp"
-#include "Fragmentation/AdaptivityMap.hpp"
 #include "Fragmentation/AtomMask.hpp"
 #include "Fragmentation/Graph.hpp"
@@ -103,5 +102,5 @@
     RootStack.pop_front();
     Walker = mol->FindAtom(RootKeyNr);
-    NumLevels = Walker->AdaptiveOrder;
+    NumLevels = Walker->getAdaptiveOrder();
     ASSERT( NumLevels == FragmentLowerOrdersList[RootNr].size(),
         "CombineAllOrderListIntoOne() - differing size and NumLevels.");
@@ -134,5 +133,5 @@
     RootStack.pop_front();
     Walker = mol->FindAtom(RootKeyNr);
-    NumLevels = Walker->AdaptiveOrder;
+    NumLevels = Walker->getAdaptiveOrder();
     for(int i=0;i<NumLevels;i++) {
       if (FragmentLowerOrdersList[RootNr][i] != NULL) {
