AMS-BP 0.0.3__py3-none-any.whl → 0.0.21__py3-none-any.whl

AMS_BP/__init__.py

@@ -10,4 +10,4 @@ Last updated: 2024-12-16
 
 """
 
-__version__ = "0.0.3"
+__version__ = "0.0.21"

AMS_BP/configio/configmodels.py

@@ -21,7 +21,9 @@ class MoleculeParameters(BaseModel):
     diffusion_coefficient: List[List[float]] = Field(
         description="Diffusion coefficients in um^2/s"
     )
+    diffusion_track_amount: List[List[float]]
     hurst_exponent: List[List[float]]
+    hurst_track_amount: List[List[float]]
     allow_transition_probability: List[bool]
     transition_matrix_time_step: List[int] = Field(description="Time step in ms")
     diffusion_transition_matrix: List[List[List[float]]]
@@ -31,7 +33,9 @@ class MoleculeParameters(BaseModel):
 
     @field_validator(
         "diffusion_coefficient",
+        "diffusion_track_amount",
         "hurst_exponent",
+        "hurst_track_amount",
         "state_probability_diffusion",
         "state_probability_hurst",
     )

AMS_BP/configio/convertconfig.py

@@ -324,12 +324,11 @@ class ConfigLoader:
         ):
             # Create PSFParameters instance
             parameters = PSFParameters(
-                emission_wavelength=wavelength,
+                wavelength=wavelength,
                 numerical_aperture=float(params_config["numerical_aperture"]),
                 pixel_size=pixel_size,
                 z_step=float(params_config["z_step"]) if z_step is None else z_step,
                 refractive_index=float(params_config.get("refractive_index", 1.0)),
-                pinhole_diameter=params_config.get("pinhole_diameter", None),
             )
 
             # Create PSF engine

AMS_BP/metadata/metadata.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterator, List, Literal, Union
+from typing import Iterator, List, Literal, Union
 
 from pydantic import BaseModel
 
@@ -77,7 +77,7 @@ class MetaData(BaseModel):
     PhysicalSizeXUnit: Literal["nm", "m"]
     PhysicalSizeY: float
     PhysicalSizeYUnit: Literal["nm", "m"]
-    Channel: Dict[Literal["Name"], List[str]]
+    # Channel: Dict[Literal["Name"], List[str]]
 
     def __post_init__(self):
         if isinstance(self.notes, (list, str)):

AMS_BP/motion/condensate_movement.py

@@ -20,6 +20,7 @@ Usage:
         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
@@ -309,3 +310,47 @@ class Condensate:
         # 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/fbm_BP.py

@@ -1,7 +1,6 @@
 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,
@@ -162,8 +161,10 @@ 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(
-            2 * self._diff_a_n * (self.dt ** (2 * self._hurst_n))
+        gn = (
+            np.random.normal(0, 1, self.n)
+            * np.sqrt(self.dt * 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=self.oversample_motion_time / 1000.0,
+            dt=1,
             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=self.oversample_motion_time / 1000.0,
+            dt=1,
             hurst_parameters=hurst_parameters,
             diffusion_parameters=diffusion_parameters,
             diffusion_parameter_transition_matrix=diffusion_transition_matrix,

AMS_BP/optics/camera/detectors.py

@@ -305,7 +305,7 @@ def create_binning_function(input_shape, binning_size, mode="sum"):
         numpy.ndarray
             Binned array
         """
-        if array.shape != tuple(input_shape):
+        if array.shape != input_shape:
             raise ValueError(
                 f"Input array shape {array.shape} does not match expected shape {input_shape}"
             )

AMS_BP/optics/lasers/laser_profiles.py

@@ -96,10 +96,7 @@ class LaserParameters:
             Power in watts
         """
         if callable(self.power):
-            power = self.power(t)
-            if power < 0:
-                raise ValueError("Laser Power Cannot be Negative")
-            return power
+            return self.power(t)
         return self.power
 
     def get_position(self, t: float) -> Tuple[float, float, float]:
@@ -371,16 +368,15 @@ class WidefieldBeam(LaserProfile):
         Returns:
             Intensity scaling factor between 0 and 1
         """
