Index: src/Fragmentation/Fragmentation.cpp
===================================================================
--- src/Fragmentation/Fragmentation.cpp	(revision 61fc12f97143076e9d1562d9aeb9f7c7c2f7ce3e)
+++ 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 );
