FlowCyPy 0.5.15__tar.gz → 0.6.0__tar.gz

{flowcypy-0.5.15 → flowcypy-0.6.0}/FlowCyPy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.15'
-__version_tuple__ = version_tuple = (0, 5, 15)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)

flowcypy-0.6.0/FlowCyPy/coupling_mechanism/mie.py

@@ -0,0 +1,207 @@
+import numpy as np
+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
+from PyMieSim.experiment.detector import Photodiode as PMS_PHOTODIODE
+from PyMieSim.experiment import Setup
+from PyMieSim.units import Quantity, degree, watt, AU, hertz
+from FlowCyPy.noises import NoiseSetting
+import pandas as pd
+
+
+
+def apply_rin_noise(source: BaseBeam, total_size: int, bandwidth: float) -> np.ndarray:
+    r"""
+    Applies Relative Intensity Noise (RIN) to the source amplitude if enabled, accounting for detection bandwidth.
+
+    Parameters
+    ----------
+    source : BaseBeam
+        The light source containing amplitude and RIN information.
+    total_size : int
+        The number of particles being simulated.
+    bandwidth : float
+        The detection bandwidth in Hz.
+
+    Returns
+    -------
+    np.ndarray
+        Array of amplitudes with RIN noise applied.
+
+    Equations
+    ---------
+    1. Relative Intensity Noise (RIN):
+        RIN quantifies the fluctuations in the laser's intensity relative to its mean intensity.
+        RIN is typically specified as a power spectral density (PSD) in units of dB/Hz:
+        \[
+        \text{RIN (dB/Hz)} = 10 \cdot \log_{10}\left(\frac{\text{Noise Power (per Hz)}}{\text{Mean Power}}\right)
+        \]
+
+    2. Conversion from dB/Hz to Linear Scale:
+        To compute noise power, RIN must be converted from dB to a linear scale:
+        \[
+        \text{RIN (linear)} = 10^{\text{RIN (dB/Hz)} / 10}
+        \]
+
+    3. Total Noise Power:
+        The total noise power depends on the bandwidth (\(B\)) of the detection system:
+        \[
+        P_{\text{noise}} = \text{RIN (linear)} \cdot B
+        \]
+
+    4. Standard Deviation of Amplitude Fluctuations:
+        The noise standard deviation for amplitude is derived from the total noise power:
+        \[
+        \sigma_{\text{amplitude}} = \sqrt{P_{\text{noise}}} \cdot \text{Amplitude}
+        \]
+        Substituting \(P_{\text{noise}}\), we get:
+        \[
+        \sigma_{\text{amplitude}} = \sqrt{\text{RIN (linear)} \cdot B} \cdot \text{Amplitude}
+        \]
+
+    Implementation
+    --------------
+    - The RIN value from the source is converted to linear scale using:
+        \[
+        \text{RIN (linear)} = 10^{\text{source.RIN} / 10}
+        \]
+    - The noise standard deviation is scaled by the detection bandwidth (\(B\)) in Hz:
+        \[
+        \sigma_{\text{amplitude}} = \sqrt{\text{RIN (linear)} \cdot B} \cdot \text{source.amplitude}
+        \]
+    - Gaussian noise with mean \(0\) and standard deviation \(\sigma_{\text{amplitude}}\) is applied to the source amplitude.
+
+    Notes
+    -----
+    - The bandwidth parameter (\(B\)) must be in Hz and reflects the frequency range of the detection system.
+    - The function assumes that RIN is specified in dB/Hz. If RIN is already in linear scale, the conversion step can be skipped.
+    """
+    amplitude_with_rin = np.ones(total_size) * source.amplitude
+
+    if NoiseSetting.include_RIN_noise and NoiseSetting.include_noises:
+        # Convert RIN from dB/Hz to linear scale if necessary
+        rin_linear = 10**(source.RIN / 10)
+
+        # Compute noise standard deviation, scaled by bandwidth
+        std_dev_amplitude = np.sqrt(rin_linear * bandwidth.to(hertz).magnitude) * source.amplitude
+
+        # Apply Gaussian noise to the amplitude
+        amplitude_with_rin += np.random.normal(
+            loc=0,
+            scale=std_dev_amplitude.to(source.amplitude.units).magnitude,
+            size=total_size
+        ) * source.amplitude.units
+
+    return amplitude_with_rin
+
+
+def initialize_scatterer(scatterer_dataframe: pd.DataFrame, source: PlaneWave, medium_refractive_index: Quantity) -> PMS_SPHERE:
+    """
+    Initializes the scatterer object for the PyMieSim experiment.
+
+    Parameters
+    ----------
+    scatterer : ScattererCollection
+        The scatterer object containing particle data.
+    source : PlaneWave
+        The light source for the simulation.
+
+    Returns
+    -------
+    PMS_SPHERE
+        Initialized scatterer for the experiment.
+    """
+    size_list = scatterer_dataframe['Size'].values
+    ri_list = scatterer_dataframe['RefractiveIndex'].values
+
+    if len(size_list) == 0:
+        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
+
+    return PMS_SPHERE(
+        diameter=size_list,
+        property=ri_list,
+        medium_property=np.ones(len(size_list)) * medium_refractive_index,
+        source=source
+    )
+
+
+def initialize_detector(detector: Detector, total_size: int) -> PMS_PHOTODIODE:
+    """
+    Initializes the detector object for the PyMieSim experiment.
+
+    Parameters
+    ----------
+    detector : Detector
+        The detector object containing configuration data.
+    total_size : int
+        The number of particles being simulated.
+
+    Returns
+    -------
+    PMS_PHOTODIODE
+        Initialized detector for the experiment.
+    """
+    ONES = np.ones(total_size)
+
+    return PMS_PHOTODIODE(
+        NA=ONES * detector.numerical_aperture,
+        cache_NA=ONES * 0 * AU,
+        gamma_offset=ONES * detector.gamma_angle,
+        phi_offset=ONES * detector.phi_angle,
+        polarization_filter=ONES * np.nan * degree,
+        sampling=ONES * detector.sampling
+    )
+
+
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer_dataframe: pd.DataFrame, medium_refractive_index: Quantity) -> np.ndarray:
+    """
+    Computes the detected signal by analyzing the scattering properties of particles.
+
+    Parameters
+    ----------
+    source : BaseBeam
+        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 : 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.
+
+    Returns
+    -------
+    np.ndarray
+        Array of coupling values for each particle, based on the detected signal.
+    """
+    size_list = scatterer_dataframe['Size'].values
+
+    if len(size_list) == 0:
+        return np.array([]) * watt
+
+    total_size = len(size_list)
+    amplitude_with_rin = apply_rin_noise(source, total_size, detector.signal_digitizer.bandwidth)
+
+    pms_source = PlaneWave(
+        wavelength=np.ones(total_size) * source.wavelength,
+        polarization=np.ones(total_size) * 0 * degree,
+        amplitude=amplitude_with_rin
+    )
+
+    pms_scatterer = initialize_scatterer(scatterer_dataframe, pms_source, medium_refractive_index)
+    pms_detector = initialize_detector(detector, total_size)
+
+    # Configure the detector
+    pms_detector.mode_number = ['NC00'] * total_size
+    pms_detector.rotation = np.ones(total_size) * 0 * degree
+    pms_detector.__post_init__()
+
+    # Set up the experiment
+    experiment = Setup(source=pms_source, scatterer=pms_scatterer, detector=pms_detector)
+
+    # Compute coupling values
+    coupling_value = experiment.get_sequential('coupling').squeeze()
+    return np.atleast_1d(coupling_value) * watt

