use std::optional for settings

Author: jordan-evens

src/cpp/firestarr.cpp

@@ -160,7 +160,7 @@ int main(const int argc, const char* const argv[])
       // HACK: ISI for yesterday really doesn't matter so just use any wind
       // HACK: it's basically wrong to assign this precip to yesterday's object,
       // but don't want to add another argument right now
-      const FwiWeather yesterday{settings.get_yesterday_weather()};
+      const FwiWeather yesterday{settings.get_weather()};
       fs::fix_tm(&start_date);
       fs::logging::note(
         "Simulation start time after fix_tm() again is %d-%02d-%02d %02d:%02d",
@@ -180,7 +180,7 @@ int main(const int argc, const char* const argv[])
         start_point,
         start,
         settings.perimeter,
-        settings.initial_size
+        settings.initial_size.value_or(0)
       );
       Log::closeLogFile();
     }

src/cpp/fs/ArgumentParser.cpp

@@ -65,6 +65,17 @@ void register_setter(T& variable, string v, string help, bool required, std::fun
   register_argument(v, help, required, [&variable, fct] { variable = fct(); });
 }
 template <class T>
+void register_setter(
+  std::optional<T>& variable,
+  string v,
+  string help,
+  bool required,
+  std::function<T()> fct
+)
+{
+  register_argument(v, help, required, [&variable, fct] { variable = fct(); });
+}
+template <class T>
 void register_setter(
   atomic<T>& variable,
   string v,
@@ -82,6 +93,11 @@ void register_index(T& index, string v, string help, bool required)
 {
   register_argument(v, help, required, [&] { index = parse_index<T>(); });
 }
+template <class T>
+void register_index(std::optional<T>& index, string v, string help, bool required)
+{
+  register_argument(v, help, required, [&] { index = parse_index<T>(); });
+}
 string ArgumentParser::get_args()
 {
   std::string args{arguments_.at(0)};

src/cpp/fs/Settings.cpp

@@ -6,6 +6,7 @@
 #include "FuelLookup.h"
 #include "Log.h"
 #include "Trim.h"
+#include "unstable.h"
 #include "Util.h"
 namespace fs::settings
 {
@@ -92,6 +93,7 @@ constexpr string to_string(const Mode mode)
     case Mode::Surface:
       return "SURFACE";
   }
+  return logging::fatal<string>("Mode %s not handled", mode);
 };
 string ModeOptions()
 {
@@ -415,15 +417,15 @@ void Settings::saveTo(const string& output_directory) const noexcept
   }
   if (Mode::Test == mode)
   {
-    put("FUEL", "initial fire size", initial_size);
+    put("FUEL", "fbp fuel type", fuel_name);
     put("TEST_ALL", "test every combination of settings for tests", test_all);
     put("HOURS", "number of hours to run tests for", hours);
   }
   if (Mode::Simulation != mode)
   {
-    put("FFMC", "fine fuel moisture code", ffmc.value);
-    put("DMC", "duff moisture code", dmc.value);
-    put("DC", "drought code", dc.value);
+    put("FFMC", "fine fuel moisture code", ffmc);
+    put("DMC", "duff moisture code", dmc);
+    put("DC", "drought code", dc);
     put("WD", "wind direction (degrees)", wind_direction);
     put("WS", "wind speed (km/h)", wind_speed);
   }
@@ -435,32 +437,21 @@ void Settings::saveTo(const string& output_directory) const noexcept
   // FIX: don't have output for set/getRoot()
   // put("", "", );
 }
-FwiWeather Settings::get_test_weather() const
+FwiWeather Settings::get_weather() const
 {
   return {
     Weather{
       Temperature::Zero(),
       RelativeHumidity::Zero(),
-      Wind{Speed{wind_speed}, Direction{Degrees{wind_direction}}},
-      Precipitation::Zero()
-    },
-    ffmc,
-    dmc,
-    dc
-  };
-}
-FwiWeather Settings::get_yesterday_weather() const
-{
-  return {
-    Weather{
-      Temperature::Zero(),
-      RelativeHumidity::Zero(),
-      Wind{Speed{wind_speed}, Direction{Degrees{wind_direction}}},
+      Wind{
+        Speed{wind_speed.value_or(Speed::Invalid().value)},
+        Direction{Degrees{wind_direction.value_or(Direction::Invalid().value)}}
+      },
       {apcp_prev}
     },
-    ffmc,
-    dmc,
-    dc
+    ffmc.value_or(Ffmc::Invalid()),
+    dmc.value_or(Dmc::Invalid()),
+    dc.value_or(Dc::Invalid())
   };
 }
 }

