FlowCyPy 0.5.2__tar.gz → 0.5.6__tar.gz

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/__init__.py

@@ -7,7 +7,7 @@ except ImportError:
 from .units import ureg, watt, meter, second, liter, particle
 from .cytometer import FlowCytometer
 from .event_correlator import EventCorrelator
-from .scatterer import Scatterer, CouplingModel
+from .scatterer_collection import ScattererCollection, CouplingModel
 from .population import Population
 from .detector import Detector
 from .flow_cell import FlowCell

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.5.6'
+__version_tuple__ = version_tuple = (0, 5, 6)

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/coupling_mechanism/empirical.py

@@ -1,10 +1,10 @@
 import numpy as np
-from FlowCyPy import Scatterer, Detector
+from FlowCyPy import ScattererCollection, Detector
 from FlowCyPy.source import BaseBeam
 from FlowCyPy.units import watt, meter
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Scatterer, granularity: float = 1.0, A: float = 1.5, n: float = 2.0) -> float:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection, granularity: float = 1.0, A: float = 1.5, n: float = 2.0) -> float:
     """
     Empirical model for scattering intensity based on particle size, granularity, and detector angle.
 

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/coupling_mechanism/mie.py

@@ -1,5 +1,5 @@
 import numpy as np
-from FlowCyPy import Scatterer, Detector
+from FlowCyPy import ScattererCollection, Detector
 from FlowCyPy.source import BaseBeam
 from PyMieSim.experiment.scatterer import Sphere as PMS_SPHERE
 from PyMieSim.experiment.source import PlaneWave
@@ -94,13 +94,13 @@ def apply_rin_noise(source: BaseBeam, total_size: int, bandwidth: float) -> np.n
     return amplitude_with_rin
 
 
-def initialize_scatterer(scatterer: Scatterer, source: PlaneWave) -> PMS_SPHERE:
+def initialize_scatterer(scatterer: ScattererCollection, source: PlaneWave) -> PMS_SPHERE:
     """
     Initializes the scatterer object for the PyMieSim experiment.
 
     Parameters
     ----------
-    scatterer : Scatterer
+    scatterer : ScattererCollection
         The scatterer object containing particle data.
     source : PlaneWave
         The light source for the simulation.
@@ -114,7 +114,7 @@ def initialize_scatterer(scatterer: Scatterer, source: PlaneWave) -> PMS_SPHERE:
     ri_list = scatterer.dataframe['RefractiveIndex'].values
 
     if len(size_list) == 0:
-        raise ValueError("Scatterer size list is empty.")
+        raise ValueError("ScattererCollection size list is empty.")
 
     size_list = size_list.quantity.magnitude * size_list.units
     ri_list = ri_list.quantity.magnitude * ri_list.units
@@ -155,7 +155,7 @@ def initialize_detector(detector: Detector, total_size: int) -> PMS_PHOTODIODE:
     )
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Scatterer, tolerance: float = 1e-5) -> np.ndarray:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection, tolerance: float = 1e-5) -> np.ndarray:
     """
     Computes the detected signal by analyzing the scattering properties of particles.
 
@@ -165,7 +165,7 @@ def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Sca
         The light source object containing wavelength, power, and other optical properties.
     detector : Detector
         The detector object containing properties such as numerical aperture and angles.
-    scatterer : Scatterer
+    scatterer : ScattererCollection
         The scatterer object containing particle size and refractive index data.
     tolerance : float, optional
         The tolerance for deciding if two values of size and refractive index are "close enough" to be cached.

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/coupling_mechanism/rayleigh.py

@@ -1,11 +1,11 @@
 
 import numpy as np
-from FlowCyPy import Scatterer, Detector
+from FlowCyPy import ScattererCollection, Detector
 from FlowCyPy.source import BaseBeam
 from FlowCyPy.units import meter
 
 
-def compute_scattering_cross_section(scatterer: Scatterer, source: BaseBeam, detector: Detector) -> np.ndarray:
+def compute_scattering_cross_section(scatterer: ScattererCollection, source: BaseBeam, detector: Detector) -> np.ndarray:
     r"""
     Computes the Rayleigh scattering cross-section for a spherical particle with angle dependency.
 
