[1.3.60] 2025-12-08

## Core
- Added vector-scalar arithmetic operators for `std::vector<float>` to enable element-wise operations: addition (`vec + scalar`, `scalar + vec`), subtraction (`vec - scalar`, `scalar - vec`), multiplication (`vec * scalar`, `scalar * vec`), and division (`vec / scalar`, `scalar / vec`).
- Fixed an issue with shared materials. If duplicate materials were merged, and the color/texture/etc. is changed for a subset of primitives, all primitives sharing that merged material would be affected.

## Photosynthesis
- Added `setCi()` method to manually override intercellular CO2 concentration for specified primitives, bypassing the normal iterative calculation that couples photosynthesis with stomatal conductance. This feature is primarily intended for testing and validation purposes.
- CRITICAL BUG: Fixed bug in `evaluateFarquharModel()` where incorrect variable name was used when calling `fzero()`. This could result in parameters reverting to the default values in certain cases.
- Added check for Farquhar `Topt` parameters to catch instances where users specify them in units of Kelvin instead of Celsius.

## Plant Architecture
- Substantially refactored XML reading/writing to avoid writing position and orientation vectors to XML. Instead, they are auto-computed based on bulk parameters.

## Radiation
- Added zoom parameter to the radiation camera parameters structure. By default zoom is 1x, so should be backward compatible.
- Added lens flare model to radiation camera.
- Radiation sources are now rendered in the radiation camera images if in view of the camera.

Author: bnbailey-psl

core/include/Context.h

