quantum_numbers.h

Go to the documentation of this file.

#ifndef quantun_numbers_h
#define quantun_numbers_h
 
#include <algorithm>
#include <compare>
#include <cstddef>
#include <istream>
#include <limits>
#include <ostream>
#include <sstream>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include "debug.h"
#include "enums.h"
#include "isotopologues.h"
#include "matpack_concepts.h"
#include "nonstd.h"
#include "rational.h"
 
constexpr Index quantum_number_error_value = -999'999'999;
 
namespace Quantum::Number {
 
struct StringValue {
  static constexpr std::size_t N = 16;
  std::array<char, N> x{'\0'};  // First is \0 to be "empty"
 
  [[nodiscard]] constexpr std::string_view val() const noexcept {
    // Look for the first \0 or return everything
    for (std::size_t i = 0; i < N; i++)
      if (x[i] == '\0') return {x.data(), i};
    return {x.data(), N};
  }
 
  constexpr StringValue() = default;
 
  explicit constexpr StringValue(std::string_view s) {
    const std::size_t n = s.size();
 
    ARTS_USER_ERROR_IF(n > N,
                       "The value \"",
                       s,
                       "\" is too long.  Can be only ",
                       N,
                       " chars but is ",
                       n)
 
    // Fill with correct values or zero characters
    std::size_t i = 0;
    for (; i < n; i++) x[i] = s[i];
    if (i < N) x[i] = '\0';
  }
 
  constexpr std::strong_ordering operator<=>(const StringValue& sv) const {
    for (std::size_t i=0; i<N; i++) {
      if (x[i] < sv.x[i]) return std::strong_ordering::less;
      if (sv.x[i] < x[i]) return std::strong_ordering::greater;
    }
    return std::strong_ordering::equal;
  }
};
 
struct IntegerValue {
  Index x{std::numeric_limits<Index>::lowest()};
 
  [[nodiscard]] constexpr Rational val() const noexcept { return x; }
 
  constexpr std::strong_ordering operator<=>(const IntegerValue& i) const {return x<=> i.x;}
};
 
struct HalfIntegerValue {
  Index x{std::numeric_limits<Index>::lowest()};
 
  [[nodiscard]] constexpr Rational val() const noexcept {
    return Rational(x, 2);
  }
 
