absorptionlines.h

Go to the documentation of this file.

/* Copyright (C) 2019
 Richard Larsson <ric.larsson@gmail.com>
 
 
 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 2, 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, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 USA. */
 
#ifndef absorptionlines_h
#define absorptionlines_h
 
#include "bifstream.h"
 
#include "bofstream.h"
 
#include "enums.h"
 
#include "lineshapemodel.h"
 
#include "matpack.h"
 
#include "quantum.h"
 
#include "zeemandata.h"
 
#include <vector>
 
 
namespace Absorption {
ENUMCLASS(MirroringType, char,
  None,             // No mirroring
  Lorentz,          // Mirror, but use Lorentz line shape
  SameAsLineShape,  // Mirror using the same line shape
  Manual            // Mirror by having a line in the array of line record with negative F0
)  // MirroringType
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreturn-type"
constexpr std::string_view mirroringtype2metadatastring(MirroringType in) noexcept {
  switch (in) {
    case MirroringType::None:
      return "These lines are not mirrored at 0 Hz.\n";
    case MirroringType::Lorentz:
      return "These lines are mirrored around 0 Hz using the Lorentz line shape.\n";
    case MirroringType::SameAsLineShape:
      return "These line are mirrored around 0 Hz using the original line shape.\n";
    case MirroringType::Manual:
      return "There are manual line entries in the catalog to mirror this line.\n";
    case MirroringType::FINAL: break;
  }
}
#pragma GCC diagnostic pop
 
ENUMCLASS(NormalizationType, char,
  None,                // Do not renormalize the line shape
  VVH,                 // Renormalize with Van Vleck and Huber specifications
  VVW,                 // Renormalize with Van Vleck and Weiskopf specifications
  RQ,                  // Renormalize using Rosenkranz's quadratic specifications
  SFS                  // Renormalize using simple frequency scaling of the line strength
)  // NormalizationType
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreturn-type"
constexpr std::string_view normalizationtype2metadatastring(NormalizationType in) {
  switch (in) {
    case NormalizationType::None:
      return "No re-normalization in the far wing will be applied.\n";
    case NormalizationType::VVH:
      return "van Vleck and Huber far-wing renormalization will be applied, "
        "i.e. F ~ (f tanh(hf/2kT))/(f0 tanh(hf0/2kT))\n";
    case NormalizationType::VVW:
      return "van Vleck and Weisskopf far-wing renormalization will be applied, "
        "i.e. F ~ (f/f0)^2\n";
    case NormalizationType::RQ:
      return "Rosenkranz quadratic far-wing renormalization will be applied, "
        "i.e. F ~ hf0/2kT sinh(hf0/2kT) (f/f0)^2\n";
    case NormalizationType::SFS:
      return "Simple frequency scaling of the far-wings will be applied, "
        "i.e. F ~ (f / f0) * ((1 - exp(- hf / kT)) / (1 - exp(- hf0 / kT)))\n";
    case NormalizationType::FINAL: break;
  }
}
#pragma GCC diagnostic pop
 
ENUMCLASS(PopulationType, char,
  LTE,                            // Assume band is in LTE
  NLTE,                           // Assume band is in NLTE and the upper-to-lower ratio is known
  VibTemps,                       // Assume band is in NLTE described by vibrational temperatures and LTE at other levels
  ByHITRANRosenkranzRelmat,       // Assume band needs to compute relaxation matrix to derive HITRAN Y-coefficients
  ByHITRANFullRelmat,             // Assume band needs to compute and directly use the relaxation matrix according to HITRAN
  ByMakarovFullRelmat,            // Assume band needs to compute and directly use the relaxation matrix according to Makarov et al 2020
  ByRovibLinearDipoleLineMixing   // Assume band needs to compute and directly use the relaxation matrix according to Hartmann, Boulet, Robert, 2008, 1st edition
)  // PopulationType
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreturn-type"
constexpr std::string_view populationtype2metadatastring(PopulationType in) {
  switch (in) {
    case PopulationType::LTE:
      return "The lines are considered as in pure LTE.\n";
    case PopulationType::ByMakarovFullRelmat:
      return "The lines requires relaxation matrix calculations in LTE - Makarov et al 2020 full method.\n";
    case PopulationType::ByRovibLinearDipoleLineMixing:
      return "The lines requires relaxation matrix calculations in LTE - Hartmann, Boulet, Robert, 2008, 1st edition method.\n";
    case PopulationType::ByHITRANFullRelmat:
      return "The lines requires relaxation matrix calculations in LTE - HITRAN full method.\n";
    case PopulationType::ByHITRANRosenkranzRelmat:
      return "The lines requires Relaxation matrix calculations in LTE - HITRAN Rosenkranz method.\n";
    case PopulationType::VibTemps:
      return "The lines are considered as in NLTE by vibrational temperatures.\n";
    case PopulationType::NLTE:
      return "The lines are considered as in pure NLTE.\n";
    case PopulationType::FINAL: return "There's an error";
  }
}
#pragma GCC diagnostic pop
 
constexpr bool relaxationtype_relmat(PopulationType in) noexcept {
  return in == PopulationType::ByHITRANFullRelmat or
         in == PopulationType::ByMakarovFullRelmat or
         in == PopulationType::ByHITRANRosenkranzRelmat or
         in == PopulationType::ByRovibLinearDipoleLineMixing;
}
 
ENUMCLASS(CutoffType, char,
  None,                             // No cutoff frequency at all
  ByLine                            // The cutoff frequency is at SingleLine::F0 plus the cutoff frequency plus the speed independent pressure shift
)  // CutoffType
 
String cutofftype2metadatastring(CutoffType in, Numeric cutoff);
 
class SingleLine {
private:
  Numeric mF0{};
  
