structured-optics 0.2__tar.gz

structured_optics-0.2/PKG-INFO

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

structured_optics-0.2/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "structured_optics"
+version = "0.2"
+description = "Package for Structured Light simulation"
+requires-python = ">=3.9"
+authors = [
+    { name = "Altilano C. Barbosa" }
+]
+
+dependencies = [
+    "numpy",
+    "scipy",
+    "PyQt6"
+]

structured_optics-0.2/setup.cfg

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

structured_optics-0.2/setup.py

@@ -0,0 +1,8 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='structured_optics',
+    version='0.2',
+    packages=find_packages()
+
+)

structured_optics-0.2/structured_optics/__init__.py

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

structured_optics-0.2/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-0.2/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-0.2/structured_optics/modes.py

@@ -0,0 +1,393 @@
+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 hg_astigmatic_mode(Beam, N, M, wx, wy, z=0, pol_index=None):                                                        
+        #get a astigmatic HG mode at distance z of order N+M
+        zrx = np.pi*wx**2/Beam.lamb
+        q0x = 1j*zrx
+        qx = -z + q0x
+        k = 2*np.pi/Beam.lamb
+        wxz = wx*np.sqrt(1 + (z/zrx)**2)
+        Cn = np.sqrt(np.sqrt(2/np.pi)*q0x/(2**N * special.factorial(N) * qx * wx))
+        un = Cn*(-np.conjugate(qx)/qx)**(N/2)*hermite(np.sqrt(2)*(Beam.x-Beam.x0)/wxz, N)*np.exp(-1j*k*(Beam.x-Beam.x0)**2/(2*qx))
+        
+        zry = np.pi*wy**2/Beam.lamb
+        q0y = 1j*zry
+        qy = -z + q0y
+        wyz = wy*np.sqrt(1 + (z/zry)**2)
+        Cm = np.sqrt(np.sqrt(2/np.pi)*q0y/(2**M * special.factorial(M) * qy * wy))
+        um = Cm*(-np.conjugate(qy)/qy)**(M/2)*hermite(np.sqrt(2)*(Beam.y-Beam.y0)/wyz, M)*np.exp(-1j*k*(Beam.y-Beam.y0)**2/(2*qy))
+        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 = Beam.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 frac_oam_qs_mode(Beam, Ma, n_modes, beta, theta_0, z, pol_index):
+    #get a quasi-stable fractional oam mode.
+    n_min = np.round(Ma-n_modes/2) 
+    n_max = n_min + n_modes - 1
+    mu = Ma%1
+    m = Ma-mu
+    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))
+        p = np.floor((np.abs(Ma) + n_modes/2 -np.abs(l))/2)
+        if Beam.pol_dim == 1:
+            F += coef*(Beam.lg(l, p, z = z).field) 
+        else:
+            F += coef*(Beam.lg(l, p, 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
+
+def circle_mode(Beam, center, radius, pol_index):
+    if radius == None:
+        radius = Beam.waist
+    #Create a circular mode
+    center_x, center_y = center
+    # Calculate distance from center for all points
+    distances = np.sqrt((Beam.x - center_x)**2 + (Beam.y - center_y)**2)
+    # Set points within radius to 1
+    mask = distances <= radius
+    F = np.zeros((Beam.Dy, Beam.Dx), dtype='complex')
+    F[mask] = 1
+    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 square_mode(Beam, center, side_length, pol_index):
+    if side_length == None:
+        side_length = Beam.waist
+    center_x, center_y = center
+    
+    # Calculate square boundaries
+    half_side = side_length / 2.0
+    
+    # Create mask for points inside square
+    mask = (np.abs(Beam.x - center_x) <= half_side) & (np.abs(Beam.y - center_y) <= half_side)
+    
+    # Set points inside square to 1
+    F = np.zeros((Beam.Dy, Beam.Dx), dtype='complex')
+    F[mask] = 1
+    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 triangle_mode(Beam, center, side_length, pol_index):
+    if side_length == None:
+        side_length = Beam.waist
+    center_x, center_y = center
+    
+    # Height of equilateral triangle
+    height = side_length * np.sqrt(3) / 2
+    
+    # Vertices for upward-pointing equilateral triangle
+    # Top vertex
+    v0_x = center_x
+    v0_y = center_y + height * 2/3
+    
+    # Bottom left vertex
+    v1_x = center_x - side_length / 2
+    v1_y = center_y - height * 1/3
+    
+    # Bottom right vertex
+    v2_x = center_x + side_length / 2
+    v2_y = center_y - height * 1/3
+    
+    # Use barycentric coordinates to determine if point is inside triangle
+    def sign(px, py, v1_x, v1_y, v2_x, v2_y):
+        return (px - v2_x) * (v1_y - v2_y) - (v1_x - v2_x) * (py - v2_y)
+    
+    # Compute signs for all points
+    d1 = sign(Beam.x, Beam.y, v0_x, v0_y, v1_x, v1_y)
+    d2 = sign(Beam.x, Beam.y, v1_x, v1_y, v2_x, v2_y)
+    d3 = sign(Beam.x, Beam.y, v2_x, v2_y, v0_x, v0_y)
+    
+    # Point is inside if all signs are same
+    has_neg = (d1 < 0) | (d2 < 0) | (d3 < 0)
+    has_pos = (d1 > 0) | (d2 > 0) | (d3 > 0)
+    
+    mask = ~(has_neg & has_pos)
+    F = np.zeros((Beam.Dy, Beam.Dx), dtype='complex')
+    F[mask] = 1
+    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-0.2/structured_optics/prop_methods.py

@@ -0,0 +1,46 @@
+import numpy as np
+from scipy import fft
+
+
+def propagate_fresnel(Beam, z):                                     
+    #Propagate the field by a distance z using fresnel integral. convolution method
+    k = 2*np.pi/Beam.lamb
+    prop = np.exp(-1j * z * (Beam.kx ** 2 + Beam.ky ** 2) / (2 * k) + 1j*k*z)
+    Beam.fourier_field = fft.fft2(Beam.field)
+    Beam.field = fft.ifft2(prop*Beam.fourier_field)
+    return Beam
+
+def propagate_incoherent(Beam, z):
+    #Propagates the INTENSITY by a distance z using incoherent propagation. Loses phase information.
+    #without pupil function doesn't seems to work
+    k = 2*np.pi/Beam.lamb
+    if z != 0:
+        h2 = np.ones_like(Beam.field)/(Beam.lamb*z)**2
+    else:
+        h2 = np.ones_like(Beam.field)
+    h2_fourier = fft.fft2(h2)
+    I_fourier = fft.fft2(Beam.int_profile())
+    Beam.field = np.sqrt(fft.ifft2(h2_fourier*I_fourier))
+    return Beam
+    
+    
+def propagate_fraunhofer(Beam, z):
+    #Propagate the field by a distance z using fraunhofer integral. Changes XY grid.
+
+    if z < 2/Beam.lamb*Beam.waist**2:
+        print("z small. Fraunhofer is probably not a good aproximation.") 
+    if z != 0:
+        k = 2*np.pi/Beam.lamb
+        dx = Beam.x[0,1] - Beam.x[0,0]
+        dy = Beam.y[1,0] - Beam.y[0,0]
+        fx = np.fft.fftshift(np.fft.fftfreq(Beam.Dx, d=dx))
+        fy = np.fft.fftshift(np.fft.fftfreq(Beam.Dy, d=dy))
+        FX, FY = np.meshgrid(fx, fy, indexing="xy")
+        Beam.x = Beam.lamb * z * FX
+        Beam.y = Beam.lamb * z * FY
+        Beam.nix = np.max(Beam.x)
+        Beam.niy = np.max(Beam.y)
+        C = np.exp(1j*k*z)/(1j*Beam.lamb*z)*np.exp(1j*k*(Beam.x**2 + Beam.y**2)/(2*z))
+        Beam.fourier_field = fft.fft2(Beam.field)
+        Beam.field = C*fft.fftshift(Beam.fourier_field)*dx*dy
+    return Beam