msptools 0.1.0__tar.gz

msptools-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> Joan Ronquillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

msptools-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: msptools
+Version: 0.1.0
+Summary: Tools for Optical Forces Calculation in Multiple Scattering Problems
+Author-email: Joan ronquillo <joan.ronquillo@uam.es>
+License: The MIT License (MIT)
+        
+        Copyright (c) <year> Joan Ronquillo
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: refractiveindex==1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Provides-Extra: gpu
+Requires-Dist: cupy; extra == "gpu"
+Provides-Extra: plotting
+Requires-Dist: matplotlib; extra == "plotting"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/logo_1_white.svg" alt="Project Logo" width="200">
+</p>
+
+## Overview
+
+**msptools** is a collection of utilities and scripts designed to facilitate the analysis and processing of Optical Forces in plasmonic particle systems characterized by the Multiple Scattering Problem (MSP). 
+
+## Features
+
+- 
+
+## Installation
+
+Clone the repository and install dependencies:
+
+To use the code in this repository, follow these steps:
+
+1. Clone the repository: `git clone https://github.com/JJkrokoder/msptools` or `git clone git@github.com:JJkrokoder/msptools.git`
+2. Install the required dependencies in a new environment: `conda env create -f environment.yml`
+3. Activate the virtual enironment: `conda activate msptools`
+4. Install the package in this environment: `pip install .`
+
+## Usage
+
+Basic usage example:
+
+## License
+
+This project is liscensed under the MIT License
+
+## Documentation
+
+Further documentation can be found in: https://msptools.readthedocs.io/en/latest/#msptools
+
+## Contact
+
+For questions, issues, or discussions, please use the GitHub Issues page.
+

msptools-0.1.0/README.md

@@ -0,0 +1,39 @@
+<p align="center">
+  <img src="assets/logo_1_white.svg" alt="Project Logo" width="200">
+</p>
+
+## Overview
+
+**msptools** is a collection of utilities and scripts designed to facilitate the analysis and processing of Optical Forces in plasmonic particle systems characterized by the Multiple Scattering Problem (MSP). 
+
+## Features
+
+- 
+
+## Installation
+
+Clone the repository and install dependencies:
+
+To use the code in this repository, follow these steps:
+
+1. Clone the repository: `git clone https://github.com/JJkrokoder/msptools` or `git clone git@github.com:JJkrokoder/msptools.git`
+2. Install the required dependencies in a new environment: `conda env create -f environment.yml`
+3. Activate the virtual enironment: `conda activate msptools`
+4. Install the package in this environment: `pip install .`
+
+## Usage
+
+Basic usage example:
+
+## License
+
+This project is liscensed under the MIT License
+
+## Documentation
+
+Further documentation can be found in: https://msptools.readthedocs.io/en/latest/#msptools
+
+## Contact
+
+For questions, issues, or discussions, please use the GitHub Issues page.
+

