jhprinz · May 7, 2015 · Apr 27, 2015 · Apr 28, 2015 · Apr 28, 2015 · Apr 28, 2015
diff --git a/openpathsampling/ensemble.py b/openpathsampling/ensemble.py
@@ -47,6 +47,11 @@ def bad_direction_error(self):
     def check(self, trajectory=None, reset=None):
         """Checks and resets (if necessary) the ensemble cache.
         """
+        logger.debug("Checking cache....")
+        logger.debug("traj " + str([id(s) for s in trajectory]))
+        logger.debug("start_frame " + str(id(self.start_frame)))
+        logger.debug("prev_last " + str(id(self.prev_last_frame)))
+
         if trajectory is not None:
             # if the first frame has changed, we should reset
             if reset is None:
@@ -867,9 +872,9 @@ def _find_subtraj_final(self, traj, subtraj_first, ens_num,
         # we overshoot
         logger.debug("*Traj slice " + str(subtraj_first) + " " + 
                      str(subtraj_final+1) + " / " + str(traj_final))
-        logger.debug("Ensemble " + str(ens.__class__.__name__))# + str(ens))
-        logger.debug("Can-app " + str(ens.can_append(subtraj, trusted=True)))
-        logger.debug("Call    " + str(ens(subtraj, trusted=True)))
+        #logger.debug("Ensemble " + str(ens.__class__.__name__))# + str(ens))
+        #logger.debug("Can-app " + str(ens.can_append(subtraj, trusted=True)))
+        #logger.debug("Call    " + str(ens(subtraj, trusted=True)))
         while ( (ens.can_append(subtraj, trusted=True) or 
                  ens(subtraj, trusted=True)
                 ) and subtraj_final < traj_final):
@@ -1426,7 +1431,10 @@ def __init__(self, ensemble):
         self.trusted = None
         self._cache_can_append = EnsembleCache(+1)
         self._cache_call = EnsembleCache(+1)
-        self._cache_can_prepend = EnsembleCache(-1)
+        self._cache_can_prepend = EnsembleCache(+1) #TODO: this is weird
+        # cache_can_prepend has to think it is going forward because the
+        # frames given to it are from a forward growing trajectory... only
+        # later is everything turned around
 
     def __call__(self, trajectory, trusted=None):
         return self._new_ensemble(self._alter(trajectory), trusted)
@@ -1479,18 +1487,33 @@ class BackwardPrependedTrajectoryEnsemble(WrappedEnsemble):
     def __init__(self, ensemble, add_trajectory):
         super(BackwardPrependedTrajectoryEnsemble, self).__init__(ensemble)
         self.add_trajectory = add_trajectory
+        self._cached_trajectory = paths.Trajectory(add_trajectory)
 
     def _alter(self, trajectory):
         logger.debug("Starting BackwardPrepended._alter")
+        logger.debug("altered " + str([id(i) for i in self._cached_trajectory]))
+        reset = self._cache_can_prepend.check(trajectory)
+        logger.debug("altered " + str([id(i) for i in self._cached_trajectory]))
+        logger.debug("traj    " + str([id(i) for i in trajectory]))
+        logger.debug("trajrev " + str([id(i) for i in trajectory.reversed]))
+        #reset = False
+        if not reset:
+            logger.debug("BackwardPrended was not reset")
+            first_frame = trajectory[-1]
+            first_frame.reversed
+            if self._cached_trajectory[0] != first_frame:
+                self._cached_trajectory.insert(0,first_frame)
+        else:
+            self._cached_trajectory = trajectory.reversed + self.add_trajectory
 
-        revtraj = trajectory.reversed
-        altered = revtraj + self.add_trajectory
-
-        logger.debug("revtraj " + str([id(i) for i in revtraj]))
+        #logger.debug("revtraj " + str([id(i) for i in revtraj]))
         logger.debug("add     " + str([id(i) for i in self.add_trajectory]))
-        logger.debug("altered " + str([id(i) for i in altered]))
+        logger.debug("altered " + str([id(i) for i in self._cached_trajectory]))
+
+        return self._cached_trajectory
 
-        return altered
+    def can_append(self, trajectory, trusted=None):
+        raise RuntimeError("BackwardPrependedTrajectoryEnsemble.can_append is nonsense.")
 
 @ops_object
 class ForwardAppendedTrajectoryEnsemble(WrappedEnsemble):

diff --git a/openpathsampling/tests/testensemble.py b/openpathsampling/tests/testensemble.py
@@ -1452,33 +1452,29 @@ def test_caching_in_bkwdprep_seq(self):
             self.outX,
             self.inX & length1 
         ])
-        traj = make_1d_traj(ttraj['upper_in_out_in_in_out_in'])
+        traj = make_1d_traj(ttraj['upper_in_out_in_in_out_in'],
+                            velocities=[1.0]*6)
 
         # sanity checks before running the suffixed version
-        #assert_equal(pseudo_minus(traj), True)
-        #for i in range(-1, -6):
-            #assert_equal(pseudo_minus.can_prepend(traj[i:]), True)
+        assert_equal(pseudo_minus(traj), True)
+        for i in range(-1, -6):
+            assert_equal(pseudo_minus.can_prepend(traj[i:]), True)
 
         logger.debug("alltraj " + str([id(i) for i in traj]))
         ens = BackwardPrependedTrajectoryEnsemble(pseudo_minus, traj[-3:])
+        assert_equal(len(ens._cached_trajectory), 3)
+
         assert_equal(ens.can_prepend(traj[-4:-3].reversed), True)
-        #assert_equal(ens._cached_trajectory, traj[-4:])
-        #assert_equal(ens._cache_can_append.trusted, False)
+        assert_equal(len(ens._cached_trajectory), 4)
+        assert_equal(ens._cache_can_prepend.trusted, False)
 
         assert_equal(ens.can_prepend(traj[-5:-3].reversed), True)
-        #assert_equal(ens._cached_trajectory, traj[-5:])
-        #assert_equal(ens._cache_can_append.trusted, False)
+        assert_equal(len(ens._cached_trajectory), 5)
+        assert_equal(ens._cache_can_prepend.trusted, True)
 
         assert_equal(ens.can_prepend(traj[-6:-3].reversed), False)
-        #assert_equal(ens._cached_trajectory, traj[-6:])
-        #assert_equal(ens._cache_can_append.trusted, False)
-
-
-
-
-
-
-        pass
+        assert_equal(len(ens._cached_trajectory), 6)
+        assert_equal(ens._cache_can_prepend.trusted, True)
 
 class testMinusInterfaceEnsemble(EnsembleTest):
     def setUp(self):