{flowcypy-0.5.15 → flowcypy-0.6.0}/FlowCyPy/coupling_mechanism/rayleigh.py

@@ -2,10 +2,11 @@
 import numpy as np
 from FlowCyPy import ScattererCollection, Detector
 from FlowCyPy.source import BaseBeam
-from FlowCyPy.units import meter
+from FlowCyPy.units import meter, Quantity
+import pandas as pd
 
 
-def compute_scattering_cross_section(scatterer: ScattererCollection, source: BaseBeam, detector: Detector) -> np.ndarray:
+def compute_scattering_cross_section(scatterer_dataframe: pd.DataFrame, source: BaseBeam, detector: Detector) -> np.ndarray:
     r"""
     Computes the Rayleigh scattering cross-section for a spherical particle with angle dependency.
 
@@ -40,9 +41,8 @@ def compute_scattering_cross_section(scatterer: ScattererCollection, source: Bas
     np.ndarray
         The angle-dependent Rayleigh scattering cross-section (in square meters, m²).
     """
-
-    size_list = scatterer.dataframe['Size'].pint.to(meter).values.numpy_data
-    ri_list = scatterer.dataframe['RefractiveIndex'].values.numpy_data
+    size_list = scatterer_dataframe['Size'].pint.to(meter).values.numpy_data
+    ri_list = scatterer_dataframe['RefractiveIndex'].values.numpy_data
 
     # Extract properties
     wavelength = source.wavelength