  constexpr std::strong_ordering operator<=>(const HalfIntegerValue& h) const {return x<=> h.x;}
};
 
ENUMCLASS(ValueType, char, S, I, H)
 
 
ENUMCLASS(Type,
          char,
          alpha,  // FIXME: Not in VAMDC
          config,  // FIXME: Not in VAMDC
          ElecStateLabel,
          F,
          F1,
          F10,
          F11,
          F12,
          F2,
          F3,
          F4,
          F5,
          F6,
          F7,
          F8,
          F9,
          I,
          J,
          K,
          Ka,
          Kc,
          L,  // FIXME: Not in VAMDC
          Lambda,
          N,
          Omega,
          S,
          Sigma,
          SpinComponentLabel,
          asSym,
          elecInv,
          elecRefl,
          elecSym,
          kronigParity,
          l,
          l1,
          l10,
          l11,
          l12,
          l2,
          l3,
          l4,
          l5,
          l6,
          l7,
          l8,
          l9,
          n,  // FIXME: Not in VAMDC
          parity,
          r,
          rotSym,
          rovibSym,
          sym,
          tau,  // FIXME: Not in VAMDC
          term,  // FIXME: Not in VAMDC
          v,
          v1,
          v10,
          v11,
          v12,
          v2,
          v3,
          v4,
          v5,
          v6,
          v7,
          v8,
          v9,
          vibInv,
          vibRefl,
          vibSym)
 
constexpr ValueType common_value_type(Type type) noexcept {
  switch (type) {
    case Type::alpha:
      return ValueType::S;
    case Type::config:
      return ValueType::S;
    case Type::ElecStateLabel:
      return ValueType::S;
    case Type::F:
      return ValueType::H;
    case Type::F1:
      return ValueType::H;
    case Type::F10:
      return ValueType::H;
    case Type::F11:
      return ValueType::H;
    case Type::F12:
      return ValueType::H;
    case Type::F2:
      return ValueType::H;
    case Type::F3:
      return ValueType::H;
    case Type::F4:
      return ValueType::H;
    case Type::F5:
      return ValueType::H;
    case Type::F6:
      return ValueType::H;
    case Type::F7:
      return ValueType::H;
    case Type::F8:
      return ValueType::H;
    case Type::F9:
      return ValueType::H;
    case Type::I:
      return ValueType::I;
    case Type::J:
      return ValueType::H;
    case Type::K:
      return ValueType::I;
    case Type::Ka:
      return ValueType::I;
    case Type::Kc:
      return ValueType::I;
    case Type::L:
      return ValueType::I;
    case Type::Lambda:
      return ValueType::I;
    case Type::N:
      return ValueType::I;
    case Type::Omega:
      return ValueType::H;
    case Type::S:
      return ValueType::H;
    case Type::Sigma:
      return ValueType::H;
    case Type::SpinComponentLabel:
      return ValueType::I;
    case Type::asSym:
      return ValueType::S;
    case Type::elecInv:
      return ValueType::S;
    case Type::elecRefl:
      return ValueType::S;
    case Type::elecSym:
      return ValueType::S;
    case Type::kronigParity:
      return ValueType::S;
    case Type::l:
      return ValueType::I;
    case Type::l1:
      return ValueType::I;
    case Type::l10:
      return ValueType::I;
    case Type::l11:
      return ValueType::I;
    case Type::l12:
      return ValueType::I;
    case Type::l2:
      return ValueType::I;
    case Type::l3:
      return ValueType::I;
    case Type::l4:
      return ValueType::I;
    case Type::l5:
      return ValueType::I;
    case Type::l6:
      return ValueType::I;
    case Type::l7:
      return ValueType::I;
    case Type::l8:
      return ValueType::I;
    case Type::l9:
      return ValueType::I;
    case Type::n:
      return ValueType::S;
    case Type::parity:
      return ValueType::S;
    case Type::r:
      return ValueType::I;
    case Type::rotSym:
      return ValueType::S;
    case Type::rovibSym:
      return ValueType::S;
    case Type::sym:
      return ValueType::S;
    case Type::tau:
      return ValueType::S;
    case Type::term:
      return ValueType::S;
    case Type::v:
      return ValueType::I;
    case Type::v1:
      return ValueType::I;
    case Type::v10:
      return ValueType::I;
    case Type::v11:
      return ValueType::I;
    case Type::v12:
      return ValueType::I;
    case Type::v2:
      return ValueType::I;
    case Type::v3:
      return ValueType::I;
    case Type::v4:
      return ValueType::I;
    case Type::v5:
      return ValueType::I;
    case Type::v6:
      return ValueType::I;
    case Type::v7:
      return ValueType::I;
    case Type::v8:
      return ValueType::I;
    case Type::v9:
      return ValueType::I;
    case Type::vibInv:
      return ValueType::S;
    case Type::vibRefl:
      return ValueType::S;
    case Type::vibSym:
      return ValueType::S;
    case Type::FINAL: {
    }
  }
  return ValueType::FINAL;
}
 
constexpr ValueType common_value_type(ValueType a, ValueType b) noexcept {
  // Same is same, H is I, a has both:
  if (a == b or (a == ValueType::H and b == ValueType::I)) return a;
 
  // H is I:
  if (b == ValueType::H and a == ValueType::I) return ValueType::H;
 
  // Something has gone very wrong:
  return ValueType::FINAL;
}
 
union ValueHolder {
  StringValue s;
  IntegerValue i;
  HalfIntegerValue h;
 
  constexpr ValueHolder(ValueType t) noexcept : s(StringValue{"NODEF"}) {
    switch (t) {
      case ValueType::H:
        h = HalfIntegerValue{0};
        break;
      case ValueType::I:
        i = IntegerValue{0};
        break;
      default: {
      }
    }
  }
 