  Numeric mI0{};
  
  Numeric mE0{};
  
  Numeric mglow{};
  
  Numeric mgupp{};
  
  Numeric mA{};
  
  Zeeman::Model mzeeman{};
  
  LineShape::Model mlineshape{};
  
  std::vector<Rational> mlowerquanta{};
  
  std::vector<Rational> mupperquanta{};
 
public:
  SingleLine(Numeric F0=0,
             Numeric I0=0,
             Numeric E0=0,
             Numeric glow=0,
             Numeric gupp=0,
             Numeric A=0,
             Zeeman::Model zeeman=Zeeman::Model(),
             LineShape::Model lineshape=LineShape::Model(),
             std::vector<Rational> lowerquanta={},
             std::vector<Rational> upperquanta={}) :
             mF0(F0),
             mI0(I0),
             mE0(E0),
             mglow(glow),
             mgupp(gupp),
             mA(A),
             mzeeman(zeeman),
             mlineshape(std::move(lineshape)),
             mlowerquanta(std::move(lowerquanta)),
             mupperquanta(std::move(upperquanta)) {}
  
  SingleLine(size_t nbroadeners, size_t nquanta, LineShape::Model metamodel) :
  mlineshape(std::move(metamodel)), mlowerquanta(nquanta), mupperquanta(nquanta) {
    ARTS_USER_ERROR_IF(Index(nbroadeners) not_eq mlineshape.nelem(),
                       "Mismatch between broadeners and model");
  }
  
  
  [[nodiscard]] Index LineShapeElems() const noexcept {return mlineshape.nelem();}
  
  [[nodiscard]] Index LowerQuantumElems() const noexcept {return mlowerquanta.size();}
  
  [[nodiscard]] Index UpperQuantumElems() const noexcept {return mupperquanta.size();}
  
  
  [[nodiscard]] Numeric F0() const noexcept {return mF0;}
  
  [[nodiscard]] Numeric E0() const noexcept {return mE0;}
  
  [[nodiscard]] Numeric I0() const noexcept {return mI0;}
  
  [[nodiscard]] Numeric A() const noexcept {return mA;}
  
  [[nodiscard]] Numeric g_low() const noexcept {return mglow;}
  
  [[nodiscard]] Numeric g_upp() const noexcept {return mgupp;}
  
  [[nodiscard]] Zeeman::Model Zeeman() const noexcept {return mzeeman;}
  
  [[nodiscard]] const LineShape::Model& LineShape() const noexcept {return mlineshape;}
  
