Cell.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, 2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include <limits>
#include "Location.h"
#include "FuelType.h"
#include "Util.h"
namespace fs::topo
{
using SpreadKey = uint32_t;
using fuel::INVALID_FUEL_CODE;
class Cell
  : public Position<Topo>
{
public:
  constexpr Cell() noexcept
    : Cell(-1,
           -1,
           numeric_limits<SlopeSize>::min(),
           numeric_limits<AspectSize>::min(),
           numeric_limits<FuelCodeSize>::min())
  {
  }
  [[nodiscard]] constexpr Topo fullHash() const
  {
    return topo_data_;
  }
  [[nodiscard]] static constexpr Topo hashCell(const SlopeSize slope,
                                               const AspectSize aspect,
                                               const FuelCodeSize& fuel) noexcept
  {
    // HACK: so we can call and set it all invalid if anything is
    // if any are invalid then they all should be
    const auto do_hash_cell = [](const SlopeSize s, const AspectSize a, const FuelCodeSize f) {
      return static_cast<Topo>(f) << FuelShift
           | static_cast<Topo>(s) << SlopeShift
           | static_cast<Topo>(a) << AspectShift;
    };
    if (
      INVALID_SLOPE == slope
      || INVALID_ASPECT == aspect
      || INVALID_FUEL_CODE == fuel)
    {
      return do_hash_cell(INVALID_SLOPE, INVALID_ASPECT, INVALID_FUEL_CODE);
    }
    // if slope is 0 make aspect north so less unique keys
    return do_hash_cell(slope, 0 == slope ? 0 : aspect, fuel);
  }
  explicit constexpr Cell(const Topo hash) noexcept
    : Position<Topo>(hash)
  {
  }
  constexpr Cell(const HashSize hash,
                 const SlopeSize slope,
                 const AspectSize aspect,
                 const FuelCodeSize& fuel) noexcept
    : Position<Topo>(
        static_cast<Topo>(hash & HashMask)
        | hashCell(slope, aspect, fuel))
  {
  }
  constexpr Cell(const Idx row,
                 const Idx column,
                 const SlopeSize slope,
                 const AspectSize aspect,
                 const FuelCodeSize& fuel) noexcept
    : Position<Topo>(
        static_cast<Topo>(doHash(row, column))
        | hashCell(slope, aspect, fuel))
  {
  }
  [[nodiscard]] static constexpr SpreadKey key(const Topo value) noexcept
  {
    // can just shift since these are the only bits left after
    return static_cast<SpreadKey>(value >> FuelShift);
  }
  [[nodiscard]] static constexpr AspectSize aspect(const SpreadKey value) noexcept
  {
    return static_cast<AspectSize>((value & (AspectMask >> FuelShift)) >> (AspectShift - FuelShift));
  }
  [[nodiscard]] static constexpr FuelCodeSize fuelCode(const SpreadKey value) noexcept
  {
    return static_cast<FuelCodeSize>((value & (FuelMask >> FuelShift)) >> (FuelShift - FuelShift));
  }
  [[nodiscard]] static constexpr SlopeSize slope(const SpreadKey value) noexcept
  {
    return static_cast<SlopeSize>((value & (SlopeMask >> FuelShift)) >> (SlopeShift - FuelShift));
  }
  [[nodiscard]] static constexpr AspectSize aspect(const Topo value) noexcept
  {
    return static_cast<AspectSize>((value & AspectMask) >> AspectShift);
  }
  [[nodiscard]] static constexpr FuelCodeSize fuelCode(const Topo value) noexcept
  {
    return static_cast<FuelCodeSize>((value & FuelMask) >> FuelShift);
  }
  [[nodiscard]] static constexpr SlopeSize slope(const Topo value) noexcept
  {
    return static_cast<SlopeSize>((value & SlopeMask) >> SlopeShift);
  }
  [[nodiscard]] static constexpr Topo topoHash(const Topo value) noexcept
  {
    return static_cast<Topo>(value) & CellMask;
  }
  [[nodiscard]] constexpr SpreadKey key() const noexcept
  {
    return Cell::key(topo_data_);
  }
  [[nodiscard]] constexpr AspectSize aspect() const noexcept
  {
    return Cell::aspect(topo_data_);
  }
  [[nodiscard]] constexpr FuelCodeSize fuelCode() const noexcept
  {
    return Cell::fuelCode(topo_data_);
  }
  [[nodiscard]] constexpr SlopeSize slope() const noexcept
  {
    return Cell::slope(topo_data_);
  }
  [[nodiscard]] constexpr Topo topoHash() const noexcept
  {
    return Cell::topoHash(topo_data_);
  }
protected:
  /*
   * Field                    Natural Range     Used Range      Bits    Bit Range
   * Row                      0 - 4095          0 - 4095        12      0 - 4095
   * Column                   0 - 4095          0 - 4095        12      0 - 4095
   * PADDING                                                    10
   * Fuel                     0 - 140           0 - 140         8       0 - 255
   * Aspect                   0 - 359           0 - 359         9       0 - 511
<<<<<<< HEAD
   * Slope                    0 - infinity      0 - 511         9       0 - 511
=======
   * Slope                    0 - infinity      0 - 127         7       0 - 127
>>>>>>> 70c2f12ad (quick fix for seasonal/specific mixedwood fuels)
   * Extra                                                      8
   *
   * Rows and Columns are restricted to 4096 since that's what gets clipped out of
   * the GIS outputs.
   *
   * Fuel is tied to how many variations of percent conifer/dead fir we want to use, and
   * if we want to allow M1/M2/M3/M4 on their own, or just use the ones that are
   * automatically tied to the green-up.
   *
   * Aspect is calculated to be in degrees, so 0 - 359.
   *
   * Slope is truncated to 0 - 70 for slope effect calculations speed for slopes,
   * but keep higher range because there's an issue with this when it tries to calculate the
   * horizontal rate of spread since if the slope has been truncated and the distance
   * calculated will be wrong.
   */
  static constexpr uint32_t FuelShift = 32;
  // Need to make sure that fuel, slope & aspect aren't in first 32 bits
  static_assert(32 <= FuelShift);
  static constexpr uint32_t FuelBits = std::bit_width<uint32_t>(NUMBER_OF_FUELS);
  static constexpr Topo FuelBitMask = util::bit_mask<FuelBits, Topo>();
  static_assert(FuelBitMask == 0xFF);
  static_assert(FuelBitMask >= NUMBER_OF_FUELS);
  static constexpr Topo FuelMask = FuelBitMask << FuelShift;
  static constexpr uint32_t AspectShift = FuelBits + FuelShift;
  static constexpr uint32_t AspectBits = std::bit_width<uint32_t>(MAX_ASPECT);
  static constexpr Topo AspectBitMask = util::bit_mask<AspectBits, Topo>();
  static_assert(AspectBitMask == 0x1FF);
  static_assert(AspectBitMask >= INVALID_ASPECT);
  static constexpr Topo AspectMask = AspectBitMask << AspectShift;
  static constexpr uint32_t SlopeShift = AspectBits + AspectShift;
  static constexpr uint32_t SlopeBits = std::bit_width<uint32_t>(MAX_SLOPE_FOR_DISTANCE);
  static_assert(SlopeBits == 9);
  static constexpr Topo SlopeBitMask = util::bit_mask<SlopeBits, Topo>();
  static_assert(SlopeBitMask == 0x1FF);
  static_assert(SlopeBitMask >= INVALID_SLOPE);
  static constexpr Topo SlopeMask = SlopeBitMask << SlopeShift;
  static constexpr Topo CellMask = HashMask | FuelMask | AspectMask | SlopeMask;
  static_assert(static_cast<size_t>(std::bit_width(std::numeric_limits<Topo>::max())) >= SlopeBits + SlopeShift);
};
constexpr bool operator<(const Cell& lhs, const Cell& rhs)
{
  return lhs.topoHash() < rhs.topoHash();
}
}
namespace std
{
template <>
struct hash<fs::topo::Cell>
{
  std::size_t operator()(const fs::topo::Cell& k) const noexcept
  {
    return k.fullHash();
  }
};
}