@@ -63,7 +63,8 @@ def compute_scattering_cross_section(scatterer: ScattererCollection, source: Bas
     return cross_section.magnitude * meter**2
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection) -> float:
+# def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection) -> float:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer_dataframe: pd.DataFrame, medium_refractive_index: Quantity) -> np.ndarray:
     r"""
     Computes the power detected by a detector from a Rayleigh scattering event.
 
@@ -98,7 +99,7 @@ def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Sca
     """
     scattering_cross_section = compute_scattering_cross_section(
         source=source,
-        scatterer=scatterer,
+        scatterer_dataframe=scatterer_dataframe,
         detector=detector
     )
 

{flowcypy-0.5.15 → flowcypy-0.6.0}/FlowCyPy/coupling_mechanism/uniform.py

@@ -3,7 +3,7 @@ from FlowCyPy import ScattererCollection, Detector, ureg
 from FlowCyPy.source import BaseBeam
 
 
-def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: ScattererCollection) -> np.ndarray:
+def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer_dataframe: ScattererCollection, medium_refractive_index) -> np.ndarray:
     r"""
     Computes the power detected by a detector from a uniform distribution.
 
@@ -36,4 +36,4 @@ def compute_detected_signal(source: BaseBeam, detector: Detector, scatterer: Sca
     float
         The power detected by the detector (in watts, W).
     """
-    return np.ones(len(scatterer.dataframe)) * ureg.watt
+    return np.ones(len(scatterer_dataframe)) * ureg.watt

{flowcypy-0.5.15 → flowcypy-0.6.0}/FlowCyPy/cytometer.py

@@ -3,16 +3,15 @@
 
 import logging
 import numpy as np
-import matplotlib.pyplot as plt
 from typing import List, Callable, Optional
 from MPSPlots.styles import mps
 from FlowCyPy.flow_cell import FlowCell
 from FlowCyPy.detector import Detector
 import pandas as pd
 import pint_pandas
+from FlowCyPy import units
 from FlowCyPy.units import Quantity, milliwatt
