raystrack 1.0.1__py3-none-any.whl

raystrack/params.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any, Dict
+
+
+@dataclass
+class MatrixParams:
+    """Configuration for scene-to-scene view-factor solves.
+
+    Parameters
+    ----------
+    samples : int
+        Quasi-Monte Carlo grid per side used for emission per emitter.
+    rays : int
+        Rays per grid cell.
+    seed : int
+        Base RNG seed. Each emitter/iteration derives its own sub-seed.
+    bvh : {"auto","off","builtin"}
+        Toggle a built-in BVH for faster visibility.
+    device : {"auto","gpu","cpu"}
+        Visibility device. GPU uses CUDA hitmask kernels. CPU uses numba njit.
+    cuda_async : bool
+        Use pinned memory + streams for overlap on CUDA.
+    gpu_raygen : bool
+        Generate rays on GPU to avoid H2D copies of rays.
+    max_iters : int
+        Maximum number of Monte-Carlo iterations.
+    tol : float
+        Convergence tolerance. Interpretation depends on ``tol_mode``.
+    tol_mode : {"delta", "stderr"}
+        - "delta": stop when successive cumulative estimates change by < tol.
+        - "stderr": stop when per-iteration replicate standard error is <= tol.
+    min_iters : int
+        Minimum number of Monte-Carlo iterations before a convergence check.
+    convergence_interval : int
+        Check convergence every N iterations. Values > 1 mainly help the CUDA
+        path by reducing host-side convergence work.
+    reciprocity : bool
+        Also compute inverse view factors via reciprocity.
+    enforce_reciprocity_rowsum : bool
+        After computation, enforce reciprocity and make each row sum to 1 using
+        symmetric diagonal scaling.
+    flip_faces : bool
+        If True, flip emitter triangle winding during emission sampling.
+    """
+    samples: int = 16
+    rays: int = 128
+    seed: int = 1
+    bvh: str = "auto"
+    device: str = "auto"
+    cuda_async: bool = True
+    gpu_raygen: bool = True
+    max_iters: int = 100
+    tol: float = 1e-4
+    tol_mode: str = "stderr"
+    min_iters: int = 5
+    convergence_interval: int = 1
+    reciprocity: bool = True
+    enforce_reciprocity_rowsum: bool = False
+    flip_faces: bool = False
+
+    def as_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MatrixParams":
+        return cls(**data)
+
+
+@dataclass
+class SkyParams:
+    """Configuration for merged sky view-factor solves.
+
+    Parameters
+    ----------
+    samples : int
+        Quasi-Monte Carlo grid per side used for emission per emitter.
+    rays : int
+        Rays per grid cell.
+    seed : int
+        Base RNG seed. Each emitter/iteration derives its own sub-seed.
+    bvh : {"auto","off","builtin"}
+        Toggle a built-in BVH for faster visibility.
+    device : {"auto","gpu","cpu"}
+        Visibility device. GPU uses CUDA hitmask kernels. CPU uses numba njit.
+    cuda_async : bool
+        Use pinned memory + streams for overlap on CUDA.
+    gpu_raygen : bool
+        Generate rays on GPU to avoid H2D copies of rays.
+    max_iters : int
+        Maximum number of Monte-Carlo iterations.
+    tol : float
+        Convergence tolerance. Interpretation depends on ``tol_mode``.
+    tol_mode : {"delta", "stderr"}
+        - "delta": stop when successive cumulative estimates change by < tol.
+        - "stderr": stop when per-iteration replicate standard error is <= tol.
+    min_iters : int
+        Minimum number of Monte-Carlo iterations before a convergence check.
+    convergence_interval : int
+        Check convergence every N iterations. Values > 1 mainly help the CUDA
+        path by reducing host-side convergence work.
+    discrete : bool
+        If True, return 145 directional patches. If False, return a single
+        merged "Sky" entry.
+    """
+    samples: int = 16
+    rays: int = 128
+    seed: int = 1
+    bvh: str = "auto"
+    device: str = "auto"
+    cuda_async: bool = True
+    gpu_raygen: bool = True
+    max_iters: int = 100
+    tol: float = 1e-4
+    tol_mode: str = "stderr"
+    min_iters: int = 5
+    convergence_interval: int = 1
+    discrete: bool = False
+
+    def as_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SkyParams":
+        return cls(**data)
+
+
+__all__ = ["MatrixParams", "SkyParams"]

