linemixing.h

Go to the documentation of this file.

#ifndef linemixing_h
#define linemixing_h
 
#include <functional>
#include <utility>
 
#include "absorption.h"
#include "arts_conversions.h"
#include "gridded_fields.h"
#include "linescaling.h"
#include "matpack_complex.h"
#include "species.h"
#include "zeemandata.h"
 
namespace Absorption::LineMixing {
 
struct EquivalentLines {
  ComplexVector val;
  ComplexVector str;
  
  explicit EquivalentLines(Index n=0) noexcept : val(n, 0), str(n, 0) {}
  
  EquivalentLines(const ComplexMatrix& W, const Vector& pop, const Vector& dip) noexcept;
  
  void sort_by_frequency(Vector& f, const ArrayOfIndex& sorting);
  
  friend std::ostream& operator<<(std::ostream& os, const EquivalentLines& eqv);
};  // EquivalentLines
 
struct PopulationAndDipole {
  Vector pop;
  Vector dip;
  
  PopulationAndDipole(const Numeric T,
                      const AbsorptionLines& band);
  
  ArrayOfIndex sort(const AbsorptionLines& band) noexcept;
  
  void sort(const ArrayOfIndex& presorting) noexcept;
};  // PopulationAndDipole
 
using EnergyFunction = std::function<Numeric (const Rational)>;
 
struct SpeciesErrorCorrectedSuddenData {
  Species::Species spec{Species::Species::Bath};
  LineShapeModelParameters scaling;
  LineShapeModelParameters beta;
  LineShapeModelParameters lambda;
  LineShapeModelParameters collisional_distance;
  Numeric mass{1};
  
  constexpr SpeciesErrorCorrectedSuddenData(Species::Species inspec=Species::Species::Bath) noexcept :
    spec(inspec), scaling(LineShapeTemperatureModel::T0, 0, 0, 0, 0),
    beta(LineShapeTemperatureModel::T0, 0, 0, 0, 0),
    lambda(LineShapeTemperatureModel::T0, 0, 0, 0, 0),
    collisional_distance(LineShapeTemperatureModel::T0, 0, 0, 0, 0) {}
  
  [[nodiscard]] Numeric Q(const Rational J,
            const Numeric T,
            const Numeric T0,
            const Numeric energy) const;
  
  [[nodiscard]] Numeric Omega(const Numeric T,
                const Numeric T0,
                const Numeric other_mass,
                const Numeric energy_x,
                const Numeric energy_xm2) const;
  
  friend std::ostream& operator<<(std::ostream& os, const SpeciesErrorCorrectedSuddenData& srbd);
  
  friend std::istream& operator>>(std::istream& is, SpeciesErrorCorrectedSuddenData& srbd);
  
  constexpr bool operator==(Species::Species species) const noexcept {
    return species == spec;
  }
};  // SpeciesErrorCorrectedSuddenData
 
using ArrayOfSpeciesErrorCorrectedSuddenData = Array<SpeciesErrorCorrectedSuddenData>;
 
struct ErrorCorrectedSuddenData {
  QuantumIdentifier id;
  
  ArrayOfSpeciesErrorCorrectedSuddenData data;
  
  explicit ErrorCorrectedSuddenData(QuantumIdentifier qid={}) noexcept :
  id(std::move(qid)), data({SpeciesErrorCorrectedSuddenData()}) {}
  
  friend std::ostream& operator<<(std::ostream& os, const ErrorCorrectedSuddenData& rbd);
  
  friend std::istream& operator>>(std::istream& is, ErrorCorrectedSuddenData& rbd);
  
  bool operator==(const QuantumIdentifier& band_id) const noexcept {
    return band_id.part_of(id);
  }
 
  [[nodiscard]] Index pos(Species::Species spec) const;
 
  [[nodiscard]] Index size() const noexcept { return data.size(); }
 
  const SpeciesErrorCorrectedSuddenData& operator[](Species::Species spec) const;
  
  SpeciesErrorCorrectedSuddenData& operator[](Species::Species spec);
};  // ErrorCorrectedSuddenData
 
struct MapOfErrorCorrectedSuddenData : public Array<ErrorCorrectedSuddenData> {
  ErrorCorrectedSuddenData& operator[](const QuantumIdentifier& id);
  
  const ErrorCorrectedSuddenData& operator[](const QuantumIdentifier& id) const;
  
  const ErrorCorrectedSuddenData& operator[](Index i) const ARTS_NOEXCEPT {
    ARTS_ASSERT(i >= 0 and i < nelem())
    return * (begin() + i);
  }
  
  ErrorCorrectedSuddenData& operator[](Index i) ARTS_NOEXCEPT {
    ARTS_ASSERT(i >= 0 and i < nelem())
    return * (begin() + i);
  }
  
  friend std::ostream& operator<<(std::ostream& os, const MapOfErrorCorrectedSuddenData& m);
};  // MapOfErrorCorrectedSuddenData
 
// Return struct from calculations
struct EcsReturn {
  ComplexVector abs;
  ArrayOfComplexVector dabs;
  bool error;
  EcsReturn(EcsReturn&&) noexcept = default;
  EcsReturn(ComplexVector&& abs_, ArrayOfComplexVector&& dabs_, bool error_) noexcept :
  abs(std::move(abs_)), dabs(std::move(dabs_)), error(error_) {}
};
 
 
EcsReturn ecs_absorption(const Numeric T,
                         const Numeric H,
                         const Numeric P,
                         const Numeric this_vmr,
                          const Vector& vmrs,
                          const ErrorCorrectedSuddenData& ecs_data,
                          const Vector& f_grid,
                          const Zeeman::Polarization zeeman_polarization,
                          const AbsorptionLines& band,
                          const ArrayOfRetrievalQuantity& jacobian_quantities={});
 
Index band_eigenvalue_adaptation(AbsorptionLines& band,
                                 const Tensor4& tempdata,
                                 const Vector& temperatures,
                                 const Numeric P0,
                                 const Index ord);
 
 
EquivalentLines eigenvalue_adaptation_of_relmat(const ComplexMatrix& W,
                                                const Vector& pop,
                                                const Vector& dip,
                                                const AbsorptionLines& band,
                                                const Numeric frenorm,
                                                const Numeric T,
                                                const Numeric P,
                                                const Numeric QT,
                                                const Numeric QT0,
                                                const Index broadener);
 
 
void ecs_eigenvalue_adaptation(AbsorptionLines& band,
                               const Vector& temperatures,
                               const ErrorCorrectedSuddenData& ecs_data,
                               const Numeric P0,
                               const Index ord,
                               const bool robust,
                               const bool rosenkranz_adaptation,
                               const Verbosity& verbosity);
 
Tensor5 ecs_eigenvalue_adaptation_test(const AbsorptionLines& band,
                                       const Vector& temperatures,
                                       const ErrorCorrectedSuddenData& ecs_data,
                                       const Vector& pressures);
} // namespace Absorption::LineMixing
 
using ErrorCorrectedSuddenData = Absorption::LineMixing::ErrorCorrectedSuddenData;
using MapOfErrorCorrectedSuddenData = Absorption::LineMixing::MapOfErrorCorrectedSuddenData;
using SpeciesErrorCorrectedSuddenData = Absorption::LineMixing::SpeciesErrorCorrectedSuddenData;
using Absorption::LineMixing::ArrayOfSpeciesErrorCorrectedSuddenData;
 
#endif  // linemixing_h