Changeset b8eb3a

Timestamp:

May 8, 2008, 12:02:43 PM (17 years ago)

Author:

Frederik Heber <heber@…>

Children:

9c3496

Parents:

c901e3

Message:

new function MoleculeLeafClass::FillBondStructureFromReference that fills the bond structure of subgraphs from total molecule

new function to abstractize molecule::FragmentMolecule more and more as the function lacks structure

File:

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

molecuilder/src/moleculelist.cpp

@@ -347 +347 @@
   return false;
 };
+
+/** Fills the bond structure of this chain list subgraphs that are derived from a complete \a *reference molecule.
+ * Calls this routine in each MoleculeLeafClass::next subgraph if it's not NULL.
+ * \param *out output stream for debugging
+ * \param *reference reference molecule with the bond structure to be copied
+ * \param &FragmentCounter Counter needed to address \a **ListOfLocalAtoms
+ * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in \a *reference, may be NULL on start, then it is filled
+ * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
+ * \return true - success, false - faoilure
+ */
+bool MoleculeLeafClass::FillBondStructureFromReference(ofstream *out, molecule *reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+{
+  atom *Walker = NULL, *OtherWalker = NULL;
+  bond *Binder = NULL;
+  bool status = true;
+  int AtomNo;
+
+  if (ListOfLocalAtoms == NULL) { // allocated initial pointer
+    // count the number of fragments
+    MoleculeLeafClass *MolecularWalker = this;
+    while (MolecularWalker->next != NULL) {
+      MolecularWalker = MolecularWalker->next;
+      FragmentCounter++;
+    }
+    // allocate and set each field to NULL 
+    ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **)*(FragmentCounter+1), "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+    if (ListOfLocalAtoms == NULL)
+      return false;
+    for (int i=0;i<=FragmentCounter;i++)
+      ListOfLocalAtoms[i] = NULL;
+    FragmentCounter = 0;
+    FreeList = FreeList && true;
+  }
+  if (ListOfLocalAtoms[FragmentCounter] == NULL) { // allocate and fill list of this fragment/subgraph
+    status = status && CreateFatherLookupTable(out, Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], reference->AtomCount);
+    FreeList = FreeList && true;
+  }
+  
+  if (status) {
+    *out << Verbose(1) << "Creating adjacency list for subgraph " << this << "." << endl;
+    Walker = Leaf->start;
+    while (Walker->next != Leaf->end) {
+      Walker = Walker->next;
+      AtomNo = Walker->father->nr;  // global id of the current walker
+      for(int i=0;i<reference->NumberOfBondsPerAtom[AtomNo];i++) { // go through father's bonds and copy them all
+        Binder = reference->ListOfBondsPerAtom[AtomNo][i];
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][Binder->GetOtherAtom(Walker->father)->nr];    // local copy of current bond partner of walker
+        if (OtherWalker != NULL) {
+          if (OtherWalker->nr > Walker->nr)
+          Leaf->AddBond(Walker, OtherWalker, Binder->BondDegree);
+        } else {
+          *out << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << Binder->GetOtherAtom(Walker->father)->nr << "] is NULL!" << endl;
+          status = false;
+        }
+      }
+    }
+    Leaf->CreateListOfBondsPerAtom(out);
+    FragmentCounter++;
+    if (next != NULL)
+      status = next->FillBondStructureFromReference(out, reference, FragmentCounter, ListOfLocalAtoms);
+  }
+  
+  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, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+  }
+  
+  return status;
+};
+
+