FBP45.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 "Duff.h"
#include "FireSpread.h"
#include "LookupTable.h"
#include "StandardFuel.h"
#ifdef DEBUG_FUEL_VARIABLE
#include "Log.h"
#endif
namespace fs::fuel
{
[[nodiscard]] constexpr bool calculate_is_green(const int nd)
{
  return nd >= 30;
}
static constexpr int START_GREENING = -43;
[[nodiscard]] constexpr int calculate_grass_curing(const int nd)
{
  const auto curing = (nd < START_GREENING)
                      ?   // we're before foliar moisture dip has started
                        100
                      : (nd >= 50)
                          ? 0   // foliar moisture is at 120.0, so grass should be totally uncured
                          // HACK: invent a formula that has 50% curing at the bottom of the foliar
                          // moisture dip foliar moisture above ranges between 120 and 85, with 85
                          // being at the point where we want 50% cured Curing:
                          // -43 => 100, 0 => 50, 50 => 0 least-squares best fit:
                          : static_cast<int>(52.5042 - 1.07324 * nd);
  return max(0, min(100, curing));
}
[[nodiscard]] static MathSize
  calculate_surface_fuel_consumption_mixed_or_c2(const MathSize bui) noexcept
{
  return 5.0 * (1.0 - exp(-0.0115 * bui));
}
static const util::LookupTable<&calculate_surface_fuel_consumption_mixed_or_c2>
  SURFACE_FUEL_CONSUMPTION_MIXED_OR_C2{};
[[nodiscard]] static MathSize
  calculate_surface_fuel_consumption_d1(const MathSize bui) noexcept
{
  return 1.5 * (1.0 - exp(-0.0183 * bui));
}
static util::LookupTable<&calculate_surface_fuel_consumption_d1>
  SURFACE_FUEL_CONSUMPTION_D1{};
template <int A, int B, int C, int Bui0, int Cbh, int Cfl, int BulkDensity, int InorganicPercent, int DuffDepth>
class FuelNonMixed
  : public StandardFuel<A, B, C, Bui0, Cbh, Cfl, BulkDensity, InorganicPercent, DuffDepth>
{
public:
  FuelNonMixed() = delete;
  ~FuelNonMixed() override = default;
  FuelNonMixed(const FuelNonMixed& rhs) noexcept = delete;
  FuelNonMixed(FuelNonMixed&& rhs) noexcept = delete;
  FuelNonMixed& operator=(const FuelNonMixed& rhs) noexcept = delete;
  FuelNonMixed& operator=(FuelNonMixed&& rhs) noexcept = delete;
protected:
  using StandardFuel<A, B, C, Bui0, Cbh, Cfl, BulkDensity, InorganicPercent, DuffDepth>::
    StandardFuel;
  [[nodiscard]] MathSize calculateIsf(const SpreadInfo& spread,
                                      const MathSize isi) const noexcept override
  {
    return this->limitIsf(1.0,
                          calculateRos(spread.nd(),
                                       *spread.weather(),
                                       isi)
                            * spread.slopeFactor());
  }
  virtual 
    MathSize
    calculateRos(const int,
                 const wx::FwiWeather&,
                 const MathSize isi) const noexcept override
  {
    return this->rosBasic(isi);
  }
};
template <int A, int B, int C, int Bui0, int Cbh, int Cfl, int BulkDensity, int InorganicPercent, int DuffDepth>
class FuelConifer
  : public FuelNonMixed<A, B, C, Bui0, Cbh, Cfl, BulkDensity, InorganicPercent, DuffDepth>
{
public:
  FuelConifer() = delete;
  ~FuelConifer() override = default;
  FuelConifer(const FuelConifer& rhs) noexcept = delete;
  FuelConifer(FuelConifer&& rhs) noexcept = delete;
  FuelConifer& operator=(const FuelConifer& rhs) noexcept = delete;
  FuelConifer& operator=(FuelConifer&& rhs) noexcept = delete;
protected:
  constexpr FuelConifer(const FuelCodeSize& code,
                        const char* name,
                        const LogValue log_q,
                        const Duff* duff_ffmc,
                        const Duff* duff_dmc)
    : FuelNonMixed<A, B, C, Bui0, Cbh, Cfl, BulkDensity, InorganicPercent, DuffDepth>(code,
                                                                                      name,
                                                                                      true,
                                                                                      log_q,
                                                                                      duff_ffmc,
                                                                                      duff_dmc)
  {
  }
  constexpr FuelConifer(const FuelCodeSize& code,
                        const char* name,
                        const LogValue log_q,
                        const Duff* duff)
    : FuelConifer(code,
                  name,
                  log_q,
                  duff,
                  duff)
  {
  }
};
[[nodiscard]] static MathSize
  calculate_surface_fuel_consumption_jackpine(
    const MathSize bui) noexcept
{
  return 5.0 * pow(1.0 - exp(-0.0164 * bui), 2.24);
}
static util::LookupTable<&calculate_surface_fuel_consumption_jackpine>
  SURFACE_FUEL_CONSUMPTION_JACKPINE{};
template <int A, int B, int C, int Bui0, int Cbh, int Cfl, int BulkDensity, int DuffDepth>
class FuelJackpine
  : public FuelConifer<A, B, C, Bui0, Cbh, Cfl, BulkDensity, 15, DuffDepth>
{
public:
  FuelJackpine() = delete;
  ~FuelJackpine() override = default;
  FuelJackpine(const FuelJackpine& rhs) noexcept = delete;
  FuelJackpine(FuelJackpine&& rhs) noexcept = delete;
  FuelJackpine& operator=(const FuelJackpine& rhs) noexcept = delete;
  FuelJackpine& operator=(FuelJackpine&& rhs) noexcept = delete;
  using FuelConifer<A, B, C, Bui0, Cbh, Cfl, BulkDensity, 15, DuffDepth>::FuelConifer;
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return SURFACE_FUEL_CONSUMPTION_JACKPINE(spread.bui().asValue());
  }
};
[[nodiscard]] static MathSize
  calculate_surface_fuel_consumption_pine(const MathSize bui) noexcept
{
  return 5.0 * pow(1.0 - exp(-0.0149 * bui), 2.48);
}
static util::LookupTable<&calculate_surface_fuel_consumption_pine>
  SURFACE_FUEL_CONSUMPTION_PINE{};