  constexpr ValueHolder(Type t) noexcept : ValueHolder(common_value_type(t)) {}
  constexpr ValueHolder(const ValueHolder&) = default;
  constexpr ValueHolder(ValueHolder&&) noexcept = default;
  constexpr ValueHolder& operator=(const ValueHolder&) = default;
  constexpr ValueHolder& operator=(ValueHolder&&) noexcept = default;
};
 
struct ValueDescription {
  ValueType type;
  ValueHolder val;
 
  constexpr ValueDescription(ValueType t) noexcept : type(t), val(t) {}
  constexpr ValueDescription(const ValueDescription&) = default;
  constexpr ValueDescription(ValueDescription&&) noexcept = default;
  constexpr ValueDescription& operator=(const ValueDescription&) = default;
  constexpr ValueDescription& operator=(ValueDescription&&) noexcept = default;
 
  friend std::ostream& operator<<(std::ostream& os, ValueDescription x);
};
 
constexpr std::strong_ordering cmp(std::strong_ordering&& a, std::strong_ordering&& b) {
  return a == std::strong_ordering::equal ? b : a;
}
 
struct TwoLevelValueHolder {
  ValueHolder upp;
  ValueHolder low;
 
  constexpr TwoLevelValueHolder(ValueDescription u, ValueDescription l, Type t)
      : upp(u.val), low(l.val) {
    auto ct = common_value_type(t);
    if (u.type not_eq ct) {
      ARTS_USER_ERROR_IF(u.type not_eq ValueType::I,
                         "Cannot convert from ",
                         u.type,
                         " to ",
                         ct)
      upp.h.x = 2 * u.val.i.x;
    }
 
    if (l.type not_eq ct) {
      ARTS_USER_ERROR_IF(l.type not_eq ValueType::I,
                         "Cannot convert from ",
                         l.type,
                         " to ",
                         ct)
      low.h.x = 2 * l.val.i.x;
    }
  }
 
  constexpr TwoLevelValueHolder(Type t) noexcept : upp(t), low(t) {}
  constexpr TwoLevelValueHolder(const TwoLevelValueHolder&) = default;
  constexpr TwoLevelValueHolder(TwoLevelValueHolder&&) noexcept = default;
  constexpr TwoLevelValueHolder& operator=(const TwoLevelValueHolder&) = default;
  constexpr TwoLevelValueHolder& operator=(TwoLevelValueHolder&&) noexcept = default;
 
