FlowCyPy 0.5.0__tar.gz

flowcypy-0.5.0/.condarc

@@ -0,0 +1,37 @@
+# Set the default channels for Conda to search packages
+channels:
+  - conda-forge
+  - defaults
+  - martinpdes
+
+# Specify whether to automatically activate the base environment
+auto_activate_base: true
+
+# Enable SSL verification
+ssl_verify: true
+
+# Proxy settings (if behind a proxy, uncomment and configure)
+#proxy_servers:
+#  http: http://username:password@proxy.example.com:port
+#  https: https://username:password@proxy.example.com:port
+
+# Enable or disable Conda’s package signature verification
+# (useful for debugging or offline setups)
+#verify_ssl: true
+
+# Show channel URLs when searching or listing packages
+show_channel_urls: true
+
+# Automatically update Conda when a new version is available
+auto_update_conda: true
+
+# Configure pip interoperability
+pip_interop_enabled: true
+
+# Override the default number of threads for solving the environment
+# (useful for large environments)
+#sat_solver_threads: 4
+
+
+plugins:
+  anaconda_telemetry: false

flowcypy-0.5.0/.flake8

@@ -0,0 +1,12 @@
+[flake8]
+max-line-length = 300
+exclude =
+    .git
+    docs/build
+    docs/source/gallery
+    development
+
+count = true
+per-file-ignores =
+    __init__.py: F403, F401
+    FlowCyPy/units.py: F401

flowcypy-0.5.0/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# Specify reviewers for pull requests
+
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    target-branch: "master"
+    schedule:
+      interval: "weekly"
+      day: "sunday"
+      time: "09:00"

flowcypy-0.5.0/.github/workflows/deploy_PyPi.yml

@@ -0,0 +1,20 @@
+name: Deploy to PyPi
+
+on:
+  push:
+    branches: [ "master" ]
+    tags:
+      - '*'
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+    contents: write
+
+jobs:
+  pure_package:
+    uses: MartinPdeS/MPSActions/.github/workflows/publish_pure_package_to_PyPi.yml@master
+    with:
+      python-version: "3.11"
+    secrets:
+      PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}

flowcypy-0.5.0/.github/workflows/deploy_anaconda.yml

@@ -0,0 +1,21 @@
+name: Deploy Conda Packages
+
+on:
+  push:
+    branches: [ "master" ]
+    tags:
+      - '*'
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+    contents: write
+
+jobs:
+  ManyLinux_x86_64:
+    uses: MartinPdeS/MPSActions/.github/workflows/publish_compiled_package_to_anaconda.yml@master
+    with:
+      python-versions: '["3.11"]'
+    secrets:
+      ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_API_TOKEN }}
+

flowcypy-0.5.0/.github/workflows/deploy_coverage.yml

@@ -0,0 +1,25 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy coverage
+
+on:
+  push:
+    branches: [ "master" ]
+    tags:
+      - '*'
+  pull_request:
+    branches: [ "master" ]
+
+
+# Sets permissions of the  GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+jobs:
+  ManyLinux_x86_64:
+    uses: MartinPdeS/MPSActions/.github/workflows/publish_coverage.yml@master
+    with:
+      python-version: "3.11"
+    secrets:
+      _GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

flowcypy-0.5.0/.github/workflows/deploy_documentation.yml

@@ -0,0 +1,24 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy documentation to github page
+
+on:
+  push:
+    branches: [ "master" ]
+    tags:
+      - '*'
+  pull_request:
+    branches: [ "master" ]
+
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+jobs:
+  ManyLinux_x86_64:
+    uses: MartinPdeS/MPSActions/.github/workflows/publish_documentation.yml@master
+    with:
+      python-version: "3.11"
+      package-name: "FlowCyPy"

flowcypy-0.5.0/.gitignore

@@ -0,0 +1,28 @@
+# General patterns
+*.DS_store
+*.ipynb_checkpoints*
+*__pycache__*
+*.so
+*.a
+.coverage*
+*.pytest_cache
+htmlcov
+dist
+build
+*.egg*
+*.whl
+CMakeCache.txt
+CMakeFiles
+install_manifest.txt
+cmake_install.cmake
+wheelhouse
+
+# Docs-specific patterns
+docs/source/gallery/*
+!docs/source/gallery/index.rst
+PyOptik/data/**/test*
+PyOptik/data/**/example*
+
+# Override for documentation_build
+!documentation_build
+!documentation_build/**

flowcypy-0.5.0/.readthedocs.yml

@@ -0,0 +1,35 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+submodules:
+  include: all
+  recursive: true
+
+build:
+  os: ubuntu-22.04
+
+
+  tools:
+    python: "3.10"
+  jobs:
+    pre_install:
+      - Xvfb :99 &
+      - export DISPLAY=:99
+      - cd docs && rm -rf source/gallery
+      - sleep 3
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - documentation
+
+sphinx:
+  builder: html
+  configuration: docs/source/conf.py
+  fail_on_warning: false

flowcypy-0.5.0/FlowCyPy/__init__.py

@@ -0,0 +1,15 @@
+try:
+    from ._version import version as __version__  # noqa: F401
+
+except ImportError:
+    __version__ = "0.0.0"
+
+from .units import ureg, watt, meter, second, liter, particle
+from .cytometer import FlowCytometer
+from .event_correlator import EventCorrelator
+from .scatterer import Scatterer, CouplingModel
+from .population import Population
+from .detector import Detector
+from .flow_cell import FlowCell
+from .source import GaussianBeam
+from .noises import NoiseSetting

flowcypy-0.5.0/FlowCyPy/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

flowcypy-0.5.0/FlowCyPy/classifier.py

@@ -0,0 +1,196 @@
+from sklearn.cluster import KMeans
+from sklearn.cluster import DBSCAN
+import pandas as pd
+from typing import List, Dict, Tuple
+
+
+class BaseClassifier:
+    def filter_dataframe(self, features: list, detectors: list = None) -> object:
+        """
+        Filter the DataFrame based on the selected features and detectors.
+
+        Parameters
+        ----------
+        features : list
+            List of features to use for filtering. Options include 'Heights', 'Widths', 'Areas'.
+        detectors : list, optional
+            List of detectors to use. If None, use all detectors.
+
+        Returns
+        -------
+        DataFrame
+            A filtered DataFrame containing only the selected detectors and features.
+
+        Raises
+        ------
+        ValueError
+            If no matching features are found for the given detectors and features.
+        """
+        # Determine detectors to use
+        if detectors is None:
+            detectors = self.dataframe.columns.get_level_values(0).unique().tolist()
+
+        # Build the list of selected columns
+        selected_features = [
+            (detector, feature) for detector in detectors for feature in features
+            if (detector, feature) in self.dataframe.columns
+        ]
+
+        if not selected_features:
+            raise ValueError("No matching features found for the given detectors and features.")
+
+        # Return the filtered DataFrame
+        return self.dataframe[selected_features]
+
+
+class KmeansClassifier(BaseClassifier):
+    def __init__(self, dataframe: object) -> None:
+        """
+        Initialize the Classifier.
+
+        Parameters
+        ----------
+        dataframe : DataFrame
+            The input dataframe with multi-index columns.
+        """
+        self.dataframe = dataframe
+        self.dataframe['Label'] = 0  # Initialize labels as 0
+
+
+
+    def run(self, number_of_cluster: int, features: list = ['Heights'], detectors: list = None, random_state: int = 42) -> None:
+        """
+        Run KMeans clustering on the selected features and detectors.
+
+        Parameters
+        ----------
+        number_of_cluster : int
+            Number of clusters for KMeans.
+        features : list
+            List of features to use for clustering. Options include 'Heights', 'Widths', 'Areas'.
+        detectors : list, optional
+            List of detectors to use. If None, use all detectors.
+        random_state : int, optional
+            Random state for KMeans, by default 42.
+        """
+        # Filter the DataFrame
+        X = self.filter_dataframe(features=features, detectors=detectors)
+
+        # Ensure data is dequantified if it uses Pint quantities
+        if hasattr(X, 'pint'):
+            X = X.pint.dequantify()
+
+        # Run KMeans
+        kmeans = KMeans(n_clusters=number_of_cluster, random_state=random_state)
+        self.dataframe['Label'] = kmeans.fit_predict(X)
+
+class DBScanClassifier(BaseClassifier):
+    def __init__(self, dataframe: object) -> None:
+        """
+        Initialize the DBScanClassifier.
+
+        Parameters
+        ----------
+        dataframe : DataFrame
+            The input dataframe with multi-index columns.
+        """
+        self.dataframe = dataframe
+        self.dataframe['Label'] = -1  # Initialize labels as -1 (noise for DBSCAN)
+
+    def run(self, eps: float = 0.5, min_samples: int = 5, features: list = ['Heights'], detectors: list = None) -> None:
+        """
+        Run DBSCAN clustering on the selected features and detectors.
+
+        Parameters
+        ----------
+        eps : float, optional
+            The maximum distance between two samples for them to be considered as in the same neighborhood, by default 0.5.
+        min_samples : int, optional
+            The number of samples in a neighborhood for a point to be considered a core point, by default 5.
+        features : list
+            List of features to use for clustering. Options include 'Heights', 'Widths', 'Areas'.
+        detectors : list, optional
+            List of detectors to use. If None, use all detectors.
+        """
+        # Filter the DataFrame
+        X = self.filter_dataframe(features=features, detectors=detectors)
+
+        # Ensure data is dequantified if it uses Pint quantities
+        if hasattr(X, 'pint'):
+            X = X.pint.dequantify()
+
+        # Handle missing values (if necessary)
+        X = X.fillna(0).to_numpy()
+
+        # Run DBSCAN
+        dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+        self.dataframe['Label'] = dbscan.fit_predict(X)
+
+
+class RangeClassifier:
+    """
+    A classifier for assigning population labels based on defined ranges.
+
+    Parameters
+    ----------
+    dataframe : pd.DataFrame
+        The input dataframe with features to classify.
+    feature : str
+        The column name of the feature to classify.
+
+    Attributes
+    ----------
+    dataframe : pd.DataFrame
+        The dataframe with an added 'Label' column.
+    ranges : List[Tuple[float, float, str]]
+        The list of ranges and their associated labels.
+    """
+
+    def __init__(self, dataframe: pd.DataFrame) -> None:
+        """
+        Initialize the classifier.
+
+        Parameters
+        ----------
+        dataframe : pd.DataFrame
+            The input dataframe with features to classify.
+        feature : str
+            The column name of the feature to classify.
+        """
+        self.dataframe = dataframe
+        self.ranges = []  # To store the ranges and their labels
+
+    def run(self, ranges: Dict[str, Tuple[float, float]]) -> None:
+        """
+        Classify the dataframe by assigning population labels based on specified ranges applied to the index.
+
+        Parameters
+        ----------
+        ranges : dict
+            A dictionary where keys are population names (labels) and values are tuples
+            specifying the (lower, upper) bounds of the range for that population.
+
+        Example
+        -------
+        >>> ranges = {
+        >>>     'Population 0': (0, 100),
+        >>>     'Population 1': (100, 150),
+        >>>     'Population 2': (150, 200)
+        >>> }
+        >>> classifier.run(ranges)
+        """
+        # Create conditions and corresponding labels
+        conditions = []
+        labels = []
+        for label, (lower, upper) in ranges.items():
+            conditions.append((self.dataframe.index >= lower) & (self.dataframe.index < upper))
+            labels.append(label)
+
+        # Use np.select to efficiently apply conditions
+        self.dataframe['Label'] = pd.Series(
+            pd.cut(self.dataframe.index,
+                   bins=[float('-inf')] + [upper for _, (_, upper) in ranges.items()],
+                   labels=list(ranges.keys()),
+                   include_lowest=True),
+            index=self.dataframe.index)
+

flowcypy-0.5.0/FlowCyPy/coupling_mechanism/__init__.py

@@ -0,0 +1,4 @@
+from . import uniform
+from . import rayleigh
+from . import mie
+from . import empirical

flowcypy-0.5.0/FlowCyPy/coupling_mechanism/empirical.py

@@ -0,0 +1,47 @@
+import numpy as np
+from FlowCyPy import Scatterer, 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:
+    """
+    Empirical model for scattering intensity based on particle size, granularity, and detector angle.
+
+    This function models forward scatter (FSC) as proportional to the particle's size squared and
+    side scatter (SSC) as proportional to the granularity and modulated by angular dependence
+    (sin^n(theta)). Granularity is a dimensionless measure of the particle's internal complexity or
+    surface irregularities:
+
+    - A default value of 1.0 is used for moderate granularity (e.g., typical white blood cells).
+    - Granularity values < 1.0 represent smoother particles with less internal complexity (e.g., bacteria).
+    - Granularity values > 1.0 represent particles with higher internal complexity or surface irregularities (e.g., granulocytes).
+
+    Parameters
+    ----------
+    detector : Detector
+        The detector object containing theta_angle (in radians).
+    particle_size : float
+        The size of the particle (in meters).
+    granularity : float, optional
+        A measure of the particle's internal complexity or surface irregularities (dimensionless).
+        Default is 1.0.
+    A : float, optional
+        Empirical scaling factor for angular dependence. Default is 1.5.
+    n : float, optional
+        Power of sine function for angular dependence. Default is 2.0.
+
+    Returns
+    -------
+    float
+        The detected scattering intensity for the given particle and detector.
+    """
+    size_list = scatterer.dataframe['Size'].pint.to(meter).values.numpy_data
+
+    # Forward scatter is proportional to size^2
+    fsc_intensity = size_list**2
+
+    # Side scatter is proportional to granularity and modulated by angular dependence
+    ssc_intensity = granularity * (1 + A * np.sin(np.radians(detector.phi_angle))**n) * np.ones_like(size_list)
+
+    return fsc_intensity * watt if detector.phi_angle < np.radians(10) else ssc_intensity * watt