Changeset 872b51 for molecuilder/src/atom.cpp

Timestamp:

Oct 18, 2009, 2:51:38 PM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

77894f

Parents:

b0ee98

git-author:

Frederik Heber <heber@…> (10/18/09 14:15:37)

git-committer:

Frederik Heber <heber@…> (10/18/09 14:51:38)

Message:

Huge refactoring: molecule::ListOfBondsPerAtom and molecule::NumberOfBondsPerAtom removed, atom::ListOfBonds introduced. Unit Test for ListOfBonds manipulation introduced.

• changes to class atom:
  • ~atom(): removes all bonds it is part of and unlink()s
  • new functions: CountBonds() - counts bonds times BondDegree, OutputGraphInfo() - graph data is output, OutputComponentNumber() - output of component numbers, OutputAdjacency() - indices of this and its neighbours, CorrectBondDegree() - corrects bond degree incrementally (by at most one) -- all since ListOfBonds is now local info
  • OutputBondOfAtom() - does not need ListOfBondsPerAtom, ... as ListOfBonds is now local info
  • new functions for ListOfBonds access: RegisterBond(), UnregisterBond(), UnregisterAllBonds() (the latter only remove from the list, do not delete, as molecule still has a global list of all bonds and does deletion.)

• changes to class bond:
  • ~bond() uses unlink(), uses UnregisterBond() on leftatom and rightatom
  • removed unused bond::GetFirstBond() and bond::GetLastBond()
  • GetOtherAtom() has now const parameter

• changes to builder.cpp: removed CreateListOfBondsPerAtom() calls, as the creation of the global arrays is not necessary anymore

• changes to LinkedCell: LinkedCell::CheckBounds(int[NDIM]) does not admonish out of bonds as this is not desired for the local offset which may become out of bounds.

• changes to lists.hpp templates: BUGFIX: unlink() now sets ->next and ->previous to NULL, cleanup() uses removedwithoutcheck()

• new templates for molecule.hpp: SumPerAtom() allows for summation of the return value of atom:...() member fiunctions. This is needed e.g. for atom::CorrectBondDegree()

• changes to MoleculeListClass:
  • changes due to ListOfBondsPerAtom -> atom::ListOfBonds: AddHydrogenCorrection(), FillBondStructureFromReference()

• changes to class molecule:
  • changes due to ListOfBondsPerAtom -> atom::ListOfBonds: GuesstimateFragmentCount(), FragmentMolecule(), FillSPListandLabelVertices(), ScanForPeriodicCorrection(), DeterminePeriodicCenter(), CyclicStructureAnalysis(), InitComponentNumbers(), FindNextUnused(), CheckAdjacencyFileAgainstMolecule(), PickLocalBackEdges(), BreadthFirstSearchAdd(), BuildInducedSubgraph(), CheckForConnectedSubgraph(), molecule(), ~molecule(), AddHydrogenReplacementAtom(), RemoveBonds(), OutputListOfBonds(), removed CreateListOfBondsPerAtom()
  • due to removal of CreateListOfBonds(): FragmentMolecule(), CreateAdjacencyListFromDbondFile(), CreateAdjacencyList(), SetNextComponentNumber()
  • ActOnAllAtoms() used: CreateAdjacencyList() - uses atom::OutputBondOfAtom(), StoreAdjacencyToFile() - uses atom::OutputAdjacency(),
  • SumPerAtom() used: CorrectBondDegree() - uses atom::CorrectBondDegree(),
  • function removed: molecule::CountAtomsBonds() - shifted to atom::CountBonds(), OutputComponentNumber() - shifted to atom::OutputComponentNumber()
  • CountCyclicBonds() - manipulates molecule::NoCyclicBonds directly.
  • rewritten DepthFirstSearchAnalysis() - refactored to CyclicBondAnalysis(), OutputGraphInfoPerAtom(), OutputGraphInfoPerBond()
  • rewritten RemoveAtom() - uses RemoveBonds()
  • FIX: rewritten CleanupMolecule() - cleanup was wrong order, now is first bonds, then atoms
  • rewritten BreadthFirstSearchAdd() - uses molecule::CopyBond() (equal code was present multiple(!) times before)
  • new functions CyclicBondAnalysis(), OutputGraphInfoPerAtom(), OutputGraphInfoPerBond(), CopyBond()