  [[nodiscard]] constexpr std::strong_ordering order(const TwoLevelValueHolder& tv, ValueType t) const {
    switch (t) {
    case ValueType::S:
      return cmp(upp.s <=> tv.upp.s, low.s <=> tv.low.s);
    case ValueType::I:
      return cmp(upp.i <=> tv.upp.i, low.i <=> tv.low.i);
    case ValueType::H:
      return cmp(upp.h <=> tv.upp.h, low.h <=> tv.low.h);
    case ValueType::FINAL: break;
    }
    return std::strong_ordering::equal;
  }
};
 
[[nodiscard]] constexpr ValueDescription value_holder(Rational r_) {
  const Rational r = reduce_by_gcd(r_);
 
  // We must now have a half-integer or not
  if (r.denom == 2) {
    ValueDescription x{ValueType::H};
    x.val.h.x = r.numer;
    return x;
  }
  
  if (r.denom == 1) {
    ValueDescription x{ValueType::I};
    x.val.i.x = r.numer;
    return x;
  }
 
  ValueDescription x{ValueType::I};
  x.val.i.x = quantum_number_error_value;
  return x;
}
 
[[nodiscard]] constexpr Rational cast_qnrat(std::string_view s) noexcept {
  // Counts for divides, decimals, and existence
  int div = 0, dot = 0, any = 0, minus = false;
  std::size_t const n = s.size();
 
  // Counts relevant items
  for (std::size_t i = 0; i < n; i++) {
    auto x = s[i];
    if (x == '-') {
      minus = true;
      if (i) return RATIONAL_UNDEFINED;
    } else if (x == '+') {
      if (i) return RATIONAL_UNDEFINED;
    } else if (x == '/')
      div++;  // Count divs because we can have at most one
    else if (x == '.')
      dot++;  // Count dots for the same reason
    else if (not nonstd::isdigit(x))
      return RATIONAL_UNDEFINED;  // Error!
 
    // There is a value!
    any++;
  }
 
  // Can only have one of div or dot and need some data
  if ((div + dot) > 1 or any == 0) return RATIONAL_UNDEFINED;
 
  // We have a rational!  Lets see which we have got
 
  // We have a simple rational
  if (div) {
    Index num = 0, den = 0;
    std::size_t i = 0;
 
    // Numerator
    for (; s[i] not_eq '/'; ++i) {
      if (s[i] == '-' or s[i] == '+') continue;
      num *= 10;
      num += s[i] - '0';
    }
 
    // Denominator
    i++;
    for (; i < s.size(); ++i) {
      den *= 10;
      den += s[i] - '0';
    }
 
    // Guard for QN style rationals
    return Rational(minus ? -num : num, den);
  }
 
  // We have a decimal number
  if (dot) {
    Index f = 0, d = 0;
    std::size_t i = 0;
 
    // The integer part
    for (; s[i] not_eq '.'; ++i) {
      if (s[i] == '-' or s[i] == '+') continue;
      f *= 10;
      f += s[i] - '0';
    }
 
    // The decimal part
    i++;
    for (; i < s.size(); ++i) {
      d *= 10;
      d += s[i] - '0';
    }
 
    if (d == 0) return minus ? -f : f;
    if (d == 5) return Rational((minus ? -1 : 1) * (2 * f + 1), 2);
    return RATIONAL_UNDEFINED;
  }
 
  std::size_t num = 0;
  for (auto x : s) {
    if (x == '-' or x == '+') continue;
    num *= 10;
    num += x - '0';
  }
  return minus ? -num : num;
}
 
[[nodiscard]] constexpr ValueDescription value_holder(std::string_view s,
                                                      Type t) {
  switch (common_value_type(t)) {
    case ValueType::I: 
    case ValueType::H: {
      const Rational r = cast_qnrat(s);
      return value_holder(r);
    }
    case ValueType::S: {
      ValueDescription x{ValueType::S};
      x.val.s = StringValue(s);
      return x;
    }
    case ValueType::FINAL: {
    }
  }
  
  return ValueType::FINAL;
}
 
struct LevelMatch {
  bool upp{true};
  bool low{true};
 
  constexpr operator bool() const noexcept { return upp and low; }
};
 
constexpr Index count_items(std::string_view s) noexcept {
  // Checks if we are in-between items, we start true as we are inbetween items
  bool last_space = true;
 
  Index count = 0;
  for (auto& x : s) {
    bool const this_space = nonstd::isspace(x);
 
    // If we had a space and now no longer do, we are in an item
    if (last_space and not this_space) count++;
 
    // The current state must be remembere
    last_space = this_space;
  }
  return count;
}
 
constexpr std::string_view rstrip(std::string_view x) {
  while (not x.empty() and nonstd::isspace(x.back())) x.remove_suffix(1);
  return x;
}
 
constexpr std::string_view lstrip(std::string_view x) {
  while (not x.empty() and nonstd::isspace(x.front())) x.remove_prefix(1);
  return x;
}
 
constexpr std::string_view strip(std::string_view x) {
  return rstrip(lstrip(x));
}
 
template <std::size_t n = 1>
constexpr std::string_view items(std::string_view s, std::size_t i) noexcept {
  static_assert(n > 0, "Must want some items");
  bool last_space = true;
 
  std::size_t beg = 0, count = 0, end = s.size();
  if (end == 0) return s;
 
  for (std::size_t ind = 0; ind < end; ind++) {
    bool const this_space = nonstd::isspace(s[ind]);
 
    // Return when we find the end of the final item
    if (this_space and count == i + n) return {&s[beg], ind - beg};
 
    // If we had a space and now no longer do, we are in an item
    if (last_space and not this_space) {
      count++;
 
      // If that is our first item, we are good!
      if (count - 1 == i) beg = ind;
    }
 
    // Count up the beginning until we have found the first item
    if (count - 1 < i) beg = ind;
 
    // The current state must be remembere
    last_space = this_space;
  }
 
  // Remove spaces at the end to be sure
  while (nonstd::isspace(s[end - 1]) and end > beg) end--;
  return {&s[beg], end - beg};
}
 
struct Value {
  Type type;
  TwoLevelValueHolder qn;
 
