add MINIMUM_ACTIVE_SIMULATIONS = 3 default setting

Author: jordan-evens

settings.ini

@@ -32,6 +32,8 @@ MAXIMUM_TIME = 0
 INTERIM_OUTPUT_INTERVAL = 240
 # minimum number of simulations to do (0 is exactly 1 simulation per scenario)
 MINIMUM_SIMULATIONS = 10
+# minimum number of simulations where any spread occurs to do (0 is exactly 1 simulation per scenario)
+MINIMUM_ACTIVE_SIMULATIONS = 3
 # maximum number of simulations to do (0 is exactly 1 simulation per scenario)
 MAXIMUM_SIMULATIONS = 10000
 # maximum percent change in statistics between runs before results are consider stable [0 - 1]

src/cpp/fs/Model.cpp

@@ -29,7 +29,8 @@ Model::Model(
   : output_directory_(output_directory), start_time_(start_time), running_since_(Clock::now()),
     time_limit_(Settings::maximumTimeSeconds()), no_interim_save_since_(Clock::now()),
     interim_save_interval_(Settings::interimOutputIntervalSeconds()), env_(env),
-    latitude_(start_point.latitude()), longitude_(start_point.longitude())
+    latitude_(start_point.latitude()), longitude_(start_point.longitude()),
+    active_simulations_still_required_(Settings::minimumActiveSimulationCount())
 {
   logging::debug("Calculating for (%f, %f)", start_point.latitude(), start_point.longitude());
   const auto nd_for_point = calculate_nd_ref_for_point(env->elevation(), start_point);
@@ -475,6 +476,10 @@ bool Model::shouldStop() const noexcept
 }
 bool Model::isOutOfTime() const noexcept { return is_out_of_time_; }
 bool Model::isUnderSimulationCountMinimum() const noexcept { return is_under_simulation_minimum_; }
+size_t Model::activeSimulationsStillRequired() const noexcept
+{
+  return active_simulations_still_required_;
+}
 bool Model::isOverSimulationCountMaximum() const noexcept { return is_over_simulation_count_; }
 shared_ptr<ProbabilityMap> Model::makeProbabilityMap(
   const DurationSize time,
@@ -552,6 +557,29 @@ bool Model::add_statistics(
   {
     return true;
   }
+  active_simulations_still_required_ = [&]() {
+    size_t num_left = Settings::minimumActiveSimulationCount();
+    for (const auto s : *all_sizes)
+    {
+      if (s > initial_size())
+      {
+        --num_left;
+      }
+      if (0 == num_left)
+      {
+        logging::note("Found enough active simulations to meet minimum");
+        return num_left;
+      }
+    }
+    logging::note(
+      "Not enough active simulations out of %ld results to meet minimum", all_sizes->size()
+    );
+    return num_left;
+  }();
+  if (0 < activeSimulationsStillRequired())
+  {
+    return true;
+  }
   is_over_simulation_count_ = all_sizes->size() >= Settings::maximumSimulationCount();
   if (isOverSimulationCountMaximum())
   {
@@ -597,15 +625,6 @@ size_t runs_required(
     logging::note("Stopping after iteration %ld because running in deterministic mode", i);
     return 0;
   }
-  if (model.isUnderSimulationCountMinimum())
-  {
-    logging::debug(
-      "Continuing after %d iterations. Simulation minimum of %d simulations has not been reached.",
-      i,
-      Settings::minimumSimulationCount()
-    );
-    return Settings::minimumSimulationCount() - i;
-  }
   if (model.isOverSimulationCountMaximum())
   {
     logging::note(
@@ -624,6 +643,27 @@ size_t runs_required(
     );
     return 0;
   }
+  const auto max_sims_left = Settings::maximumSimulationCount() - i;
+  if (model.isUnderSimulationCountMinimum())
+  {
+    logging::debug(
+      "Continuing after %d iterations. Simulation minimum of %d simulations has not been reached.",
+      i,
+      Settings::minimumSimulationCount()
+    );
+    return min(max_sims_left, Settings::minimumSimulationCount() - i);
+  }
+  const auto active_still_required = model.activeSimulationsStillRequired();
+  if (0 < active_still_required)
+  {
+    logging::debug(
+      "Continuing after %d iterations. Active simulation minimum of %d simulations has not been reached.",
+      i,
+      Settings::minimumActiveSimulationCount()
+    );
+    // HACK: if we have n active sims so far then expect that many per i simulations?
+    return min(max_sims_left, i * active_still_required);
+  }
   // HACK: statistics don't work if only one value, so need at least 2
   const auto min_values = min(min(all_sizes->size(), means->size()), pct->size());
   if (1 >= min_values)

src/cpp/fs/Model.h

@@ -6,6 +6,7 @@
 #include "FireWeather.h"
 #include "Iteration.h"
 #include "Perimeter.h"
+#include "unstable.h"
 namespace fs
 {
 class StartPoint;
@@ -207,6 +208,11 @@ class Model
    * \return Whether or not simulation is under min simulation count
    */
   [[nodiscard]] bool isUnderSimulationCountMinimum() const noexcept;
+  /**
+   * \brief How many active simulations are still needed
+   * \return How many active simulations are still needed
+   */
+  [[nodiscard]] size_t activeSimulationsStillRequired() const noexcept;
   /**
    * \brief Whether or not simulation is over max simulation count
    * \return Whether or not simulation is over max simulation count
@@ -478,6 +484,10 @@ class Model
    * \brief If simulation is undex min simulation count
    */
   bool is_under_simulation_minimum_{true};
+  /**
+   * \brief Number of active simulations still required
+   */
+  size_t active_simulations_still_required_{};
   /**
    * \brief If simulation is over max simulation count
    */

src/cpp/fs/Settings.cpp

@@ -253,6 +253,14 @@ class SettingsImplementation
   {
     return minimum_simulation_count_;
   }
+  /**
+   * \brief Minimum number of simulations that must run before stopping
+   * \return Minimum number of simulations that must run before stopping
+   */
+  [[nodiscard]] constexpr size_t minimumActiveSimulationCount() noexcept
+  {
+    return minimum_active_simulation_count_;
+  }
   /**
    * \brief Maximum number of simulations before stopping and whatever results it has are used
    * \return Maximum number of simulations before stopping and whatever results it has are used
@@ -383,6 +391,10 @@ class SettingsImplementation
    * \brief Minimum number of simulations that must run before stopping
    */
   size_t minimum_simulation_count_;
+  /**
+   * \brief Minimum number of simulations with any spread that must run before stopping
+   */
+  size_t minimum_active_simulation_count_;
   /**
    * \brief Maximum number of simulations before stopping and whatever results it has are used
    */
@@ -581,6 +593,7 @@ void SettingsImplementation::setRoot(const char* dirname) noexcept
     maximum_time_seconds_ = stol(get_value(settings, "MAXIMUM_TIME"));
     interim_output_interval_seconds_ = stol(get_value(settings, "INTERIM_OUTPUT_INTERVAL"));
     minimum_simulation_count_ = stol(get_value(settings, "MINIMUM_SIMULATIONS"));
+    minimum_active_simulation_count_ = stol(get_value(settings, "MINIMUM_ACTIVE_SIMULATIONS"));
     maximum_simulation_count_ = stol(get_value(settings, "MAXIMUM_SIMULATIONS"));
     threshold_scenario_weight_ = stod(get_value(settings, "THRESHOLD_SCENARIO_WEIGHT"));
     threshold_daily_weight_ = stod(get_value(settings, "THRESHOLD_DAILY_WEIGHT"));
@@ -803,6 +816,10 @@ size_t Settings::minimumSimulationCount() noexcept
 {
   return SettingsImplementation::instance().minimumSimulationCount();
 }
+size_t Settings::minimumActiveSimulationCount() noexcept
+{
+  return SettingsImplementation::instance().minimumActiveSimulationCount();
+}
 size_t Settings::maximumSimulationCount() noexcept
 {
   return SettingsImplementation::instance().maximumSimulationCount();

src/cpp/fs/Settings.h

@@ -304,6 +304,11 @@ class Settings
    * \return Minimum number of simulations that must run before stopping
    */
   [[nodiscard]] static size_t minimumSimulationCount() noexcept;
+  /**
+   * \brief Minimum number of simulations that must run before stopping
+   * \return Minimum number of simulations that must run before stopping
+   */
+  [[nodiscard]] static size_t minimumActiveSimulationCount() noexcept;
   /**
    * \brief Maximum number of simulations before stopping and whatever results it has are used
    * \return Maximum number of simulations before stopping and whatever results it has are used