AMS-BP 0.0.26__py3-none-any.whl → 0.0.32__py3-none-any.whl

AMS_BP/__init__.py

@@ -10,4 +10,4 @@ Last updated: 2024-12-16
 
 """
 
-__version__ = "0.0.26"
+__version__ = "0.0.32"

AMS_BP/configio/convertconfig.py

@@ -770,7 +770,7 @@ def make_sample(global_params, cell_params) -> SamplePlane:
             (0, global_params.sample_plane_dim[0]),
             (0, global_params.sample_plane_dim[1]),
             (-cell_params.cell_axial_radius, cell_params.cell_axial_radius),
-        ),
+        ),  # simulates the whole simulation space to avoid the issue of PSF bleeding into FOV if the molecule's location is technically outside of the FOV dictated by the camera detector size and objective magnification.
         oversample_motion_time=global_params.oversample_motion_time,
         t_end=totaltime,
     )

AMS_BP/groundtruth_generators/__init__.py

@@ -0,0 +1,3 @@
+from .nuclearporecomplexes import generate_nup96_positions
+
+__all__ = ["generate_nup96_positions"]

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/movement/fbm_BP.py

@@ -1,6 +1,7 @@
 import numpy as np
-from .boundary_conditions import _refecting_boundary, _absorbing_boundary
+
 from ...probabilityfuncs.markov_chain import MCMC_state_selection
+from .boundary_conditions import _absorbing_boundary, _refecting_boundary
 
 BOUNDARY_CONDITIONS = {
     "reflecting": _refecting_boundary,
@@ -161,10 +162,8 @@ class FBM_BP:
         phi = np.zeros(self.n)
         psi = np.zeros(self.n)
         # construct a gaussian noise vector
-        gn = (
-            np.random.normal(0, 1, self.n)
-            * np.sqrt(self.dt * 2 * self._diff_a_n)
-            * (self.dt ** (2 * self._hurst_n))
+        gn = np.random.normal(0, 1, self.n) * np.sqrt(
+            2 * self._diff_a_n * (self.dt ** (2 * self._hurst_n))
         )
         # catch is all hurst are 0.5 then use the gaussian noise vector corresponding to the scale defined by the diffusion parameter
         if np.all(self._hurst_n == 0.5):

AMS_BP/motion/track_gen.py

@@ -124,12 +124,12 @@ class Track_generator:
             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],
@@ -216,11 +216,11 @@ class Track_generator:
         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,

AMS_BP/optics/lasers/laser_profiles.py

@@ -23,17 +23,21 @@ class LaserParameters:
 
     wavelength: float  # Wavelength in nanometers
     power: Union[float, Callable[[float], float]]  # Power in watts
-    beam_width: float  # 1/e² beam width at waist in microns
+    beam_width: Optional[float] = None  # 1/e² beam width at waist in microns
     numerical_aperture: Optional[float] = None  # NA of focusing lens
-    position: Union[Tuple[float, float, float], Callable[[float], np.ndarray]] = (
+    position: Union[
+        Tuple[float, float, float], Callable[[float], Tuple[float, float, float]]
+    ] = (
         0.0,
         0.0,
         0.0,
     )
-    refractive_index: float = 1.0  # Refractive index of medium
+    refractive_index: Optional[float] = 1.0  # Refractive index of medium
 
     def __post_init__(self):
         """Validate parameters after initialization."""
+        if not self.beam_width:
+            self.beam_width = self.diffraction_limited_width
         self._validate_parameters()
         self._compute_derived_parameters()
         self.max_power = self.power

AMS_BP/optics/lasers/scanning_patterns.py

@@ -0,0 +1,102 @@
+import math
+from functools import partial
+from typing import Callable, List, Tuple
+
+import numpy as np
+
+"""Currently unused module"""
+
+
+def plane_point_scan(
+    x_lims: List[float],
+    y_lims: List[float],
+    step_xy: float,
+) -> np.ndarray:
+    """
+    Generate a point scanning pattern for a confocal microscope plane scan.
+
+    Args:
+        x_lims (List[float]): [min_x, max_x] scanning limits in x direction
+        y_lims (List[float]): [min_y, max_y] scanning limits in y direction
+        step_xy (float): Step size between points in both x and y directions
+
+    Returns:
+        np.ndarray: Array of shape (n_points, 2) containing [x, y] coordinates for the scan
+    """
+    # Calculate number of points in each dimension
+    nx = math.ceil((x_lims[1] - x_lims[0]) / step_xy) + 1
+    ny = math.ceil((y_lims[1] - y_lims[0]) / step_xy) + 1
+
+    # Generate coordinate arrays
+    x = np.linspace(x_lims[0], x_lims[1], nx)
+    y = np.linspace(y_lims[0], y_lims[1], ny)
+
+    # Create meshgrid for all coordinates
+    xx, yy = np.meshgrid(x, y)
+
+    # Convert to scan pattern array
+    # For even rows, reverse x direction for serpentine scan
+    scan_points = []
+    for i in range(ny):
+        row_x = xx[i]
+        row_y = yy[i]
+
+        if i % 2 == 1:  # Reverse even rows for serpentine pattern
+            row_x = row_x[::-1]
+
+        points = np.column_stack((row_x, row_y))
+        scan_points.append(points)
+
+    # Combine all points into final array
+    scan_pattern = np.vstack(scan_points)
+
+    return scan_pattern
+
+
+def confocal_pointscan_time_z(
+    x_lims: List[float],
+    y_lims: List[float],
+    step_xy: float,  # can be defined as the beam width at the focus plane
+    frame_exposure_time: float,  # s
+) -> Tuple[Callable[[float, float], Tuple[float, float, float]], float]:
+    scan_pattern = plane_point_scan(x_lims=x_lims, y_lims=y_lims, step_xy=step_xy)
+    scan_pattern_len = len(scan_pattern)
+
+    dwell_time = frame_exposure_time / scan_pattern_len
+
+    def return_laser_position(
+        z_position: float, time: float
+    ) -> Tuple[float, float, float]:
+        index_frame = time % frame_exposure_time
+        ind = int(index_frame / dwell_time)
+        # print(index_frame, ind)
+        return (*scan_pattern[ind], z_position)
+
+    return return_laser_position, dwell_time
+
+
+def confocal_pointscan_time_z0(
+    x_lims: List[float],
+    y_lims: List[float],
+    step_xy: float,  # can be defined as the beam width at the focus plane
+    frame_exposure_time: float,  # s
+    z_val: float,  # um
+) -> Tuple[Callable[[float], Tuple[float, float, float]], float]:
+    """
+    Create a generator for a point scanning pattern for a confocal microscope plane scan which takes in a time and returns the postion of the laser.
+
+    Args:
+        x_lims (List[float]): [min_x, max_x] scanning limits in x direction
+        y_lims (List[float]): [min_y, max_y] scanning limits in y direction
+        step_xy (float): Step size between points in both x and y directions
+        frame_exposure_time (float): exposure time of the frame
+        z_val (float): z value of the sample plane
+
+    Returns:
+        Callable[time]: (x,y,z) position of the laser
+        dwell_time (float): the dwell time per position
+    """
+    func, dwell_time = confocal_pointscan_time_z(
+        x_lims, y_lims, step_xy, frame_exposure_time
+    )
+    return partial(func, z_val), dwell_time

AMS_BP/optics/psf/psf_engine.py

@@ -85,15 +85,19 @@ class PSFEngine:
         self._grid_xy = _generate_grid(self._psf_size, self.params.pixel_size)
 
         # Pre-calculate normalized sigma values
-        self._norm_sigma_xy = self._sigma_xy / 2.355
-        self._norm_sigma_z = self._sigma_z / 2.355
+        self._norm_sigma_xy = self._sigma_xy / 2.0
+        self._norm_sigma_z = self._sigma_z / 2.0
 
         # Generate pinhole mask if specified
         if self.params.pinhole_radius is not None:
             if self.params.pinhole_radius < AIRYFACTOR * self._sigma_xy:
-                raise ValueError(
+                RuntimeWarning(
                     f"Pinhole size ({self.params.pinhole_radius} um) is smaller than {AIRYFACTOR} times the Airy lobe. This will diffract the emission light in the pinhole; an ideal pinhole size for this setup is {self._sigma_xy} um."
                 )
+                #
+                # raise ValueError(
+                #     f"Pinhole size ({self.params.pinhole_radius} um) is smaller than {AIRYFACTOR} times the Airy lobe. This will diffract the emission light in the pinhole; an ideal pinhole size for this setup is {self._sigma_xy} um."
+                # )
             self._pinhole_mask = self._generate_pinhole_mask()
         else:
             self._pinhole_mask = None
@@ -116,7 +120,9 @@ class PSFEngine:
         return (r <= self.params.pinhole_radius).astype(np.float64)
 
     @lru_cache(maxsize=128)
-    def psf_z(self, x_val: float, y_val: float, z_val: float) -> NDArray[np.float64]:
+    def psf_z(
+        self, x_val: float, y_val: float, z_val: float, norm_scale: bool = True
+    ) -> NDArray[np.float64]:
         """Calculate the PSF at the detector for a point source at z_val.
 
         This represents how light from a point source at position z_val