  [[nodiscard]] const std::vector<Rational>& LowerQuantumNumbers() const noexcept {return mlowerquanta;}
  
  [[nodiscard]] const std::vector<Rational>& UpperQuantumNumbers() const noexcept {return mupperquanta;}
  
  
  Numeric& F0() noexcept {return mF0;}
  
  Numeric& E0() noexcept {return mE0;}
  
  Numeric& I0() noexcept {return mI0;}
  
  Numeric& A() noexcept {return mA;}
  
  Numeric& g_low() noexcept {return mglow;}
  
  Numeric& g_upp() noexcept {return mgupp;}
  
  Zeeman::Model& Zeeman() noexcept {return mzeeman;}
  
  LineShape::Model& LineShape() noexcept {return mlineshape;}
  
  std::vector<Rational>& LowerQuantumNumbers() noexcept {return mlowerquanta;}
  
  std::vector<Rational>& UpperQuantumNumbers() noexcept {return mupperquanta;}
  
  
  void F0(Numeric x) noexcept {mF0 = x;}
  
  void E0(Numeric x) noexcept {mE0 = x;}
  
  void I0(Numeric x) noexcept {mI0 = x;}
  
  void A(Numeric x) noexcept {mA = x;}
  
  void g_low(Numeric x) noexcept {mglow = x;}
  
  void g_upp(Numeric x) noexcept {mgupp = x;}
  
  
  [[nodiscard]] Rational LowerQuantumNumber(size_t i) const noexcept {return mlowerquanta[i];}
  
  [[nodiscard]] Rational UpperQuantumNumber(size_t i) const noexcept {return mupperquanta[i];}
  
  Rational& LowerQuantumNumber(size_t i) noexcept {return mlowerquanta[i];}
  
  Rational& UpperQuantumNumber(size_t i) noexcept {return mupperquanta[i];}
  
  [[nodiscard]] bool SameQuantumNumbers(const SingleLine& sl) const noexcept;
  
  
  void SetAutomaticZeeman(QuantumIdentifier qid, const std::vector<QuantumNumberType>& keys);
  
  void SetLineMixing2SecondOrderData(const Vector& d);
  
  void SetLineMixing2AER(const Vector& d);
  
  bifstream& read(bifstream& bif);
  
  bofstream& write(bofstream& bof) const;
};  // SingleLine
 
std::ostream& operator<<(std::ostream&, const SingleLine&);
 
std::istream& operator>>(std::istream&, SingleLine&);
 
struct SingleLineExternal {
  bool bad=true;
  bool selfbroadening=false;
  bool bathbroadening=false;
  CutoffType cutoff=CutoffType::None;
  MirroringType mirroring=MirroringType::None;
  PopulationType population=PopulationType::LTE;
  NormalizationType normalization=NormalizationType::None;
  LineShape::Type lineshapetype=LineShape::Type::DP;
  Numeric T0=0;
  Numeric cutofffreq=0;
  Numeric linemixinglimit=-1;
  QuantumIdentifier quantumidentity;
  ArrayOfSpecies species;
  SingleLine line;
};
 
class Lines {
public:
  static constexpr Index version = 1;
private:
  bool mselfbroadening;
  
  bool mbathbroadening;
  
  CutoffType mcutoff;
  
  MirroringType mmirroring;
  
  PopulationType mpopulation;
  
  NormalizationType mnormalization;
 
  LineShape::Type mlineshapetype;
  
  Numeric mT0;
  
  Numeric mcutofffreq;
  
  Numeric mlinemixinglimit;
  
  QuantumIdentifier mquantumidentity;
  
  std::vector<QuantumNumberType> mlocalquanta;
  
  ArrayOfSpecies mbroadeningspecies;
  
