Face.h

Go to the documentation of this file.

/***************************************************************************
 *  ThunderEgg, a library for solvers on adaptively refined block-structured
 *  Cartesian grids.
 *
 *  Copyright (c) 2021      Scott Aiton
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 ***************************************************************************/
 
#ifndef THUNDEREGG_FACE_H
#define THUNDEREGG_FACE_H
 
#include <ThunderEgg/tpl/json.hpp>
#include <array>
namespace ThunderEgg {
template<int D, int M>
class Face
{
private:
  unsigned char value = number_of;
 
  static constexpr size_t twopow(size_t N) { return 0b1 << N; }
 
  static constexpr size_t factorial(size_t N) { return N == 0 ? 1 : N * factorial(N - 1); }
 
  static constexpr size_t choose(size_t N, size_t K)
  {
    return factorial(N) / (factorial(K) * factorial(N - K));
  }
 
  static constexpr size_t sum(int N)
  {
    return N == -1 ? 0 : (twopow(D - N) * choose(D, N) + sum(N - 1));
  }
 
public:
  static constexpr int dimensionality = M;
  static constexpr size_t number_of = twopow(D - M) * choose(D, M);
 
  static constexpr size_t sum_of_faces = M <= 0 ? 0 : sum(M - 1);
  explicit Face(unsigned char value)
    : value(value)
  {
    static_assert(D <= 3 && D >= 0, "Only up to 3 dimensions supported");
    static_assert(M >= 0 && M < D, "Invalid M value");
  }
 
  Face()
  {
    static_assert(D <= 3 && D >= 0, "Only up to 3 dimensions supported");
    static_assert(M >= 0 && M < D, "Invalid M value");
  }
 
  static Face<D, M> null() { return Face<D, M>(number_of); }
 
  /*
   * these can be cleaned up when version is bumped to c++20
   */
 
  template<int N = 0>
  static auto west() -> typename std::enable_if<D <= 3 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b000);
  }
  template<int N = 0>
  static auto east() -> typename std::enable_if<D <= 3 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b001);
  }
  template<int N = 0>
  static auto south() ->
    typename std::enable_if<D <= 3 && D >= 2 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b010);
  }
  template<int N = 0>
  static auto north() ->
    typename std::enable_if<D <= 3 && D >= 2 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b011);
  }
  template<int N = 0>
  static auto bottom() ->
    typename std::enable_if<D <= 3 && D >= 3 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b100);
  }
  template<int N = 0>
  static auto top() ->
    typename std::enable_if<D <= 3 && D >= 3 && M == D - 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b101);
  }
 
  template<int N = 0>
  static auto sw() -> typename std::enable_if<D == 2 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b00);
  }
  template<int N = 0>
  static auto se() -> typename std::enable_if<D == 2 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b01);
  }
  template<int N = 0>
  static auto nw() -> typename std::enable_if<D == 2 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b10);
  }
  template<int N = 0>
  static auto ne() -> typename std::enable_if<D == 2 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b11);
  }
 
  template<int N = 0>
  static auto bsw() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b000);
  }
  template<int N = 0>
  static auto bse() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b001);
  }
  template<int N = 0>
  static auto bnw() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b010);
  }
  template<int N = 0>
  static auto bne() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b011);
  }
  template<int N = 0>
  static auto tsw() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b100);
  }
  template<int N = 0>
  static auto tse() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b101);
  }
  template<int N = 0>
  static auto tnw() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b110);
  }
  template<int N = 0>
  static auto tne() -> typename std::enable_if<D == 3 && M == 0 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b111);
  }
 
  template<int N = 0>
  static auto bs() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0000);
  }
  template<int N = 0>
  static auto bn() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0001);
  }
  template<int N = 0>
  static auto ts() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0010);
  }
  template<int N = 0>
  static auto tn() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0011);
  }
  template<int N = 0>
  static auto bw() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0100);
  }
  template<int N = 0>
  static auto be() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0101);
  }
  template<int N = 0>
  static auto tw() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0110);
  }
  template<int N = 0>
  static auto te() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b0111);
  }
  template<int N = 0>
  static auto sw() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b1000);
  }
  template<int N = 0>
  static auto se() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b1001);
  }
  template<int N = 0>
  static auto nw() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b1010);
  }
  template<int N = 0>
  static auto ne() -> typename std::enable_if<D == 3 && M == 1 && N == N, Face<D, M>>::type
  {
    return Face<D, M>(0b1011);
  }
 
  class Range
  {
  public:
    class Iterator : public std::input_iterator_tag
    {
    private:
      Face<D, M> s;
 
    public:
      explicit Iterator(Face<D, M> s)
        : s(s)
      {}
      const Face<D, M>& operator++()
      {
        ++s.value;
        return s;
      }
      const Face<D, M>& operator*() const { return s; }
      const Face<D, M>* operator->() const { return &s; }
      bool operator==(const Iterator& b) const { return s.value == b.s.value; }
      bool operator!=(const Iterator& b) const { return s.value != b.s.value; }
    };
    Iterator begin() { return Iterator(Face<D, M>(0)); }
    Iterator end() { return Iterator(null()); }
  };
  static Range getValues() { return Range(); }
 
  size_t getIndex() const { return value; }
 
  template<int N = 0>
  auto getAxisIndex() const ->
    typename std::enable_if<D <= 3 && D >= 1 && M == D - 1 && N == N, size_t>::type
  {
    return value >> 1;
  }
 
  template<int N = 0>
  auto isLowerOnAxis() const ->
    typename std::enable_if<D <= 3 && D >= 1 && M == D - 1 && N == N, bool>::type
  {
    return !(value & 0b1);
  }
 
  template<int N = 0>
  auto isHigherOnAxis() const ->
    typename std::enable_if<D <= 3 && D >= 1 && M == D - 1 && N == N, bool>::type
  {
    return value & 0b1;
  }
 
  Face<D, M> opposite() const { return Face<D, M>(value ^ ~((~0u) << (D - M))); }
 
  std::array<Face<D, D - 1>, D - M> getSides() const
  {
    std::array<Face<D, D - 1>, D - M> sides;
    if constexpr (D > 1 && M == 0) {
      for (size_t i = 0; i < D; i++) {
        size_t side = 2 * i;
        if ((1 << i) & value) {
          side |= 1;
        }
        sides[i] = Face<D, D - 1>(side);
      }
    } else if constexpr (D == 3 && M == 1) {
      size_t not_axis = value >> 2;
      size_t curr_index = 0;
      for (unsigned char i = 0; i < D; i++) {
        if (i != not_axis) {
          unsigned char bit = (value & (0b1 << curr_index)) >> curr_index;
          sides[curr_index] = Face<D, D - 1>((i << 1) ^ bit);
          curr_index++;
        }
      }
    } else {
      sides[0] = Face<D, D - 1>(value);
    }
    return sides;
  }
 
  bool operator<(const Face<D, M>& other) const { return value < other.value; }
 
  bool operator==(const Face<D, M>& other) const { return value == other.value; }
 
  bool operator!=(const Face<D, M>& other) const { return value != other.value; }
};
 
template<int D>
using Side = Face<D, D - 1>;
template<int D>
Side<D>
HigherSideOnAxis(size_t axis)
{
  return Side<D>((axis << 1) + 1);
}
template<int D>
Side<D>
LowerSideOnAxis(size_t axis)
{
  return Side<D>(axis << 1);
}
void
to_json(tpl::nlohmann::json& j, const Side<1>& s);
void
to_json(tpl::nlohmann::json& j, const Side<2>& s);
void
to_json(tpl::nlohmann::json& j, const Side<3>& s);
void
from_json(const tpl::nlohmann::json& j, Side<1>& s);
void
from_json(const tpl::nlohmann::json& j, Side<2>& s);
void
from_json(const tpl::nlohmann::json& j, Side<3>& s);
std::ostream&
operator<<(std::ostream& os, const Side<1>& s);
std::ostream&
operator<<(std::ostream& os, const Side<2>& s);
std::ostream&
operator<<(std::ostream& os, const Side<3>& s);
 
using Edge = Face<3, 1>;
std::ostream&
operator<<(std::ostream& os, const Edge& o);
void
to_json(tpl::nlohmann::json& j, const Edge& o);
void
from_json(const tpl::nlohmann::json& j, Edge& o);
 
template<int D>
using Corner = Face<D, 0>;
std::ostream&
operator<<(std::ostream& os, const Corner<2>& o);
std::ostream&
operator<<(std::ostream& os, const Corner<3>& o);
void
to_json(tpl::nlohmann::json& j, const Corner<2>& o);
void
to_json(tpl::nlohmann::json& j, const Corner<3>& o);
void
from_json(const tpl::nlohmann::json& j, Corner<2>& o);
void
from_json(const tpl::nlohmann::json& j, Corner<3>& o);
} // namespace ThunderEgg
#endif