[1.3.61] 2025-12-17

## Core
- Fixed CMake linkage visibility for `stdc++fs` library on older GNU compilers (< 9.0) by specifying `PRIVATE` visibility.
- Added `compact` parameter to `WarningAggregator::report()` for single-line warning summaries.

## Energy Balance
- CUDA is now optional. Plugin uses three-tier execution: GPU (CUDA), OpenMP (parallel CPU), or serial CPU fallback. OpenMP is recommended for most workloads.
- Added `enableGPUAcceleration()`, `disableGPUAcceleration()`, and `isGPUAccelerationEnabled()` methods to control GPU usage at runtime (only available when compiled with CUDA).

## Collision Detection
- Added runtime warning when OpenMP is not available, recommending its installation for better performance.

## Plant Architecture
- Added nitrogen model for simulating nitrogen uptake, allocation, remobilization, and stress effects on plant growth. Uses area-based nitrogen tracking (g N/m²) with three-level pool structure (root → available → per-leaf). Calculates nitrogen stress factor (0-1) for use by other plugins.

## Leaf Optics
- Added nitrogen-based automatic leaf optics mode that computes chlorophyll and carotenoid content from leaf nitrogen concentration. Uses adaptive binning to limit computational overhead while maintaining spectral fidelity across nitrogen gradients. Integrates with PlantArchitecture nitrogen model via `leaf_nitrogen_gN_m2` object data.

Author: bnbailey-psl

core/CMake_project.cmake

@@ -154,7 +154,7 @@ endif()
 add_subdirectory( "${BASE_DIRECTORY}/core" "lib" )
 target_link_libraries( ${EXECUTABLE_NAME} PUBLIC helios)
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
-    target_link_libraries(${EXECUTABLE_NAME} stdc++fs)
+    target_link_libraries(${EXECUTABLE_NAME} PRIVATE stdc++fs)
 endif()
 if(APPLE) #get rid of annoying duplicate library warning on Mac
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-no_warn_duplicate_libraries")
@@ -173,7 +173,7 @@ foreach(PLUGIN ${PLUGINS})
     target_link_libraries( ${PLUGIN} PUBLIC helios )
     if( NOT APPLE )
         if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
-            target_link_libraries(${PLUGIN} stdc++fs)
+            target_link_libraries(${PLUGIN} PRIVATE stdc++fs)
         endif()
     endif()
 endforeach(PLUGIN)

core/include/global.h

