addatmatrix 0.2.0__py3-none-any.whl

addatmatrix/cross_section.py

@@ -0,0 +1,60 @@
+import addatmatrix.wrapper
+import sys
+import addatmatrix.far_field
+import numpy as np
+import tqdm
+from tqdm import trange
+
+from addatmatrix.t_matrix import ILLUMINATION_GRID
+
+
+def get_cross_section(min_wavelength, max_wavelength, num_wavelength, adda_string, material_refractive_index=None):
+    wavelength_range = np.linspace(min_wavelength, max_wavelength, num_wavelength)
+    if material_refractive_index is not None and len(material_refractive_index) != num_wavelength:
+        raise ValueError("Length of material_refractive_index must be equal to num_wavelength")
+
+    csx = []
+    csy = []
+    for iwl, wl in enumerate(tqdm.tqdm(wavelength_range)):
+        if material_refractive_index is not None:
+            material_adda_string = f" -m {material_refractive_index[iwl].real} {material_refractive_index[iwl].imag}"
+        else:
+            material_adda_string = ""
+        adda_output = addatmatrix.wrapper.run_from_args(adda_string + material_adda_string + f" -scat_matr none -lambda {wl}")
+        csx.append(adda_output.cross_section_x)
+        csy.append(adda_output.cross_section_y)
+
+    csx = np.array(csx)
+    csy = np.array(csy)
+    return csx, csy
+
+def calculate_orientation_averaged_extinction_cross_section(illumination_number, wavenumber, **kwargs):
+    def adda_callable(adda_string, kth, kph):
+        nz = np.cos(kth)
+        ny = np.sin(kth) * np.sin(kph)
+        nx = np.sin(kth) * np.cos(kph)
+        return addatmatrix.wrapper.run_from_args(adda_string +' -prop '+str(nx)+' '+str(ny)+' '+str(nz))
+
+    illumination_grid = ILLUMINATION_GRID(illumination_number=illumination_number, wavenumber=wavenumber)
+    csx = []
+    csy = []
+    for iang in trange(len(illumination_grid)):
+        illumination = illumination_grid[iang]
+
+        adda_output = adda_callable(**kwargs, kth=illumination.theta,
+                                    kph=illumination.phi)
+        csx.append(adda_output.cross_section_x)
+        csy.append(adda_output.cross_section_y)
+    return np.mean(np.array(csx)[:,0]), np.mean(np.array(csy)[:,0])
+
+if __name__ == "__main__":
+    min_wavelength = float(sys.argv[1])
+    max_wavelength = float(sys.argv[2])
+    num_wavelength = int(sys.argv[3])
+    adda_string = sys.argv[4]
+
+    csx, csy = get_cross_section(min_wavelength, max_wavelength, num_wavelength, adda_string)
+
+    np.save("csx",csx)
+    np.save("csy",csy)
+

addatmatrix/data.py