  std::vector<SingleLine> mlines;
  
public:
  Lines(bool selfbroadening=false,
        bool bathbroadening=false,
        CutoffType cutoff=CutoffType::None,
        MirroringType mirroring=MirroringType::None,
        PopulationType population=PopulationType::LTE,
        NormalizationType normalization=NormalizationType::None,
        LineShape::Type lineshapetype=LineShape::Type::DP,
        Numeric T0=296,
        Numeric cutofffreq=-1,
        Numeric linemixinglimit=-1,
        const QuantumIdentifier& quantumidentity=QuantumIdentifier(),
        std::vector<QuantumNumberType> localquanta={},
        ArrayOfSpecies broadeningspecies={},
        std::vector<SingleLine> lines={}) :
        mselfbroadening(selfbroadening),
        mbathbroadening(bathbroadening),
        mcutoff(cutoff),
        mmirroring(mirroring),
        mpopulation(population),
        mnormalization(normalization),
        mlineshapetype(lineshapetype),
        mT0(T0),
        mcutofffreq(cutofffreq),
        mlinemixinglimit(linemixinglimit),
        mquantumidentity(quantumidentity),
        mlocalquanta(std::move(localquanta)),
        mbroadeningspecies(std::move(broadeningspecies)),
        mlines(std::move(lines)) {
    if (selfbroadening) mbroadeningspecies.front() = quantumidentity.Species();
    if (bathbroadening) mbroadeningspecies.back() = Species::Species::Bath;
  }
  
  Lines(bool selfbroadening,
        bool bathbroadening,
        size_t nlines,
        CutoffType cutoff,
        MirroringType mirroring,
        PopulationType population,
        NormalizationType normalization,
        LineShape::Type lineshapetype,
        Numeric T0,
        Numeric cutofffreq,
        Numeric linemixinglimit,
        const QuantumIdentifier& quantumidentity,
        const std::vector<QuantumNumberType>& localquanta,
        const ArrayOfSpecies& broadeningspecies,
        const LineShape::Model& metamodel) :
        mselfbroadening(selfbroadening),
        mbathbroadening(bathbroadening),
        mcutoff(cutoff),
        mmirroring(mirroring),
        mpopulation(population),
        mnormalization(normalization),
        mlineshapetype(lineshapetype),
        mT0(T0),
        mcutofffreq(cutofffreq),
        mlinemixinglimit(linemixinglimit),
        mquantumidentity(quantumidentity),
        mlocalquanta(localquanta),
        mbroadeningspecies(broadeningspecies),
        mlines(nlines,
               SingleLine(broadeningspecies.size(),
               localquanta.size(), metamodel)) {
    if (selfbroadening) mbroadeningspecies.front() = quantumidentity.Species();
    if (bathbroadening) mbroadeningspecies.back() = Species::Species::Bath;
  }
  
  void AppendSingleLine(SingleLine&& sl);
  
  void AppendSingleLine(const SingleLine& sl);
  
  [[nodiscard]] bool MatchWithExternal(const SingleLineExternal& sle, const QuantumIdentifier& quantumidentity) const ARTS_NOEXCEPT;
  
  [[nodiscard]] bool Match(const Lines& l) const noexcept;
  
  void sort_by_frequency();
  
  void sort_by_einstein();
  
  void truncate_global_quantum_numbers();
  
  void truncate_local_quantum_numbers();
  
  [[nodiscard]] String SpeciesName() const noexcept;
  
  [[nodiscard]] String UpperQuantumNumbers() const noexcept;
  
  [[nodiscard]] String LowerQuantumNumbers() const noexcept;
  
  [[nodiscard]] String LineShapeMetaData() const noexcept;
  
  [[nodiscard]] Species::Species Species() const noexcept {return mquantumidentity.Species();}
  
  [[nodiscard]] const Species::IsotopeRecord& Isotopologue() const noexcept {return mquantumidentity.Isotopologue();}
  
  [[nodiscard]] Index NumLines() const noexcept {return Index(mlines.size());}
  
  [[nodiscard]] const std::vector<SingleLine>& AllLines() const noexcept {return mlines;}
  
  std::vector<SingleLine>& AllLines() noexcept {return mlines;}
  
  [[nodiscard]] Index NumBroadeners() const noexcept {return Index(mbroadeningspecies.nelem());}
  
  [[nodiscard]] Index NumLocalQuanta() const noexcept {return Index(mlocalquanta.size());}
  
  void RemoveUnusedLocalQuantums();
  
