PyMieSim 3.5.4__cp310-cp310-win_amd64.whl → 3.5.4.3__cp310-cp310-win_amd64.whl

PyMieSim/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.5.4'
-__version_tuple__ = version_tuple = (3, 5, 4)
+__version__ = version = '3.5.4.3'
+__version_tuple__ = version_tuple = (3, 5, 4, 3)

PyMieSim/experiment/scatterer/base.py

@@ -62,11 +62,17 @@ class BaseScatterer():
         CPPClass = CppMediumProperties if name == 'medium' else CppScattererProperties
 
         if all(isinstance(item, Quantity) for item in properties):
-            self.binding_kwargs[f'{name}_properties'] = CPPClass(index_properties=properties.magnitude)
+            instance = CPPClass(index_properties=properties.magnitude)
+            self.binding_kwargs[f'{name}_properties'] = instance
+
+            return instance
 
         elif all(isinstance(item, BaseMaterial) for item in properties):
             eval_index = numpy.asarray([m.compute_refractive_index(self.source.wavelength.to_base_units().magnitude) for m in properties])
-            self.binding_kwargs[f'{name}_properties'] = CPPClass(material_properties=eval_index)
+            instance = CPPClass(material_properties=eval_index)
+            self.binding_kwargs[f'{name}_properties'] = instance
+
+            return instance
 
         else:
             raise TypeError("All elements in the list must be of type 'Quantity' or 'BaseMaterial', not a mix of both.")

PyMieSim/experiment/scatterer/core_shell.py

@@ -66,14 +66,17 @@ class CoreShell(BaseScatterer, Sequential):
             is_sequential=self.is_sequential
         )
 
-        self._add_properties(name='medium', properties=self.medium_property)
+        mediun_properties = self._add_properties(name='medium', properties=self.medium_property)
 
-        self._add_properties(name='core', properties=self.core_property)
+        core_properties = self._add_properties(name='core', properties=self.core_property)
 
-        self._add_properties(name='shell', properties=self.shell_property)
+        shell_properties = self._add_properties(name='shell', properties=self.shell_property)
 
-        binding_kwargs = {
-            k: v.to_base_units().magnitude if isinstance(v, Quantity) else v for k, v in self.binding_kwargs.items()
-        }
-
-        self.binding = CppCoreShellSet(**binding_kwargs)
+        self.binding = CppCoreShellSet(
+            core_diameter=self.core_diameter.to('meter').magnitude,
+            shell_thickness=self.shell_thickness.to('meter').magnitude,
+            core_properties=core_properties,
+            shell_properties=shell_properties,
+            medium_properties=mediun_properties,
+            is_sequential=self.is_sequential,
+        )

PyMieSim/experiment/scatterer/cylinder.py

@@ -51,12 +51,13 @@ class Cylinder(BaseScatterer, Sequential):
 
         self.binding_kwargs = dict(diameter=self.diameter, is_sequential=self.is_sequential)
 
-        self._add_properties(name='medium', properties=self.medium_property)
+        mediun_properties = self._add_properties(name='medium', properties=self.medium_property)
 
-        self._add_properties(name='scatterer', properties=self.property)
+        scatterer_properties = self._add_properties(name='scatterer', properties=self.property)
 
-        binding_kwargs = {
-            k: v.to_base_units().magnitude if isinstance(v, Quantity) else v for k, v in self.binding_kwargs.items()
-        }
-
-        self.binding = CppCylinderSet(**binding_kwargs)
+        self.binding = CppCylinderSet(
+            diameter=self.diameter.to('meter').magnitude,
+            scatterer_properties=scatterer_properties,
+            medium_properties=mediun_properties,
+            is_sequential=self.is_sequential,
+        )

PyMieSim/experiment/scatterer/sphere.py

@@ -54,12 +54,13 @@ class Sphere(BaseScatterer, Sequential):
 
         self.binding_kwargs = dict(diameter=self.diameter, is_sequential=self.is_sequential)
 
-        self._add_properties(name='medium', properties=self.medium_property)
+        mediun_properties = self._add_properties(name='medium', properties=self.medium_property)
 
-        self._add_properties(name='scatterer', properties=self.property)
+        scatterer_properties = self._add_properties(name='scatterer', properties=self.property)
 
-        binding_kwargs = {
-            k: v.to_base_units().magnitude if isinstance(v, Quantity) else v for k, v in self.binding_kwargs.items()
-        }
-
-        self.binding = CppSphereSet(**binding_kwargs)
+        self.binding = CppSphereSet(
+            diameter=self.diameter.to('meter').magnitude,
+            scatterer_properties=scatterer_properties,
+            medium_properties=mediun_properties,
+            is_sequential=self.is_sequential,
+        )

PyMieSim/experiment/source/gaussian.py

@@ -32,12 +32,17 @@ class Gaussian(BaseSource, Sequential):
     wavelength: Quantity
     polarization: Union[BasePolarization, Quantity]
 
-    def _generate_binding_kwargs(self) -> None:
+    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,
@@ -46,16 +51,10 @@ class Gaussian(BaseSource, Sequential):
             is_sequential=self.is_sequential
         )
 
-    def _generate_binding(self):
-        self.mapping = {}
-
-        if not isinstance(self.polarization, BasePolarization):
-            self.polarization = Linear(self.polarization)
-
-        self._generate_binding_kwargs()
-
-        binding_kwargs = {
-            k: v.to_base_units().magnitude if isinstance(v, Quantity) else v for k, v in self.binding_kwargs.items()
-        }
-
-        self.binding = CppGaussianSourceSet(**binding_kwargs)
+        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

@@ -40,14 +40,20 @@ class PlaneWave(BaseSource, Sequential):
 
         return value
 
-    def _generate_binding_kwargs(self) -> None:
+    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
+        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,
@@ -55,16 +61,9 @@ class PlaneWave(BaseSource, Sequential):
             is_sequential=self.is_sequential
         )
 
-    def _generate_binding(self):
-        self.mapping = {}
-
-        if not isinstance(self.polarization, BasePolarization):
-            self.polarization = Linear(self.polarization)
-
-        self._generate_binding_kwargs()
-
-        binding_kwargs = {
-            k: v.to_base_units().magnitude if isinstance(v, Quantity) else v for k, v in self.binding_kwargs.items()
-        }
-
-        self.binding = CppPlaneWaveSourceSet(**binding_kwargs)
+        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/mesh.py