@@ -0,0 +1,177 @@
+import h5py
+import numpy as np
+
+
+def get_smuthi_indices(lmax):
+    l = [l for l in range(1,lmax+1) for m in range(-l,l+1)]
+    m = [m for l in range(1,lmax+1) for m in range(-l,l+1)]
+    l = np.array(2*l)
+    m = np.array(2*m)
+    pol = np.array([0]*(len(l)//2) + [1]*(len(l)//2))
+    ind = np.array(range(len(l)))
+    return l, m, pol, ind
+
+def rearrange_blocks(T, lmax):
+    l = [l for l in range(1,lmax+1) for m in range(-l,l+1)]
+    num_block = len(l)
+    T_mm = T[:num_block,:num_block]
+    T_ee = T[num_block:,num_block:]
+    T_em = T[num_block:,:num_block]
+    T_me = T[:num_block,num_block:]
+
+    T_arr = np.block([[T_ee,T_em],[T_me,T_mm]])
+    return T_arr
+
+def convert_indices(pol, m, l, ind):
+    pol_conv = pol.reshape(2,-1).T.flatten()
+    m_conv = m.reshape(2,-1).T.flatten()
+    l_conv = l.reshape(2,-1).T.flatten()
+    ind_conv = ind.reshape(2,-1).T.flatten()
+    return pol_conv, m_conv, l_conv, ind_conv
+
+def invert_indices(ind_conv):
+    inverse = np.zeros_like(ind_conv)
+
+    for idx, value in enumerate(ind_conv):
+        inverse[value] = idx
+    return inverse
+
+def normalize_t_matrix(t_matrix, m_conv):
+    m_a,m_b = np.meshgrid(m_conv,m_conv)
+    norm_factor_t = (-1.0)**(m_a-m_b)
+    return norm_factor_t * t_matrix
+
+def convert_t_matrix(T, ind_conv):
+    T_conv = T[ind_conv][:,ind_conv]
+    return T_conv
+
+def prepare_data_for_storage(T, lmax):
+    l, m, pol, ind = get_smuthi_indices(lmax)
+    pol_conv, m_conv, l_conv, ind_conv = convert_indices(pol, m, l, ind)
+    T_arr = rearrange_blocks(T, lmax)
+    T_conv = convert_t_matrix(T_arr, ind_conv)
+    T_norm = normalize_t_matrix(T_conv, m_conv)
+    indices = (l_conv, m_conv, pol_conv)
+    return T_norm, indices
+
+
+def t_matrix_to_smuthi_convention(t_ref, lmax):
+    l, m, pol, ind = get_smuthi_indices(lmax)
+    pol_conv, m_conv, l_conv, ind_conv = convert_indices(pol, m, l, ind)
+    inv = invert_indices(ind_conv)
+
+    t_ref_unnorm = normalize_t_matrix(t_ref, m_conv)
+    T_conv = convert_t_matrix(t_ref_unnorm, inv)
+    T_conv2 = rearrange_blocks(T_conv, lmax)
+    return T_conv2
+
+def get_metadata(adda_string):
+    adda_command_split = adda_string.split("-")
+    metadata = {ind.split()[0]:ind.split()[1:] for ind in adda_command_split[1:]}
+    return metadata
+
+def write_t_matrix_data(path, tmatrix_data, indices, metadata):
+    l, m_ind, pol = indices
+    mstring = metadata["m"]
+    m = float(mstring[0]) + 1j * float(mstring[1])
+    relative_permittivity = m ** 2
+    relative_permeability = 1.0
+
+    # Create the HDF5 file
+    with h5py.File(path, 'w') as h5file:
+        # Creating groups
+        computation_group = h5file.create_group('computation')
+        embedding_group = h5file.create_group('embedding')
+        modes_group = h5file.create_group('modes')
+        scatterer_group = h5file.create_group('scatterer')
+
+        # Creating datasets
+        h5file.create_dataset('vacuum_wavelength', data=metadata["lambda"])
+        
+        mesh_msh_data = "Mesh data as a string or binary blob"  # Example data for mesh.msh
+        h5file.create_dataset('mesh.msh', data=np.void(mesh_msh_data.encode('utf-8')))
+        
+        h5file.create_dataset('tmatrix', data=tmatrix_data)
+        
+        # Adding sub-groups and datasets in computation group
+        method_parameters = computation_group.create_group('method_parameters')
+        for key, val in metadata.items():
+            method_parameters.create_dataset(key, data=np.string_(str(val)))
+        
+        # Adding sub-groups and datasets in embedding group
+        embedding_group.create_dataset('relative_permeability', data=1.0)
+        embedding_group.create_dataset('relative_permittivity', data=1.0)
+        
+        # Adding sub-groups and datasets in modes group
+        modes_group.create_dataset('l', data=l)
+        modes_group.create_dataset('m', data=m_ind)
+        modes_group.create_dataset('polarization', data=pol)
+        
+        # Adding sub-groups and datasets in scatterer group
+        geometry_group = scatterer_group.create_group('geometry')
+        material_group = scatterer_group.create_group('material')
+        material_group.create_dataset('relative_permeability', data=relative_permeability)
+        material_group.create_dataset('relative_permittivity', data=relative_permittivity)
+
+def write_cross_section(csx,csy,output_path):
+    np.savez(output_path, csx, csy)
+
+
+def read_t_matrix_data(path):
+    with h5py.File(path, 'r') as h5file:
+        # Read basic metadata
+        vacuum_wavelength = h5file['vacuum_wavelength'][()]
+        print(f"Vacuum Wavelength: {vacuum_wavelength}")
+
+        # Read mesh data (assuming it's stored as a string)
+        #mesh_msh_data = h5file['mesh.msh']
+        #mesh_msh_data = mesh_msh_data.tobytes().decode('utf-8')  # Decoding binary data back to string
+        #print(f"Mesh MSH Data: {mesh_msh_data}")
+
+        # Read the T-matrix data
+        tmatrix_data = h5file['tmatrix'][:]
+        print(f"T-matrix Data shape: {tmatrix_data.shape}")
+
+        # Read method parameters from the 'computation' group
+        computation_group = h5file['computation/method_parameters']
+        method_parameters = {key: computation_group[key][()] for key in computation_group}
+        print("Method Parameters:")
+        for key, value in method_parameters.items():
+            print(f"{key}: {value}")
+
+        # Read data from the 'embedding' group
+        embedding_group = h5file['embedding']
+        relative_permeability = embedding_group['relative_permeability'][()]
+        relative_permittivity = embedding_group['relative_permittivity'][()]
+        print(
+            f"Embedding Group: Relative Permeability = {relative_permeability}, Relative Permittivity = {relative_permittivity}")
+
+        # Read data from the 'modes' group
+        modes_group = h5file['modes']
+        l = modes_group['l'][:]
+        m = modes_group['m'][:]
+        polarization = modes_group['polarization'][:]
+        print(f"Modes Group: l = {l}, m = {m}, Polarization = {polarization}")
+
+        # Read data from the 'scatterer' group
+        scatterer_group = h5file['scatterer']
+        material_group = scatterer_group['material']
+        scatterer_relative_permittivity = material_group['relative_permittivity'][()]
+        scatterer_relative_permeability = material_group['relative_permeability'][()]
+        print(
+            f"Scatterer Group: Relative Permittivity = {scatterer_relative_permittivity}, Relative Permeability = {scatterer_relative_permeability}")
+
+        # Return the loaded data as a dictionary or any other format as needed
+        data = {
+            'vacuum_wavelength': vacuum_wavelength,
+            'tmatrix_data': tmatrix_data,
+            'method_parameters': method_parameters,
+            'relative_permittivity': relative_permittivity,
+            'relative_permeability': relative_permeability,
+            'l': l,
+            'm': m,
+            'polarization': polarization,
+            'scatterer_relative_permittivity': scatterer_relative_permittivity,
+            'scatterer_relative_permeability': scatterer_relative_permeability
+        }
+        return data

addatmatrix/far_field.py

@@ -0,0 +1,151 @@
+from typing import Tuple
+
+import numpy as np
+from numba import njit
+from tqdm import tqdm
+
+from addatmatrix.spatial import IntegrationGrid
+from addatmatrix.math import spherical_harmonic_m, spherical_harmonic_n
+from addatmatrix.wrapper import pol_from_adda_string
+
+import numpy as np
+from multiprocessing import Pool, cpu_count
+from functools import partial
+from tqdm import tqdm
+
+
+@njit
+def getposfac(ks, er, pos):
+    er_dot_r = er[0] * pos[0] + er[1] * pos[1] + er[2] * pos[2]
+    return np.exp(-1j * ks * er_dot_r)
+
+def parse_pol_file(data: np.array) -> Tuple[np.array, np.array]:
+    r = data[:, :3]
+    pol = np.zeros((data.shape[0], 3), dtype=complex)
+    pol[:, 0] = data[:, 4] + 1j * data[:, 5]
+    pol[:, 1] = data[:, 6] + 1j * data[:, 7]
+    pol[:, 2] = data[:, 8] + 1j * data[:, 9]
+    return pol, r
+
+@njit
+def get_total_polarization(pol: np.array, er: np.array, r: np.array, ks: float) -> np.array:
+    pol_eff = np.zeros_like(er) + 1j * np.zeros_like(er)
+    for ip, pos in enumerate(r):
+        posfac = getposfac(ks, er, pos)
+        pol_eff[0,:,:] = pol_eff[0,:,:] + pol[ip, 0] * posfac
+        pol_eff[1,:,:] = pol_eff[1,:,:] + pol[ip, 1] * posfac
+        pol_eff[2,:,:] = pol_eff[2,:,:] + pol[ip, 2] * posfac 
+    return pol_eff
+
+def convert_cartesian_to_spherical(pol_eff: np.array, grid: IntegrationGrid) -> np.array:
+    T, P = (grid.T, grid.P)
+    pol_sph = np.zeros((2, pol_eff.shape[1], pol_eff.shape[2]), dtype=complex)
+    pol_sph[0,:,:] = np.cos(T)*np.cos(P)*pol_eff[0,:,:]+np.cos(T)*np.sin(P)*pol_eff[1,:,:]-np.sin(T)*pol_eff[2,:,:]
+    pol_sph[1,:,:] = -np.sin(P)*pol_eff[0,:,:]+np.cos(P)*pol_eff[1,:,:]
+    return pol_sph
+
+def calculate_far_field(pol: np.array, ks: float) -> np.array:
+    Escat = np.zeros(pol.shape, dtype=complex)
+    Escat[1, :, :] = 1j * ks ** 3 * pol[0, :, :]
+    Escat[0, :, :] = 1j * ks ** 3 * pol[1, :, :]
+    Escat[1, :, :] = -Escat[1, :, :]
+    Escat = -np.nan_to_num(Escat)
+    return Escat
+
+def azimuthal_average_far_field(b_coeffs, theta, phi, k, lmax):
+    res = []
+    phi_shape = phi.shape
+    azimuthal_angles = phi[0]
+    phi = phi.flatten()
+    theta = theta.flatten()
+    for tau in [0, 1]:
+        for l in range(1, lmax + 1):
+            for m in range(-l, l + 1):
+                if tau:
+                    mr = spherical_harmonic_m(theta, phi, l, m)
+                else:
+                    mr = 1j * spherical_harmonic_n(theta, phi, l, m)
+                prefactor = (-1j) ** (l + 1)
+                res.append(prefactor * mr)
+    res = np.array(res)
+    myff = (b_coeffs[:, None, None] * res).sum(axis=0)
+
+    myff = myff.reshape(-1, *phi_shape)
+    myff[1] = -myff[1]
+
+    azimuthal_average = np.trapz(np.abs(myff) ** 2 / (k ** 2), azimuthal_angles)
+    return azimuthal_average
+
+def convert_adda_output_to_far_field(adda_output, grid, pol, ks):
+    data = adda_output.dipole_polarization_x if pol == 1 else adda_output.dipole_polarization_y
+    pol_cart, r = parse_pol_file(data)
+    pol_eff = get_total_polarization(pol_cart, grid.er, r, ks)
+    pol_eff_sph = convert_cartesian_to_spherical(pol_eff, grid)
+    Escat = calculate_far_field(pol_eff_sph, ks)
+    return Escat
+
+def get_far_field_from_adda(illumination, grid, **kwargs):
+    adda_output = pol_from_adda_string(**kwargs, kth=illumination.theta,
+                                kph=illumination.phi)
+
+    Escat = convert_adda_output_to_far_field(adda_output, grid,
+                                             illumination.polarization,
+                                             illumination.wavenumber)
+    return Escat
+
+
+def _far_field_worker(args):
+    """Worker function for multiprocessing."""
+    iang, illumination, grid, kwargs = args
+    Escat = get_far_field_from_adda(illumination, grid, **kwargs)
+    return iang, Escat
+
+
+def get_plane_wave_t_matrix(illumination_grid, grid, n_processes=None, **kwargs):
+    Ntheta, Nphi = grid.T.shape
+    n_illum = illumination_grid.illumination_number
+
+    Escat_tot = np.zeros(
+        (2 * n_illum, 2, Ntheta, Nphi),
+        dtype=complex
+    )
+
+    if n_processes is None:
+        n_processes = cpu_count()
+
+    # Prepare arguments for workers
+    tasks = [
+        (iang, illumination, grid, kwargs)
+        for iang, illumination in enumerate(illumination_grid)
+    ]
+
+    with Pool(processes=n_processes) as pool:
+        with tqdm(total=len(tasks)) as pbar:
+            for iang, Escat in pool.imap_unordered(_far_field_worker, tasks):
+                Escat_tot[iang, :, :, :] = Escat
+                pbar.update(1)
+
+    T_pl = Escat_tot.reshape(2 * n_illum, -1).T
+    return T_pl
+
+def vsh_far_field(b_coeffs, grid, k, lmax):
+    phi = grid.P
+    theta = grid.T
+    res = []
+    phi_shape = phi.shape
+    phi = phi.flatten()
+    theta = theta.flatten()
+    for tau in [0, 1]:
+        for l in range(1, lmax + 1):
+            for m in range(-l, l + 1):
+                if tau:
+                    mr = spherical_harmonic_m(theta, phi, l, m)
+                else:
+                    mr = 1j * spherical_harmonic_n(theta, phi, l, m)
+                prefactor = (-1j) ** (l + 1)
+                res.append(prefactor * mr)
+    res = np.array(res)
+    myff = (b_coeffs[:, None, None] * res).sum(axis=0)
+
+    myff = myff.reshape(-1, *phi_shape)
+    return myff

addatmatrix/gauss_legendre.py

@@ -0,0 +1,97 @@
+from addatmatrix.math import spherical_harmonic_m, spherical_harmonic_n
+from collections import namedtuple
+from scipy.special import roots_legendre
+import numpy as np
+
+Grid = namedtuple('Grid', ['T', 'P'])
+
+def get_all_harmonics(lmax, grid):
+    all_harmonics = []
+    for tau in [0, 1]:
+        for l in range(1, lmax + 1):
+            for m in range(-l, l + 1):
+                if tau:
+                    mr = spherical_harmonic_m(grid.T, grid.P, l, m)
+                else:
+                    mr = 1j * spherical_harmonic_n(grid.T, grid.P, l, m)
+                all_harmonics.append(mr)
+    all_harmonics = np.array(all_harmonics)
+    return all_harmonics
+
+def get_weights(grid):
+    theta_grid_new, phi_grid_new = grid.T, grid.P
+    n_theta, n_phi = theta_grid_new.shape
+    _, theta_weights = roots_legendre(n_theta)
+    phi_weights = (2 * np.pi / n_phi) * np.ones(n_phi)
+
+    # Compute weights
+    weights_grid = theta_weights[:, None] * phi_weights[None, :]
+    return weights_grid
+
+def get_grid(n_theta=10, n_phi=20):
+    # Gauss-Legendre for cos(theta)
+    theta_nodes, _ = roots_legendre(n_theta)
+    theta_nodes = np.arccos(theta_nodes)
+
+    # Trapezoidal rule for phi
+    phi_nodes = np.linspace(0, 2 * np.pi, n_phi, endpoint=False)
+
+    theta_grid_new, phi_grid_new = np.meshgrid(theta_nodes, phi_nodes,
+                                               indexing='ij')
+    return Grid(theta_grid_new, phi_grid_new)
+
+def get_prefactors(lmax):
+    prefactors = []
+    for _ in range(2):
+        for l in range(1, lmax + 1):
+            for m in range(-l, l + 1):
+                prefactor = 1 / (-1j) ** (l + 1)
+                prefactors.append(prefactor)
+    return np.array(prefactors)
+
+def get_indicator_vector(theta_target, phi_target, grid, prepend_flag = False):
+    theta_grid_new, phi_grid_new = grid.T, grid.P
+
+    theta_flat = theta_grid_new.flatten()
+    phi_flat = phi_grid_new.flatten()
+
+    distances = np.sqrt((theta_flat - theta_target)**2 + (phi_flat - phi_target)**2)
+
+    min_index = np.argmin(distances)
+
+    indicator_vector = np.zeros_like(theta_flat)
+    indicator_vector[min_index] = 1  # Set the closest index to 1
+
+    zero_clone = np.zeros_like(indicator_vector)
+
+    if prepend_flag:
+        final_vector = np.concatenate((zero_clone, indicator_vector))
+    else:
+        final_vector = np.concatenate((indicator_vector, zero_clone))
+    return final_vector
+
+def build_matrices_from_grid(grid, lmax):
+    all_harmonics = grid.get_all_harmonics(lmax)
+    prefactors = get_prefactors(lmax)
+    W = np.diag(np.concatenate(2 * [grid.weights.flatten()]))
+    D = np.diag(prefactors.flatten())
+    U = all_harmonics.reshape(len(prefactors), -1).T
+    return W, D, U
+
+def get_initial_field_vsh_conversion_matrix(W, D, U):
+    N = W.shape[0]
+    S = np.diag(np.ones(N))
+    S[N//2:, N//2:] = -S[N//2:, N//2:]
+    sph_to_pw = -1 / (4 * np.pi) * S @ W @ U @ D.conj()
+    return sph_to_pw
+
+def get_scattered_pw_conversion_matrix(W, D, U):
+    scat_pw_to_sph = 1 / np.pi * D @ U.T.conj() @ W
+    return scat_pw_to_sph
+
+def get_initial_field_pw_conversion_matrix(W, D, U):
+    N = W.shape[0]
+    S = np.diag(np.ones(N))
+    S[N//2:, N//2:] = -S[N//2:, N//2:]
+    pw_to_sph = -4 * D @ U.T.conj() @ S
+    return pw_to_sph

addatmatrix/incident_field.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+import numpy as np
+from addatmatrix.math import pwe_to_swe_conversion
+
+
+@dataclass
+class PlaneWaveIllumination:
+    theta: float
+    phi: float
+    polarization: int
+    wavenumber: float
+
+    def get_spherical_wave_coefficients(self, particle_z, lmax):
+        kth = self.theta
+        kph = self.phi
+        pol = self.polarization
+
+        pos = [0, 0, particle_z]
+        kth_arr = np.array([kth])
+        azimuthal_angle = np.array([kph])[:, None]
+        incf = pwe_to_swe_conversion(lmax, lmax, pos, pos, int(pol), np.sin(kth_arr),
+                                     np.cos(kth_arr), azimuthal_angle)
+        return incf