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