AMS-BP 0.0.2__py3-none-any.whl

AMS_BP/configio/experiments.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from ..metadata.metadata import MetaData
+from ..sim_microscopy import VirtualMicroscope
+
+
+@dataclass
+class BaseExpConfig:
+    name: str
+    description: str
+
+
+@dataclass
+class TimeSeriesExpConfig(BaseExpConfig):
+    z_position: float
+    laser_names_active: List[str]
+    laser_powers_active: List[float]
+    laser_positions_active: List
+    xyoffset: Tuple[float, float]
+
+    exposure_time: Optional[int] = None
+    interval_time: Optional[int] = None
+    duration_time: Optional[int] = None
+
+    def __post_init__(self):
+        len_ln = len(self.laser_names_active)
+        len_lpow = len(self.laser_powers_active)
+        len_lpos = len(self.laser_positions_active)
+        if len_ln != len_lpos or len_ln != len_lpow:
+            raise ValueError(
+                f"Length mismatch among lists: "
+                f"laser_names_active({len_ln}), "
+                f"laser_powers_active({len_lpow}), "
+                f"laser_positions_active({len_lpos})"
+            )
+        if self.exposure_time or self.interval_time or self.duration_time:
+            raise ValueError(
+                "Please do not define exposure_time, interval_time, or duration_time in a time series experiment component. Use the GlobalParameters to set this."
+            )
+        self.laser_powers = {
+            self.laser_names_active[i]: self.laser_powers_active[i]
+            for i in range(len(self.laser_names_active))
+        }
+        self.laser_positions = {
+            self.laser_names_active[i]: self.laser_positions_active[i]
+            for i in range(len(self.laser_names_active))
+        }
+
+
+@dataclass
+class zStackExpConfig(BaseExpConfig):
+    z_position: List[float]
+    laser_names_active: List[str]
+    laser_powers_active: List[float]
+    laser_positions_active: List
+    xyoffset: Tuple[float, float]
+
+    exposure_time: int
+    interval_time: int
+
+    def __post_init__(self):
+        len_ln = len(self.laser_names_active)
+        len_lpow = len(self.laser_powers_active)
+        len_lpos = len(self.laser_positions_active)
+        if len_ln != len_lpos or len_ln != len_lpow:
+            raise ValueError(
+                f"Length mismatch among lists: "
+                f"laser_names_active({len_ln}), "
+                f"laser_powers_active({len_lpow}), "
+                f"laser_positions_active({len_lpos})"
+            )
+        self.laser_powers = {
+            self.laser_names_active[i]: self.laser_powers_active[i]
+            for i in range(len(self.laser_names_active))
+        }
+        self.laser_positions = {
+            self.laser_names_active[i]: self.laser_positions_active[i]
+            for i in range(len(self.laser_names_active))
+        }
+
+
+def timeseriesEXP(
+    microscope: VirtualMicroscope,
+    config: TimeSeriesExpConfig,
+) -> Tuple[np.ndarray, MetaData]:
+    frames, metadata = microscope.run_sim(
+        z_val=config.z_position,
+        laser_power=config.laser_powers,
+        laser_position=config.laser_positions,
+        xyoffset=config.xyoffset,
+        duration_total=config.duration_time,
+        exposure_time=config.exposure_time,
+        interval_time=config.interval_time,
+    )
+    return np.array([frames]), metadata
+
+
+def zseriesEXP(
+    microscope: VirtualMicroscope,
+    config: zStackExpConfig,
+) -> Tuple[np.ndarray, MetaData]:
+    frames = []
+    for i in config.z_position:
+        f, m = microscope.run_sim(
+            z_val=i,
+            laser_power=config.laser_powers,
+            laser_position=config.laser_positions,
+            xyoffset=config.xyoffset,
+            duration_total=config.exposure_time + config.interval_time,
+            exposure_time=config.exposure_time,
+            interval_time=config.interval_time,
+        )
+        frames.append(f)
+    # m.Channel = {"name": microscope.channels.names}
+    # m.TimeIncrementUnit = None
+    # m.TimeIncrement = None
+    metadata = m
+    return np.array(frames), metadata

AMS_BP/configio/saving.py