src/cpp/fs/Settings.h

@@ -177,34 +177,33 @@ class Settings
   LazyFuelLookup fuel_lookup{};
   // Days to output probability contours for (1 is start date, 2 is day after, etc.)
   OutputDateOffsets output_date_offsets{};
-  FwiWeather get_yesterday_weather() const;
+  FwiWeather get_weather() const;
   // FIX: need to get rain since noon yesterday to start of this hourly weather
   Precipitation apcp_prev{Precipitation::Zero()};
 
 public:
   // normal mode only variables
   // initial fire size (ha)
-  size_t initial_size{0};
+  std::optional<size_t> initial_size{};
 
 public:
   // test mode only variables
   // name of fuel to use for test
-  string fuel_name{};
+  std::optional<string> fuel_name{};
   // test every combination of settings for tests
-  bool test_all{false};
+  std::optional<bool> test_all{};
   // number of hours to run tests for
-  MathSize hours{INVALID_TIME};
-  FwiWeather get_test_weather() const;
+  std::optional<MathSize> hours{};
 
 public:
   // test/surface mode variables
-  Ffmc ffmc{Ffmc::Invalid()};
-  Dmc dmc{Dmc::Invalid()};
-  Dc dc{Dc::Invalid()};
-  MathSize wind_direction{Direction::Invalid().value};
-  MathSize wind_speed{Speed::Invalid().value};
-  SlopeSize slope = static_cast<SlopeSize>(INVALID_SLOPE);
-  AspectSize aspect = static_cast<AspectSize>(INVALID_ASPECT);
+  std::optional<Ffmc> ffmc{};
+  std::optional<Dmc> dmc{};
+  std::optional<Dc> dc{};
+  std::optional<MathSize> wind_direction{};
+  std::optional<MathSize> wind_speed{};
+  std::optional<SlopeSize> slope{};
+  std::optional<AspectSize> aspect{};
 
 private:
   /**

src/cpp/fs/StrictType.h

@@ -102,6 +102,7 @@ struct StrictType
     value /= rhs.value;
     return *this;
   }
+  operator string() noexcept { return string(value); }
 };
 template <class ConcreteType, units::UnitType Units, class ValueType, int InvalidValue>
 [[nodiscard]] constexpr ConcreteType operator*(

src/cpp/fs/Test.cpp

@@ -302,14 +302,7 @@ void show_options(const char* name, const vector<string>& values)
 };
 int test(Settings& settings)
 {
-  const FwiWeather wx_test{settings.get_test_weather()};
   const auto output_directory{settings.output_directory};
-  const auto num_hours{settings.hours};
-  const ptr<const FwiWeather> wx{&wx_test};
-  const auto constant_fuel_name{settings.fuel_name};
-  const auto constant_slope{settings.slope};
-  const auto constant_aspect{settings.aspect};
-  const auto test_all{settings.test_all};
   static const AspectSize ASPECT_INCREMENT = 90;
   static const SlopeSize SLOPE_INCREMENT = 60;
   static const int WS_INCREMENT = 5;
@@ -344,24 +337,20 @@ int test(Settings& settings)
   settings.save_points = false;
   // make sure all tests run regardless of how long it takes
   settings.maximum_time_seconds = numeric_limits<size_t>::max();
-  const auto hours = INVALID_TIME == num_hours ? DEFAULT_HOURS : num_hours;
-  const auto ffmc = (fs::Ffmc::Invalid() == wx->ffmc) ? DEFAULT_FFMC : wx->ffmc;
-  const auto dmc = (fs::Dmc::Invalid() == wx->dmc) ? DEFAULT_DMC : wx->dmc;
-  const auto dc = (fs::Dc::Invalid() == wx->dc) ? DEFAULT_DC : wx->dc;
-  // HACK: need to compare value and not object
-  const auto wind_direction = (fs::Direction::Invalid().value == wx->wind.direction.value)
-                              ? DEFAULT_WIND_DIRECTION
-                              : wx->wind.direction;
-  const auto wind_speed =
-    (fs::Speed::Invalid().value == wx->wind.speed.value) ? DEFAULT_WIND_SPEED : wx->wind.speed;
-  const auto wind = fs::Wind{wind_speed, wind_direction};
-  const auto slope = (INVALID_SLOPE == constant_slope) ? DEFAULT_SLOPE : constant_slope;
-  const auto aspect = (INVALID_ASPECT == constant_aspect) ? DEFAULT_ASPECT : constant_aspect;
-  const auto fixed_fuel_name = simplify_fuel_name(constant_fuel_name);
+  const auto hours{settings.hours.value_or(DEFAULT_HOURS)};
+  const auto ffmc{settings.ffmc.value_or(DEFAULT_FFMC)};
+  const auto dmc{settings.dmc.value_or(DEFAULT_DMC)};
+  const auto dc{settings.dc.value_or(DEFAULT_DC)};
+  const Direction wind_direction{settings.wind_direction.value_or(DEFAULT_WIND_DIRECTION.value)};
+  const Speed wind_speed{settings.wind_speed.value_or(DEFAULT_WIND_SPEED.value)};
+  const Wind wind{wind_speed, wind_direction};
+  const auto slope{settings.slope.value_or(DEFAULT_SLOPE)};
+  const auto aspect{settings.aspect.value_or(DEFAULT_ASPECT)};
+  const auto fixed_fuel_name = simplify_fuel_name(settings.fuel_name.value_or(""));
   const auto fuel = (fixed_fuel_name.empty() ? DEFAULT_FUEL_NAME : fixed_fuel_name);
   try
   {
-    if (test_all)
+    if (settings.test_all.value_or(false))
     {
       size_t result = 0;
       // generate all options first so we can say how many there are at start
@@ -378,7 +367,7 @@ int test(Settings& settings)
         fuel_names.emplace_back(fuel);
       }
       auto slopes = vector<SlopeSize>();
-      if (INVALID_SLOPE == constant_slope)
+      if (!settings.slope.has_value())
       {
         for (SlopeSize slope = 0; slope <= 100; slope += SLOPE_INCREMENT)
         {
@@ -387,10 +376,10 @@ int test(Settings& settings)
       }
       else
       {
-        slopes.emplace_back(constant_slope);
+        slopes.emplace_back(slope);
       }
       auto aspects = vector<AspectSize>();
-      if (INVALID_ASPECT == constant_aspect)
+      if (!settings.aspect.has_value())
       {
         for (AspectSize aspect = 0; aspect < 360; aspect += ASPECT_INCREMENT)
         {
@@ -399,10 +388,10 @@ int test(Settings& settings)
       }
       else
       {
-        aspects.emplace_back(constant_aspect);
+        aspects.emplace_back(aspect);
       }
       auto wind_directions = vector<DirectionSize>();
-      if (fs::Direction::Invalid() == wx->wind.direction)
+      if (!settings.wind_direction.has_value())
       {
         for (auto wind_direction = 0; wind_direction < 360; wind_direction += WD_INCREMENT)
         {
@@ -411,10 +400,10 @@ int test(Settings& settings)
       }
       else
       {
-        wind_directions.emplace_back(static_cast<int>(wx->wind.direction.asDegreesSize()));
+        wind_directions.emplace_back(static_cast<int>(wind_direction.value));
       }
       auto wind_speeds = vector<int>();
-      if (fs::Speed::Invalid() == wx->wind.speed)
+      if (!settings.wind_speed.has_value())
       {
         for (auto wind_speed = 0; wind_speed <= MAX_WIND; wind_speed += WS_INCREMENT)
         {
@@ -423,7 +412,7 @@ int test(Settings& settings)
       }
       else
       {
-        wind_speeds.emplace_back(static_cast<int>(wx->wind.speed.value));
+        wind_speeds.emplace_back(static_cast<int>(wind_speed.value));
       }
       size_t values = 1;
       values *= fuel_names.size();