  void RemoveLocalQuantum(size_t);
  
  [[nodiscard]] Rational LowerQuantumNumber(size_t k, QuantumNumberType qnt) const noexcept;
  
  [[nodiscard]] Rational UpperQuantumNumber(size_t k, QuantumNumberType qnt) const noexcept;
  
  Rational& LowerQuantumNumber(size_t k, QuantumNumberType qnt) noexcept;
  
  Rational& UpperQuantumNumber(size_t k, QuantumNumberType qnt) noexcept;
  
  [[nodiscard]] Index ZeemanCount(size_t k, Zeeman::Polarization type) const noexcept;
  
  [[nodiscard]] Numeric ZeemanStrength(size_t k, Zeeman::Polarization type, Index i) const noexcept;
  
  [[nodiscard]] Numeric ZeemanSplitting(size_t k, Zeeman::Polarization type, Index i) const noexcept;
  
  void SetAutomaticZeeman() noexcept;
  
  [[nodiscard]] Numeric F0(size_t k) const noexcept {return mlines[k].F0();}
  
  Numeric& F0(size_t k) noexcept {return mlines[k].F0();}
  
  [[nodiscard]] Numeric F_mean(Numeric T=0) const noexcept;
  
  [[nodiscard]] Numeric F_mean(const ConstVectorView& wgts) const noexcept;
  
  [[nodiscard]] Numeric E0(size_t k) const noexcept {return mlines[k].E0();}
  
  Numeric& E0(size_t k) noexcept {return mlines[k].E0();}
  
  [[nodiscard]] Numeric I0(size_t k) const noexcept {return mlines[k].I0();}
  
  Numeric& I0(size_t k) noexcept {return mlines[k].I0();}
  
  [[nodiscard]] Numeric A(size_t k) const noexcept {return mlines[k].A();}
  
  Numeric& A(size_t k) noexcept {return mlines[k].A();}
  
  [[nodiscard]] Numeric g_low(size_t k) const noexcept {return mlines[k].g_low();}
  
  Numeric& g_low(size_t k) noexcept {return mlines[k].g_low();}
  
  [[nodiscard]] Numeric g_upp(size_t k) const noexcept {return mlines[k].g_upp();}
  
  Numeric& g_upp(size_t k) noexcept {return mlines[k].g_upp();}
  
  [[nodiscard]] MirroringType Mirroring() const noexcept {return mmirroring;}
  
  MirroringType& Mirroring() noexcept {return mmirroring;}
  
  void Mirroring(MirroringType x) noexcept {mmirroring = x;}
  
  static bool validIndexForMirroring(Index x) noexcept {
    return good_enum(MirroringType(x));
  }
  
  static MirroringType string2Mirroring(const String& in) noexcept {
    return toMirroringType(in);
  }
  
  [[nodiscard]] NormalizationType Normalization() const noexcept {return mnormalization;}
  
  NormalizationType& Normalization() noexcept {return mnormalization;}
  
  void Normalization(NormalizationType x) noexcept {mnormalization = x;}
  
  static bool validIndexForNormalization(Index x) noexcept {
    return good_enum(NormalizationType(x));
  }
  
  static NormalizationType string2Normalization(const String& in) noexcept {
    return toNormalizationType(in);
  }
  
  [[nodiscard]] CutoffType Cutoff() const noexcept {return mcutoff;}
  
  CutoffType& Cutoff() noexcept {return mcutoff;}
  
  void Cutoff(CutoffType x) noexcept {mcutoff = x;}
  
  static bool validIndexForCutoff(Index x) noexcept {
    return good_enum(CutoffType(x));
  }
  
  static CutoffType string2Cutoff(const String& in) noexcept {
    return toCutoffType(in);
  }
  
  [[nodiscard]] PopulationType Population() const noexcept {return mpopulation;}
  
  [[nodiscard]] bool OnTheFlyLineMixing() const noexcept {
    return mpopulation == PopulationType::ByMakarovFullRelmat or
           mpopulation == PopulationType::ByRovibLinearDipoleLineMixing;
  }
  
  PopulationType& Population() noexcept {return mpopulation;}
  