@@ -28,8 +28,8 @@ def compute_scattering_cross_section(scatterer: Scatterer, source: BaseBeam, det
 
     Parameters
     ----------
-    scatterer : Scatterer
-        An instance of `Scatterer` containing the scatterer properties such as size and refractive index.
+    scatterer : ScattererCollection
+        An instance of `ScattererCollection` containing the scatterer properties such as size and refractive index.
     source : BaseBeam
         An instance of `BaseBeam` containing the laser properties, including the wavelength.
     detector : Detector
@@ -63,7 +63,7 @@ def compute_scattering_cross_section(scatterer: Scatterer, source: BaseBeam, det
     return cross_section.magnitude * meter**2
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Scatterer) -> float:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection) -> float:
     r"""
     Computes the power detected by a detector from a Rayleigh scattering event.
 

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/coupling_mechanism/uniform.py

@@ -1,9 +1,9 @@
 import numpy as np
-from FlowCyPy import Scatterer, Detector, ureg
+from FlowCyPy import ScattererCollection, Detector, ureg
 from FlowCyPy.source import BaseBeam
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Scatterer) -> np.ndarray:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection) -> np.ndarray:
     r"""
     Computes the power detected by a detector from a uniform distribution.
 

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/cytometer.py

@@ -6,7 +6,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 from typing import List, Callable, Optional
 from MPSPlots.styles import mps
-from FlowCyPy.scatterer import Scatterer
+from FlowCyPy.flow_cell import FlowCell
 from FlowCyPy.detector import Detector
 from FlowCyPy.source import GaussianBeam
 import pandas as pd
@@ -30,8 +30,8 @@ class FlowCytometer:
 
     Parameters
     ----------
-    scatterer : Scatterer
-        The distribution of particle sizes which affects scattering signals.
+    flow_cell : FlowCell
+        Void
     source : GaussianBeam
         The laser source object representing the illumination scheme.
     detectors : List[Detector]
@@ -40,14 +40,14 @@ class FlowCytometer:
     """
     def __init__(
             self,
-            scatterer: Scatterer,
-            source: GaussianBeam,
+            flow_cell: FlowCell,
             detectors: List[Detector],
             coupling_mechanism: Optional[str] = 'mie',
             background_power: Optional[Quantity] = 0 * milliwatt):
 
-        self.scatterer = scatterer
-        self.source = source
+        self.flow_cell = flow_cell
+        self.scatterer_collection = flow_cell.scatterer_collection
+        self.source = flow_cell.source
         self.detectors = detectors
         self.coupling_mechanism = coupling_mechanism
         self.background_power = background_power
@@ -70,25 +70,25 @@ class FlowCytometer:
 
         self._generate_pulse_parameters()
 
-        _widths = self.scatterer.dataframe['Widths'].values
-        _centers = self.scatterer.dataframe['Time'].values
+        _widths = self.scatterer_collection.dataframe['Widths'].values
+        _centers = self.scatterer_collection.dataframe['Time'].values
 
         detection_mechanism = self._get_detection_mechanism()
 
         # Initialize the detectors
         for detector in self.detectors:
             detector.source = self.source
-            detector.init_raw_signal(run_time=self.scatterer.flow_cell.run_time)
+            detector.init_raw_signal(run_time=self.flow_cell.run_time)
 
         # Fetch the coupling power for each scatterer
         for detector in self.detectors:
             coupling_power = detection_mechanism(
                 source=self.source,
                 detector=detector,
-                scatterer=self.scatterer
+                scatterer=self.scatterer_collection
             )
 
-            self.scatterer.dataframe['CouplingPower'] = pint_pandas.PintArray(coupling_power, dtype=coupling_power.units)
+            self.scatterer_collection.dataframe['CouplingPower'] = pint_pandas.PintArray(coupling_power, dtype=coupling_power.units)
 
         for detector in self.detectors:
             # Generate noise components
@@ -160,11 +160,11 @@ class FlowCytometer:
         width : np.ndarray
             The width of the pulse (standard deviation of the Gaussian, in seconds).
         """
