Model.h

/* Copyright (c) Queen's Printer for Ontario, 2020. */
/* Copyright (c) His Majesty the King in Right of Canada as represented by the Minister of Natural Resources, 2021-2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include <condition_variable>
#include <cstdio>
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
#include "Environment.h"
#include "Iteration.h"
#include "FireWeather.h"
namespace fs
{
namespace topo
{
class StartPoint;
}
namespace sim
{
class Event;
class Scenario;
class Semaphore
{
public:
  explicit Semaphore(const int n)
    : used_{0},
      limit_{n}
  {
  }
  Semaphore(const Semaphore& rhs) = delete;
  Semaphore(Semaphore&& rhs) = delete;
  Semaphore& operator=(const Semaphore& rhs) = delete;
  Semaphore& operator=(Semaphore&& rhs) = delete;
  void set_limit(size_t limit)
  {
    logging::debug("Changing Semaphore limit from %d to %d", limit_, limit);
    // NOTE: won't drop threads if set lower but won't give out more until below limit
    limit_ = limit;
  }
  size_t limit()
  {
    return limit_;
  }
  void notify()
  {
    std::unique_lock<std::mutex> l(mutex_);
    --used_;
    cv_.notify_one();
  }
  void wait()
  {
    std::unique_lock<std::mutex> l(mutex_);
    cv_.wait(l, [this] { return used_ <= limit_; });
    ++used_;
  }
private:
  std::mutex mutex_;
  std::condition_variable cv_;
  int used_;
  int limit_;
};
class CriticalSection
{
  Semaphore& s_;
public:
  explicit CriticalSection(Semaphore& ss)
    : s_{ss}
  {
    s_.wait();
  }
  CriticalSection(const CriticalSection& rhs) = delete;
  CriticalSection(CriticalSection&& rhs) = delete;
  CriticalSection& operator=(const CriticalSection& rhs) = delete;
  CriticalSection& operator=(CriticalSection&& rhs) = delete;
  ~CriticalSection() noexcept
  {
    try
    {
      s_.notify();
    }
    catch (const std::exception& ex)
    {
      logging::fatal(ex);
      std::terminate();
    }
  }
};
class Model
{
public:
  [[nodiscard]] static int runScenarios(const string dir_out,
                                        const char* weather_input,
                                        const wx::FwiWeather& yesterday,
                                        const char* raster_root,
                                        const topo::StartPoint& start_point,
                                        const tm& start_time,
                                        const string& perimeter,
                                        size_t size);
  [[nodiscard]]
#ifdef NDEBUG
  CONSTEXPR
#endif
    topo::Cell
    cell(const Idx row, const Idx column) const
  {
    return env_->cell(row, column);
  }
  template <class P>
  [[nodiscard]] constexpr topo::Cell cell(const Position<P>& position) const
  {
    return env_->cell(position);
  }
  //  [[nodiscard]] constexpr topo::Cell cell(const HashSize hash_size) const
  //  {
  //    return env_->cell(hash_size);
  //  }
  [[nodiscard]] constexpr Idx rows() const
  {
    return env_->rows();
  }
  [[nodiscard]] constexpr Idx columns() const
  {
    return env_->columns();
  }
  [[nodiscard]] constexpr MathSize cellSize() const
  {
    return env_->cellSize();
  }
  [[nodiscard]] constexpr const topo::Environment& environment() const
  {
    return *env_;
  }
  [[nodiscard]] constexpr Clock::time_point runningSince() const
  {
    return running_since_;
  }
  [[nodiscard]] constexpr Clock::duration timeLimit() const
  {
    return time_limit_;
  }
  [[nodiscard]] constexpr Clock::duration interimTimeLimit() const
  {
    return interim_save_interval_;
  }
  [[nodiscard]] bool shouldStop() const noexcept;
  [[nodiscard]] bool isOutOfTime() const noexcept;
  [[nodiscard]] bool isOverSimulationCountLimit() const noexcept;
  [[nodiscard]] int year() const noexcept
  {
    return year_;
  }
  [[nodiscard]] int ignitionScenarios() const noexcept
  {
    return starts_.size();
  }
  [[nodiscard]] int scenarioCount() const noexcept
  {
    return wx_.size() * ignitionScenarios();
  }
  [[nodiscard]] constexpr int nd(const DurationSize time) const
  {
    return nd_.at(static_cast<Day>(time));
  }
  [[nodiscard]] const char* outputDirectory() const
  {
    return dir_out_.c_str();
  }
  [[nodiscard]] std::chrono::seconds runTime() const;
  [[nodiscard]] std::chrono::seconds timeSinceLastSave() const;
  [[nodiscard]] ProbabilityMap* makeProbabilityMap(DurationSize time,
                                                   DurationSize start_time) const;
  ~Model() = default;
  Model(const string dir_out,
        const topo::StartPoint& start_point,
        topo::Environment* env);
  Model(Model&& rhs) noexcept = delete;
  Model(const Model& rhs) = delete;
  Model& operator=(Model&& rhs) noexcept = delete;
  Model& operator=(const Model& rhs) = delete;
  void setWeather(const wx::FwiWeather& weather, const Day start_day);
  void readWeather(const wx::FwiWeather& yesterday,
                   const MathSize latitude,
                   const string& filename);
  void makeStarts(Coordinates coordinates,
                  const topo::Point& point,
                  string perim,
                  size_t size);
  [[nodiscard]] Iteration readScenarios(const topo::StartPoint& start_point,
                                        DurationSize start,
                                        Day start_day,
                                        Day last_date);
  [[nodiscard]] BurnedData* getBurnedVector() const noexcept;
  void releaseBurnedVector(BurnedData* has_burned) const noexcept;
  static Semaphore task_limiter;
  const wx::FwiWeather* yesterday() const noexcept
  {
    return &yesterday_;
  }
private:
  const string dir_out_;
  void add_statistics(vector<MathSize>* all_sizes,
                      vector<MathSize>* means,
                      vector<MathSize>* pct,
                      const util::SafeVector& sizes);
  mutable mutex vector_mutex_;
  tm start_time_;
  mutable vector<unique_ptr<BurnedData>> vectors_{};
  map<DurationSize, ProbabilityMap*> runIterations(const topo::StartPoint& start_point,
                                                   DurationSize start,
                                                   Day start_day);
  DurationSize saveProbabilities(map<DurationSize, ProbabilityMap*>& probabilities, const Day start_day, const bool is_interim);
  void findStarts(Location location);
  array<int, MAX_DAYS> nd_{};
  map<size_t, shared_ptr<wx::FireWeather>> wx_{};
  map<size_t, shared_ptr<wx::FireWeather>> wx_daily_{};
  vector<shared_ptr<topo::Cell>> starts_{};
  Clock::time_point running_since_;
  Clock::duration time_limit_;
  Clock::time_point no_interim_save_since_;
  Clock::duration interim_save_interval_;
  // /**
  //  * @brief Initial intensity map based off perimeter
  //  */
  // shared_ptr<IntensityMap> initial_intensity_ = nullptr;
  shared_ptr<topo::Perimeter> perimeter_ = nullptr;
  topo::Environment* env_;
#ifdef DEBUG_WEATHER
  void outputWeather();
  void outputWeather(
    map<size_t, shared_ptr<wx::FireWeather>>& weather,
    const char* file_name);
#endif
  int year_;
  bool is_out_of_time_ = false;
  bool should_output_interim_ = false;
  bool is_being_cancelled_ = false;
  size_t scenarios_done_ = 0;
  size_t scenarios_required_done_ = 0;
  atomic<size_t> scenarios_last_save_ = 0;
  size_t scenarios_per_iteration_ = 0;
  size_t iterations_done_ = 0;
  bool interim_changed_ = true;
  bool is_over_simulation_count_ = false;
  wx::FwiWeather yesterday_;
  // /**
  //  * @brief Time when we last checked if simulation should end
  //  *
  //  */
  std::chrono::steady_clock::time_point last_checked_;
  MathSize latitude_;
  MathSize longitude_;
private:
  mutex mutex_;
};
}
}