  constexpr std::strong_ordering operator<=>(const Value& v) const {
    if (type < v.type) return std::strong_ordering::less;
    if (v.type < type) return std::strong_ordering::greater;
    return qn.order(v.qn, common_value_type(type));
  }
 
  constexpr Value(Type t=Type::FINAL) : type(t), qn(type) {}
  Value(const Value&) = default;
  Value(Value&&) noexcept = default;
  Value& operator=(const Value&) = default;
  Value& operator=(Value&&) noexcept = default;
 
  constexpr Value(Type t, Rational upp_, Rational low_) : Value(t) {
    Rational upp = reduce_by_gcd(upp_), low = reduce_by_gcd(low_);
 
    if (common_value_type(type) == ValueType::H) {
      ARTS_ASSERT(upp.denom <= 2 and low.denom <= 2)
      if (upp.denom not_eq 2) upp *= 2;
      if (low.denom not_eq 2) low *= 2;
      qn.upp.h.x = upp.numer;
      qn.low.h.x = low.numer;
    } else if (common_value_type(type) == ValueType::I) {
      ARTS_ASSERT(upp.denom == 1 and low.denom == 1)
      qn.upp.i.x = upp.numer;
      qn.low.i.x = low.numer;
    } else {
      ARTS_USER_ERROR(
          t, " is a string-type, so cannot be constructed from rationals")
    }
  }
 
  constexpr Value(std::string_view s) : Value(toTypeOrThrow(items(s, 0))) {
    ARTS_USER_ERROR_IF(count_items(s) not_eq 3,
                       "Must have ' TYPE UPPNUM LOWNUM ' but got: '",
                       s,
                       '\'')
 
    // Get values and ensure they are good types
    auto upv = value_holder(items(s, 1), type);
    auto lov = value_holder(items(s, 2), type);
 
    // Deal with errors while setting the level values
    qn = TwoLevelValueHolder(upv, lov, type);
  }
 
  [[nodiscard]] constexpr Rational upp() const noexcept {
    switch (common_value_type(type)) {
      case ValueType::I:
        return qn.upp.i.val();
      case ValueType::H:
        return qn.upp.h.val();
      default: {
      }
    }
    return RATIONAL_UNDEFINED;
  }
 
  [[nodiscard]] constexpr Rational low() const noexcept {
    switch (common_value_type(type)) {
      case ValueType::I:
        return qn.low.i.val();
      case ValueType::H:
        return qn.low.h.val();
      default: {
      }
    }
    return RATIONAL_UNDEFINED;
  }
 
  [[nodiscard]] String str_upp() const noexcept;
 
  [[nodiscard]] String str_low() const noexcept;
 
  void swap_values(Value& x);
 
  constexpr void set(std::string_view s, bool upp) {
    ValueDescription const v = value_holder(s, type);
    TwoLevelValueHolder const nqn(v, v, type);
    if (upp) {
      qn.upp = nqn.upp;
    } else {
      qn.low = nqn.low;
    }
  }
 
  [[nodiscard]] constexpr LevelMatch level_match(Value other) const noexcept {
    if (type == other.type) {
      switch (common_value_type(type)) {
        case ValueType::I:
        case ValueType::H:
          return {upp() == other.upp(), low() == other.low()};
        case ValueType::S:
          return {qn.upp.s.x == other.qn.upp.s.x,
                  qn.low.s.x == other.qn.low.s.x};
        case ValueType::FINAL: {
        }
      }
    }
    return {false, false};
  }
 