@@ -1537,9 +1537,11 @@ namespace helios {
         //! Report all accumulated warnings and clear
         /**
          * \param[in] stream Output stream to write warnings to (default: std::cerr)
-         * \note Outputs format: "WARNING: N instances of 'category' (showing first 3):"
+         * \param[in] compact If true, output single line per category with count only (default: false)
+         * \note Standard format: "WARNING: N instances of 'category' (showing first 3):"
+         * \note Compact format: "WARNING: N instances of 'category'"
          */
-        void report(std::ostream &stream = std::cerr);
+        void report(std::ostream &stream = std::cerr, bool compact = false);
 
         //! Get the count of warnings for a specific category
         /**

core/src/global.cpp

@@ -2995,7 +2995,7 @@ void helios::WarningAggregator::addWarning(const std::string &category, const st
     }
 }
 
-void helios::WarningAggregator::report(std::ostream &stream) {
+void helios::WarningAggregator::report(std::ostream &stream, bool compact) {
     std::lock_guard<std::mutex> lock(mutex_);
 
     if (counts_.empty()) {
@@ -3009,21 +3009,26 @@ void helios::WarningAggregator::report(std::ostream &stream) {
 
         stream << "WARNING: " << count << " instance" << (count > 1 ? "s" : "") << " of '" << category << "'";
 
-        // Get stored messages for this category
-        const auto &messages = warnings_[category];
+        if (!compact) {
+            // Original behavior: show examples
+            const auto &messages = warnings_[category];
 
-        // Show first few examples
-        size_t examples_to_show = std::min(size_t(3), messages.size());
-        stream << " (showing first " << examples_to_show << "):" << std::endl;
+            // Show first few examples
+            size_t examples_to_show = std::min(size_t(3), messages.size());
+            stream << " (showing first " << examples_to_show << "):" << std::endl;
 
-        for (size_t i = 0; i < examples_to_show; ++i) {
-            stream << "  - " << messages[i] << std::endl;
-        }
+            for (size_t i = 0; i < examples_to_show; ++i) {
+                stream << "  - " << messages[i] << std::endl;
+            }
 
-        if (count > MAX_EXAMPLES) {
-            stream << "  (Note: More than " << MAX_EXAMPLES << " warnings of this type were encountered)" << std::endl;
+            if (count > MAX_EXAMPLES) {
+                stream << "  (Note: More than " << MAX_EXAMPLES << " warnings of this type were encountered)" << std::endl;
+            }
+            stream << std::endl;
+        } else {
+            // Compact mode: just the count
+            stream << std::endl;
         }
-        stream << std::endl;
     }
 
     // Clear after reporting

doc/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+# [1.3.61] 2025-12-17
+
+## Core
+- Fixed CMake linkage visibility for `stdc++fs` library on older GNU compilers (< 9.0) by specifying `PRIVATE` visibility.
+- Added `compact` parameter to `WarningAggregator::report()` for single-line warning summaries.
+
+## Energy Balance
+- CUDA is now optional. Plugin uses three-tier execution: GPU (CUDA), OpenMP (parallel CPU), or serial CPU fallback. OpenMP is recommended for most workloads.
+- Added `enableGPUAcceleration()`, `disableGPUAcceleration()`, and `isGPUAccelerationEnabled()` methods to control GPU usage at runtime (only available when compiled with CUDA).
+
+## Collision Detection
+- Added runtime warning when OpenMP is not available, recommending its installation for better performance.
+
+## Plant Architecture
+- Added nitrogen model for simulating nitrogen uptake, allocation, remobilization, and stress effects on plant growth. Uses area-based nitrogen tracking (g N/m²) with three-level pool structure (root → available → per-leaf). Calculates nitrogen stress factor (0-1) for use by other plugins.
+
+## Leaf Optics
+- Added nitrogen-based automatic leaf optics mode that computes chlorophyll and carotenoid content from leaf nitrogen concentration. Uses adaptive binning to limit computational overhead while maintaining spectral fidelity across nitrogen gradients. Integrates with PlantArchitecture nitrogen model via `leaf_nitrogen_gN_m2` object data. 
+
 # [1.3.60] 2025-12-08
 
 ## Core

doc/header.html

@@ -47,7 +47,6 @@
 $treeview
 $search
 $mathjax
-$darkmode
 <link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
 $extrastylesheet
 </head>

plugins/collisiondetection/doc/CollisionDetection.dox

@@ -5,19 +5,19 @@
  <p> <br><br> </p>
 
  <table>
-   <tr>	
+   <tr>
       <th>Dependencies</th>
-      <td>NVIDIA CUDA 9.0+ (optional)</td>
+      <td>OpenMP (recommended), NVIDIA CUDA 9.0+ (optional)</td>
    </tr>
-   <tr>	
+   <tr>
      <th>CMakeLists.txt</th>
      <td>set( PLUGINS "collisiondetection" )</td>
    </tr>
-   <tr>	
+   <tr>
      <th>Header File</th>
      <td>#include "CollisionDetection.h"</td>
    </tr>
-   <tr>	
+   <tr>
      <th>Class</th>
      <td>\ref CollisionDetection</td>
    </tr>
@@ -28,25 +28,36 @@
 <table>
     <tr>
         <th>Package</th>
+        <th>Status</th>
         <td>\image html apple-logo.png</td>
         <td>\image html unix-logo.png</td>
         <td>\image html windows-logo.png</td>
     </tr>
+    <tr>
+        <td>OpenMP</td>
+        <td><b>Recommended</b></td>
+        <td>Usually available (via libomp)</td>
+        <td>Usually available</td>
+        <td>Usually available</td>
+    </tr>
     <tr>
         <td>NVIDIA CUDA 9.0+ (optional)</td>
+        <td><b>Optional</b></td>
         <td>Mac OSX: Not available</td>
         <td>Use <a href="https://developer.nvidia.com/cuda-downloads">CUDA installer</a></td>
         <td>Use <a href="https://developer.nvidia.com/cuda-downloads">CUDA installer</a></td>
     </tr>
 </table>
 
+<b>Performance Note:</b> OpenMP is strongly recommended for production use. The plugin will work without OpenMP using serial CPU execution, but performance will be significantly slower for large scenes.
+
 For help choosing the correct CUDA toolkit version and accompanying OptiX version for your system, consult this page: \ref ChoosingCUDA
 
 Useful OS-specific information for installing CUDA can be found here: \ref DependentSoftware
 
 If you are using a PC, it is likely you will need to increase the GPU timeout in the registry, otherwise calculations lasting longer than 2 secs. will timeout and kill your program. A guide on how to increase the timeout can be found here: \ref PCGPUTimeout
 
-<b>Note:</b> CUDA is optional for this plugin. The collision detection system will work on CPU-only systems, but GPU acceleration provides significant performance improvements for large scenes.
+<b>Note:</b> CUDA is optional for this plugin. The collision detection system will work on CPU-only systems. OpenMP provides parallel CPU execution and is recommended for best performance. When neither GPU nor OpenMP is available, the plugin falls back to serial CPU execution with a performance warning.
 
  \section CDIntro Introduction
 

plugins/collisiondetection/src/CollisionDetection.cpp

@@ -98,6 +98,16 @@ CollisionDetection::CollisionDetection(helios::Context *a_context) {
     tree_isolation_distance = 5.0f; // Default 5 meter isolation distance
     obstacle_spatial_grid_initialized = false;
 
+    // Issue warning if OpenMP not available
+    #ifndef _OPENMP
+    static bool openmp_warning_issued = false;
+    if (printmessages && !openmp_warning_issued) {
+        std::cout << "WARNING (CollisionDetection): OpenMP not available. Using serial CPU implementation. "
+                  << "Performance will be significantly slower. Consider installing OpenMP for parallel execution." << std::endl;
+        openmp_warning_issued = true;
+    }
+    #endif
+
     // Initialize grid parameters
     grid_center = make_vec3(0, 0, 0);
     grid_size = make_vec3(1, 1, 1);

plugins/energybalance/CMakeLists.txt

@@ -7,73 +7,90 @@ endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
 
-find_package(CUDAToolkit REQUIRED)
-set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
+# Try to find CUDA toolkit (optional)
+find_package(CUDAToolkit QUIET)
 
-# Set CUDA architectures before enabling CUDA language
-if( OPTIX_VERSION_LEGACY )
-     set(CMAKE_CUDA_ARCHITECTURES "35")
-else()
-     include("${CMAKE_BINARY_DIR}/lib/detect_GPU_compute.cmake")
-endif()
+if(CUDAToolkit_FOUND)
+    message(STATUS "[EnergyBalance] CUDA found - building with GPU acceleration")
+    set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
 
-# Enable CUDA as a language (modern CMake approach)
-enable_language(CUDA)
-
-# Windows-specific: Override CMake's automatic CUDA flag injection
-if(WIN32 AND MSVC)
-	# Clear all CMake-generated CUDA flags that contain problematic MSVC options
-	set(CMAKE_CUDA_FLAGS_DEBUG "")
-	set(CMAKE_CUDA_FLAGS_RELEASE "")
-	set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "")
-	set(CMAKE_CUDA_FLAGS_MINSIZEREL "")
-	
-	# Override the CUDA compile rule to prevent MSVC flag injection
-	set(CMAKE_CUDA_COMPILE_OBJECT "<CMAKE_CUDA_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c <SOURCE> -o <OBJECT>")
-endif()
+    # Set CUDA architectures before enabling CUDA language
+    if( OPTIX_VERSION_LEGACY )
+         set(CMAKE_CUDA_ARCHITECTURES "35")
+    else()
+         include("${CMAKE_BINARY_DIR}/lib/detect_GPU_compute.cmake")
+    endif()
 
-# Set CUDA flags after enabling language to override defaults
-if(WIN32)
-	# On Windows, use minimal flags and override any CMake defaults
-	set(CMAKE_CUDA_FLAGS "--use_fast_math")
-	
-	# Force override CMake's build-type specific flags after they're set
-	set(CMAKE_CUDA_FLAGS_DEBUG "${CMAKE_CUDA_FLAGS}")
-	set(CMAKE_CUDA_FLAGS_RELEASE "${CMAKE_CUDA_FLAGS}")
-	set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "${CMAKE_CUDA_FLAGS}")
-	set(CMAKE_CUDA_FLAGS_MINSIZEREL "${CMAKE_CUDA_FLAGS}")
-else()
-	# Non-Windows platforms use full flags
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --use_fast_math -Wno-deprecated-gpu-targets")
-	
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -std=c++${CMAKE_CXX_STANDARD}")
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D_MWAITXINTRIN_H_INCLUDED -D__STRICT_ANSI__")
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}/include")
-endif()
+    # Enable CUDA as a language (modern CMake approach)
+    enable_language(CUDA)
 
-if( CMAKE_BUILD_TYPE STREQUAL Debug OR NOT DEFINED CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "" )
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -g -O0")
-else()
-	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -O3")
-endif()
+    # Windows-specific: Override CMake's automatic CUDA flag injection
+    if(WIN32 AND MSVC)
+    	# Clear all CMake-generated CUDA flags that contain problematic MSVC options
+    	set(CMAKE_CUDA_FLAGS_DEBUG "")
+    	set(CMAKE_CUDA_FLAGS_RELEASE "")
+    	set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "")
+    	set(CMAKE_CUDA_FLAGS_MINSIZEREL "")
 
-add_library(energybalance STATIC "src/EnergyBalanceModel.cpp" "src/EnergyBalanceModel.cu" "tests/selfTest.cpp")
+    	# Override the CUDA compile rule to prevent MSVC flag injection
+    	set(CMAKE_CUDA_COMPILE_OBJECT "<CMAKE_CUDA_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c <SOURCE> -o <OBJECT>")
+    endif()
 
-# Set CUDA properties for the target
-set_target_properties(energybalance PROPERTIES CUDA_RUNTIME_LIBRARY Static CUDA_RESOLVE_DEVICE_SYMBOLS ON )
+    # Set CUDA flags after enabling language to override defaults
+    if(WIN32)
+    	# On Windows, use minimal flags and override any CMake defaults
+    	set(CMAKE_CUDA_FLAGS "--use_fast_math")
 
-# Windows-specific: Clear any inherited global compile options that cause nvcc issues
-if(WIN32 AND MSVC)
-	# Remove the global /utf-8 flag and other MSVC options from CUDA compilation
-	set_property(TARGET energybalance PROPERTY COMPILE_OPTIONS "")
-	set_property(TARGET energybalance PROPERTY COMPILE_DEFINITIONS "")
-	
-	# Windows-specific defines
-	target_compile_definitions(energybalance PRIVATE NOMINMAX _USE_MATH_DEFINES _MWAITXINTRIN_H_INCLUDED __STRICT_ANSI__ )
-endif()
+    	# Force override CMake's build-type specific flags after they're set
+    	set(CMAKE_CUDA_FLAGS_DEBUG "${CMAKE_CUDA_FLAGS}")
+    	set(CMAKE_CUDA_FLAGS_RELEASE "${CMAKE_CUDA_FLAGS}")
+    	set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "${CMAKE_CUDA_FLAGS}")
+    	set(CMAKE_CUDA_FLAGS_MINSIZEREL "${CMAKE_CUDA_FLAGS}")
+    else()
+    	# Non-Windows platforms use full flags
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --use_fast_math -Wno-deprecated-gpu-targets")
+
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -std=c++${CMAKE_CXX_STANDARD}")
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D_MWAITXINTRIN_H_INCLUDED -D__STRICT_ANSI__")
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}/include")
+    endif()
+
+    if( CMAKE_BUILD_TYPE STREQUAL Debug OR NOT DEFINED CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "" )
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -g -O0")
+    else()
+    	set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -O3")
+    endif()
 
-target_link_libraries(energybalance PUBLIC CUDA::cudart_static)
+    # Build with CUDA support (.cu file included)
+    add_library(energybalance STATIC "src/EnergyBalanceModel.cpp" "src/EnergyBalanceModel.cu" "tests/selfTest.cpp")
+
+    # Set CUDA properties for the target
+    set_target_properties(energybalance PROPERTIES CUDA_RUNTIME_LIBRARY Static CUDA_RESOLVE_DEVICE_SYMBOLS ON )
+
+    # Windows-specific: Clear any inherited global compile options that cause nvcc issues
+    if(WIN32 AND MSVC)
+    	# Remove the global /utf-8 flag and other MSVC options from CUDA compilation
+    	set_property(TARGET energybalance PROPERTY COMPILE_OPTIONS "")
+    	set_property(TARGET energybalance PROPERTY COMPILE_DEFINITIONS "")
+
+    	# Windows-specific defines
+    	target_compile_definitions(energybalance PRIVATE NOMINMAX _USE_MATH_DEFINES _MWAITXINTRIN_H_INCLUDED __STRICT_ANSI__ )
+    endif()
+
+    target_link_libraries(energybalance PUBLIC CUDA::cudart_static)
+
+    # Define preprocessor macro to indicate CUDA support
+    target_compile_definitions(energybalance PRIVATE HELIOS_CUDA_AVAILABLE)
+
+else()
+    message(STATUS "[EnergyBalance] CUDA not found - building CPU-only version with OpenMP")
+
+    # Build CPU-only version (exclude .cu file)
+    add_library(energybalance STATIC "src/EnergyBalanceModel.cpp" "tests/selfTest.cpp")
+
+endif()
 
+# Common configurations for both CUDA and CPU-only builds
 target_include_directories(energybalance PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 if(BUILD_TESTS)