@@ -7,7 +7,7 @@ import numpy
 from PyMieSim.binary.interface_detector import FIBONACCIMESH
 from PyMieSim import units
 
-class FibonacciMesh:
+class FibonacciMesh(FIBONACCIMESH):
     """
     Represents an angular mesh using a Fibonacci sphere distribution, where each point
     covers an equivalent solid angle. This type of mesh is useful for simulating angular
@@ -44,8 +44,6 @@ class FibonacciMesh:
 
     Methods
     -------
-    initialize_properties():
-        Initializes additional mesh properties based on the Fibonacci distribution generated by the binding.
     projection_HV_vector() -> tuple:
         Returns the parallel and perpendicular projections of the mesh on the horizontal and vertical base vectors as vectors.
     projection_HV_scalar() -> tuple:
@@ -54,14 +52,14 @@ class FibonacciMesh:
         Computes the scalar projection of a given vector onto a base vector.
     projection_on_base_vector(vector, base_vector) -> numpy.ndarray:
         Computes the vector projection of a given vector onto a base vector.
-    get_cartesian_coordinates() -> numpy.ndarray:
-        Returns the Cartesian coordinates of the mesh points.
     get_axis_vector() -> numpy.ndarray:
         Returns the axis vector corresponding to the phi and gamma offsets.
     rotate_around_axis(rotation_angle) -> None:
         Rotates the mesh around its principal axis by a specified angle.
 
     """
+
+    # ---------------------- Validation Methods ----------------------
     def _validate_angle_units(cls, value):
         """
         Ensures that diameter is Quantity objects with length units.
@@ -80,199 +78,134 @@ class FibonacciMesh:
 
         return value
 
-
-    def __init__(self, max_angle: float, sampling: int, phi_offset: float, gamma_offset: float, rotation_angle: Optional[float] = 0.0):
+    # ---------------------- Initialization Methods ----------------------
+    def __init__(self,
+        max_angle: units.Quantity,
+        sampling: int,
+        phi_offset: units.Quantity,
+        gamma_offset: units.Quantity,
+        min_angle: units.Quantity = 0 * units.degree,
+        rotation_angle: Optional[units.Quantity] = 0.0):
         """
         Initializes the FibonacciMesh with the specified parameters.
 
         Parameters
         ----------
-        max_angle : float
+        max_angle : units.Quantity
             The maximum angle in radians, typically defined by the numerical aperture of the imaging system.
         sampling : int
             The number of points distributed across the mesh. Higher values result in finer resolution.
-        phi_offset : float
+        phi_offset : units.Quantity
             Angle offset in the azimuthal (parallel to incident light polarization) direction in degrees.
-        gamma_offset : float
+        gamma_offset : units.Quantity
             Angle offset in the polar (perpendicular to incident light polarization) direction in degrees.
-        rotation_angle : Optional[float], default=0.0
+        rotation_angle : Optional[units.Quantity], default=0.0
             Rotation of the entire mesh around its principal axis, in degrees.
         """
         self.sampling = sampling
         self.max_angle = self._validate_angle_units(max_angle)
-        self.phi_offset = self._validate_angle_units(phi_offset)
-        self.gamma_offset = self._validate_angle_units(gamma_offset)
-        self.rotation_angle = self._validate_angle_units(rotation_angle)
-
-        self.structured = False
-        self._para = None
-        self._perp = None
-
-        self.vertical_vector = numpy.array([1, 0, 0])
-        self.horizontal_vector = numpy.array([0, 1, 0])
+        self.min_angle = self._validate_angle_units(min_angle)
+        phi_offset = self._validate_angle_units(phi_offset)
+        gamma_offset = self._validate_angle_units(gamma_offset)
+        rotation = self._validate_angle_units(rotation_angle)
 
-        self.binding = FIBONACCIMESH(
+        super().__init__(
             sampling=self.sampling,
             max_angle=self.max_angle,
-            phi_offset=numpy.deg2rad(self.phi_offset),
-            gamma_offset=numpy.deg2rad(self.gamma_offset),
-            rotation_angle=self.rotation_angle
+            min_angle=self.min_angle,
+            rotation_angle=rotation,
+            phi_offset=numpy.deg2rad(phi_offset),
+            gamma_offset=numpy.deg2rad(gamma_offset),
         )
 
-        self.initialize_properties()
-        self.binding.compute_vector_field()
-
-
-
-
+        self.compute_vector_field()
 
+    # ---------------------- Property Methods ----------------------
     @property
-    def horizontal_to_perpendicular(self):
+    def theta(self) -> units.Quantity:
         """
-        Returns the projection of the horizontal base vector onto the perpendicular component.
+        Returns the polar angles (theta) of the mesh in radians.
 
         Returns
         -------
-        numpy.ndarray
-            The horizontal projection onto the perpendicular vector field.
+        units.Quantity
+            The polar angles in radians.
         """
-        return self.binding.horizontal_to_perpendicular_vector
+        return self.spherical.theta * units.radian
 
     @property
-    def horizontal_to_parallel(self):
+    def phi(self) -> units.Quantity:
         """
-        Returns the projection of the horizontal base vector onto the parallel component.
+        Returns the azimuthal angles (phi) of the mesh in radians.
 
         Returns
         -------
-        numpy.ndarray
-            The horizontal projection onto the parallel vector field.
+        units.Quantity
+            The azimuthal angles in radians.
         """
-        return self.binding.horizontal_to_parallel_vector
+        return self.spherical.phi * units.radian
 
     @property
-    def vertical_to_perpendicular(self):
+    def d_omega(self) -> units.Quantity:
         """
-        Returns the projection of the vertical base vector onto the perpendicular component.
+        Returns the solid angle (d_omega) of the mesh in steradians.
 
         Returns
         -------
-        numpy.ndarray
-            The vertical projection onto the perpendicular vector field.
+        units.Quantity
+            The solid angle in steradians.
         """
-        return self.binding.perpendicular_vector
+        return self.spherical._cpp_d_omega * units.steradian
 
     @property
-    def vertical_to_parallel(self):
+    def omega(self) -> units.Quantity:
         """