• New UnitTest for ListOfBonds:
  • tests AddBond(), RemoveAtom(), RemoveBond(), RemoveBonds() and simple deletion of atoms or bonds, where afterwards chain lists of bonds should remain intact.

Signed-off-by: Frederik Heber <heber@…>

File:

• molecuilder/src/atom.cpp (modified) (7 diffs)

molecuilder/src/atom.cpp

@@ -9 +9 @@
 #include "config.hpp"
 #include "element.hpp"
+#include "lists.hpp"
 #include "memoryallocator.hpp"
 #include "parser.hpp"
@@ -67 +68 @@
 atom::~atom()
 {
+  BondList::const_iterator Runner;
+  while (!ListOfBonds.empty()) {
+    Runner = ListOfBonds.begin();
+    removewithoutcheck(*Runner);
+  }
+  unlink(this);
   Free<int>(&ComponentNr, "atom::~atom: *ComponentNr");
   Free<char>(&Name, "atom::~atom: *Name");
@@ -118 +125 @@
 {
   return (node->IsInParallelepiped(offset, parallelepiped));
+};
+
+/** Counts the number of bonds weighted by bond::BondDegree.
+ * \param bonds times bond::BondDegree
+ */
+int atom::CountBonds() const
+{
+  int NoBonds = 0;
+  for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
+    NoBonds += (*Runner)->BondDegree;
+  return NoBonds;
 };
 
@@ -215 +233 @@
 };
 
-/** Prints all bonds of this atom from given global lists.
+/** Output graph info of this atom.
+ * \param *out output stream
+ */
+void atom::OutputGraphInfo(ofstream *out) const
+{
+  *out << Verbose(2) << "Atom " << Name << " is " << ((SeparationVertex) ? "a" : "not a") << " separation vertex, components are ";
+  OutputComponentNumber(out);
+  *out << " with Lowpoint " << LowpointNr << " and Graph Nr. " << GraphNr << "." << endl;
+};
+
+/** Output a list of flags, stating whether the bond was visited or not.
+ * Note, we make use of the last entry of the ComponentNr always being -1 if allocated.
+ * \param *out output stream for debugging
+ */
+void atom::OutputComponentNumber(ofstream *out) const
+{
+  if (ComponentNr != NULL) {
+    for (int i=0; ComponentNr[i] != -1; i++)
+      *out << ComponentNr[i] << " ";
+  }
+};
+
+
+/** Prints all bonds of this atom with total degree.
  * \param *out stream to output to
- * \param *NumberOfBondsPerAtom array with number of bonds per atomic index
- * \param ***ListOfBondsPerAtom array per atomic index of array with pointer to bond
  * \return true - \a *out present, false - \a *out is NULL
  */