  void Population(PopulationType x) noexcept {mpopulation = x;}
  
  static bool validIndexForPopulation(Index x) noexcept {
    return good_enum(PopulationType(x));
  }
  
  static PopulationType string2Population(const String& in) noexcept {
    return toPopulationType(in);
  }
  
  [[nodiscard]] LineShape::Type LineShapeType() const noexcept {return mlineshapetype;}
  
  LineShape::Type& LineShapeType() noexcept {return mlineshapetype;}
  
  void LineShapeType(LineShape::Type x) noexcept {mlineshapetype = x;}
  
  static bool validIndexForLineShapeType(Index x) noexcept {
    return good_enum(LineShape::Type(x));
  }
  
  static LineShape::Type string2LineShapeType(const String& type) noexcept {
    return LineShape::toType(type);
  }
  
  [[nodiscard]] bool DoLineMixing(Numeric P) const noexcept {
    return mlinemixinglimit < 0 ? true : mlinemixinglimit > P;
  }
  
  [[nodiscard]] LineShape::Output ShapeParameters(size_t k, Numeric T, Numeric P, const Vector& vmrs) const noexcept;
  
  [[nodiscard]] LineShape::Output ShapeParameters(size_t k, Numeric T, Numeric P, size_t m) const noexcept;
  
  [[nodiscard]] LineShape::Output ShapeParameters_dT(size_t k, Numeric T, Numeric P, const Vector& vmrs) const noexcept;
  
  [[nodiscard]] Index LineShapePos(const Species::Species spec) const noexcept;
  
  [[nodiscard]] Index LineShapePos(const QuantumIdentifier& qid) const noexcept {
    return LineShapePos(qid.Species());
  }
  
  [[nodiscard]] LineShape::Output ShapeParameters_dVMR(size_t k, Numeric T, Numeric P,
                                         const QuantumIdentifier& vmr_qid) const noexcept;
  
  [[nodiscard]] Numeric ShapeParameter_dInternal(size_t k, Numeric T, Numeric P,
                                   const Vector& vmrs,
                                   const RetrievalQuantity& derivative) const noexcept;
  
  [[nodiscard]] Numeric CutoffFreq(size_t k, Numeric shift=0) const noexcept;
  
  [[nodiscard]] Numeric CutoffFreqMinus(size_t k, Numeric shift=0) const noexcept;
  
  [[nodiscard]] Numeric T0() const noexcept {
    return mT0;
  }
  
  void T0(Numeric x) noexcept {
    mT0 = x;
  }
  
  [[nodiscard]] Numeric CutoffFreqValue() const noexcept {
    return mcutofffreq;
  }
  
  void CutoffFreqValue(Numeric x) noexcept {
    mcutofffreq = x;
  }
  
  [[nodiscard]] Numeric LinemixingLimit() const noexcept {
    return mlinemixinglimit;
  }
  
  void LinemixingLimit(Numeric x) noexcept {
    mlinemixinglimit = x;
  }
  
  [[nodiscard]] const std::vector<QuantumNumberType>& LocalQuanta() const noexcept {
    return mlocalquanta;
  }
  
  std::vector<QuantumNumberType>& LocalQuanta() noexcept {
    return mlocalquanta;
  }
  
  [[nodiscard]] const ArrayOfSpecies& BroadeningSpecies() const noexcept {
    return mbroadeningspecies;
  }
  
  ArrayOfSpecies& BroadeningSpecies() noexcept {
    return mbroadeningspecies;
  }
  
  [[nodiscard]] Index BroadeningSpeciesPosition(Species::Species spec) const noexcept {
    if (auto ptr = std::find(mbroadeningspecies.cbegin(),
      mbroadeningspecies.cend(), spec); ptr not_eq mbroadeningspecies.cend())
      return std::distance(mbroadeningspecies.cbegin(), ptr);
    return -1;
  }
  
  [[nodiscard]] bool Self() const noexcept {
    return mselfbroadening;
  }
  
  void Self(bool x) noexcept {
    mselfbroadening = x;
  }
  
