add moisture analysis

Author: peacekeeper228

data/moisture.csv

@@ -0,0 +1 @@
+80,1.830057

include/Cell.h

@@ -10,6 +10,7 @@ class cell
     cellState current_state_;
     std::shared_ptr<const Wind> wind_state_;
     std::unique_ptr<Fire> fire_state_;
+    int biomass_;
     double altitude_;
 
 public:
@@ -39,6 +40,9 @@ class cell
     int getAltitude() const;
     ~cell();
 
+    void setBiomass(const int biomass);
+    int getBiomass() const;
+
     const Fire* getFireInCell() const;
 };
 /// @brief this function make a proper assignment wind to cell. Also it follows invariants in wind

include/Math.h

@@ -83,16 +83,22 @@ class Math1 final : public Math
     mutable std::unordered_map<SlopeMetaData, double> slope_result_;
     mutable std::map<double, int> result_wind_;
     mutable std::map<int, int> result_overall;
-    mutable clock_t slope_timer;
+    mutable clock_t slope_timer; 
     mutable int slope_counter;
 
     mutable clock_t wind_timer_;
     mutable int wind_counter_;
     mutable std::unordered_map<WindMetaData, double> wind_result_;
+
+    mutable clock_t moisture_timer_;
+    mutable int moisture_counter_;
+    mutable std::unordered_map<int, double> moisture_result_;
 
     double calculateKoef(float windSpeed, double slopeAngleRad) const;
     double calculateWindKoef(const cell *c, directions InvestigatedDirection) const;
     double calculateGroundSlopeKoef(directions InvestigatedDirection, int altitudeDifference) const;
+    double calculateBiomassKoef(const cell *c) const;
+    double calculateMoistureKoeff(int moisture_percentage) const;
 
 public:
     bool willSpread(const cell *c, directions InvestigatedDirection, int altitudeDifference) const override;

include/Wind.h

@@ -6,11 +6,13 @@ class Wind
 private:
     directions direction_;
     float wind_speed_;
+    int moisture_percentage_;
 public:
-    Wind(directions initialDirection, float w);
+    Wind(directions initialDirection, float w, int moisture_percentage);
     ~Wind();
     directions getWindDirection() const;
     float getWindSpeed() const;
+    int getMoistureCoeff() const;
 
     /// @deprecated now calculates over math module
     /// @brief calculate the wind coeff based on mathematical model

src/Cell.cpp

@@ -111,3 +111,13 @@ cell::~cell()
 {
     setWindToCell(this, nullptr);
 }
+
+void cell::setBiomass(const int biomass)
+{
+    biomass_ = biomass;
+}
+
+int cell::getBiomass() const
+{
+    return biomass_;
+}

src/Math.cpp

@@ -86,11 +86,54 @@ double Math1::calculateGroundSlopeKoef(directions InvestigatedDirection, int alt
     return result;
 }
 
+double Math1::calculateBiomassKoef(const cell *c) const
+{
+    int coeff = -1;
+    switch (c->getBiomass())
+    {
+        case 0 ... 100:
+            coeff = -0.4;
+            break;
+        case 101 ... 150:
+            coeff = 0;
+            break;
+        case 151 ... 300:
+            coeff = 0.3;
+            break;
+        default:
+            throw std::invalid_argument("received strange value in biomass");
+            break;
+    }
+    return double(1+coeff);
+}
+
+double Math1::calculateMoistureKoeff(int moisture_percentage) const
+{
+    clock_t start = clock();
+
+    auto a = moisture_result_[moisture_percentage];
+    if (a != 0){
+        clock_t per_iteration = clock() - start;
+        moisture_timer_ = per_iteration+moisture_timer_;
+        moisture_counter_++;
+        return moisture_result_[moisture_percentage];
+    };
+
+    double result = 2 * exp(-0.111 * moisture_percentage / 100);
+    moisture_result_[moisture_percentage] = result;
+    clock_t per_iteration = clock() - start;
+    moisture_timer_ = per_iteration+moisture_timer_;
+    moisture_counter_++;
+    return result;
+}
+
 bool Math1::willSpread(const cell *c, directions InvestigatedDirection, int altitudeDifference) const
 {
     double fireKoeff = calculateWindKoef(c, InvestigatedDirection);
     double slopeKoeff = calculateGroundSlopeKoef(InvestigatedDirection, altitudeDifference);
-    int result = fireKoeff * slopeKoeff * 100 - 40;
+    double biomassKoeff = calculateBiomassKoef(c);
+    double moistureKoeff = calculateMoistureKoeff(c->getWind().get()->getMoistureCoeff());
+    int result = fireKoeff * slopeKoeff * biomassKoeff * moistureKoeff * 100 - 40;
     result_overall[result]++;
     return result + (rand() % 100) > ignitionPercentage();
 }