@@ -148,6 +148,10 @@ namespace helios {
             Value of 0 means one-sided (absorb/emit from front face only). */
         uint twosided_flag;
 
+        //! Reference count - number of primitives currently using this material
+        /** Used for efficient copy-on-write material sharing */
+        mutable uint reference_count;
+
         //! Material primitive data storage - type registry
         std::map<std::string, HeliosDataType> material_data_types;
         //! Material primitive data storage - integer data
@@ -176,11 +180,13 @@ namespace helios {
         std::map<std::string, std::vector<bool>> material_data_bool;
 
         //! Default constructor
-        Material() : materialID(0), label(""), color(make_RGBAcolor(0, 0, 0, 1)), texture_file(""), texture_color_overridden(false), twosided_flag(1) {}
+        Material() : materialID(0), label(""), color(make_RGBAcolor(0, 0, 0, 1)), texture_file(""), texture_color_overridden(false), twosided_flag(1), reference_count(0) {
+        }
 
         //! Constructor with parameters
-        Material(uint ID, const std::string &lbl, const RGBAcolor &c, const std::string &tex, bool override, uint twosided = 1)
-            : materialID(ID), label(lbl), color(c), texture_file(tex), texture_color_overridden(override), twosided_flag(twosided) {}
+        Material(uint ID, const std::string &lbl, const RGBAcolor &c, const std::string &tex, bool override, uint twosided = 1) :
+            materialID(ID), label(lbl), color(c), texture_file(tex), texture_color_overridden(override), twosided_flag(twosided), reference_count(0) {
+        }
 
         //-------- Material Data Methods ---------- //
 
@@ -549,7 +555,7 @@ namespace helios {
         std::vector<std::string> listMaterialData() const {
             std::vector<std::string> data_labels;
             data_labels.reserve(material_data_types.size());
-            for (const auto &data : material_data_types) {
+            for (const auto &data: material_data_types) {
                 data_labels.push_back(data.first);
             }
             return data_labels;
@@ -2472,7 +2478,7 @@ namespace helios {
      * be initialized via a call to initializeContext(), after which geometry and models can be added and simulated.
      */
     class Context {
-        friend class Primitive;  // Allow Primitive methods to access private material data
+        friend class Primitive; // Allow Primitive methods to access private material data
 
     private:
         //---------- PRIMITIVE/OBJECT HELIOS::VECTORS ----------------//
@@ -2608,7 +2614,7 @@ namespace helios {
         //------------ MATERIALS ----------------//
 
         //! Reserved label for the default material
-        static constexpr const char* DEFAULT_MATERIAL_LABEL = "__default__";
+        static constexpr const char *DEFAULT_MATERIAL_LABEL = "__default__";
 
         //! Map containing all materials indexed by material ID
         std::map<uint, Material> materials;
@@ -2632,6 +2638,12 @@ namespace helios {
         //! Generate material label from properties for automatic de-duplication
         std::string generateMaterialLabel(const RGBAcolor &color, const std::string &texture, bool texture_override) const;
 
+        //! Check if a material is shared by multiple primitives
+        bool isMaterialShared(uint materialID) const;
+
+        //! Create a copy of a material for a specific primitive (copy-on-write)
+        uint copyMaterialForPrimitive(uint primitiveUUID);
+
         //----------- GLOBAL DATA -------------//
 
         std::map<std::string, GlobalData> globaldata;
@@ -4418,9 +4430,7 @@ namespace helios {
             }
             // If neither has the data, throw error
             else {
-                helios_runtime_error("ERROR (Context::getDataWithMaterialFallback): Data " + std::string(data_label) +
-                                   " does not exist for primitive " + std::to_string(UUID) +
-                                   " (neither in its material nor as primitive data).");
+                helios_runtime_error("ERROR (Context::getDataWithMaterialFallback): Data " + std::string(data_label) + " does not exist for primitive " + std::to_string(UUID) + " (neither in its material nor as primitive data).");
             }
         }
 
@@ -4436,7 +4446,7 @@ namespace helios {
          * \param[in] materialID Unique identifier of the material
          * \return Constant reference to the Material struct
          */
-        [[nodiscard]] const Material& getMaterial(uint materialID) const;
+        [[nodiscard]] const Material &getMaterial(uint materialID) const;
 
         //! Get material ID from material label
         /**

core/include/global.h

@@ -1028,7 +1028,8 @@ namespace helios {
      * \param[in] max_iterations [optional] Maximum number of iterations to allow before exiting solver.
      * \param[in] warnings [optional] Pointer to WarningAggregator for collecting convergence warnings. If nullptr, warnings are not collected.
      */
-    [[nodiscard]] float fzero(float (*function)(float value, std::vector<float> &variables, const void *parameters), std::vector<float> &variables, const void *parameters, float init_guess, float err_tol = 0.0001f, int max_iterations = 100, WarningAggregator* warnings = nullptr);
+    [[nodiscard]] float fzero(float (*function)(float value, std::vector<float> &variables, const void *parameters), std::vector<float> &variables, const void *parameters, float init_guess, float err_tol = 0.0001f, int max_iterations = 100,
+                              WarningAggregator *warnings = nullptr);
 
     //! Use Newton-Raphson method to find the zero of a function with convergence status
     /**
@@ -1275,6 +1276,118 @@ namespace helios {
         return result;
     }
 
+    //! Add a scalar to each element of a vector
+    /**
+     * \param[in] vec Vector of floats
+     * \param[in] scalar Scalar value to add
+     * \return New vector with scalar added to each element
+     * \ingroup functions
+     */
+    inline std::vector<float> operator+(const std::vector<float> &vec, float scalar) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = vec[i] + scalar;
+        }
+        return result;
+    }
+
+    //! Add a scalar to each element of a vector (scalar on left)
+    /**
+     * \param[in] scalar Scalar value to add
+     * \param[in] vec Vector of floats
+     * \return New vector with scalar added to each element
+     * \ingroup functions
+     */
+    inline std::vector<float> operator+(float scalar, const std::vector<float> &vec) {
+        return vec + scalar;
+    }
+
+    //! Subtract a scalar from each element of a vector
+    /**
+     * \param[in] vec Vector of floats
+     * \param[in] scalar Scalar value to subtract
+     * \return New vector with scalar subtracted from each element
+     * \ingroup functions
+     */
+    inline std::vector<float> operator-(const std::vector<float> &vec, float scalar) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = vec[i] - scalar;
+        }
+        return result;
+    }
+
+    //! Subtract each element of a vector from a scalar
+    /**
+     * \param[in] scalar Scalar value
+     * \param[in] vec Vector of floats to subtract from scalar
+     * \return New vector with each element being scalar minus the vector element
+     * \ingroup functions
+     */
+    inline std::vector<float> operator-(float scalar, const std::vector<float> &vec) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = scalar - vec[i];
+        }
+        return result;
+    }
+
+    //! Multiply each element of a vector by a scalar
+    /**
+     * \param[in] vec Vector of floats
+     * \param[in] scalar Scalar value to multiply
+     * \return New vector with each element multiplied by scalar
+     * \ingroup functions
+     */
+    inline std::vector<float> operator*(const std::vector<float> &vec, float scalar) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = vec[i] * scalar;
+        }
+        return result;
+    }
+
+    //! Multiply each element of a vector by a scalar (scalar on left)
+    /**
+     * \param[in] scalar Scalar value to multiply
+     * \param[in] vec Vector of floats
+     * \return New vector with each element multiplied by scalar
+     * \ingroup functions
+     */
+    inline std::vector<float> operator*(float scalar, const std::vector<float> &vec) {
+        return vec * scalar;
+    }
+
+    //! Divide each element of a vector by a scalar
+    /**
+     * \param[in] vec Vector of floats
+     * \param[in] scalar Scalar value to divide by
+     * \return New vector with each element divided by scalar
+     * \ingroup functions
+     */
+    inline std::vector<float> operator/(const std::vector<float> &vec, float scalar) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = vec[i] / scalar;
+        }
+        return result;
+    }
+
+    //! Divide a scalar by each element of a vector
+    /**
+     * \param[in] scalar Scalar value (numerator)
+     * \param[in] vec Vector of floats (denominators)
+     * \return New vector with each element being scalar divided by vector element
+     * \ingroup functions
+     */
+    inline std::vector<float> operator/(float scalar, const std::vector<float> &vec) {
+        std::vector<float> result(vec.size());
+        for (std::size_t i = 0; i < vec.size(); ++i) {
+            result[i] = scalar / vec[i];
+        }
+        return result;
+    }
+
     /**
      * \class PixelUVKey
      * \brief Represents a unique key for a pixel using its UV coordinates.
@@ -1452,11 +1565,11 @@ namespace helios {
         [[nodiscard]] bool isEnabled() const;
 
     private:
-        mutable std::mutex mutex_;                                     //!< Thread safety for OpenMP
+        mutable std::mutex mutex_; //!< Thread safety for OpenMP
         std::unordered_map<std::string, std::vector<std::string>> warnings_; //!< Storage: category -> messages
-        std::unordered_map<std::string, size_t> counts_;               //!< Total count per category (may exceed stored messages)
-        bool enabled_ = true;                                          //!< Whether to accumulate warnings
-        static constexpr size_t MAX_EXAMPLES = 100;                    //!< Maximum examples to store per category
+        std::unordered_map<std::string, size_t> counts_; //!< Total count per category (may exceed stored messages)
+        bool enabled_ = true; //!< Whether to accumulate warnings
+        static constexpr size_t MAX_EXAMPLES = 100; //!< Maximum examples to store per category
     };
 
     //! Default null SphericalCoord that applies no rotation