Changeset 255d13 for molecuilder

Timestamp:

May 8, 2008, 12:41:47 PM (17 years ago)

Author:

Frederik Heber <heber@…>

Children:

7b80a5

Parents:

9c3496

Message:

FillBondStructureFromReference: previous == NULL was bad idea, new functions Count() and FillRootStackForSubgraphs()

FillBondStructureFromReference: checking previous == NULL if we are the first is bad due to starting node (with mpty leaf) being actual previous, hence we decrease FragmentCounter before return, thus climb up the ladder and then down again and free in this course. Initial list pointer is free'd if FragmentCounter == 0: much better!
Count: simply counts the number of further leaves in the chain list, also by the neat recursive trick
FillRootStackForSubgraphs: Fills a rootstack by going through the leaves of a subgraph and checking on their atom's father's atom::AdaptiveOrder against given Order. This is further abstraction for molecule::FragmentMolecule()

File:

• molecuilder/src/moleculelist.cpp (modified) (1 diff)

molecuilder/src/moleculelist.cpp

@@ -411 +411 @@
   if (FreeList) {
     // free the index lookup list
-    for (int i=0;i<FragmentCounter;i++)
-      Free((void **)&ListOfLocalAtoms[i], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
-    if (previous == NULL) // if we are the first in this chain list, empty initial pointer
+    Free((void **)&ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
+    if (ListOfLocalAtoms[FragmentCounter] == NULL)
       Free((void **)&ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
   }
-  
+  FragmentCounter--;
   return status;
 };
 
-
+/** Fills the root stack for sites to be used as root in fragmentation depending on order or adaptivity criteria
+ * Again, as in \sa FillBondStructureFromReference steps recursively through each Leaf in this chain list of molecule's.
+ * \param *out output stream for debugging
+ * \param *&RootStack stack to be filled
+ * \param Order desired bond order for all sites 
+ * \param &FragmentCounter counts through the fragments in this MoleculeLeafClass
+ * \return true - stack is non-empty, fragmentation necessary, false - stack is empty, no more sites to update
+ */
+bool MoleculeLeafClass::FillRootStackForSubgraphs(ofstream *out, KeyStack *&RootStack, int Order, int &FragmentCounter)
+{
+  atom *Walker = NULL;
+
+  if (RootStack != NULL) {
+    if (Order == -1) {  // means we want to increase order adaptively
+      cerr << "Adaptive chosing of sites not yet implemented!" << endl;
+    } else {  // means we just want to increase it at every site by one
+      // find first root candidates 
+      if (&(RootStack[FragmentCounter]) != NULL) {
+        RootStack[FragmentCounter].clear();  
+        Walker = Leaf->start;
+        while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
+          Walker = Walker->next;
+      #ifdef ADDHYDROGEN
+          if (Walker->type->Z != 1) // skip hydrogen
+      #endif
+            if (Walker->GetTrueFather()->AdaptiveOrder < Order) // only if Order is still greater
+              RootStack[FragmentCounter].push_front(Walker->nr);
+        }
+        if (next != NULL)
+          next->FillRootStackForSubgraphs(out, RootStack, Order, ++FragmentCounter);
+      } else
+        return false;
+    }
+    return true;
+  } else
+    return false;
+};
+
+/** Simply counts the number of items in the list, from given MoleculeLeafClass.
+ * \return number of items
+ */
+int MoleculeLeafClass::Count()
+{
+  if (next != NULL)
+    return next->Count()+1;
+  else
+    return 1; 
+};