[1.3.63] 2026-01-21

- Updated docs to be mobile friendly with slide-out sidebar navigation and hamburger menu.

- Removed direct CUDA dependency; ray tracing now uses the CollisionDetection plugin for GPU acceleration.
- Renamed `calculateLeafAreaGPU()` to `calculateLeafArea()` (old methods deprecated but still available).
- Added `enableGPUAcceleration()` and `disableGPUAcceleration()` methods to control CollisionDetection GPU usage.
- Added adaptive triangulation filtering for multi-return data using separation ratio thresholds.
- Improved `gapfillMisses()` to track filled grid positions and avoid duplicate gap-filled points.

- Refined carbohydrate model with new parameters for structural vs non-structural carbon tracking (`carbohydrate_percentage`, `stem_structural_carbon_percentage`, `living_wood_fraction`, `dormant_respiration_fraction`) and separate upward/downward transfer thresholds.
- Added `vegetative_bud_break_probability_max` parameter to ShootParameters for controlling maximum bud break probability.
- Added `updateShootFruitCounts()` and `getShootInternodeObjectIDs()` methods.
- Added additional internode object data outputs for carbon model diagnostics (`carbohydrate_pool_molC`, `daily_net_photosynthesis`, `daily_respiration`, `daily_growth`).
- Added two new almond tree model variants: `almond_aldrich` and `almond_wood_colony`.

Author: bnbailey-psl

doc/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+# [1.3.63] 2026-01-21
+
+## Core
+- Updated docs to be mobile friendly with slide-out sidebar navigation and hamburger menu.
+
+## LiDAR
+- Removed direct CUDA dependency; ray tracing now uses the CollisionDetection plugin for GPU acceleration.
+- Renamed `calculateLeafAreaGPU()` to `calculateLeafArea()` (old methods deprecated but still available).
+- Added `enableGPUAcceleration()` and `disableGPUAcceleration()` methods to control CollisionDetection GPU usage.
+- Added adaptive triangulation filtering for multi-return data using separation ratio thresholds.
+- Improved `gapfillMisses()` to track filled grid positions and avoid duplicate gap-filled points.
+
+## Plant Architecture
+- Refined carbohydrate model with new parameters for structural vs non-structural carbon tracking (`carbohydrate_percentage`, `stem_structural_carbon_percentage`, `living_wood_fraction`, `dormant_respiration_fraction`) and separate upward/downward transfer thresholds.
+- Added `vegetative_bud_break_probability_max` parameter to ShootParameters for controlling maximum bud break probability.
+- Added `updateShootFruitCounts()` and `getShootInternodeObjectIDs()` methods.
+- Added additional internode object data outputs for carbon model diagnostics (`carbohydrate_pool_molC`, `daily_net_photosynthesis`, `daily_respiration`, `daily_growth`).
+- Added two new almond tree model variants: `almond_aldrich` and `almond_wood_colony`.
+
 # [1.3.62] 2026-01-12
 
 ## Core

doc/assets/custom.css

