StandardFuel.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 "FireSpread.h"
#include "FuelType.h"
#include "LookupTable.h"
namespace fs
{
using sim::SpreadInfo;
namespace fuel
{
static constexpr MathSize SLOPE_LIMIT_ISI = 0.01;
[[nodiscard]] static constexpr MathSize
  calculate_standard_foliar_moisture_fmc(
    const MathSize fmc) noexcept
{
  return util::pow_int<4>(1.5 - 0.00275 * fmc) / (460.0 + 25.9 * fmc) / 0.778 * 1000.0;
}
static const util::LookupTable<&calculate_standard_foliar_moisture_fmc>
  STANDARD_FOLIAR_MOISTURE_FMC{};
[[nodiscard]] static MathSize
  calculate_standard_foliar_moisture_isi(
    const MathSize isi) noexcept
{
  return 60.0 * (1.0 - exp(-0.0497 * isi));
}
static const util::LookupTable<&calculate_standard_foliar_moisture_isi>
  STANDARD_FOLIAR_MOISTURE_ISI{};
[[nodiscard]] static MathSize
  calculate_standard_length_to_breadth(const MathSize ws) noexcept
{
  return 1.0 + 8.729 * pow(1.0 - exp(-0.030 * ws), 2.155);
}
static const util::LookupTable<&calculate_standard_length_to_breadth>
  STANDARD_LENGTH_TO_BREADTH{};
template <int A, int B, int C, int Bui0, int Cbh, int Cfl, int BulkDensity, int InorganicPercent, int DuffDepth>
class StandardFuel
  : public FuelBase<BulkDensity, InorganicPercent, DuffDepth>
{
public:
  constexpr StandardFuel(const FuelCodeSize& code,
                         const char* name,
                         const bool can_crown,
                         const LogValue log_q,
                         const Duff* duff_ffmc,
                         const Duff* duff_dmc) noexcept
    : FuelBase<BulkDensity, InorganicPercent, DuffDepth>(code,
                                                         name,
                                                         can_crown,
                                                         duff_ffmc,
                                                         duff_dmc),
      log_q_(log_q)
  {
  }
  constexpr StandardFuel(const FuelCodeSize& code,
                         const char* name,
                         const bool can_crown,
                         const LogValue log_q,
                         const Duff* duff) noexcept
    : StandardFuel(code,
                   name,
                   can_crown,
                   log_q,
                   duff,
                   duff)
  {
  }
  StandardFuel(StandardFuel&& rhs) noexcept = delete;
  StandardFuel(const StandardFuel& rhs) noexcept = delete;
  StandardFuel& operator=(StandardFuel&& rhs) noexcept = delete;
  StandardFuel& operator=(const StandardFuel& rhs) = delete;
  [[nodiscard]] MathSize rosBasic(const MathSize isi) const noexcept
  {
    return a() * pow(1.0 - exp(negB() * isi), c());
  }
  virtual 
    MathSize
    crownConsumption(const MathSize cfb) const noexcept override
  {
    return cfl() * cfb;
  }
  [[nodiscard]] MathSize limitIsf(const MathSize mu, const MathSize rsf) const noexcept
  {
    return (1.0 / negB()) * log(max(SLOPE_LIMIT_ISI, (rsf > 0.0) ? (1.0 - pow((rsf / (mu * a())), (1.0 / c()))) : 1.0));
  }
  [[nodiscard]] MathSize criticalSurfaceIntensity(const SpreadInfo& spread) const noexcept
    override
  {
    return 0.001 * pow(cbh(), 1.5) * pow(460.0 + 25.9 * spread.foliarMoisture(), 1.5);
  }
  [[nodiscard]] MathSize lengthToBreadth(const MathSize ws) const noexcept override
  {
    return STANDARD_LENGTH_TO_BREADTH(ws);
  }
  MathSize finalRos(const SpreadInfo&,
                    MathSize,
                    MathSize,
                    const MathSize rss) const noexcept override
  {
    return rss;
  }
  [[nodiscard]] MathSize buiEffect(const MathSize bui) const noexcept override
  {
    return (0 < bui)
           ? exp(
               50.0
               * log_q_.asValue()
               * ((1.0 / bui) - (1.0 / bui0())))
           : 1.0;
  }
protected:
  ~StandardFuel() = default;
  [[nodiscard]] static constexpr MathSize bui0() noexcept
  {
    return Bui0;
  }
  [[nodiscard]] MathSize cbh() const override
  {
    return Cbh;
  }
  [[nodiscard]] MathSize cfl() const override
  {
    return Cfl / 100.0;
  }
  [[nodiscard]] static constexpr MathSize a() noexcept
  {
    return A;
  }
  [[nodiscard]] static constexpr MathSize negB() noexcept
  {
    // the only places this gets used it gets negated so just store it that way
    return -B / 10000.0;
  }
  [[nodiscard]] static constexpr MathSize c() noexcept
  {
    return C / 100.0;
  }
  [[nodiscard]] static constexpr MathSize crownRateOfSpread(const MathSize isi,
                                                            const MathSize fmc) noexcept
  {
    return STANDARD_FOLIAR_MOISTURE_ISI(isi) * STANDARD_FOLIAR_MOISTURE_FMC(fmc);
  }
private:
  LogValue log_q_;
  static_assert(-negB() < 1);
  static_assert(c() < 10 && c() > 1);
};
}
}