template <int A, int B, int C, int Bui0, int Cbh, int Cfl, int BulkDensity, int DuffDepth>
class FuelPine : public FuelConifer<A, B, C, Bui0, Cbh, Cfl, BulkDensity, 15, DuffDepth>
{
public:
  FuelPine() = delete;
  ~FuelPine() override = default;
  FuelPine(const FuelPine& rhs) noexcept = delete;
  FuelPine(FuelPine&& rhs) noexcept = delete;
  FuelPine& operator=(const FuelPine& rhs) noexcept = delete;
  FuelPine& operator=(FuelPine&& rhs) noexcept = delete;
  using FuelConifer<A, B, C, Bui0, Cbh, Cfl, BulkDensity, 15, DuffDepth>::FuelConifer;
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return SURFACE_FUEL_CONSUMPTION_PINE(spread.bui().asValue());
  }
};
namespace fbp
{
class FuelD1 : public FuelNonMixed<30, 232, 160, 32, 0, 0, 61, 59, 24>
{
public:
  FuelD1() = delete;
  ~FuelD1() override = default;
  FuelD1(const FuelD1& rhs) noexcept = delete;
  FuelD1(FuelD1&& rhs) noexcept = delete;
  FuelD1& operator=(const FuelD1& rhs) noexcept = delete;
  FuelD1& operator=(FuelD1&& rhs) noexcept = delete;
  explicit constexpr FuelD1(const FuelCodeSize& code) noexcept
    : FuelNonMixed(code,
                   "D-1",
                   false,
                   data::LOG_0_90,
                   &Duff::Peat)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return SURFACE_FUEL_CONSUMPTION_D1(spread.bui().asValue());
  }
  [[nodiscard]] MathSize isfD1(const SpreadInfo& spread,
                               MathSize ros_multiplier,
                               MathSize isi) const noexcept;
};
}
template <int A, int B, int C, int Bui0, int RosMultiplier, int PercentMixed, int BulkDensity, int InorganicPercent, int DuffDepth>
class FuelMixed
  : public StandardFuel<A, B, C, Bui0, 6, 80, BulkDensity, InorganicPercent, DuffDepth>
{
public:
  FuelMixed() = delete;
  ~FuelMixed() = default;
  FuelMixed(const FuelMixed& rhs) noexcept = delete;
  FuelMixed(FuelMixed&& rhs) noexcept = delete;
  FuelMixed& operator=(const FuelMixed& rhs) noexcept = delete;
  FuelMixed& operator=(FuelMixed&& rhs) noexcept = delete;
  constexpr FuelMixed(const FuelCodeSize& code,
                      const char* name,
                      const LogValue log_q)
    : StandardFuel<A, B, C, Bui0, 6, 80, BulkDensity, InorganicPercent, DuffDepth>(code,
                                                                                   name,
                                                                                   true,
                                                                                   log_q,
                                                                                   &Duff::Peat,
                                                                                   &Duff::Peat)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return SURFACE_FUEL_CONSUMPTION_MIXED_OR_C2(spread.bui().asValue());
  }
  [[nodiscard]] MathSize crownConsumption(const MathSize cfb) const noexcept override
  {
    return ratioConifer() * StandardFuel<A, B, C, Bui0, 6, 80, BulkDensity, InorganicPercent, DuffDepth>::crownConsumption(cfb);
  }
  [[nodiscard]] MathSize calculateRos(const int,
                                      const wx::FwiWeather&,
                                      const MathSize isi) const noexcept override
  {
    static const fbp::FuelD1 F{14};
    return ratioConifer() * this->rosBasic(isi) + rosMultiplier() * ratioDeciduous() * F.rosBasic(isi);
  }
  [[nodiscard]] MathSize calculateIsf(const SpreadInfo& spread,
                                      const MathSize isi) const noexcept override
  {
    return ratioConifer() * this->limitIsf(1.0, spread.slopeFactor() * this->rosBasic(isi))
         + ratioDeciduous() * isfD1(spread, isi);
  }
  [[nodiscard]] static constexpr MathSize ratioConifer()
  {
    return PercentMixed / 100.0;
  }
  [[nodiscard]] static constexpr MathSize ratioDeciduous()
  {
    return 1.0 - (PercentMixed / 100.0);
  }