  [[nodiscard]] bool Bath() const noexcept {
    return mbathbroadening;
  }
  
  void Bath(bool x) noexcept {
    mbathbroadening = x;
  }
  
  [[nodiscard]] const QuantumIdentifier& QuantumIdentity() const noexcept {
    return mquantumidentity;
  }
  
  QuantumIdentifier& QuantumIdentity() noexcept {
    return mquantumidentity;
  }
  
  [[nodiscard]] QuantumIdentifier QuantumIdentityOfLine(Index k) const noexcept;
  
  [[nodiscard]] String MetaData() const;
  
  void RemoveLine(Index) noexcept;
  
  SingleLine PopLine(Index) noexcept;
  
  SingleLine& Line(Index) noexcept;
  
  [[nodiscard]] const SingleLine& Line(Index) const noexcept;
  
  void ReverseLines() noexcept;
  
  [[nodiscard]] Numeric SpeciesMass() const noexcept;
  
  [[nodiscard]] Vector BroadeningSpeciesVMR(const ConstVectorView&, const ArrayOfArrayOfSpeciesTag&) const;
  
  [[nodiscard]] Vector BroadeningSpeciesMass(const ConstVectorView&, const ArrayOfArrayOfSpeciesTag&, const SpeciesIsotopologueRatios&, const Numeric& bath_mass=0) const;
  
  [[nodiscard]] Numeric SelfVMR(const ConstVectorView&, const ArrayOfArrayOfSpeciesTag&) const;
  
  bifstream& read(bifstream& is);
  
  bofstream& write(bofstream& os) const;
  
  [[nodiscard]] bool OK() const noexcept;
  
  [[nodiscard]] Numeric DopplerConstant(Numeric T) const noexcept;
};  // Lines
 
std::ostream& operator<<(std::ostream&, const Lines&);
std::istream& operator>>(std::istream&, Lines&);
 
SingleLineExternal ReadFromArtscat3Stream(istream& is);
 
SingleLineExternal ReadFromArtscat4Stream(istream& is);
 
SingleLineExternal ReadFromArtscat5Stream(istream& is);
 
SingleLineExternal ReadFromLBLRTMStream(istream& is);
 
SingleLineExternal ReadFromHitran2012Stream(istream& is);
 
SingleLineExternal ReadFromHitran2004Stream(istream& is);
 
SingleLineExternal ReadFromHitranOnlineStream(istream& is);
 
SingleLineExternal ReadFromHitran2001Stream(istream& is);
 
SingleLineExternal ReadFromJplStream(istream& is);
 
std::vector<Lines> split_list_of_external_lines(std::vector<SingleLineExternal>& external_lines,
                                                const std::vector<QuantumNumberType>& localquantas={},
                                                const std::vector<QuantumNumberType>& globalquantas={});
 
Lines createEmptyCopy(const Lines& al) noexcept;
 
inline Index nelem(const Lines& l) {return l.NumLines();}
 
inline Index nelem(const Array<Lines>& l) {Index n=0; for (auto& x:l) n+=nelem(x); return n;}
 
inline Index nelem(const Array<Array<Lines>>& l) {Index n=0; for (auto& x:l) n+=nelem(x); return n;}
 
Numeric reduced_rovibrational_dipole(Rational Jf, Rational Ji, Rational lf, Rational li, Rational k = Rational(1));
 
Numeric reduced_magnetic_quadrapole(Rational Jf, Rational Ji, Rational N);
 
ENUMCLASS(QuantumIdentifierLineTargetType, char,
          None,
          Species,
          Isotopologue,
          Band,
          Line,
          Level
)
          
struct QuantumIdentifierLineTarget {
  QuantumIdentifierLineTargetType found{QuantumIdentifierLineTargetType::None};
  bool lower{false};
  bool upper{false};
  
  constexpr QuantumIdentifierLineTarget() noexcept = default;
  
