PyMieSim 3.6.0__cp313-cp313-win_amd64.whl

PyMieSim/experiment/source/base.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import numpy
+from pydantic import field_validator
+import pint_pandas
+from dataclasses import fields
+from PyMieSim.polarization import BasePolarization, Linear
+from PyMieSim.units import Quantity, meter, watt, AU, degree
+
+
+class BaseSource:
+    """
+    Base class for light sources in PyMieSim experiments.
+    """
+
+    @field_validator('wavelength', mode='plain')
+    def _validate_length(cls, value):
+        """
+        Ensures that diameter is Quantity objects with length units.
+        """
+        if not isinstance(value, Quantity) or not value.check(meter):
+            raise ValueError(f"{value} must be a Quantity with meters units [meter].")
+
+        return numpy.atleast_1d(value)
+
+    @field_validator('optical_power', mode='plain')
+    def _validate_power(cls, value):
+        """
+        Ensure that arrays are properly converted to numpy arrays.
+        """
+        if not isinstance(value, Quantity) or not value.check(watt):
+            raise ValueError(f"{value} must be a Quantity with power units [watt].")
+
+        if not isinstance(value, numpy.ndarray):
+            value = numpy.atleast_1d(value)
+
+        return value
+
+    @field_validator('NA', mode='plain')
+    def _validate_arbitrary_units(cls, value):
+        """
+        Ensure that arrays are properly converted to numpy arrays.
+        """
+        if not isinstance(value, Quantity) or not value.check(AU):
+            raise ValueError(f"{value} must be a Quantity with arbitrary units [AU].")
+
+        if not isinstance(value, numpy.ndarray):
+            value = numpy.atleast_1d(value)
+
+        return value
+
+    @field_validator('polarization', mode='before')
+    def _validate_polarization(cls, value):
+        """
+        Ensures that polarization is well defined.
+        """
+        if (not isinstance(value, Quantity) or not value.check(degree)) and not isinstance(value, BasePolarization):
+            raise ValueError(f"{value} must be a Quantity with degree units [degree] or a Polarization instance.")
+
+        if isinstance(value, BasePolarization):
+            return value
+
+        if isinstance(value, Quantity):
+            return Linear(value)
+
+    def _generate_mapping(self) -> None:
+        """
+        Constructs a table of the scatterer's properties formatted for data visualization.
+        This method populates the `mapping` dictionary with user-friendly descriptions and formats of the scatterer properties.
+
+        Returns:
+            list: A list of visual representations for each property in the `mapping` dictionary that has been populated.
+        """
+        for attr in [f.name for f in fields(self) if f.name != 'source']:
+            values = getattr(self, attr)
+
+            if values is None:
+                continue
+
+            if hasattr(values, 'magnitude'):
+                magnitude = values.magnitude
+                units = values.units
+                self.mapping["source:" + attr] = pint_pandas.PintArray(magnitude, dtype=units)
+            else:
+                self.mapping["source:" + attr] = [repr(m) for m in values]