-from FlowCyPy.logger import SimulationLogger
-import seaborn as sns
+from FlowCyPy.experiment import Experiment
 
 # Set up logging configuration
 logging.basicConfig(
@@ -20,7 +19,6 @@ logging.basicConfig(
     format='%(levelname)s - %(message)s'
 )
 
-
 class FlowCytometer:
     """
     A simulation class for modeling flow cytometer signals, including Forward Scatter (FSC) and Side Scatter (SSC) channels.
@@ -65,23 +63,26 @@ class FlowCytometer:
     """
     def __init__(
             self,
+            scatterer_collection: object,
             flow_cell: FlowCell,
             detectors: List[Detector],
             coupling_mechanism: Optional[str] = 'mie',
             background_power: Optional[Quantity] = 0 * milliwatt):
 
+        self.scatterer_collection = scatterer_collection
         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
-        self.plot = self.PlotInterface(self)
 
         assert len(self.detectors) == 2, 'For now, FlowCytometer can only take two detectors for the analysis.'
         assert self.detectors[0].name != self.detectors[1].name, 'Both detectors cannot have the same name'
 
-    def run_coupling_analysis(self) -> None:
+        for detector in detectors:
+            detector.cytometer = self
+
+    def run_coupling_analysis(self, scatterer_dataframe: pd.DataFrame) -> None:
         """
         Computes and assigns the optical coupling power for each particle-detection event.
 
@@ -106,14 +107,39 @@ class FlowCytometer:
             self.coupling_power = detection_mechanism(
                 source=self.source,
                 detector=detector,
-                scatterer=self.scatterer_collection
+                scatterer_dataframe=scatterer_dataframe,
+                medium_refractive_index=self.scatterer_collection.medium_refractive_index
             )
 
-            self.scatterer_collection.dataframe["detector: " + detector.name] = pint_pandas.PintArray(self.coupling_power, dtype=self.coupling_power.units)
+            scatterer_dataframe["detector: " + detector.name] = pint_pandas.PintArray(self.coupling_power, dtype=self.coupling_power.units)
+
+    def _generate_pulse_parameters(self, scatterer_dataframe: pd.DataFrame) -> None:
+        """
+        Generates and assigns random Gaussian pulse parameters for each particle event.
+
+        The generated parameters include:
+        - Centers: The time at which each pulse occurs.
+        - Widths: The standard deviation (spread) of each pulse in seconds.
+
+        Effects
+        -------
+        scatterer_collection.dataframe : pandas.DataFrame
+            Adds a 'Widths' column with computed pulse widths for each particle.
+            Uses the flow speed and beam waist to calculate pulse widths.
+        """
+        columns = pd.MultiIndex.from_product(
+            [[p.name for p in self.detectors], ['Centers', 'Heights']]
+        )
+
+        self.pulse_dataframe = pd.DataFrame(columns=columns)
+
+        self.pulse_dataframe['Centers'] = scatterer_dataframe['Time']
 
-        self._generate_pulse_parameters()
+        widths = self.source.waist / self.flow_cell.flow_speed * np.ones(len(scatterer_dataframe))
 
-    def initialize_signal(self) -> None:
+        scatterer_dataframe['Widths'] = pint_pandas.PintArray(widths, dtype=widths.units)
+
+    def initialize_signal(self, run_time: Quantity) -> None:
         """
         Initializes the raw signal for each detector based on the source and flow cell configuration.
 
@@ -126,12 +152,19 @@ class FlowCytometer:
         based on the flow cell's runtime.
 
         """
+        dataframes = []
+
         # Initialize the detectors
         for detector in self.detectors:
-            detector.source = self.source
-            detector.init_raw_signal(run_time=self.flow_cell.run_time)
+            dataframe = detector.get_initialized_signal(run_time=run_time)
+
+            dataframes.append(dataframe)
+
+        self.dataframe = pd.concat(dataframes, keys=[d.name for d in self.detectors])
 
-    def simulate_pulse(self) -> None:
+        self.dataframe.index.names = ["Detector", "Index"]
+
+    def get_continous_acquisition(self, run_time: Quantity) -> None:
         """
         Simulates the generation of optical signal pulses for each particle event.
 
@@ -150,24 +183,41 @@ class FlowCytometer:
         ValueError
             If the scatterer collection lacks required data columns ('Widths', 'Time').
         """
-        logging.debug("Starting pulse simulation.")
+        if not run_time.check('second'):
+            raise ValueError(f"flow_speed must be in meter per second, but got {run_time.units}")
+
+        self.initialize_signal(run_time=run_time)
+
+        scatterer_dataframe = self.flow_cell.generate_event_dataframe(self.scatterer_collection.populations, run_time=run_time)
+
+        self.scatterer_collection.fill_dataframe_with_sampling(scatterer_dataframe)
 
-        _widths = self.scatterer_collection.dataframe['Widths'].values
-        _centers = self.scatterer_collection.dataframe['Time'].values
+        self.run_coupling_analysis(scatterer_dataframe)
+
+        self._generate_pulse_parameters(scatterer_dataframe)
+
+        self.scatterer_collection.dataframe = scatterer_dataframe
+
+        _widths = scatterer_dataframe['Widths'].pint.to('second').pint.quantity.magnitude
+        _centers = scatterer_dataframe['Time'].pint.to('second').pint.quantity.magnitude
 
         for detector in self.detectors:
-            _coupling_power = self.scatterer_collection.dataframe["detector: " + detector.name].values
+            _coupling_power = scatterer_dataframe["detector: " + detector.name].values
+
+            detector_signal = self.dataframe.xs(detector.name)['Signal']
 
             # Generate noise components
-            detector._add_thermal_noise_to_raw_signal()
+            detector._add_thermal_noise_to_raw_signal(signal=detector_signal)
 
-            detector._add_dark_current_noise_to_raw_signal()
+            detector._add_dark_current_noise_to_raw_signal(signal=detector_signal)
 
             # Broadcast the time array to the shape of (number of signals, len(detector.time))
-            time_grid = np.expand_dims(detector.dataframe.Time.values.numpy_data, axis=0) * _centers.units
+            time = self.dataframe.xs(detector.name)['Time'].pint.magnitude
 
-            centers = np.expand_dims(_centers.numpy_data, axis=1) * _centers.units
-            widths = np.expand_dims(_widths.numpy_data, axis=1) * _widths.units
+            time_grid = np.expand_dims(time, axis=0) * units.second
+
+            centers = np.expand_dims(_centers, axis=1) * units.second
+            widths = np.expand_dims(_widths, axis=1) * units.second
 
             # Compute the Gaussian for each height, center, and width using broadcasting
             power_gaussians = _coupling_power[:, np.newaxis] * np.exp(- (time_grid - centers) ** 2 / (2 * widths ** 2))
@@ -175,36 +225,25 @@ class FlowCytometer:
             total_power = np.sum(power_gaussians, axis=0) + self.background_power
 
             # Sum all the Gaussians and add them to the detector.raw_signal
-            detector._add_optical_power_to_raw_signal(optical_power=total_power)
+            detector._add_optical_power_to_raw_signal(
+                signal=detector_signal,
+                optical_power=total_power,
+                wavelength=self.flow_cell.source.wavelength
+            )
 
-            detector.capture_signal()
+            digitized_signal, is_saturated = detector.capture_signal(signal=detector_signal)
 
-        self._log_statistics()
+            self.dataframe.loc[detector.name, 'DigitizedSignal'] = digitized_signal
 
-    def _log_statistics(self) -> SimulationLogger:
-        """
-        Logs and displays key statistics about the simulated events.
+            detector.is_saturated = is_saturated
 
-        This includes metrics such as:
-        - Total number of events processed.
-        - Average time between events.
-        - First and last event times.
-        - Minimum time intervals between events.
-
-        Returns
-        -------
-        SimulationLogger
-            An instance of the logger containing all recorded statistics.
-
-        Effects
-        -------
-        Outputs formatted tables to the console or log file, depending on the logger's configuration.
-        """
-        logger = SimulationLogger(cytometer=self)
-
-        logger.log_statistics(include_totals=True, table_format="fancy_grid")
+        experiment = Experiment(
+            run_time=run_time,
+            scatterer_dataframe=scatterer_dataframe,
+            detector_dataframe=self.dataframe
+        )
 
-        return logger
+        return experiment
 
     def _get_detection_mechanism(self) -> Callable:
         """
@@ -242,32 +281,6 @@ class FlowCytometer:
             case _:
                 raise ValueError("Invalid coupling mechanism. Choose 'rayleigh' or 'uniform'.")
 
-    def _generate_pulse_parameters(self) -> None:
-        """
-        Generates and assigns random Gaussian pulse parameters for each particle event.
-
-        The generated parameters include:
-        - Centers: The time at which each pulse occurs.
-        - Widths: The standard deviation (spread) of each pulse in seconds.
-
-        Effects
-        -------
-        scatterer_collection.dataframe : pandas.DataFrame
-            Adds a 'Widths' column with computed pulse widths for each particle.
-            Uses the flow speed and beam waist to calculate pulse widths.
-        """
-        columns = pd.MultiIndex.from_product(
-            [[p.name for p in self.detectors], ['Centers', 'Heights']]
-        )
-
-        self.pulse_dataframe = pd.DataFrame(columns=columns)
-
-        self.pulse_dataframe['Centers'] = self.scatterer_collection.dataframe['Time']
-
-        widths = self.source.waist / self.flow_cell.flow_speed * np.ones(self.scatterer_collection.n_events)
-
-        self.scatterer_collection.dataframe['Widths'] = pint_pandas.PintArray(widths, dtype=widths.units)
-
     def add_detector(self, **kwargs) -> Detector:
         """
         Dynamically adds a new detector to the system configuration.
@@ -292,105 +305,3 @@ class FlowCytometer:
 
         return detector
 
-    class PlotInterface:
-        def __init__(self, cytometer):
-            self.cytometer = cytometer
-
-        def signals(self, figure_size: tuple = (10, 6), add_peak_locator: bool = False, show: bool = True) -> None:
-            """
-            Visualizes the raw signals for all detector channels along with the scatterer distribution.
-
-            Parameters
-            ----------
-            figure_size : tuple, optional
-                Dimensions of the generated plot (default: (10, 6)).
-            add_peak_locator : bool, optional
-                If True, adds visual markers for detected signal peaks (default: False).
-
-            Effects
-            -------
-            Displays a multi-panel plot showing:
-            - Raw signals for each detector channel.
-            - Scatterer distribution along the time axis.
-            """
-            logging.info("Plotting the signal for the different channels.")
-
-            scatterer_collection = self.cytometer.scatterer_collection
-            detectors = self.cytometer.detectors
-
-            n_detectors = len(detectors)
-
-            with plt.style.context(mps):
-                _, axes = plt.subplots(ncols=1, nrows=n_detectors + 1, figsize=figure_size, sharex=True, sharey=True, gridspec_kw={'height_ratios': [1, 1, 0.4]})
-
-            time_unit, signal_unit = detectors[0].plot(ax=axes[0], show=False, add_peak_locator=add_peak_locator)
-            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)
-            scatterer_collection.add_to_ax(axes[-1])
-
-            # Add legends to each subplot
-            for ax in axes:
-                ax.legend()
-
-            if show: # Display the plot
-                plt.show()
-
-        def coupling_distribution(self, log_scale: bool = False, show: bool = True, equal_limits: bool = False, save_path: str = None) -> None:
-            """
-            Plots the density distribution of optical coupling in the FSC and SSC channels.
-
-            This method generates a joint plot showing the relationship between the signals from
-            the forward scatter ('detector: forward') and side scatter ('detector: side') detectors.
-            The plot is color-coded by particle population and can optionally display axes on a logarithmic scale.
-
-            Parameters
-            ----------
-            log_scale : bool, optional
-                If True, applies a logarithmic scale to both the x and y axes of the plot (default: False).
-            show : bool, optional
-                If True, displays the plot immediately. If False, the plot is created but not displayed,
-                allowing for further customization or saving externally (default: True).
-            equal_limits : bool, optional
-                If True, sets the same limits for both the x and y axes based on the maximum range
-                across both axes. If False, the limits are set automatically based on the data (default: False).
-
-            """
-            scatterer_collection = self.cytometer.scatterer_collection
-            detector_0, detector_1 = self.cytometer.detectors
-
-            with plt.style.context(mps):
-                joint_plot = sns.jointplot(
-                    data=scatterer_collection.dataframe,
-                    x=f'detector: {detector_0.name}',
-                    y=f'detector: {detector_1.name}',
-                    hue="Population",
-                    alpha=0.8,
-                )
-
-            if log_scale:
-                joint_plot.ax_joint.set_xscale('log')
-                joint_plot.ax_joint.set_yscale('log')
-
-            if equal_limits:
-                # Get data limits
-                x_data = scatterer_collection.dataframe[f'detector: {detector_0.name}']
-                y_data = scatterer_collection.dataframe[f'detector: {detector_1.name}']
-
-                x_min, x_max = x_data.min(), x_data.max()
-                y_min, y_max = y_data.min(), y_data.max()
-
-                # Find the overall min and max
-                overall_min = min(x_min, y_min)
-                overall_max = max(x_max, y_max)
-
-                # Set equal limits
-                joint_plot.ax_joint.set_xlim(overall_min, overall_max)
-                joint_plot.ax_joint.set_ylim(overall_min, overall_max)
-
-            if save_path:
-                joint_plot.figure.savefig(save_path, dpi=300, bbox_inches='tight')
-                print(f"Plot saved to {save_path}")
-
-            if show:  # Display the plot
-                plt.show()