quantum.h

Go to the documentation of this file.

/* Copyright (C) 2013
   Oliver Lemke <olemke@core-dump.info>

   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 quantum_h
#define quantum_h

#include <map>
#include <iostream>
#include "matpack.h"
#include "rational.h"


/*
 If you add anything here, remember to also adapt
 operator<<(ostream&, const QuantumNumbers&) and
 operator>>(istream&, QuantumNumbers&)
 to handle the added numbers.
 */
typedef enum {
    QN_J,           // Total
    QN_N,           // Total-Spin
    QN_S,           // Electronic spin
    QN_F,           // Total + nuclear spin
    QN_Omega,       // Absolute of projection of total + projection of spin
    QN_K1,          // Either K or Ka in HITRAN (This is a projection of J along one axis)
    QN_K2,          // Either Kb in HITRAN (This is a projection of J along another axis)
    QN_v1,          // Vibrational mode 1
    QN_v2,          // Vibrational mode 2
    QN_v3,          // Vibrational mode 3
    QN_FINAL_ENTRY  // We need this to determine the number of elements in this enum
} QuantumIds;


class QuantumNumbers
{
public:
    typedef std::map<Index, Rational> QuantumContainer;

    const Rational operator[](const Index qn) const
    {
        QuantumContainer::const_iterator it = mqnumbers.find(qn);
        if (it != mqnumbers.end())
            return it->second;
        else
            return RATIONAL_UNDEFINED;
    }

    void Set(Index qn, Rational r) { assert(qn < QN_FINAL_ENTRY); mqnumbers[qn] = r; }

    const QuantumContainer& GetNumbers() const { return mqnumbers; }


    bool Compare(const QuantumNumbers& qn) const;

private:
    QuantumContainer mqnumbers;
};


class QuantumNumberRecord
{
public:
    void SetLower(const Index i, const Rational r) { mqn_lower.Set(i, r); }

    void SetUpper(const Index i, const Rational r) { mqn_upper.Set(i, r); }

    Rational Lower(Index i) const { return mqn_lower[i]; }

    Rational Upper(Index i) const { return mqn_upper[i]; }

    QuantumNumbers& Lower() { return mqn_lower; }

    const QuantumNumbers& Lower() const { return mqn_lower; }

    QuantumNumbers& Upper() { return mqn_upper; }

    const QuantumNumbers& Upper() const { return mqn_upper; }

private:
    QuantumNumbers mqn_upper;
    QuantumNumbers mqn_lower;
};


std::istream& operator>>(std::istream& is, QuantumNumbers& qn);
std::ostream& operator<<(std::ostream& os, const QuantumNumbers& qn);

std::ostream& operator<<(std::ostream& os, const QuantumNumberRecord& qr);

#endif