vectorwaves 1.0.0__tar.gz

vectorwaves-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mayank Soni
+
+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.

vectorwaves-1.0.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: vectorwaves
+Version: 1.0.0
+Summary: Three-dimensional electromagnetic field simulation and topology analysis
+Author: Mayank Soni
+License: MIT License
+        
+        Copyright (c) 2026 Mayank Soni
+        
+        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.
+Project-URL: Homepage, https://github.com/1Rayokelvin/VectorWaves
+Project-URL: Repository, https://github.com/1Rayokelvin/VectorWaves
+Project-URL: Issues, https://github.com/1Rayokelvin/VectorWaves/issues
+Project-URL: Documentation, https://1rayokelvin.github.io/VectorWaves
+Keywords: physics,optics,wave-optics,vector-optics,electromagnetism,electromagnetic-fields,structured-light,gaussian-beams,laguerre-gaussian,plane-wave-expansion,computational-physics,optical-singularities,polarization-singularities,phase-singularities,topological-optics,optical-vortices
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: numba>=0.59.0
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7.0; extra == "viz"
+Requires-Dist: pyvista>=0.40.0; extra == "viz"
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.65.0; extra == "progress"
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda12x>=12.0.0; extra == "gpu"
+Provides-Extra: all
+Requires-Dist: matplotlib>=3.7.0; extra == "all"
+Requires-Dist: pyvista>=0.40.0; extra == "all"
+Requires-Dist: tqdm>=4.65.0; extra == "all"
+Requires-Dist: cupy-cuda12x>=12.0.0; extra == "all"
+Dynamic: license-file
+
+VectorWaves provides a framework for generating, computing, and analyzing fully three-dimensional electromagnetic fields and their topology through discrete plane-wave expansions.
+
+## Installation
+
+```bash
+pip install vectorwaves
+```
+
+For additional features, you can install the optional dependencies:
+
+| Extra | Purpose |
+|---------|---------|
+| `viz` | Matplotlib and PyVista for visualizations |
+| `progress` | Progress bars via tqdm |
+| `gpu` | CUDA acceleration via CuPy |
+| `all` | All the above |
+
+To install, 
+```bash
+pip install vectorwaves[extra]
+```
+
+## Features
+
+- Physics-oriented configuration system with `numpy`, `numba`, and CuPy (GPU) backends.
+- Exact non-paraxial 3D propagation via Fibonacci-sphere discrete plane-wave expansions.
+- Monochromatic and polychromatic sources with arbitrary envelopes, structured light support.
+- Stochastic process generation for speckle-like fields.
+- Fully analytic computation of E-fields, B-fields, spatial derivatives.
+- Topological polarization analysis: C, Cᵀ, and Lᵀ point finding with 3D line tracing.
+  
+## Quick Example
+
+```python
+import vectorwaves as vw
+
+# Generate a tightly-focused Laguerre-Gaussian beam
+config = vw.get_config()
+config.source.k_space.laguerre_gauss(p=1, l=2, sigma_k_perp=1)
+config.source.randomize.off()
+
+# Construct the beam and visualize its plane-wave modes
+beam = vw.setup_beam(config)
+
+# Requires matplotlib, install with  'viz' extra: pip install vectorwaves[viz]
+beam.plot_kspace_3d(plot_type='colored_vectors')
+```
+
+![LG beam k-space](https://github.com/1Rayokelvin/VectorWaves/blob/main/docs/images/LG_kspace.png?raw=true)
+
+For tutorials and examples, please refer to the [official documentation](https://1rayokelvin.github.io/VectorWaves). Source code is available on [GitHub](https://github.com/1Rayokelvin/VectorWaves/).

vectorwaves-1.0.0/README.md

@@ -0,0 +1,83 @@
+# VectorWaves
+
+A Python library for constructing and analyzing electromagnetic fields through discrete plane-wave expansions.
+
+Classical light is fundamentally an electromagnetic wave. In vacuum, electromagnetic fields admit a plane-wave decomposition, and VectorWaves provides a framework for constructing, computing, and analyzing fully three-dimensional vector fields and their topological structures.
+
+**For full documentation, basic usage, and tutorials, visit the [official documentation site](https://1rayokelvin.github.io/VectorWaves).**
+
+## Installation
+
+```bash
+pip install VectorWaves
+```
+
+For additional features, you can install optional dependencies:
+
+| Extra | Purpose |
+|---------|---------|
+| `viz` | Matplotlib and PyVista for visualizations |
+| `progress` | Progress bars via tqdm |
+| `gpu` | CUDA acceleration via CuPy |
+| `all` | All the above |
+
+To install, 
+```bash
+pip install vectorwaves[#Extra]
+```
+
+## Features
+
+- **Exact 3D Fields**: Electric, Magnetic fields and spatial derivatives via Fibonacci-sphere discrete plane-wave expansions.
+- **Monochromatic Source Models**: Built-in source definitions and arbitrary user-defined spatial spectra.
+- **Polychromatic Source Models**: Built-in spectral distributions and arbitrary user-defined spectral profiles.
+- **Advanced Topology**: Detect and trace polarization singularities (C, Cᵀ, and Lᵀ points/lines).
+- **Physical Diagnostics**: Easily compute Stokes parameters and polarization ellipses for quick visuals.
+- **Stochastic Fields**: Built-in randomization for generating speckles and unpolarized fields.
+- **High Performance**: Hierarchical configuration with seamless switching between CPU (`numpy`, `numba`) and GPU (`cupy`) backends.
+
+## Quick Tour: The Power of Plane-Wave Superposition
+
+Because VectorWaves natively superposes true 3D plane-wave vectors, it effortlessly captures complex non-paraxial vector effects that scalar FFT propagators miss entirely. 
+
+For example, when you tightly focus a linearly polarized Gaussian beam, a longitudinal (z-direction) electric field and a clover-like cross-polarized field naturally emerge purely from the geometry of the converging wavevectors.
+
+```python
+import matplotlib.pyplot as plt
+plt.style.use('dark_background')
+import numpy as np
+import vectorwaves as vw
+
+# 1. Configure a tightly focused, x-polarized Gaussian beam
+config = vw.get_config()
+config.op.size = (2,2); config.op.spacing = 0.02
+config.source.pol_vect = (1, 0)
+config.source.k_space.gaussian(sigma_k_perp=2.0) # High divergence
+config.source.theta_max = np.pi/2 # Allow modes up to 90 degrees
+config.source.randomize.off()
+
+# 2. Construct the engine and compute the exact vector field at the focus
+engine = vw.setup_engine(config)
+result = engine.compute_on_op(z=0.0)
+
+# 3. Extract the intensity of x and z components
+Ex, Ey, Ez = result.E
+I_x, I_z = np.abs(Ex)**2, np.abs(Ez)**2
+
+# Plotting the two intensities
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,5))
+extent = engine.op_extent
+
+im1 = ax1.imshow(I_x, extent=extent, cmap='magma'); ax1.set_title("|Ex|² (Main)")
+im2 = ax2.imshow(I_z, extent=extent, cmap='magma'); ax2.set_title("|Ez|² (Longitudinal)")
+
+fig.colorbar(im1, ax=ax1); fig.colorbar(im2, ax=ax2)
+plt.tight_layout()
+plt.show()
+```
+
+![Gaussian Beam components](docs/images/gaussian_beam_vector.png)
+*(Note the colorbar scales: the solver automatically calculates the correct relative magnitudes of the emergent longitudinal components without any paraxial approximations).*
+
+### Ready to learn more?
+For a gentler introduction covering basic configurations, spectral envelopes, or fully 3D field visualizations, head over to the **[Getting Started Guide](https://1rayokelvin.github.io/VectorWaves)**.

vectorwaves-1.0.0/README_PyPi.md

@@ -0,0 +1,51 @@
+VectorWaves provides a framework for generating, computing, and analyzing fully three-dimensional electromagnetic fields and their topology through discrete plane-wave expansions.
+
+## Installation
+
+```bash
+pip install vectorwaves
+```
+
+For additional features, you can install the optional dependencies:
+
+| Extra | Purpose |
+|---------|---------|
+| `viz` | Matplotlib and PyVista for visualizations |
+| `progress` | Progress bars via tqdm |
+| `gpu` | CUDA acceleration via CuPy |
+| `all` | All the above |
+
+To install, 
+```bash
+pip install vectorwaves[extra]
+```
+
+## Features
+
+- Physics-oriented configuration system with `numpy`, `numba`, and CuPy (GPU) backends.
+- Exact non-paraxial 3D propagation via Fibonacci-sphere discrete plane-wave expansions.
+- Monochromatic and polychromatic sources with arbitrary envelopes, structured light support.
+- Stochastic process generation for speckle-like fields.
+- Fully analytic computation of E-fields, B-fields, spatial derivatives.
+- Topological polarization analysis: C, Cᵀ, and Lᵀ point finding with 3D line tracing.
+  
+## Quick Example
+
+```python
+import vectorwaves as vw
+
+# Generate a tightly-focused Laguerre-Gaussian beam
+config = vw.get_config()
+config.source.k_space.laguerre_gauss(p=1, l=2, sigma_k_perp=1)
+config.source.randomize.off()
+
+# Construct the beam and visualize its plane-wave modes
+beam = vw.setup_beam(config)
+
+# Requires matplotlib, install with  'viz' extra: pip install vectorwaves[viz]
+beam.plot_kspace_3d(plot_type='colored_vectors')
+```
+
+![LG beam k-space](https://github.com/1Rayokelvin/VectorWaves/blob/main/docs/images/LG_kspace.png?raw=true)
+
+For tutorials and examples, please refer to the [official documentation](https://1rayokelvin.github.io/VectorWaves). Source code is available on [GitHub](https://github.com/1Rayokelvin/VectorWaves/).

vectorwaves-1.0.0/pyproject.toml

@@ -0,0 +1,101 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vectorwaves"
+dynamic = ["version"]
+description = "Three-dimensional electromagnetic field simulation and topology analysis"
+authors = [
+  { name = "Mayank Soni" }
+]
+readme = "README_PyPi.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+
+# CORE DEPENDENCIES
+# These are strictly required for the physics pipeline to function.
+dependencies = [
+  "numpy>=1.24.0",
+  "scipy>=1.10.0",
+  "numba>=0.59.0" 
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+
+    "License :: OSI Approved :: MIT License",
+
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+
+    "Operating System :: OS Independent",
+
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Scientific/Engineering",
+]
+
+keywords = [
+    "physics",
+    "optics",
+    "wave-optics",
+    "vector-optics",
+    "electromagnetism",
+    "electromagnetic-fields",
+    "structured-light",
+    "gaussian-beams",
+    "laguerre-gaussian",
+    "plane-wave-expansion",
+    "computational-physics",
+    "optical-singularities",
+    "polarization-singularities",
+    "phase-singularities",
+    "topological-optics",
+    "optical-vortices"
+]
+
+[project.optional-dependencies]
+# VISUALIZATION: Plotting k-space, profiles, and tutorials
+viz = [
+  "matplotlib>=3.7.0",
+  "pyvista>=0.40.0"
+]
+
+# PROGRESS: Console loading bars
+progress = [
+  "tqdm>=4.65.0"
+]
+
+# GPU: CuPy for CUDA 12.x (Note: Users with AMD or older CUDA will need to install their specific cupy build)
+gpu = [
+  "cupy-cuda12x>=12.0.0"
+]
+
+# ALL optional dependencies
+all = [
+  "matplotlib>=3.7.0",
+  "pyvista>=0.40.0",
+  "tqdm>=4.65.0",
+  "cupy-cuda12x>=12.0.0"
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "vectorwaves.version.current_version_str" }
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.urls]
+Homepage = "https://github.com/1Rayokelvin/VectorWaves"
+Repository = "https://github.com/1Rayokelvin/VectorWaves"
+Issues = "https://github.com/1Rayokelvin/VectorWaves/issues"
+Documentation = "https://1rayokelvin.github.io/VectorWaves" 

vectorwaves-1.0.0/setup.cfg

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

vectorwaves-1.0.0/src/vectorwaves/__init__.py

@@ -0,0 +1,88 @@
+"""
+VectorWaves - A Python library for electromagnetic field simulations using plane wave expansion.
+==========================================================================
+
+Main workflow:
+    >>> import vectorwaves as vw
+    >>> config = vw.get_config()
+    >>> config.source.num_modes = 10000
+    >>> expt = vw.setup_engine(config)
+    >>> result = expt.compute_on_op(z=0.0)
+
+Author: Mayank Soni
+Year: 2026
+"""
+from .version import current_version, current_version_str
+__version_info__ = current_version
+__version__ = current_version_str
+
+# Core configuration
+from .config_stuff import (
+    Config,
+    OpConfig,
+    SourceConfig,
+    RandomizeConfig,
+    KSpaceConfig,
+    PolychromaticConfig,
+    get_config,
+    load_config
+)
+
+# Core Pipeline
+from .beam_stuff import BeamMaker, Beam
+from .engine_stuff import FieldEngine, FieldResult, tqdm
+
+# Utilities & Physics Math
+from .utils import (
+    get_stokes_params,
+    get_pol_ellipse_params,
+    decompose_in_basis,
+)
+
+# Singularity Finders
+from .singularities import SingularityFinder
+
+def setup_beam(config: Config) -> Beam:
+    """High-level wrapper to generate the beam from config object."""
+    return BeamMaker(config).generate_beam()
+
+def setup_engine(config: Config) -> FieldEngine:
+    """
+    High-level wrapper to generate the beam and initialize the computation engine.
+    """
+    return FieldEngine(setup_beam(config), config)
+
+__all__ =[
+    # Config
+    "Config",
+    "OpConfig", 
+    "SourceConfig",
+    "RandomizeConfig",
+    "KSpaceConfig",
+    "PolychromaticConfig",
+    "get_config",
+    "load_config",
+    
+    # Engine Pipeline
+    "setup_engine",
+    "setup_beam",
+    "BeamMaker",
+    "Beam",
+    "FieldEngine",
+    "FieldResult",
+    
+    # Utilities
+    "get_stokes_params",
+    "get_pol_ellipse_params", 
+    "decompose_in_basis",
+
+    # Topologies
+    "SingularityFinder",
+
+    # tqdm
+    "tqdm",
+    
+    # Version
+    "__version__",
+    "__version_info__"
+]

vectorwaves-1.0.0/src/vectorwaves/backends/cupy_backend.py

@@ -0,0 +1,197 @@
+import numpy as np
+try:
+    import cupy as cp
+    has_cupy = True
+except ImportError:
+    has_cupy = False
+
+class CupyMethods:
+    def __init__(self, beam, use_single_precision=True):
+        if not has_cupy:
+            raise RuntimeError("CuPy/CUDA not found.")
+            
+        self.use_single = use_single_precision
+        self.real_dt = cp.float32   if self.use_single else cp.float64
+        self.comp_dt = cp.complex64 if self.use_single else cp.complex128
+
+        # --- Persistent Model Data ---
+        def to_gpu(arr, dtype): return cp.ascontiguousarray(cp.asarray(arr, dtype=dtype))
+
+        self.kx = to_gpu(beam.k[0], self.real_dt)
+        self.ky = to_gpu(beam.k[1], self.real_dt)
+        self.kz = to_gpu(beam.k[2], self.real_dt)
+        self.w  = to_gpu(beam.w, self.real_dt)
+        self.inv_w = to_gpu(beam.inv_w, self.real_dt)
+        self.c_base = to_gpu(beam.c, self.comp_dt)
+        self.num_waves = len(self.w)
+        
+        self._kernel_cache = {}
+
+    def _get_kernel(self, num_components, is_grid=False):
+        key = (num_components, is_grid)
+        if key in self._kernel_cache: return self._kernel_cache[key]
+
+        real_t = "float" if self.use_single else "double"
+        comp_t = "complex<float>" if self.use_single else "complex<double>"
+        sincos_f = "sincosf" if self.use_single else "sincos"
+
+        coord_logic = """
+            int ix = p % nx;
+            int iy = p / nx;
+            {real_t} px = x_vec[ix];
+            {real_t} py = y_vec[iy];
+            {real_t} pz = z_scalar;
+        """ if is_grid else """
+            {real_t} px = x_vec[p];
+            {real_t} py = y_vec[p];
+            {real_t} pz = z_vec[p];
+        """
+
+        kernel_code = f"""
+        #include <cupy/complex.cuh>
+        extern "C" __global__
+        void compute_kernel(
+            const {real_t}* __restrict__ x_vec, const {real_t}* __restrict__ y_vec, const {real_t}* __restrict__ z_vec,
+            const {real_t}* __restrict__ kx, const {real_t}* __restrict__ ky, const {real_t}* __restrict__ kz, 
+            const {real_t}* __restrict__ w, const {comp_t}* __restrict__ super_vec,
+            {comp_t}* __restrict__ out,
+            {real_t} z_scalar, {real_t} t, int nx, int num_pts, int num_waves
+        ) {{
+            int p = blockDim.x * blockIdx.x + threadIdx.x;
+            if (p >= num_pts) return;
+
+            {coord_logic.format(real_t=real_t)}
+            
+            {comp_t} acc[{num_components}];
+            #pragma unroll
+            for(int i=0; i<{num_components}; i++) acc[i] = {comp_t}(0, 0);
+
+            for (int i = 0; i < num_waves; i++) {{
+                {real_t} phase = kx[i]*px + ky[i]*py + kz[i]*pz - w[i]*t;
+                {real_t} s, c;
+                {sincos_f}(phase, &s, &c);
+                {comp_t} wf(c, s);
+
+                #pragma unroll
+                for (int j = 0; j < {num_components}; j++) {{
+                    acc[j] += super_vec[i * {num_components} + j] * wf;
+                }}
+            }}
+
+            for (int j = 0; j < {num_components}; j++) {{
+                out[j * num_pts + p] = acc[j];
+            }}
+        }}
+        """
+        kernel = cp.RawKernel(kernel_code, 'compute_kernel')
+        self._kernel_cache[key] = kernel
+        return kernel
+
+    def _prepare_super_vec(self, need_b, need_derivs):
+        vecs = [self.c_base]
+        if need_b:
+            bx = (self.ky * self.c_base[2] - self.kz * self.c_base[1]) * self.inv_w
+            by = (self.kz * self.c_base[0] - self.kx * self.c_base[2]) * self.inv_w
+            bz = (self.kx * self.c_base[1] - self.ky * self.c_base[0]) * self.inv_w
+            vecs.append(cp.stack([bx, by, bz]))
+        if need_derivs:
+            ik = 1j * cp.stack([self.kx, self.ky, self.kz])
+            for i in range(3): vecs.append(self.c_base * ik[i])
+        
+        return cp.ascontiguousarray(cp.vstack(vecs).T)
+
+    def compute_grid(self, x_vec, y_vec, z, t, need_b=True, need_derivs=True, progress_callback=None):
+        nx, ny = len(x_vec), len(y_vec)
+        
+        super_vec = self._prepare_super_vec(need_b, need_derivs)
+        num_comps = super_vec.shape[1]
+        kernel = self._get_kernel(num_comps, is_grid=True)
+
+        # Pre-allocate the final CPU array to store results
+        out_h = np.zeros((num_comps, ny, nx), dtype=np.complex128)
+
+        # Move the X vector to GPU once
+        x_g = cp.asarray(x_vec, dtype=self.real_dt)
+
+        # Target ~500MB maximum VRAM footprint for the output buffer
+        bytes_per_element = 8 if self.use_single else 16
+        bytes_per_row = nx * num_comps * bytes_per_element
+        MAX_VRAM_BYTES = 1000 * 1024 * 1024 # 1 GB
+        
+        # Calculate how many rows we can safely process at once
+        rows_per_batch = max(1, MAX_VRAM_BYTES // bytes_per_row)
+
+        for i in range(0, ny, rows_per_batch):
+            end = min(i + rows_per_batch, ny)
+            cur_ny = end - i
+            cur_pts = nx * cur_ny
+
+            # Move just this chunk of Y coordinates to GPU
+            y_g = cp.asarray(y_vec[i:end], dtype=self.real_dt)
+            
+            # Allocate GPU buffer for just this batch
+            out_g = cp.empty((num_comps, cur_pts), dtype=self.comp_dt)
+
+            threads = 256
+            blocks = (cur_pts + threads - 1) // threads
+            
+            kernel((blocks,), (threads,), (
+                x_g, y_g, None, self.kx, self.ky, self.kz, self.w, 
+                super_vec, out_g, 
+                self.real_dt(z), self.real_dt(t), cp.int32(nx), cp.int32(cur_pts), cp.int32(self.num_waves)
+            ))
+
+            # Fetch result to CPU and reshape directly into the pre-allocated CPU array
+            out_h[:, i:end, :] = out_g.get().reshape(num_comps, cur_ny, nx)
+            
+            if progress_callback: 
+                progress_callback(cur_ny)
+    
+        # Unpack the CPU array into standard shapes
+        E = out_h[0:3]
+        idx = 3
+        B = out_h[idx:idx+3] if need_b else None
+        if need_b: idx += 3
+        D = (out_h[idx:idx+3], out_h[idx+3:idx+6], out_h[idx+6:idx+9]) if need_derivs else (None,None,None)
+        
+        return E, D, B
+        
+    def compute_cloud(self, x, y, z, t, need_b=True, need_derivs=True, progress_callback=None):
+        num_pts = len(x)
+        super_vec = self._prepare_super_vec(need_b, need_derivs)
+        num_comps = super_vec.shape[1]
+        kernel = self._get_kernel(num_comps, is_grid=False)
+
+        E_h, B_h, dx_h, dy_h, dz_h = self._allocate_cpu_arrays((num_pts,))
+        CHUNK = 500_000
+
+        for s in range(0, num_pts, CHUNK):
+            e = min(s + CHUNK, num_pts)
+            cur_n = e - s
+            x_g, y_g, z_g = [cp.asarray(arr[s:e], dtype=self.real_dt) for arr in [x,y,z]]
+            out_g = cp.empty((num_comps, cur_n), dtype=self.comp_dt)
+
+            kernel(((cur_n+255)//256,), (256,), (
+                x_g, y_g, z_g, self.kx, self.ky, self.kz, self.w, 
+                super_vec, out_g, 0.0, self.real_dt(t), 0, cp.int32(cur_n), cp.int32(self.num_waves)
+            ))
+
+            out_c = out_g.get()
+            if progress_callback: progress_callback(cur_n)
+            E_h[:, s:e] = out_c[0:3]
+            idx = 3
+            if need_b: B_h[:, s:e] = out_c[idx:idx+3]; idx += 3
+            if need_derivs:
+                dx_h[:, s:e], dy_h[:, s:e], dz_h[:, s:e] = out_c[idx:idx+3], out_c[idx+3:idx+6], out_c[idx+6:idx+9]
+        
+        return E_h, (dx_h, dy_h, dz_h) if need_derivs else (None,None,None), B_h if need_b else None
+
+    def _allocate_cpu_arrays(self, shape):
+        return tuple(np.zeros((3, *shape), dtype=np.complex128) for _ in range(5))
+
+    def compute_point(self, x, y, z, t, need_b=True, need_derivs=True):
+        E, D, B = self.compute_cloud(np.array([x]), np.array([y]), np.array([z]), t, need_b, need_derivs)
+        return E[:,0], (tuple(d[:,0] for d in D) if need_derivs else (None,None,None)), (B[:,0] if need_b else None) # type: ignore
+    
+    def __del__(self):
+        self._kernel_cache.clear()