FWI.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 <string>
#include "Weather.h"
namespace fs::wx
{
class Ffmc : public Index<Ffmc>
{
public:
  using Index::Index;
 
  Ffmc(const Temperature& temperature,
       const RelativeHumidity& rh,
       const Speed& ws,
       const Precipitation& prec,
       const Ffmc& ffmc_previous) noexcept;
  static const Ffmc Zero;
  static const Ffmc Invalid;
};
class Dmc : public Index<Dmc>
{
public:
  using Index::Index;
 
  Dmc(const Temperature& temperature,
      const RelativeHumidity& rh,
      const Precipitation& prec,
      const Dmc& dmc_previous,
      int month,
      MathSize latitude) noexcept;
  static const Dmc Zero;
  static const Dmc Invalid;
};
class Dc : public Index<Dc>
{
public:
  using Index::Index;
 
  Dc(const Temperature& temperature,
     const Precipitation& prec,
     const Dc& dc_previous,
     int month,
     MathSize latitude) noexcept;
  static const Dc Zero;
  static const Dc Invalid;
};
class Isi : public Index<Isi>
{
public:
  Isi(MathSize value, const Speed& ws, const Ffmc& ffmc) noexcept;
  Isi(const Speed& ws, const Ffmc& ffmc) noexcept;
  static const Isi Zero;
  static const Isi Invalid;
private:
  using Index::Index;
};
class Bui : public Index<Bui>
{
public:
  Bui(MathSize value, const Dmc& dmc, const Dc& dc) noexcept;
  Bui(const Dmc& dmc, const Dc& dc) noexcept;
  static const Bui Zero;
  static const Bui Invalid;
private:
  using Index::Index;
};
class Fwi : public Index<Fwi>
{
public:
  Fwi(MathSize value, const Isi& isi, const Bui& bui) noexcept;
  Fwi(const Isi& isi, const Bui& bui) noexcept;
  static const Fwi Zero;
  static const Fwi Invalid;
private:
  using Index::Index;
};
class Dsr : public Index<Dsr>
{
public:
  using Index::Index;
 
  explicit Dsr(const Fwi& fwi) noexcept;
  static const Dsr Zero;
  static const Dsr Invalids;
};
class FwiWeather
  : public Weather
{
public:
  static const FwiWeather Zero;
  static const FwiWeather Invalid;
  FwiWeather() noexcept;
  FwiWeather(istringstream* iss,
             string* str);
  FwiWeather(const FwiWeather& yesterday,
             const int month,
             const MathSize latitude,
             const Temperature& temp,
             const RelativeHumidity& rh,
             const Wind& wind,
             const Precipitation& prec);
  FwiWeather(const Temperature& temp,
             const RelativeHumidity& rh,
             const Wind& wind,
             const Precipitation& prec,
             const Ffmc& ffmc,
             const Dmc& dmc,
             const Dc& dc,
             const Isi& isi,
             const Bui& bui,
             const Fwi& fwi) noexcept;
  FwiWeather(const Temperature& temp,
             const RelativeHumidity& rh,
             const Wind& wind,
             const Precipitation& prec,
             const Ffmc& ffmc,
             const Dmc& dmc,
             const Dc& dc,
             const Isi& isi,
             const Bui& bui) noexcept;
  FwiWeather(const Temperature& temp,
             const RelativeHumidity& rh,
             const Wind& wind,
             const Precipitation& prec,
             const Ffmc& ffmc,
             const Dmc& dmc,
             const Dc& dc) noexcept;
  FwiWeather(const FwiWeather& wx, const Speed& ws, const Ffmc& ffmc) noexcept;
  ~FwiWeather() override = default;
  constexpr FwiWeather(FwiWeather&& rhs) noexcept = default;
  constexpr FwiWeather(const FwiWeather& rhs) noexcept = default;
  FwiWeather& operator=(FwiWeather&& rhs) noexcept = default;
  FwiWeather& operator=(const FwiWeather& rhs) = default;
  [[nodiscard]] constexpr const Ffmc& ffmc() const
  {
    return ffmc_;
  }
  [[nodiscard]] constexpr const Dmc& dmc() const
  {
    return dmc_;
  }
  [[nodiscard]] constexpr const Dc& dc() const
  {
    return dc_;
  }
  [[nodiscard]] constexpr const Isi& isi() const
  {
    return isi_;
  }
  [[nodiscard]] constexpr const Bui& bui() const
  {
    return bui_;
  }
  [[nodiscard]] constexpr const Fwi& fwi() const
  {
    return fwi_;
  }
  [[nodiscard]] constexpr MathSize mcFfmcPct() const
  {
    return mc_ffmc_pct_;
  }
  [[nodiscard]] constexpr MathSize mcDmcPct() const
  {
    return mc_dmc_pct_;
  }
  [[nodiscard]] constexpr MathSize mcFfmc() const
  {
    return mcFfmcPct() / 100.0;
  }
  [[nodiscard]] constexpr MathSize mcDmc() const
  {
    return mcDmcPct() / 100.0;
  }
  [[nodiscard]] constexpr MathSize ffmcEffect() const
  {
    return ffmc_effect_;
  }
private:
  FwiWeather(const FwiWeather& wx,
             const Wind& wind,
             const Ffmc& ffmc,
             const Isi& isi) noexcept;
  FwiWeather(const FwiWeather& wx, const Wind& wind, const Ffmc& ffmc) noexcept;
  Ffmc ffmc_;
  Dmc dmc_;
  Dc dc_;
  Isi isi_;
  Bui bui_;
  Fwi fwi_;
  MathSize mc_ffmc_pct_;
  MathSize mc_dmc_pct_;
  MathSize ffmc_effect_;
};
[[nodiscard]] constexpr bool operator<(const FwiWeather& lhs, const FwiWeather& rhs)
{
  if (lhs.temp() == rhs.temp())
  {
    if (lhs.rh() == rhs.rh())
    {
      if (lhs.wind() == rhs.wind())
      {
        if (lhs.prec() == rhs.prec())
        {
          if (lhs.ffmc() == rhs.ffmc())
          {
            if (lhs.dmc() == rhs.dmc())
            {
              if (lhs.dc() == rhs.dc())
              {
                assert(lhs.isi() == rhs.isi());
                assert(lhs.bui() == rhs.bui());
                assert(lhs.fwi() == rhs.fwi());
              }
              return lhs.dc() < rhs.dc();
            }
            return lhs.dmc() < rhs.dmc();
          }
          return lhs.ffmc() < rhs.ffmc();
        }
        return lhs.prec() < rhs.prec();
      }
      return lhs.wind() < rhs.wind();
    }
    return lhs.rh() < rhs.rh();
  }
  return lhs.temp() < rhs.temp();
}
[[nodiscard]] constexpr bool operator!=(const FwiWeather& lhs, const FwiWeather& rhs)
{
  return lhs.temp() != rhs.temp()
      || lhs.rh() != rhs.rh()
      || lhs.wind() != rhs.wind()
      || lhs.prec() != rhs.prec()
      || lhs.ffmc() != rhs.ffmc()
      || lhs.dmc() != rhs.dmc()
      || lhs.dc() != rhs.dc()
      || lhs.isi() != rhs.isi()
      || lhs.bui() != rhs.bui()
      || lhs.fwi() != rhs.fwi();
}
[[nodiscard]] constexpr bool operator==(const FwiWeather& lhs, const FwiWeather& rhs)
{
  return !(lhs != rhs);
}
constexpr auto FFMC_MOISTURE_CONSTANT = 147.27723;
constexpr MathSize ffmc_to_moisture(const MathSize ffmc) noexcept
{
  return FFMC_MOISTURE_CONSTANT * (101.0 - ffmc) / (59.5 + ffmc);
}
constexpr MathSize ffmc_to_moisture(const Ffmc& ffmc) noexcept
{
  return ffmc_to_moisture(ffmc.asValue());
}
constexpr MathSize moisture_to_ffmc(const MathSize m) noexcept
{
  return (59.5 * (250.0 - m) / (FFMC_MOISTURE_CONSTANT + m));
}
constexpr Ffmc ffmc_from_moisture(const MathSize m) noexcept
{
  return Ffmc(moisture_to_ffmc(m));
}
}