@@ -132,13 +138,20 @@ class PSFEngine:
             2D array containing the light intensity pattern at the detector
         """
         x, y = self._grid_xy
+        sigma_xy_z_squared = (self._norm_sigma_xy**2) * (
+            1 + (z_val / self._norm_sigma_z) ** 2
+        )
 
         # Calculate how light from the point source diffracts through collection optics
-        r_squared = (
-            (x - x_val % self.params.pixel_size) / self._norm_sigma_xy
-        ) ** 2 + ((y - y_val % self.params.pixel_size) / self._norm_sigma_xy) ** 2
-        z_term = (z_val / self._norm_sigma_z) ** 2
-        psf_at_detector = np.exp(-0.5 * (r_squared + z_term))
+        r_squared = (x - x_val % self.params.pixel_size) ** 2 + (
+            y - y_val % self.params.pixel_size
+        ) ** 2
+        psf_at_detector = np.exp(-0.5 * (r_squared / sigma_xy_z_squared))
+
+        if norm_scale:
+            psf_at_detector = self.normalize_psf(
+                psf_at_detector, mode="sum"
+            ) * self.psf_z_xy0(z_val)
 
         if self._pinhole_mask is not None:
             # Apply pinhole's spatial filtering

AMS_BP/photophysics/state_kinetics.py

@@ -45,15 +45,33 @@ class StateTransitionCalculator:
                 self.fluorescent_state_history[i.name] = [0, laser_intensities]
         return laser_intensities
 
+    def _get_intensities(self, time_pos: int, time_laser: float) -> dict:
+        laser_intensities = self.laser_intensity_generator(
+            florPos=self.flurophoreobj.position_history[time_pos],
+            time=time_laser,
+        )
+        return laser_intensities
+
     def MCMC(self) -> Tuple[State, ErnoMsg]:
         time = 0
         transitions = self.flurophoreobj.state_history[self.current_global_time][2]
+        if not transitions:
+            self.fluorescent_state_history[
+                self.flurophoreobj.fluorophore.states[
+                    self.flurophoreobj.state_history[self.current_global_time][0].name
+                ]
+            ][0] += self.time_duration
+            return self.flurophoreobj.fluorophore.states[
+                self.flurophoreobj.state_history[self.current_global_time][0].name
+            ], ErnoMsg(success=True)
         final_state_name = transitions[0].from_state
         laser_intensities = self._initialize_state_hist(
             self.current_global_time, time + self.current_global_time_s
         )
-
         while time < self.time_duration:
+            laser_intensities = self._get_intensities(
+                self.current_global_time, self.current_global_time_s + time
+            )
             stateTransitionMatrixR = [
                 sum(
                     state_transitions.rate()(laser["wavelength"], laser["intensity"])
@@ -62,8 +80,22 @@ class StateTransitionCalculator:
                 for state_transitions in transitions
             ]  # 1/s
             if not stateTransitionMatrixR:
+                if (
+                    self.flurophoreobj.fluorophore.states[final_state_name].state_type
+                    == StateType.FLUORESCENT
+                ):
+                    self.fluorescent_state_history[
+                        self.flurophoreobj.fluorophore.states[final_state_name].name
+                    ][0] += self.time_duration
                 break
             if sum(stateTransitionMatrixR) == 0:
+                if (
+                    self.flurophoreobj.fluorophore.states[final_state_name].state_type
+                    == StateType.FLUORESCENT
+                ):
+                    self.fluorescent_state_history[
+                        self.flurophoreobj.fluorophore.states[final_state_name].name
+                    ][0] += self.time_duration
                 break
 
             # print(final_state_name)

AMS_BP/sample/sim_sampleplane.py

@@ -133,8 +133,8 @@ class SampleSpace:
         z_min, z_max = fov.z_bounds
 
         return (
-            0 <= x_min <= x_max <= self.x_max
-            and 0 <= y_min <= y_max <= self.y_max
+            x_min <= x_min <= x_max <= self.x_max
+            and x_min <= y_min <= y_max <= self.y_max
             and self.z_min <= z_min <= z_max <= self.z_max
         )
 
@@ -332,3 +332,34 @@ class SamplePlane:
     ) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]:
         """Return the sample space bounds"""
         return self._space.bounds
+
+
+def _FOV_lims(
+    xyoffset: Tuple[float, float],
+    detector_pixelcount: Tuple[int, int],
+    detector_pixelsize_magnification: float,
+) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+    """
+    Utility to determine the FOV (what regions in the sample space the camera can capture) -> mainly used for defining laser position callables.
+
+    Parameters:
+    -----------
+    xyoffset: Tuple[float, float]
+        position in the sample plane which defines the bottom left corner on the detector pixel array; in units of the sample space (um)
+
+    detector_pixelcount: Tuple[int, int]
+        number of pixels in the detector in the both x and y
+
+    detector_pixelsize_magnification: float
+        the pixel size of each pixel (of detector_pixelcount) after the magnification of the optical setup is considered. I.e what each pixel in the final image represents in the units of the sample space (um).
+
+    Returns:
+    --------
+    (x_lims, y_lims): Tuple[Tuple[float, float], Tuple[float, float]]
+        min < max for each lim
+    """
+    x_min = xyoffset[0]
+    y_min = xyoffset[1]
+    x_max = x_min + detector_pixelcount[0] * detector_pixelsize_magnification
+    y_max = y_min + detector_pixelcount[1] * detector_pixelsize_magnification
+    return ((x_min, x_max), (y_min, y_max))

AMS_BP/sim_microscopy.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Literal, Optional, Tuple
+from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
 
@@ -16,7 +16,7 @@ from .photophysics.photon_physics import (
     incident_photons,
 )
 from .photophysics.state_kinetics import StateTransitionCalculator
-from .sample.flurophores.flurophore_schema import WavelengthDependentProperty
+from .sample.flurophores.flurophore_schema import StateType, WavelengthDependentProperty
 from .sample.sim_sampleplane import EMPTY_STATE_HISTORY_DICT, SamplePlane
 from .utils.util_functions import ms_to_seconds
 
@@ -70,7 +70,9 @@ class VirtualMicroscope:
             "_time": self._time,
         }
 
-    def _set_laser_powers(self, laser_power: Dict[str, float]) -> None:
+    def _set_laser_powers(
+        self, laser_power: Dict[str, Union[float, Callable[[float], float]]]
+    ) -> None:
         if laser_power is not None:
             for laser in laser_power.keys():
                 if isinstance(self.lasers[laser].params.power, float) and isinstance(
@@ -86,7 +88,14 @@ class VirtualMicroscope:
                 self.lasers[laser].params.power = laser_power[laser]
 
     def _set_laser_positions(
-        self, laser_positions: Dict[str, Tuple[float, float, float]]
+        self,
+        laser_positions: Dict[
+            str,
+            Union[
+                Tuple[float, float, float],
+                Callable[[float], Tuple[float, float, float]],
+            ],
+        ],
     ) -> None:
         if laser_positions is not None:
             for laser in laser_positions.keys():
@@ -95,15 +104,28 @@ class VirtualMicroscope:
     def run_sim(
         self,
         z_val: float,  # um
-        laser_power: Dict[str, float],  # str = lasername, float = power in W
+        laser_power: Dict[
+            str, Union[float, Callable[[float], float]]  # power or f(t) -> power
+        ],  # str = lasername, float = power in W
         xyoffset: Tuple[
             float, float
         ],  # location of the bottom left corner of the field of view -> sample -> camera
-        laser_position: Dict[str, Tuple[float, float, float]]
-        | None,  # str = lasername, Tuple = x, y, z in um at the sample plane
+        laser_position: Optional[
+            Dict[
+                str,  # laser name
+                Union[
+                    Tuple[float, float, float],  # x, y, z
+                    Callable[[float], Tuple[float, float, float]],  # f(t) -> x, y, z
+                ],
+            ]
+        ] = None,  # str = lasername, Tuple = x, y, z in um at the sample plane
         duration_total: Optional[int] = None,  # ms
         exposure_time: Optional[int] = None,
         interval_time: Optional[int] = None,
+        scanning: Optional[
+            bool
+        ] = False,  # True if scanning -> laser will autoposition to the xy location of the fluorophore but at the z_val of the plane being imaged and NOT the z value of the fluorophore.
+        # as a consequence the "effective" time spent by the laser of on the fluorophore position is not the dwell time of traditional confocal, but "always on". TODO: better fix.
     ) -> Tuple[np.ndarray, MetaData]:
         self._set_laser_powers(laser_power=laser_power)
         if laser_position is not None:
@@ -151,7 +173,9 @@ class VirtualMicroscope:
                 statehist = fluorObj.state_history[time]
                 # if not aval transitions go next
                 # this assumes that the bleached state is the only state from which there are no more transitions
-                if not statehist[2]:
+                if (not statehist[2]) and (
+                    statehist[0].state_type != StateType.FLUORESCENT
+                ):
                     fluorObj.state_history[time + self.sample_plane.dt] = statehist
                     continue
 
@@ -167,6 +191,11 @@ class VirtualMicroscope:
                 ) -> dict:
                     laser_intensities = {}
                     for laserID in laser_power.keys():
+                        if scanning:
+                            self.lasers[laserID].params.position = (
+                                *florPos[:2],
+                                0,
+                            )  # z value is 0 since this is the neew focus plane
                         laser_intensities[laserID] = {
                             "wavelength": self.lasers[laserID].params.wavelength,
                             "intensity": (

AMS_BP/utils/util_functions.py

@@ -1,6 +1,7 @@
 import json
 import os
 import pickle
+from bisect import bisect_right
 
 import numpy as np
 import skimage as skimage
@@ -9,6 +10,14 @@ from PIL import Image
 from ..utils.decorators import cache
 
 
+def find_le(a, x) -> int:
+    "Find rightmost value less than or equal to x"
+    i = bisect_right(a, x)
+    if i:
+        return a[i - 1]
+    raise ValueError
+
+
 def convert_arrays_to_lists(obj: np.ndarray | dict) -> list | dict:
     """
     Recursively convert NumPy arrays to lists.