@@ -0,0 +1,32 @@
+import json
+import os
+
+import numpy as np
+from tifffile import TiffWriter
+
+from ..configio.configmodels import OutputParameters
+from ..metadata.metadata import MetaData
+
+
+def save_config_frames(
+    config: MetaData, frames: np.ndarray, outputparams: OutputParameters
+) -> None:
+    cd = outputparams.output_path
+    # make the directory if it does not exist
+    if not os.path.exists(cd):
+        os.makedirs(cd)
+
+    with TiffWriter(
+        os.path.join(cd, outputparams.output_name + ".ome" + ".tiff"), bigtiff=True
+    ) as f:
+        f.write(
+            frames,
+            metadata=config.model_dump(exclude={"notes"}),
+        )
+    # make json ster. from the MetaData
+    metadata_json = config.model_dump()
+
+    # save json
+    json_path = os.path.join(cd, "metadata.json")
+    with open(json_path, "w") as f:
+        json.dump(metadata_json, f)

AMS_BP/metadata/metadata.py

@@ -0,0 +1,87 @@
+from typing import Iterator, List, Literal, Union
+
+from pydantic import BaseModel
+
+
+class StringNode:
+    def __init__(self, value: Union[str, List["StringNode"]] = None) -> None:
+        """Initialize a node with either a string or a nested list of nodes."""
+        if isinstance(value, str):
+            self.value = value
+            self.children = None
+        elif isinstance(value, list):
+            self.value = None
+            self.children = value
+        elif value is None:
+            self.value = None
+            self.children = []
+        else:
+            raise ValueError("Value must be a string, a list of StringNode, or None.")
+
+    def is_leaf(self) -> bool:
+        """Check if this node is a leaf node (contains a string)."""
+        return self.value is not None
+
+    def add(self, child: "StringNode") -> None:
+        """Add a child node to this node."""
+        if self.is_leaf():
+            raise TypeError("Cannot add children to a leaf node.")
+        self.children.append(child)
+
+    def remove(self, child: "StringNode") -> None:
+        """Remove a child node."""
+        if self.is_leaf():
+            raise TypeError("Cannot remove children from a leaf node.")
+        self.children.remove(child)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the node."""
+        if self.is_leaf():
+            return f"StringNode(value={self.value!r})"
+        return f"StringNode(children={self.children!r})"
+
+    def __iter__(self) -> Iterator["StringNode"]:
+        """Iterate over children if this is not a leaf node."""
+        if not self.is_leaf():
+            return iter(self.children)
+        raise TypeError("Leaf nodes are not iterable.")
+
+
+def to_string_node(nested: Union[str, List]) -> StringNode:
+    """
+    Convert a nested list of strings into a StringNode structure.
+
+    Args:
+        nested: A string or a nested list of strings.
+
+    Returns:
+        A StringNode representing the nested structure.
+    """
+    if isinstance(nested, str):
+        # Base case: If it's a string, create a leaf node
+        return StringNode(nested)
+    elif isinstance(nested, list):
+        # Recursive case: If it's a list, create a parent node with children
+        children = [to_string_node(item) for item in nested]
+        return StringNode(children)
+    else:
+        raise ValueError("Input must be a string or a nested list of strings.")
+
+
+class MetaData(BaseModel):
+    notes: StringNode | list | str
+    axes: str
+    TimeIncrement: float
+    TimeIncrementUnit: Literal["s", "ms"]
+    PhysicalSizeX: float
+    PhysicalSizeXUnit: Literal["nm", "m"]
+    PhysicalSizeY: float
+    PhysicalSizeYUnit: Literal["nm", "m"]
+    # Channel: Dict[Literal["Name"], List[str]]
+
+    def __post_init__(self):
+        if isinstance(self.notes, (list, str)):
+            self.notes = to_string_node(self.notes)
+
+    class Config:
+        arbitrary_types_allowed = True

AMS_BP/motion/__init__.py

@@ -0,0 +1,4 @@
+from .condensate_movement import Condensate, create_condensate_dict
+from .track_gen import Track_generator
+
+__all__ = ["Condensate", "create_condensate_dict", "Track_generator"]

AMS_BP/motion/condensate_movement.py

@@ -0,0 +1,356 @@
+"""
+Contains class for storing condensate data. Condensates are defined as spherical always; defined by a
+center (x,y,z), radius (r), and time (t). The complete description of the condensate at any time (t) is:
+(x,y,z,r,t).
+
+Usage:
+------
+    Initialize the class as follows:
+        condensate = Condensate(**{
+            "initial_position":np.array([0, 0, 0]),
+            "initial_time":0,
+            "diffusion_coefficient":0,
+            "hurst_exponent":0,
+            "units_time":'ms',
+            "units_position":'um',
+            "condensate_id":0,
+            "initial_scale":0,
+        })
+    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}
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ..cells.rectangular_cell import RectangularCell
+from ..utils.decorators import cache
+from .track_gen import Track_generator as sf
+
+
+def create_condensate_dict(
+    initial_centers: np.ndarray,
+    initial_scale: np.ndarray,
+    diffusion_coefficient: np.ndarray,
+    hurst_exponent: np.ndarray,
+    cell: RectangularCell,
+    **kwargs,
+) -> dict:
+    """
+    Creates a dictionary of condensates for simulation.
+
+    Parameters:
+    -----------
+    initial_centers : np.ndarray
+        Array of shape (num_condensates, 2) representing the initial centers of the condensates.
+    initial_scale : np.ndarray
+        Array of shape (num_condensates, 2) representing the initial scales of the condensates.
+    diffusion_coefficient : np.ndarray
+        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.
+    **kwargs : dict
+        Additional arguments passed to `Condensate` class.
+
+    Returns:
+    --------
+    dict
+        A dictionary of `Condensate` objects with keys as condensate IDs.
+    """
+    # check the length of diffusion_coefficient to find the number of condensates
+    num_condensates = len(diffusion_coefficient)
+    condensates = {}
+    units_time = kwargs.get("units_time", ["ms"] * num_condensates)
+    for i in range(num_condensates):
+        condensates[str(i)] = Condensate(
+            initial_position=initial_centers[i],
+            initial_scale=initial_scale[i],
+            diffusion_coefficient=diffusion_coefficient[i],
+            hurst_exponent=hurst_exponent[i],
+            condensate_id=int(str(i)),
+            units_time=units_time[i],
+            cell=cell,
+        )
+    return condensates
+
+
+class Condensate:
+    """Condensate class for storing condensate data.
+
+    Parameters:
+    -----------
+    initial_position: np.ndarray = np.array([0, 0, 0])
+        Initial position of the condensate.
+    initial_time: float = 0
+        Initial time of the condensates.
+    diffusion_coefficient: float = 0
+        Diffusion coefficient of the condensate.
+    hurst_exponent: float = 0
+        Hurst exponent of the condensate.
+    units_time: str = 's'
+        Units of time. Units work as follows: in the class reference frame, start from 0 and iterate by 1 each time.
+        For a units_time of "ms", 1 represents 1ms.
+        For a units_time of "s", 1 represents 1s.
+        For a units_time of "20ms", 1 represents 20ms.
+    units_position: str = 'um'
+        Units of position.
+    condensate_id: int = 0
+        ID of the condensate.
+    initial_scale: float = 0
+        Initial scale of the condensate.
+    cell: RectangularCell = None
+        The rectangular cell that contains the condensates.
+
+    """
+
+    def __init__(
+        self,
+        initial_position: np.ndarray = np.array([0, 0, 0]),
+        initial_time: int = 0,
+        diffusion_coefficient: float = 0,  # same units as position and time
+        hurst_exponent: float = 0,  # 0<hurst_exponent<1
+        units_time: str = "ms",
+        units_position: str = "um",
+        condensate_id: int = 0,
+        initial_scale: float = 0,
+        cell: RectangularCell = None,
+    ):
+        self.initial_position = (
+            np.array(initial_position)
+            if not isinstance(initial_position, np.ndarray)
+            else initial_position
+        )
+        self.initial_time = (
+            int(initial_time) if not isinstance(initial_time, int) else initial_time
+        )
+        self.diffusion_coefficient = (
+            np.array(diffusion_coefficient)
+            if not isinstance(diffusion_coefficient, np.ndarray)
+            else diffusion_coefficient
+        )
+        self.hurst_exponent = (
+            np.array(hurst_exponent)
+            if not isinstance(hurst_exponent, np.ndarray)
+            else hurst_exponent
+        )
+        self.units_time = units_time
+        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]
+
+        # initialize the properties of the condensate
+        self._initialize_properties()
+
+    def _initialize_properties(self) -> None:
+        """Initializes the properties of the condensate."""
+        self.times = np.array([self.initial_time])
+        self.condensate_positions = np.array([self.initial_position])
+        self.scale = np.array([self.initial_scale])
+
+    @property
+    def times(self) -> np.ndarray:
+        """Returns the times of the condensate."""
+        return self._times
+
+    @times.setter
+    def times(self, value) -> None:
+        # make sure this is a numpy array
+        if not isinstance(value, np.ndarray):
+            raise TypeError("Times must be a numpy array.")
+        self._times = value
+
+    @property
+    def condensate_positions(self) -> np.ndarray:
+        """Returns the positions of the condensate."""
+        # make sure this is a numpy array and that it is the same dimension as the initial position
+        return self._condensate_positions
+
+    @condensate_positions.setter
+    def condensate_positions(self, value) -> None:
+        if not isinstance(value, np.ndarray):
+            raise TypeError("Condensate positions must be a numpy array.")
+        if value.shape[1] != self.dim:
+            raise ValueError(
+                "Condensate positions must be the same dimension as the initial position."
+            )
+        self._condensate_positions = value
+
+    @property
+    def scale(self) -> np.ndarray:
+        """Returns the scale of the condensate."""
+        return self._scale
+
+    @scale.setter
+    def scale(self, value) -> None:
+        self._scale = value
+
+    def add_positions(
+        self, time: np.ndarray, position: np.ndarray, scale: np.ndarray
+    ) -> None:
+        """Adds positions to the condensate.
+
+        Parameters:
+        -----------
+        time: np.ndarray
+            Times at which to add positions.
+        position: np.ndarray
+            Positions to add to the condensate.
+        scale: np.ndarray
+            Scale to add to the condensate.
+        """
+        self.times = np.append(self.times, time)
+        self.condensate_positions = np.append(
+            self.condensate_positions, position, axis=0
+        )
+        self.scale = np.append(self.scale, scale)
+
+    @cache
+    def __call__(self, time: int, time_unit: str) -> dict:
+        """Returns the position and scale of the condensate at a given time.
+
+        Parameters:
+        -----------
+        time: float
+            Time at which to return the position of the condensate. User needs to convert to the reference frame of the condensate class.
+        time_unit: str
+            Units of time.
+            Just to make sure the user is aware of the conversion they need to do to get into the reference frame of the condensate class.
+
+        Returns:
+        --------
+        Dict of the position and scale of the condensate at the given time.
+            Keys:
+                Position: np.ndarray
+                    Position of the condensate at the given time.
+                Scale: float
+                    Scale of the condensate at the given time.
+        """
+        if time_unit != self.units_time:
+            # raise error that you need to ask for the time units in the condensates reference frame
+            raise ValueError("Time units do not match to the condensate.")
+        # check if the _condensate_positions exists
+        if not hasattr(self, "_condensate_positions"):
+            # if it doesn't then we need to generate the condensate positions
+            self.times = np.array([self.initial_time])
+            self.condensate_positions = np.array([self.initial_position])
+            self.scale = np.array([self.initial_scale])
+        # if the time larger than the last time in the condensate_positions then we need to generate more positions
+        if time > self.times[-1]:
+            self.generate_condensate_positions(time)
+
+        return {
+            "Position": self.condensate_positions[self.times == time][0],
+            "Scale": self.scale[self.times == time][0],
+        }
+
+    def generate_condensate_positions(self, time: int) -> None:
+        """Generates the condensate positions up to a given time.
+
+        Parameters:
+        -----------
+        time: int
+            Time up to which to generate the condensate positions.
+        """
+        # 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
+            ]
+        )
+        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 = track_generator.track_generation_no_transition(
+            diffusion_coefficient=self.diffusion_coefficient,
+            hurst_exponent=self.hurst_exponent,
+            track_length=time_difference,
+            initials=self.condensate_positions[-1],
+            start_time=self.times[-1],
+        )
+        track_xyz = track["xy"][:]
+        # take all the x,y,z
+        track_xyz = track_xyz[:, :]
+        # get the scale for the time array and positions
+        scales = self.calculate_scale(time_array, track_xyz)
+        # add the positions to the condensate_positions
+        self.add_positions(time_array, track_xyz, scales)
+
+    def calculate_scale(self, time: np.ndarray, position: np.ndarray) -> np.ndarray:
+        """Calculates the scale of the condensate at a given time.
+
+        Parameters:
+        -----------
+        time: np.ndarray
+            Times at which to calculate the scale.
+        position: np.ndarray
+            Positions at which to calculate the scale.
+        """
+        # find the last scale in the scale array
+        last_scale = self.scale[-1]
+        # make array of length time with the last scale
+        scale = np.full(time.shape, last_scale)
+        return scale
+
+    def plot_condensate(self, ax, **kwargs):
+        """
+        Plots the condensate
+
+        Parameters:
+        -----------
+        ax: plt.Axes
+            Axes to plot the condensate on.
+        **kwargs:
+            Keyword arguments to pass to the plot function.
+        """
+        # check if the _condensate_positions exists
+        if not hasattr(self, "_condensate_positions"):
+            # if it doesn't then we need to generate the condensate positions
+            self.times = np.array([self.initial_time])
+            self.condensate_positions = np.array([self.initial_position])
+            self.scale = np.array([self.initial_scale])
+
+        # plot the condensate positions
+        ax.plot(
+            self.condensate_positions[:, 0], self.condensate_positions[:, 1], **kwargs
+        )
+
+        # plot a circle at all the positions with the scale as the radius
+        for i in range(len(self.condensate_positions)):
+            ax.add_patch(
+                plt.Circle(
+                    self.condensate_positions[i], self.scale[i], color="r", fill=False
+                )
+            )
+
+        # plot the initial position in a different colour
+        ax.scatter(self.initial_position[0], self.initial_position[1], color="g")
+        # plot the final position in a different colour
+        ax.scatter(
+            self.condensate_positions[-1][0],
+            self.condensate_positions[-1][1],
+            color="b",
+        )
+        if "save_path" in kwargs:
+            plt.savefig(kwargs["save_path"])
+        # plt.show()
+        return ax

