voxcity.simulator_gpu.solar.raytracing ====================================== .. py:module:: voxcity.simulator_gpu.solar.raytracing .. autoapi-nested-parse:: Ray tracing module for solar simulation. This module provides the RayTracer class for GPU-accelerated radiation calculations. Shared ray tracing functions are imported from simulator_gpu.raytracing. Usage: from .raytracing import RayTracer, ray_voxel_first_hit, ray_canopy_absorption Classes ------- .. toctree:: :hidden: /autoapi/voxcity/simulator_gpu/solar/raytracing/RayTracer .. autoapisummary:: voxcity.simulator_gpu.solar.raytracing.RayTracer Functions --------- .. autoapisummary:: voxcity.simulator_gpu.solar.raytracing.ray_aabb_intersect voxcity.simulator_gpu.solar.raytracing.ray_voxel_first_hit voxcity.simulator_gpu.solar.raytracing.ray_canopy_absorption voxcity.simulator_gpu.solar.raytracing.ray_voxel_transmissivity voxcity.simulator_gpu.solar.raytracing.ray_trace_to_target voxcity.simulator_gpu.solar.raytracing.ray_point_to_point_transmissivity voxcity.simulator_gpu.solar.raytracing.sample_hemisphere_direction voxcity.simulator_gpu.solar.raytracing.hemisphere_solid_angle Module Contents --------------- .. py:function:: ray_aabb_intersect(ray_origin: voxcity.simulator_gpu.core.Vector3, ray_dir: voxcity.simulator_gpu.core.Vector3, box_min: voxcity.simulator_gpu.core.Vector3, box_max: voxcity.simulator_gpu.core.Vector3, t_min: taichi.f32, t_max: taichi.f32) Ray-AABB intersection using slab method. :param ray_origin: Ray origin point :param ray_dir: Ray direction (normalized) :param box_min: AABB minimum corner :param box_max: AABB maximum corner :param t_min: Minimum t value :param t_max: Maximum t value :returns: Tuple of (hit, t_enter, t_exit) .. py:function:: ray_voxel_first_hit(ray_origin: voxcity.simulator_gpu.core.Vector3, ray_dir: voxcity.simulator_gpu.core.Vector3, is_solid: ti.template(), nx: taichi.i32, ny: taichi.i32, nz: taichi.i32, dx: taichi.f32, dy: taichi.f32, dz: taichi.f32, max_dist: taichi.f32) 3D-DDA ray marching to find first solid voxel hit. :param ray_origin: Ray origin :param ray_dir: Ray direction (normalized) :param is_solid: 3D field of solid cells :param nx: Grid dimensions :param ny: Grid dimensions :param nz: Grid dimensions :param dx: Cell sizes :param dy: Cell sizes :param dz: Cell sizes :param max_dist: Maximum ray distance :returns: Tuple of (hit, t_hit, ix, iy, iz) .. py:function:: ray_canopy_absorption(ray_origin: voxcity.simulator_gpu.core.Vector3, ray_dir: voxcity.simulator_gpu.core.Vector3, lad: ti.template(), is_solid: ti.template(), nx: taichi.i32, ny: taichi.i32, nz: taichi.i32, dx: taichi.f32, dy: taichi.f32, dz: taichi.f32, max_dist: taichi.f32, ext_coef: taichi.f32) Trace ray through canopy computing Beer-Lambert absorption. :param ray_origin: Ray origin :param ray_dir: Ray direction (normalized) :param lad: 3D field of Leaf Area Density :param is_solid: 3D field of solid cells (buildings/terrain) :param nx: Grid dimensions :param ny: Grid dimensions :param nz: Grid dimensions :param dx: Cell sizes :param dy: Cell sizes :param dz: Cell sizes :param max_dist: Maximum ray distance :param ext_coef: Extinction coefficient :returns: Tuple of (transmissivity, path_length_through_canopy) .. py:function:: ray_voxel_transmissivity(ray_origin: voxcity.simulator_gpu.core.Vector3, ray_dir: voxcity.simulator_gpu.core.Vector3, is_solid: ti.template(), is_tree: ti.template(), nx: taichi.i32, ny: taichi.i32, nz: taichi.i32, dx: taichi.f32, dy: taichi.f32, dz: taichi.f32, max_dist: taichi.f32, tree_k: taichi.f32, tree_lad: taichi.f32) 3D-DDA ray marching with tree canopy transmissivity calculation. :param ray_origin: Ray origin :param ray_dir: Ray direction (normalized) :param is_solid: 3D field of solid cells (buildings, ground) :param is_tree: 3D field of tree cells :param nx: Grid dimensions :param ny: Grid dimensions :param nz: Grid dimensions :param dx: Cell sizes :param dy: Cell sizes :param dz: Cell sizes :param max_dist: Maximum ray distance :param tree_k: Tree extinction coefficient :param tree_lad: Leaf area density :returns: Tuple of (blocked_by_solid, transmissivity) - blocked_by_solid: 1 if ray hit solid, 0 otherwise - transmissivity: 0-1 fraction of light that gets through trees .. py:function:: ray_trace_to_target(origin: voxcity.simulator_gpu.core.Vector3, target: voxcity.simulator_gpu.core.Vector3, is_solid: ti.template(), is_tree: ti.template(), nx: taichi.i32, ny: taichi.i32, nz: taichi.i32, dx: taichi.f32, dy: taichi.f32, dz: taichi.f32, tree_att: taichi.f32, att_cutoff: taichi.f32) Trace ray from origin to target, checking for visibility. :param origin: Start position (in voxel coordinates) :param target: End position (in voxel coordinates) :param is_solid: 3D field of solid cells :param is_tree: 3D field of tree cells :param nx: Grid dimensions :param ny: Grid dimensions :param nz: Grid dimensions :param dx: Cell sizes (typically all 1.0 for voxel coords) :param dy: Cell sizes (typically all 1.0 for voxel coords) :param dz: Cell sizes (typically all 1.0 for voxel coords) :param tree_att: Attenuation factor per voxel for trees :param att_cutoff: Minimum transmissivity before considering blocked :returns: 1 if target is visible, 0 otherwise .. py:function:: ray_point_to_point_transmissivity(pos_from: voxcity.simulator_gpu.core.Vector3, pos_to: voxcity.simulator_gpu.core.Vector3, lad: ti.template(), is_solid: ti.template(), nx: taichi.i32, ny: taichi.i32, nz: taichi.i32, dx: taichi.f32, dy: taichi.f32, dz: taichi.f32, ext_coef: taichi.f32) Compute transmissivity of radiation between two points through canopy. This is used for surface-to-surface reflections where reflected radiation must pass through any intervening vegetation. :param pos_from: Start position (emitting surface center) :param pos_to: End position (receiving surface center) :param lad: 3D field of Leaf Area Density :param is_solid: 3D field of solid cells (buildings/terrain) :param nx: Grid dimensions :param ny: Grid dimensions :param nz: Grid dimensions :param dx: Cell sizes :param dy: Cell sizes :param dz: Cell sizes :param ext_coef: Extinction coefficient :returns: Tuple of (transmissivity, blocked_by_solid) - transmissivity: 0-1 fraction of radiation that gets through - blocked_by_solid: 1 if ray hits a solid cell, 0 otherwise .. py:function:: sample_hemisphere_direction(i_azim: taichi.i32, i_elev: taichi.i32, n_azim: taichi.i32, n_elev: taichi.i32) -> voxcity.simulator_gpu.core.Vector3 Generate a direction on the upper hemisphere. :param i_azim: Azimuthal index (0 to n_azim-1) :param i_elev: Elevation index (0 to n_elev-1) :param n_azim: Number of azimuthal divisions :param n_elev: Number of elevation divisions :returns: Unit direction vector .. py:function:: hemisphere_solid_angle(i_elev: taichi.i32, n_azim: taichi.i32, n_elev: taichi.i32) -> taichi.f32 Calculate solid angle for a hemisphere segment.