@@ -108,6 +151,7 @@ bool to_bool(std::string const &s)
 }
 
 Math1::Math1()
+    :slope_timer(0), slope_counter(0), wind_timer_(0), wind_counter_(0), moisture_timer_(0), moisture_counter_(0)
 {
     std::ifstream csvFile{"data/slope.csv"};
     std::string row;
@@ -139,16 +183,26 @@ Math1::Math1()
         wind_result_[WindMetaData{atoi(cols[0].c_str()), a}] = atof(cols[2].c_str());
     }
     csvFile2.close();
-    slope_counter = 0;
-    slope_timer = 0;
-    wind_counter_ = 0;
-    wind_timer_ = 0;
+    std::ifstream csvFile3{"data/moisture.csv"};
+    while (std::getline(csvFile3, row))
+    {
+        std::stringstream rowStream(row);
+        std::string col;
+        std::vector<std::string> cols;
+        while (std::getline(rowStream, col, ','))
+        {
+            cols.push_back(col);
+        }
+        moisture_result_[atoi(cols[0].c_str())] = atof(cols[1].c_str());
+    }
+    csvFile3.close();
 }
 
 Math1::~Math1()
 {
     printf("total time %f, overall counts %d\n", (double)(slope_timer), slope_counter);
     printf("total time %f, overall counts %d\n", (double)(wind_timer_), wind_counter_);
+    printf("total time %f, overall counts %d\n", (double)(moisture_timer_), moisture_counter_);
     // printf("slope profiling\n");
     // std::map<int, int> slope_distribution;
 

src/ProfilingDecorator.cpp

@@ -3,7 +3,7 @@
 #include <iostream>
 
 ProfilingDecorator::ProfilingDecorator(Math *formula)
-    : primary_class_(formula), counter_(0), positive_counter_(0)
+    : primary_class_(formula), positive_counter_(0), counter_(0)
 {
 }
 

src/Wind.cpp

@@ -3,8 +3,8 @@
 
 constexpr double pi() { return std::atan(1) * 4; }
 
-Wind::Wind(directions initialDirection, float w)
-    : direction_(initialDirection), wind_speed_(w)
+Wind::Wind(directions initialDirection, float w, int moisture_percentage)
+    : direction_(initialDirection), wind_speed_(w), moisture_percentage_(moisture_percentage)
 {
 }
 
@@ -18,6 +18,11 @@ float Wind::getWindSpeed() const
     return this->wind_speed_;
 }
 
+int Wind::getMoistureCoeff() const
+{
+    return moisture_percentage_;
+}
+
 Wind::~Wind()
 {
 }

src/main.cpp

@@ -27,11 +27,13 @@ int main()
     CellStorage s = CellStorage(&formulaDecorator);
     auto xRange = std::make_pair<int, int>(0, getXArea());
     auto yRange = std::make_pair<int, int>(0, getYArea()/2);
-    auto w = std::make_shared<const Wind>(directions::SouthWest, float(5.0));
+    auto w = std::make_shared<const Wind>(directions::SouthWest, float(5.0), 80); //Surgut
+    // auto w = std::make_shared<const Wind>(directions::NorthEast, float(2.0)); // Vanderhoof
+
     s.setWindToArea(xRange, yRange, w);
 
     yRange = std::make_pair<int, int>(getYArea()/2, getYArea());
-    w = std::make_shared<const Wind>(directions::SouthEast, float(2.0));
+    w = std::make_shared<const Wind>(directions::SouthEast, float(2.0), 80);
     s.setWindToArea(xRange, yRange, w);
 
     for (size_t i = 0; i < 10; i++)

tests/test_main.cpp

@@ -31,7 +31,7 @@ void test_Cell(){
     assert(c.getState() == cellState::Artificial);
 
     float wS = 1.0;
-    auto w = std::make_shared<const Wind>(directions::North, wS);
+    auto w = std::make_shared<const Wind>(directions::North, wS, 0.1);
     c.setWind(w);
     assert(c.getWind().get() == w.get());
 }
@@ -55,7 +55,7 @@ void test_CellStorage_setWindToArea(){
     CellStorage s = CellStorage(&formula);
     std::pair<int, int> p = std::make_pair<int, int>(4, 5);
     float wS = 1.0;
-    auto w = std::make_shared<const Wind>(directions::North, wS);
+    auto w = std::make_shared<const Wind>(directions::North, wS, 0.1);
 
     assert(!s.checkAndGetCell(4, 4)->getWind());
 
@@ -87,7 +87,7 @@ void test_CellStorage(){
 
 void test_Wind(){
     float wS = 1.0;
-    Wind w = Wind(directions::North, wS);
+    Wind w = Wind(directions::North, wS, 0.1);
     assert(w.getWindDirection() == directions::North);
 
     assert(w.angleBetweenDirections(directions::North) == 0);