-        Returns the projection of the vertical base vector onto the parallel component.
+        Returns the solid angle (omega) of the mesh in steradians.
 
         Returns
         -------
-        numpy.ndarray
-            The vertical projection onto the parallel vector field.
+        units.Quantity
+            The solid angle in steradians.
         """
-        return self.binding.parallel_vector
-
-    def get_phi(self, unit: str = 'radian'):
-        """
-        Returns the azimuthal angle (phi) of the mesh in the specified unit.
-
-        Parameters
-        ----------
-        unit : str, optional
-            The unit of the angle to return, either 'radian' or 'degree'. Default is 'radian'.
-
-        Returns
-        -------
-        numpy.ndarray
-            Array of phi values in the specified unit.
-        """
-        if unit.lower() in ['rad', 'radian']:
-            return self.binding.phi
-        elif unit.lower() in ['deg', 'degree']:
-            return numpy.rad2deg(self.binding.phi)
-
-    def get_theta(self, unit: str = 'radian'):
-        """
-        Returns the polar angle (theta) of the mesh in the specified unit.
-
-        Parameters
-        ----------
-        unit : str, optional
-            The unit of the angle to return, either 'radian' or 'degree'. Default is 'radian'.
-
-        Returns
-        -------
-        numpy.ndarray
-            Array of theta values in the specified unit.
-        """
-        if unit.lower() in ['rad', 'radian']:
-            return self.binding.theta
-        elif unit.lower() in ['deg', 'degree']:
-            return numpy.rad2deg(self.binding.theta)
+        return self.spherical._cpp_omega * units.steradian
 
     @property
-    def X(self) -> numpy.ndarray:
+    def phi_offset(self) -> units.Quantity:
         """
-        Returns the X-coordinate of the mesh points.
+        Returns the azimuthal angle offset (phi_offset) in radians.
 
         Returns
         -------
-        numpy.ndarray
-            Array of X-coordinates.
+        units.Quantity
+            The azimuthal angle offset in radians.
         """
-        return self.binding.x
+        return self._cpp_phi_offset * units.radian
 
     @property
-    def Y(self) -> numpy.ndarray:
+    def gamma_offset(self) -> units.Quantity:
         """
-        Returns the Y-coordinate of the mesh points.
+        Returns the polar angle offset (gamma_offset) in radians.
 
         Returns
         -------
-        numpy.ndarray
-            Array of Y-coordinates.
+        units.Quantity
+            The polar angle offset in radians.
         """
-        return self.binding.y
+        return self._cpp_gamma_offset * units.radian
 
     @property
-    def Z(self) -> numpy.ndarray:
-        """
-        Returns the Z-coordinate of the mesh points.
-
-        Returns
-        -------
-        numpy.ndarray
-            Array of Z-coordinates.
-        """
-        return self.binding.z
-
-    def initialize_properties(self):
-        """
-        Initializes additional properties of the Fibonacci mesh based on the underlying
-        C++ implementation.
-
-        This includes calculating Cartesian coordinates and solid angles for each point on the mesh.
+    def rotation(self) -> units.Quantity:
         """
-        self.cartesian_coordinates = numpy.column_stack((self.binding.x, self.binding.y, self.binding.z))
-        self.d_omega_radian = self.binding.d_omega
-        self.d_omega_degree = self.binding.d_omega * (180 / numpy.pi) ** 2
-        self.omega_radian = self.binding.omega
-        self.omega_degree = self.binding.omega * (180 / numpy.pi) ** 2
-
-
-    def get_cartesian_coordinates(self) -> numpy.ndarray:
-        """
-        Returns the Cartesian coordinates of the mesh points.
+        Returns the rotation angle of the mesh around its principal axis in radians.
 
         Returns
         -------
-        numpy.ndarray
-            Array of Cartesian coordinates (X, Y, Z) for the mesh points.
+        units.Quantity
+            The rotation angle in radians.
         """
-        return numpy.c_[self.X, self.Y, self.Z].T
+        return self._cpp_rotation * units.radian
 
+    # ---------------------- Additional Methods ----------------------
     def get_axis_vector(self) -> numpy.ndarray:
         """
         Returns the axis vector corresponding to the phi and gamma offsets.
@@ -282,28 +215,12 @@ class FibonacciMesh:
         numpy.ndarray
             The axis vector normalized to unit length.
         """
-        x, y, z = self.get_cartesian_coordinates()
-        axis_vector = numpy.array([x[0], y[0], z[0]])
+        axis_vector = numpy.array([self.cartesian.x[0], self.cartesian.y[0], self.cartesian.z[0]])
 
         norm = numpy.sqrt(numpy.square(axis_vector).sum())
 
         return axis_vector / norm
 
-    def rotate_around_axis(self, rotation_angle: float) -> None:
-        """
-        Rotates the mesh around its principal axis by a specified angle.
-
-        Parameters
-        ----------
-        rotation_angle : float
-            The angle in degrees by which to rotate the mesh.
-
-        Returns
-        -------
-        None
-        """
-        self.binding.rotate_around_axis(rotation_angle)
-
     def projection_HV_vector(self) -> tuple:
         """
         Projects the vertical and horizontal base vectors onto the parallel and perpendicular components
@@ -324,16 +241,16 @@ class FibonacciMesh:
         """
         parallel_projection = [
             self.projection_on_base_vector(
-                vector=self.vertical_to_parallel,
+                vector=self.parallel,
                 base_vector=X
-            ) for X in [self.vertical_vector, self.horizontal_vector]
+            ) for X in [self._cpp_vertical_base, self._cpp_horizontal_base]
         ]
 
         perpendicular_projection = [
             self.projection_on_base_vector(
-                vector=self.vertical_to_perpendicular,
+                vector=self.perpendicular,
                 base_vector=X
-            ) for X in [self.vertical_vector, self.horizontal_vector]
+            ) for X in [self._cpp_vertical_base, self._cpp_horizontal_base]
         ]
 
         return numpy.array(parallel_projection), numpy.array(perpendicular_projection)
@@ -359,16 +276,16 @@ class FibonacciMesh:
         """
         parallel_projection = [
             self.projection_on_base_scalar(
-                vector=self.vertical_to_parallel,
+                vector=self.parallel,
                 base_vector=X
-            ) for X in [self.vertical_vector, self.horizontal_vector]
+            ) for X in [self._cpp_vertical_base, self._cpp_horizontal_base]
         ]
 
         perpendicular_projection = [
             self.projection_on_base_scalar(
-                vector=self.vertical_to_perpendicular,
+                vector=self.perpendicular,
                 base_vector=X
-            ) for X in [self.vertical_vector, self.horizontal_vector]
+            ) for X in [self._cpp_vertical_base, self._cpp_horizontal_base]
         ]
 
         return numpy.array(parallel_projection), numpy.array(perpendicular_projection)