  constexpr QuantumIdentifierLineTarget(const QuantumIdentifier& qt, const QuantumIdentifier& qid) ARTS_NOEXCEPT : QuantumIdentifierLineTarget()
  {
    ARTS_ASSERT(qid.type == Quantum::IdentifierType::Transition);
    
    // We have no match if we do not match the species
    if (qt.Species() == qid.Species()) found = QuantumIdentifierLineTargetType::Species;
    
    // We can only match the isotopologue if we match the species
    if (found == QuantumIdentifierLineTargetType::Species and qt.Isotopologue() == qid.Isotopologue()) found = QuantumIdentifierLineTargetType::Isotopologue;
    
    // We do cannot match the band if we do not match the isotopologue
    if (found == QuantumIdentifierLineTargetType::Isotopologue) {
      if (qt.type == Quantum::IdentifierType::All) {
        
        // Nothing to do here
        
      } else if (qt.type == Quantum::IdentifierType::None) {
        
        found = QuantumIdentifierLineTargetType::None;  // We turned this off!
        
      } else if (qt.type == Quantum::IdentifierType::Transition) {
        
        // We are band specific values
        bool all_good = true;
        for (auto qn: ::enumtyps::QuantumNumberTypeTypes) {
          if (qn not_eq QuantumNumberType::FINAL) {
            const Rational& low_band = qid.Lower()[qn];
            const Rational& low_targ = qt.Lower()[qn];
            const Rational& upp_band = qid.Upper()[qn];
            const Rational& upp_targ = qt.Upper()[qn];
            all_good = all_good
            and (low_band.isUndefined() or low_band == low_targ)
            and (upp_band.isUndefined() or upp_band == upp_targ);
          }
        }
        
        // We are a band?
        if (all_good) found = QuantumIdentifierLineTargetType::Band;
        
      } else if (qt.type == Quantum::IdentifierType::EnergyLevel) {
        
        // We are the right species, are we a level?
        bool low_lvl = true;
        bool upp_lvl = true;
        for (auto qn: ::enumtyps::QuantumNumberTypeTypes) {
          if (qn not_eq QuantumNumberType::FINAL) {
            // Check only numbers in the energy levels
            const Rational& low_band = qid.Lower()[qn];
            const Rational& upp_band = qid.Upper()[qn];
            const Rational& lvl_targ = qt.Level()[qn];
            low_lvl = low_lvl and (low_band.isUndefined() or low_band == lvl_targ);
            upp_lvl = upp_lvl and (upp_band.isUndefined() or upp_band == lvl_targ);
          }
        }
        
        // We are a level?
        if (low_lvl or upp_lvl) found = QuantumIdentifierLineTargetType::Level;
        lower = low_lvl;
        upper = upp_lvl;
        
      }
    }
  }
  
  QuantumIdentifierLineTarget(const QuantumIdentifier& qt, const Lines& lines) ARTS_NOEXCEPT :
    QuantumIdentifierLineTarget(qt, lines.QuantumIdentity()) {}
  
  QuantumIdentifierLineTarget(const QuantumIdentifier&, const Lines&, const Index) ARTS_NOEXCEPT;
  
  constexpr bool operator==(QuantumIdentifierLineTargetType x) const noexcept {return x == found;}
  
  constexpr bool operator!=(QuantumIdentifierLineTargetType x) const noexcept {return x != found;}
  
  friend std::ostream& operator<<(std::ostream& os, QuantumIdentifierLineTarget qlt) {
    return os << qlt.found << ' ' << qlt.lower << ' ' << qlt.upper;
  }
};
} // namespace Absorption
 
using AbsorptionSingleLine = Absorption::SingleLine;
using AbsorptionLines = Absorption::Lines;
using ArrayOfAbsorptionLines = Array<AbsorptionLines>;
using ArrayOfArrayOfAbsorptionLines = Array<ArrayOfAbsorptionLines>;
 
std::ostream& operator<<(std::ostream&, const ArrayOfAbsorptionLines&);
 
std::ostream& operator<<(std::ostream&, const ArrayOfArrayOfAbsorptionLines&);
 
using AbsorptionNormalizationType = Absorption::NormalizationType;
using AbsorptionPopulationType = Absorption::PopulationType;
using AbsorptionMirroringType = Absorption::MirroringType;
using AbsorptionCutoffType = Absorption::CutoffType;
 
#endif  // absorptionlines_h