AMS_BP/motion/movement/__init__.py

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

AMS_BP/motion/movement/boundary_conditions.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+from ...utils.decorators import _catch_recursion_error
+
+# 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
+
+
+@_catch_recursion_error
+def _refecting_boundary(
+    fbm_store_last: float, fbm_candidate: float, space_lim: np.ndarray
+) -> float:
+    """Reflecting boundary condition for the FBM 1D
+
+    Parameters:
+    -----------
+    fbm_store_last : float
+        Last value of the FBM
+    fbm_candidate : float
+        Candidate value of the FBM
+    space_lim : np.ndarray
+        Space limit (min, max) for the FBM
+
+    Returns:
+    --------
+    float
+        New value of the FBM
+    """
+    if fbm_candidate > space_lim[1]:
+        # if the candidate is greater than the space limit then reflect the difference back into the space limit
+        return _refecting_boundary(
+            fbm_store_last,
+            space_lim[1] - np.abs(fbm_candidate - space_lim[1]),
+            space_lim,
+        )
+    elif fbm_candidate < space_lim[0]:
+        # if the candidate is less than the negative space limit then reflect the difference back into the space limit
+        return _refecting_boundary(
+            fbm_store_last,
+            space_lim[0] + np.abs(fbm_candidate - space_lim[0]),
+            space_lim,
+        )
+    else:
+        return fbm_candidate
+
+
+# Boundary condition where the step is set at the boundary limit if the candidate is out of the space limit
+
+
+@_catch_recursion_error
+def _absorbing_boundary(
+    fbm_store_last: float, fbm_candidate: float, space_lim: np.ndarray
+) -> float:
+    """Absorbing boundary condition for the FBM 1D
+
+    Parameters:
+    -----------
+    fbm_store_last : float
+        Last value of the FBM
+    fbm_candidate : float
+        Candidate value of the FBM
+    space_lim : np.ndarray
+        Space limit (min, max) for the FBM
+
+    Returns:
+    --------
+    float
+        New value of the FBM
+    """
+    if fbm_candidate > space_lim[1]:
+        return space_lim[1]
+    elif fbm_candidate < space_lim[0]:
+        return space_lim[0]
+    else:
+        return fbm_candidate