PyMieSim/experiment/source/gaussian.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from typing import Union
+from PyMieSim.single.source import Gaussian as _  # noqa:F401  # Necessary for pybind11 binding initialization
+from pydantic.dataclasses import dataclass
+from PyMieSim.units import Quantity
+from PyMieSim.experiment.source.base import BaseSource
+from PyMieSim.experiment.utils import config_dict, Sequential
+from PyMieSim.polarization import BasePolarization, Linear
+from PyMieSim.binary.interface_sets import CppGaussianSourceSet
+
+@dataclass(config=config_dict)
+class Gaussian(BaseSource, Sequential):
+    """
+    Represents a Gaussian light source with a specified numerical aperture and optical power.
+
+    Inherits from BaseSource and adds specific attributes for Gaussian sources.
+
+    Parameters
+    ----------
+    wavelength : Quantity
+        The wavelength(s) of the light source.
+    polarization : Union[UnitPolarizationAngle, Quantity]
+        Polarization state of the light field, if float is given it is assumed Linear polarization of angle theta.
+    NA : Quantity
+        The numerical aperture(s) of the Gaussian source.
+    optical_power : Quantity
+        The optical power of the source, in Watts.
+    """
+    NA: Quantity
+    optical_power: Quantity
+    wavelength: Quantity
+    polarization: Union[BasePolarization, Quantity]
+
+    def _generate_binding(self) -> None:
+        """
+        Prepares the keyword arguments for the C++ binding based on the scatterer's properties. This
+        involves evaluating material indices and organizing them into a dictionary for the C++ interface.
+
+        """
+        self.mapping = {}
+
+        if not isinstance(self.polarization, BasePolarization):
+            self.polarization = Linear(self.polarization)
+
+        self.binding_kwargs = dict(
+            wavelength=self.wavelength,
+            jones_vector=self.polarization.element,
+            NA=self.NA,
+            optical_power=self.optical_power,
+            is_sequential=self.is_sequential
+        )
+
+        self.binding = CppGaussianSourceSet(
+            wavelength=self.wavelength.to('meter').magnitude,
+            jones_vector=self.polarization.element,
+            NA=self.NA.to('dimensionless').magnitude,
+            optical_power=self.optical_power.to('watt').magnitude,
+            is_sequential=self.is_sequential
+        )

PyMieSim/experiment/source/planewave.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from typing import Union
+from PyMieSim.single.source import PlaneWave as _  # noqa:F401  # Necessary for pybind11 binding initialization
+import numpy
+from pydantic.dataclasses import dataclass
+from pydantic import field_validator
+from PyMieSim.units import Quantity
+from PyMieSim.experiment.source.base import BaseSource
+from PyMieSim.polarization import BasePolarization, Linear
+from PyMieSim.experiment.utils import config_dict, Sequential
+from PyMieSim.binary.interface_sets import CppPlaneWaveSourceSet
+
+
+@dataclass(config=config_dict)
+class PlaneWave(BaseSource, Sequential):
+    """
+    Represents a Plane Wave light source with a specified amplitude.
+
+    Inherits from BaseSource and specifies amplitude directly.
+
+    Parameters
+    ----------
+    wavelength : Quantity
+        The wavelength(s) of the light source.
+    polarization : Union[UnitPolarizationAngle, Quantity]
+        Polarization state of the light field, if float is given it is assumed Linear polarization of angle theta.
+    amplitude : Quantity
+        The amplitude of the plane wave, in Volt/Meter.
+    """
+    amplitude: Quantity
+    wavelength: Quantity
+    polarization: Union[BasePolarization, Quantity]
+
+    @field_validator('amplitude', mode='before')
+    def _validate_array(cls, value):
+        """Ensure that arrays are properly converted to numpy arrays."""
+        if not isinstance(value, numpy.ndarray):
+            value = numpy.atleast_1d(value)
+
+        return value
+
+    def _generate_binding(self) -> None:
+        """
+        Prepares the keyword arguments for the C++ binding based on the scatterer's properties. This
+        involves evaluating material indices and organizing them into a dictionary for the C++ interface.
+
+        Returns
+        -------
+        None
+        """
+        self.mapping = {}
+
+        if not isinstance(self.polarization, BasePolarization):
+            self.polarization = Linear(self.polarization)
+
+        self.binding_kwargs = dict(
+            wavelength=self.wavelength,
+            jones_vector=self.polarization.element,
+            amplitude=self.amplitude,
+            is_sequential=self.is_sequential
+        )
+
+        self.binding = CppPlaneWaveSourceSet(
+            wavelength=self.wavelength.to('meter').magnitude,
+            jones_vector=self.polarization.element,
+            amplitude=self.amplitude.to('volt/meter').magnitude,
+            is_sequential=self.is_sequential
+        )

PyMieSim/experiment/utils.py

