Changeset 9861d0 for src

Timestamp:

Apr 10, 2018, 6:43:30 AM (7 years ago)

Author:

Frederik Heber <frederik.heber@…>

Branches:

AutomationFragmentation_failures, Candidate_v1.6.1, ChemicalSpaceEvaluator, Exclude_Hydrogens_annealWithBondGraph, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_contraction-expansion, Gui_displays_atomic_force_velocity, PythonUI_with_named_parameters, StoppableMakroAction, TremoloParser_IncreasedPrecision

Children:

825d33

Parents:

2f3905

git-author:

Frederik Heber <frederik.heber@…> (06/29/17 14:40:12)

git-committer:

Frederik Heber <frederik.heber@…> (04/10/18 06:43:30)

Message:

BondVectors now return subset of BondVectors for a given atom.

• functionality extracted from ForceAnnealing::annealWithBondgraph().
• also the mapped_t type is now kept up-to-date internally as we need it for returning the subset efficiently over a number of atoms, e.g. all in the given range.
• also moved a few simple implementations over to _impl module.

Location:

src/Dynamics

Files:

• BondVectors.cpp (modified) (3 diffs)
• BondVectors.hpp (modified) (3 diffs)
• BondVectors_impl.hpp (modified) (2 diffs)
• ForceAnnealing.hpp (modified) (2 diffs)

src/Dynamics/BondVectors.cpp

@@ -41 +41 @@
 #include <iterator>
 
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Log.hpp"
+
 #include "Atom/atom.hpp"
+#include "Bond/bond.hpp"
 
-BondVectors::mapped_t BondVectors::getBondVectorsAtStep(
+void BondVectors::recalculateBondVectorsAtStep(
     const size_t &_step) const
 {
-  mapped_t returnlist;
+  current_mapped_vectors.clear();
 
   ASSERT( !container.empty(),
@@ -56 +60 @@
         - current_bond->rightatom->getPositionAtStep(_step);
     BondVector.Normalize();
-    returnlist.insert( std::make_pair(current_bond, BondVector) );
+    current_mapped_vectors.insert( std::make_pair(current_bond, BondVector) );
   }
-  ASSERT( returnlist.size() == container.size(),
+  ASSERT( current_mapped_vectors.size() == container.size(),
       "BondVectors::getBondVectors() - not same amount of bond vectors as bonds?");
 
-  return returnlist;
+  map_is_dirty = false;
+  current_step_for_map = _step;
 }
 
@@ -76 +81 @@
 }
 
+std::vector<Vector> BondVectors::getAtomsBondVectorsAtStep(
+    const atom &_walker,
+    const size_t &_step) const
+{
+  if (map_is_dirty || (current_step_for_map != _step))
+    recalculateBondVectorsAtStep(_step);
+
+  std::vector<Vector> BondVectors;
+  // gather subset of BondVectors for the current atom
+  const BondList& ListOfBonds = _walker.getListOfBonds();
+  for(BondList::const_iterator bonditer = ListOfBonds.begin();
+      bonditer != ListOfBonds.end(); ++bonditer) {
+    const bond::ptr &current_bond = *bonditer;
+    const BondVectors::mapped_t::const_iterator bviter =
+        current_mapped_vectors.find(current_bond);
+    ASSERT( bviter != current_mapped_vectors.end(),
+        "ForceAnnealing() - cannot find current_bond ?");
+    ASSERT( bviter != current_mapped_vectors.end(),
+        "ForceAnnealing - cannot find current bond "+toString(*current_bond)
+        +" in bonds.");
+    BondVectors.push_back(bviter->second);
+  }
+  LOG(4, "DEBUG: BondVectors for atom #" << _walker.getId() << ": " << BondVectors);
+
+  return BondVectors;
+}

src/Dynamics/BondVectors.hpp

@@ -37 +37 @@
   typedef std::map<bond::ptr, Vector> mapped_t;
 
+  /** Default cstor for class BondVectors.
+   *
+   */
+  BondVectors();
+
   /** Prepares the internal container from the bonds of a range of atoms.
    *
@@ -53 +58 @@
    * \return const ref to internal container
    */
-  const container_t& getSorted() const
-  {
-    ASSERT( !container.empty(),
-        "BondVectors::getSorted() - empty internal container, not set properly?");
-    return container;
-  }
+  const container_t& getSorted() const;
 
-  /** Calculates the bond vector for each bond in the internal container and
-   * returns them in same order as the internal container.
+  /** Getter for the Bondvectors.
    *
    * \param _step time step for which the bond vector is request
    * \return a map from bond to bond vector
    */
-  mapped_t getBondVectorsAtStep(const size_t &_step) const;
+  const mapped_t& getBondVectorsAtStep(const size_t &_step) const;
 
   /** Get the position in the internal container for a specific bond.
@@ -75 +74 @@
   size_t getIndexForBond(const bond::ptr &_bond) const;
 
+  /** Gather the subset of BondVectors for the given atom.
+   *
+   * \param _walker atom to get BondVectors for
+   * \param _step time step for which the bond vector is request
+   */
+  std::vector<Vector> getAtomsBondVectorsAtStep(
+      const atom &_walker,
+      const size_t &_step) const;
+
+private:
+  /** Calculates the bond vector for each bond in the internal container.
+   *
+   * \param _step time step for which the bond vector is request
+   */
+  void recalculateBondVectorsAtStep(const size_t &_step) const;
+
 private:
   //!> internal container for sorted bonds
   container_t container;
+
+  //!> states whether map needs update or not
+  mutable bool map_is_dirty;
+
+  //!> contains the step for which the map was calculated
+  mutable size_t current_step_for_map;
+
+  //!> internal map for bond Bondvector association
+  mutable mapped_t current_mapped_vectors;
 };
 