{ams_bp-0.0.26.dist-info → ams_bp-0.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AMS_BP
-Version: 0.0.26
+Version: 0.0.32
 Summary: Advanced Microscopy Simulations developed for the Weber Lab by Baljyot Singh Parmar
 Project-URL: Documentation, https://joemans3.github.io/AMS_BP/
 Project-URL: Source code, https://github.com/joemans3/AMS_BP

{ams_bp-0.0.26.dist-info → ams_bp-0.0.32.dist-info}/RECORD

@@ -1,7 +1,7 @@
-AMS_BP/__init__.py,sha256=PRd0eVcZs7H8ezQRMXS-q-AES78dJ-DWPSQZT3j5QP0,327
+AMS_BP/__init__.py,sha256=cpKNY-v_X4yiqwdfXMUdEc-j-zmY5npRlWs-Q6Sd4eI,327
 AMS_BP/run_cell_simulation.py,sha256=7InopFikjo0HfaLO2siXskBIbyCIte9avG4YXjjaWCI,7420
 AMS_BP/sim_config.toml,sha256=3IqOQIJYmP5g4okk15nqQiNZb3ij7Pt63HbpI-5tySw,11672
-AMS_BP/sim_microscopy.py,sha256=u60ApTA6MTUmqSAd7EsAxweKya_Typput8NumDq9fp8,18697
+AMS_BP/sim_microscopy.py,sha256=Vsga9lTWqP0pjEnfFj0qKaSz7YZ_F4E3TqsaErwhi3E,19991
 AMS_BP/cells/__init__.py,sha256=yWFScBC1uOGDkeC8i1m1ZBtIREcyt4JHxYa72LxbBZU,177
 AMS_BP/cells/base_cell.py,sha256=FIPB9J8F40tb53vv7C6qG-SaAFLOI8-MGIk1mmZ-gnI,1503
 AMS_BP/cells/rectangular_cell.py,sha256=5yGxvTXYvgldLXyWXpE_SD9Zx2NLerC-I2j02reHsJ0,2515
@@ -9,17 +9,19 @@ AMS_BP/cells/rod_cell.py,sha256=jQ1kLEk74Pv2rcXPRJ6-QJJhux-mYiDSytzqlxCNWfA,3181
 AMS_BP/cells/spherical_cell.py,sha256=n3ou3tW0nCxXIwv6uLkVKHkYCfgoNn8VI6CVTLBIll0,2140
 AMS_BP/configio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/configio/configmodels.py,sha256=Gd2Qdut0u5zS0IpjPwGIB3ur-b4Dfa9e8SbhotBKymc,2894
-AMS_BP/configio/convertconfig.py,sha256=Fg9pOCZSxmWuHnrg-5xZRvhPEK6Qc1kXqu6LL9e9QYw,34741
+AMS_BP/configio/convertconfig.py,sha256=zLyHWmqQnpKDGcIoVlI03dCtXa4L953kzRvPx7-ZqUM,34952
 AMS_BP/configio/experiments.py,sha256=HdfaSi0gPPJ_wLF87XcW5ICja19Uezx7-ygFEwNzi30,3995
 AMS_BP/configio/saving.py,sha256=596QgAadV32rzsN4B2FngGFcBWCzCDnLFN-qtQsv3bM,857
+AMS_BP/groundtruth_generators/__init__.py,sha256=UPVmhiB81OfyqAes5LoN-n6XgQuBCYCqRPAGd2jpMfc,99
+AMS_BP/groundtruth_generators/nuclearporecomplexes.py,sha256=1aBcWltsKo0OGd7A9GfuEZ3azQBx5SzpjrSLLMXuYn8,2518
 AMS_BP/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/metadata/metadata.py,sha256=YDumjc5sI3lY_UZx8f0ZhMqbG2qKQkysXwl7CY4ZtnY,2927
 AMS_BP/motion/__init__.py,sha256=cy3W-wCRjjlN1DrTqYc-JltYwcE8SZCXMVPJ2o6q_BQ,178
 AMS_BP/motion/condensate_movement.py,sha256=eig4WtD7o1cvIafWMjOk6pqxyhe_IIucgLcBEoDvasU,11648
-AMS_BP/motion/track_gen.py,sha256=Z3QJLVMP1gX4SlgOXFxBg8sJhBG0Xq25ixnBoEHEAZI,19462
+AMS_BP/motion/track_gen.py,sha256=2ssg8BXxZUEufycqgziL2BOeKOInTmmjzsthfS80gfI,19540
 AMS_BP/motion/movement/__init__.py,sha256=PqovpG4dAuFFIP9M2_kt-6egQJX3P5ig4MMWVzNaswg,278
 AMS_BP/motion/movement/boundary_conditions.py,sha256=jpfK3AEUY8btrTsu19bpUfx-jri7_HfyxqMFjMoxAVM,2200
-AMS_BP/motion/movement/fbm_BP.py,sha256=dH-JZiAInnIaZXH1wAAo8dOIX9zafclqnZ4dOhKtnO0,9327
+AMS_BP/motion/movement/fbm_BP.py,sha256=47d2ph4r8Izso_mBxxgQYH9xjEqj_zXUzIGpEXPEhFM,9292
 AMS_BP/optics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/optics/camera/__init__.py,sha256=eCoDUFHcoCWgbgYdLn8EH7AULM53A3XWTXNZnV8QxeY,182
 AMS_BP/optics/camera/detectors.py,sha256=_815Ovo7Aj375OZh5Xim8pFuZEEcSVtSdnLRYFqb3_8,10355
@@ -29,17 +31,18 @@ AMS_BP/optics/filters/filters.py,sha256=-iw7eqmDO77SEqlFTv5jJNVwpA8y93TLsjy5hhsA
 AMS_BP/optics/filters/channels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/optics/filters/channels/channelschema.py,sha256=SConyA5yVdfnI_8sgcxVC8SV7S8tGUJYPPC6jn7lglU,906
 AMS_BP/optics/lasers/__init__.py,sha256=T7dHohhyLf_pBw4TidarYHWmiwxVXGE71-Bf1aeBbuc,564
-AMS_BP/optics/lasers/laser_profiles.py,sha256=7mqf5VMpb0VN_veqYEdeiakr0kaOilfGzNq5mzFQuRw,17136
+AMS_BP/optics/lasers/laser_profiles.py,sha256=Naz42SSqG_VS7TtLfM6kz7Gs7opDh6wa2An9CdR6C9M,17286
+AMS_BP/optics/lasers/scanning_patterns.py,sha256=Xen96e5BlYI892HzZDXdwm80id6TbyNCNj-qvnRnSnI,3393
 AMS_BP/optics/psf/__init__.py,sha256=ezrKPgpTeR4gTHOvF0mhF6u2zMMTd8Bgp8PGeOf11fA,121
-AMS_BP/optics/psf/psf_engine.py,sha256=CDtnZpUvYexIih6ssBZsd5s1RUSa5fjUxgzEVELo6CE,9684
+AMS_BP/optics/psf/psf_engine.py,sha256=FbR4VHQ-VgCWrrDj8AHPPnVgwVUGs-OP19w_TjcbMcU,10215
 AMS_BP/photophysics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/photophysics/photon_physics.py,sha256=9FWBXaxuSRaSxW8bY0x1d5R5buooibZbRdYTuQcMXhQ,6624
-AMS_BP/photophysics/state_kinetics.py,sha256=IdZtlHCLs--iSjLwDu2IQA617qXC4la8VpqosrM-vgQ,5401
+AMS_BP/photophysics/state_kinetics.py,sha256=hDb1VqoeEkbYcse-N-S7BzyE4hIt4KLMju7ZKOIJDYc,6980
 AMS_BP/probabilityfuncs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/probabilityfuncs/markov_chain.py,sha256=LV6KGr8Lv4NIvBPJqsR0CEynssa_mPH30qLaK85GObA,4339
 AMS_BP/probabilityfuncs/probability_functions.py,sha256=j_rIxrupGBf_FKkQBh1TvEa34A44jAasaZQRg2u3FuY,11793
 AMS_BP/sample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-AMS_BP/sample/sim_sampleplane.py,sha256=A1BnGaFDnJ0VYaXUmpr0bLdZ01UzfZrATBTubGt3gjo,11525
+AMS_BP/sample/sim_sampleplane.py,sha256=-Vb3o3vgUuN1qfoLMR8SanTbI7JtbtBvs78QzRdkps0,12826
 AMS_BP/sample/flurophores/__init__.py,sha256=arLVUx1-yh5T41fH9Mr6RNY8Ao3ZioFQUtsfEZlzQkU,250
 AMS_BP/sample/flurophores/flurophore_schema.py,sha256=j8jnr4w4ltuhXUkjd74IoyyuotyH52mn8FWkgahX5Vw,10886
 AMS_BP/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,9 +50,9 @@ AMS_BP/utils/constants.py,sha256=-r3cnEiuxb-XzRgGhpOuJshYYhKnDu_hv0YSffkxAfc,273
 AMS_BP/utils/decorators.py,sha256=4qFdvzPJne0dhkhD1znPxRln1Rfr5NX8rdcCDcbATRU,6224
 AMS_BP/utils/errors.py,sha256=7BOd-L4_YeKmWn3Q4EOdTnNF3Bj_exDa3eg5X0yCZrc,759
 AMS_BP/utils/maskMaker.py,sha256=2ca3n2nc8rFtUh1LurKXOJJsUmhrOpWbRnVX7fjRVvs,335
-AMS_BP/utils/util_functions.py,sha256=jI6WBh09_khdABnEoVK7SK1WRvCLHuw40f5ALyflzlc,9478
-ams_bp-0.0.26.dist-info/METADATA,sha256=aaB17p23_wqvfOqQQfb90g7zFD1MrgpdXwoCsbYx37s,5869
-ams_bp-0.0.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ams_bp-0.0.26.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
-ams_bp-0.0.26.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
-ams_bp-0.0.26.dist-info/RECORD,,
+AMS_BP/utils/util_functions.py,sha256=9Qlr4kjY04fObktR8TrzB0IgoG1yXtcmxPRX9AN34mM,9671
+ams_bp-0.0.32.dist-info/METADATA,sha256=ga6yZDd1sIWFqn1pdMbgjhvw4iEpyU1B4gJTbi7S21w,5869
+ams_bp-0.0.32.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ams_bp-0.0.32.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
+ams_bp-0.0.32.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
+ams_bp-0.0.32.dist-info/RECORD,,