raystrack/utils/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+"""Utility subpackage exports.
+
+This module re-exports commonly used helpers so callers can do:
+    from raystrack.utils import cached_halton, flatten_receivers, build_rays
+
+Keeping imports light: avoid importing CUDA-specific modules here so that the
+package imports cleanly on systems without CUDA. Heavy modules are loaded on
+first use by their direct importers.
+"""
+
+# Lightweight, CPU-safe helpers
+from .halton import cached_halton  # noqa: F401
+from .geometry import flatten_receivers, flip_meshes  # noqa: F401
+from .ray_builder import build_rays  # noqa: F401
+
+__all__ = [
+    "cached_halton",
+    "flatten_receivers",
+    "flip_meshes",
+    "build_rays",
+]

raystrack/utils/bvh.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+import numpy as np
+
+LEAF_SIZE = 8  # triangles per leaf
+
+
+def _tri_bounds(p0: np.ndarray, p1: np.ndarray, p2: np.ndarray):
+    bmin = np.minimum(np.minimum(p0, p1), p2)
+    bmax = np.maximum(np.maximum(p0, p1), p2)
+    centroid = (p0 + p1 + p2) / 3.0
+    return bmin.astype(np.float32), bmax.astype(np.float32), centroid.astype(np.float32)
+
+
+def build_bvh(v0: np.ndarray, e1: np.ndarray, e2: np.ndarray,
+              leaf_size: int = LEAF_SIZE):
+    """Return BVH arrays and triangle permutation."""
+    m = v0.shape[0]
+    tmin = np.empty((m, 3), np.float32)
+    tmax = np.empty((m, 3), np.float32)
+    cent = np.empty((m, 3), np.float32)
+    for i in range(m):
+        p0 = v0[i]
+        p1 = v0[i] + e1[i]
+        p2 = v0[i] + e2[i]
+        bmin, bmax, c = _tri_bounds(p0, p1, p2)
+        tmin[i] = bmin
+        tmax[i] = bmax
+        cent[i] = c
+
+    bb_min, bb_max = [], []
+    left, right = [], []
+    start, count = [], []
+    order: list[int] = []
+
+    def add_node(idxs: np.ndarray) -> int:
+        node = len(bb_min)
+        bb_min.append(np.zeros(3, np.float32))
+        bb_max.append(np.zeros(3, np.float32))
+        left.append(-1)
+        right.append(-1)
+        start.append(0)
+        count.append(0)
+
+        bmin = tmin[idxs].min(axis=0)
+        bmax = tmax[idxs].max(axis=0)
+        bb_min[node][:] = bmin
+        bb_max[node][:] = bmax
+
+        if len(idxs) <= leaf_size:
+            start[node] = len(order)
+            count[node] = len(idxs)
+            order.extend(idxs.tolist())
+        else:
+            ext = bmax - bmin
+            axis = int(np.argmax(ext))
+            idxs_sorted = idxs[np.argsort(cent[idxs, axis])]
+            mid = idxs_sorted.size // 2
+            l = add_node(idxs_sorted[:mid])
+            r = add_node(idxs_sorted[mid:])
+            left[node] = l
+            right[node] = r
+        return node
+
+    add_node(np.arange(m, dtype=np.int32))
+    perm = np.array(order, dtype=np.int32)
+    return (np.asarray(bb_min, np.float32),
+            np.asarray(bb_max, np.float32),
+            np.asarray(left, np.int32),
+            np.asarray(right, np.int32),
+            np.asarray(start, np.int32),
+            np.asarray(count, np.int32),
+            perm)
+
+__all__ = ["build_bvh", "LEAF_SIZE"]