@@ -0,0 +1,132 @@
+import numpy as np
+from typing import Union, List, Dict, Optional, TypeVar
+from PyMieSim.units import Quantity
+from PyOptik.material.base_class import BaseMaterial
+
+
+T = TypeVar('T')
+
+from pydantic import ConfigDict
+
+# Configuration dictionary for the Pydantic dataclass
+config_dict = ConfigDict(
+    kw_only=True,
+    slots=True,
+    extra='forbid',
+    arbitrary_types_allowed=True
+)
+
+
+def broadcast_params(total_size: Optional[int] = None, **kwargs: Union[T, List[T]]) -> Dict[str, np.ndarray]:
+    """
+    Broadcast scalar or single-element parameters to NumPy arrays of a given target size.
+
+    Each parameter is first converted to a 1D NumPy array. If a parameter is given as a scalar
+    or an array/list of length one, it will be repeated (broadcast) to match the target size.
+    The target size is determined by `total_size` if provided, or as the maximum size among all
+    parameters otherwise. If any parameter is provided as an array of length greater than one and
+    its length does not match the target size, a ValueError is raised.
+
+    Parameters
+    ----------
+    total_size : int, optional
+        The explicit target size for broadcasting. Must be a positive integer if provided.
+        If not provided, the target size is determined as the maximum size among the input parameters.
+    **kwargs
+        Keyword arguments mapping parameter names to values, each of which may be a scalar or a list/array.
+
+    Returns
+    -------
+    dict
+        A dictionary with the same keys as the input parameters, where each value is a NumPy array
+        of length equal to the target size.
+
+    Raises
+    ------
+    ValueError
+        If any parameter provided as a list/array has a length greater than one that does not match
+        the target size, or if total_size is provided and is less than the maximum size among the inputs.
+    AssertionError
+        If total_size is provided and is not a positive integer.
+    """
+    if total_size is not None:
+        assert isinstance(total_size, int) and total_size > 0, "total_size must be a positive integer"
+
+    # Convert each parameter to a 1D NumPy array.
+    arrays = {name: np.atleast_1d(val) for name, val in kwargs.items()}
+
+    # Determine the target size.
+    target_size = total_size or  max(arr.size for arr in arrays.values())
+
+    # Ensure no provided array of size > 1 mismatches the explicit target_size.
+    for name, arr in arrays.items():
+        if arr.size > 1 and arr.size != target_size:
+            raise ValueError(f"Inconsistent sizes: '{name}' has size {arr.size} but expected 1 or {target_size}.")
+
+    # Broadcast any array of size 1 to the target size.
+    for name, arr in arrays.items():
+        if arr.size == 1:
+            arrays[name] = np.full(target_size, arr.item())
+            if isinstance(arr, Quantity):
+                arrays[name] *= arr.units
+
+    return arrays
+
+
+class Sequential:
+    is_sequential = False
+
+    @classmethod
+    def build_sequential(cls, total_size: Optional[int] = None, **kwargs) -> object:
+        """
+        Broadcast scalar or single-element parameters to NumPy arrays of uniform length
+        and construct a new instance of the class.
+
+        Each parameter passed via keyword arguments may be provided as a scalar or as a list/array.
+        Scalars or single-element lists/arrays will be repeated to match the length of the longest
+        parameter. If any parameter is given as a list/array with more than one element, its length
+        must equal the maximum length among all parameters (or the explicit `total_size` if provided);
+        otherwise, a ValueError is raised.
+
+        Additionally, if a keyword argument 'source' is provided, it is removed from the
+        broadcasted parameters and passed directly to the class constructor.
+
+        Parameters
+        ----------
+        total_size : int, optional
+            The explicit target size for broadcasting. Must be a positive integer if provided.
+            If not specified, the target size is determined by the maximum size among the input parameters.
+        **kwargs : dict
+            Arbitrary keyword arguments mapping parameter names to values. Each value may be a scalar
+            or a list/array of values. Examples include parameters such as `source`, `diameter`,
+            `property`, or `medium_property`.
+
+        Returns
+        -------
+        object
+            A new instance of the class with all provided parameters broadcasted as NumPy arrays
+            of equal length. If 'source' is provided, it is passed directly to the class constructor.
+
+        Raises
+        ------
+        ValueError
+            If any parameter provided as a list/array has a length greater than one that does not
+            match the target size.
+        """
+        is_material = any([
+            isinstance(v, BaseMaterial) for v in kwargs.values()
+        ])
+
+        assert not is_material, "For the moment no Material can be defined material property for sequential computing, one should use refractive index property. See documentation online."
+        source = kwargs.pop("source", None)
+        kwargs = broadcast_params(total_size=total_size, **kwargs)
+
+        if source is not None:
+            instance = cls(source=source, **kwargs)
+        else:
+            instance = cls(**kwargs)
+
+        instance.is_sequential = True
+
+        return instance
+

