structured-optics 0.1__py3-none-any.whl

structured_optics/__init__.py

@@ -0,0 +1,3 @@
+from .struct_opt import *
+
+__all__ = struct_opt.__all__ if "core" in globals() else []

structured_optics/algebra_utils.py

@@ -0,0 +1,90 @@
+from structured_optics.utils import overlap
+import numpy as np
+
+
+
+def hg_proj(Beam,N, completeness = False):
+    overlaps = np.zeros((N+1, N+1), dtype='complex')
+    auxiliary_beam  = Beam.copy_clean()
+    for n in range(N+1):
+        for m in range(N+1):
+            auxiliary_beam.hg(n,m)
+            overlaps[n,m] = overlap(Beam, auxiliary_beam)
+    n, m =  np.meshgrid(np.arange(0, N+1, 1), np.arange(0, N+1, 1))
+    comp = np.sum(np.abs(overlaps)**2)
+    if completeness == True:
+        return n, m, overlaps, comp
+    else:
+        return n, m, overlaps
+    
+
+def lg_proj(Beam, N, completeness = False):
+    overlaps = np.zeros((int(2*N)+1, int(N/2)+1), dtype='complex')
+    auxiliary_beam  = Beam.copy_clean()
+    for l in np.arange(-N, N+1, 1):
+        for p in range(int(N/2)+1):
+            auxiliary_beam.lg(l,p)
+            overlaps[l+N,p] = overlap(Beam, auxiliary_beam)
+    p, l = np.meshgrid(np.arange(0, int(N/2)+1, 1), np.arange(-N, N+1, 1))
+    comp = np.sum(np.abs(overlaps)**2)
+    if completeness == True:
+        return l, p, overlaps, comp
+    else:
+        return l, p, overlaps
+    
+def hg_basis(Beam, N, waist = None, norm1 = False):
+    aux = Beam.copy_clean()
+    if waist != None:
+        aux.waist = waist
+    basis = np.empty((N+1, N+1, Beam.Dy, Beam.Dx), dtype = 'complex')
+    for n in range(N+1):
+        for m in range(N+1):
+            aux.hg(n, m)
+            basis[n, m] = aux.field
+    if norm1 == True:
+        basis = basis/np.max(basis)
+    return basis
+
+def lg_basis(Beam, N, waist=None, norm1=False):
+    aux = Beam.copy_clean()
+    if waist != None:
+        aux.waist = waist
+    basis = np.empty((N+1, N+1, Beam.Dy, Beam.Dx), dtype = 'complex')
+    for n in range(N+1):
+        for m in range(N+1):
+            l = m-n
+            p = min(n,m)
+            aux.lg(l, p)
+            basis[n, m] = aux.field
+    if norm1 == True:
+        basis = basis/np.max(basis)
+    return basis
+
+def bessel_basis(Beam, Nmax, waist=None, norm1=False):
+    aux = Beam.copy_clean()
+    if waist is not None:
+        aux.waist = waist
+    # basis[n] = Bessel beam of order n
+    basis = np.empty((2*Nmax+1, aux.Dy, aux.Dx), dtype='complex')
+    for n in range(2*Nmax+1):
+        aux.bessel(n-Nmax)   # or aux.bessel(n, theta=...)
+        basis[n] = aux.field
+    if norm1:
+        basis = basis / np.max(np.abs(basis))
+    return basis
+
+def build_from_coefs_and_basis(Beam, coefs, basis):
+    N = len(coefs)
+    aux = Beam.copy_clean()
+    for i in range(N):
+        for j in range(N):
+            aux.field = aux.field + coefs[i,j] * basis[i,j]
+    Beam.field = aux.field
+    return Beam
+
+def astigmatic_mode_converter(Beam, N, theta): 
+    n, m, overlaps = Beam.hg_projector(N)
+    converter = np.exp(1j*(m-n)*theta)
+    overlaps = overlaps*converter
+    Beam.build_from_coefs_and_basis(overlaps, Beam.hg_basis(N))
+    return Beam

structured_optics/hologram.py

@@ -0,0 +1,70 @@
+from structured_optics.struct_opt import *
+import numpy as np
+from structured_optics.utils import *
+import time
+
+
+def slm_hologram(Beam, x_grating, y_grating, method, input_beam, eps, max_range):
+    #generate a hologram for a slm
+    if Beam.pol_dim != 1:
+        print('Beam must be scalar (pol_dim=1) to generate holograms')
+        return None
+    
+    dx = (Beam.x[0,1] - Beam.x[0,0])
+    dy = (Beam.y[1,0] - Beam.y[0,0])
+    if input_beam is None:
+        input_field = np.exp(-((Beam.x**2 + Beam.y**2)/(2*np.max(Beam.x))**2))
+    else:
+        input_field = input_beam.field
+    desired = Beam.field/np.max(np.abs(Beam.field))
+    lamb_x = dx*x_grating
+    lamb_y = dy*y_grating
+    Ain = np.abs(input_field)
+    Ain = Ain / Ain.max()
+    Ades = np.abs(desired)
+    s = np.min(Ain / (Ades + eps))
+    Ades = s * Ades
+    A_rel = Ades / Ain
+    phi_g = np.mod(2*np.pi*(Beam.x/lamb_x + Beam.y/lamb_y), 2*np.pi)
+    phi_relg = np.angle(desired) - np.angle(input_field) + phi_g
+    if method == 'simple':
+        H = A_rel*phi_relg
+    elif method == 'g_holo':
+        edg = desired*np.exp(1j*phi_g)
+        N = np.min(np.abs(input_field)/(np.abs(desired) + 1e-9))
+        H = np.angle(N*edg + input_field)
+    elif method == 'davis':
+        H = (1-inv_sinc(A_rel)/np.pi)*phi_relg
+    elif method == 'bolduc':
+        M = 1+inv_sinc(A_rel)/np.pi
+        H = M*(phi_relg - np.pi*M)
+    elif method == 'bessel0':
+        H = phi_relg + inv_J0(A_rel)*np.sin(phi_relg)
+    elif method == 'bessel1':
+        H = inv_J1(A_rel)*np.sin(phi_relg)
+    else:
+        print('Error! method must be simple, g_holo, davis, bolduc, bessel0 or bessel1.')
+    H = max_range * (H - H.min()) / (H.max() - H.min())
+    return H.astype(np.uint8)
+
+def dmd_hologram(Beam, cx, cy, sign):
+    #generates a hologram for a dmd
+    if Beam.pol_dim != 1:
+        print('Beam must be scalar (pol_dim=1) to generate holograms')
+        return None
+    U = np.abs(Beam.field)
+    U = U/np.amax(U)
+    phi = Beam.phase()
+    A = np.arcsin(U)
+
+    fx = cx*Beam.Dx/(2*Beam.nix)
+    fy = cy*Beam.Dy/(2*Beam.niy)
+    g = [fx, fy]
+    G = g[0]*Beam.x + g[1]*Beam.y
+
+    H = 0.5 + sign*0.5*np.sign(np.cos(phi + 2*np.pi*G) - np.cos(A))
+    return H
+
+
+
+