protected:
  [[nodiscard]] static constexpr MathSize rosMultiplier()
  {
    return RosMultiplier / 10.0;
  }
  [[nodiscard]] static MathSize
    isfD1(const SpreadInfo& spread,
          const MathSize isi) noexcept
  {
    static const fbp::FuelD1 F{14};
    return F.isfD1(spread, rosMultiplier(), isi);
  }
};
template <int A, int B, int C, int Bui0, int RosMultiplier, int PercentDeadFir>
class FuelMixedDead
  : public FuelMixed<A, B, C, Bui0, RosMultiplier, PercentDeadFir, 61, 15, 75>
{
public:
  FuelMixedDead() = delete;
  ~FuelMixedDead() = default;
  FuelMixedDead(const FuelMixedDead& rhs) noexcept = delete;
  FuelMixedDead(FuelMixedDead&& rhs) noexcept = delete;
  FuelMixedDead& operator=(const FuelMixedDead& rhs) noexcept = delete;
  FuelMixedDead& operator=(FuelMixedDead&& rhs) noexcept = delete;
  constexpr FuelMixedDead(const FuelCodeSize& code,
                          const char* name,
                          const LogValue log_q)
    : FuelMixed<A, B, C, Bui0, RosMultiplier, PercentDeadFir, 61, 15, 75>(code,
                                                                          name,
                                                                          log_q)
  {
  }
};
template <int RosMultiplier, int RatioMixed>
class FuelMixedWood
  : public FuelMixed<110, 282, 150, 50, RosMultiplier, RatioMixed, 108, 25, 50>
{
public:
  FuelMixedWood() = delete;
  ~FuelMixedWood() = default;
  FuelMixedWood(const FuelMixedWood& rhs) noexcept = delete;
  FuelMixedWood(FuelMixedWood&& rhs) noexcept = delete;
  FuelMixedWood& operator=(const FuelMixedWood& rhs) noexcept = delete;
  FuelMixedWood& operator=(FuelMixedWood&& rhs) noexcept = delete;
  constexpr FuelMixedWood(const FuelCodeSize& code,
                          const char* name)
    : FuelMixed<110, 282, 150, 50, RosMultiplier, RatioMixed, 108, 25, 50>(code,
                                                                           name,
                                                                           data::LOG_0_80)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return this->ratioConifer() * FuelMixed<110, 282, 150, 50, RosMultiplier, RatioMixed, 108, 25, 50>::surfaceFuelConsumption(spread)
         + this->ratioDeciduous() * SURFACE_FUEL_CONSUMPTION_D1(spread.bui().asValue());
  }
};
[[nodiscard]] static constexpr MathSize
  calculate_length_to_breadth_grass(const MathSize ws) noexcept
{
  return ws < 1.0 ? 1.0 : (1.1 * pow(ws, 0.464));
}
static util::LookupTable<calculate_length_to_breadth_grass> LENGTH_TO_BREADTH_GRASS{};
[[nodiscard]] static constexpr MathSize
  calculate_base_multiplier_curing(const MathSize curing) noexcept
{
  return (curing >= 58.8)
         ? (0.176 + 0.02 * (curing - 58.8))
         : (0.005 * expm1(0.061 * curing));
}
static util::LookupTable<&calculate_base_multiplier_curing> BASE_MULTIPLIER_CURING{};
template <int A, int B, int C>
class FuelGrass
  : public StandardFuel<A, B, C, 1, 0, 0, 0, 0, static_cast<int>(DUFF_FFMC_DEPTH * 10.0)>
{
public:
  FuelGrass() = delete;
  ~FuelGrass() override = default;
  FuelGrass(const FuelGrass& rhs) noexcept = delete;
  FuelGrass(FuelGrass&& rhs) noexcept = delete;
  FuelGrass& operator=(const FuelGrass& rhs) noexcept = delete;
  FuelGrass& operator=(FuelGrass&& rhs) noexcept = delete;
  constexpr FuelGrass(const FuelCodeSize& code,
                      const char* name,
                      const LogValue log_q)
    // HACK: grass assumes no duff (total duff depth == ffmc depth => dmc depth is 0)
    : StandardFuel<A, B, C, 1, 0, 0, 0, 0, static_cast<int>(DUFF_FFMC_DEPTH * 10.0)>(code,
                                                                                     name,
                                                                                     false,
                                                                                     log_q,
                                                                                     &Duff::PeatMuck,
                                                                                     &Duff::PeatMuck)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo&) const noexcept override
  {
    return DEFAULT_GRASS_FUEL_LOAD;
  }
  [[nodiscard]] MathSize grass_curing(const int nd, const wx::FwiWeather& wx) const override
  {
    return wx.dc().asValue() > 500
           ?   // we're in drought conditions
             100
           : calculate_grass_curing(nd);
  }
  [[nodiscard]] MathSize baseMultiplier(const int nd,
                                        const wx::FwiWeather& wx) const noexcept
  {
    return BASE_MULTIPLIER_CURING(grass_curing(nd, wx));
  }
  [[nodiscard]] MathSize calculateIsf(const SpreadInfo& spread,
                                      const MathSize isi) const noexcept override
  {
    const auto mu = baseMultiplier(spread.nd(), *spread.weather());
    // prevent divide by 0
    const auto mu_not_zero = max(0.001, mu);
    return this->limitIsf(mu_not_zero, calculateRos(mu, isi) * spread.slopeFactor());
  }
  [[nodiscard]] MathSize calculateRos(const int nd,
                                      const wx::FwiWeather& wx,
                                      const MathSize isi) const noexcept override
  {
    return calculateRos(baseMultiplier(nd, wx), isi);
  }