  friend std::ostream& operator<<(std::ostream& os, Value x);
 
  friend std::istream& operator>>(std::istream& is, Value& x);
 
  bofstream& write(bofstream& bof) const;
 
  bifstream& read(bifstream& bif);
 
  [[nodiscard]] constexpr bool good() const {return level_match(*this);}
};
 
ENUMCLASS(CheckValue, char, Full, AinB, BinA, Miss)
 
 
struct CheckMatch {
  CheckValue upp{CheckValue::Full};
  CheckValue low{CheckValue::Full};
 
  constexpr operator bool() const noexcept {
    return upp == CheckValue::Full and low == CheckValue::Full;
  }
};
 
constexpr CheckValue update(CheckValue val, CheckValue res) noexcept {
  if (val == CheckValue::Miss) return val;
  if (val == CheckValue::Full) return res;
  if (res == CheckValue::Miss) return res;
  if (res == CheckValue::Full) return val;
  if (val == res) return val;
  return CheckValue::Miss;
}
 
constexpr CheckMatch update(CheckMatch val, CheckValue res) noexcept {
  return {update(val.upp, res), update(val.low, res)};
}
 
constexpr CheckMatch update(CheckMatch val, CheckMatch res) noexcept {
  return {update(val.upp, res.upp), update(val.low, res.low)};
}
 
template <size_t N>
constexpr bool is_sorted(const std::array<Type, N>& types) noexcept {
  for (size_t i = 1; i < N; i++)
    if (not(types[i - 1] < types[i])) return false;
  return true;
}
 
class ValueList {
  Array<Value> values;
 
  void sort_by_type();
 
  [[nodiscard]] bool has_unique_increasing_types() const;
 
 public:
  explicit ValueList(std::string_view s, bool legacy = false);
 
  ValueList(std::string_view upp, std::string_view low);
 
  std::strong_ordering operator<=>(const ValueList& v) const {
    const std::size_t n = std::min(values.size(), v.values.size());
    for (std::size_t i=0; i<n; i++) {
      if (values[i] < v.values[i]) return std::strong_ordering::less;
      if (v.values[i] < values[i]) return std::strong_ordering::greater;
    }
    return values.size() <=> v.values.size();
  }
 
  explicit ValueList(Array<Value> values_) : values(std::move(values_)) {
    finalize();
  }
 
  ValueList() : values(0) {}
 
  Array<Value>::iterator begin() { return values.begin(); }
  Array<Value>::iterator end() { return values.end(); }
  Array<Value>::iterator cbegin() { return values.begin(); }
  Array<Value>::iterator cend() { return values.end(); }
  [[nodiscard]] Array<Value>::const_iterator begin() const {
    return values.begin();
  }
  [[nodiscard]] Array<Value>::const_iterator end() const {
    return values.end();
  }
  [[nodiscard]] Array<Value>::const_iterator cbegin() const {
    return values.cbegin();
  }
  [[nodiscard]] Array<Value>::const_iterator cend() const {
    return values.cend();
  }
 
  void finalize();
 
  [[nodiscard]] Index nelem() const ARTS_NOEXCEPT { return values.nelem(); }
 
  [[nodiscard]] bool perpendicular(const ValueList& that) const ARTS_NOEXCEPT;
 
  template <typename... Types>
  [[nodiscard]] bool has(Types... ts) const ARTS_NOEXCEPT {
    static_assert(sizeof...(Types) > 0);
 
    ARTS_ASSERT(is_sorted(std::array{Type(ts)...}))
 
    auto ptr = cbegin();
    auto end = cend();
    for (Type t : {Type(ts)...}) {
      ptr = std::find_if(ptr, end, [t](auto& x) { return x.type == t; });
      if (ptr == end) return false;
    }
    return true;
  }
 
  const Value& operator[](Type t) const ARTS_NOEXCEPT;
 
  Value& operator[](Index i) { return values.at(i); }
 