-bool atom::OutputBondOfAtom(ofstream *out, int *NumberOfBondsPerAtom, bond ***ListOfBondsPerAtom) const
+bool atom::OutputBondOfAtom(ofstream *out) const
 {
   if (out != NULL) {
@@ -227 +266 @@
     if (type->Z != 1) {   // regard only non-hydrogen
 #endif
-      *out << Verbose(4) << "Atom " << Name << "/" << nr << " with " << NumberOfBondsPerAtom[nr] << " bonds: ";
+      *out << Verbose(4) << "Atom " << Name << "/" << nr << " with " << ListOfBonds.size() << " bonds: ";
       int TotalDegree = 0;
-      for (int j=0;j<NumberOfBondsPerAtom[nr];j++) {
-        *out << *ListOfBondsPerAtom[nr][j] << "\t";
-        TotalDegree += ListOfBondsPerAtom[nr][j]->BondDegree;
+      for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); ++Runner) {
+        *out << **Runner << "\t";
+        TotalDegree += (*Runner)->BondDegree;
       }
       *out << " -- TotalDegree: " << TotalDegree << endl;
@@ -240 +279 @@
   } else
     return false;
+};
+
+/** Output of atom::nr along with all bond partners.
+ * \param *AdjacencyFile output stream
+ */
+void atom::OutputAdjacency(ofstream *AdjacencyFile) const
+{
+  *AdjacencyFile << nr << "\t";
+  for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
+    *AdjacencyFile << (*Runner)->GetOtherAtom(this)->nr << "\t";
+  *AdjacencyFile << endl;
+};
+
+/** Puts a given bond into atom::ListOfBonds.
+ * \param *Binder bond to insert
+ */
+bool atom::RegisterBond(bond *Binder)
+{
+  bool status = false;
+  if (Binder != NULL) {
+    if (Binder->Contains(this)) {
+      ListOfBonds.push_back(Binder);
+      status = true;
+    } else {
+      cout << Verbose(1) << "ERROR: " << *Binder << " does not contain " << *this << "." << endl;
+    }
+  } else {
+    cout << Verbose(1) << "ERROR: Binder is " << Binder << "." << endl;
+  }
+  return status;
+};
+
+/** Removes a given bond from atom::ListOfBonds.
+ * \param *Binder bond to remove
+ */
+bool atom::UnregisterBond(bond *Binder)
+{
+  bool status = false;
+  if (Binder != NULL) {
+    if (Binder->Contains(this)) {
+      ListOfBonds.remove(Binder);
+      status = true;
+    } else {
+      cout << Verbose(1) << "ERROR: " << *Binder << " does not contain " << *this << "." << endl;
+    }
+  } else {
+    cout << Verbose(1) << "ERROR: Binder is " << Binder << "." << endl;
+  }
+  return status;
+};
+
+/** Removes all bonds from atom::ListOfBonds.
+ * \note Does not do any memory de-allocation.
+ */
+void atom::UnregisterAllBond()
+{
+  ListOfBonds.clear();
+};
+
+/** Corrects the bond degree by one at most if necessary.
+ * \param *out output stream for debugging
+ */
+int atom::CorrectBondDegree(ofstream *out)
+{
+  int NoBonds = 0;
+  int OtherNoBonds = 0;
+  int FalseBondDegree = 0;
+  atom *OtherWalker = NULL;
+  bond *CandidateBond = NULL;
+
+  *out << Verbose(3) << "Walker " << *this << ": " << (int)this->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+  NoBonds = CountBonds();
+  if ((int)(type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
+    for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner)) {
+      OtherWalker = (*Runner)->GetOtherAtom(this);
+      OtherNoBonds = OtherWalker->CountBonds();
+      *out << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
+      if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
+        if ((CandidateBond == NULL) || (ListOfBonds.size() > OtherWalker->ListOfBonds.size())) { // pick the one with fewer number of bonds first
+          CandidateBond = (*Runner);
+          *out << Verbose(3) << "New candidate is " << *CandidateBond << "." << endl;
+        }
+      }
+    }
+    if ((CandidateBond != NULL)) {
+      CandidateBond->BondDegree++;
+      *out << Verbose(2) << "Increased bond degree for bond " << *CandidateBond << "." << endl;
+    } else {
+      *out << Verbose(2) << "Could not find correct degree for atom " << *this << "." << endl;
+      FalseBondDegree++;
+    }
+  }
+  return FalseBondDegree;
 };
 
@@ -345 +477 @@
 {
   *file << nr << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << endl;
-  //cout << Verbose(2) << "Storing: " << Walker->nr << "\t" << (int)Walker->AdaptiveOrder << "\t" << (int)Walker->MaxOrder << "." << endl;
+  //cout << Verbose(2) << "Storing: " << nr << "\t" << (int)AdaptiveOrder << "\t" << (int)MaxOrder << "." << endl;
 }