vectorwaves 1.0.0__py3-none-any.whl

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/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()

vectorwaves/backends/numba_backend.py

@@ -0,0 +1,271 @@
+import numpy as np
+import time; from dataclasses import dataclass
+
+try: 
+    from numba import jit, prange
+    has_numba = True
+except ImportError:
+    def jit(*args, **kwargs): 
+        def decor(f): return f
+        return decor
+    prange = range
+    has_numba = False
+
+K_ARGS = {'nopython': True, 'parallel': True, 'fastmath': True, 'cache': True}
+
+@jit(**K_ARGS)
+def _kernel_grid_rect(x_vec, y_vec, z, t, kx, ky, kz, cx, cy, cz, w, inv_w, 
+                      need_b, need_derivs, 
+                      E_out, B_out, dx_out, dy_out, dz_out):
+    nx, ny = len(x_vec), len(y_vec)
+    num_waves = len(w)
+
+    for iy in prange(ny):
+        y = y_vec[iy]
+        for ix in range(nx):
+            x = x_vec[ix]
+            
+            ex, ey, ez = 0j, 0j, 0j
+            bx, by, bz = 0j, 0j, 0j
+            dxx, dxy, dxz, dyx, dyy, dyz, dzx, dzy, dzz = 0j,0j,0j,0j,0j,0j,0j,0j,0j
+
+            if not need_b and not need_derivs:
+                for i in range(num_waves):
+                    wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                    ex += cx[i] * wf; ey += cy[i] * wf; ez += cz[i] * wf
+
+            elif need_b and not need_derivs:
+                for i in range(num_waves):
+                    wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                    c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                    ex += c_x; ey += c_y; ez += c_z
+
+                    bx += (ky[i]*c_z - kz[i]*c_y) * inv_w[i]
+                    by += (kz[i]*c_x - kx[i]*c_z) * inv_w[i]
+                    bz += (kx[i]*c_y - ky[i]*c_x) * inv_w[i]
+
+            elif not need_b and need_derivs:
+                for i in range(num_waves):
+                    wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                    c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                    ex += c_x; ey += c_y; ez += c_z
+
+                    ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+                    dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+                    dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+                    dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+            else: # need_b AND need_derivs
+                for i in range(num_waves):
+                    wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                    c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                    ex += c_x; ey += c_y; ez += c_z
+
+                    bx += (ky[i]*c_z - kz[i]*c_y) * inv_w[i]
+                    by += (kz[i]*c_x - kx[i]*c_z) * inv_w[i]
+                    bz += (kx[i]*c_y - ky[i]*c_x) * inv_w[i]
+
+                    ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+                    dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+                    dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+                    dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+            E_out[0, iy, ix], E_out[1, iy, ix], E_out[2, iy, ix] = ex, ey, ez
+
+            if need_b:
+                B_out[0, iy, ix], B_out[1, iy, ix], B_out[2, iy, ix] = bx, by, bz
+
+            if need_derivs:
+                dx_out[0, iy, ix], dx_out[1, iy, ix], dx_out[2, iy, ix] = dxx, dxy, dxz
+                dy_out[0, iy, ix], dy_out[1, iy, ix], dy_out[2, iy, ix] = dyx, dyy, dyz
+                dz_out[0, iy, ix], dz_out[1, iy, ix], dz_out[2, iy, ix] = dzx, dzy, dzz
+
+@jit(**K_ARGS)
+def _kernel_cloud_flat(x_arr, y_arr, z_arr, t, kx, ky, kz, cx, cy, cz, w, inv_w, 
+                  need_b, need_derivs, 
+                  E_out, B_out, dx_out, dy_out, dz_out):
+    num_points = len(x_arr)
+    num_waves = len(w)
+
+    for p in prange(num_points):
+        x, y, z = x_arr[p], y_arr[p], z_arr[p]
+        ex, ey, ez = 0j, 0j, 0j
+        bx, by, bz = 0j, 0j, 0j
+        dxx, dxy, dxz, dyx, dyy, dyz, dzx, dzy, dzz = 0j,0j,0j,0j,0j,0j,0j,0j,0j
+
+        if not need_b and not need_derivs:
+            for i in range(num_waves):
+                wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                ex += cx[i] * wf; ey += cy[i] * wf; ez += cz[i] * wf
+
+        elif need_b and not need_derivs:
+            for i in range(num_waves):
+                wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                ex += c_x; ey += c_y; ez += c_z
+
+                bx += (ky[i]*c_z - kz[i]*c_y)*inv_w[i]
+                by += (kz[i]*c_x - kx[i]*c_z)*inv_w[i]
+                bz += (kx[i]*c_y - ky[i]*c_x)*inv_w[i]
+
+        elif not need_b and need_derivs:
+            for i in range(num_waves):
+                wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                ex += c_x; ey += c_y; ez += c_z
+                
+                ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+                dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+                dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+                dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+        else:
+            for i in range(num_waves):
+                wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+                c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+                ex += c_x; ey += c_y; ez += c_z
+
+                bx += (ky[i]*c_z - kz[i]*c_y)*inv_w[i]
+                by += (kz[i]*c_x - kx[i]*c_z)*inv_w[i]
+                bz += (kx[i]*c_y - ky[i]*c_x)*inv_w[i]
+
+                ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+                dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+                dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+                dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+        E_out[0, p], E_out[1, p], E_out[2, p] = ex, ey, ez
+
+        if need_b: B_out[0, p], B_out[1, p], B_out[2, p] = bx, by, bz
+
+        if need_derivs:
+            dx_out[0,p], dx_out[1,p], dx_out[2,p] = dxx, dxy, dxz
+            dy_out[0,p], dy_out[1,p], dy_out[2,p] = dyx, dyy, dyz
+            dz_out[0,p], dz_out[1,p], dz_out[2,p] = dzx, dzy, dzz
+
+@jit(nopython=True, parallel=False, fastmath=True, cache=True)
+def _kernel_point(x, y, z, t, kx, ky, kz, cx, cy, cz, w, inv_w, need_b, need_derivs):
+    num_waves = len(w)
+    ex, ey, ez = 0j, 0j, 0j
+    bx, by, bz = 0j, 0j, 0j
+    dxx, dxy, dxz, dyx, dyy, dyz, dzx, dzy, dzz = 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j, 0j
+
+    if not need_b and not need_derivs:
+        for i in range(num_waves):
+            wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+            ex += cx[i] * wf; ey += cy[i] * wf; ez += cz[i] * wf
+
+    elif need_b and not need_derivs:
+        for i in range(num_waves):
+            wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+            c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+            ex += c_x; ey += c_y; ez += c_z
+
+            bx += (ky[i]*c_z - kz[i]*c_y)*inv_w[i]
+            by += (kz[i]*c_x - kx[i]*c_z)*inv_w[i]
+            bz += (kx[i]*c_y - ky[i]*c_x)*inv_w[i]
+
+    elif not need_b and need_derivs:
+        for i in range(num_waves):
+            wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+            c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+            ex += c_x; ey += c_y; ez += c_z
+
+            ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+            dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+            dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+            dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+    else:
+        for i in range(num_waves):
+            wf = np.exp(1j * (kx[i]*x + ky[i]*y + kz[i]*z - w[i]*t))
+            c_x, c_y, c_z = cx[i]*wf, cy[i]*wf, cz[i]*wf
+            ex += c_x; ey += c_y; ez += c_z
+
+            bx += (ky[i]*c_z - kz[i]*c_y)*inv_w[i]
+            by += (kz[i]*c_x - kx[i]*c_z)*inv_w[i]
+            bz += (kx[i]*c_y - ky[i]*c_x)*inv_w[i]
+
+            ikx, iky, ikz = 1j*kx[i], 1j*ky[i], 1j*kz[i]
+            dxx += ikx*c_x; dxy += ikx*c_y; dxz += ikx*c_z
+            dyx += iky*c_x; dyy += iky*c_y; dyz += iky*c_z
+            dzx += ikz*c_x; dzy += ikz*c_y; dzz += ikz*c_z
+
+    E = np.empty(3, dtype=np.complex128)
+    E[0], E[1], E[2] = ex, ey, ez
+
+    B = np.empty(3, dtype=np.complex128)
+    if need_b: B[0], B[1], B[2] = bx, by, bz
+
+    dx = np.empty(3, dtype=np.complex128)
+    dy = np.empty(3, dtype=np.complex128)
+    dz = np.empty(3, dtype=np.complex128)
+    if need_derivs:
+        dx[0], dx[1], dx[2] = dxx, dxy, dxz
+        dy[0], dy[1], dy[2] = dyx, dyy, dyz
+        dz[0], dz[1], dz[2] = dzx, dzy, dzz
+
+    return E, (dx, dy, dz), B
+
+class NumbaMethods:
+    def __init__(self, beam, max_points_per_batch=250_000):
+        self.kx, self.ky, self.kz = beam.k
+        self.cx, self.cy, self.cz = beam.c
+        self.w, self.inv_w = beam.w, beam.inv_w
+        self.max_batch_size = max_points_per_batch
+
+    def _allocate_arrays(self, shape):
+        return tuple(np.empty((3,*shape), dtype=np.complex128) for _ in range(5))
+        
+    def compute_cloud(self, x, y, z, t, need_b=True, need_derivs=True, progress_callback=None):
+        total_points = len(x)
+        batch_size = self.max_batch_size
+        if progress_callback: 
+            batch_size = min(self.max_batch_size, max(1, total_points // 5))
+
+        E, B, dx, dy, dz = self._allocate_arrays((total_points,))
+        
+        for i in range(0, total_points, batch_size):
+            end = min(i + batch_size, total_points)
+            _kernel_cloud_flat(
+                x[i:end], y[i:end], z[i:end], t, 
+                self.kx, self.ky, self.kz, self.cx, self.cy, self.cz, self.w, self.inv_w, 
+                need_b, need_derivs, 
+                E[:, i:end], B[:, i:end], dx[:,i:end], dy[:, i:end], dz[:, i:end]
+            )
+            if progress_callback: progress_callback(end - i) 
+            
+        D = (dx, dy, dz) if need_derivs else (None, None, None)
+        B = B if need_b else None
+
+        return E, D, B
+
+    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)
+        rows_per_batch = max(1, self.max_batch_size // nx)
+            
+        E, B, dx, dy, dz = self._allocate_arrays((ny, nx))
+        
+        for i in range(0, ny, rows_per_batch):
+            end = min(i + rows_per_batch, ny)
+            _kernel_grid_rect(
+                x_vec, y_vec[i:end], z, t, 
+                self.kx, self.ky, self.kz, self.cx, self.cy, self.cz, self.w, self.inv_w, 
+                need_b, need_derivs, 
+                E[:, i:end, :], B[:, i:end, :], dx[:, i:end, :], dy[:, i:end, :], dz[:, i:end, :]
+            )
+            if progress_callback: progress_callback(end - i)
+            
+        D = (dx, dy, dz) if need_derivs else (None, None, None)
+        B = B if need_b else None
+
+        return E, D, B
+    
+    def compute_point(self, x, y, z, t, need_b=True, need_derivs=True):
+        E, D, B = _kernel_point(
+            x, y, z, t, self.kx, self.ky, self.kz, self.cx, self.cy, self.cz, 
+            self.w, self.inv_w, need_b, need_derivs
+        )
+        if not need_derivs: D = (None, None, None)
+        if not need_b: B = None
+        return E, D, B