@@ -406,7 +323,7 @@ class FibonacciMesh:
 
         where :math:`\vec{v}` is the input vector and :math:`\vec{b}` is the base vector.
         """
-        return vector.dot(base_vector)
+        return vector._cpp_get_scalar_product(base_vector)
 
     def projection_on_base_vector(self, vector: numpy.ndarray, base_vector: numpy.ndarray) -> numpy.ndarray:
         r"""
@@ -446,6 +363,6 @@ class FibonacciMesh:
         then scales `base_vector` by this scalar to produce the projected vector.
         """
         projection = self.projection_on_base_scalar(vector, base_vector)
-        base_projection = numpy.outer(projection, base_vector)
+        base_projection = numpy.outer(projection, base_vector.data)
 
         return base_projection

PyMieSim/single/detector/base.py

@@ -6,7 +6,7 @@ from typing import Optional
 
 from PyMieSim.single.representations import Footprint
 from MPSPlots.colormaps import blue_black_red
-from PyMieSim.units import Quantity, degree, watt, meter, second, farad, volt
+from PyMieSim.units import Quantity, watt, meter, second, farad, volt
 from PyMieSim import units
 from PyMieSim.single.scatterer.base import BaseScatterer
 import pyvista
@@ -124,10 +124,10 @@ class BaseDetector(units.UnitsValidation):
             None: This method does not return a value. It modifies the provided scene.
         """
         # Stack the mesh coordinates into a single array
-        coordinates = numpy.row_stack((
-            self._cpp_mesh.x,
-            self._cpp_mesh.y,
-            self._cpp_mesh.z
+        coordinates = numpy.vstack((
+            self._cpp_mesh.cartesian.x,
+            self._cpp_mesh.cartesian.y,
+            self._cpp_mesh.cartesian.z
         ))
 
         # Wrap the coordinates for PyVista visualization
@@ -206,8 +206,8 @@ class BaseDetector(units.UnitsValidation):
 
         """
         Ephi, Etheta = scatterer.get_farfields_array(
-            phi=self._cpp_mesh.phi,
-            theta=self._cpp_mesh.theta,
+            phi=self._cpp_mesh.spherical.phi,
+            theta=self._cpp_mesh.spherical.theta,
             r=distance
         )
 
@@ -263,9 +263,9 @@ class BaseDetector(units.UnitsValidation):
         """
         poynting_vector = self.get_poynting_vector(scatterer=scatterer, distance=distance)
 
-        dA = self._cpp_mesh.d_omega * distance ** 2
+        dA = self._cpp_mesh._cpp_d_omega * distance ** 2
 
-        total_power = 0.5 * numpy.trapz(y=poynting_vector, dx=dA)
+        total_power = 0.5 * numpy.trapezoid(y=poynting_vector, dx=dA)
 
         return total_power
 

PyMieSim/single/detector/coherent.py

@@ -83,18 +83,17 @@ class CoherentMode(DETECTOR, BaseDetector):
         self.polarization_filter = self._validate_detector_polarization_units(polarization_filter)
 
         super().__init__(
-            coherent=False,
             mode_number=self.mode_number,
+            sampling=self.sampling,
             NA=self.NA.to(units.AU).magnitude,
             cache_NA=self.cache_NA.to(units.AU).magnitude,
-            sampling=self.sampling,
-            mean_coupling=self.mean_coupling,
-            gamma_offset=self.gamma_offset.to(units.radian).magnitude,
             phi_offset=self.phi_offset.to(units.radian).magnitude,
+            gamma_offset=self.gamma_offset.to(units.radian).magnitude,
             polarization_filter=self.polarization_filter.to(units.radian).magnitude,
             rotation=self.rotation.to(units.radian).magnitude,
-            medium_refractive_index=self.medium_refractive_index.to(units.RIU).magnitude
+            coherent=False,
+            mean_coupling=self.mean_coupling,
+            medium_refractive_index=self.medium_refractive_index.to(units.RIU).magnitude,
         )
 
-
 # -

PyMieSim/single/detector/uncoherent.py

@@ -21,8 +21,7 @@ class Photodiode(DETECTOR, BaseDetector):
             polarization_filter: Optional[units.Quantity] = None,
             cache_NA: Optional[units.Quantity] = 0 * units.AU,
             mean_coupling: bool = False,
-            medium_refractive_index: units.Quantity = 1.0 * units.RIU
-        ):
+            medium_refractive_index: units.Quantity = 1.0 * units.RIU):
         """
         Initialize the Photodiode detector with its parameters.
 

PyMieSim/single/representations.py

@@ -110,12 +110,12 @@ class BaseRepresentation():
         scene.add_mesh(glyphs, color=color, opacity=opacity)
 
     def add_phi_vector_to_3d_plot(
-            self,
-            scene: pyvista.Plotter,
-            n_points: int = 20,
-            opacity: float = 1.0,
-            radius: float = 1.0,
-            color: str = 'black') -> None:
+        self,
+        scene: pyvista.Plotter,
+        n_points: int = 20,
+        opacity: float = 1.0,
+        radius: float = 1.0,
+        color: str = 'black') -> None:
         """
         Adds a vector field to the 3D plot, representing vectors in the phi direction.
 