  Value& add(Type t);
 
  Value& add(Value v);
 
  void set(Value v);
 
  void set(Index i, std::string_view upp, std::string_view low);
 
  [[nodiscard]] CheckMatch check_match(const ValueList& other) const ARTS_NOEXCEPT;
 
  friend std::ostream& operator<<(std::ostream& os, const ValueList& vl);
 
  friend std::istream& operator>>(std::istream& is, ValueList& vl);
 
  void add_type_wo_sort(Type);
 
  [[nodiscard]] bool good() const;
};
 
ValueList from_hitran(std::string_view upp, std::string_view low);
 
struct LocalState {
  ValueList val{};
 
  std::strong_ordering operator<=>(const LocalState& l) const {
    return val <=> l.val;
  }
  auto operator==(const LocalState& l) const {return std::strong_ordering::equal == (*this <=> l);}
  auto operator!=(const LocalState& l) const {return std::strong_ordering::equal != (*this <=> l);}
 
  LocalState() = default;
 
  template <typename... Values>
  LocalState(Values... vals) : val(Array<Value>{Value(vals)...}) {}
 
  void set_unsorted_qns(const Array<Type>& vals);
 
  [[nodiscard]] String keys() const;
 
  [[nodiscard]] String values() const;
 
  [[nodiscard]] bool same_types_as(const LocalState& that) const;
 
  friend std::ostream& operator<<(std::ostream& os, const LocalState& vl);
 
  friend std::istream& operator>>(std::istream& is, LocalState& vl);
 
  [[nodiscard]] bool good() const;
};
 
struct LevelTest {bool upp{true}, low{true};};
 
struct GlobalState {
  static constexpr Index version = 1;  // Second version of quantum identifiers
 
  Index isotopologue_index{-1};
  ValueList val{};
 
  GlobalState() = default;
 
  explicit GlobalState(Index i, ValueList v = {})
      : isotopologue_index(i), val(std::move(v)) {}
 
  explicit GlobalState(const Species::IsotopeRecord& ir)
      : isotopologue_index(Species::find_species_index(ir)) {}
 
  explicit GlobalState(std::string_view s, Index v = version);
 
  [[nodiscard]] Species::IsotopeRecord Isotopologue() const noexcept;
  [[nodiscard]] Species::Species Species() const noexcept;
 
  friend std::ostream& operator<<(std::ostream& os, const GlobalState& gs);
 
  friend std::istream& operator>>(std::istream& is, GlobalState& gs);
 
  [[nodiscard]] GlobalState LowerLevel() const;
  [[nodiscard]] GlobalState UpperLevel() const;
 
  std::strong_ordering operator<=>(const GlobalState& g) const {
    if (isotopologue_index < g.isotopologue_index) return std::strong_ordering::less;
    if (g.isotopologue_index < isotopologue_index) return std::strong_ordering::greater;
    return val <=> g.val;
  }
  auto operator==(const GlobalState& g) const {return std::strong_ordering::equal == (*this <=> g);}
  auto operator!=(const GlobalState& g) const {return std::strong_ordering::equal != (*this <=> g);}
 
  [[nodiscard]] bool part_of(const GlobalState& other) const;
 
  [[nodiscard]] LevelTest part_of(const GlobalState& g, const LocalState& l) const;
 
  [[nodiscard]] bool good() const;
};
 
ENUMCLASS(StateMatchType, char, Full, Level, Isotopologue, Species, None)
 
 
struct StateMatch {
  StateMatchType type{StateMatchType::None};
  bool upp{false}, low{false};
 
  constexpr StateMatch() = default;
 
  StateMatch(const GlobalState& target,
             const LocalState& local,
             const GlobalState& global);
 
  StateMatch(const GlobalState& target, const GlobalState& key);
 
  constexpr bool operator==(StateMatchType x) const noexcept {
    return x == type;
  }
 