-        self.pulse_dataframe['Centers'] = self.scatterer.dataframe['Time']
+        self.pulse_dataframe['Centers'] = self.scatterer_collection.dataframe['Time']
 
-        widths = self.source.waist / self.scatterer.flow_cell.flow_speed * np.ones(self.scatterer.n_events)
+        widths = self.source.waist / self.flow_cell.flow_speed * np.ones(self.scatterer_collection.n_events)
 
-        self.scatterer.dataframe['Widths'] = pint_pandas.PintArray(widths, dtype=widths.units)
+        self.scatterer_collection.dataframe['Widths'] = pint_pandas.PintArray(widths, dtype=widths.units)
 
     def plot(self, figure_size: tuple = (10, 6), add_peak_locator: bool = False) -> None:
         """Plots the signals generated for each detector channel."""
@@ -179,7 +179,7 @@ class FlowCytometer:
         self.detectors[1].plot(ax=axes[1], show=False, time_unit=time_unit, signal_unit=signal_unit, add_peak_locator=add_peak_locator)
 
         axes[-1].get_yaxis().set_visible(False)
-        self.scatterer.add_to_ax(axes[-1])
+        self.scatterer_collection.add_to_ax(axes[-1])
 
         # Add legends to each subplot
         for ax in axes:

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/base_class.py

@@ -4,6 +4,12 @@ import matplotlib.pyplot as plt
 from MPSPlots.styles import mps
 from FlowCyPy.units import particle, Quantity
 
+config_dict = dict(
+    arbitrary_types_allowed=True,
+    kw_only=True,
+    slots=True,
+    extra='forbid'
+)
 
 class Base:
     """

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/delta.py

@@ -1,17 +1,10 @@
 
-from FlowCyPy.distribution.base_class import Base
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from PyMieSim.units import Quantity
 from pydantic.dataclasses import dataclass
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
 
 @dataclass(config=config_dict)
 class Delta(Base):

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/lognormal.py

@@ -1,17 +1,10 @@
-from FlowCyPy.distribution.base_class import Base
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from scipy.stats import lognorm
 from PyMieSim.units import Quantity
 from pydantic.dataclasses import dataclass
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
 
 @dataclass(config=config_dict)
 class LogNormal(Base):

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/normal.py

@@ -1,17 +1,10 @@
-from FlowCyPy.distribution.base_class import Base
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from scipy.stats import norm
 from PyMieSim.units import Quantity
 from pydantic.dataclasses import dataclass
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
 
 @dataclass(config=config_dict)
 class Normal(Base):

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/particle_size_distribution.py

@@ -1,16 +1,9 @@
-from FlowCyPy.distribution.base_class import Base
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from PyMieSim.units import Quantity
 from pydantic.dataclasses import dataclass
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
 
 @dataclass(config=config_dict)
 class RosinRammler(Base):

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/uniform.py

@@ -1,18 +1,10 @@
-from FlowCyPy.distribution.base_class import Base
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from scipy.stats import uniform
 from PyMieSim.units import Quantity
 from pydantic.dataclasses import dataclass
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
-
 @dataclass(config=config_dict)
 class Uniform(Base):
     r"""

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/distribution/weibull.py

@@ -1,18 +1,10 @@
+from FlowCyPy.distribution.base_class import Base, config_dict
 import numpy as np
 from typing import Tuple
 from PyMieSim.units import Quantity
-from FlowCyPy.distribution.base_class import Base
 from pydantic.dataclasses import dataclass
 
 
