- Fix ts buffer overwrite issue in BufferedTrajectory

- Rename per-frame and batch compute methods to be generic in ROG

Author: PardhavMaradani

mdadash/backend/analyses/rog.py

@@ -145,7 +145,7 @@ def on_input_change(self, attribute, _old_value, new_value):
             self.y_values = deque(maxlen=self.maxlen)
             self._set_x_values()
 
-    def _compute_rog_per_frame(self):
+    def _compute_per_frame(self):
         """Compute ROG values for current frame"""
         masses = self.ag.masses
         total_mass = np.sum(masses)
@@ -169,12 +169,12 @@ def _compute_rog_per_frame(self):
             rog,
         )
 
-    def _compute_rog_batch(self, batch_size):
+    def _compute_batch(self, batch_size):
         """Compute ROG values for current batch"""
         values = []
         for i in range(batch_size):
             _ = self.u.trajectory[i]
-            values.append(self._compute_rog_per_frame())
+            values.append(self._compute_per_frame())
         return values
 
     def _create_plot(self, values):
@@ -201,17 +201,17 @@ def _create_plot(self, values):
 
     def run_per_frame(self):
         """per-frame run handler"""
-        self._create_plot(self._compute_rog_per_frame())
+        self._create_plot(self._compute_per_frame())
 
     def run_batch(self, batch_size):
         """batch run handler"""
-        self._create_plot(self._compute_rog_batch(batch_size))
+        self._create_plot(self._compute_batch(batch_size))
 
     def get_parallel_job(self, batch_size):
         """get parallel job handler"""
         if self._run_frequency == "batch":
-            return delayed(self._compute_rog_batch)(batch_size)
-        return delayed(self._compute_rog_per_frame)()
+            return delayed(self._compute_batch)(batch_size)
+        return delayed(self._compute_per_frame)()
 
     def apply_parallel_results(self, values):
         """apply parallel results handler"""

mdadash/backend/kernel/core.py

@@ -51,6 +51,14 @@ def next(self):
         self._buffer.append(ts.copy())
         return ts
 
+    def _prepare_for_next(self):
+        """IMDReader during `_read_frame` loads the new frame into the current
+        timestep using `_load_imdframe_into_ts`. This will overwrite the values
+        if current ts is a reference to a buffer item. Hence make a copy to
+        prevent current buffer items from getting overwritten during iteration.
+        """
+        self._trajectory.ts = self._buffer[-1].copy()
+
 
 class CommHandler:
     """Comm Handler
@@ -293,6 +301,7 @@ def _trajectory_next(self, u, step):
             #   with support for 'Transmission rate' packet
             # Burn the timesteps until we reach the desired step
             # Don't use next() to avoid unnecessary transformations
+            u.trajectory._prepare_for_next()
             while (u.trajectory._frame + 1) % step != 0:
                 u.trajectory._read_next_timestep()
             u.trajectory.next()