  constexpr bool operator!=(StateMatchType x) const noexcept { return not((*this) == x); }
};
 
ENUMCLASS(
    VAMDC,
    char,
    asymcs,  // Schema for specifying the quantum numbers of closed-shell asymmetric top molecules
    asymos,  // Schema for specifying the quantum numbers of open-shell asymmetric top molecules
    dcs,  // Schema for specifying the quantum numbers of closed-shell, diatomic molecules
    hunda,  // Schema for specifying the quantum numbers for Hund's case (a) diatomic molecules
    hundb,  // Schema for specifying the quantum numbers for Hund's case (b) diatomic molecules
    lpcs,  // Schema for specifying the quantum numbers of closed-shell linear polyatomic molecules
    lpos,  // Schema for specifying the quantum numbers of open-shell linear polyatomic molecules
    ltcs,  // Schema for specifying the quantum numbers of closed-shell linear triatomic molecules
    ltos,  // Schema for specifying the quantum numbers of open-shell linear triatomic molecules
    nltcs,  // Schema for specifying the quantum numbers of closed-shell non-linear triatomic molecules
    nltos,  // Schema for specifying the quantum numbers of open-shell non-linear triatomic molecules
    sphcs,  // Schema for specifying the quantum numbers of closed-shell spherical top molecules
    sphos,  // Schema for specifying the quantum numbers of closed-shell spherical top molecules
    stcs  // Schema for specifying the quantum numbers of closed-shell, symmetric top molecules
)
 
 
bool vamdcCheck(const ValueList& l, VAMDC type) ARTS_NOEXCEPT;
 
[[maybe_unused]] constexpr std::array global_types{Type::alpha,
                                                   Type::config,
                                                   Type::ElecStateLabel,
                                                   Type::L,
                                                   Type::Lambda,
                                                   Type::Omega,
                                                   Type::S,
                                                   Type::Sigma,
                                                   Type::SpinComponentLabel,
                                                   Type::asSym,
                                                   Type::elecInv,
                                                   Type::elecRefl,
                                                   Type::elecSym,
                                                   Type::kronigParity,
                                                   Type::l,
                                                   Type::l1,
                                                   Type::l10,
                                                   Type::l11,
                                                   Type::l12,
                                                   Type::l2,
                                                   Type::l3,
                                                   Type::l4,
                                                   Type::l5,
                                                   Type::l6,
                                                   Type::l7,
                                                   Type::l8,
                                                   Type::l9,
                                                   Type::n,
                                                   Type::parity,
                                                   Type::r,
                                                   Type::rotSym,
                                                   Type::rovibSym,
                                                   Type::sym,
                                                   Type::tau,
                                                   Type::term,
                                                   Type::v,
                                                   Type::v1,
                                                   Type::v10,
                                                   Type::v11,
                                                   Type::v12,
                                                   Type::v2,
                                                   Type::v3,
                                                   Type::v4,
                                                   Type::v5,
                                                   Type::v6,
                                                   Type::v7,
                                                   Type::v8,
                                                   Type::v9,
                                                   Type::vibInv,
                                                   Type::vibRefl,
                                                   Type::vibSym};
 
[[maybe_unused]] constexpr std::array local_types{Type::F,
                                                  Type::F1,
                                                  Type::F10,
                                                  Type::F11,
                                                  Type::F12,
                                                  Type::F2,
                                                  Type::F3,
                                                  Type::F4,
                                                  Type::F5,
                                                  Type::F6,
                                                  Type::F7,
                                                  Type::F8,
                                                  Type::F9,
                                                  Type::I,
                                                  Type::J,
                                                  Type::K,
                                                  Type::Ka,
                                                  Type::Kc,
                                                  Type::N};
}  // namespace Quantum::Number
 
using QuantumNumberType = Quantum::Number::Type;
using QuantumNumberValue = Quantum::Number::Value;
using QuantumNumberValueList = Quantum::Number::ValueList;
using QuantumNumberLocalState = Quantum::Number::LocalState;
using QuantumIdentifier = Quantum::Number::GlobalState;
using ArrayOfQuantumIdentifier = Array<QuantumIdentifier>;
 
#endif  // quantun_numbers_h