-config_dict = dict(
-    arbitrary_types_allowed=True,
-    kw_only=True,
-    slots=True,
-    extra='forbid'
-)
-
-
 @dataclass(config=config_dict)
 class Weibull(Base):
     r"""
@@ -78,3 +70,6 @@ class Weibull(Base):
         pdf = a * b ** (self.shape - 1) * c
 
         return x, self.scale_factor * pdf
+
+    def __repr__(self) -> str:
+        return f"Weibull({self.scale:.2f~P}, {self.shape:.2f~P})"

flowcypy-0.5.6/FlowCyPy/flow_cell.py

@@ -0,0 +1,295 @@
+from typing import List
+from FlowCyPy.units import meter, second, particle
+
+from PyMieSim.units import Quantity
+from tabulate import tabulate
+from pydantic.dataclasses import dataclass
+from pydantic import field_validator
+from pint_pandas import PintType, PintArray
+from FlowCyPy.source import BaseBeam
+from FlowCyPy.population import Population
+from FlowCyPy.scatterer_collection import ScattererCollection
+import pandas
+import numpy
+import warnings
+
+config_dict = dict(
+    arbitrary_types_allowed=True,
+    kw_only=True,
+    slots=True,
+    extra='forbid'
+)
+
+
+@dataclass(config=config_dict)
+class FlowCell(object):
+    """
+    Models the flow parameters in a flow cytometer, including flow speed, flow area,
+    and particle interactions. This class interacts with ScattererDistribution to simulate
+    the flow of particles through the cytometer.
+
+    Parameters
+    ----------
+    flow_speed : Quantity
+        The speed of the flow in meters per second (m/s).
+    flow_area : Quantity
+        The cross-sectional area of the flow tube in square meters (m²).
+    run_time : Quantity
+        The total duration of the flow simulation in seconds.
+    """
+    flow_speed: Quantity
+    flow_area: Quantity
+    run_time: Quantity
+
+    source: BaseBeam = None
+
+    def __post_init__(self):
+        """Initialize units for flow parameters."""
+        self.flow_speed = Quantity(self.flow_speed, meter / second)
+        self.flow_area = Quantity(self.flow_area, meter ** 2)
+        self.run_time = Quantity(self.run_time, second)
+
+        self.volume = self.flow_area * self.flow_speed * self.run_time
+
+    @field_validator('flow_speed')
+    def _validate_flow_speed(cls, value):
+        """
+        Validates that the flow speed is provided in meter per second.
+
+        Parameters
+        ----------
+        value : Quantity
+            The flow speed to validate.
+
+        Returns
+        -------
+        Quantity
+            The flow speed frequency.
+
+        Raises:
+            ValueError: If the flow speed is not in meter per second.
+        """
+        if not value.check(meter / second):
+            raise ValueError(f"flow_speed must be in meter per second, but got {value.units}")
+        return value
+
+    @field_validator('flow_area')
+    def _validate_flow_area(cls, value):
+        """
+        Validates that the flow area is provided in hertz.
+
+        Parameters
+        ----------
+        value : Quantity
+            The flow area to validate.
+
+        Returns
+        -------
+        Quantity
+            The validated flow area.
+
+        Raises:
+            ValueError: If the flow area is not in hertz.
+        """
+        if not value.check(meter ** 2):
+            raise ValueError(f"flow_area must be in meter ** 2, but got {value.units}")
+        return value
+
+    @field_validator('run_time')
+    def _validate_run_time(cls, value):
+        """
+        Validates that the total time is provided in second.
+
+        Parameters
+        ----------
+        value : Quantity
+            The total time to validate.
+
+        Returns
+        -------
+        Quantity
+            The validated total time.
+
+        Raises:
+            ValueError: If the total time is not in second.
+        """
+        if not value.check(second):
+            raise ValueError(f"run_time must be in second, but got {value.units}")
+        return value
+
+    def print_properties(self) -> None:
+        """
+        Print the core properties of the flow and particle interactions in the flow cytometer.
+        """
+        print("\nFlow Properties")
+        print(tabulate(self.get_properties(), headers=["Property", "Value"], tablefmt="grid"))
+
+    def get_properties(self) -> List[List[str]]:
+        return [
+            ['Flow Speed', f"{self.flow_speed:.2f~#P}"],
+            ['Flow Area', f"{self.flow_area:.2f~#P}"],
+            ['Total Time', f"{self.run_time:.2f~#P}"]
+        ]
+    
+    # def initialize(self, scatterer: Population | ScattererCollection) -> None:
+    #     if isinstance(scatterer, Population):
+    #         return self._initialize_population(scatterer)
+
+    #     elif isinstance(scatterer, ScattererCollection):
+    #         return self._initialize_scatterer_collection(scatterer)
+    
+    def _initialize_population(self, population: Population) -> None:
+        population.dataframe = pandas.DataFrame()
+
+        population.n_events = population.particle_count.calculate_number_of_events(
+            flow_area=self.flow_area,
+            flow_speed=self.flow_speed,
+            run_time=self.run_time
+        )
+
+        self._generate_longitudinal_positions(population)
+
+        size = population.size.generate(population.n_events)
+        population.dataframe['Size'] = PintArray(size, dtype=size.units)
+
+        ri = population.refractive_index.generate(population.n_events)
+        population.dataframe['RefractiveIndex'] = PintArray(ri, dtype=ri.units)
+
+    def initialize(self, scatterer_collection: ScattererCollection, size_units: str = 'micrometer') -> None:
+        """
+        Initializes particle size, refractive index, and medium refractive index distributions.
+
+        Parameters
+        ----------
+        scatterer : Scatterer
+            An instance of the Scatterer class that describes the scatterer collection being used.
+
+        """        
+        self.scatterer_collection = scatterer_collection
+
+        for population in self.scatterer_collection.populations:
+            self._initialize_population(population)
+            population.dataframe.Size = population.dataframe.Size.pint.to(size_units)
+        
+        if len(self.scatterer_collection.populations) != 0:
+            self.scatterer_collection.dataframe = pandas.concat(
+                [population.dataframe for population in self.scatterer_collection.populations],
+                axis=0,
+                keys=[population.name for population in self.scatterer_collection.populations],
+            )
+            self.scatterer_collection.dataframe.index.names = ['Population', 'Index']
+
+        else:
+            dtypes = {
+                'Time': PintType('second'),            # Time column with seconds unit
+                'Position': PintType('meter'),         # Position column with meters unit
+                'Size': PintType('meter'),             # Size column with micrometers unit
+                'RefractiveIndex': PintType('meter')   # Dimensionless unit for refractive index
+            }
+
+            multi_index = pandas.MultiIndex.from_tuples([], names=["Population", "Index"])
+
+            # Create an empty DataFrame with specified column types and a multi-index
+            self.scatterer_collection.dataframe = pandas.DataFrame(
+                {col: pandas.Series(dtype=dtype) for col, dtype in dtypes.items()},
+                index=multi_index
+            )
+
+        self.scatterer_collection.n_events = len(self.scatterer_collection.dataframe)        
+
+    def distribute_time_linearly(self, sequential_population: bool = False) -> None:
+        """
+        Distributes particle arrival times linearly across the total runtime of the flow cell.
+
+        Optionally randomizes the order of times for all populations to simulate non-sequential particle arrivals.
+
+        Parameters
+        ----------
+        sequential_population : bool, optional
+            If `True`, organize the order of arrival times across all populations (default is `False`).
+
+        """
+        # Generate linearly spaced time values across the flow cell runtime
+        linear_spacing = numpy.linspace(0, self.run_time, self.n_events)
+
+        # Optionally randomize the linear spacing
+        if not sequential_population:
+            numpy.random.shuffle(linear_spacing)
+
+        # Assign the linearly spaced or randomized times to the scatterer DataFrame
+        self.scatterer_collectionscatterer.dataframe.Time = PintArray(linear_spacing, dtype=self.scatterer_collection.dataframe.Time.pint.units)        
+
+    def _generate_longitudinal_positions(self, population: Population) -> None:
+        r"""
+        Generate particle arrival times over the entire experiment duration based on a Poisson process.
+
+        In flow cytometry, the particle arrival times can be modeled as a Poisson process, where the time
+        intervals between successive particle arrivals follow an exponential distribution. The average rate
+        of particle arrivals (the particle flux) is given by:
+
+        .. math::
+            \text{Particle Flux} = \rho \cdot v \cdot A
+
+        where:
+        - :math:`\rho` is the scatterer density (particles per cubic meter),
+        - :math:`v` is the flow speed (meters per second),
+        - :math:`A` is the cross-sectional area of the flow tube (square meters).
+
+        The number of particles arriving in a given time interval follows a Poisson distribution, and the
+        time between successive arrivals follows an exponential distribution. The mean inter-arrival time
+        is the inverse of the particle flux:
+
+        .. math::
+            \Delta t \sim \text{Exponential}(1/\lambda)
+
+        where:
+            - :math:`\Delta t` is the time between successive particle arrivals,
+            - :math:`\lambda` is the particle flux (particles per second).
+
+        Steps:
+            1. Compute the particle flux, which is the average number of particles passing through the detection
+            region per second.
+            2. Calculate the expected number of particles over the entire experiment duration.
+            3. Generate random inter-arrival times using the exponential distribution.
+            4. Compute the cumulative arrival times by summing the inter-arrival times.
+            5. Ensure that all arrival times fall within the total experiment duration.
+
+        Returns
+        -------
+        np.ndarray
+            An array of particle arrival times (in seconds) for the entire experiment duration, based on the Poisson process.
+        """
+        # Step 1: Compute the average particle flux (particles per second)
+        particle_flux = population.particle_count.compute_particle_flux(
+            flow_speed=self.flow_speed,
+            flow_area=self.flow_area,
+            run_time=self.run_time
+        )
+
+        # Step 2: Calculate the expected number of particles over the entire experiment
+        expected_particles = population.n_events
+
+        # Step 3: Generate inter-arrival times (exponentially distributed)
+        inter_arrival_times = numpy.random.exponential(
+            scale=1 / particle_flux.magnitude,
+            size=int(expected_particles.magnitude)
+        ) / (particle_flux.units / particle)
+
+        # Step 4: Compute cumulative arrival times
+        arrival_times = numpy.cumsum(inter_arrival_times)
+
+        # Step 5: Limit the arrival times to the total experiment duration
+        arrival_times = arrival_times[arrival_times <= self.run_time]
+
+        time = arrival_times[arrival_times <= self.run_time]
+
+        population.dataframe['Time'] = PintArray(time, dtype=time.units)
+
+        position = arrival_times * self.flow_speed
+
+        population.dataframe['Position'] = PintArray(position, dtype=position.units)
+
+        population.n_events = len(arrival_times) * particle
+
+        if population.n_events == 0:
+            warnings.warn("Population has been initialized with 0 events.")

{flowcypy-0.5.2 → flowcypy-0.5.6}/FlowCyPy/logger.py

@@ -77,7 +77,7 @@ class EventCorrelatorLogger:
             time_diffs = times.diff().dropna()
             avg_time_between_peaks = f"{time_diffs.mean().to_compact():.4~P}"
             min_time_between_peaks = f"{time_diffs.min().to_compact():.4~P}"
-            measured_concentration = num_events * particle / self.correlator.cytometer.scatterer.flow_cell.volume.to(milliliter)
+            measured_concentration = num_events * particle / self.correlator.cytometer.flow_cell.volume.to(milliliter)
         else:
             avg_time_between_peaks = "N/A"
             min_time_between_peaks = "N/A"
@@ -289,7 +289,7 @@ class SimulationLogger:
         first_event_time = self._format_time(centers.min()) if num_events > 0 else "N/A"
         last_event_time = self._format_time(centers.max()) if num_events > 0 else "N/A"
 
-        mean_event_rate = (num_events / self.cytometer.scatterer.flow_cell.run_time).to('Hz')
+        mean_event_rate = (num_events / self.cytometer.flow_cell.run_time).to('Hz')
 
         return [
             detector.name,