energylevelmap.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 energylevelmap_h
#define energylevelmap_h
 
#include "absorptionlines.h"
#include "matpackIV.h"
#include "mystring.h"
#include "quantum.h"
 
// Output from EnergyLevelMap
struct Output2{
  Numeric r_low;
  Numeric r_upp;
};
 
// Output from EnergyLevelMap
struct Output4{
  Numeric E_low;
  Numeric E_upp;
  Numeric T_low;
  Numeric T_upp;
};
 
enum class EnergyLevelMapType {
  Tensor3_t,
  Vector_t,
  Numeric_t,
  None_t,
};
 
EnergyLevelMapType string2energylevelmaptype(const String& s);
 
String energylevelmaptype2string(EnergyLevelMapType type);
 
class EnergyLevelMap {
private:
  EnergyLevelMapType mtype{EnergyLevelMapType::None_t};
  ArrayOfQuantumIdentifier mlevels;
  Vector mvib_energy;
  Tensor4 mvalue;
  
public:
  [[nodiscard]] bool OK() const noexcept;
  
  void ThrowIfNotOK() const ARTS_NOEXCEPT {ARTS_ASSERT (OK(), "Class in bad state");}
  
  EnergyLevelMap() : mlevels(0),
  mvib_energy(0), mvalue(0, 0, 0, 0) {}
  
  EnergyLevelMap(EnergyLevelMapType new_type, Index pages, Index rows,
                 Index cols, const EnergyLevelMap& old) : 
  mtype(new_type), mlevels(old.mlevels), mvib_energy(old.mvib_energy),
  mvalue(old.mlevels.nelem(), pages, rows, cols) {ThrowIfNotOK();};
  
  // Create Tensor3_t from the raw inputs
  EnergyLevelMap(Tensor4 data, ArrayOfQuantumIdentifier levels, Vector energies=Vector(0));
  
  // Create Vector_t from the raw inputs
  EnergyLevelMap(const Matrix& data, ArrayOfQuantumIdentifier levels, Vector energies=Vector(0));
  
  // Create Numeric_t from the raw inputs
  EnergyLevelMap(const Vector& data, ArrayOfQuantumIdentifier levels, Vector energies=Vector(0));
  
  // Create Vector_t from Tensor3_t
  [[nodiscard]] EnergyLevelMap InterpToGridPos(Index atmosphere_dim, const ArrayOfGridPos& p, const ArrayOfGridPos& lat, const ArrayOfGridPos& lon) const;
  
  // Create Numeric_t from Vector_t
  [[nodiscard]] EnergyLevelMap operator[](Index ip) const;
  
  // Create Numeric_t from Tensor3_t
  [[nodiscard]] EnergyLevelMap operator()(Index ip, Index ilat, Index ilon) const;
  
  [[nodiscard]] EnergyLevelMapType Type() const noexcept {return mtype;}
  
  [[nodiscard]] const ArrayOfQuantumIdentifier& Levels() const noexcept {return mlevels;}
  
  [[nodiscard]] const Vector& Energies() const noexcept {return mvib_energy;}
  
  [[nodiscard]] const Tensor4& Data() const noexcept {return mvalue;}
  
  EnergyLevelMapType& Type() noexcept {return mtype;}
  
  ArrayOfQuantumIdentifier& Levels() noexcept {return mlevels;}
  
  Vector& Energies() noexcept {return mvib_energy;}
  
  Tensor4& Data() noexcept {return mvalue;}
  
  // C API interface access //
  
  static bool validIndexForType(Index x) noexcept
  {
    constexpr auto keys = stdarrayify(Index(EnergyLevelMapType::Tensor3_t), EnergyLevelMapType::Vector_t, EnergyLevelMapType::Numeric_t, EnergyLevelMapType::None_t);
    return std::any_of(keys.cbegin(), keys.cend(), [x](auto y){return x == y;});
  }
  
  void Type(EnergyLevelMapType x) noexcept {mtype = x;}
  
  static EnergyLevelMapType string2Type(const String& s) noexcept
  {
    if (s == "Tensor3")
      return EnergyLevelMapType::Tensor3_t;
    if (s == "Vector")
      return EnergyLevelMapType::Vector_t;
    if (s == "Numeric")
      return EnergyLevelMapType::Numeric_t;
    if (s == "None")
      return EnergyLevelMapType::None_t;
    return EnergyLevelMapType(-1);
  }
  
  // Numeric_t access //
  
  [[nodiscard]] Output2 get_ratio_params(const AbsorptionLines& band, const Index& line_index) const;
  
  [[nodiscard]] Output4 get_vibtemp_params(const AbsorptionLines& band, const Index& line_index, const Numeric T) const;
};
 
std::ostream& operator<<(std::ostream& os, const EnergyLevelMap& elm);
 
#endif  // energylevelmap_h