-        # # Use error function for smooth transition at DoF boundaries
-        # # Scale factor determines how sharp the transition is
-        # scale_factor = 2.0  # Adjust this to change transition sharpness
-        #
-        # # Normalize z by DoF and create smooth falloff
-        # normalized_z = scale_factor * (np.abs(z)) / self.dof
-        #
-        # # Use sigmoid function for smooth transition
-        # return 1 / (1 + np.exp(normalized_z))
-        return 1.0
+        # Use error function for smooth transition at DoF boundaries
+        # Scale factor determines how sharp the transition is
+        scale_factor = 2.0  # Adjust this to change transition sharpness
+
+        # Normalize z by DoF and create smooth falloff
+        normalized_z = scale_factor * (np.abs(z) - self.dof / 2) / self.dof
+
+        # Use sigmoid function for smooth transition
+        return 1 / (1 + np.exp(normalized_z))
 
     def calculate_intensity(
         self,
@@ -417,7 +413,7 @@ class WidefieldBeam(LaserProfile):
         base_intensity = power / (np.pi * self.max_radius**2)
 
         # Apply radial intensity profile with smooth falloff at edges
-        edge_width = self.max_radius * 0.00001
+        edge_width = self.max_radius * 0.1  # 10% of max radius
         radial_profile = 0.5 * (1 - np.tanh((r - self.max_radius) / edge_width))
         # Apply DoF-based axial intensity profile
         axial_profile = self._calculate_dof_profile(z_shifted)
@@ -426,6 +422,32 @@ class WidefieldBeam(LaserProfile):
         return base_intensity * radial_profile * axial_profile
 
 
+# Example usage
+if __name__ == "__main__":
+    # Create parameters for a typical microscope objective
+    params = LaserParameters(
+        wavelength=488,  # 488 nm
+        power=0.001,  # 1 mW
+        beam_width=0.25,  # 250 nm
+        numerical_aperture=1.4,
+        refractive_index=1.518,  # Oil immersion
+    )
+
+    # Create beam object
+    beam = GaussianBeam(params)
+
+    # Get intensity map
+    result = beam.get_intensity_map(
+        volume_size=(5, 5, 10),  # 5x5x10 microns
+        voxel_size=0.1,  # 100 nm voxels
+        t=0,  # t=0 seconds
+    )
+
+    # print(f"Beam waist: {params.beam_width:.3f} µm")
+    # print(f"Rayleigh range: {params.rayleigh_range:.3f} µm")
+    # print(f"Diffraction limit: {params.diffraction_limited_width:.3f} µm")
+
+
 class HiLoBeam(LaserProfile):
     """
     Highly Inclined Laminated Optical (HiLo) illumination profile.
@@ -527,3 +549,143 @@ class HiLoBeam(LaserProfile):
         lamination_factor = np.exp(-np.abs(z_shifted) / (2 * self.axial_resolution))
 
         return intensity * lamination_factor
+
+
+class ConfocalBeam(LaserProfile):
+    """
+    Confocal microscopy beam profile with point scanning and pinhole characteristics.
+
+    Implements key optical principles of confocal microscopy:
+    - Point scanning illumination
+    - Pinhole-based rejection of out-of-focus light
+    - Depth-resolved imaging capabilities
+    """
+
+    def __init__(
+        self,
+        params: LaserParameters,
+        pinhole_diameter: float,  # Pinhole diameter in microns
+        scanning_mode: str = "point",  # 'point' or 'line'
+        line_orientation: str = "horizontal",  # 'horizontal' or 'vertical'
+    ):
+        """
+        Initialize Confocal beam profile.
+
+        Args:
+            params: LaserParameters for the beam
+            pinhole_diameter: Diameter of the detection pinhole in microns
+            scanning_mode: Scanning method ('point' or 'line')
+            line_orientation: Orientation for line scanning
+        """
+        super().__init__(params)
+
+        # Validate numerical aperture
+        if params.numerical_aperture is None:
+            raise ValueError(
+                "Numerical aperture must be specified for confocal microscopy"
+            )
+
+        # Pinhole and optical characteristics
+        self.pinhole_diameter = pinhole_diameter
+        self.scanning_mode = scanning_mode
+        self.line_orientation = line_orientation
+
+        # Calculate optical parameters
+        wavelength_microns = params.wavelength / 1000.0
+        na = params.numerical_aperture
+
+        # Theoretical resolution calculations
+        self.lateral_resolution = 0.61 * wavelength_microns / na
+        self.axial_resolution = 0.5 * wavelength_microns / (na**2)
+
+        # Pinhole transmission calculation
+        # Airy disk radius calculation
+        self.airy_radius = 1.22 * wavelength_microns / (2 * na)
+
+        # Transmission through pinhole
+        def pinhole_transmission(z):
+            """
+            Calculate pinhole transmission as a function of z-position.
+            Uses an error function to model smooth transition.
+            """
+            # Normalized z-position relative to focal plane
+            z_norm = z / self.axial_resolution
+
+            # Smooth transition function
+            return 0.5 * (1 + np.tanh(-z_norm))
+
+        self.pinhole_transmission = pinhole_transmission
+
+        # print("Confocal Microscopy Configuration:")
+        # print(f"  Scanning Mode: {scanning_mode}")
+        # print(f"  Pinhole Diameter: {pinhole_diameter:.2f} µm")
+        # print(f"  Lateral Resolution: {self.lateral_resolution:.3f} µm")
+        # print(f"  Axial Resolution: {self.axial_resolution:.3f} µm")
+        # print(f"  Airy Disk Radius: {self.airy_radius:.3f} µm")
+
+    def calculate_intensity(
+        self,
+        x: np.ndarray | float,
+        y: np.ndarray | float,
+        z: np.ndarray | float,
+        t: float,
+    ) -> np.ndarray:
+        """
+        Calculate the confocal illumination intensity distribution.
+
+        Args:
+            x: X coordinates in microns (3D array)
+            y: Y coordinates in microns (3D array)
+            z: Z coordinates in microns (3D array)
+            t: Time in seconds
+
+        Returns:
+            3D array of intensities in W/µm²
+        """
+        # Get time-dependent parameters
+        power = self.params.get_power(t)
+        pos = self.params.get_position(t)
+
+        # Shift coordinates based on current beam position
+        x_shifted = x - pos[0]
+        y_shifted = y - pos[1]
+        z_shifted = z - pos[2]
+
+        # Base beam parameters
+        w0 = self.params.beam_width  # Beam waist
+        zR = self.params.rayleigh_range  # Rayleigh range
+
+        # Calculate beam width at z
+        w_z = w0 * np.sqrt(1 + (z_shifted / zR) ** 2)
+
+        # Peak intensity calculation
+        I0 = 2 * power / (np.pi * w0**2)
+
+        # Scanning mode intensity modification
+        if self.scanning_mode == "point":
+            # Point scanning: standard Gaussian beam
+            radial_intensity = (
+                I0
+                * (w0 / w_z) ** 2
+                * np.exp(-2 * (x_shifted**2 + y_shifted**2) / w_z**2)
+            )
+        elif self.scanning_mode == "line":
+            # Line scanning: different intensity distribution
+            if self.line_orientation == "horizontal":
+                line_intensity = (
+                    I0 * (w0 / w_z) ** 2 * np.exp(-2 * y_shifted**2 / w_z**2)
+                )
+                radial_intensity = line_intensity
+            else:  # vertical line scanning
+                line_intensity = (
+                    I0 * (w0 / w_z) ** 2 * np.exp(-2 * x_shifted**2 / w_z**2)
+                )
+                radial_intensity = line_intensity
+        else:
+            raise ValueError(f"Unknown scanning mode: {self.scanning_mode}")
+
+        # Pinhole transmission effect
+        pinhole_effect = self.pinhole_transmission(z_shifted)
+
+        # Final intensity calculation
+        return radial_intensity * pinhole_effect

AMS_BP/optics/psf/psf_engine.py

@@ -5,61 +5,52 @@ from typing import Literal, Optional, Tuple
 import numpy as np
 from numpy.typing import NDArray
 
-AIRYFACTOR = 1.0
-
 
 @dataclass(frozen=True)
 class PSFParameters:
-    """Parameters for emission PSF (Point Spread Function) at the detector.
-
-
-    This class defines parameters that determine how light from a point source
-    (e.g., a fluorescent molecule) diffracts through the collection optics
-    to form a pattern at the detector.
+    """Parameters for PSF (Point Spread Function) generation.
 
     Attributes:
-        emission_wavelength: Emission wavelength in nanometers
-        numerical_aperture: Numerical aperture of the collection objective
-        pixel_size: Size of pixels in micrometers at the detector
+        wavelength: Light wavelength in nanometers
+        numerical_aperture: Numerical aperture of the optical system
+        pixel_size: Size of pixels in micrometers
         z_step: Axial step size in micrometers
         refractive_index: Refractive index of the medium (default: 1.0 for air)
-        pinhole_diameter: Diameter of the pinhole in micrometers (default: None for widefield)
-                         The pinhole spatially filters the emitted light before it reaches
-                         the detector.
     """
 
-    emission_wavelength: float
+    wavelength: float
     numerical_aperture: float
     pixel_size: float
     z_step: float
     refractive_index: float = 1.0
-    pinhole_diameter: Optional[float] = None  # um
 
-    @cached_property
-    def wavelength_um(self) -> float:
-        """Emission wavelength in micrometers."""
-        return self.emission_wavelength / 1000.0
+    # def __post_init__(self) -> None:
+    #     """Validate parameters after initialization."""
+    #     if any(
+    #         param <= 0
+    #         for param in (
+    #             self.wavelength,
+    #             self.numerical_aperture,
+    #             self.pixel_size,
+    #             self.z_step,
+    #             self.refractive_index,
+    #         )
+    #     ):
+    #         raise ValueError("All parameters must be positive numbers")
+    #     if self.numerical_aperture >= self.refractive_index:
+    #         raise ValueError("Numerical aperture must be less than refractive index")
 
     @cached_property
-    def pinhole_radius(self) -> Optional[float]:
-        """Pinhole radius in micrometers."""
-        return (
-            self.pinhole_diameter / 2.0 if self.pinhole_diameter is not None else None
-        )
+    def wavelength_um(self) -> float:
+        """Wavelength in micrometers."""
+        return self.wavelength / 1000.0
 
 
 class PSFEngine:
-    """Engine for calculating emission light PSF at the detector.
-
-    This class calculates how light from a point source (like a fluorescent molecule)
-    spreads due to diffraction through the collection optics to form a pattern at
-    the detector. For confocal systems, it can include the effect of a pinhole
-    that spatially filters the light before detection.
+    """Engine for generating various microscope Point Spread Functions.
 
-    Note: This PSF describes only the diffraction of emitted light through the
-    collection optics. While a confocal microscope uses focused illumination to
-    excite molecules, that illumination pattern does not affect how the emitted
-    light diffracts to form the PSF we calculate here.
+    This class implements calculations for both 2D and 3D Point Spread Functions
+    using Gaussian approximations.
     """
 
     def __init__(self, params: PSFParameters):
@@ -88,80 +79,34 @@ class PSFEngine:
         self._norm_sigma_xy = self._sigma_xy / 2.355
         self._norm_sigma_z = self._sigma_z / 2.355
 
-        # Generate pinhole mask if specified
-        if self.params.pinhole_radius is not None:
-            if self.params.pinhole_radius < AIRYFACTOR * self._sigma_xy:
-                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
-
-    def _generate_pinhole_mask(self) -> NDArray[np.float64]:
-        """Generate a binary mask representing the pinhole's spatial filtering.
-        The pinhole is centered on the grid, blocking emission light based on position
-        in the image plane, affecting what portion of the diffracted light reaches
-        the detector.
-        """
-        x, y = self._grid_xy
-
-        # Calculate the grid center
-        x_center = (x.max() + x.min()) / 2
-        y_center = (y.max() + y.min()) / 2
-
-        # Calculate radial distance from grid center
-        r = np.sqrt((x - x_center) ** 2 + (y - y_center) ** 2)
-
-        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]:
-        """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
-        diffracts through the collection optics to form a pattern at the
-        detector. If a pinhole is present, it spatially filters this pattern.
+    def psf_z(self, z_val: float) -> NDArray[np.float64]:
+        """Generate z=z_val Gaussian approximation of PSF.
 
         Args:
-            x_val: x-position of the point source in micrometers
-            y_val: y-position of the point source in micrometers
-            z_val: Z-position of the point source in micrometers
+            z_val: Z-position in micrometers
 
         Returns:
-            2D array containing the light intensity pattern at the detector
+            2D array containing the PSF at given z position
         """
         x, y = self._grid_xy
 
-        # 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
+        # Vectorized calculation
+        r_squared = (x / self._norm_sigma_xy) ** 2 + (y / 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))
-
-        if self._pinhole_mask is not None:
-            # Apply pinhole's spatial filtering
-            return psf_at_detector * self._pinhole_mask
-
-        return psf_at_detector
+        return np.exp(-0.5 * (r_squared + z_term))
 
     @lru_cache(maxsize=128)
     def psf_z_xy0(self, z_val: float) -> float:
-        """Calculate the PSF intensity at the center of the detector.
-
-        For a point source at z_val, this gives the intensity of light
-        that reaches the detector center (x=y=0). This point is always
-        within the pinhole if one is present.
+        """Generate z=z_val Gaussian approximation of PSF with x=y=0.
 
         Args:
-            z_val: Z-position of the point source in micrometers
+            z_val: Z-position in micrometers
 
         Returns:
-            Light intensity at detector center
+            PSF value at x=y=0 and given z position
         """
-        z_term = (z_val / self._norm_sigma_z) ** 2
-        return np.exp(-0.5 * z_term)
+        return np.exp(-0.5 * (z_val / self._norm_sigma_z) ** 2)
 
     @cache
     def _3d_normalization_A(
@@ -256,7 +201,7 @@ def calculate_psf_size(
         Tuple of dimensions (z,y,x) or (y,x) for the PSF calculation
     """
     # Calculate radius to capture important features (2x Airy radius)
-    r_psf = 3 * sigma_xy
+    r_psf = 2 * sigma_xy
 
     # Convert to pixels and ensure odd number
     pixels_xy = int(np.ceil(r_psf / pixel_size))

AMS_BP/photophysics/photon_physics.py

@@ -168,11 +168,11 @@ class incident_photons:
                 photons_n = self.transmission_photon_rate.values[i] * dt
                 photons += photons_n
                 psf_gen = (
-                    self.generator[i].psf_z(
-                        x_val=self.position[0],
-                        y_val=self.position[1],
-                        z_val=self.position[2],
+                    self.generator[i].normalize_psf(
+                        self.generator[i].psf_z(z_val=self.position[2]),
+                        mode="sum",
                     )
+                    * self.generator[i].psf_z_xy0(z_val=self.position[2])
                     * photons_n
                 )
 

AMS_BP/photophysics/state_kinetics.py

@@ -27,7 +27,6 @@ class StateTransitionCalculator:
         self.current_global_time = current_global_time  # ms (oversample motion time)
         self.laser_intensity_generator = laser_intensity_generator
         self.fluorescent_state_history = {}  # {fluorescent.state.name : [delta time (seconds), laser_intensites], ...}
-        self.current_global_time_s = self.current_global_time * 1e-3
 
     def __call__(
         self,
@@ -49,9 +48,7 @@ class StateTransitionCalculator:
         time = 0
         transitions = self.flurophoreobj.state_history[self.current_global_time][2]
         final_state_name = transitions[0].from_state
-        laser_intensities = self._initialize_state_hist(
-            self.current_global_time, time + self.current_global_time_s
-        )
+        laser_intensities = self._initialize_state_hist(self.current_global_time, time)
 
         while time < self.time_duration:
             stateTransitionMatrixR = [

AMS_BP/run_cell_simulation.py

@@ -1,14 +1,14 @@
 """
 run_cell_simulation.py
 
-This file contains the command-line interface (CLI) for the AMS_BP package.
+This file contains the command-line interface (CLI) for the SMS_BP package, which is used for simulating single molecule localization microscopy experiments.
 
 The CLI is built using Typer and provides two main commands:
 1. 'config': Generates a sample configuration file.
 2. 'runsim': Runs the cell simulation using a provided configuration file.
 
 Main Components:
-- typer_app_asms_bp: The main Typer application object.
+- typer_app_sms_bp: The main Typer application object.
 - cell_simulation(): Callback function that displays the version information.
 - generate_config(): Command to generate a sample configuration file.
 - run_cell_simulation(): Command to run the cell simulation using a configuration file.
@@ -37,7 +37,7 @@ from .configio.saving import save_config_frames
 
 cli_help_doc = str(
     """
-CLI tool to run [underline]A[/underline]dvanced [underline]M[/underline]olecule [underline]S[/underline]imulation: [underline]AMS[/underline]-BP. GitHub: [green]https://github.com/joemans3/AMS_BP[/green].
+CLI tool to run [underline]A[/underline]dvanced [underline]M[/underline]olecule [underline]S[/underline]imulation: [underline]ASMS[/underline]-BP. GitHub: [green]https://github.com/joemans3/AMS_BP[/green].
 [Version: [bold]{0}[/bold]]
 """.format(__version__)
 )

AMS_BP/sim_config.toml

@@ -23,8 +23,18 @@ diffusion_coefficient = [
         0.0,
     ],
 ] # um^2/s, size of each index (eg. len(...[0]) is the # of diffusion coefficients the system can explore.
-
+diffusion_track_amount = [
+    [
+        0.5,
+        0.5,
+    ],
+    [
+        0.5,
+        0.5,
+    ],
+] # only usefull for initial distribution of diffusion coefficients to trajectories.
 hurst_exponent = [[0.5], [0.5]]
+hurst_track_amount = [[1.0], [1.0]]
 allow_transition_probability = [true, true] # bool
 transition_matrix_time_step = [
     20,
@@ -183,6 +193,12 @@ to_state = "triplet"
 photon_dependent = false
 base_rate = 1            # 1/s
 
+[fluorophores.PAmCherry.transitions.triplet_to_bleached]
+from_state = "triplet"
+to_state = "bleached"
+photon_dependent = false
+base_rate = 1            # 1/s
+
 [fluorophores.PAmCherry.transitions.triplet_to_dark]
 from_state = "triplet"
 to_state = "dark"
@@ -259,7 +275,6 @@ custom_path = ""
 [psf.parameters]
 numerical_aperture = 1.4 # typical range: 0.1 - 1.5
 refractive_index = 1.0   # default is air (1.0)
-#pinhole_diameter = 1.0  # Do not include for no pinhole else float in um units
 
 # Multiple Laser Configuration File
 

AMS_BP/sim_microscopy.py

@@ -73,9 +73,7 @@ class VirtualMicroscope:
     def _set_laser_powers(self, laser_power: Dict[str, float]) -> None:
         if laser_power is not None:
             for laser in laser_power.keys():
-                if isinstance(self.lasers[laser].params.power, float) and isinstance(
-                    laser_power[laser], float
-                ):
+                if isinstance(self.lasers[laser].params.power, float):
                     if laser_power[laser] > self.lasers[laser].params.max_power:
                         raise ValueError(
                             "Provided laser power for laser: {} nm, is larger than the maximum power: {}".format(
@@ -278,7 +276,7 @@ class VirtualMicroscope:
             PhysicalSizeXUnit="m",
             PhysicalSizeY=self.camera.pixel_size * 1e-6,
             PhysicalSizeYUnit="m",
-            Channel={"Name": self.channels.names},
+            # Channel={"Name": self.channels.names},
         )
 
         # return frames in the format ZCTYX

{ams_bp-0.0.3.dist-info → ams_bp-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AMS_BP
-Version: 0.0.3
+Version: 0.0.21
 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
@@ -10,6 +10,7 @@ License-File: LICENSE
 Keywords: SMS
 Requires-Python: >=3.10
 Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: matplotlib>=3.6.0
 Requires-Dist: numpy>=1.21.2
 Requires-Dist: pydantic>=2.9.2
 Requires-Dist: scikit-image>=0.18.3
@@ -171,5 +172,3 @@ frames, metadata = function_exp(microscope=microscope, config=config_exp)
 from AMS_BP.configio.saving import save_config_frames
 save_config_frames(metadata, frames, setup_config["base_config"].OutputParameters)
 ```
-
-> A more detailed example is provided in the jupyter notebook in the examples. For starters refer to the [VisualizingIndividualModules](examples/VisualizingIndividualModules/modules_explained.ipynb). Then head over to the [laser modulation module](examples/VisualizingIndividualModules/laser_modulation.ipynb) which will show how to change the laser power over time in the simulations. Then view an example of a complex experiment setup for [FRAP](examples/QuantitativeExperiments/FRAP_methods.ipynb) which is possible by the use of compositions of modules in this simulation library.

{ams_bp-0.0.3.dist-info → ams_bp-0.0.21.dist-info}/RECORD

@@ -1,40 +1,40 @@
-AMS_BP/__init__.py,sha256=XXgng_5FKa65FmYXfkLAQAUD1WX_poIPUnrmCBnIWuI,326
-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/__init__.py,sha256=gA3WHujyg_TRO9bQK9orLK8uNHSObJpmsLkv8GHRzLc,327
+AMS_BP/run_cell_simulation.py,sha256=fPU1Tuu7hBupGtMk07j2t8QYo_TjFLMJRU9fwmAgU9c,7502
+AMS_BP/sim_config.toml,sha256=FD-OcSDAgRuNIalFe0pC8sbsaSwM-9DV2DNswds2q54,11976
+AMS_BP/sim_microscopy.py,sha256=7JQ6NQlgNZCvFE-FC1f9Ehh6DoJgn7bLzeqS_Mamq9Y,18619
 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
 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/configmodels.py,sha256=Isc6THk3RAIVdjEUBW4c_OD0I122dYufgEvAcGJQ5uo,3046
+AMS_BP/configio/convertconfig.py,sha256=lS7FTDheESdbpaZ0K1LcE8rkdJOKLjzIvcmWpjeebSs,34654
 AMS_BP/configio/experiments.py,sha256=HdfaSi0gPPJ_wLF87XcW5ICja19Uezx7-ygFEwNzi30,3995
 AMS_BP/configio/saving.py,sha256=596QgAadV32rzsN4B2FngGFcBWCzCDnLFN-qtQsv3bM,857
 AMS_BP/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-AMS_BP/metadata/metadata.py,sha256=YDumjc5sI3lY_UZx8f0ZhMqbG2qKQkysXwl7CY4ZtnY,2927
+AMS_BP/metadata/metadata.py,sha256=_FwbSRsUhGwigY6YYffMgEx5hlXTT_vu-9AldMFPa6w,2923
 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=2ssg8BXxZUEufycqgziL2BOeKOInTmmjzsthfS80gfI,19540
+AMS_BP/motion/condensate_movement.py,sha256=cGLHIOL7VUJ7U-JrJXetcnUF2v9SepIBznoqu6AQPxU,13252
+AMS_BP/motion/track_gen.py,sha256=Z3QJLVMP1gX4SlgOXFxBg8sJhBG0Xq25ixnBoEHEAZI,19462
 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=47d2ph4r8Izso_mBxxgQYH9xjEqj_zXUzIGpEXPEhFM,9292
+AMS_BP/motion/movement/fbm_BP.py,sha256=dH-JZiAInnIaZXH1wAAo8dOIX9zafclqnZ4dOhKtnO0,9327
 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
+AMS_BP/optics/camera/detectors.py,sha256=UJqi7owESw9nkFiQhoAe7Q1LIi_fYCzuvZLgtM3yAPk,10348
 AMS_BP/optics/camera/quantum_eff.py,sha256=ZCvJ8dJESOUbjwblsJIBcCg_b-_DNdhDlkzd7HeGMDg,2378
 AMS_BP/optics/filters/__init__.py,sha256=oYPk2_wuL4KrwbaZy3gktvO5biQUfdQLUColWhkU1lw,337
 AMS_BP/optics/filters/filters.py,sha256=-iw7eqmDO77SEqlFTv5jJNVwpA8y93TLsjy5hhsAfiI,6406
 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=J9czY646XcW8GzXx9Eb16mG7tQdWw4oVYveOrihZCeY,22745
 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=ejmTwAKtEpXvKeMuUFcuz6HjJbEjQa_NvkE6a3hkVzk,6769
 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/photon_physics.py,sha256=QRG_QIZ4csJ3g5qGP9Wtk7kzqm8_MUbVHfFef6cMtHQ,6671
+AMS_BP/photophysics/state_kinetics.py,sha256=0cc7Vc4LtAbEdGDeg22IJmRGLsONOty4c32hXHO-TSU,5281
 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
@@ -48,8 +48,8 @@ AMS_BP/utils/decorators.py,sha256=4qFdvzPJne0dhkhD1znPxRln1Rfr5NX8rdcCDcbATRU,62
 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.3.dist-info/METADATA,sha256=bAzPauaepeW-ZODjT65J91m1-mmwHgJ8-LnpX8-NZ14,5868
-ams_bp-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ams_bp-0.0.3.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
-ams_bp-0.0.3.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
-ams_bp-0.0.3.dist-info/RECORD,,
+ams_bp-0.0.21.dist-info/METADATA,sha256=RhM8C7dT2SXt-rbPFdQdo_EaiOFUx-7uC7uvic8IpvU,5316
+ams_bp-0.0.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ams_bp-0.0.21.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
+ams_bp-0.0.21.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
+ams_bp-0.0.21.dist-info/RECORD,,