Scenario.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, 2024-2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include "stdafx.h"
#include "EventCompare.h"
#include "FireWeather.h"
#include "IntensityMap.h"
#include "Model.h"
#include "Settings.h"
#include "StartPoint.h"
#include "InnerPos.h"
#include "FireSpread.h"
#include "CellPoints.h"
 
namespace fs::sim
{
class LogPoints;
class IObserver;
class Event;
using topo::Location;
using topo::Position;
using PointSet = vector<InnerPos>;
struct IObserver_deleter
{
  void operator()(IObserver*) const;
};
class Scenario
  : public logging::SelfLogger
{
public:
  [[nodiscard]] static size_t completed() noexcept;
  [[nodiscard]] static size_t count() noexcept;
  [[nodiscard]] static size_t total_steps() noexcept;
  [[nodiscard]] constexpr size_t weightedDsr() const noexcept
  {
    return weather_->weightedDsr();
  }
  virtual ~Scenario();
  Scenario(Model* model,
           size_t id,
           wx::FireWeather* weather,
           wx::FireWeather* weather_daily,
           DurationSize start_time,
           //  const shared_ptr<IntensityMap>& initial_intensity,
           const shared_ptr<topo::Perimeter>& perimeter,
           const topo::StartPoint& start_point,
           Day start_day,
           Day last_date);
  Scenario(Model* model,
           size_t id,
           wx::FireWeather* weather,
           wx::FireWeather* weather_daily,
           DurationSize start_time,
           const shared_ptr<topo::Cell>& start_cell,
           const topo::StartPoint& start_point,
           Day start_day,
           Day last_date);
  Scenario(Scenario&& rhs) noexcept;
  Scenario(const Scenario& rhs) = delete;
  Scenario& operator=(Scenario&& rhs) noexcept;
  Scenario& operator=(const Scenario& rhs) const = delete;
  // HACK: use for surface right now
  [[nodiscard]] Scenario* reset_with_new_start(const shared_ptr<topo::Cell>& start_cell,
                                               util::SafeVector* final_sizes);
  [[nodiscard]] Scenario* reset(mt19937* mt_extinction,
                                mt19937* mt_spread,
                                util::SafeVector* final_sizes);
  void burn(const Event& event);
  void cancel(bool show_warning) noexcept;
  [[nodiscard]]
#ifdef NDEBUG
  constexpr
#endif
    topo::Cell
    cell(const Idx row, const Idx column) const
  {
    return model_->cell(row, column);
  }
  template <class P>
  [[nodiscard]] constexpr topo::Cell cell(const Position<P>& position) const
  {
    return model_->cell(position);
  }
  [[nodiscard]] constexpr Idx rows() const
  {
    return model_->rows();
  }
  [[nodiscard]] constexpr Idx columns() const
  {
    return model_->columns();
  }
  [[nodiscard]] constexpr MathSize cellSize() const
  {
    return model_->cellSize();
  }
  [[nodiscard]] constexpr int64_t simulation() const
  {
    return simulation_;
  }
  [[nodiscard]] constexpr const topo::StartPoint& startPoint() const
  {
    return start_point_;
  }
  [[nodiscard]] constexpr DurationSize startTime() const
  {
    return start_time_;
  }
  [[nodiscard]] constexpr size_t id() const
  {
    return id_;
  }
  [[nodiscard]] constexpr const Model& model() const
  {
    return *model_;
  }
  [[nodiscard]] constexpr DurationSize dayStart(const size_t for_day) const
  {
    return start_point_.dayStart(for_day);
  }
  [[nodiscard]] constexpr DurationSize dayEnd(const size_t for_day) const
  {
    return start_point_.dayEnd(for_day);
  }
  [[nodiscard]] const wx::FwiWeather* weather(const DurationSize time) const
  {
    return weather_->at(time);
  }
  [[nodiscard]] const wx::FwiWeather* weather_daily(const DurationSize time) const
  {
    return weather_daily_->at(time);
  }
  [[nodiscard]] constexpr int nd(const DurationSize time) const
  {
    return model().nd(time);
  }
  [[nodiscard]] ThresholdSize extinctionThreshold(const DurationSize time) const
  {
    return extinction_thresholds_.at(util::time_index(time - start_day_));
  }
  [[nodiscard]] ThresholdSize spreadThresholdByRos(const DurationSize time) const
  {
    return spread_thresholds_by_ros_.at(util::time_index(time - start_day_));
  }
  [[nodiscard]] constexpr bool isAtNight(const DurationSize time) const
  {
    const auto day = static_cast<Day>(time);
    const auto hour_part = 24 * (time - day);
    return hour_part < dayStart(day) || hour_part > dayEnd(day);
  }
  [[nodiscard]] MathSize minimumFfmcForSpread(const DurationSize time) const noexcept
  {
    return isAtNight(time) ? Settings::minimumFfmcAtNight() : Settings::minimumFfmc();
  }
  [[nodiscard]] bool isSurrounded(const Location& location) const;
  template <class P>
  [[nodiscard]] bool isSurrounded(const Position<P>& position) const
  {
    return isSurrounded(Location{position.hash()});
  }
  [[nodiscard]] topo::Cell cell(const InnerPos& p) const noexcept;
  Scenario* run(map<DurationSize, ProbabilityMap*>* probabilities);
  void scheduleFireSpread(const Event& event);
  [[nodiscard]] MathSize currentFireSize() const;
  [[nodiscard]] bool canBurn(const topo::Cell& location) const;
  //  [[nodiscard]] bool canBurn(HashSize hash) const;
  [[nodiscard]] bool hasBurned(const Location& location) const;
  template <class P>
  [[nodiscard]] bool hasBurned(const Position<P>& position) const
  {
    return hasBurned(Location{position.hash()});
  }
  //  [[nodiscard]] bool hasBurned(HashSize hash) const;
  void addEvent(Event&& event);
  // bool evaluateNextEvent();
  void evaluateNextEvent();
  void endSimulation() noexcept;
  void addSaveByOffset(int offset);
  template <class V>
  void addSave(V time);
  void saveObservers(const string& base_name) const;
  void saveObservers(DurationSize time) const;
  void saveIntensity(const string& dir, const string& base_name) const;
  [[nodiscard]] bool ran() const noexcept;
  [[nodiscard]] bool survives(const DurationSize time,
                              const topo::Cell& cell,
                              const DurationSize time_at_location) const
  {
    if (Settings::deterministic())
    {
      // always survive if deterministic
      return true;
    }
    try
    {
      const auto fire_wx = weather_;
      // // NOTE: Does using daily makes sense if we're looking at moisture?
      // // HACK: use daily with diurnal curves to be consistent with pre-hourly wx version
      // const auto fire_wx = weather_daily_;
      const auto wx = fire_wx->at(time);
      // use Mike's table
      const auto mc = wx->mcDmcPct();
      if (100 > mc
          || (109 >= mc && 5 > time_at_location)
          || (119 >= mc && 4 > time_at_location)
          || (131 >= mc && 3 > time_at_location)
          || (145 >= mc && 2 > time_at_location)
          || (218 >= mc && 1 > time_at_location))
      {
        return true;
      }
      // we can look by fuel type because the entire landscape shares the weather
      return extinctionThreshold(time) < fire_wx->survivalProbability(
               time,
               cell.fuelCode());
    }
    catch (const std::out_of_range& e)
    {
      // FIX: just ignore for now
      // std::cerr << e.what() << '\n';
      // logging::warning("Survival is checking for weather that doesn't exist at %f", time);
      // no weather, so don't survive
      return false;
    }
  }
  [[nodiscard]] vector<DurationSize> savePoints() const;
  void saveStats(DurationSize time) const;
  void registerObserver(IObserver* observer);
  void notify(const Event& event) const;
  void evaluate(const Event& event);
  void clear() noexcept;
protected:
  string add_log(const char* format) const noexcept override;
  Scenario(Model* model,
           size_t id,
           wx::FireWeather* weather,
           wx::FireWeather* weather_daily,
           DurationSize start_time,
           //  const shared_ptr<IntensityMap>& initial_intensity,
           const shared_ptr<topo::Perimeter>& perimeter,
           const shared_ptr<topo::Cell>& start_cell,
           topo::StartPoint start_point,
           Day start_day,
           Day last_date);
  list<unique_ptr<IObserver, IObserver_deleter>> observers_{};
  vector<DurationSize> save_points_;
  vector<ThresholdSize> extinction_thresholds_{};
  vector<ThresholdSize> spread_thresholds_by_ros_{};
  DurationSize current_time_;
  CellPointsMap points_;
  BurnedData* unburnable_;
  set<Event, EventCompare> scheduler_;
  unique_ptr<IntensityMap> intensity_;
  // /**
  //  * @brief Initial intensity map based off perimeter
  //  */
  // shared_ptr<IntensityMap> initial_intensity_;
  shared_ptr<topo::Perimeter> perimeter_;
  map<topo::SpreadKey, SpreadInfo> spread_info_{};
  map<topo::Cell, DurationSize> arrival_{};
  MathSize max_ros_;
  shared_ptr<topo::Cell> start_cell_;
  wx::FireWeather* weather_;
  wx::FireWeather* weather_daily_;
  Model* model_;
  map<DurationSize, ProbabilityMap*>* probabilities_;
  util::SafeVector* final_sizes_;
  topo::StartPoint start_point_;
  size_t id_;
  DurationSize start_time_;
  DurationSize last_save_;
  size_t current_time_index_ = numeric_limits<size_t>::max();
  int64_t simulation_;
  Day start_day_;
  Day last_date_;
  bool ran_;
  bool cancelled_ = false;
  shared_ptr<LogPoints> log_points_;
  size_t step_;
  size_t oob_spread_;
};
}