@@ -213,14 +213,14 @@ class Stokes(BaseRepresentation):
         self.V = (-2 * numpy.imag(self.E_phi * self.E_theta.conjugate())) / intensity
 
     def plot(
-            self,
-            unit_size: List[float] = (400, 400),
-            background_color: str = 'white',
-            show_edges: bool = False,
-            colormap: str = blue_black_red,
-            opacity: float = 1.0,
-            symmetric_colormap: bool = False,
-            show_axis_label: bool = False) -> None:
+        self,
+        unit_size: List[float] = (400, 400),
+        background_color: str = 'white',
+        show_edges: bool = False,
+        colormap: str = blue_black_red,
+        opacity: float = 1.0,
+        symmetric_colormap: bool = False,
+        show_axis_label: bool = False) -> None:
         """
         Visualizes the Stokes parameters (I, Q, U, V) on a 3D plot.
 

PyMieSim/single/source/gaussian.py

@@ -5,7 +5,6 @@ import numpy
 import pyvista
 from PyMieSim import units
 from PyMieSim.polarization import BasePolarization
-from PyMieSim.special_functions import NA_to_angle
 from PyMieSim.binary.interface_source import GAUSSIAN
 from PyMieSim.single.source.base import BaseSource
 
@@ -14,10 +13,10 @@ class Gaussian(GAUSSIAN, BaseSource):
     amplitude: units.Quantity
 
     def __init__(self,
-            wavelength: units.Quantity,
-            polarization: units.Quantity | BasePolarization,
-            optical_power: units.Quantity,
-            NA: units.Quantity) -> None:
+        wavelength: units.Quantity,
+        polarization: units.Quantity | BasePolarization,
+        optical_power: units.Quantity,
+        NA: units.Quantity) -> None:
         """
         Initializes a Gaussian light source for light scattering simulations, characterized by its optical power and numerical aperture.
 
@@ -50,6 +49,21 @@ class Gaussian(GAUSSIAN, BaseSource):
             NA=self.NA.to(units.AU).magnitude,
         )
 
+    def numerical_aperture_to_angle(self, numerical_aperture: float) -> float:
+        """
+        Convert numerical aperture (NA) to angle in radians.
+
+        Parameters
+        ----------
+        NA : float
+            The numerical aperture.
+
+        Returns
+        -------
+        float
+            The angle in radians.
+        """
+        return numpy.arcsin(numerical_aperture) if numerical_aperture <= 1.0 else numpy.arcsin(numerical_aperture - 1) + numpy.pi / 2
 
     def plot(self, color: str = 'red', opacity: float = 0.8, show_axis_label: bool = False) -> None:
         """
@@ -103,7 +117,11 @@ class Gaussian(GAUSSIAN, BaseSource):
         """
         # Calculate the maximum angle from the numerical aperture (NA)
 