protected:
  [[nodiscard]] MathSize lengthToBreadth(const MathSize ws) const noexcept override
  {
    return LENGTH_TO_BREADTH_GRASS(ws);
  }
private:
  [[nodiscard]] MathSize calculateRos(const MathSize multiplier,
                                      const MathSize isi) const noexcept
  {
    return multiplier * this->rosBasic(isi);
  }
};
namespace fbp
{
class FuelC1 : public FuelConifer<90, 649, 450, 72, 2, 75, 45, 5, 34>
{
public:
  FuelC1() = delete;
  ~FuelC1() override = default;
  FuelC1(const FuelC1& rhs) noexcept = delete;
  FuelC1(FuelC1&& rhs) noexcept = delete;
  FuelC1& operator=(const FuelC1& rhs) noexcept = delete;
  FuelC1& operator=(FuelC1&& rhs) noexcept = delete;
  explicit constexpr FuelC1(const FuelCodeSize& code) noexcept
    : FuelConifer(code,
                  "C-1",
                  data::LOG_0_90,
                  &Duff::Reindeer,
                  &Duff::Peat)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override;
};
class FuelC2 : public FuelConifer<110, 282, 150, 64, 3, 80, 34, 0, 100>
{
public:
  FuelC2() = delete;
  ~FuelC2() override = default;
  FuelC2(const FuelC2& rhs) noexcept = delete;
  FuelC2(FuelC2&& rhs) noexcept = delete;
  FuelC2& operator=(const FuelC2& rhs) noexcept = delete;
  FuelC2& operator=(FuelC2&& rhs) noexcept = delete;
  explicit constexpr FuelC2(const FuelCodeSize& code) noexcept
    : FuelConifer(code,
                  "C-2",
                  data::LOG_0_70,
                  &Duff::SphagnumUpper)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override;
};
class FuelC3 : public FuelJackpine<110, 444, 300, 62, 8, 115, 20, 65>
{
public:
  FuelC3() = delete;
  ~FuelC3() override = default;
  FuelC3(const FuelC3& rhs) noexcept = delete;
  FuelC3(FuelC3&& rhs) noexcept = delete;
  FuelC3& operator=(const FuelC3& rhs) noexcept = delete;
  FuelC3& operator=(FuelC3&& rhs) noexcept = delete;
  explicit constexpr FuelC3(const FuelCodeSize& code) noexcept
    : FuelJackpine(code,
                   "C-3",
                   data::LOG_0_75,
                   &Duff::FeatherMoss,
                   &Duff::PineSeney)
  {
  }
};
class FuelC4 : public FuelJackpine<110, 293, 150, 66, 4, 120, 31, 62>
{
public:
  FuelC4() = delete;
  ~FuelC4() override = default;
  FuelC4(const FuelC4& rhs) noexcept = delete;
  FuelC4(FuelC4&& rhs) noexcept = delete;
  FuelC4& operator=(const FuelC4& rhs) noexcept = delete;
  FuelC4& operator=(FuelC4&& rhs) noexcept = delete;
  explicit constexpr FuelC4(const FuelCodeSize& code) noexcept
    : FuelJackpine(code,
                   "C-4",
                   data::LOG_0_80,
                   &Duff::PineSeney)
  {
  }
};
class FuelC5 : public FuelPine<30, 697, 400, 56, 18, 120, 93, 46>
{
public:
  FuelC5() = delete;
  ~FuelC5() override = default;
  FuelC5(const FuelC5& rhs) noexcept = delete;
  FuelC5(FuelC5&& rhs) noexcept = delete;
  FuelC5& operator=(const FuelC5& rhs) noexcept = delete;
  FuelC5& operator=(FuelC5&& rhs) noexcept = delete;
  explicit constexpr FuelC5(const FuelCodeSize& code) noexcept
    : FuelPine(code,
               "C-5",
               data::LOG_0_80,
               &Duff::PineSeney)
  {
  }
};
class FuelC6 : public FuelPine<30, 800, 300, 62, 7, 180, 50, 50>
{
public:
  FuelC6() = delete;
  ~FuelC6() override = default;
  FuelC6(const FuelC6& rhs) noexcept = delete;
  FuelC6(FuelC6&& rhs) noexcept = delete;
  FuelC6& operator=(const FuelC6& rhs) noexcept = delete;
  FuelC6& operator=(FuelC6&& rhs) noexcept = delete;
  explicit constexpr FuelC6(const FuelCodeSize& code) noexcept
    : FuelPine(code,
               "C-6",
               data::LOG_0_80,
               &Duff::PineSeney)
  {
  }
protected:
  [[nodiscard]] MathSize finalRos(const SpreadInfo& spread,
                                  MathSize isi,
                                  MathSize cfb,
                                  MathSize rss) const noexcept override;
};
class FuelC7 : public FuelConifer<45, 305, 200, 106, 10, 50, 20, 15, 50>
{
public:
  FuelC7() = delete;
  ~FuelC7() override = default;
  FuelC7(const FuelC7& rhs) noexcept = delete;
  FuelC7(FuelC7&& rhs) noexcept = delete;
  FuelC7& operator=(const FuelC7& rhs) noexcept = delete;
  FuelC7& operator=(FuelC7&& rhs) noexcept = delete;
  explicit constexpr FuelC7(const FuelCodeSize& code) noexcept
    : FuelConifer(code,
                  "C-7",
                  data::LOG_0_85,
                  &Duff::SprucePine)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override;
};
class FuelD2 : public FuelNonMixed<6, 232, 160, 32, 0, 0, 61, 59, 24>
{
public:
  FuelD2() = delete;
  ~FuelD2() override = default;
  FuelD2(const FuelD2& rhs) noexcept = delete;
  FuelD2(FuelD2&& rhs) noexcept = delete;
  FuelD2& operator=(const FuelD2& rhs) noexcept = delete;
  FuelD2& operator=(FuelD2&& rhs) noexcept = delete;
  // HACK: assume same bulk_density and inorganicContent as D1
  explicit constexpr FuelD2(const FuelCodeSize& code) noexcept
    : FuelNonMixed(code,
                   "D-2",
                   false,
                   data::LOG_0_90,
                   &Duff::Peat)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override;
  [[nodiscard]] MathSize calculateRos(int nd,
                                      const wx::FwiWeather& wx,
                                      MathSize isi) const noexcept override;
};
template <int PercentConifer>
class FuelM1 : public FuelMixedWood<10, PercentConifer>
{
public:
  FuelM1() = delete;
  ~FuelM1() = default;
  FuelM1(const FuelM1& rhs) noexcept = delete;
  FuelM1(FuelM1&& rhs) noexcept = delete;
  FuelM1& operator=(const FuelM1& rhs) noexcept = delete;
  FuelM1& operator=(FuelM1&& rhs) noexcept = delete;
  constexpr FuelM1(const FuelCodeSize& code, const char* name)
    : FuelMixedWood<10, PercentConifer>(code, name)
  {
  }
};
template <int PercentConifer>
class FuelM2 : public FuelMixedWood<2, PercentConifer>
{
public:
  FuelM2() = delete;
  ~FuelM2() = default;
  FuelM2(const FuelM2& rhs) noexcept = delete;
  FuelM2(FuelM2&& rhs) noexcept = delete;
  FuelM2& operator=(const FuelM2& rhs) noexcept = delete;
  FuelM2& operator=(FuelM2&& rhs) noexcept = delete;
  constexpr FuelM2(const FuelCodeSize& code, const char* name)
    : FuelMixedWood<2, PercentConifer>(code, name)
  {
  }
};
template <int PercentDeadFir>
class FuelM3 : public FuelMixedDead<120, 572, 140, 50, 10, PercentDeadFir>
{
public:
  FuelM3() = delete;
  ~FuelM3() = default;
  FuelM3(const FuelM3& rhs) noexcept = delete;
  FuelM3(FuelM3&& rhs) noexcept = delete;
  FuelM3& operator=(const FuelM3& rhs) noexcept = delete;
  FuelM3& operator=(FuelM3&& rhs) noexcept = delete;
  constexpr FuelM3(const FuelCodeSize& code, const char* name)
    : FuelMixedDead<120, 572, 140, 50, 10, PercentDeadFir>(code,
                                                           name,
                                                           data::LOG_0_80)
  {
  }
};
template <int PercentDeadFir>
class FuelM4 : public FuelMixedDead<100, 404, 148, 50, 2, PercentDeadFir>
{
public:
  FuelM4() = delete;
  ~FuelM4() = default;
  FuelM4(const FuelM4& rhs) noexcept = delete;
  FuelM4(FuelM4&& rhs) noexcept = delete;
  FuelM4& operator=(const FuelM4& rhs) noexcept = delete;
  FuelM4& operator=(FuelM4&& rhs) noexcept = delete;
  constexpr FuelM4(const FuelCodeSize& code, const char* name)
    : FuelMixedDead<100, 404, 148, 50, 2, PercentDeadFir>(code,
                                                          name,
                                                          data::LOG_0_80)
  {
  }
};
class FuelO1A : public FuelGrass<190, 310, 140>
{
public:
  FuelO1A() = delete;
  ~FuelO1A() override = default;
  FuelO1A(const FuelO1A& rhs) noexcept = delete;
  FuelO1A(FuelO1A&& rhs) noexcept = delete;
  FuelO1A& operator=(const FuelO1A& rhs) noexcept = delete;
  FuelO1A& operator=(FuelO1A&& rhs) noexcept = delete;
  explicit constexpr FuelO1A(const FuelCodeSize& code) noexcept
    : FuelGrass(code, "O-1a", data::LOG_1_00)
  {
  }
};
class FuelO1B : public FuelGrass<250, 350, 170>
{
public:
  FuelO1B() = delete;
  ~FuelO1B() override = default;
  FuelO1B(const FuelO1B& rhs) noexcept = delete;
  FuelO1B(FuelO1B&& rhs) noexcept = delete;
  FuelO1B& operator=(const FuelO1B& rhs) noexcept = delete;
  FuelO1B& operator=(FuelO1B&& rhs) noexcept = delete;
  explicit constexpr FuelO1B(const FuelCodeSize& code) noexcept
    : FuelGrass(code, "O-1b", data::LOG_1_00)
  {
  }
};
}
template <int A, int B, int C, int Bui0, int FfcA, int FfcB, int WfcA, int WfcB, int BulkDensity>
class FuelSlash : public FuelConifer<A, B, C, Bui0, 0, 0, BulkDensity, 15, 74>
{
public:
  FuelSlash() = delete;
  ~FuelSlash() override = default;
  FuelSlash(const FuelSlash& rhs) noexcept = delete;
  FuelSlash(FuelSlash&& rhs) noexcept = delete;
  FuelSlash& operator=(const FuelSlash& rhs) noexcept = delete;
  FuelSlash& operator=(FuelSlash&& rhs) noexcept = delete;
  constexpr FuelSlash(const FuelCodeSize& code,
                      const char* name,
                      const LogValue log_q,
                      const Duff* duff_ffmc,
                      const Duff* duff_dmc)
    : FuelConifer<A, B, C, Bui0, 0, 0, BulkDensity, 15, 74>(code,
                                                            name,
                                                            log_q,
                                                            duff_ffmc,
                                                            duff_dmc)
  {
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const noexcept override
  {
    return ffcA() * (1.0 - exp(ffcB() * spread.bui().asValue()))
         + wfcA() * (1.0 - exp(wfcB() * spread.bui().asValue()));
  }
private:
  [[nodiscard]] static constexpr MathSize ffcA()
  {
    return FfcA;
  }
  [[nodiscard]] static constexpr MathSize ffcB()
  {
    return FfcB / 10000.0;
  }
  [[nodiscard]] static constexpr MathSize wfcA()
  {
    return WfcA;
  }
  [[nodiscard]] static constexpr MathSize wfcB()
  {
    return WfcB / 10000.0;
  }
};
namespace fbp
{
class FuelS1 : public FuelSlash<75, 297, 130, 38, 4, -250, 4, -340, 78>
{
public:
  FuelS1() = delete;
  ~FuelS1() override = default;
  FuelS1(const FuelS1& rhs) noexcept = delete;
  FuelS1(FuelS1&& rhs) noexcept = delete;
  FuelS1& operator=(const FuelS1& rhs) noexcept = delete;
  FuelS1& operator=(FuelS1&& rhs) noexcept = delete;
  explicit constexpr FuelS1(const FuelCodeSize& code) noexcept
    : FuelSlash(code,
                "S-1",
                data::LOG_0_75,
                &Duff::FeatherMoss,
                &Duff::PineSeney)
  {
  }
};
class FuelS2 : public FuelSlash<40, 438, 170, 63, 10, -130, 6, -600, 132>
{
public:
  FuelS2() = delete;
  ~FuelS2() override = default;
  FuelS2(const FuelS2& rhs) noexcept = delete;
  FuelS2(FuelS2&& rhs) noexcept = delete;
  FuelS2& operator=(const FuelS2& rhs) noexcept = delete;
  FuelS2& operator=(FuelS2&& rhs) noexcept = delete;
  explicit constexpr FuelS2(const FuelCodeSize& code) noexcept
    : FuelSlash(code,
                "S-2",
                data::LOG_0_75,
                &Duff::FeatherMoss,
                &Duff::WhiteSpruce)
  {
  }
};
class FuelS3 : public FuelSlash<55, 829, 320, 31, 12, -166, 20, -210, 100>
{
public:
  FuelS3() = delete;
  ~FuelS3() override = default;
  FuelS3(const FuelS3& rhs) noexcept = delete;
  FuelS3(FuelS3&& rhs) noexcept = delete;
  FuelS3& operator=(const FuelS3& rhs) noexcept = delete;
  FuelS3& operator=(FuelS3&& rhs) noexcept = delete;
  explicit constexpr FuelS3(const FuelCodeSize& code) noexcept
    : FuelSlash(code,
                "S-3",
                data::LOG_0_75,
                &Duff::FeatherMoss,
                &Duff::PineSeney)
  {
  }
};
}
template <class FuelSpring, class FuelSummer>
class FuelVariable;
template <class FuelSpring, class FuelSummer>
[[nodiscard]] const FuelType& find_fuel_by_season(const int nd,
                                                  const FuelVariable<
                                                    FuelSpring,
                                                    FuelSummer>& fuel) noexcept
{
  // if not green yet, then still in spring conditions
  return calculate_is_green(nd)
         ? fuel.summer()
         : fuel.spring();
}
template <class FuelSpring, class FuelSummer>
[[nodiscard]] MathSize compare_by_season(const FuelVariable<FuelSpring, FuelSummer>& fuel,
                                         const function<MathSize(const FuelType&)>& fct)
{
  // HACK: no way to tell which is which, so let's assume they have to be the same??
  // HACK: use a function so that DEBUG section doesn't get out of sync
  const auto for_spring = fct(fuel.spring());
#ifdef DEBUG_FUEL_VARIABLE
  const auto for_summer = fct(fuel.summer());
  logging::check_fatal(for_spring != for_summer, "Expected spring and summer cfb to be identical");
#endif
  return for_spring;
}
template <class FuelSpring, class FuelSummer>
class FuelVariable : public FuelType
{
public:
  // don't delete pointers since they're handled elsewhere
  ~FuelVariable() override = default;
  constexpr FuelVariable(const FuelCodeSize& code,
                         const char* name,
                         const bool can_crown,
                         const FuelSpring* const spring,
                         const FuelSummer* const summer)
    : FuelType(code, name, can_crown),
      spring_(spring),
      summer_(summer)
  {
  }
  FuelVariable(FuelVariable&& rhs) noexcept = delete;
  FuelVariable(const FuelVariable& rhs) = delete;
  FuelVariable& operator=(FuelVariable&& rhs) noexcept = delete;
  FuelVariable& operator=(const FuelVariable& rhs) = delete;
  [[nodiscard]] MathSize buiEffect(MathSize bui) const override
  {
    return compare_by_season(*this, [bui](const FuelType& fuel) { return fuel.buiEffect(bui); });
  }
  [[nodiscard]] MathSize grass_curing(const int nd, const wx::FwiWeather& wx) const override
  {
    return compare_by_season(*this, [&nd, &wx](const FuelType& fuel) { return fuel.grass_curing(nd, wx); });
  }
  [[nodiscard]] MathSize cbh() const override
  {
    return compare_by_season(*this, [](const FuelType& fuel) { return fuel.cbh(); });
  }
  [[nodiscard]] MathSize cfl() const override
  {
    return compare_by_season(*this, [](const FuelType& fuel) { return fuel.cfl(); });
  }
  [[nodiscard]] MathSize crownConsumption(const MathSize cfb) const override
  {
    return compare_by_season(*this, [cfb](const FuelType& fuel) { return fuel.crownConsumption(cfb); });
  }
  [[nodiscard]] MathSize calculateRos(const int nd,
                                      const wx::FwiWeather& wx,
                                      const MathSize isi) const override
  {
    return find_fuel_by_season(nd, *this).calculateRos(nd, wx, isi);
  }
  [[nodiscard]] MathSize calculateIsf(const SpreadInfo& spread,
                                      const MathSize isi) const override
  {
    return find_fuel_by_season(spread.nd(), *this).calculateIsf(spread, isi);
  }
  [[nodiscard]] MathSize surfaceFuelConsumption(
    const SpreadInfo& spread) const override
  {
    return find_fuel_by_season(spread.nd(), *this).surfaceFuelConsumption(spread);
  }
  [[nodiscard]] MathSize lengthToBreadth(const MathSize ws) const override
  {
    return compare_by_season(*this, [ws](const FuelType& fuel) { return fuel.lengthToBreadth(ws); });
  }
  [[nodiscard]] MathSize finalRos(const SpreadInfo& spread,
                                  const MathSize isi,
                                  const MathSize cfb,
                                  const MathSize rss) const override
  {
    return find_fuel_by_season(spread.nd(), *this).finalRos(spread, isi, cfb, rss);
  }
  [[nodiscard]] MathSize criticalSurfaceIntensity(
    const SpreadInfo& spread) const override
  {
    return find_fuel_by_season(spread.nd(), *this).criticalSurfaceIntensity(spread);
  }
  [[nodiscard]] MathSize crownFractionBurned(const MathSize rss,
                                             const MathSize rso) const noexcept override
  {
    return spring().crownFractionBurned(rss, rso);
  }
  [[nodiscard]] MathSize probabilityPeat(const MathSize mc_fraction) const noexcept override
  {
    return spring().probabilityPeat(mc_fraction);
  }
  [[nodiscard]] MathSize survivalProbability(const wx::FwiWeather& wx) const noexcept
    override
  {
    return spring().survivalProbability(wx);
  }
  [[nodiscard]] constexpr const FuelType& spring() const
  {
    return *spring_;
  }
  [[nodiscard]] constexpr const FuelType& summer() const
  {
    return *summer_;
  }
private:
  const FuelSpring* const spring_;
  const FuelSummer* const summer_;
};
namespace fbp
{
class FuelD1D2 : public FuelVariable<FuelD1, FuelD2>
{
public:
  FuelD1D2() = delete;
  ~FuelD1D2() override = default;
  FuelD1D2(const FuelD1D2& rhs) noexcept = delete;
  FuelD1D2(FuelD1D2&& rhs) noexcept = delete;
  FuelD1D2& operator=(const FuelD1D2& rhs) noexcept = delete;
  FuelD1D2& operator=(FuelD1D2&& rhs) noexcept = delete;
  constexpr FuelD1D2(const FuelCodeSize& code,
                     const FuelD1* d1,
                     const FuelD2* d2) noexcept
    : FuelVariable(code, "D-1/D-2", false, d1, d2)
  {
  }
};
template <int PercentConifer>
class FuelM1M2 : public FuelVariable<FuelM1<PercentConifer>, FuelM2<PercentConifer>>
{
public:
  FuelM1M2() = delete;
  ~FuelM1M2() = default;
  FuelM1M2(const FuelM1M2& rhs) noexcept = delete;
  FuelM1M2(FuelM1M2&& rhs) noexcept = delete;
  FuelM1M2& operator=(const FuelM1M2& rhs) noexcept = delete;
  FuelM1M2& operator=(FuelM1M2&& rhs) noexcept = delete;
  // HACK: it's up to you to make sure these match
  constexpr FuelM1M2(const FuelCodeSize& code,
                     const char* name,
                     const FuelM1<PercentConifer>* m1,
                     const FuelM2<PercentConifer>* m2)
    : FuelVariable<FuelM1<PercentConifer>, FuelM2<PercentConifer>>(code, name, true, m1, m2)
  {
  }
};
template <int PercentDeadFir>
class FuelM3M4 : public FuelVariable<FuelM3<PercentDeadFir>, FuelM4<PercentDeadFir>>
{
public:
  FuelM3M4() = delete;
  ~FuelM3M4() = default;
  FuelM3M4(const FuelM3M4& rhs) noexcept = delete;
  FuelM3M4(FuelM3M4&& rhs) noexcept = delete;
  FuelM3M4& operator=(const FuelM3M4& rhs) noexcept = delete;
  FuelM3M4& operator=(FuelM3M4&& rhs) noexcept = delete;
  constexpr FuelM3M4(const FuelCodeSize& code,
                     const char* name,
                     const FuelM3<PercentDeadFir>* m3,
                     const FuelM4<PercentDeadFir>* m4)
    : FuelVariable<FuelM3<PercentDeadFir>, FuelM4<PercentDeadFir>>(code, name, true, m3, m4)
  {
  }
};
class FuelO1 : public FuelVariable<FuelO1A, FuelO1B>
{
public:
  FuelO1() = delete;
  ~FuelO1() = default;
  FuelO1(const FuelO1& rhs) noexcept = delete;
  FuelO1(FuelO1&& rhs) noexcept = delete;
  FuelO1& operator=(const FuelO1& rhs) noexcept = delete;
  FuelO1& operator=(FuelO1&& rhs) noexcept = delete;
  constexpr FuelO1(const FuelCodeSize& code,
                   const char* name,
                   const FuelO1A* o1a,
                   const FuelO1B* o1b)
    : FuelVariable<FuelO1A, FuelO1B>(code, name, true, o1a, o1b)
  {
  }
};
}
}