abs_species_tags.h

Go to the documentation of this file.

/* Copyright (C) 2002-2012 Stefan Buehler  <sbuehler@ltu.se>
 
   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 abs_species_h
#define abs_species_h
 
#include <stdexcept>
#include "array.h"
#include "bifstream.h"
#include "matpackI.h"
#include "mystring.h"
 
class SpeciesTag {
 public:
  SpeciesTag()
      : mspecies(-1),
        misotopologue(-1),
        mlf(0.),
        muf(0.),
        mtype(-1),
        mcia_second(-1),
        mcia_dataset(-1) { /* Nothing to be done here. */
  }
 
  // Documentation is with implementation.
  explicit SpeciesTag(String def);
 
  // Documentation is with implementation.
  String Name() const;
 
  Index Species() const { return mspecies; }
  
  void Species(Index x) { mspecies = x; }
 
  Index BathSpecies() const { return mcia_second; }
 
  String SpeciesNameMain() const;
 
  Numeric SpeciesMass() const;
 
  bool IsSpecies(const String& s) const;
 
  bool IsIsotopologue(const String& i) const;
 
  Index Isotopologue() const { return misotopologue; }
  
  void Isotopologue(Index x) { misotopologue = x; }
 
  Numeric Lf() const { return mlf; }
 
  void Lf(Numeric x) { mlf = x; }
 
  Numeric Uf() const { return muf; }
 
  void Uf(Numeric x) { muf = x; }
 
  Index CIASecond() const { return mcia_second; }
  
  void CIASecond(Index x) { mcia_second = x; }
 
  Index CIADataset() const { return mcia_dataset; }
  
  void CIADataset(Index x) { mcia_dataset = x; }
 
 
  bool operator==(const SpeciesTag& other) const {
    if (other.mspecies != mspecies) return false;
    if (other.misotopologue != misotopologue) return false;
    if (other.mlf != mlf) return false;
    if (other.muf != muf) return false;
    if (other.mtype != mtype) return false;
    if (mtype == TYPE_CIA && (other.mcia_second != mcia_second ||
                              other.mcia_dataset != mcia_dataset))
      return false;
    return true;
  }
 
  enum : Index {
    TYPE_PLAIN,
    TYPE_ZEEMAN,
    TYPE_PREDEF,
    TYPE_CIA,
    TYPE_FREE_ELECTRONS,
    TYPE_PARTICLES,
    TYPE_HITRAN_XSEC
  };
 
  Index Type() const { return mtype; }
 
  void Type(Index x) { mtype = x; }
  
  static bool validIndexForType(Index x) noexcept {
    constexpr auto keys = stdarrayify(Index(TYPE_PLAIN), TYPE_ZEEMAN, TYPE_PREDEF, TYPE_CIA, TYPE_FREE_ELECTRONS, TYPE_PARTICLES, TYPE_HITRAN_XSEC);
    return std::any_of(keys.cbegin(), keys.cend(), [x](auto y){return x == y;});
  }
  
  Index string2Type(const String& str) const {
    if (std::string("TYPE_PLAIN") == str) {
      return TYPE_PLAIN;
    } else if (std::string("TYPE_ZEEMAN") == str) {
      return TYPE_ZEEMAN;
    } else if (std::string("TYPE_PREDEF") == str) {
      return TYPE_PREDEF;
    } else if (std::string("TYPE_CIA") == str) {
      return TYPE_CIA;
    } else if (std::string("TYPE_FREE_ELECTRONS") == str) {
      return TYPE_FREE_ELECTRONS;
    } else if (std::string("TYPE_PARTICLES") == str) {
      return TYPE_PARTICLES;
    } else if (std::string("TYPE_HITRAN_XSEC") == str) {
      return TYPE_HITRAN_XSEC;
    } else {
      return -1;
    }
  }
 
 private:
  Index mspecies;
 
 
  Index misotopologue;
 
 
  Numeric mlf;
 
 
  Numeric muf;
 
  Index mtype;
 
 
  Index mcia_second;
 
 
  Index mcia_dataset;
};
 
ostream& operator<<(ostream& os, const SpeciesTag& ot);
 
typedef Array<SpeciesTag> ArrayOfSpeciesTag;
 
typedef Array<ArrayOfSpeciesTag> ArrayOfArrayOfSpeciesTag;
 
//======================================================================
//             Functions related to species and tags
//======================================================================
 
String get_tag_group_name(const ArrayOfSpeciesTag& tg);
 
String get_species_name(const ArrayOfSpeciesTag& tg);
 
Index find_first_species_tg(const ArrayOfArrayOfSpeciesTag& tgs,
                            const Index& spec);
 
Index find_next_species_tg(const ArrayOfArrayOfSpeciesTag& tgs,
                           const Index& spec,
                           const Index& start);
 
Index find_first_species_tg(const ArrayOfArrayOfSpeciesTag& list_of_tags, const SpeciesTag& tag);
 
void array_species_tag_from_string(ArrayOfSpeciesTag& tags,
                                   const String& names);
 
void check_abs_species(const ArrayOfArrayOfSpeciesTag& abs_species);
 
bool is_zeeman(const ArrayOfSpeciesTag& tg);
 
//--------------------------------------------------------------------------------
// Functions from ARTS-1-0. Are they still needed?
//--------------------------------------------------------------------------------
 
void get_tag_group_index_for_tag_group(Index& tags1_index,
                                       const ArrayOfArrayOfSpeciesTag& tags1,
                                       const Array<SpeciesTag>& tags2);
 
#endif  // abs_species_h