-        max_angle = numpy.rad2deg(NA_to_angle(NA=self.NA.magnitude))
+        numerical_aperture = self.NA.magnitude
+
+        angle = self.numerical_aperture_to_angle(numerical_aperture)
+
+        max_angle = numpy.rad2deg(angle)
 
         # Create the cone mesh
         cone_mesh = pyvista.Cone(

PyMieSim/special_functions.py

@@ -4,23 +4,6 @@
 import numpy
 
 
-def NA_to_angle(NA: float) -> float:
-    """
-    Convert numerical aperture (NA) to angle in radians.
-
-    Parameters
-    ----------
-    NA : float
-        The numerical aperture.
-
-    Returns
-    -------
-    float
-        The angle in radians.
-    """
-    return numpy.arcsin(NA) if NA <= 1.0 else numpy.arcsin(NA - 1) + numpy.pi / 2
-
-
 def cartesian_to_spherical(x: numpy.ndarray, y: numpy.ndarray, z: numpy.ndarray) -> tuple:
     """
     Convert Cartesian coordinates to spherical coordinates.

PyMieSim/units.py

@@ -53,6 +53,7 @@ def initialize_registry(ureg: Optional[object] = None):
         'refractive_index_unit': ureg.refractive_index_unit,
         'degree': ureg.degree,
         'radian': ureg.radian,
+        'steradian': ureg.steradian,
         'AU': ureg.dimensionless,
         'distance': ureg.meter.dimensionality,
         'time': ureg.second.dimensionality,

{pymiesim-3.5.4.dist-info → pymiesim-3.5.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyMieSim
-Version: 3.5.4
+Version: 3.5.4.3
 Summary: A package for light scattering computation.
 Keywords: mie,scattering,backscatter,sphere,cylinder,nanoparticle,phase function,efficiency,rayleigh,backscattering
 Author-Email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
@@ -54,14 +54,14 @@ Requires-Dist: MPSPlots==1.6.4
 Requires-Dist: pydantic<2.12.0,>=2.9.2
 Requires-Dist: pint-pandas~=0.6
 Requires-Dist: pandas~=2.3.0
-Requires-Dist: PyOptik==1.10.6
+Requires-Dist: PyOptik==1.10.8
 Requires-Dist: tabulate~=0.9
 Requires-Dist: pyvista==0.45.2
 Provides-Extra: testing
 Requires-Dist: pytest>=0.6; extra == "testing"
 Requires-Dist: pytest-cov>=2.0; extra == "testing"
 Requires-Dist: pytest-json-report==1.5.0; extra == "testing"
-Requires-Dist: coverage==7.8.2; extra == "testing"
+Requires-Dist: coverage==7.9.1; extra == "testing"
 Provides-Extra: documentation
 Requires-Dist: numpydoc==1.8.0; extra == "documentation"
 Requires-Dist: sphinx>=5.1.1; extra == "documentation"

{pymiesim-3.5.4.dist-info → pymiesim-3.5.4.3.dist-info}/RECORD

@@ -1,26 +1,25 @@
+lib/lib_ZBessel.a,sha256=VnqIXli9K9pfkldxnep2bB897rSdeh9BdJc2mgmzAIw,10676
+lib/libcpp_base_scatterer.a,sha256=YobPrrig-o6FKlB0C2mOtJZ1f_umNUASo7z-RySBBKg,275118
+lib/libcpp_coreshell.a,sha256=yg9hVrqxIzaaqUfgO1Ls4oHhBWVPRMpW9b-BYkqFnOY,278146
+lib/libcpp_cylinder.a,sha256=DIt2Tf5ZQ1PQ5Xe_FzZ3fHrCuyq739UaBwjoXTYFas4,259476
+lib/libcpp_sphere.a,sha256=st6T-gs_-S1sG5kHRO_ORK8it5YboCoNfut9Xvg5tB4,272358
+lib/libZBessel.a,sha256=5xbNMpsEK0WE1Pt_hruOuoAtcQoGmkmc0XvXIHwTSBw,133174
 PyMieSim/__init__.py,sha256=ATPcasYo6e8DbNhyXGPN8lRhB_mcOGvNV-kO82U9Z5k,260
 PyMieSim/__main__.py,sha256=ZSJaGgDhOSzpwPZLLrqyzu6JH5nO7KPHblCD8OMuF4A,180
-PyMieSim/_version.py,sha256=1u0Voot6NhBTgzWhywtXiRExifGg3U1S-2F5WPsUOcw,532
+PyMieSim/_version.py,sha256=SPA2ARbwEu3rmTOQ07I3xcu74m_6fSX88nf8mSfbM_U,537
 PyMieSim/binary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PyMieSim/binary/interface_detector.cp310-win_amd64.pyd,sha256=hdtlmpNpogsjoeBJ3egPuLzp12zYH13bVK5au7mGO1U,1495040
-PyMieSim/binary/interface_experiment.cp310-win_amd64.pyd,sha256=d4JWd1xOFRF0BmR3rmp6YFv362E9VmOr-IbL-xYOUAk,1572352
-PyMieSim/binary/interface_fibonacci.cp310-win_amd64.pyd,sha256=adIR3eAr4erhy_uODm_lzCgFXLp9Uk9t9kxtB4s5E7s,482304
-PyMieSim/binary/interface_mode_field.cp310-win_amd64.pyd,sha256=3HnimpuhJMAb4rL_HcTAym1ey7mmF36hEb3vJgUx_vk,482304
-PyMieSim/binary/interface_scatterer.cp310-win_amd64.pyd,sha256=Mr7EusBszygS_R8bYOtyWq1ijyaGeMrEXS835NdhP1Q,1183744
-PyMieSim/binary/interface_sets.cp310-win_amd64.pyd,sha256=CBH6oF3HAE2qLI-hZNjgzEX-eU1-W63egnokT6_T9lE,1916416
-PyMieSim/binary/interface_source.cp310-win_amd64.pyd,sha256=OgvehrRBAVCn6uk5Xq568rQaF_OPvsFbW0NuOPxVICM,538112
-PyMieSim/binary/lib_ZBessel.a,sha256=-QOPkUsiB9PwEnpPOaYbqxPsNsZmkHT0UrBPA_KtZc4,10676
-PyMieSim/binary/libcpp_base_scatterer.a,sha256=Pq6zjt01Kq96jN-m5yViZD8MAF7v1CM9axI7Xy9nZfs,274972
-PyMieSim/binary/libcpp_coreshell.a,sha256=9s3AIwKgHXzQmHPVvUwqHaJKeNaP9oxnx7LeB32u4qs,277006
-PyMieSim/binary/libcpp_cylinder.a,sha256=PlP7Is41TazIRk6KkCHphNkH-h4N57rOfyoX6Pf1glk,258428
-PyMieSim/binary/libcpp_detector.a,sha256=Uyie0fRKrpODjshS6x9qWBmRNQlGNQo-FHYZFjy_93Y,278260
-PyMieSim/binary/libcpp_experiment.a,sha256=Gjn0xAWmTJsOR6x0ebF3S4Afb75eN1DKpL3wUYJ7biQ,239272
-PyMieSim/binary/libcpp_fibonacci.a,sha256=1B2tFOjPjmTNMI3LCqKMvkVWzANcyMxYvWKWNLexauU,239758
-PyMieSim/binary/libcpp_mode_field.a,sha256=VGYo6dyuKJQ7bGNpoUHu2F_S1qW7S3gnndcbxNqNRnk,222224
-PyMieSim/binary/libcpp_sets.a,sha256=QSUKEGG7_PqqiihQ3DJqrAJqTk_zcMGObaKHZJw1gRM,239186
-PyMieSim/binary/libcpp_source.a,sha256=H9zJ7YUbsDCy7LyQYmx8egso3vJfJN5zBugtbBBVGds,1172
-PyMieSim/binary/libcpp_sphere.a,sha256=hstOnDx7CwkmhcyJ9cBiwRpBzoEbin17HVxpvUU8oQE,270590
-PyMieSim/binary/libZBessel.a,sha256=F1Dm3OX5mjDIXOEHgJ43v1tqgyftM6GUBPin7iK9WBg,133174
+PyMieSim/binary/interface_detector.cp310-win_amd64.pyd,sha256=k_eFMo3StUEQDOdeIacs0DbZG4vwoZaxk-8RPsCyEVI,755712
+PyMieSim/binary/interface_experiment.cp310-win_amd64.pyd,sha256=XKfGab5bUHMZPVK_c5qNsVtRE9uE4NIArcCBFpZbLk0,797696
+PyMieSim/binary/interface_scatterer.cp310-win_amd64.pyd,sha256=4Ot0KbxHCfRgTJKOJfPxWzpsM6FWdKyB5Vig0i6-2YE,1171968
+PyMieSim/binary/interface_sets.cp310-win_amd64.pyd,sha256=_WVxNPVZkRnlhk_7LSaweouzs-giwNglHL42l-kGYBs,1178624
+PyMieSim/binary/interface_source.cp310-win_amd64.pyd,sha256=yOLgbVBPeOKYZrENJDeUlEPnolzflrjjJgYLlGVAwgs,539648
+PyMieSim/binary/libcpp_coordinates.a,sha256=G0ePnS04Tb3zN1VZyiR2WMyOqMy22B8b7hj3aAml7Jw,23506
+PyMieSim/binary/libcpp_detector.a,sha256=QvZPm8DgpGhDvUngUB8_yzU0EC9jQqAU_iPJ9GaOWvc,280582
+PyMieSim/binary/libcpp_experiment.a,sha256=VjJuxgXS7SRllm3PzVson0EhFf7xh6H6VsbsTBL0hK0,238940
+PyMieSim/binary/libcpp_fibonacci.a,sha256=xKmzrTtK6JGHhYzW_doMkEK_C8D2lkQe5uqzvFOpbsE,16808
+PyMieSim/binary/libcpp_mode_field.a,sha256=XlEJisgBBb-Olg3kO0VuomVnFqu_WwH6IQZNahRiiCE,13388
+PyMieSim/binary/libcpp_sets.a,sha256=97idX2JTjxrP8jEXqTNxc0YTNOzNrb4gWdfo2XM1olI,238854
+PyMieSim/binary/libcpp_source.a,sha256=Tr3taFsPqyD7_pd02H075fIfzJJqaUkLn2_qrSMrSYg,4070
 PyMieSim/directories.py,sha256=x8nf0HACHDuny0YQ3sPnktY8aCKOA1RDvbDTSrerGN0,679
 PyMieSim/experiment/__init__.py,sha256=3W7RgRQ2wspQyhAsUUfd5oYx199lQbYv90Lf0A5Ypf4,46
 PyMieSim/experiment/dataframe_subclass.py,sha256=WVVbvLmdPaqgFU48f8Ua0-WOlNj-CDpK_tFNCDC5ixU,7394
@@ -29,28 +28,28 @@ PyMieSim/experiment/detector/base.py,sha256=R2kObUqhY1FicedybH7xn4DJu50-SdAWtHc2
 PyMieSim/experiment/detector/coherent_mode.py,sha256=5bnQ0j22R5-6ALR9_3wseF01JOiSk9iii2opvcsaQpc,1855
 PyMieSim/experiment/detector/photodiode.py,sha256=Hpw9Nxo19QUV-r31LCuEl2-EOgUPDEbkbOVB0zPyw8s,1902
 PyMieSim/experiment/scatterer/__init__.py,sha256=Daf3HTH5jA5Br5R3hb0NQSVZAz5NpaiedGUQG1bYtkU,128
-PyMieSim/experiment/scatterer/base.py,sha256=8ZInPzjBpwOsC13L7oAZ6dD9ISHcWLRSzAbX3gKCxfY,3849
-PyMieSim/experiment/scatterer/core_shell.py,sha256=OO5-Rg5WKmsFCi1JoMR134WO-bHXQLz8nVRa11TT3YA,3327
-PyMieSim/experiment/scatterer/cylinder.py,sha256=FiPeZROIiDmLgGekLK5y0kTHvTnxh6oGJ1m59NA-Kmc,2511
-PyMieSim/experiment/scatterer/sphere.py,sha256=rM0miEr8qIht8HO3zSvh3a8pvCyjIn8QghlF82DpVYo,2821
+PyMieSim/experiment/scatterer/base.py,sha256=3wKHLeOnXIXNK9ZE8-q0vNVjeYP2pJV4191DuGSfRuQ,3977
+PyMieSim/experiment/scatterer/core_shell.py,sha256=2HQI285zd63hY0DaDNUwyeOEaDaE5DX3dF9WG9SyhRU,3552
+PyMieSim/experiment/scatterer/cylinder.py,sha256=bpypSsx23WAOx9FEdnkepJI0tfIKBbUndXR7DDjktHw,2601
+PyMieSim/experiment/scatterer/sphere.py,sha256=hiv8rXTm-7BEhE0d48jX9KvSoaxiD1KkmNaC7O9J5sM,2911
 PyMieSim/experiment/setup.py,sha256=bNbiKh77TX94qKBhDP9PBjE5WZ6b_uQXMK-7R5CrrBI,13649
 PyMieSim/experiment/source/__init__.py,sha256=QOwlP9wBNAlQA3dmH-g8mNpb2qu5hFdlD_zkmw88Q8w,66
 PyMieSim/experiment/source/base.py,sha256=bkIM2UDO8APBi6MPWWGrapkSqddQBmiCScJ3Y2Q741c,3189
-PyMieSim/experiment/source/gaussian.py,sha256=glmSVMXMJqZ4VDWGjp31wpmTX0eXx_p4MrqWjUEAWxE,2354
-PyMieSim/experiment/source/planewave.py,sha256=qMr3T-RBWjmLJD4ep6ofPwHa9YurOm65Ja85tSopb4Q,2557
+PyMieSim/experiment/source/gaussian.py,sha256=00FAe2dHDefDNFr-nh3yA9P4dvtoVfdQmDI36G6wdLI,2390
+PyMieSim/experiment/source/planewave.py,sha256=rZtCS_fOk--WzUg8tz7e5QwHZy_3N9KS-QP4jgo6gXI,2548
 PyMieSim/experiment/utils.py,sha256=pVdLsLYACnOt1aKPmLO9qLC9I2a9paN4ypMF3TIaaGA,5512
 PyMieSim/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 PyMieSim/gui/helper.py,sha256=GWrG91CBVgMruvwvQbhfU_07ZhbIBkgAs3FwOvCPhe8,2605
 PyMieSim/gui/interface.py,sha256=MLE1_6VXdNxAsQlEh0LzKs3o6U7jT5im8QuSGOpiXcA,4948
 PyMieSim/gui/section.py,sha256=Ro7lbaUJhtvtZEAhzYn5Fbl8BSdQGjAImYESNmYmis4,21701
-PyMieSim/mesh.py,sha256=_EsKj9gOAkwmOKl-7AxFgbIN-cwORhBr_e1tY-5XXrg,17577
+PyMieSim/mesh.py,sha256=6ZwIv79eQY7bOl4NRTK1oOSV8X6aMG8BOUC0UTmbU0Q,14934
 PyMieSim/polarization.py,sha256=l94om78Sku0BjDjzZfBqJ9zW06EghHLs6wKKv-lZRDU,5661
 PyMieSim/single/__init__.py,sha256=uE3Ctqg90vm4CWTn9uHdnENSOAg7dgHZwwjbrEGWBd8,2255
 PyMieSim/single/detector/__init__.py,sha256=5w47VDcm6L5VVNz019syCYtM84k1BIHbJll5UktDNjk,91
-PyMieSim/single/detector/base.py,sha256=28duZ-ijW1usnB_HKcLRPnaHhgMCkWG9AImBCec5Hwg,11542
-PyMieSim/single/detector/coherent.py,sha256=W1qF5HX1nwOW_BYh2e28W50JlaUVLCt2dlZKnKOiK2g,5406
-PyMieSim/single/detector/uncoherent.py,sha256=YNLFQkC51TGr08mVcIdbgdc_2mB22139Tt6C8Cxmpgg,4963
-PyMieSim/single/representations.py,sha256=4-tBMtoUCOwNXbG0VEj37mq02Ya-I242Oh-qlYx9udY,29939
+PyMieSim/single/detector/base.py,sha256=ex-TMwiv5kI3QJnkSyNgf7oMz22508v_51PE8orqUnU,11590
+PyMieSim/single/detector/coherent.py,sha256=tvJJG41iSFHbFbWg1FB_Frxu1k5s6V8OMZBFU3-meag,5405
+PyMieSim/single/detector/uncoherent.py,sha256=CKR_Iqcx2UjD8ospj9H4rMFNbbM_jLXZgL_PLj2BGWw,4953
+PyMieSim/single/representations.py,sha256=vOznCZL-8KrErz-4m4-9w7g433rmUCfVmWFObLONd_Q,29883
 PyMieSim/single/scatterer/__init__.py,sha256=CN5D1UTvtIWMrlYvN4YqA3_DAp0jOPlPKl8ZCKUUU-4,128
 PyMieSim/single/scatterer/base.py,sha256=bRNhLsvu9t8SVROdpnXnpklR_9UNKhw69YmBo6PIjG8,20106
 PyMieSim/single/scatterer/core_shell.py,sha256=5u5kJpNf3m-E6hU6E4vhALYZitJ0BwlhnYrD1Ek6cIM,4785
@@ -58,10 +57,10 @@ PyMieSim/single/scatterer/cylinder.py,sha256=uKnpNQ1gq-Mb2bOXIlWpohpd4xIdriT85LF
 PyMieSim/single/scatterer/sphere.py,sha256=UBdfnOSVA9Ep4Xz4ASgXmLKUOCtFoFqJgRTlMCk66Q4,3581
 PyMieSim/single/source/__init__.py,sha256=UTGc7nja-s3Cfx9tbscY-OOpku8td8eTyRkruUNfN00,96
 PyMieSim/single/source/base.py,sha256=T7Wx-4JYsG7-OOuZAga7XrzQiYo1jzB2AHLWTxr71Uw,130
-PyMieSim/single/source/gaussian.py,sha256=SP1xCOaDCDLgXrJp6T5YbmJ-AT7G1q0YNrjWV-n7H_g,4472
+PyMieSim/single/source/gaussian.py,sha256=LY7ShqlnpefXdHaEz5oQZBVhjxBQWcLhNjgGVzfOSxc,4986
 PyMieSim/single/source/planewave.py,sha256=Wr5vnege_0yyogG4oVDnJgGOnTfBcI0Delw61M_iTn8,3683
-PyMieSim/special_functions.py,sha256=wcdUDTw74cpypRgTco6O4Wage77RBizqS40yNrbbHA4,2518
-PyMieSim/units.py,sha256=ONJVF21F0uc6eCWY1YdHzaIFfbG8_mO8OqnVjq7XNC8,4315
+PyMieSim/special_functions.py,sha256=Dwdt3civrBFckhw3Tj0bQvJ2m124B70dqXXQX5VQmcQ,2164
+PyMieSim/units.py,sha256=b6TscVsAkKOiJfqs28gRLI4z_0g1tMS9lzelO623OjQ,4353
 PyMieSim/validation_data/bohren_huffman/figure_810.csv,sha256=a16WSB7y7_TuGcboXUINj7y-mX0mkG_Vo0CFtE-pfF8,10073
 PyMieSim/validation_data/bohren_huffman/figure_87.csv,sha256=6vf5uPxzYP7N1rD8GgQJxi4-Yme8Q3ycPpsavXlQQZY,40002
 PyMieSim/validation_data/bohren_huffman/figure_88.csv,sha256=c30NQRjxlPz6plBcuG3kMVdTYQ0sHmRXRnzS67gyFnQ,40002
@@ -81,7 +80,7 @@ PyMieSim/validation_data/pymiescatt/validation_Qsca_coreshell_1.csv,sha256=fW1pa
 PyMieSim/validation_data/pymiescatt/validation_Qsca_coreshell_2.csv,sha256=khOJo3N54CqvrG9sxpuvvv5mZlcF3awOk738WHLougI,10400
 PyMieSim/validation_data/pymiescatt/validation_Qsca_medium.csv,sha256=7PE_F3sLIKmKPhcoMUxeByZHw3lzDfc3TH9g9bh3Noo,20800
 PyMieSim/validation_data/pymiescatt/validation_sphere.csv,sha256=0VCbInLU-PcTMa8IOsGL9vBWYJ9tQ6FpMv3ApV8fQVY,143548
-pymiesim-3.5.4.dist-info/METADATA,sha256=OAX_CRIIu9LL_bphPnMINPvy2qsHwlNMaHrhnzuTTAk,13470
-pymiesim-3.5.4.dist-info/WHEEL,sha256=Bg3xfVZCdvCQkqUyMs2y8LOfK6ua4a-d4Njc-PtQZvk,106
-pymiesim-3.5.4.dist-info/licenses/LICENSE,sha256=Iiz1zBIAocPfqqVpPTakp8OKXY9K5j4bIRbgaXy2iAE,1109
-pymiesim-3.5.4.dist-info/RECORD,,
+pymiesim-3.5.4.3.dist-info/METADATA,sha256=3QF4Pz6lqkM-onxvKsHs4zMk7yLajZ-4mZx9uSpp8dM,13472
+pymiesim-3.5.4.3.dist-info/WHEEL,sha256=Bg3xfVZCdvCQkqUyMs2y8LOfK6ua4a-d4Njc-PtQZvk,106
+pymiesim-3.5.4.3.dist-info/licenses/LICENSE,sha256=Iiz1zBIAocPfqqVpPTakp8OKXY9K5j4bIRbgaXy2iAE,1109
+pymiesim-3.5.4.3.dist-info/RECORD,,