Diffusion

src/non_local_detector/analysis/distance1D.py

@@ -84,8 +84,8 @@ def _get_MAP_estimate_2d_position_edges(
     try:
         place_bin_center_2D_position = env.place_bin_center_2D_position_
     except AttributeError:
-        place_bin_center_2D_position = np.asarray(
-            env.place_bin_centers_nodes_df_.loc[:, ["x_position", "y_position"]]
+        place_bin_center_2D_position = (
+            env.get_bin_center_dataframe().loc[:, ["pos_x", "pos_y"]].to_numpy()
         )
 
     mental_position_2d = place_bin_center_2D_position[map_position_ind]
@@ -94,7 +94,7 @@ def _get_MAP_estimate_2d_position_edges(
     try:
         edge_id = env.place_bin_center_ind_to_edge_id_
     except AttributeError:
-        edge_id = np.asarray(env.place_bin_centers_nodes_df_.edge_id)
+        edge_id = env.get_bin_center_dataframe().edge_id.to_numpy()
 
     track_segment_id = edge_id[map_position_ind]
     mental_position_edges = np.asarray(list(track_graph.edges))[track_segment_id]
@@ -422,7 +422,7 @@ def get_ahead_behind_distance(
 
 def get_map_speed(
     posterior: xr.DataArray,
-    track_graph_with_bin_centers_edges: nx.Graph,
+    track_graph_bin_centers_edges: nx.Graph,
     place_bin_center_ind_to_node: np.ndarray,
     sampling_frequency: float = 500.0,
     smooth_sigma: float = 0.0025,
@@ -432,7 +432,7 @@ def get_map_speed(
     Parameters
     ----------
     posterior : xr.DataArray
-    track_graph_with_bin_centers_edges : nx.Graph
+    track_graph_bin_centers_edges : nx.Graph
         Track graph with bin centers as nodes and edges
     place_bin_center_ind_to_node : np.ndarray
         Mapping of place bin center index to node ID
@@ -460,7 +460,7 @@ def get_map_speed(
             speed,
             0,
             nx.shortest_path_length(
-                track_graph_with_bin_centers_edges,
+                track_graph_bin_centers_edges,
                 source=node_ids[0],
                 target=node_ids[1],
                 weight="distance",
@@ -471,7 +471,7 @@ def get_map_speed(
             speed,
             -1,
             nx.shortest_path_length(
-                track_graph_with_bin_centers_edges,
+                track_graph_bin_centers_edges,
                 source=node_ids[-2],
                 target=node_ids[-1],
                 weight="distance",
@@ -483,7 +483,7 @@ def get_map_speed(
         for node1, node2 in zip(node_ids[:-2], node_ids[2:]):
             speed.append(
                 nx.shortest_path_length(
-                    track_graph_with_bin_centers_edges,
+                    track_graph_bin_centers_edges,
                     source=node1,
                     target=node2,
                     weight="distance",
@@ -495,7 +495,7 @@ def get_map_speed(
             speed,
             0,
             nx.shortest_path_length(
-                track_graph_with_bin_centers_edges,
+                track_graph_bin_centers_edges,
                 source=node_ids[0],
                 target=node_ids[1],
                 weight="distance",
@@ -506,7 +506,7 @@ def get_map_speed(
             speed,
             -1,
             nx.shortest_path_length(
-                track_graph_with_bin_centers_edges,
+                track_graph_bin_centers_edges,
                 source=node_ids[-2],
                 target=node_ids[-1],
                 weight="distance",

src/non_local_detector/continuous_state_transitions.py

@@ -25,8 +25,8 @@ def _normalize_row_probability(x: np.ndarray) -> np.ndarray:
     """
     # Handle cases where the sum is zero to avoid division by zero -> NaN
     row_sums = x.sum(axis=1, keepdims=True)
-    # Use np.errstate to temporarily ignore invalid division warnings
-    with np.errstate(invalid="ignore"):
+    # Use np.errstate to temporarily ignore invalid division/zero warnings
+    with np.errstate(invalid="ignore", divide="ignore"):
         normalized_x = np.where(row_sums > 0, x / row_sums, 0.0)
     # Ensure any remaining NaNs (though unlikely with the above) are zero
     normalized_x[np.isnan(normalized_x)] = 0.0
@@ -187,8 +187,8 @@ def _handle_no_track_graph(self) -> np.ndarray:
         else:
             transition_matrix = (
                 multivariate_normal(mean=self.movement_mean, cov=self.movement_var)
-                .pdf(self.environment.distance_between_nodes_.flat)
-                .reshape(self.environment.distance_between_nodes_.shape)
+                .pdf(self.environment.distance_between_bins.flat)
+                .reshape(self.environment.distance_between_bins.shape)
             )
 
             if self.direction is not None:
@@ -198,14 +198,14 @@ def _handle_no_track_graph(self) -> np.ndarray:
                 }.get(self.direction.lower(), None)
 
                 centrality = nx.closeness_centrality(
-                    self.environment.track_graphDD, distance="distance"
+                    self.environment.track_graph_nd_, distance="distance"
                 )
                 center_node_id = list(centrality.keys())[
                     np.argmax(list(centrality.values()))
                 ]
                 transition_matrix *= direction_func(
-                    self.environment.distance_between_nodes_[:, [center_node_id]],
-                    self.environment.distance_between_nodes_[[center_node_id]],
+                    self.environment.distance_between_bins[:, [center_node_id]],
+                    self.environment.distance_between_bins[[center_node_id]],
                 )
 
         return transition_matrix
@@ -218,15 +218,15 @@ def _handle_with_track_graph(self) -> np.ndarray:
                 "Random walk with track graph is only implemented for 1D environments"
             )
 
-        place_bin_center_ind_to_node = np.asarray(
-            self.environment.place_bin_centers_nodes_df_.node_id
+        place_bin_center_ind_to_node = (
+            self.environment.get_bin_center_dataframe().reset_index().node_id.to_numpy()
         )
         return _random_walk_on_track_graph(
             self.environment.place_bin_centers_,
             self.movement_mean,
             self.movement_var,
             place_bin_center_ind_to_node,
-            self.environment.distance_between_nodes_,
+            self.environment.distance_between_bins,
         )
 
 
@@ -514,3 +514,35 @@ def make_state_transition(self, *args, **kwargs) -> np.ndarray:
         state_transition_matrix : np.ndarray, shape (1, 1)
         """
         return np.ones((1, 1))
+
+
+def calculate_rw_movement_variance(speed: float, time_step: float) -> float:
+    """Calculates the variance for a RandomWalk model based on speed.
+
+    Assumes the characteristic distance traveled in one time step
+    (speed * time_step) corresponds to the standard deviation of
+    displacement per dimension.
+
+    Parameters
+    ----------
+    speed : float
+        Characteristic speed (e.g., in cm/s).
+    time_step : float
+        Duration of one time step. Units must be consistent
+        with speed's time unit (e.g., in 0.002 s).
+
+    Returns
+    -------
+    movement_variance : float
+        The calculated variance (movement_var) for the RandomWalk model
+        (e.g., in cm^2).
+    """
+    if time_step <= 0:
+        raise ValueError("time_step must be positive.")
+
+    # Calculate characteristic distance
+    # (interpreted as standard deviation sigma)
+    sigma = speed * time_step
+
+    # Variance is sigma squared
+    return sigma**2