structured_optics/modes.py

@@ -0,0 +1,234 @@
+from structured_optics.utils import *
+import numpy as np
+from scipy import special
+
+
+#modes implementations
+
+def hg_mode(Beam, N, M, z, pol_index=None):                                                        
+    #get a HG mode at distance z of order N+M
+    zr = Beam.zr()
+    q0 = 1j*zr
+    q = -z + 1j*zr
+    k = 2*np.pi/Beam.lamb
+    w = Beam.waist*np.sqrt(1 + (z/zr)**2)
+    Cn = np.sqrt(np.sqrt(2/np.pi)*q0/(2**N * special.factorial(N) * q * Beam.waist))
+    un = Cn*(-np.conjugate(q)/q)**(N/2)*hermite(np.sqrt(2)*(Beam.x-Beam.x0)/w, N)*np.exp(-1j*k*(Beam.x-Beam.x0)**2/(2*q))
+    Cm = np.sqrt(np.sqrt(2/np.pi)*q0/(2**M * special.factorial(M) * q * Beam.waist))
+    um = Cm*(-np.conjugate(q)/q)**(M/2)*hermite(np.sqrt(2)*(Beam.y-Beam.y0)/w, M)*np.exp(-1j*k*(Beam.y-Beam.y0)**2/(2*q))
+    F = un*um*np.exp(1j*k*z)
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])/np.sqrt(2)
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])/np.sqrt(3)
+    else:
+        Beam.field[pol_index] = F
+    return Beam
+
+
+def lg_mode(Beam,l,p, z, pol_index=None):                                    
+    #get a LG mode at distance z of order abs(N) + 2M
+    zr = Beam.zr()
+    k = 2*np.pi/Beam.lamb
+    w = Beam.waist*np.sqrt(1 + (z/zr)**2)
+    R = (z**2 + zr**2)
+    gouy = (np.abs(l) + 2*p + 1)*np.arctan(z/zr)
+    r = np.sqrt((Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2)
+    Cte = np.sqrt(2*special.factorial(p) / (np.pi*special.factorial(p+np.abs(l))))
+    F = Cte*(1/w)*(np.sqrt(2)*r/w)**(np.abs(l)) * np.exp(-(r/w)**2) * laguerre(2*(r/w)**2, np.abs(l), p) *\
+        np.exp(1j*(k*z + k*z*(r**2)/(2*R) + l*np.arctan2(Beam.y-Beam.y0,Beam.x-Beam.x0) - gouy))
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])/np.sqrt(2)
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])/np.sqrt(3)
+    else:
+        Beam.field[pol_index] = F
+    return Beam
+
+def bessel_mode(Beam, N, z, pol_index=None):                       
+    #get a Bessel mode of order N at distance z
+    k = 2*np.pi / Beam.lamb        # wavenumber
+    j01 = special.jn_zeros(abs(N), 1)[0]  # first zero of J_N
+    # enforce the first zero at r = self.waist
+    kr = j01 / Beam.waist
+    kz = np.sqrt(k**2 - kr**2)    
+    r = np.sqrt((Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2)
+    phi = np.arctan2(Beam.y-Beam.y0, Beam.x-Beam.x0)
+    F = (np.exp(1j*kz*z) * special.jv(abs(N), kr*r) * np.exp(-1j*N*phi))
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def gbessel_mode(Beam, N, r0, pol_index):                                    
+    #get a gaussian bessel beam of order N at z=0
+    rad = 2*np.pi*Beam.waist**2/r0
+    r = np.sqrt((Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2)
+    F = special.jv(np.abs(N),rad*r/Beam.waist**2)*\
+        np.exp(-1j*N*np.arctan2(Beam.y-Beam.y0, Beam.x-Beam.x0))*np.exp(-(r/Beam.waist)**2)
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def lg_prod_mode(Beam, N, ls, centers, pol_index):
+    if centers is None:
+        centers = np.zeros((N, 2))
+    centers = np.asarray(centers)
+    if ls is None:
+        ls = np.ones(N, dtype=int)
+    ls = np.asarray(ls)
+
+    F = np.ones((Beam.Dy, Beam.Dx), dtype='complex128')
+    for i in range(N):
+        x0 = centers[i, 0]
+        y0 = centers[i, 1]
+        l = ls[i]
+        sign = -1 if l < 0 else 1
+        exp_pow = int(np.abs(l))
+        arg = (Beam.x - x0) + 1j * sign * (Beam.y - y0)
+        r2 = (Beam.x - x0)**2 + (Beam.y - y0)**2
+        lg = arg**exp_pow * np.exp(-r2/N / ((Beam.waist)**2))
+        F *= lg
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def frac_oam_mode(Beam, Ma, n_modes, beta, theta_0, z, pol_index):        
+    #get a fractional OAM beam, with OAM Ma (!= integer), by the method of LG supperpositions.
+    mu = Ma%1
+    m = Ma-mu
+    if mu >=0.5:
+        n_min = np.ceil(Ma - n_modes / 2)
+    else: 
+        n_min = np.floor(Ma - n_modes / 2)
+    n_max = n_min + n_modes - 1
+    F = np.zeros((Beam.Dy, Beam.Dx), dtype='complex128')
+    for l in np.arange(int(n_min), int(n_max)+1):
+        coef = np.exp(-1j*mu*beta)*1j*np.exp(1j*(Ma-l)*theta_0)/(2*np.pi*(Ma-l))*np.exp(1j*(m-l)*beta)*(1-np.exp(1j*mu*2*np.pi))
+        if Beam.pol_dim == 1:
+            F += coef*(Beam.lg(l, 0, z = z).field) 
+        else:
+            F += coef*(Beam.lg(l, 0, z = z, pol_index=0).field[0])
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def IG_even_mode(Beam, p, m, q, z, pol_index):
+    #Even Ince-Gaussian mode IG_p,m^e(x,y)
+    
+    xi, eta = cartesian_to_elliptic(Beam.x-Beam.x0, Beam.y-Beam.y0, q, Beam.waist, z, Beam.lamb)
+
+    Ce_xi  = C_ince(1j*xi,  p, m, q)
+    Ce_eta = C_ince(eta, p, m, q)
+
+    zr = np.pi * Beam.waist**2 / Beam.lamb
+    k = 2*np.pi/Beam.lamb
+    wz = Beam.waist * np.sqrt(1 + (z * Beam.lamb / (np.pi * Beam.waist**2))**2)
+    Rz = (z**2 + zr**2)
+    r2 = (Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2
+    gouy = (p+1)*np.arctan(z / zr)
+    F = Ce_xi * Ce_eta * np.exp(-r2 / (wz**2))*np.exp(1j*(k*z + k*z*(r2)/(2*Rz) - gouy))
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def IG_odd_mode(Beam, p, m, q, z, pol_index):
+    #Odd Ince-Gaussian mode IG_p,m^o(x,y)
+    
+    xi, eta = cartesian_to_elliptic(Beam.x-Beam.x0, Beam.y-Beam.y0, q, Beam.waist, z, Beam.lamb)
+    So_xi  = S_ince(1j*xi,  p, m, q)
+    So_eta = S_ince(eta, p, m, q)
+
+    zr = np.pi * Beam.waist**2 / Beam.lamb
+    k = 2*np.pi/Beam.lamb
+    wz = Beam.waist * np.sqrt(1 + (z * Beam.lamb / (np.pi * Beam.waist**2))**2)
+    Rz = (z**2 + zr**2)
+    r2 = (Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2
+    gouy = (p+1)*np.arctan(z / zr)
+    F = So_xi * So_eta * np.exp(-r2 / (wz**2))*np.exp(1j*(k*z + k*z*(r2)/(2*Rz) - gouy))
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam
+
+def HInceG_mode(Beam, p, m, q, z, helicity, pol_index):
+    #Hermite-Ince-Gaussian mode HIG_p,m^e(x,y), combining even and odd Ince-Gaussian modes with given helicity.
+    #For some reason IG_odd has a 3*pi/2 phase shift wrt IG_even, so the helicity sign is inverted here.
+    xi, eta = cartesian_to_elliptic(Beam.x-Beam.x0, Beam.y-Beam.y0, q, Beam.waist, z, Beam.lamb)
+
+    Ce_xi  = C_ince(1j*xi,  p, m, q)
+    Ce_eta = C_ince(eta, p, m, q)
+
+    So_xi  = S_ince(1j*xi,  p, m, q)
+    So_eta = S_ince(eta, p, m, q)
+
+    zr = np.pi * Beam.waist**2 / Beam.lamb
+    k = 2*np.pi/Beam.lamb
+    wz = Beam.waist * np.sqrt(1 + (z * Beam.lamb / (np.pi * Beam.waist**2))**2)
+    Rz = (z**2 + zr**2)
+    r2 = (Beam.x-Beam.x0)**2 + (Beam.y-Beam.y0)**2
+    gouy = (p+1)*np.arctan(z / zr)
+    F = (Ce_xi * Ce_eta - helicity*So_xi * So_eta) * np.exp(-r2 / (wz**2))*np.exp(1j*(k*z + k*z*(r2)/(2*Rz) - gouy))
+    if pol_index == None:
+        if Beam.pol_dim == 1:
+            Beam.field = F
+        elif Beam.pol_dim == 2:
+            Beam.field = np.array([F, F])
+        elif Beam.pol_dim == 3:
+            Beam.field = np.array([F, F, F])
+    else:
+        Beam.field[pol_index] = F
+    Beam.norm_beam()
+    return Beam

structured_optics/prop_methods.py

@@ -0,0 +1,12 @@
+import numpy as np
+from scipy import fft
+
+
+def propagate_conv(space, z):                                     
+    #propagate the field by a distance z using fresnel integral. convolution method
+    k = 2*np.pi/space.lamb
+    prop = np.exp(-1j * z * (space.kx ** 2 + space.ky ** 2) / (2 * k) - 1j*k*z)
+    space.fourier_field = fft.fft2(space.field)
+    space.field = fft.ifft2(prop*space.fourier_field)
+    return space
+

structured_optics/slmdisplay.py

@@ -0,0 +1,85 @@
+import sys
+import numpy as np
+from PyQt6.QtWidgets import QApplication, QLabel
+from PyQt6.QtGui import QImage, QPixmap
+from PyQt6.QtCore import Qt
+
+class My_SLM(QLabel):
+    def __init__(self, screen_index=0):
+        self.app = QApplication.instance() or QApplication(sys.argv)
+        super().__init__()
+
+        screens = self.app.screens()
+        if screen_index >= len(screens):
+            raise ValueError("Invalid screen index")
+
+        screen = screens[screen_index]
+
+        # Force native window creation (CRITICAL on Linux)
+        self.setAttribute(Qt.WidgetAttribute.WA_NativeWindow)
+
+        self.setWindowFlags(
+            Qt.WindowType.FramelessWindowHint
+        )
+
+        self.show()  # must come before windowHandle()
+
+        self.windowHandle().setScreen(screen)
+        geo = screen.geometry()
+
+        # Store logical screen size
+        self.width = geo.width()
+        self.height = geo.height()
+        self.setGeometry(geo)
+
+        self.showFullScreen()
+
+        self._img_ref = None
+
+
+    def update_image(self, img: np.ndarray):
+        """
+        img:
+          - (H, W) uint8 → grayscale
+          - (H, W, 3) uint8 → RGB
+        """
+        if img.dtype != np.uint8:
+            raise TypeError("Image must be uint8")
+
+        self._img_ref = img  # keep reference alive
+
+        if img.ndim == 2:
+            h, w = img.shape
+            stride = img.strides[0]
+
+            qimg = QImage(
+                img.data,
+                w,
+                h,
+                stride,
+                QImage.Format.Format_Grayscale8
+            )
+
+        elif img.ndim == 3 and img.shape[2] == 3:
+            h, w, _ = img.shape
+            stride = img.strides[0]
+
+            qimg = QImage(
+                img.data,
+                w,
+                h,
+                stride,
+                QImage.Format.Format_RGB888
+            )
+        else:
+            raise ValueError("Image must be (H,W) or (H,W,3)")
+
+        self.setPixmap(QPixmap.fromImage(qimg))
+        self.app.processEvents()
+
+    def close(self):
+        if not self.isVisible():
+            return
+        self.hide()
+        self.setParent(None)   # detach from Qt ownership
+        self.deleteLater() 

structured_optics/struct_opt.py

@@ -0,0 +1,357 @@
+
+
+import numpy as np
+from scipy import fft, ndimage
+from structured_optics.prop_methods import *
+import copy
+from structured_optics.utils import *
+from structured_optics.modes import *
+from structured_optics.algebra_utils import *
+from structured_optics.hologram import *
+
+
+
+class Beam():
+    def __init__(self, nix: float,        #Region of interest in x (from -nix to +nix)
+                 Dx: int,                 #Number of points in x
+                 niy: float=None,         #Region of interest in y (from -niy to +niy), equals nix if None
+                 Dy: int=None,            #Number of points in y, equals Dx if None
+                 sparse:bool =True,       #Whether to use sparse meshgrid for x and y
+                 pol_dim:int=1,           #Number of polarization components, Ex, Ey, Ez
+                 waist:float=1e-3,        #Beam waist. Standard value 1mm
+                 lamb:float = 1064e-9,    #Wavelength. Standard value 1064nm
+                 x0:float = 0,            #Beam center x position
+                 y0:float = 0) -> object: #Beam center y position
+        # Initiate an object with the necessary parameters for calculating transverse fields
+
+        self.sparse = sparse
+        self.nix = nix
+        if niy == None:
+            self.niy = nix
+        else:
+            self.niy = niy
+        self.Dx = Dx
+        if Dy == None:
+            self.Dy = Dx
+        else:
+            self.Dy = Dy
+        self.pol_dim = pol_dim
+        self.x, self.y = np.meshgrid(np.linspace(-self.nix, self.nix, self.Dx), np.linspace(-self.niy, self.niy, self.Dy), sparse=sparse)
+        self.field = np.zeros((pol_dim, self.Dy, self.Dx), dtype='complex128')
+        self.kx, self.ky = np.meshgrid(2*np.pi*fft.fftfreq(self.Dx, 2*self.nix/self.Dx), 2*np.pi*fft.fftfreq(self.Dy, 2*self.niy/self.Dy), sparse=sparse)
+        self.lamb = lamb                 
+        self.waist = waist          
+        self.x0 = x0
+        self.y0 = y0
+
+
+
+
+    #Auxialiary 
+
+    def copy(self):                 
+        #Perform a deep copy of the Beam object
+        return copy.deepcopy(self)
+    
+    def copy_clean(self):           
+        #Perform a deep copy of the Beam object, but with field initialized to zero
+        new = self.copy()
+        new.field = np.zeros((self.pol_dim, self.Dy, self.Dx), dtype='complex128')
+        return new
+
+
+
+
+    #Operator overloading
+
+    def __mul__(self, other):
+        #Multiply the transverse fields point by point if multiplied by another field, or globally if multiplied by number.
+        if isinstance(other, (type(self))):
+            new = self.copy()
+            new.field = self.field*other.field
+            return new
+        if isinstance(other, (int, float, complex)):
+            new = self.copy()
+            new.field = other*self.field
+            return new
+
+        else:
+            raise TypeError(f"sorry, don't know how to multiply by {type(other).__name__}")
+        
+    __rmul__ = __mul__
+    
+    def __add__(self, other:object):       
+        #Add the transverse fields point by point
+        if isinstance(other, (Beam, type(self))):
+            new = self.copy()
+            new.field = other.field + self.field
+            return new
+        else:
+            raise TypeError(f"sorry, don't know how to add by {type(other).__name__}")
+        
+    __radd__ = __add__
+        
+    def __sub__(self, other:object):       
+        #Subtract the transverse fields point by point
+        if isinstance(other, Beam):
+            new = self.copy()
+            new.field = self.field - other.field
+            return new
+        else:
+            raise TypeError(f"sorry, don't know how to subtract by {type(other).__name__}")
+        
+    __rsub__ = __sub__
+    
+
+
+
+    #modes
+    #pol_index: polarization index to store the mode, if None uses all polarizations
+    #returns the Beam object with the mode stored in field
+    def hg(self, n:int, m:int, z:float=0, pol_index:int=None) -> object:      
+        #get a HG mode at distance z of order n+m
+        return hg_mode(self, n, m, z, pol_index)                    
+    
+    def lg(self,l:int,p:int, z:float=0, pol_index:int=None) -> object:        
+        #get a LG mode at distance z of order abs(N) + 2M
+        return lg_mode(self, l, p, z, pol_index)
+    
+    def bessel(self, N:int, z:float=0, pol_index:int=None) -> object:         
+        #get a Bessel mode of order N at distance z
+        return bessel_mode(self, N, z, pol_index)
+    
+    def gbessel(self, N:int, r0:int, pol_index:int=None) -> object:           
+        #get a gaussian bessel beam of order N at z=0, r0 is the radius of the first intensity null
+        return gbessel_mode(self, N, r0, pol_index)
+    
+    def lg_prod(self, N:int, ls:tuple=None, centers:tuple=None, pol_index:int=None) -> object:     
+        #get a product superposition of N LG modes, with list of OAMs ls and list of centers
+        return lg_prod_mode(self, N, ls, centers, pol_index)
+    
+    def frac_oam(self, Ma:float, n_modes:int, beta:float = 0, theta_0:float=0, z:float = 0, pol_index=None) -> object:        
+        #get a fractional OAM beam, with OAM Ma (!= integer).
+        return frac_oam_mode(self, Ma, n_modes, beta, theta_0, z, pol_index)
+    
+    def IG_even(self, p:int, m:int, q:float, z:float=0, pol_index:int=None) -> object:    
+        #get an even Ince-Gaussian beam IG_p,m^e at distance z with ellipticity q
+        return IG_even_mode(self, p, m, q, z, pol_index)
+    
+    def IG_odd(self, p:int, m:int, q:float, z:float=0, pol_index:int=None) -> object:     
+        #get an odd Ince-Gaussian beam IG_p,m^o at distance z with ellipticity q
+        return IG_odd_mode(self, p, m, q, z, pol_index)
+                        
+    def HelIG(self, p:int, m:int, q:float, z:float=0, helicity:int=1, pol_index:int=None) -> object:     
+        #get a Hermite-Ince-Gaussian beam HIG_p,m at distance z with ellipticity q and given helicity (+1 or -1)
+        return HInceG_mode(self, p, m, q, z, helicity, pol_index)
+    
+    #Holograms put dmd and slm hologram here
+
+
+
+    #Linear Algebra with modes utils
+
+    def hg_projector(self,N:int, completeness:bool = False) -> tuple:
+        #Project the beam into HG basis up to order N
+        #returns tuple with n, m index and overlaps array, if completeness=True also returns completeness value
+        return hg_proj(self, N, completeness)
+
+    def lg_projector(self, N:int, completeness:bool = False) -> tuple:
+        #Project the beam into LG basis up to order N
+        #returns tuple with l, p index and overlaps array, if completeness=True also returns completeness value
+        return lg_proj(self, N, completeness)
+        
+    def hg_basis(self, N:int, waist:float=None, norm1:bool = False) -> np.ndarray:
+        #Create a HG basis up to order N
+        return hg_basis(self, N, waist, norm1)
+    
+    def lg_basis(self, N:int, waist:float=None, norm1:bool=False) -> np.ndarray:
+        #Create a LG basis up to order N
+        return lg_basis(self, N, waist, norm1)
+    
+    def bessel_basis(self, Nmax:int, waist:float=None, norm1:bool=False) -> np.ndarray:
+        #Create a Bessel basis up to Nmax
+        return bessel_basis(self, Nmax, waist, norm1)
+
+    def build_from_coefs_and_basis(self, coefs:np.ndarray, basis:np.ndarray) -> object:
+        #Build beam from given coefficients and basis
+        return build_from_coefs_and_basis(self, coefs, basis)
+    
+    def mode_converter(self, N:int, theta:float=np.pi/4) -> object: 
+        #Astigmatic mode converter that converts HG to LG modes and viceversa
+        return astigmatic_mode_converter(self, N, theta)
+    
+
+
+
+    #Beam physical atributes and its utilities
+
+    def Power(self, pol_index:int=None) -> float:
+        #Get the total Power of a field within the region of interest
+        if pol_index == None:
+            return np.sum(self.int_profile())*(4*self.nix/self.Dx)*(self.niy/self.Dy)
+        else:
+            return np.sum(self.int_profile(pol_index))*(4*self.nix/self.Dx)*(self.niy/self.Dy)
+    
+    def zr(self) -> float:
+        #Get the Rayleigh range of the beam
+        return np.pi*self.waist**2/self.lamb
+    
+    def int_profile(self, pol_index:int=None) -> np.ndarray:
+        #Get intensity profile of the field within Beam
+        I = np.abs(self.field)**2
+        if pol_index == None:
+            return I
+        else:
+            return I[pol_index]
+    
+    def phase(self, twopi:bool=False) -> np.ndarray:
+        #Get phase profile of the field. If twopi=True, phase is given in [0, 2pi], else in [-pi, pi]
+        if twopi == False:
+            return np.angle(self.field)
+        if twopi == True:
+            p = np.angle(self.field)
+            neg = p<0
+            p = p + neg*2*np.pi
+            return p
+    
+    def center_mass(self, pol_index:int=0) -> tuple:
+        #Calculates the center of mass of intensities of a given field in given polarization
+        #pol_index: polarization index to use for the calculation, default 0
+        if self.pol_dim >1:
+            c = ndimage.center_of_mass(self.int_profile(pol_index))
+        else:
+            c = ndimage.center_of_mass(self.int_profile())
+        return c
+  
+    def std(self, pol_index:int=0) -> float:
+        #Calculate the standard deviation of intensities
+        #pol_index: polarization index to use for the calculation, default 0
+        if self.pol_dim >1:
+            c = self.center_mass(pol_index)
+            return np.sqrt(np.average((self.x-self.x[0,int(c[1])])**2+(self.y-self.y[int(c[0]),0])**2, weights=self.int_profile(pol_index)))
+        else:
+            c = self.center_mass()
+            return np.sqrt(np.average((self.x-self.x[0,int(c[1])])**2+(self.y-self.y[int(c[0]),0])**2, weights=self.int_profile()))
+    
+    def section(self, ang_min:float, ang_max:float) -> np.ndarray:
+        #Return field distribution of given section, defined by minimum angle and maximum angle
+        return get_section(self, ang_min, ang_max)
+    
+    def int_section(self, ang_min:float, ang_max:float)-> np.ndarray:
+        #Get intensity profile of given section, defined by minimum angle and maximum angle
+        return np.abs(self.section(ang_min, ang_max))**2
+    
+    def Power_section(self, ang_min:float, ang_max:float)-> float:
+        #Get power of given section
+        return np.sum(np.abs(self.section(ang_min, ang_max))**2*(4*self.nix/self.Dx)*(self.niy/self.Dy))
+    
+    def norm_beam(self)-> object:                                       
+        #normalize beam so that Total Power = 1 in region of interest
+        self.field = self.field/np.sqrt(self.Power())
+        return self
+    
+    def Max_int1(self)-> object:                                         
+        #rescale the field such that the maximum Intensity point is equal to one.
+        self.field = self.field/np.sqrt(np.amax(self.int_profile()))
+        return self
+    
+    def crop(self, center:tuple=None, std:float=None, window:float=2, pol_index:int=0)-> object:
+        #Crops a field by its std*window arround the center of mass
+        #Here pol_index is the field taken as reference for calcutale std and center
+        return get_crop(self, center, std, window, pol_index)
+    
+
+
+
+
+
+
+
+    #masks
+    def lens(self, f:float, f0:tuple=(0,0))-> object:                                
+        #apply a lens operator to the field, with lens center at f0 and focus lenght equal to f
+        k = 2*np.pi/self.lamb
+        self.field = self.field*np.exp(-1j*k*(((self.x-f0[0])**2 + (self.y-f0[1])**2)/(2*f)))
+        return self
+
+    def astigmatic_lens(self, fx:float, fy:float, f0:tuple=(0,0))-> object:                      
+        #apply a astigmatic lens with two focal axis, with focus fx and fy.
+        k = 2*np.pi/self.lamb
+        self.field = self.field*np.exp(-1j*k*(((self.x-f0[0])**2)/fx + ((self.y-f0[1])**2)/fy)/2)
+        return self
+    
+    def tilted_lens(self, f:float, phi:float, f0:tuple=(0,0))-> object:                      
+        #apply a astigmatic lens with two focal axis, with each focus given by a tilt phi.
+        fx = f*np.cos(phi)**3
+        fy = f*np.cos(phi)
+        return self.astigmatic_lens(fx,fy, f0)
+    
+    def tilted_lens_y(self, f:float, phi:float, f0:tuple=(0,0))-> object:                      
+        #apply a astigmatic lens with two focal axis, with each focus given by a tilt phi, this time the tilt is in y direction.
+        fx = f*np.cos(phi)
+        fy = f*np.cos(phi)**3
+        return self.astigmatic_lens(fx,fy, f0)
+
+    
+    def stripe_v(self, size, move=0):
+        """Def vertical stripe"""
+        d = move*self.Dx/(2*self.nix)
+        s = size*self.Dx/(2*self.nix)
+        self.field[:,int(self.Dx/2 - s + d):int(self.Dx/2+s+d)] = 0
+        return self
+    
+    def stripe_h(self, size):
+        """Def horizontal stripe"""
+        s = size*self.Dy/(2*self.niy)
+        self.field[int(self.Dy/2 - s):int(self.Dy/2+s),:] = 0
+        return self
+    
+    def stripe_cross(self, size, hsize=None):
+        """Def cross stripe"""
+        if hsize == None:
+            hsize = size
+        s = size*self.Dx/(2*self.nix)
+        sh = hsize*self.Dy/(2*self.niy)
+        self.field[int(self.Dy/2 - sh):int(self.Dy/2+sh),:] = 0
+        self.field[:,int(self.Dx/2 - s):int(self.Dx/2+s)] = 0
+        return self
+
+    def slit(self, size):
+        """Def 1 slit"""
+        s = size*self.Dx/(2*self.nix)
+        self.field[:,:int(self.Dx/2-s)] = 0
+        self.field[:,int(self.Dx/2 + s):] = 0
+        return self
+    
+    def double_slit(self, size, dis):
+        """Def double slit"""
+        s = size*self.Dx/(2*self.nix)
+        d = dis*self.Dx/(2*self.nix)
+        self.field[:,0:int((self.Dx-d-s)/2)] = 0
+        self.field[:,int((self.Dx-d+s)/2):int((self.Dx+d-s)/2)] = 0
+        self.field[:,int((self.Dx+d+s)/2):] = 0
+        return self
+    
+
+    
+    
+
+    #Propagation 
+    def propagate(self, z, method='conv', renorm=False):           #propagate the field by a distance z using fresnel integral with exp(-ikz)
+        if method == 'conv':
+            self = propagate_conv(self, z)
+        if renorm == True:
+            self.norm_beam()
+        return self
+    
+
+    #Holograms
+
+    def slm_holo(self, x_grating:int, y_grating:int, method:str = 'bessel1', input_beam:object= None, 
+                 eps:float = 1e-12, max_range:int = 255)-> np.ndarray:
+        #generates hologram for slm
+        return slm_hologram(self, x_grating, y_grating, method = method, input_beam = input_beam, eps = eps, max_range = max_range)
+    
+    def dmd_holo(self, cx:float, cy:float, sign:int=1)-> np.ndarray:
+        #generates hologram for dmd
+        return dmd_hologram(self, cx, cy, sign)

structured_optics/utils.py

@@ -0,0 +1,306 @@
+import numpy as np
+from scipy import special
+
+
+
+#utils for modes
+
+def hermite(X, N):              #hermite polynomial
+    HER = special.hermite(N)
+    sn = HER(X)
+    return sn
+
+def laguerre(X, L, P):          #laguerre polynomial
+    LAG = special.genlaguerre(P, L)
+    sn = LAG(X)
+    return sn
+
+def even_coeffs(p, q, kind):
+    #Compute coefficients A_r of even Ince polynomials C_p^m.
+    if p % 2 != 0:
+        raise ValueError("p must be even for even coefs")
+
+    N = p // 2 
+
+    if kind =='C':
+        M = np.zeros((N+1, N+1), dtype=float)
+        # First equation
+        M[0,0] = 0
+        if N >= 1:
+            M[0, 1] = (p/2 + 1) * q
+
+        # Second equation
+        if N >= 1:
+            M[1, 0] = p * q
+            M[1, 1] = 4
+            if N >= 2:
+                M[1, 2] = (p/2 + 2) * q
+
+        # General recurrence
+        for r in range(2,N):
+
+            M[r, r-1]   = -(r -1 - p/2) * q
+            M[r, r] = 4 * (r)**2
+            M[r, r+1] = (p/2 + r + 1) * q
+        # Last row
+        if N >=2:
+            M[N, N-1] = q
+            M[N, N]   = 4 * (N)**2
+
+    
+    elif kind =='S':
+        M = np.zeros((N+1, N+1), dtype=float)
+        
+        # First equation (r=1)
+        if N >= 1:
+            M[1, 1] = 4
+        if N >= 2:
+            M[1, 2] = (p/2 + 2) * q
+
+        # General recurrence
+        for r in range(2, N):
+            M[r, r-1] = -(r - 1 - p/2) * q
+            M[r, r] = 4 * (r)**2
+            M[r, r+1] = (p/2 + r + 1) * q
+        
+        # Last row
+        if N >= 2:
+            M[N, N-1] = -(N - 1 - p/2) * q
+            M[N, N] = 4 * (N)**2
+
+    eigvals, eigvecs = np.linalg.eig(M)
+
+    # Move the eigenvector with zero eigenvalue to the front (only for 'S' kind) and sort the rest.
+    if kind == 'S':
+        #find zero position
+        zero_idx = np.argmin(np.abs(eigvals))
+        
+        mask = np.arange(len(eigvals)) != zero_idx
+        
+        non_zero_eigvals = eigvals[mask]
+        non_zero_eigvecs = eigvecs[:, mask]
+        
+        #sort non-zero eigenvalues and eigenvectors
+        sorted_idx = np.argsort(non_zero_eigvals)
+        non_zero_eigvals_sorted = non_zero_eigvals[sorted_idx]
+        non_zero_eigvecs_sorted = non_zero_eigvecs[:, sorted_idx]
+
+        #combine zero eigenvalue and sorted non-zero ones
+        eigvals_sorted = np.concatenate([[eigvals[zero_idx]], non_zero_eigvals_sorted])
+        eigvecs_sorted = np.column_stack([eigvecs[:, zero_idx:zero_idx+1], non_zero_eigvecs_sorted])
+    else:
+        # For 'C' kind, just sort normally
+        idx = np.argsort(eigvals)
+        eigvals_sorted = eigvals[idx]
+        eigvecs_sorted = eigvecs[:, idx]
+
+    # Sign convention: ensure sum of coefficients is positive
+    for i in range(eigvecs_sorted.shape[1]):
+        if np.sum(eigvecs_sorted[:, i]) < 0:
+            eigvecs_sorted[:, i] *= -1
+        
+    return eigvals_sorted, eigvecs_sorted
+
+
+def odd_coeffs(p, q, kind):
+    
+    if p % 2 != 1:
+        raise ValueError("p must be odd for odd coefs")
+
+    N = p // 2 
+    M = np.zeros((N+1, N+1), dtype=float)
+
+    if kind == 'C':
+        # First equation
+        M[0, 0] = q/2 * (p + 1) + 1
+        if N >= 1:
+            M[0, 1] = q/2 * (p + 3)
+
+        # General recurrence (r >= 1)
+        for r in range(1, N):
+            M[r, r-1] = -q/2 * (2*r - p - 1)
+            M[r, r]   = (2*r + 1)**2
+            M[r, r+1] = q/2 * (p + 2*r + 3)
+        # Last row
+        if N >=1:
+            M[N, N-1] = q   
+            M[N, N]   = (2*N + 1)**2
+
+    if kind == 'S':
+        # First equation
+        M[0, 0] = 1 - q/2 * (p + 1)
+        if N >= 1:
+            M[0, 1] = q/2 * (p + 3)
+
+        # General recurrence (r >= 1)
+        for r in range(1, N):
+            M[r, r-1] = -q/2 * (2*r - p - 1)
+            M[r, r]   = (2*r + 1)**2
+            M[r, r+1] = q/2 * (p + 2*r + 3)
+        # Last row
+        if N >=1:
+            M[N, N-1] = q   
+            M[N, N]   = (2*N + 1)**2
+
+    eigvals, eigvecs = np.linalg.eig(M)
+
+    # Sort eigenvalues and eigenvectors
+    idx = np.argsort(eigvals)
+    eigvals_sorted = eigvals[idx]
+    eigvecs_sorted = eigvecs[:, idx]
+
+    # Sign convention: ensure sum of coefficients is positive
+    for i in range(eigvecs_sorted.shape[1]):
+        if np.sum(eigvecs_sorted[:, i]) < 0:
+            eigvecs_sorted[:, i] *= -1
+
+    return eigvals_sorted, eigvecs_sorted
+    
+
+def C_ince(xi, p, m, q):
+    # Compute even Ince polynomial C_p^m(xi, q)
+    if p<0 or m < 0 or m > p:
+        raise ValueError("invalid p,m")
+    if p % 2 == 0 and m % 2 == 0:
+        eigvals, eigvecs = even_coeffs(p, q, kind='C')
+        idx = m // 2 
+        A = eigvecs[:, idx]
+        s = sum(A[r] * np.cos(2*r*xi) for r in range(len(A)))
+        return s
+    if p % 2 == 1 and m % 2 == 1:
+        eigvals, eigvecs = odd_coeffs(p, q, kind='C')
+        idx = m // 2
+        B = eigvecs[:, idx]
+        s = sum(B[r] * np.cos((2*r+1)*xi) for r in range(len(B)))
+        return s
+    else:
+        raise ValueError("C_ince is only defined for even (p-m)")
+    
+def S_ince(xi, p, m, q):
+    # Compute odd Ince polynomial S_p^m(xi, q)
+    if p<0 or m < 0 or m > p:
+        raise ValueError("invalid p,m")
+    if p % 2 == 0 and m % 2 == 0:
+        eigvals, eigvecs = even_coeffs(p, q, kind='S')
+        idx = m // 2
+        A = eigvecs[:, idx]
+        s = sum(A[r] * np.sin(2*r*xi) for r in range(1,len(A)))
+        return s
+    if p % 2 == 1 and m % 2 == 1:
+        eigvals, eigvecs = odd_coeffs(p, q, kind='S')
+        idx = (m-1) // 2
+        B = eigvecs[:, idx]
+        s = sum(B[r] * np.sin((2*r+1)*xi) for r in range(len(B)))
+        return s
+    else:
+        raise ValueError("S_ince is only defined for even (p-m)")
+    
+
+def cartesian_to_elliptic(x, y, q, w0, z, lamb):
+    #Convert Cartesian (x,y) to elliptic coordinates (xi, eta) with elipticity q.
+
+    f0 = w0*np.sqrt(q/2)
+    w = w0 * np.sqrt(1 + (z * lamb / (np.pi * w0**2))**2)
+    f = f0*w/w0
+    r_plus  = np.sqrt((x + f)**2 + y**2)
+    r_minus = np.sqrt((x - f)**2 + y**2)
+
+    xi  = np.arccosh((r_plus + r_minus) / (2*f))
+    eta = np.sign(y)*np.arccos((r_plus - r_minus) / (2*f))
+
+    return xi, eta
+
+def elliptic_to_cartesian(xi, eta, q, w0, z, lamb):
+    #Convert elliptic coordinates (xi, eta) to Cartesian (x,y) with elipticity q.
+    f0 = w0*np.sqrt(q/2)
+    w = w0 * np.sqrt(1 + (z * lamb / (np.pi * w0**2))**2)
+    f = f0*w/w0
+    x = f * np.cosh(xi) * np.cos(eta)
+    y = f * np.sinh(xi) * np.sin(eta)
+    return x, y
+
+
+
+#utils for Beam class parameters calculation
+
+def overlap(first_beam:object, second_beam:object)->complex: 
+    # calculate overlap between two beams, only properly works if ni and D of beams are equal.
+    return np.sum(first_beam.field*np.conjugate(second_beam.field))*4*(first_beam.nix/first_beam.Dx) \
+        *(first_beam.niy/first_beam.Dy)/np.sqrt(first_beam.Power()*second_beam.Power())
+
+def int_overlap(first_beam:object, second_beam:object)->float:
+    return np.sum(first_beam.int_profile()*second_beam.int_profile())*4*(first_beam.nix/first_beam.Dx) \
+        *(first_beam.niy/first_beam.Dy)/(first_beam.Power()*second_beam.Power())
+
+
+def get_section(Beam, ang_min, ang_max):
+    #Return field distribution of given section, defined by minimum angle and maximum angle
+    if ang_min > ang_max:
+        ang_min, ang_max = ang_max, ang_min
+    if ang_max <= np.pi and ang_min <= np.pi:
+        sec = (np.arctan2(Beam.y,Beam.x)>=ang_min)*(np.arctan2(Beam.y,Beam.x)<ang_max)
+    if ang_max> np.pi and ang_min <= np.pi:
+        sec1 = (np.arctan2(Beam.y,Beam.x)>=ang_min)
+        ang_max = ang_max-2*np.pi
+        sec2 = (np.arctan2(Beam.y,Beam.x)<ang_max)
+        sec = sec1 + sec2
+    if ang_max>np.pi and ang_min > np.pi:
+        ang_max = ang_max - 2*np.pi
+        ang_min = ang_min - 2*np.pi
+        sec = (np.arctan2(Beam.y,Beam.x)>=ang_min)*(np.arctan2(Beam.y,Beam.x)<ang_max)
+    return Beam.field*sec
+
+
+def get_crop(Beam, center=None, std=None, window=2, pol_index:int=0):
+    #Crops a field by its std*window arround the center of mass
+    if center == None:
+        center = Beam.center_mass(pol_index)
+    if std == None:
+        std = Beam.std(pol_index)
+    xmin = int(center[1] - window*std*Beam.Dx/Beam.nix/2)
+    xmax = int(center[1] + window*std*Beam.Dx/Beam.nix/2)
+    ymin = int(center[0] - window*std*Beam.Dy/Beam.niy/2)
+    ymax = int(center[0] + window*std*Beam.Dy/Beam.niy/2)
+    Beam.x = Beam.x[:,xmin:xmax]
+    Beam.y = Beam.y[ymin:ymax, :]
+    if Beam.pol_dim >1:
+        Beam.field = Beam.field[:,ymin:ymax, xmin:xmax]
+    else:
+        Beam.field = Beam.field[ymin:ymax, xmin:xmax]
+    Beam.Dx = len(Beam.x[0,:])
+    Beam.Dy = len(Beam.y[:,0])
+    Beam.nix = (Beam.x[0,-1] - Beam.x[0,0])/2
+    Beam.niy = (Beam.y[-1,0] - Beam.y[0,0])/2
+    Beam.x0 = center[1]
+    Beam.y0 = center[0]
+    return Beam
+
+
+#utils for holograms
+
+def inv_sinc(A, n=10000):
+    #invert function sinc
+    x = np.linspace(0, np.pi, n)
+    y = np.sinc(x/np.pi)
+
+    return np.interp(A, y[::-1], x[::-1])
+
+def inv_J0(A, n=10000):
+    #invert bessel function J0
+    j01 = 2.404825557695773
+    x = np.linspace(0.0, j01, n)
+    y = special.j0(x)  
+
+    return np.interp(A, y[::-1], x[::-1])
+
+
+def inv_J1(A, a=None, n=10000):
+    #invert bessel function J1
+    x1_max = 1.8411837813406593
+    if a == None:
+        a = special.j1(x1_max)  
+    A = np.clip(A, 0.0, 1.0)
+    x = np.linspace(0.0, x1_max, n)
+    y = special.j1(x) 
+
+    return np.interp(a * A, y, x)

structured_optics-0.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: structured_optics
+Version: 0.1
+Summary: Package for Structured Light simulation
+Author: Altilano C. Barbosa
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: PyQt6
+Dynamic: author

structured_optics-0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+structured_optics/__init__.py,sha256=fOIda-DvXD8aSlijBC2bYj-MHFUlBBeNTdHf_ejhOz4,86
+structured_optics/algebra_utils.py,sha256=kECxFBjza074AbBlM40CjUdoltNQT-_kGmAUQTAkgrs,2861
+structured_optics/hologram.py,sha256=nm93Ma4u4X88KJQAOt7JYlM0X5SU1dTVzcPeMuWNa-c,2216
+structured_optics/modes.py,sha256=nemaiAKPqHAwimObKgbUXItU3DSv2TTDYixnqf4U9xc,8668
+structured_optics/prop_methods.py,sha256=NZcwjHdhkF3coZ-XcI1TbZGWI-2Hk9h4d53Ap-btwEY,421
+structured_optics/slmdisplay.py,sha256=sMeixkJxSeqaXXyieWTpX3U7oqNWPQqDxb_qZGFUQog,2215
+structured_optics/struct_opt.py,sha256=CW1MYL_fy8FvE9abPJCMkJSO6_2curAUfwgeXbSAWQg,14678
+structured_optics/utils.py,sha256=Ml2bGIBalOSTQPv-7CYkQPY8D0gT3nk_079hnolj5WY,9414
+structured_optics-0.1.dist-info/METADATA,sha256=So3HcKl_05c-0Asxbd2kmtgpLU1Rg_6dN8whwH9iKrQ,238
+structured_optics-0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+structured_optics-0.1.dist-info/top_level.txt,sha256=3YZZDRH--fgZIAQh3FIjP6BuDbC6XDj9OTEVwSiqDt4,18
+structured_optics-0.1.dist-info/RECORD,,

structured_optics-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

structured_optics-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+structured_optics