@@ -53,4 +53,155 @@ html {
 #searchbox-container doxygen-awesome-dark-mode-toggle,
 #titlearea tr:has(> td > #MSearchBox) doxygen-awesome-dark-mode-toggle {
     flex: 0 0 auto;
+}
+
+/* ============================================
+   Nav Tree Arrowhead Styles (missing from older doxygen-awesome)
+   ============================================ */
+
+/* Arrowhead triangle for expandable nav items */
+span.arrowhead {
+    display: inline-block;
+    width: 0;
+    height: 0;
+    border-left: 4px solid transparent;
+    border-right: 4px solid transparent;
+    border-top: 6px solid var(--primary-light-color);
+    vertical-align: middle;
+    margin-right: 4px;
+    transition: transform var(--animation-duration) ease-out;
+}
+
+/* Closed state - arrow points right */
+span.arrowhead.closed {
+    transform: rotate(-90deg);
+}
+
+/* Open state - arrow points down */
+span.arrowhead.opened {
+    transform: rotate(0deg);
+}
+
+/* Selected item arrowhead color */
+.selected span.arrowhead {
+    border-top-color: var(--primary-color);
+}
+
+/* ============================================
+   Mobile Navigation Sidebar Toggle
+   ============================================ */
+
+/* Mobile hamburger button - hidden on desktop, shown on mobile */
+#mobile-menu-btn {
+    display: none;
+    position: fixed;
+    top: 10px;
+    left: 10px;
+    z-index: 101;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    width: 44px;
+    height: 44px;
+    padding: 10px;
+    background: var(--page-background-color);
+    border: 1px solid var(--separator-color);
+    border-radius: var(--border-radius-medium);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+    cursor: pointer;
+    gap: 5px;
+}
+
+#mobile-menu-btn span {
+    display: block;
+    width: 20px;
+    height: 2px;
+    background-color: var(--page-foreground-color);
+    border-radius: 1px;
+    transition: transform 0.3s ease, opacity 0.3s ease;
+}
+
+/* Hamburger to X animation when open */
+.mobile-sidebar-open #mobile-menu-btn span:nth-child(1) {
+    transform: translateY(7px) rotate(45deg);
+}
+
+.mobile-sidebar-open #mobile-menu-btn span:nth-child(2) {
+    opacity: 0;
+}
+
+.mobile-sidebar-open #mobile-menu-btn span:nth-child(3) {
+    transform: translateY(-7px) rotate(-45deg);
+}
+
+/* Mobile overlay - hidden by default */
+#mobile-nav-overlay {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 99;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+}
+
+/* Mobile-specific styles */
+@media screen and (max-width: 767px) {
+    /* Show hamburger button on mobile */
+    #mobile-menu-btn {
+        display: flex;
+    }
+
+    /* Override doxygen-awesome hiding the sidebar - make it a slide-out drawer */
+    #side-nav {
+        display: block !important;
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        bottom: 0 !important;
+        width: 280px !important;
+        max-width: 85vw !important;
+        z-index: 100 !important;
+        transform: translateX(-100%);
+        transition: transform 0.3s ease;
+        overflow-y: auto !important;
+        box-shadow: none;
+    }
+
+    /* Show sidebar when open */
+    .mobile-sidebar-open #side-nav {
+        transform: translateX(0);
+        box-shadow: 2px 0 8px rgba(0, 0, 0, 0.2);
+    }
+
+    /* Show and animate overlay when sidebar is open */
+    .mobile-sidebar-open #mobile-nav-overlay {
+        display: block;
+        opacity: 1;
+    }
+
+    /* Prevent body scroll when sidebar is open */
+    .mobile-sidebar-open {
+        overflow: hidden;
+    }
+
+    /* Ensure content doesn't shift */
+    #doc-content {
+        margin-left: 0 !important;
+        padding-top: 60px !important;
+    }
+
+    /* Hide titlearea inside sidebar on mobile - we only want nav tree */
+    #side-nav #titlearea {
+        display: none !important;
+    }
+
+    /* Ensure nav tree arrows are visible on hover in mobile sidebar */
+    #side-nav #nav-tree div.item:hover .arrow,
+    #side-nav #nav-tree a:focus .arrow {
+        opacity: 0.9 !important;
+    }
 }

doc/header.html

@@ -32,6 +32,35 @@
   DoxygenAwesomeTabs.init()
   DoxygenAwesomeInteractiveToc.init()
 </script>
