Index: src/Dynamics/BondVectors.cpp
===================================================================
--- src/Dynamics/BondVectors.cpp	(revision fd0b4a3700ae0c00d662810280e52405cc1914d1)
+++ src/Dynamics/BondVectors.cpp	(revision 24430bfbb8bd2761fd232ea9bd5d2745090a0d83)
@@ -41,10 +41,14 @@
 #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,10 +60,11 @@
         - 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,2 +81,28 @@
 }
 
+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;
+}
Index: src/Dynamics/BondVectors.hpp
===================================================================
--- src/Dynamics/BondVectors.hpp	(revision fd0b4a3700ae0c00d662810280e52405cc1914d1)
+++ src/Dynamics/BondVectors.hpp	(revision 24430bfbb8bd2761fd232ea9bd5d2745090a0d83)
@@ -37,4 +37,9 @@
   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,18 +58,12 @@
    * \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,7 +74,32 @@
   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;
 };
 
Index: src/Dynamics/BondVectors_impl.hpp
===================================================================
--- src/Dynamics/BondVectors_impl.hpp	(revision fd0b4a3700ae0c00d662810280e52405cc1914d1)
+++ src/Dynamics/BondVectors_impl.hpp	(revision 24430bfbb8bd2761fd232ea9bd5d2745090a0d83)
@@ -21,4 +21,9 @@
 #include "Atom/atom.hpp"
 
+BondVectors::BondVectors() :
+  map_is_dirty(false),
+  current_step_for_map((size_t)-1)
+{}
+
 template <class T>
 void BondVectors::setFromAtomRange(
@@ -36,6 +41,22 @@
   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_ */
Index: src/Dynamics/ForceAnnealing.hpp
===================================================================
--- src/Dynamics/ForceAnnealing.hpp	(revision fd0b4a3700ae0c00d662810280e52405cc1914d1)
+++ src/Dynamics/ForceAnnealing.hpp	(revision 24430bfbb8bd2761fd232ea9bd5d2745090a0d83)
@@ -301,8 +301,4 @@
           << ", 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,18 +313,5 @@
 
           // 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
