From 41ec6ae8bfb554629ea649ae183bacd85cd59504 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Fri, 1 Aug 2025 15:43:00 -0700 Subject: [PATCH 1/7] [BHP1-1247] Safe Seperation Distance Calculator --- .../safeSeparationDistanceCalculator.cpp | 59 ++++++++++ src/behave/safeSeparationDistanceCalculator.h | 105 ++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 src/behave/safeSeparationDistanceCalculator.cpp create mode 100644 src/behave/safeSeparationDistanceCalculator.h diff --git a/src/behave/safeSeparationDistanceCalculator.cpp b/src/behave/safeSeparationDistanceCalculator.cpp new file mode 100644 index 0000000..3195eaf --- /dev/null +++ b/src/behave/safeSeparationDistanceCalculator.cpp @@ -0,0 +1,59 @@ +#include "safeSeparationDistanceCalculator.h" + +// Calculate + +void SafeSeparationDistanceCalculator::calculate() { + double vegetationHeight = LengthUnits::fromBaseUnits(_vegetationHeight, LengthUnits::Feet); + + std::tuple key = { _speedClass, _burningCondition, _slopeClass }; + double delta = _deltaLookup[key]; + + // Perform calculation using delta + double safeSeparationDistance = 8.0 * vegetationHeight * delta; + double safetyZoneSite = M_PI * pow(safeSeparationDistance, 2.0); + + _safeSeparationDistance = LengthUnits::toBaseUnits(safeSeparationDistance, LengthUnits::Feet); + _safetyZoneSite = AreaUnits::toBaseUnits(safetyZoneSite, AreaUnits::Acres); +} + +// Getters +BurningCondition::BurningConditionEnum SafeSeparationDistanceCalculator::getBurningCondition() { + return _burningCondition; +} + +SlopeClass::SlopeClassEnum SafeSeparationDistanceCalculator::getSlopeClass() { + return _slopeClass; +} + +SpeedClass::SpeedClassEnum SafeSeparationDistanceCalculator::getSpeedClass() { + return _speedClass; +} + +double SafeSeparationDistanceCalculator::getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits) { + return LengthUnits::fromBaseUnits(_vegetationHeight, lengthUnits); +} + +double SafeSeparationDistanceCalculator::getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits) { + return LengthUnits::fromBaseUnits(_safeSeparationDistance, lengthUnits); +} + +double SafeSeparationDistanceCalculator::getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits) { + return AreaUnits::fromBaseUnits(_safetyZoneSite, areaUnits); +} + +// Setters +void SafeSeparationDistanceCalculator::setBurningCondition(BurningCondition::BurningConditionEnum condition) { + _burningCondition = condition; +} + +void SafeSeparationDistanceCalculator::setSlopeClass(SlopeClass::SlopeClassEnum slope) { + _slopeClass = slope; +} + +void SafeSeparationDistanceCalculator::setSpeedClass(SpeedClass::SpeedClassEnum speed) { + _speedClass = speed; +} + +void SafeSeparationDistanceCalculator::setVegetationHeight(double vegetationHeight, LengthUnits::LengthUnitsEnum lengthUnits) { + _vegetationHeight = LengthUnits::toBaseUnits(vegetationHeight, lengthUnits); +} diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h new file mode 100644 index 0000000..f4efa09 --- /dev/null +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -0,0 +1,105 @@ +#pragma once +#include +#include +#include "behaveUnits.h" + +struct BurningCondition { + enum BurningConditionEnum { + Low, + Moderate, + Extreme + }; +}; + +struct SlopeClass { + enum SlopeClassEnum { + Flat, + Moderate, + Steep + }; +}; + +struct SpeedClass { + enum SpeedClassEnum { + Light, + Moderate, + High + }; +}; + +class SafeSeparationDistanceCalculator { +public: + + // calculate + void calculate(); + + // Getters + BurningCondition::BurningConditionEnum getBurningCondition(); + SlopeClass::SlopeClassEnum getSlopeClass(); + SpeedClass::SpeedClassEnum getSpeedClass(); + double getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits); + double getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits); + double getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits); + + // Setters + void setBurningCondition(BurningCondition::BurningConditionEnum condition); + void setSlopeClass(SlopeClass::SlopeClassEnum slope); + void setSpeedClass(SpeedClass::SpeedClassEnum speed); + void setVegetationHeight(double height, LengthUnits::LengthUnitsEnum lengthUnits); + +protected: + BurningCondition::BurningConditionEnum _burningCondition; + SlopeClass::SlopeClassEnum _slopeClass; + SpeedClass::SpeedClassEnum _speedClass; + double _vegetationHeight; + double _safeSeparationDistance; + double _safetyZoneSite; + + std::unordered_map, double> _deltaLookup = { + // Light Burning Conditions + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Moderate}, 1.0}, + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Steep}, 2.0}, + + // Moderate Burning Conditions + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Moderate}, 1.0}, + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Steep}, 2.0}, + + // Extreme Burning Conditions + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Moderate}, 2.0}, + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Steep}, 3.0}, + + /// Moderate Wind Speed + // Light Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Flat}, 1.5}, + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Moderate}, 3.0}, + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Steep}, 4.0}, + + // Moderate Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Flat}, 2.0}, + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Moderate}, 4.0}, + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Steep}, 5.0}, + + // Extreme Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Flat}, 2.5}, + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Steep}, 5.0}, + + /// High Wind Speed + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Flat}, 3.0}, + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Moderate}, 4.0}, + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Steep}, 6.0}, + + // Moderate Burning Conditions + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Flat}, 3.0}, + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Steep}, 7.0}, + + // Extreme Burning Conditions + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Flat}, 4.0}, + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Steep}, 10.0}, + }; +}; From 30c35891c70d9bacb1172adcdc098ff936b49f11 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Mon, 25 Aug 2025 22:17:26 -0700 Subject: [PATCH 2/7] Add to CMakeLists.txt --- CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 898a692..ab61e71 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -81,6 +81,7 @@ SET(SOURCE src/behave/randfuel.cpp src/behave/randthread.cpp src/behave/safety.cpp + src/behave/safeSeparationDistanceCalculator.cpp src/behave/slopeTool.cpp src/behave/species_master_table.cpp src/behave/spot.cpp @@ -122,6 +123,7 @@ SET(HEADERS src/behave/randfuel.h src/behave/randthread.h src/behave/safety.h + src/behave/safeSeparationDistanceCalculator.h src/behave/slopeTool.h src/behave/species_master_table.h src/behave/spot.h From 8d67249bc1fee14ee87e5ce57cc663b225cfb019 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Mon, 25 Aug 2025 22:39:10 -0700 Subject: [PATCH 3/7] Adjust member variable names, add constructors --- .../safeSeparationDistanceCalculator.cpp | 88 +++++++++++++------ src/behave/safeSeparationDistanceCalculator.h | 23 +++-- 2 files changed, 76 insertions(+), 35 deletions(-) diff --git a/src/behave/safeSeparationDistanceCalculator.cpp b/src/behave/safeSeparationDistanceCalculator.cpp index 3195eaf..304af56 100644 --- a/src/behave/safeSeparationDistanceCalculator.cpp +++ b/src/behave/safeSeparationDistanceCalculator.cpp @@ -1,59 +1,93 @@ #include "safeSeparationDistanceCalculator.h" +SafeSeparationDistanceCalculator::~SafeSeparationDistanceCalculator() +{ + burningCondition_ = BurningCondition::Low; + slopeClass_ = SlopeClass::Flat; + speedClass_ = SpeedClass::Light; + vegetationHeight_ = 0.0; + safeSeparationDistance_ = 0.0; + safetyZoneSite_ = 0.0; +} + +SafeSeparationDistanceCalculator::SafeSeparationDistanceCalculator(const SafeSeparationDistanceCalculator& rhs) +{ + memberwiseCopyAssignment(rhs); +} + +SafeSeparationDistanceCalculator& SafeSeparationDistanceCalculator::operator=(const SafeSeparationDistanceCalculator& rhs) +{ + if (this != &rhs) + { + memberwiseCopyAssignment(rhs); + } + return *this; +} + // Calculate void SafeSeparationDistanceCalculator::calculate() { - double vegetationHeight = LengthUnits::fromBaseUnits(_vegetationHeight, LengthUnits::Feet); - - std::tuple key = { _speedClass, _burningCondition, _slopeClass }; - double delta = _deltaLookup[key]; - + double vegetationHeight = LengthUnits::fromBaseUnits(vegetationHeight_, LengthUnits::Feet); + + std::tuple key = { speedClass_, burningCondition_, slopeClass_ }; + double delta = SafeSeparationDistanceCalculator::deltaLookup[key]; + // Perform calculation using delta double safeSeparationDistance = 8.0 * vegetationHeight * delta; double safetyZoneSite = M_PI * pow(safeSeparationDistance, 2.0); - _safeSeparationDistance = LengthUnits::toBaseUnits(safeSeparationDistance, LengthUnits::Feet); - _safetyZoneSite = AreaUnits::toBaseUnits(safetyZoneSite, AreaUnits::Acres); + safeSeparationDistance_ = LengthUnits::toBaseUnits(safeSeparationDistance, LengthUnits::Feet); + safetyZoneSite_ = AreaUnits::toBaseUnits(safetyZoneSite, AreaUnits::Acres); } // Getters -BurningCondition::BurningConditionEnum SafeSeparationDistanceCalculator::getBurningCondition() { - return _burningCondition; +BurningCondition::BurningConditionEnum SafeSeparationDistanceCalculator::getBurningCondition() { + return burningCondition_; } -SlopeClass::SlopeClassEnum SafeSeparationDistanceCalculator::getSlopeClass() { - return _slopeClass; +SlopeClass::SlopeClassEnum SafeSeparationDistanceCalculator::getSlopeClass() { + return slopeClass_; } -SpeedClass::SpeedClassEnum SafeSeparationDistanceCalculator::getSpeedClass() { - return _speedClass; +SpeedClass::SpeedClassEnum SafeSeparationDistanceCalculator::getSpeedClass() { + return speedClass_; } -double SafeSeparationDistanceCalculator::getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits) { - return LengthUnits::fromBaseUnits(_vegetationHeight, lengthUnits); +double SafeSeparationDistanceCalculator::getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits) { + return LengthUnits::fromBaseUnits(vegetationHeight_, lengthUnits); } -double SafeSeparationDistanceCalculator::getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits) { - return LengthUnits::fromBaseUnits(_safeSeparationDistance, lengthUnits); +double SafeSeparationDistanceCalculator::getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits) { + return LengthUnits::fromBaseUnits(safeSeparationDistance_, lengthUnits); } -double SafeSeparationDistanceCalculator::getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits) { - return AreaUnits::fromBaseUnits(_safetyZoneSite, areaUnits); +double SafeSeparationDistanceCalculator::getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits) { + return AreaUnits::fromBaseUnits(safetyZoneSite_, areaUnits); } // Setters -void SafeSeparationDistanceCalculator::setBurningCondition(BurningCondition::BurningConditionEnum condition) { - _burningCondition = condition; +void SafeSeparationDistanceCalculator::setBurningCondition(BurningCondition::BurningConditionEnum condition) { + burningCondition_ = condition; +} + +void SafeSeparationDistanceCalculator::setSlopeClass(SlopeClass::SlopeClassEnum slope) { + slopeClass_ = slope; } -void SafeSeparationDistanceCalculator::setSlopeClass(SlopeClass::SlopeClassEnum slope) { - _slopeClass = slope; +void SafeSeparationDistanceCalculator::setSpeedClass(SpeedClass::SpeedClassEnum speed) { + speedClass_ = speed; } -void SafeSeparationDistanceCalculator::setSpeedClass(SpeedClass::SpeedClassEnum speed) { - _speedClass = speed; +void SafeSeparationDistanceCalculator::setVegetationHeight(double vegetationHeight, LengthUnits::LengthUnitsEnum lengthUnits) { + vegetationHeight_ = LengthUnits::toBaseUnits(vegetationHeight, lengthUnits); } -void SafeSeparationDistanceCalculator::setVegetationHeight(double vegetationHeight, LengthUnits::LengthUnitsEnum lengthUnits) { - _vegetationHeight = LengthUnits::toBaseUnits(vegetationHeight, lengthUnits); +void SafeSeparationDistanceCalculator::memberwiseCopyAssignment(const SafeSeparationDistanceCalculator& rhs) +{ + burningCondition_ = rhs.burningCondition_; + slopeClass_ = rhs.slopeClass_; + speedClass_ = rhs.speedClass_; + vegetationHeight_ = rhs.vegetationHeight_; + safeSeparationDistance_ = rhs.safeSeparationDistance_; + safetyZoneSite_ = rhs.safetyZoneSite_; } diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h index f4efa09..a3703c2 100644 --- a/src/behave/safeSeparationDistanceCalculator.h +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -29,6 +29,11 @@ struct SpeedClass { class SafeSeparationDistanceCalculator { public: + SafeSeparationDistanceCalculator(); + ~SafeSeparationDistanceCalculator(); + SafeSeparationDistanceCalculator(const SafeSeparationDistanceCalculator& rhs); + SafeSeparationDistanceCalculator& operator=(const SafeSeparationDistanceCalculator& rhs); + // calculate void calculate(); @@ -48,14 +53,16 @@ class SafeSeparationDistanceCalculator { void setVegetationHeight(double height, LengthUnits::LengthUnitsEnum lengthUnits); protected: - BurningCondition::BurningConditionEnum _burningCondition; - SlopeClass::SlopeClassEnum _slopeClass; - SpeedClass::SpeedClassEnum _speedClass; - double _vegetationHeight; - double _safeSeparationDistance; - double _safetyZoneSite; - - std::unordered_map, double> _deltaLookup = { + void memberwiseCopyAssignment(const SafeSeparationDistanceCalculator& rhs); + + BurningCondition::BurningConditionEnum burningCondition_; + SlopeClass::SlopeClassEnum slopeClass_; + SpeedClass::SpeedClassEnum speedClass_; + double vegetationHeight_; + double safeSeparationDistance_; + double safetyZoneSite_; + + static std::unordered_map, double> deltaLookup = { // Light Burning Conditions {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Flat}, 1.0}, {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Moderate}, 1.0}, From 49b11bf63f6c89e6f63b0d5f26d765f0937147d6 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Mon, 25 Aug 2025 23:59:02 -0700 Subject: [PATCH 4/7] Add Safety Condition --- .../safeSeparationDistanceCalculator.cpp | 30 +++++++++++++++++++ src/behave/safeSeparationDistanceCalculator.h | 10 ++++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/src/behave/safeSeparationDistanceCalculator.cpp b/src/behave/safeSeparationDistanceCalculator.cpp index 304af56..25d5b51 100644 --- a/src/behave/safeSeparationDistanceCalculator.cpp +++ b/src/behave/safeSeparationDistanceCalculator.cpp @@ -53,6 +53,36 @@ SpeedClass::SpeedClassEnum SafeSeparationDistanceCalculator::getSpeedClass() { return speedClass_; } +SafetyCondition::SafetyConditionEnum SafeSeparationDistanceCalculator::getSafetyCondition() { + if (slopeClass_ == SlopeClass:Flat) { + if (speedClass_ == SpeedClass::High) { + return SafetyCondition::Moderate; + } else { + return SafetyCondition::Low; + } + } else if (slopeClass_ == SlopeClass:Moderate) { + if (speedClass_ == SpeedClass::Light) { + return SafetyCondition::Low; + } else if (speedClass_ == SpeedClass::Moderate) { + return SafetyCondition::Moderate; + } else { + return SafetyCondition::Extreme; + } + } else /* Steep Slope */ { + if (speedClass_ == SpeedClass::Light) { + if (burningCondition_ == BurningCondition::Extreme) { + return SafetyCondition::Moderate; + } else { + return SafetyCondition::Low; + } + } else if (speedClass == SpeedClass::Moderate) { + return SafetyCondition::Moderate; + } else { + return SafetyCondition::Extreme; + } + } +} + double SafeSeparationDistanceCalculator::getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits) { return LengthUnits::fromBaseUnits(vegetationHeight_, lengthUnits); } diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h index a3703c2..6d7b58e 100644 --- a/src/behave/safeSeparationDistanceCalculator.h +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -27,6 +27,14 @@ struct SpeedClass { }; }; +struct SafetyCondition { + enum SafetyConditionEnum { + Low, + Moderate, + Extreme + }; +}; + class SafeSeparationDistanceCalculator { public: SafeSeparationDistanceCalculator(); @@ -34,7 +42,6 @@ class SafeSeparationDistanceCalculator { SafeSeparationDistanceCalculator(const SafeSeparationDistanceCalculator& rhs); SafeSeparationDistanceCalculator& operator=(const SafeSeparationDistanceCalculator& rhs); - // calculate void calculate(); @@ -42,6 +49,7 @@ class SafeSeparationDistanceCalculator { BurningCondition::BurningConditionEnum getBurningCondition(); SlopeClass::SlopeClassEnum getSlopeClass(); SpeedClass::SpeedClassEnum getSpeedClass(); + SafetyCondition::SafetyConditionEnum getSafetyCondition(); double getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits); double getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits); double getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits); From 1aaca1b7dd061b768b8f933db4ebcd4c9b968934 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Tue, 26 Aug 2025 00:25:42 -0700 Subject: [PATCH 5/7] Site -> Size --- src/behave/safeSeparationDistanceCalculator.cpp | 12 ++++++------ src/behave/safeSeparationDistanceCalculator.h | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/behave/safeSeparationDistanceCalculator.cpp b/src/behave/safeSeparationDistanceCalculator.cpp index 25d5b51..73c25bd 100644 --- a/src/behave/safeSeparationDistanceCalculator.cpp +++ b/src/behave/safeSeparationDistanceCalculator.cpp @@ -7,7 +7,7 @@ SafeSeparationDistanceCalculator::~SafeSeparationDistanceCalculator() speedClass_ = SpeedClass::Light; vegetationHeight_ = 0.0; safeSeparationDistance_ = 0.0; - safetyZoneSite_ = 0.0; + safetyZoneSize_ = 0.0; } SafeSeparationDistanceCalculator::SafeSeparationDistanceCalculator(const SafeSeparationDistanceCalculator& rhs) @@ -34,10 +34,10 @@ void SafeSeparationDistanceCalculator::calculate() { // Perform calculation using delta double safeSeparationDistance = 8.0 * vegetationHeight * delta; - double safetyZoneSite = M_PI * pow(safeSeparationDistance, 2.0); + double safetyZoneSize = M_PI * pow(safeSeparationDistance, 2.0); safeSeparationDistance_ = LengthUnits::toBaseUnits(safeSeparationDistance, LengthUnits::Feet); - safetyZoneSite_ = AreaUnits::toBaseUnits(safetyZoneSite, AreaUnits::Acres); + safetyZoneSize_ = AreaUnits::toBaseUnits(safetyZoneSize, AreaUnits::Acres); } // Getters @@ -91,8 +91,8 @@ double SafeSeparationDistanceCalculator::getSafeSeparationDistance(LengthUnits:: return LengthUnits::fromBaseUnits(safeSeparationDistance_, lengthUnits); } -double SafeSeparationDistanceCalculator::getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits) { - return AreaUnits::fromBaseUnits(safetyZoneSite_, areaUnits); +double SafeSeparationDistanceCalculator::getSafetyZoneSize(AreaUnits::AreaUnitsEnum areaUnits) { + return AreaUnits::fromBaseUnits(safetyZoneSize_, areaUnits); } // Setters @@ -119,5 +119,5 @@ void SafeSeparationDistanceCalculator::memberwiseCopyAssignment(const SafeSepara speedClass_ = rhs.speedClass_; vegetationHeight_ = rhs.vegetationHeight_; safeSeparationDistance_ = rhs.safeSeparationDistance_; - safetyZoneSite_ = rhs.safetyZoneSite_; + safetyZoneSize_ = rhs.safetyZoneSize_; } diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h index 6d7b58e..964a693 100644 --- a/src/behave/safeSeparationDistanceCalculator.h +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -52,7 +52,7 @@ class SafeSeparationDistanceCalculator { SafetyCondition::SafetyConditionEnum getSafetyCondition(); double getVegetationHeight(LengthUnits::LengthUnitsEnum lengthUnits); double getSafeSeparationDistance(LengthUnits::LengthUnitsEnum lengthUnits); - double getSafetyZoneSite(AreaUnits::AreaUnitsEnum areaUnits); + double getSafetyZoneSize(AreaUnits::AreaUnitsEnum areaUnits); // Setters void setBurningCondition(BurningCondition::BurningConditionEnum condition); @@ -68,7 +68,7 @@ class SafeSeparationDistanceCalculator { SpeedClass::SpeedClassEnum speedClass_; double vegetationHeight_; double safeSeparationDistance_; - double safetyZoneSite_; + double safetyZoneSize_; static std::unordered_map, double> deltaLookup = { // Light Burning Conditions From f7308c96d83fa5952667062d9fd739518740599e Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Tue, 26 Aug 2025 16:34:24 -0700 Subject: [PATCH 6/7] Update delta lookup with TupleHash --- .../safeSeparationDistanceCalculator.cpp | 61 +++++++++++++++-- src/behave/safeSeparationDistanceCalculator.h | 66 ++++++------------- 2 files changed, 74 insertions(+), 53 deletions(-) diff --git a/src/behave/safeSeparationDistanceCalculator.cpp b/src/behave/safeSeparationDistanceCalculator.cpp index 73c25bd..f3b6001 100644 --- a/src/behave/safeSeparationDistanceCalculator.cpp +++ b/src/behave/safeSeparationDistanceCalculator.cpp @@ -1,6 +1,53 @@ #include "safeSeparationDistanceCalculator.h" -SafeSeparationDistanceCalculator::~SafeSeparationDistanceCalculator() +const std::unordered_map, double, TupleHash> SafeSeparationDistanceCalculator::deltaLookup = { + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Moderate}, 1.0}, + {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Steep}, 2.0}, + + // Moderate Burning Conditions + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Moderate}, 1.0}, + {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Steep}, 2.0}, + + // Extreme Burning Conditions + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Flat}, 1.0}, + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Moderate}, 2.0}, + {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Steep}, 3.0}, + + /// Moderate Wind Speed + // Light Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Flat}, 1.5}, + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Moderate}, 3.0}, + {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Steep}, 4.0}, + + // Moderate Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Flat}, 2.0}, + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Moderate}, 4.0}, + {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Steep}, 5.0}, + + // Extreme Burning Conditions + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Flat}, 2.5}, + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Steep}, 5.0}, + + /// High Wind Speed + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Flat}, 3.0}, + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Moderate}, 4.0}, + {{SpeedClass::High, BurningCondition::Low, SlopeClass::Steep}, 6.0}, + + // Moderate Burning Conditions + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Flat}, 3.0}, + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Steep}, 7.0}, + + // Extreme Burning Conditions + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Flat}, 4.0}, + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, + {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Steep}, 10.0}, +}; + +SafeSeparationDistanceCalculator::SafeSeparationDistanceCalculator() { burningCondition_ = BurningCondition::Low; slopeClass_ = SlopeClass::Flat; @@ -10,6 +57,9 @@ SafeSeparationDistanceCalculator::~SafeSeparationDistanceCalculator() safetyZoneSize_ = 0.0; } +SafeSeparationDistanceCalculator::~SafeSeparationDistanceCalculator() { +} + SafeSeparationDistanceCalculator::SafeSeparationDistanceCalculator(const SafeSeparationDistanceCalculator& rhs) { memberwiseCopyAssignment(rhs); @@ -29,8 +79,7 @@ SafeSeparationDistanceCalculator& SafeSeparationDistanceCalculator::operator=(co void SafeSeparationDistanceCalculator::calculate() { double vegetationHeight = LengthUnits::fromBaseUnits(vegetationHeight_, LengthUnits::Feet); - std::tuple key = { speedClass_, burningCondition_, slopeClass_ }; - double delta = SafeSeparationDistanceCalculator::deltaLookup[key]; + double delta = SafeSeparationDistanceCalculator::getValue(speedClass_, burningCondition_, slopeClass_); // Perform calculation using delta double safeSeparationDistance = 8.0 * vegetationHeight * delta; @@ -54,13 +103,13 @@ SpeedClass::SpeedClassEnum SafeSeparationDistanceCalculator::getSpeedClass() { } SafetyCondition::SafetyConditionEnum SafeSeparationDistanceCalculator::getSafetyCondition() { - if (slopeClass_ == SlopeClass:Flat) { + if (slopeClass_ == SlopeClass::Flat) { if (speedClass_ == SpeedClass::High) { return SafetyCondition::Moderate; } else { return SafetyCondition::Low; } - } else if (slopeClass_ == SlopeClass:Moderate) { + } else if (slopeClass_ == SlopeClass::Moderate) { if (speedClass_ == SpeedClass::Light) { return SafetyCondition::Low; } else if (speedClass_ == SpeedClass::Moderate) { @@ -75,7 +124,7 @@ SafetyCondition::SafetyConditionEnum SafeSeparationDistanceCalculator::getSafety } else { return SafetyCondition::Low; } - } else if (speedClass == SpeedClass::Moderate) { + } else if (speedClass_ == SpeedClass::Moderate) { return SafetyCondition::Moderate; } else { return SafetyCondition::Extreme; diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h index 964a693..a6e0881 100644 --- a/src/behave/safeSeparationDistanceCalculator.h +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -35,6 +35,16 @@ struct SafetyCondition { }; }; +struct TupleHash { + template + std::size_t operator()(const std::tuple& t) const { + auto hash1 = std::hash{}(std::get<0>(t)); + auto hash2 = std::hash{}(std::get<1>(t)); + auto hash3 = std::hash{}(std::get<2>(t)); + return hash1 ^ (hash2 << 1) ^ (hash3 << 2); // Combine the hash values + } +}; + class SafeSeparationDistanceCalculator { public: SafeSeparationDistanceCalculator(); @@ -62,6 +72,14 @@ class SafeSeparationDistanceCalculator { protected: void memberwiseCopyAssignment(const SafeSeparationDistanceCalculator& rhs); + static double getValue(SpeedClass::SpeedClassEnum speed, BurningCondition::BurningConditionEnum burning, SlopeClass::SlopeClassEnum slope) { + auto key = std::make_tuple(speed, burning, slope); + auto it = deltaLookup.find(key); + if (it != deltaLookup.end()) { + return it->second; + } + return 0.0; + } BurningCondition::BurningConditionEnum burningCondition_; SlopeClass::SlopeClassEnum slopeClass_; @@ -70,51 +88,5 @@ class SafeSeparationDistanceCalculator { double safeSeparationDistance_; double safetyZoneSize_; - static std::unordered_map, double> deltaLookup = { - // Light Burning Conditions - {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Flat}, 1.0}, - {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Moderate}, 1.0}, - {{SpeedClass::Light, BurningCondition::Low, SlopeClass::Steep}, 2.0}, - - // Moderate Burning Conditions - {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Flat}, 1.0}, - {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Moderate}, 1.0}, - {{SpeedClass::Light, BurningCondition::Moderate, SlopeClass::Steep}, 2.0}, - - // Extreme Burning Conditions - {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Flat}, 1.0}, - {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Moderate}, 2.0}, - {{SpeedClass::Light, BurningCondition::Extreme, SlopeClass::Steep}, 3.0}, - - /// Moderate Wind Speed - // Light Burning Conditions - {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Flat}, 1.5}, - {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Moderate}, 3.0}, - {{SpeedClass::Moderate, BurningCondition::Low, SlopeClass::Steep}, 4.0}, - - // Moderate Burning Conditions - {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Flat}, 2.0}, - {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Moderate}, 4.0}, - {{SpeedClass::Moderate, BurningCondition::Moderate, SlopeClass::Steep}, 5.0}, - - // Extreme Burning Conditions - {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Flat}, 2.5}, - {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, - {{SpeedClass::Moderate, BurningCondition::Extreme, SlopeClass::Steep}, 5.0}, - - /// High Wind Speed - {{SpeedClass::High, BurningCondition::Low, SlopeClass::Flat}, 3.0}, - {{SpeedClass::High, BurningCondition::Low, SlopeClass::Moderate}, 4.0}, - {{SpeedClass::High, BurningCondition::Low, SlopeClass::Steep}, 6.0}, - - // Moderate Burning Conditions - {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Flat}, 3.0}, - {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Moderate}, 5.0}, - {{SpeedClass::High, BurningCondition::Moderate, SlopeClass::Steep}, 7.0}, - - // Extreme Burning Conditions - {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Flat}, 4.0}, - {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Moderate}, 5.0}, - {{SpeedClass::High, BurningCondition::Extreme, SlopeClass::Steep}, 10.0}, - }; + static const std::unordered_map, double, TupleHash> deltaLookup; }; From df6e0ae33398d601886a28139f1ee267157485a1 Mon Sep 17 00:00:00 2001 From: RJ Sheperd Date: Wed, 27 Aug 2025 07:25:00 -0700 Subject: [PATCH 7/7] Adds math.h --- src/behave/safeSeparationDistanceCalculator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/behave/safeSeparationDistanceCalculator.h b/src/behave/safeSeparationDistanceCalculator.h index a6e0881..166a6ec 100644 --- a/src/behave/safeSeparationDistanceCalculator.h +++ b/src/behave/safeSeparationDistanceCalculator.h @@ -1,4 +1,5 @@ #pragma once +#include #include #include #include "behaveUnits.h"