+<script type="text/javascript">
+  // Mobile sidebar toggle functionality
+  function toggleMobileSidebar() {
+    var sidebar = document.getElementById('side-nav');
+    var overlay = document.getElementById('mobile-nav-overlay');
+    var menuBtn = document.getElementById('mobile-menu-btn');
+    var body = document.body;
+
+    if (sidebar && overlay && menuBtn) {
+      var isOpen = body.classList.contains('mobile-sidebar-open');
+      if (isOpen) {
+        body.classList.remove('mobile-sidebar-open');
+        menuBtn.setAttribute('aria-expanded', 'false');
+        menuBtn.setAttribute('aria-label', 'Open navigation menu');
+      } else {
+        body.classList.add('mobile-sidebar-open');
+        menuBtn.setAttribute('aria-expanded', 'true');
+        menuBtn.setAttribute('aria-label', 'Close navigation menu');
+      }
+    }
+  }
+
+  // Close sidebar on escape key
+  document.addEventListener('keydown', function(e) {
+    if (e.key === 'Escape' && document.body.classList.contains('mobile-sidebar-open')) {
+      toggleMobileSidebar();
+    }
+  });
+</script>
 <script>
     try {
         // Remove the stored “last visited page” so the tree always starts fresh
@@ -69,6 +98,16 @@
     gtag('config', 'G-3F0Y5Z6543');
 </script>
 <body>
+<!-- Mobile sidebar overlay -->
+<div id="mobile-nav-overlay" onclick="toggleMobileSidebar()"></div>
+
+<!-- Mobile hamburger menu button - must be outside #side-nav to avoid transform containment -->
+<button id="mobile-menu-btn" aria-label="Open navigation menu" onclick="toggleMobileSidebar()">
+  <span></span>
+  <span></span>
+  <span></span>
+</button>
+
 <!--BEGIN DISABLE_INDEX-->
   <!--BEGIN FULL_SIDEBAR-->
 <div id="side-nav" class="ui-resizable side-nav-resizable"><!-- do not remove this div, it is closed by doxygen! -->

plugins/collisiondetection/CMakeLists.txt

@@ -82,10 +82,10 @@ if(CUDAToolkit_FOUND)
     target_include_directories(collisiondetection PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
     target_link_libraries(collisiondetection PUBLIC CUDA::cudart_static)
-    
+
     # Define preprocessor macro to indicate CUDA support
     target_compile_definitions(collisiondetection PRIVATE HELIOS_CUDA_AVAILABLE)
-    
+
 else()
     message(STATUS "CUDA not found - building CPU-only version")
 

plugins/collisiondetection/include/CollisionDetection.h

@@ -1546,7 +1546,7 @@ class CollisionDetection {
      * \param[in] ray_origins Vector of ray origin points
      * \param[in] ray_directions Vector of ray direction vectors
      */
-    void calculateVoxelRayPathLengths_GPU(const std::vector<helios::vec3> &ray_origins, const std::vector<helios::vec3> &ray_directions);
+    bool calculateVoxelRayPathLengths_GPU(const std::vector<helios::vec3> &ray_origins, const std::vector<helios::vec3> &ray_directions);
 
     /**
      * \brief Validate voxel grid indices

plugins/collisiondetection/src/CollisionDetection.cpp

@@ -51,7 +51,7 @@ struct GPUBVHNode {
 extern "C" {
 void launchBVHTraversal(void *h_nodes, int node_count, unsigned int *h_primitive_indices, int primitive_count, float *h_primitive_aabb_min, float *h_primitive_aabb_max, float *h_query_aabb_min, float *h_query_aabb_max, int num_queries,
                         unsigned int *h_results, unsigned int *h_result_counts, int max_results_per_query);
-void launchVoxelRayPathLengths(int num_rays, float *h_ray_origins, float *h_ray_directions, float grid_center_x, float grid_center_y, float grid_center_z, float grid_size_x, float grid_size_y, float grid_size_z, int grid_divisions_x,
+bool launchVoxelRayPathLengths(int num_rays, float *h_ray_origins, float *h_ray_directions, float grid_center_x, float grid_center_y, float grid_center_z, float grid_size_x, float grid_size_y, float grid_size_z, int grid_divisions_x,
                                int grid_divisions_y, int grid_divisions_z, int primitive_count, int *h_voxel_ray_counts, float *h_voxel_path_lengths, int *h_voxel_transmitted, int *h_voxel_hit_before, int *h_voxel_hit_after, int *h_voxel_hit_inside);
 // Warp-efficient GPU kernels
 void launchWarpEfficientBVH(void *h_bvh_soa_gpu, unsigned int *h_primitive_indices, int primitive_count, float *h_primitive_aabb_min, float *h_primitive_aabb_max, float *h_ray_origins, float *h_ray_directions, float *h_ray_max_distances,
@@ -928,6 +928,11 @@ void CollisionDetection::buildBVHRecursive(uint node_index, size_t primitive_sta
             centroid_b_coord = 0.5f * (aabb_b.first.z + aabb_b.second.z);
         }
 
+        // Add stable tiebreaker using UUID to ensure deterministic BVH construction
+        // This prevents non-deterministic behavior when primitives have equal centroids
+        if (centroid_a_coord == centroid_b_coord) {
+            return a < b;
+        }
         return centroid_a_coord < centroid_b_coord;
     });
 
@@ -3137,7 +3142,16 @@ void CollisionDetection::calculateVoxelRayPathLengths(const vec3 &grid_center, c
     // Choose GPU or CPU implementation based on acceleration setting
 #ifdef HELIOS_CUDA_AVAILABLE
     if (isGPUAccelerationEnabled()) {
-        calculateVoxelRayPathLengths_GPU(ray_origins, ray_directions);
+        // Try GPU first, but fall back to CPU if GPU fails (no hardware, out of memory, etc.)
+        bool gpu_success = calculateVoxelRayPathLengths_GPU(ray_origins, ray_directions);
+        if (!gpu_success) {
+            // GPU failed - fall back to CPU and disable GPU for future calls
+            if (printmessages) {
+                warnings.addWarning("gpu_voxel_fallback", "GPU voxel calculation failed, falling back to CPU");
+            }
+            gpu_acceleration_enabled = false;
+            calculateVoxelRayPathLengths_CPU(ray_origins, ray_directions);
+        }
     } else {
         calculateVoxelRayPathLengths_CPU(ray_origins, ray_directions);
     }
@@ -3933,7 +3947,15 @@ void CollisionDetection::calculateVoxelRayPathLengths_CPU(const std::vector<vec3
 }
 
 #ifdef HELIOS_CUDA_AVAILABLE
-void CollisionDetection::calculateVoxelRayPathLengths_GPU(const std::vector<vec3> &ray_origins, const std::vector<vec3> &ray_directions) {
+bool CollisionDetection::calculateVoxelRayPathLengths_GPU(const std::vector<vec3> &ray_origins, const std::vector<vec3> &ray_directions) {
+    // Check if GPU is actually available at runtime
+    int deviceCount = 0;
+    cudaError_t err = cudaGetDeviceCount(&deviceCount);
+    if (err != cudaSuccess || deviceCount == 0) {
+        // No GPU hardware available - return false to trigger CPU fallback
+        return false;
+    }
+
     if (printmessages) {
     }
 
@@ -3967,10 +3989,15 @@ void CollisionDetection::calculateVoxelRayPathLengths_GPU(const std::vector<vec3
     int primitive_count = static_cast<int>(primitive_cache.size());
 
     // Launch CUDA kernel
-    launchVoxelRayPathLengths(num_rays, h_ray_origins.data(), h_ray_directions.data(), voxel_grid_center.x, voxel_grid_center.y, voxel_grid_center.z, voxel_grid_size.x, voxel_grid_size.y, voxel_grid_size.z, voxel_grid_divisions.x,
+    bool gpu_success = launchVoxelRayPathLengths(num_rays, h_ray_origins.data(), h_ray_directions.data(), voxel_grid_center.x, voxel_grid_center.y, voxel_grid_center.z, voxel_grid_size.x, voxel_grid_size.y, voxel_grid_size.z, voxel_grid_divisions.x,
                               voxel_grid_divisions.y, voxel_grid_divisions.z, primitive_count, h_voxel_ray_counts.data(), h_voxel_path_lengths.data(), h_voxel_transmitted.data(), h_voxel_hit_before.data(), h_voxel_hit_after.data(),
                               h_voxel_hit_inside.data());
 
+    if (!gpu_success) {
+        // GPU kernel failed - return false to trigger CPU fallback
+        return false;
+    }
+
     // Copy results back to class data structures
     if (use_flat_arrays) {
         // Copy directly to flat arrays
@@ -4117,6 +4144,8 @@ void CollisionDetection::calculateVoxelRayPathLengths_GPU(const std::vector<vec3
             total_ray_voxel_intersections += count;
         }
     }
+
+    return true; // GPU execution succeeded
 }
 #endif