src/Dynamics/BondVectors_impl.hpp

@@ -21 +21 @@
 #include "Atom/atom.hpp"
 
+BondVectors::BondVectors() :
+  map_is_dirty(false),
+  current_step_for_map((size_t)-1)
+{}
+
 template <class T>
 void BondVectors::setFromAtomRange(
@@ -36 +41 @@
   std::sort(container.begin(), container.end());
   container.erase(std::unique(container.begin(), container.end()), container.end());
+  map_is_dirty = true;
 }
 
+const BondVectors::mapped_t&
+BondVectors::getBondVectorsAtStep(const size_t &_step) const
+{
+  if (map_is_dirty || (current_step_for_map != _step))
+    recalculateBondVectorsAtStep(_step);
+  return current_mapped_vectors;
+}
+
+const BondVectors::container_t&
+BondVectors::getSorted() const
+{
+  ASSERT( !container.empty(),
+      "BondVectors::getSorted() - empty internal container, not set properly?");
+  return container;
+}
 
 #endif /* DYNAMICS_BONDVECTORS_IMPL_HPP_ */

src/Dynamics/ForceAnnealing.hpp

@@ -301 +301 @@
           << ", and CurrentStep is " << CurrentStep);
 
-      // get all bond vectors for this time step (from the perspective of the
-      // bonds taken from the currentStep)
-      const BondVectors::mapped_t bondvectors = bv.getBondVectorsAtStep(CurrentStep);
-
       for(typename AtomSetMixin<T>::const_iterator iter = AtomicForceManipulator<T>::atoms.begin();
           iter != AtomicForceManipulator<T>::atoms.end(); ++iter) {
@@ -317 +313 @@
 
           // gather subset of BondVectors for the current atom
-          std::vector<Vector> BondVectors;
-          for(BondList::const_iterator bonditer = ListOfBonds.begin();
-              bonditer != ListOfBonds.end(); ++bonditer) {
-            const bond::ptr &current_bond = *bonditer;
-            const BondVectors::mapped_t::const_iterator bviter =
-                bondvectors.find(current_bond);
-            ASSERT( bviter != bondvectors.end(),
-                "ForceAnnealing() - cannot find current_bond ?");
-            ASSERT( bviter != bondvectors.end(),
-                "ForceAnnealing - cannot find current bond "+toString(*current_bond)
-                +" in bonds.");
-            BondVectors.push_back(bviter->second);
-          }
-          LOG(4, "DEBUG: BondVectors for atom #" << walker.getId() << ": " << BondVectors);
+          std::vector<Vector> BondVectors = bv.getAtomsBondVectorsAtStep(walker, CurrentStep);
 
           // go through all its bonds and calculate what magnitude is represented