AMS-BP 0.0.231__py3-none-any.whl → 0.2.0__py3-none-any.whl

AMS_BP/groundtruth_generators/nuclearporecomplexes.py

@@ -0,0 +1,68 @@
+import numpy as np
+
+
+def generate_nup96_positions(
+    ring_diameter: float = 107.0,
+    molecule_spacing: float = 12.0,
+    ring_spacing: float = 50.0,
+) -> np.ndarray:
+    """
+    Generate the 3D coordinates of Nup96 proteins in the nuclear pore complex.
+
+    Parameters:
+    -----------
+    ring_diameter : float
+        Diameter of the main ring in nanometers (default: 107.0 nm)
+    molecule_spacing : float
+        Distance between two Nup96 molecules within same section (default: 12.0 nm)
+    ring_spacing : float
+        Distance between nuclear and cytoplasmic rings in z-direction (default: 50.0 nm)
+
+    Returns:
+    --------
+    numpy.ndarray
+        Array of shape (32, 3) containing x, y, z coordinates for all Nup96 proteins in um
+        First 32 coordinates are the main structural Nup96 (16 nuclear, 16 cytoplasmic)
+    """
+
+    # Initialize array to store coordinates
+    coordinates = np.zeros((32, 3))
+    ring_radius = ring_diameter / 2
+
+    # Generate positions for both main rings (nuclear and cytoplasmic)
+    for ring in range(2):  # 0 = nuclear side, 1 = cytoplasmic side
+        z = ring_spacing / 2 if ring == 0 else -ring_spacing / 2
+
+        for octant in range(8):
+            # Calculate base angle for this octant
+            base_angle = octant * 2 * np.pi / 8
+
+            # Calculate the center position of this octamer
+            center_x = ring_radius * np.cos(base_angle)
+            center_y = ring_radius * np.sin(base_angle)
+
+            # Place two Nup96 molecules in each octant section
+            for molecule in range(2):
+                # Calculate the offset direction perpendicular to the radius
+                perpendicular_angle = (
+                    base_angle
+                    + np.pi / 2
+                    + molecule_spacing / 3 * (1 if molecule == 0 else -1)
+                )
+
+                # Offset from center position
+                offset = (molecule_spacing / 3) * (-1 if molecule == 0 else 1) + (
+                    molecule_spacing / 5
+                ) * (-1 if ring == 0 else 1)
+
+                # Calculate final x and y coordinates
+                x = center_x + offset * np.cos(perpendicular_angle)
+                y = center_y + offset * np.sin(perpendicular_angle)
+
+                # Store coordinates
+                idx = ring * 16 + octant * 2 + molecule
+                coordinates[idx] = [x, y, z]
+                # add 1 nm gitter
+                coordinates[idx] += np.random.normal(0, 1, 3)
+
+    return coordinates / 1000.0

AMS_BP/motion/condensate_movement.py

@@ -15,16 +15,19 @@ Usage:
             "units_position":'um',
             "condensate_id":0,
             "initial_scale":0,
+            "oversample_motion_time":20,
         })
     Call the class object as follows to get the position and scale of the condensate at a given time:
         condensate(times, time_unit) -> dict{"Position":np.ndarray, "Scale":float}
 """
 
+from typing import Optional
+
 import numpy as np
 
-from ..cells.rectangular_cell import RectangularCell
+from ..cells import BaseCell
 from ..utils.decorators import cache
-from .track_gen import Track_generator as sf
+from .track_gen import Track_generator
 
 
 def create_condensate_dict(
@@ -32,7 +35,7 @@ def create_condensate_dict(
     initial_scale: np.ndarray,
     diffusion_coefficient: np.ndarray,
     hurst_exponent: np.ndarray,
-    cell: RectangularCell,
+    cell: BaseCell,
     **kwargs,
 ) -> dict:
     """