msptools-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "msptools"
+version = "0.1.0"
+requires-python = ">=3.8"
+description = "Tools for Optical Forces Calculation in Multiple Scattering Problems"
+authors = [
+    { name = "Joan ronquillo", email = "joan.ronquillo@uam.es" }
+]
+readme = "README.md"
+license = { file = "LICENSE" }
+dependencies = [
+    "numpy",
+    "scipy",
+    "refractiveindex==1.0.0"
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+docs = ["sphinx"]
+gpu = ["cupy"]
+plotting = ["matplotlib"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+

msptools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

msptools-0.1.0/src/msptools/GreenTensor_Electric.py

@@ -0,0 +1,236 @@
+from .backend import get_backend
+from numpy.typing import ArrayLike
+import numpy as np
+from scipy.constants import pi
+from cmath import exp
+
+def G_0_function(r: float | ArrayLike, wave_number: float) -> complex | ArrayLike:
+    """
+    Computes the G_0 function for a given distance r and wave number.
+
+    Parameters
+    ----------
+    r :
+        The distance between two points.
+    wave_number :
+        The wave number.
+
+    Returns
+    -------
+    complex | ArrayLike
+        The value of the G_0 function.
+    """
+    if isinstance(r, (float, int)):
+        if r > 0:
+            kr = wave_number * r
+            return exp(1j * wave_number * r) / (4 * pi * r) * (1 + 1j/kr - 1/kr**2)
+        else:
+            return 0.0j
+    else:
+        xp = get_backend(r)
+        mask = r > 0
+        result = xp.zeros_like(r, dtype=complex)
+        kr = wave_number * r[mask]
+        result[mask] = xp.exp(1j * kr) / (4 * pi * r[mask]) * (1 + 1j/kr - 1/kr**2)
+        return result
+
+def G_1_function(r: float | ArrayLike, wave_number: float) -> complex | ArrayLike:
+    """
+    Computes the G_1 function for a given distance r and wave number.
+
+    Parameters
+    ----------
+    r :
+        The distance between two points.
+    wave_number :
+        The wave number.
+
+    Returns
+    -------
+    complex | ArrayLike
+        The value of the G_1 function.
+    """
+    if isinstance(r, (float, int)):
+        if r > 0:
+            kr = wave_number * r
+            return -exp(1j * wave_number * r) / (4 * pi * r**3) * (1 + 3j/kr - 3/kr**2)
+        else:
+            return 0.0j
+    else:
+        xp = get_backend(r)
+        mask = r > 0
+        result = xp.zeros_like(r, dtype=complex)
+        kr = wave_number * r[mask]
+        result[mask] = -xp.exp(1j * kr) / (4 * xp.pi * r[mask]**3) * (1 + 3j/kr - 3/kr**2)
+        return result
+
+def G_0_derivative_function(r: float | ArrayLike, wave_number: float) -> complex:
+    """
+    Computes the derivative of the G_0 function with respect to r.
+
+    Parameters
+    ----------
+    r : float
+        The distance between two points.
+    wave_number : float
+        The wave number.
+
+    Returns
+    -------
+    complex
+        The value of the derivative of the G_0 function.
+    """
+    if isinstance(r, (float, int)):
+        xp = np
+    else:
+        xp = get_backend(r)
+    return wave_number * xp.exp(1j * wave_number * r) / (4 * xp.pi * r) * \
+           (1j - 2/(wave_number * r) - 3j/(wave_number * r)**2 + 3/(wave_number * r)**3)
+
+def G_1_derivative_function(r: float | ArrayLike, wave_number: float) -> complex:
+    """
+    Computes the derivative of the G_1 function with respect to r.
+
+    Parameters
+    ----------
+    r : float
+        The distance between two points.
+    wave_number : float
+        The wave number.
+
+    Returns
+    -------
+    complex
+        The value of the derivative of the G_1 function.
+    """
+    if isinstance(r, (float, int)):
+        xp = np
+    else:
+        xp = get_backend(r)
+    return -wave_number * xp.exp(1j * wave_number * r) / (4 * xp.pi * r**3) * \
+           (1j - 6/(wave_number * r) - 15j/(wave_number * r)**2 + 15/(wave_number * r)**3)
+
+def v_cross_derivative(r_vec: ArrayLike, coordinate: int) -> np.ndarray:
+    """
+    Computes the derivative of a vector cross dyadic product with respect to a specific coordinate.
+
+    Parameters
+    ----------
+    r_vec : 
+        The vector for which the derivative is computed.
+    coordinate : 
+        The coordinate with respect to which the derivative is taken (0, 1, or 2).
+
+    Returns
+    -------
+    np.ndarray
+        The derivative of the cross product with respect to the specified coordinate.
+    """
+    xp = get_backend(r_vec)
+
+    dimensions = r_vec.shape[0]
+    if coordinate < 0 or coordinate >= dimensions:
+        raise ValueError("Coordinate must be in the range [0, {}]".format(dimensions - 1))
+
+    der_R_cross = xp.zeros((dimensions, dimensions))
+
+    for i in range(dimensions):
+        if i == coordinate:
+            der_R_cross[i, i] = 2 * r_vec[i]
+        else:
+            der_R_cross[i, coordinate] = r_vec[i]
+            der_R_cross[coordinate, i] = r_vec[i]
+
+    return der_R_cross
+
+def construct_green_tensor(positions : np.ndarray, wave_number: float) -> np.ndarray:
+    """
+    Constructs the Green's tensor for a given set of positions and wave number.
+
+    Parameters
+    ----------
+    positions : np.ndarray
+        Array of shape (num_particles, dimension) containing the positions of the particles.
+    wave_number : float
+        The wave number.
+
+    Returns
+    -------
+    np.ndarray
+        Green's tensor of shape (num_particles, num_particles, dimension, dimension).
+    """
+    xp = get_backend(positions)
+    dimensions = positions.shape[1]
+    rel_vec_matrix = positions[:, None, :] - positions[None, :, :]
+    distances = xp.linalg.norm(rel_vec_matrix, axis=-1)
+    G_0_matrix = G_0_function(distances, wave_number)
+    G_1_matrix = G_1_function(distances, wave_number)
+    R_cross_matrix = rel_vec_matrix[:, :, :, None] * rel_vec_matrix[:, :, None, :]
+    green_tensor = G_0_matrix[:, :, None, None] * xp.eye(dimensions) + G_1_matrix[:, :, None, None] * R_cross_matrix
+    
+    return green_tensor
+
+
+def pair_green_tensor_derivative(pos_i: np.ndarray, pos_j: np.ndarray, coordinate : int,  wave_number: float):
+    """
+    Constructs the derivative of the pair Green's tensor with respect to a specific coordinate.
+
+    Parameters
+    ----------
+    pos_i : np.ndarray
+        Position of the first particle.
+    pos_j : np.ndarray
+        Position of the second particle.
+    coordinate : int
+        The coordinate with respect to which the derivative is taken (0, 1, or 2).
+    wave_number : float
+        The wave number.
+
+    Returns
+    -------
+    np.ndarray
+        Derivative of the pair Green's tensor with respect to the specified coordinate.
+    """
+    xp = get_backend(pos_i)
+    dimensions = pos_i.shape[0]
+    R_vec = pos_i - pos_j
+    r = xp.linalg.norm(R_vec)
+
+    g_1 = G_1_function(r, wave_number)
+    der_g_0 = G_0_derivative_function(r, wave_number) * R_vec[coordinate] / r
+    der_g_1 = G_1_derivative_function(r, wave_number) * R_vec[coordinate] / r
+    R_cross = R_vec[:, None] @ R_vec[None, :]
+    der_R_cross = v_cross_derivative(R_vec, coordinate)
+
+    derivative_tensor = der_g_0 * xp.eye(dimensions) + der_g_1 * R_cross + g_1 * der_R_cross
+    
+    return derivative_tensor 
+
+def construct_green_tensor_gradient(positions : np.ndarray, wave_number: float) -> np.ndarray:
+    """
+    Constructs the derivative of the Green's tensor for a given set of positions and wave number.
+
+    Parameters
+    ----------
+    positions : np.ndarray
+        Array of shape (num_particles, dimension) containing the positions of the particles.
+    wave_number : float
+        The wave number.
+
+    Returns
+    -------
+    np.ndarray
+        Derivative of Green's tensor of shape (num_particles, num_particles, dimension, dimension, dimension).
+    """
+    xp = get_backend(positions)
+    
+    num_particles, dimensions = positions.shape
+    green_tensor_derivative = xp.zeros((num_particles, num_particles, dimensions, dimensions, dimensions), dtype=xp.complex128)
+
+    for i in range(num_particles):
+        for j in range(i + 1, num_particles):
+            for coord in range(dimensions):
+                green_tensor_derivative[i, j, coord, :, :] = pair_green_tensor_derivative(positions[i], positions[j], coord, wave_number)
+                green_tensor_derivative[j, i, coord, :, :] = -green_tensor_derivative[i, j, coord, :, :]
+    return green_tensor_derivative
+    

msptools-0.1.0/src/msptools/MSP.py

@@ -0,0 +1,175 @@
+from .backend import get_backend
+from typing import Iterable
+from numpy.typing import ArrayLike
+
+from msptools.dipole_moments import calculate_dipole_moments_linear
+
+def solve_MSP_from_arrays(polarizability: ArrayLike,
+                          external_field : ArrayLike,
+                          wave_number : float,
+                          green_tensor : ArrayLike,
+                          method : str = 'Inverse',
+                          **kwargs) -> ArrayLike:
+
+    """
+    Solve the Multiple Scattering Problem (MSP) using the provided arrays.
+
+    Parameters
+    ----------
+    polarizability :
+        Polarizability of the particles, can be a complex number, float, int, list, or numpy array.
+    external_field :
+        External field on particles positions.
+    wave_number :
+        Wave number of the incident wave.
+    green_tensor :
+        Green's tensor for the system.
+    method :
+        Method to solve the MSP, either 'Iterative' or 'Inverse'. The default is 'Iterative'.
+
+    Returns
+    -------
+    ArrayLike
+        The solution to the MSP.
+
+    """
+    
+    
+    if green_tensor.ndim != 4 or green_tensor.shape[0] != green_tensor.shape[1] or green_tensor.shape[2] != green_tensor.shape[3]:
+        raise ValueError("Invalid green_tensor shape. Expected shape (N, N, d, d), got {}".format(green_tensor.shape))
+    if green_tensor.shape[0] != external_field.shape[0]:
+        raise ValueError("The first dimension of green_tensor must match the number of particles in external_field. Expected {}, got {}".format(external_field.shape[0], green_tensor.shape[0]))
+    if green_tensor.shape[2] != external_field.shape[1]:
+        raise ValueError("The third dimension of green_tensor must match the system dimensionality. Expected {}, got {}".format(external_field.shape[1], green_tensor.shape[2]))
+
+    if method == 'Iterative':
+        if 'tolerance' in kwargs:
+            tolerance = kwargs['tolerance']
+            return array_MSP_iterative(polarizability, external_field, wave_number, green_tensor, tolerance=tolerance)
+        else:
+            return array_MSP_iterative(polarizability, external_field, wave_number, green_tensor)
+    elif method == 'Inverse':
+        return array_MSP_inverse(polarizability, external_field, wave_number, green_tensor)
+    else:
+        raise ValueError("Unknown method: {}".format(method))
+
+def array_MSP_iterative(polarizability : ArrayLike,
+                          external_field : ArrayLike,
+                          wave_number : float,
+                          green_tensor : ArrayLike,
+                          num_iterations : int = 500,
+                          tolerance : float = 1e-6) -> ArrayLike:
+    
+    """
+    Solve the MSP using an iterative method.
+
+    Parameters
+    ----------
+    polarizability :
+        Polarizability of the particles.
+    external_field :
+        External field on particles positions.
+    wave_number :
+        Wave number of the incident wave.
+    green_tensor :
+        Green's tensor for the system.
+    num_iterations : optional
+        Maximum number of iterations for the iterative method. Default is 500.
+    tolerance : optional
+        Convergence tolerance for the iterative method. Default is 1e-6.
+
+    Returns
+    -------
+    xp.ndarray
+        The solution to the MSP.
+    """
+
+    xp = get_backend(external_field)
+    old_field = external_field.copy()
+
+    for iteration in range(num_iterations):
+        
+        dipole_moments = calculate_dipole_moments_linear(polarizability, old_field)
+        scattered_field = wave_number**2 * xp.einsum('ijmn,jn->im', green_tensor, dipole_moments)
+        new_field = external_field + scattered_field
+
+        if xp.allclose(new_field, old_field, rtol=tolerance):
+            break
+        old_field = new_field.copy()
+
+    if iteration == num_iterations - 1:
+        print(f"Warning: MSP iterative solution did not converge within {num_iterations} iterations.")
+
+    return new_field
+
+def array_MSP_inverse(polarizability : ArrayLike,
+                        external_field : ArrayLike,
+                        wave_number : float,
+                        green_tensor : ArrayLike) -> ArrayLike:
+        """
+        Solve the MSP using the inverse method.
+    
+        Parameters
+        ----------
+        polarizability :
+            Polarizability of the particles.
+        external_field :
+            External field on particles positions.
+        wave_number :
+            Wave number of the incident wave.
+        green_tensor :
+            Green's tensor for the system.
+    
+        Returns
+        -------
+        xp.ndarray
+            The solution to the MSP.
+        """
+        xp = get_backend(external_field)
+        num_particles = external_field.shape[0]
+        dimensions = external_field.shape[1]
+        
+        scattering_matrix = wave_number**2 * xp.einsum('ijmk,jkl->ijml', green_tensor, polarizability)
+
+        MSP_matrix = xp.eye(num_particles * dimensions) - scattering_matrix.transpose(0,2,1,3).reshape(num_particles * dimensions, num_particles * dimensions)
+        
+        total_field = xp.linalg.solve(MSP_matrix, external_field.flatten())
+        total_field = total_field.reshape(num_particles, dimensions)
+        return total_field
+
+def MSP_gradient_from_arrays(dipole_moments: ArrayLike,
+                             external_gradient : ArrayLike,
+                             wave_number : float,
+                             green_tensor_derivative : ArrayLike) -> ArrayLike:
+    """
+    Compute the gradient of the MSP solution with respect to particle positions.
+
+    Parameters
+    ----------
+    polarizability :
+        Polarizability of the particles.
+    MS_field :
+        Multiple scattering field on particles positions.
+    external_gradient :
+        Gradient of the external field on particles positions.
+    wave_number :
+        Wave number of the incident wave.
+    green_tensor_derivative :
+        Derivative of the Green's tensor with respect to particle positions.
+
+    Returns
+    -------
+    xp.ndarray
+        The gradient of the MSP solution with respect to particle positions.
+    
+    Notes
+    -----
+    The gradient is returned as an array of shape (N, d, d) where N is the number of particles and d is the dimensionality.
+    """
+
+    xp = get_backend(external_gradient)
+    scattered_gradient = wave_number**2 * xp.einsum('ijcmn,jn->icm', green_tensor_derivative, dipole_moments)
+    
+    MSP_gradient = external_gradient + scattered_gradient
+
+    return MSP_gradient

msptools-0.1.0/src/msptools/OFO_calculations.py

@@ -0,0 +1,36 @@
+from typing import Iterable
+from .backend import get_backend
+from numpy.typing import ArrayLike
+
+def calculate_forces_eppgrad(medium_permittivity: float, dipole_moments: ArrayLike, field_gradient: ArrayLike) -> ArrayLike:
+    """
+    Calculate the force on a set of dipoles in an electric field gradient.
+
+    Parameters
+    ----------
+    medium_permittivity :
+        The permittivity of the medium in which the dipoles are located.
+    dipole_moments :
+        An array representing the dipole moments of the particles. Shape should be (N, d), 
+        where N is the number of dipoles and d is the dimensionality.
+    field_gradient :
+        An array representing the electric field gradient at the location of the dipoles. 
+        Shape should be (N, d, d), where N is the number of dipoles and d is the dimensionality.
+
+    Returns
+    -------
+    Forces :
+        An array representing the force on each dipole.
+    
+    Notes
+    -----
+    The force is calculated using the formula:
+        F = (ε/2) * Re{ p · ∇E* }
+    where ε is the medium permittivity, p is the dipole moment, and ∇E* is the complex conjugate of the electric field gradient.
+    """
+    xp = get_backend(dipole_moments)
+
+    forces = (medium_permittivity / 2) * xp.real(xp.einsum('im,inm->in', dipole_moments, xp.conj(field_gradient)))
+
+    return forces
+