Context Navigation

-              rdbe3b9
+              r6d551c
 #include "Graph/CyclicStructureAnalysis.hpp"
 #include "Graph/DepthFirstSearchAnalysis.hpp"
+#include "Graph/ListOfLocalAtoms.hpp"
 #include "molecule.hpp"
 #include "MoleculeLeafClass.hpp"
 …
 Action::state_ptr GraphDepthFirstSearchAction::performCall() {
   LOG(1, "Depth-First-Search Analysis.");
   atom **ListOfAtoms = NULL;
+  ListOfLocalAtoms_t ListOfAtoms;
   std::deque<bond *> *LocalBackEdgeStack = NULL;
   DepthFirstSearchAnalysis DFS;
 …
     while (Subgraphs->next != NULL) {
       Subgraphs = Subgraphs->next;
       ListOfAtoms = NULL;
+      ListOfAtoms.clear();
       Subgraphs->Leaf->FillListOfLocalAtoms(ListOfAtoms, Subgraphs->Leaf->getAtomCount());
       LocalBackEdgeStack = new std::deque<bond *>; // no need to have it Subgraphs->Leaf->BondCount size
 …
       Subgraphs->Leaf = NULL;
       delete(Subgraphs->previous);
-      delete[](ListOfAtoms);  // allocated by FillListOfLocalAtoms
       FragmentCounter++;
+    }

src/Fragmentation/Fragmentation.cpp

-              rdbe3b9
+              r6d551c
 #include "Graph/BondGraph.hpp"
 #include "Graph/CheckAgainstAdjacencyFile.hpp"
+#include "Graph/ListOfLocalAtoms.hpp"
 #include "molecule.hpp"
 #include "MoleculeLeafClass.hpp"
 …
   Graph TotalGraph;     // graph with all keysets however local numbers
   int TotalNumberOfKeySets = 0;
-  atom ***ListOfLocalAtoms = NULL;
   bool *AtomMask = NULL;
 …
   // ===== 6a. assign each keyset to its respective subgraph =====
   const int MolCount = World::getInstance().numMolecules();
-  ListOfLocalAtoms = new atom **[MolCount];
-  for (int i=0;i<MolCount;i++)
-    ListOfLocalAtoms[i] = NULL;
   FragmentCounter = 0;
+  Subgraphs->next->AssignKeySetsToFragment(mol, &ParsedFragmentList, ListOfLocalAtoms, FragmentList, FragmentCounter, true);
+  delete[](ListOfLocalAtoms);
+  {
+    ListOfLocalAtoms_t *ListOfLocalAtoms = new ListOfLocalAtoms_t[MolCount];
+    Subgraphs->next->AssignKeySetsToFragment(mol, &ParsedFragmentList, ListOfLocalAtoms, FragmentList, FragmentCounter, true);
+    delete[] ListOfLocalAtoms;
+  }
   // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle

src/Graph/DepthFirstSearchAnalysis.cpp

-              rdbe3b9
+              r6d551c
 #include "Descriptors/AtomDescriptor.hpp"
 #include "Descriptors/MoleculeDescriptor.hpp"
+#include "Graph/ListOfLocalAtoms.hpp"
 #include "molecule.hpp"
 #include "MoleculeLeafClass.hpp"
 …
 bool DepthFirstSearchAnalysis::PickLocalBackEdges(atom **ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const
+bool DepthFirstSearchAnalysis::PickLocalBackEdges(const ListOfLocalAtoms_t &ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const
+{
   bool status = true;
 …
   do { // go through all bonds and push local ones
+    Walker = ListOfLocalAtoms[Binder->leftatom->getNr()]; // get one atom in the reference molecule
+    const ListOfLocalAtoms_t::const_iterator leftiter = ListOfLocalAtoms.find(Binder->leftatom->getNr());
+    ASSERT( leftiter != ListOfLocalAtoms.end(),
+        "DepthFirstSearchAnalysis::PickLocalBackEdges() - could not find atom id "
+        +toString(Binder->leftatom->getNr())+" in ListOfLocalAtoms.");
+    Walker = leftiter->second; // get one atom in the reference molecule
     if (Walker != NULL) { // if this Walker exists in the subgraph ...
       const BondList& ListOfBonds = Walker->getListOfBonds();
 …
           ++Runner) {
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->getNr()]) { // found the bond
+        const ListOfLocalAtoms_t::const_iterator rightiter = ListOfLocalAtoms.find((*Runner)->rightatom->getNr());
+        if (OtherAtom == rightiter->second) { // found the bond
           LocalStack->push_front((*Runner));
           LOG(3, "INFO: Found local edge " << *(*Runner) << ".");

src/Graph/DepthFirstSearchAnalysis.hpp

-              rdbe3b9
+              r6d551c
 class atom;
 class bond;
+class ListOfLocalAtoms_t;
 class MoleculeLeafClass;
 class molecule;
 …
    * Reference is the internal BackEdgeStack.
+   *
    * \param **ListOfLocalAtoms array of father atom::nr to local atom::nr (reverse of atom::father)
+   * \param ListOfLocalAtoms array of father atom::nr to local atom::nr (reverse of atom::father)
    * \param *LocalStack stack to be filled
    * \return true - everything ok, false - ReferenceStack was empty
    */
   bool PickLocalBackEdges(atom **ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const;
+  bool PickLocalBackEdges(const ListOfLocalAtoms_t &ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const;
   /** Getter for BackEdgeStack.

src/Graph/Makefile.am

-              rdbe3b9
+              r6d551c
         Graph/ConnectedSubgraph.hpp \
         Graph/CyclicStructureAnalysis.hpp \
+        Graph/DepthFirstSearchAnalysis.hpp
+        Graph/DepthFirstSearchAnalysis.hpp \
+        Graph/ListOfLocalAtoms.hpp

src/MoleculeLeafClass.cpp

-              rdbe3b9
+              r6d551c
 #include "Fragmentation/Graph.hpp"
 #include "Fragmentation/KeySet.hpp"
+#include "Graph/ListOfLocalAtoms.hpp"
 #include "molecule.hpp"
 …
  * \param *reference reference molecule with the bond structure to be copied
  * \param *KeySetList list with all keysets
  * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
+ * \param *ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
  * \param **&FragmentList list to be allocated and returned
  * \param &FragmentCounter counts the fragments as we move along the list
 …
  * \retuen true - success, false - failure
  */
 bool MoleculeLeafClass::AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
+bool MoleculeLeafClass::AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, ListOfLocalAtoms_t *&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
+{
   bool status = true;
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
     delete[](ListOfLocalAtoms[FragmentCounter]);
+    (ListOfLocalAtoms[FragmentCounter]).clear();
+  }
   LOG(1, "End of AssignKeySetsToFragment.");

src/MoleculeLeafClass.hpp

-              rdbe3b9
+              r6d551c
 class atom;
 class Graph;
+class ListOfLocalAtoms_t;
 class molecule;
 …
   bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
   bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter, const enum HydrogenSaturation saturation);
   bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
+  bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, ListOfLocalAtoms_t *&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
   void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
   int Count() const;

src/molecule.hpp

-              rdbe3b9
+              r6d551c
 class Graph;
 class LinkedCell_deprecated;
+class ListOfLocalAtoms_t;
 class molecule;
 class MoleculeLeafClass;
 …
   bool StoreBondsToFile(std::string filename, std::string path = "");
   bool StoreAdjacencyToFile(std::string filename, std::string path = "");
   bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
+  bool CreateFatherLookupTable(ListOfLocalAtoms_t &LookupTable, int count = 0);
   // Recognize doubly appearing molecules in a list of them
   int * GetFatherSonAtomicMap(molecule *OtherMolecule);
   bool FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList = false);
   bool FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount);
+  bool FillBondStructureFromReference(const molecule * const reference, ListOfLocalAtoms_t &ListOfLocalAtoms, bool FreeList = false);
+  bool FillListOfLocalAtoms(ListOfLocalAtoms_t &ListOfLocalAtoms, const int GlobalAtomCount);
   // Output routines.

src/molecule_graph.cpp

-              rdbe3b9
+              r6d551c
 #include "Element/element.hpp"
 #include "Graph/BondGraph.hpp"
+#include "Graph/ListOfLocalAtoms.hpp"
 #include "Helpers/defs.hpp"
 #include "Helpers/helpers.hpp"
 …
  * Calls this routine in each MoleculeLeafClass::next subgraph if it's not NULL.
  * \param *reference reference molecule with the bond structure to be copied
  * \param **&ListOfLocalAtoms Lookup table for this 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
+ * \param ListOfLocalAtoms Lookup table for this 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 - failure
  */
 bool molecule::FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList)
+bool molecule::FillBondStructureFromReference(const molecule * const reference, ListOfLocalAtoms_t &ListOfLocalAtoms, bool FreeList)
+{
   bool status = true;
 …
           ++Runner) {
         atom * const OtherAtom = (*Runner)->GetOtherAtom((*iter)->GetTrueFather());
+        atom * const OtherWalker = ListOfLocalAtoms[OtherAtom->getNr()]; // local copy of current bond partner of walker
+        const ListOfLocalAtoms_t::const_iterator localiter = ListOfLocalAtoms.find(OtherAtom->getNr());
+        ASSERT( localiter != ListOfLocalAtoms.end(),
+            "molecule::FillBondStructureFromReference() - could not find id"
+            +toString(OtherAtom->getNr())+" in ListOfLocalAtoms.");
+        atom * const OtherWalker = localiter->second; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
           if (OtherWalker->getNr() > (*iter)->getNr())
 …
+  }
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
+  if ((FreeList) && (!ListOfLocalAtoms.empty())) {
     // free the index lookup list
     delete[](ListOfLocalAtoms);
+    ListOfLocalAtoms.clear();
+  }
   LOG(1, "End of FillBondStructureFromReference.");
 …
 /** Fills a lookup list of father's Atom::nr -> atom for each subgraph.
  * \param **&ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
+ * \param ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
  * \param GlobalAtomCount number of atoms in the complete molecule
  * \return true - success, false - failure (ListOfLocalAtoms != NULL)
  */
 bool molecule::FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount)
+bool molecule::FillListOfLocalAtoms(ListOfLocalAtoms_t &ListOfLocalAtoms, const int GlobalAtomCount)
+{
   bool status = true;
   if (ListOfLocalAtoms == NULL) { // allocate and fill list of this fragment/subgraph
+  if (ListOfLocalAtoms.empty()) { // allocate and fill list of this fragment/subgraph
     status = status && CreateFatherLookupTable(ListOfLocalAtoms, GlobalAtomCount);
   } else
 …
  * \return true - success, false - failure
  */
 bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
+bool molecule::CreateFatherLookupTable(ListOfLocalAtoms_t &LookupTable, int count)
+{
   bool status = true;
   int AtomNo;
   if (LookupTable != NULL) {
     ELOG(1, "Pointer for Lookup table is not NULL! Aborting ...");
+  if (!LookupTable.empty()) {
+    ELOG(1, "Pointer for Lookup table is not empty! Aborting ...");
     return false;
+  }
 …
   // allocate and fill
+  LookupTable = new atom *[count+1];
+  if (LookupTable == NULL) {
+    ELOG(0, "LookupTable memory allocation failed!");
+    performCriticalExit();
+    status = false;
+  } else {
+    for (int i=0;i<=count;i++)
+      LookupTable[i] = NULL;
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) {
+      AtomNo = (*iter)->GetTrueFather()->getNr();
+      if ((AtomNo >= 0) && (AtomNo <= count)) {
+        LOG(3, "DEBUG: Setting LookupTable[" << AtomNo << "] to " << *(*iter));
+        LookupTable[AtomNo] = (*iter);
+      } else {
+        ELOG(1, "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << "].");
+        status = false;
+        break;
+      }
+  for (int i=0;i<=count;i++)
+    LookupTable[i] = NULL;
+  for (molecule::iterator iter = begin(); iter != end(); ++iter) {
+    AtomNo = (*iter)->GetTrueFather()->getNr();
+    if ((AtomNo >= 0) && (AtomNo <= count)) {
+      LOG(3, "DEBUG: Setting LookupTable[" << AtomNo << "] to " << *(*iter));
+      LookupTable[AtomNo] = (*iter);
+    } else {
+      ELOG(1, "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << "].");
+      status = false;
+      break;
+    }
+  }

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 6d551c for src

Legend:

Download in other formats: