RefFrame.h

Go to the documentation of this file.

/*
 * RefFrame.h
 *
 *  Created on: 19 Oct 2018
 *      Author: Nicola Mori
 */

#ifndef HERD_REFFRAME_H_
#define HERD_REFFRAME_H_

#include <array>
#include <stdexcept>
#include <string>

#include "common/Exception.h"

namespace Herd {

namespace RefFrame {

enum class Coo : int { NONE = -1, X = 0, Y = 1, Z = 2 };
constexpr std::array<Coo, 3> Coos{Coo::X, Coo::Y, Coo::Z};
const std::array<std::string, 3> CooName{"X", "Y", "Z"};
inline std::ostream &operator<<(std::ostream &out, const Coo &coo) { return out << CooName[static_cast<int>(coo)]; }
inline std::string operator+(const std::string &str, const Coo &coo) { return str + CooName[static_cast<int>(coo)]; }

// REMEMBER: modify the ToCoo function if/when new axes are defined.
enum class Axis : int { NONE = -1, X = 0, Y = 1, Z = 2 };
constexpr int NAxes = 3;
constexpr std::array<Axis, NAxes> Axes{Axis::X, Axis::Y, Axis::Z};
const std::array<std::string, NAxes> AxisName{"X", "Y", "Z"};
inline std::ostream &operator<<(std::ostream &out, const Axis &axis) { return out << AxisName[static_cast<int>(axis)]; }
inline std::string operator+(const std::string &str, const Axis &axis) {
  return str + AxisName[static_cast<int>(axis)];
}

enum class Direction : int {
  NONE = -1,
  Xpos = 0,
  Xneg = 1,
  Ypos = 2,
  Yneg = 3,
  Zpos = 4,
  Zneg = 5,
  XnegYneg = 6,
  XposYneg = 7,
  XnegYpos = 8,
  XposYpos = 9
};

constexpr int NDirections = 10;

constexpr std::array<RefFrame::Direction, RefFrame::NDirections> Directions{
    RefFrame::Direction::Xpos,     RefFrame::Direction::Xneg,     RefFrame::Direction::Ypos,
    RefFrame::Direction::Yneg,     RefFrame::Direction::Zpos,     RefFrame::Direction::Zneg,
    RefFrame::Direction::XnegYneg, RefFrame::Direction::XposYneg, RefFrame::Direction::XnegYpos,
    RefFrame::Direction::XposYpos};

const std::array<std::string, RefFrame::NDirections> DirectionName{
    "Xpos", "Xneg", "Ypos", "Yneg", "Zpos", "Zneg", "XnegYneg", "XposYneg", "XnegYpos", "XposYpos"};

inline std::ostream &operator<<(std::ostream &out, const Direction &direction) {
  return out << DirectionName[static_cast<int>(direction)];
}
inline std::string operator+(const std::string &str, const Direction &direction) {
  return str + DirectionName[static_cast<int>(direction)];
}

enum class View : int { NONE = -1, XY = 0, XZ = 1, YZ = 2 };
constexpr int NViews = 3;
constexpr std::array<View, NViews> Views{View::XY, View::XZ, View::YZ};
const std::array<std::string, NViews> ViewName{"XY", "XZ", "YZ"};
inline std::ostream &operator<<(std::ostream &out, const View &view) { return out << ViewName[static_cast<int>(view)]; }
inline std::string operator+(const std::string &str, const View &view) {
  return str + ViewName[static_cast<int>(view)];
}

enum class Side : int { NONE = -1, Xpos = 0, Xneg = 1, Ypos = 2, Yneg = 3, TOP = 4 };
constexpr int NSides = 5;
constexpr std::array<Side, NSides> Sides{Side::Xpos, Side::Xneg, Side::Ypos, Side::Yneg, Side::TOP};
const std::array<std::string, NSides> SideName{"Xpos", "Xneg", "Ypos", "Yneg", "TOP"};
inline std::ostream &operator<<(std::ostream &out, const Side &side) { return out << SideName[static_cast<int>(side)]; }
inline std::string operator+(const std::string &str, const Side &side) {
  return str + SideName[static_cast<int>(side)];
}

template <RefFrame::Axis T> struct Ortog {};

template <> struct Ortog<RefFrame::Axis::X> {
  RefFrame::Axis Dir1 = RefFrame::Axis::Y;
  RefFrame::Axis Dir2 = RefFrame::Axis::Z;
};

template <> struct Ortog<RefFrame::Axis::Y> {
  RefFrame::Axis Dir1 = RefFrame::Axis::X;
  RefFrame::Axis Dir2 = RefFrame::Axis::Z;
};

template <> struct Ortog<RefFrame::Axis::Z> {
  RefFrame::Axis Dir1 = RefFrame::Axis::X;
  RefFrame::Axis Dir2 = RefFrame::Axis::Y;
};

struct ViewAxes {
  RefFrame::Axis abscissa;
  RefFrame::Axis ordinate;
};

inline RefFrame::ViewAxes AxesOf(RefFrame::View view) {
  switch (view) {
  case View::XZ:
    return {Axis::X, Axis::Z};
    break;
  case View::YZ:
    return {Axis::Y, Axis::Z};
    break;
  case View::XY:
    return {Axis::X, Axis::Y};
    break;
  default:
    throw Exception("RefFrame::AxesOf: Invalid view");
    break;
  }
}

/* ******** Conversion functions ******** */

inline Coo ToCoo(Axis axis) { return static_cast<Coo>(static_cast<int>(axis)); }

inline Axis ToAxis(Coo coo) { return static_cast<Axis>(static_cast<int>(coo)); }

inline Axis ToAxis(Direction dir) {
  switch (dir) {
  case Direction::Xneg:
  case Direction::Xpos:
    return Axis::X;
  case Direction::Yneg:
  case Direction::Ypos:
    return Axis::Y;
  case Direction::Zneg:
  case Direction::Zpos:
    return Axis::Z;
  case Direction::NONE:
    return Axis::NONE;
  default:
    throw std::runtime_error("RefFrame::ToAxis: unknown direction");
  }
  throw std::runtime_error("RefFrame::ToAxis: unknown direction");
}

inline Coo ToCoo(Direction direction) { return static_cast<Coo>(static_cast<int>(RefFrame::ToAxis(direction))); }

/* ******** Utility functions ******** */

inline Axis NormalAxis(Side side) {
  switch (side) {
  case Side::TOP:
    return Axis::Z;
  case Side::Xpos:
  case Side::Xneg:
    return Axis::X;
  case Side::Ypos:
  case Side::Yneg:
    return Axis::Y;
  case Side::NONE:
    return Axis::NONE;
  }
  throw std::runtime_error("RefFrame::NormalAxis: unknown side");
}

inline Axis NormalAxis(View view) {
  switch (view) {
  case View::XZ:
    return Axis::Y;
  case View::YZ:
    return Axis::X;
  case View::XY:
    return Axis::Z;
  case View::NONE:
    return Axis::NONE;
  }
  throw std::runtime_error("RefFrame::NormalAxis: unknown side");
}

inline Direction NormalDirection(Side side) {
  switch (side) {
  case Side::TOP:
    return Direction::Zpos;
  case Side::Xpos:
    return Direction::Xpos;
  case Side::Xneg:
    return Direction::Xneg;
  case Side::Ypos:
    return Direction::Ypos;
  case Side::Yneg:
    return Direction::Yneg;
  case Side::NONE:
    return Direction::NONE;
  }
  throw std::runtime_error("RefFrame::NormalAxis: unknown side");
}

inline Axis NormalAxis(Axis ax1, Axis ax2) {
  if (ax1 == ax2) {
    throw std::runtime_error("RefFrame::NormalAxis: called with ax1 = ax2");
  }

  if ((ax1 == Axis::X && ax2 == Axis::Y) || (ax1 == Axis::Y && ax2 == Axis::X)) {
    return Axis::Z;
  }
  if ((ax1 == Axis::X && ax2 == Axis::Z) || (ax1 == Axis::Z && ax2 == Axis::X)) {
    return Axis::Y;
  }
  if ((ax1 == Axis::Z && ax2 == Axis::Y) || (ax1 == Axis::Y && ax2 == Axis::Z)) {
    return Axis::X;
  }

  return Axis::NONE;
}

inline std::pair<Axis, Axis> NormalAxes(Axis ax) {
  std::pair<Axis, Axis> normalAxes;
  if (ax == Axis::X) {
    normalAxes.first = Axis::Y;
    normalAxes.second = Axis::Z;
  } else if (ax == Axis::Y) {
    normalAxes.first = Axis::Z;
    normalAxes.second = Axis::X;
  } else if (ax == Axis::Z) {
    normalAxes.first = Axis::X;
    normalAxes.second = Axis::Y;
  } else {
    throw Herd::Exception("RefFrame::NormalAxes: called with invalid axis");
  }
  return normalAxes;
}

inline bool IsPositive(Direction dir) {
  if (dir == Direction::XposYpos || dir == Direction::XnegYpos || dir == Direction::XnegYneg ||
      dir == Direction::XposYneg)
    throw std::runtime_error(
        "RefFrame:::IsPositive called with direction = to XposYpos or XnegYpos or XnegYneg or XposYneg");
  return (dir == Direction::Xpos || dir == Direction::Ypos || dir == Direction::Zpos);
}

} // namespace RefFrame

} // namespace Herd

#endif /* HERD_REFFRAME_H_ */