PyMieSim/gui/helper.py

@@ -0,0 +1,60 @@
+from PyMieSim.experiment.source.gaussian import Gaussian
+from PyMieSim.experiment.scatterer.sphere import Sphere
+from PyMieSim.experiment.detector.photodiode import Photodiode
+from PyMieSim.experiment import Setup
+from PyMieSim.units import nanometer, degree, milliwatt, AU, RIU
+import numpy
+
+
+length_units = nanometer
+power_units = milliwatt
+angle_units = degree
+
+
+def parse_string_to_array_or_float(input_str):
+    """
+    Parse a string to return either a numpy array or a float.
+
+    If the string is in the format 'start:end:count', return np.linspace(start, end, count).
+    If the string is a comma-separated list, return a numpy array.
+    If the string is a single numeric value, return it as a float.
+    """
+    try:
+        if ":" in input_str:
+            start, end, count = map(float, input_str.split(":"))
+            return numpy.linspace(start, end, int(count))
+        elif "," in input_str:
+            return numpy.array(list(map(float, input_str.split(","))))
+        else:
+            return float(input_str)
+    except ValueError:
+        raise ValueError("Invalid input string format. Expected 'start:end:count', a comma-separated list, or a single numeric value.")
+
+
+def interface(source_kwargs: dict, scatterer_kwargs: dict, detector_kwargs: dict, measure: str, **kwargs):
+    source = Gaussian(
+        wavelength=parse_string_to_array_or_float(source_kwargs['wavelength']) * length_units,
+        polarization=parse_string_to_array_or_float(source_kwargs['polarization']) * angle_units,
+        NA=parse_string_to_array_or_float(source_kwargs['NA']) * AU,
+        optical_power=parse_string_to_array_or_float(source_kwargs['optical_power']) * milliwatt
+    )
+
+    scatterer = Sphere(
+        diameter=parse_string_to_array_or_float(scatterer_kwargs['diameter']) * length_units,
+        property=parse_string_to_array_or_float(scatterer_kwargs['property']) * RIU,
+        medium_property=parse_string_to_array_or_float(scatterer_kwargs['medium_property']) * RIU,
+        source=source
+    )
+
+    detector = Photodiode(
+        NA=parse_string_to_array_or_float(detector_kwargs['NA']) * AU,
+        gamma_offset=parse_string_to_array_or_float(detector_kwargs['gamma_offset']) * angle_units,
+        phi_offset=parse_string_to_array_or_float(detector_kwargs['phi_offset']) * angle_units,
+        sampling=parse_string_to_array_or_float(detector_kwargs['sampling']) * AU,
+    )
+
+    setup = Setup(source=source, scatterer=scatterer, detector=detector)
+
+    dataframe = setup.get(measure, **kwargs)
+
+    return dataframe

PyMieSim/gui/interface.py