@@ -48,11 +51,14 @@ def create_condensate_dict(
         Array of shape (num_condensates, 2) representing the diffusion coefficients of the condensates.
     hurst_exponent : np.ndarray
         Array of shape (num_condensates, 2) representing the Hurst exponents of the condensates.
-    cell : RectangularCell
-        The rectangular cell that contains the condensates.
+    cell : BaseCell
+        The cell that contains the condensates.
     **kwargs : dict
         Additional arguments passed to `Condensate` class.
 
+        oversample_motion_time : int
+            smallest time unit for motion (time resolution for motion) (ms)
+
     Returns:
     --------
     dict
@@ -99,8 +105,10 @@ class Condensate:
         ID of the condensate.
     initial_scale: float = 0
         Initial scale of the condensate.
-    cell: RectangularCell = None
-        The rectangular cell that contains the condensates.
+    cell: BaseCell = None
+        The cell that contains the condensates.
+    oversample_motion_time: int = None
+        motion resolution
 
     """
 
@@ -114,7 +122,8 @@ class Condensate:
         units_position: str = "um",
         condensate_id: int = 0,
         initial_scale: float = 0,
-        cell: RectangularCell = None,
+        cell: Optional[BaseCell] = None,
+        oversample_motion_time: Optional[int] = None,
     ):
         self.initial_position = (
             np.array(initial_position)
@@ -138,13 +147,11 @@ class Condensate:
         self.units_position = units_position
         self.condensate_id = condensate_id
         self.initial_scale = initial_scale
-        if cell is None:
-            cell = RectangularCell(
-                origin=np.array([0, 0]), dimensions=np.array([0, 0, 0])
-            )
+
         self.cell = cell
         self.dim = self.initial_position.shape[0]
 
+        self.oversample_motion_time = oversample_motion_time
         # initialize the properties of the condensate
         self._initialize_properties()
 
@@ -261,28 +268,20 @@ class Condensate:
         # find the time difference
         time_difference = time - self.times[-1]
         # make a time array starting from the last time +1 and goin to the time inclusive
-        time_array = np.arange(self.times[-1] + 1, time + 1)
-        # Get cell bounds for track generator
-        min_bound, max_bound = self.cell.get_bounds()
-        cell_space = np.array(
-            [
-                [min_bound[0], max_bound[0]],  # x bounds
-                [min_bound[1], max_bound[1]],  # y bounds
-            ]
+        time_array = np.arange(
+            self.times[-1] + self.oversample_motion_time,
+            time + self.oversample_motion_time,
         )
-        cell_axial_range = (max_bound[2] - min_bound[2]) / 2.0
-        track_generator = sf.Track_generator(
-            cell_space=cell_space,
-            cell_axial_range=cell_axial_range,
-            cycle_count=500,
-            exposure_time=20,
-            interval_time=0,
-            oversample_motion_time=20,
+
+        track_generator = Track_generator(
+            cell=self.cell,
+            total_time=time,
+            oversample_motion_time=self.oversample_motion_time,
         )
         track = track_generator.track_generation_no_transition(
             diffusion_coefficient=self.diffusion_coefficient,
             hurst_exponent=self.hurst_exponent,
-            track_length=time_difference,
+            track_length=int(time_difference / self.oversample_motion_time),
             initials=self.condensate_positions[-1],
             start_time=self.times[-1],
         )

AMS_BP/motion/movement/__init__.py

@@ -1,10 +1,5 @@
-from .fbm_BP import FBM_BP
-from .boundary_conditions import _refecting_boundary, _absorbing_boundary
-from ...probabilityfuncs.markov_chain import MCMC_state_selection
+from boundedfbm import FBM_BP
 
 __all__ = [
     "FBM_BP",
-    "_refecting_boundary",
-    "_absorbing_boundary",
-    "MCMC_state_selection",
 ]

AMS_BP/motion/movement/boundary_conditions.py

@@ -1,11 +1,19 @@
+"""
+Deprecated module due to switching to the Pyvista model for 3D cell shapes.
+Removal Time: NDY (not determined yet)
+"""
+
 import numpy as np
 
-from ...utils.decorators import _catch_recursion_error
+from ...utils.decorators import _catch_recursion_error, deprecated
 
 # Reflecting boundary condition which is a recursive function so that even if the first candidate
 # is out of the space limit, the function will keep calling itself until the candidate is within the space limit
 
 
+@deprecated(
+    reason="Not used explicitly due to the use of Pyvista mesh objects to define shapes."
+)
 @_catch_recursion_error
 def _refecting_boundary(
     fbm_store_last: float, fbm_candidate: float, space_lim: np.ndarray
@@ -47,6 +55,9 @@ def _refecting_boundary(
 # Boundary condition where the step is set at the boundary limit if the candidate is out of the space limit
 
 
+@deprecated(
+    reason="Not used explicitly due to the use of Pyvista mesh objects to define shapes."
+)
 @_catch_recursion_error
 def _absorbing_boundary(
     fbm_store_last: float, fbm_candidate: float, space_lim: np.ndarray

AMS_BP/motion/track_gen.py

@@ -11,16 +11,12 @@ Classes:
 """
 
 import random
-from typing import Union, overload
+from typing import overload
 
 import numpy as np
+from boundedfbm.motion.FBM import FBM_BP
 
-from ..cells.rectangular_cell import RectangularCell
-from ..cells.rod_cell import RodCell
-from ..cells.spherical_cell import SphericalCell
-from .movement.fbm_BP import FBM_BP
-
-CellType = Union[SphericalCell, RodCell, RectangularCell]
+from ..cells import BaseCell
 
 
 class Track_generator:
@@ -29,60 +25,33 @@ class Track_generator:
 
     Parameters:
     -----------
-    cell : CellType
+    cell : BaseCell
         Cell object defining the space for track generation
-    cycle_count : int
-        The number of frames for the simulation.
-    exposure_time : int | float
-        Exposure time in milliseconds.
-    interval_time : int | float
-        Interval time between frames in milliseconds.
     oversample_motion_time : int | float
         Time for oversampling motion in milliseconds.
     """
 
     def __init__(
         self,
-        cell: CellType,
-        cycle_count: int,
-        exposure_time: int | float,
-        interval_time: int | float,
+        cell: BaseCell,
+        total_time: int | float,
         oversample_motion_time: int | float,
     ) -> None:
         self.cell = cell
         self._allowable_cell_types()
-        min_point, max_point = self.cell.get_bounds()
-
-        # Extract space limits from cell bounds
-        self.min_x = min_point[0]
-        self.max_x = max_point[0]
-        self.min_y = min_point[1]
-        self.max_y = max_point[1]
-        self.min_z = min_point[2]
-        self.max_z = max_point[2]
-
-        self.space_lim = np.array(
-            [
-                [self.min_x, self.max_x],
-                [self.min_y, self.max_y],
-                [self.min_z, self.max_z],
-            ]
-        )
 
-        self.cycle_count = cycle_count  # count of frames
-        self.exposure_time = exposure_time  # in ms
-        self.interval_time = interval_time  # in ms
         self.oversample_motion_time = oversample_motion_time  # in ms
         # total time in ms is the exposure time + interval time * (cycle_count) / oversample_motion_time
         # in ms
-        self.total_time = self._convert_frame_to_time(self.cycle_count)
+        self.total_time = total_time
 
     def _allowable_cell_types(self):
         # only allow rectangular cells for now
-        if not isinstance(self.cell, RectangularCell):
-            raise ValueError(
-                "Only rectangular cells are supported for track generation"
-            )
+        # if not isinstance(self.cell, RectangularCell):
+        #     raise ValueError(
+        #         "Only rectangular cells are supported for track generation"
+        #     )
+        pass
 
     def track_generation_no_transition(
         self,
@@ -118,42 +87,30 @@ class Track_generator:
         if np.shape(initials) == (2,):
             # change the shape to (3,)
             initials = np.array([initials[0], initials[1], 0])
-        # subtract each element of the first dimension of self.space_lim by the first element of initials
-        rel_space_lim = np.zeros((3, 2))
-        for i in range(3):
-            rel_space_lim[i] = self.space_lim[i] - initials[i]
-
         # convert the diffusion_coefficients
-        diffusion_coefficient = self._convert_diffcoef_um2s_um2xms(
-            diffusion_coefficient
-        )
+        # diffusion_coefficient = self._convert_diffcoef_um2s_um2xms(
+        #     diffusion_coefficient
+        # )
         fbm = FBM_BP(
             n=track_length,
-            dt=1,
+            dt=self.oversample_motion_time / 1000.0,
             hurst_parameters=[hurst_exponent],
             diffusion_parameters=[diffusion_coefficient],
             diffusion_parameter_transition_matrix=[1],
             hurst_parameter_transition_matrix=[1],
             state_probability_diffusion=[1],
             state_probability_hurst=[1],
-            space_lim=rel_space_lim[0],
+            cell=self.cell,
+            initial_position=initials,
         )
-        x = fbm.fbm()
-        # repeat for y,z
-        fbm.space_lim = rel_space_lim[1]
-        y = fbm.fbm()
-        fbm.space_lim = rel_space_lim[2]
-        z = fbm.fbm()
-        # convert to format [[x1,y1,z1],[x2,y2,z2],...]
-        xyz = np.stack((x, y, z), axis=-1)
+        xyz = fbm.fbm(dims=3)
         # make the times starting from the starting time
         track_times = np.arange(
             start_time,
             (track_length) * self.oversample_motion_time,
             self.oversample_motion_time,
         )
-        # add back the initial position to the track
-        track_xyz = xyz + initials
+        track_xyz = xyz
         # create the dict
         track_data = {
             "xy": track_xyz,
@@ -212,39 +169,30 @@ class Track_generator:
             # change the shape to (3,)
             initials = np.array([initials[0], initials[1], 0])
         # subtract each element of the first dimension of self.space_lim by the first element of initials
-        rel_space_lim = np.zeros((3, 2))
-        for i in range(3):
-            rel_space_lim[i] = self.space_lim[i] - initials[i]
+
         # convert the diffusion_coefficients
-        diffusion_parameters = self._convert_diffcoef_um2s_um2xms(diffusion_parameters)
+        # diffusion_parameters = self._convert_diffcoef_um2s_um2xms(diffusion_parameters)
         # initialize the fbm class
         fbm = FBM_BP(
             n=track_length,
-            dt=1,
+            dt=self.oversample_motion_time / 1000.0,
             hurst_parameters=hurst_parameters,
             diffusion_parameters=diffusion_parameters,
             diffusion_parameter_transition_matrix=diffusion_transition_matrix,
             hurst_parameter_transition_matrix=hurst_transition_matrix,
             state_probability_diffusion=diffusion_state_probability,
             state_probability_hurst=hurst_state_probability,
-            space_lim=rel_space_lim[0],
+            cell=self.cell,
+            initial_position=initials,
         )
-        x = fbm.fbm()
-        # repeat for y,z
-        fbm.space_lim = rel_space_lim[1]
-        y = fbm.fbm()
-        fbm.space_lim = rel_space_lim[2]
-        z = fbm.fbm()
-        # convert to format [[x1,y1,z1],[x2,y2,z2],...]
-        xyz = np.stack((x, y, z), axis=-1)
+        xyz = fbm.fbm(dims=3)
         # make the times starting from the starting time
         track_times = np.arange(
             start_time,
             track_length * self.oversample_motion_time,
             self.oversample_motion_time,
         )
-        # add back the initial position to the track
-        track_xyz = xyz + initials
+        track_xyz = xyz
         # create the dict
         track_data = {
             "xy": track_xyz,
@@ -321,7 +269,9 @@ class Track_generator:
         else:
             raise TypeError(f"Unsupported type: {type(diffusion_coefficient)}")
 
-    def _convert_time_to_frame(self, time: int) -> int:
+    def _convert_time_to_frame(
+        self, time: int, exposure_time: int, interval_time: int
+    ) -> int:
         """
         Parameters:
         -----------
@@ -333,11 +283,12 @@ class Track_generator:
         int: frame number
         """
         return int(
-            (time * self.oversample_motion_time)
-            / (self.exposure_time + self.interval_time)
+            (time * self.oversample_motion_time) / (exposure_time + interval_time)
         )
 
-    def _convert_frame_to_time(self, frame: int) -> int:
+    def _convert_frame_to_time(
+        self, frame: int, exposure_time: int, interval_time: int
+    ) -> int:
         """
         Parameters:
         -----------
@@ -348,7 +299,7 @@ class Track_generator:
         --------
         int: time in ms
         """
-        return int((frame * (self.exposure_time + self.interval_time)))
+        return int((frame * (exposure_time + interval_time)))
 
 
 def _initialize_points_per_time(total_time: int, oversample_motion_time: int) -> dict: