species_tags.h

Go to the documentation of this file.

#ifndef species_tags_h
#define species_tags_h
 
#include <algorithm>
#include <set>
 
#include "array.h"
#include "enums.h"
#include "isotopologues.h"
#include "matpackI.h"
#include "mystring.h"
 
namespace Species {
ENUMCLASS(TagType, unsigned char,
    Plain,
    Zeeman,
    PredefinedLegacy,
    PredefinedModern,
    Cia,
    FreeElectrons,
    Particles,
    XsecFit,
    NoLines)
struct Tag {
  Index spec_ind{-1};
 
 
  Numeric lower_freq{-1};
 
 
  Numeric upper_freq{-1};
  
  TagType type{TagType::FINAL};
 
 
  Species cia_2nd_species{Species::FINAL};
 
 
  Index cia_dataset_index{-1};
 
  constexpr Tag() noexcept = default;
  
  // Documentation is with implementation.
  explicit Tag(String def);
  
  constexpr Tag(const IsotopeRecord& isot) noexcept :
  spec_ind(find_species_index(isot)),
  type(is_predefined_model(isot) ? TagType::PredefinedLegacy : TagType::Plain) { /* Nothing to be done here. */
  }
  
  // Documentation is with implementation.
  [[nodiscard]] String Name() const;
  
  [[nodiscard]] constexpr IsotopeRecord Isotopologue() const noexcept {return spec_ind < 0 ? IsotopeRecord{} : Isotopologues[spec_ind];}
  
  constexpr void Isotopologue(const IsotopeRecord& ir) ARTS_NOEXCEPT {
    Index ind = find_species_index(ir);
    ARTS_ASSERT(ind < 0, "Bad species extracted from: ", ir)
    spec_ind = ind;
  }
  
  [[nodiscard]] constexpr Numeric Mass() const noexcept {return Isotopologue().mass;}
  
  [[nodiscard]] Numeric Q(Numeric T) const;
  
  [[nodiscard]] Numeric dQdT(Numeric T) const;
  
  [[nodiscard]] String FullName() const noexcept {return Isotopologue().FullName();}
  
  [[nodiscard]] constexpr Species Spec() const noexcept {return Isotopologue().spec;}
  
  [[nodiscard]] constexpr TagType Type() const noexcept {return type;}
  
  friend std::ostream& operator<<(std::ostream& os, const Tag& ot) {return os << ot.Name();}
  
  constexpr bool operator==(const Tag& other) const noexcept {
    return  other.spec_ind == spec_ind and
            other.lower_freq == lower_freq and
            other.upper_freq == upper_freq and
            other.type == type and
            other.cia_2nd_species == cia_2nd_species and
            other.cia_dataset_index == cia_dataset_index;
  }
  
  constexpr bool operator!=(const Tag& other) const noexcept {
    return not operator==(other);
  }
  
  [[nodiscard]] constexpr bool is_joker() const ARTS_NOEXCEPT {ARTS_ASSERT(spec_ind >= 0) return Joker == Isotopologue().isotname;}
};
} // namespace Species
 
using SpeciesTagType = Species::TagType;
 
using SpeciesTag = Species::Tag;
 
class ArrayOfSpeciesTag final : public Array<SpeciesTag> {
public:
  ArrayOfSpeciesTag() noexcept : Array<SpeciesTag>() {}
  explicit ArrayOfSpeciesTag(Index n) :  Array<SpeciesTag>(n) {}
  ArrayOfSpeciesTag(Index n, const SpeciesTag& fillvalue) : Array<SpeciesTag>(n, fillvalue) {}
  ArrayOfSpeciesTag(const ArrayOfSpeciesTag& A) = default;
  ArrayOfSpeciesTag(ArrayOfSpeciesTag&& A) noexcept : Array<SpeciesTag>(std::move(A)) {}
  explicit ArrayOfSpeciesTag(std::vector<SpeciesTag> x) : Array<SpeciesTag>(std::move(x)) {}
  
  // Assignment operators:
  ArrayOfSpeciesTag& operator=(SpeciesTag x) {
    std::fill(this->begin(), this->end(), x);
    return *this;
  }
  ArrayOfSpeciesTag& operator=(const ArrayOfSpeciesTag& A) {
    this->resize(A.size());
    std::copy(A.begin(), A.end(), this->begin());
    return *this;
  }
  ArrayOfSpeciesTag& operator=(ArrayOfSpeciesTag&& A) noexcept {
    Array<SpeciesTag>::operator=(std::move(A));
    return *this;
  }
  
  ArrayOfSpeciesTag(String names);
  
  friend std::ostream& operator<<(std::ostream& os, const ArrayOfSpeciesTag& ot) {
    bool first = true;
    for (auto& x: ot) {if (not first) os << ' '; else first = false; os << x;}
    return os;
  }
  
  [[nodiscard]] Species::Species Species() const ARTS_NOEXCEPT {
    ARTS_ASSERT(size() not_eq 0, "Invalid ArrayOfSpeciesTag without any species")
    return operator[](0).Spec();
  }
  
//   /*! Returns the species of the first elements, it is not allowed to have an empty list calling this */
  [[nodiscard]] Species::TagType Type() const ARTS_NOEXCEPT {
    ARTS_ASSERT(size() not_eq 0, "Invalid ArrayOfSpeciesTag without any species")
    return operator[](0).Type();
  }
  
  [[nodiscard]] String Name() const;
  
  [[nodiscard]] bool Plain() const noexcept {
    return std::any_of(cbegin(), cend(), [](auto& spec){return spec.Type() == Species::TagType::Plain;});
  }
  
  [[nodiscard]] bool Zeeman() const noexcept {
    return std::any_of(cbegin(), cend(), [](auto& spec){return spec.Type() == Species::TagType::Zeeman;});
  }
  
  [[nodiscard]] bool RequireLines() const noexcept {
    return Plain() or Zeeman();
  }
  
  [[nodiscard]] bool FreeElectrons() const noexcept {
    return std::any_of(cbegin(), cend(), [](auto& spec){return spec.Type() == Species::TagType::FreeElectrons;});
  }
  
  [[nodiscard]] bool Particles() const noexcept {
    return std::any_of(cbegin(), cend(), [](auto& spec){return spec.Type() == Species::TagType::Particles;});
  }
};
 
using ArrayOfArrayOfSpeciesTag = Array<ArrayOfSpeciesTag>;
 
struct SpeciesTagTypeStatus {
  bool Plain{false},
    Zeeman{false},
    PredefinedLegacy{false},
    PredefinedModern{false},
    Cia{false},
    FreeElectrons{false},
    Particles{false},
    XsecFit{false},
    NoLines{false};
  SpeciesTagTypeStatus(const ArrayOfArrayOfSpeciesTag& abs_species);
  friend std::ostream& operator<<(std::ostream&, SpeciesTagTypeStatus);
};
 
Index find_next_species(const ArrayOfArrayOfSpeciesTag& abs_species, Species::Species spec, Index i) noexcept;
 
Index find_first_species(const ArrayOfArrayOfSpeciesTag& abs_species, Species::Species spec) noexcept;
 
std::pair<Index, Index> find_first_species_tag(const ArrayOfArrayOfSpeciesTag& abs_species, const SpeciesTag& tag) noexcept;
 
std::pair<Index, Index> find_first_isotologue(const ArrayOfArrayOfSpeciesTag& abs_species, const SpeciesIsotopeRecord& isot) noexcept;
 
void check_abs_species(const ArrayOfArrayOfSpeciesTag& abs_species);
 
std::set<Species::Species> lbl_species(const ArrayOfArrayOfSpeciesTag&) noexcept;
 
namespace Species {
Numeric first_vmr(const ArrayOfArrayOfSpeciesTag& abs_species,
                  const Vector& rtp_vmr,
                  const Species spec) ARTS_NOEXCEPT;
} // namespace Species
 
#endif  // species_tags_h