@@ -0,0 +1,136 @@
+from dash import Dash, html, dcc
+import matplotlib.pyplot as plt
+import io
+import base64
+import webbrowser
+from PyMieSim.gui.section import SourceSection, ScattererSection, DetectorSection, MeasureSection
+from PyMieSim.gui.helper import interface
+
+dcc_store_id = "input-store"
+
+class OpticalSetupGUI:
+    """
+    A class to manage the overall GUI for the optical simulation interface.
+
+    This class integrates various sections, including Source, Scatterer, Detector, and Measure sections,
+    and sets up the layout and callbacks for the Dash application.
+    """
+
+    def __init__(self):
+        """
+        Initialize the Dash app and other settings.
+
+        This method sets up the Dash application, initializes the individual sections, and prepares the layout
+        and callbacks.
+        """
+        plt.switch_backend('Agg')
+        self.app = Dash(__name__, external_stylesheets=["https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"])
+
+        self.source_section = SourceSection(self.app)
+        self.scatterer_section = ScattererSection(self.app)
+        self.detector_section = DetectorSection(self.app)
+        self.measure_section = MeasureSection(self.app, self.scatterer_section, self.source_section, self.detector_section)
+
+        self.setup_layout()
+        self.setup_callbacks()
+
+    def create_plot(self, measure: str, xaxis: str):
+        """
+        Generate a matplotlib plot and return it as a base64 image.
+
+        Parameters
+        ----------
+        measure : str
+            The type of measure to plot (e.g., Qsca, Qext).
+        xaxis : str
+            The parameter to plot on the x-axis.
+
+        Returns
+        -------
+        str
+            A base64-encoded string of the generated plot image.
+        """
+        data = interface(
+            source_kwargs=self.source_section.data,
+            scatterer_kwargs=self.scatterer_section.data,
+            detector_kwargs=self.detector_section.data,
+            measure=measure
+        )
+
+        data.plot(x=xaxis)
+
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        encoded_image = base64.b64encode(buf.read()).decode('utf-8')
+        buf.close()
+        return f"data:image/png;base64,{encoded_image}"
+
+    def save_func(self, filename: str, measure: str):
+        """
+        Save the simulation data to a CSV file.
+
+        Parameters
+        ----------
+        filename : str
+            The name of the file to save the data.
+        measure : str
+            The type of measure to save.
+        xaxis : str
+            The parameter to include on the x-axis in the saved data.
+        """
+        return interface(
+            source_kwargs=self.source_section.data,
+            scatterer_kwargs=self.scatterer_section.data,
+            detector_kwargs=self.detector_section.data,
+            measure=measure,
+            add_units=False
+        )
+
+    def setup_layout(self):
+        """
+        Define the layout of the Dash app.
+
+        This method organizes the sections and visualization components in the application layout.
+        """
+        self.app.layout = html.Div([
+            dcc.Store(id=dcc_store_id),  # Store to save input values
+            html.Div([
+                html.H1("Optical Simulation Interface", style={'text-align': 'center'}),
+                *self.source_section.create(),
+                *self.scatterer_section.create(),
+                *self.detector_section.create(),
+            ], style={'width': '40%', 'float': 'left', 'padding': '10px'}),
+
+            html.Div([
+                html.H1("Visualization", style={'text-align': 'center'}),
+                self.measure_section.create(),
+                html.Img(id="plot-image", style={'width': '100%', 'height': 'auto', 'margin-top': '20px'})
+            ], style={'width': '55%', 'float': 'right', 'padding': '10px', 'border-left': '1px solid black'})
+        ])
+
+    def setup_callbacks(self):
+        """
+        Set up Dash callbacks for the GUI.
+
+        This method links user interactions with the relevant functions to update the plot and save data.
+        """
+        self.measure_section.update_callbacks(self.create_plot, self.save_func)
+
+    def run(self, host: str = "0.0.0.0", port: str = "8050", open_browser: bool = False, debug: bool = False):
+        """
+        Run the Dash app.
+
+        This method starts the Dash server and opens the application in the default web browser.
+        """
+        if open_browser:
+            webbrowser.open(f"http://{host}:{port}/", new=2)
+            self.app.run_server(debug=debug)
+
+        else:
+            self.app.run_server(debug=debug, host=host, port=port)
+
+
+if __name__ == '__main__':
+    _gui = OpticalSetupGUI()
+    _gui.run(host='0.0.0.0', port='8050', open_browser=False, debug=True)