QuantumNumbers.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_QuantumNumbers_h
#define yap_QuantumNumbers_h

#include "Spin.h"

#include <ostream>
#include <string>

namespace yap {


class QuantumNumbers
{
public:


    constexpr QuantumNumbers(unsigned twoJ, int P, int C, unsigned twoI, int G, int Q)
        : TwoJ_(twoJ), P_(P), C_(C), TwoI_(twoI), G_(G), Q_(Q) {}

    constexpr QuantumNumbers(unsigned twoI, unsigned twoJ, int P, int Q)
        : QuantumNumbers(twoJ, P, 0, twoI, 0, Q) {}

    constexpr QuantumNumbers(unsigned twoJ, int P, int Q)
        : QuantumNumbers(twoJ, P, 0, 0, 0, Q) {}

    constexpr QuantumNumbers(unsigned twoJ, int Q)
        : QuantumNumbers(twoJ, 0, 0, 0, 0, Q) {}

    QuantumNumbers()
        : QuantumNumbers(0, 0, 0, 0) {}


    virtual bool consistent() const;


    constexpr unsigned twoJ() const
    { return TwoJ_; }

    constexpr double J() const
    { return TwoJ_ * 0.5; }

    constexpr int P() const
    { return P_; }

    constexpr int C() const
    { return C_; }

    constexpr unsigned twoI() const
    { return TwoI_; }

    constexpr double I() const
    { return TwoI_ * 0.5; }

    constexpr int G() const
    { return G_; }

    constexpr int Q() const
    { return Q_; }



    void setJ(double J)
    { TwoJ_ = 2 * J; }

    void setTwoJ(unsigned J)
    { TwoJ_ = J; }


private:

    unsigned TwoJ_;

    int P_;

    int C_;

    unsigned TwoI_;

    int G_;

    int Q_;

};

bool operator==(const QuantumNumbers& lhs, const QuantumNumbers& rhs);

inline bool operator!=(const QuantumNumbers& lhs, const QuantumNumbers& rhs)
{ return !(lhs == rhs); }

inline std::string to_string(const QuantumNumbers& Q)
{ return spin_to_string(Q.twoJ()) + (Q.P() > 0 ? "+" : "-") + (Q.C() == 0 ? "" : (Q.C() > 0 ? "+" : "-")); }

inline std::string debug_string(const QuantumNumbers& Q)
{ return (std::to_string(Q.twoJ()) + " " + std::to_string(Q.P()) + " " + std::to_string(Q.C()) + " " + std::to_string(Q.twoI()) + " " + std::to_string(Q.G()) + " " + std::to_string(Q.Q())); }

inline std::ostream& operator<< (std::ostream& os, const QuantumNumbers& Q)
{ os << "JP" << ((Q.C() == 0) ? "" : "C") << " = " << to_string(Q); return os; }

}

#endif