tkspin_parity.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#include "tkspin_parity.h"
 
#include <iomanip>
#include <cmath>
 
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
using namespace std;
 
tkspin::tkspin(int N, int D)
{
    set(N,D);
}
 
tkstring tkspin::get_string()
{
    tkstring spin;
 
    if (fD != 1)
        spin = tkstring::Form("%d/%d", fN, fD);
    else
        spin = tkstring::Form("%d", fN);
 
    if(is_info(kTentative)) {
        spin.prepend("(");spin.append(")");
    }
    else if(is_info(kTheo)) {
        spin.prepend("[");spin.append("]");
    }
    else if(is_info(kAbout)) {
        spin.prepend("~");
    }
 
    return spin;
}
 
void tkspin::set(const tkstring &_st)
{
    tkstring st = _st;
 
    if(st.ends_with("(-)") || st.ends_with("(+)"))  st.erase(st.length()-3,3);
 
    std::istringstream input; input.clear();
    switch( what_is(st.data()) ){
    case kKnown:
        if ( st.contains("/") ) { // not an integer
            st.replace_all("/"," "); input.str(st); input >> fN >> fD;
        }
        else { input.str(st); input >> fN; fD = 1; }
        if ( input.fail() )
            set_info(kUnknown);
        else
            set_info(kKnown);
        break;
    case kUnknown:
        set_info(kUnknown);
        break;
    case kAbout:
        st.replace_all("~"," ");
        if ( st.contains("/") ) { // not an integer
            st.replace_all("/"," "); input.str(st); input >> fN >> fD;
        }
        else { input.str(st); input >> fN; fD = 1; }
        if ( input.fail() )
            set_info(kUnknown);
        else
            set_info(kAbout);
        break;
    case kTentative:
        st.replace_all("("," ");
        st.replace_all(")"," ");
        if ( st.contains("/") ) { // not an integer
            st.replace_all("/"," "); input.str(st); input >> fN >> fD;
        }
        else { input.str(st); input >> fN; fD = 1; }
        if ( input.fail() )
            set_info(kUnknown);
        else
            set_info(kTentative);
        break;
    case kTheo:
        st.replace_all("["," ");
        st.replace_all("]"," ");
        if ( st.contains("/") ) { // not an integer
            st.replace_all("/"," "); input.str(st); input >> fN >> fD;
        }
        else { input.str(st); input >> fN; fD = 1; }
        if ( input.fail() )
            set_info(kUnknown);
        else
            set_info(kTheo);
        break;
    default:
        set_info(kUnknown);
        break;
    }
}
 
void tkspin::set(int _n, int _d)
{
    fN = _n; fD = _d;
    set_info(kKnown);
    if ( fD < 1 || fD > 2 ) {
        glog << warning << "A spin should be an integer or half an integer !\n";
        glog << tkstring::form("\t [%d/%d] --> [%d/1]",fN,fD,fN) << do_endl;
        fD = 1;
        set_info(kUnknown);
    }
}
 
void tkspin::set(double _spin)
{
    int _2spin = lround(2*_spin);
    if(_2spin%2==0) {
        fN = _2spin/2;
        fD = 1;
    }
    else {
        fN = _2spin;
        fD = 2;
    }
    set_info(kKnown);
    if ( fD < 1 || fD > 2 ) {
        glog << warning << "A spin should be an integer or half an integer !\n";
        glog << tkstring::form("\t [%d/%d] --> [%d/1]",fN,fD,fN) << do_endl;
        fD = 1;
        set_info(kUnknown);
    }
}
 
void tkspin::print()
{
    if(!is_info(kUnknown)) {
        glog << info_o << "spin: " << get_string() << " type: " << get_info_str() << do_endl;
    }
    else {
        glog << warning_o << "spin is unknown" << do_endl;
    }
}
 
#ifdef HAS_ROOT
ClassImp(tkspin);
#endif
 
void tkparity::set(const tkstring &_st)
{
    set_info(kUnknown);
    fParity = kParityUnknown;
 
    if(_st.contains("+")) {
        fParity = kParityPlus;
        if(_st.ends_with("+")) set_info(kKnown);
        if(_st.ends_with(")")) set_info(kTentative);
        else if(_st.ends_with("]")) set_info(kTheo);
    }
    if(_st.contains("-")) {
        fParity = kParityMinus;
        if(_st.ends_with("-")) set_info(kKnown);
        if(_st.ends_with(")")) set_info(kTentative);
        else if(_st.ends_with("]")) set_info(kTheo);
    }
}
 
void tkparity::set(int _parity)
{
    if(_parity==0) {
        fParity = kParityPlus;
        set_info(kKnown);
    }
    else if(_parity==1) {
        fParity = kParityMinus;
        set_info(kKnown);
    }
    else {
        set_info(kUnknown);
        fParity = kParityUnknown;
    }
}
 
tkstring tkparity::get_string()
{
    tkstring parity;
 
    if(is_info(kUnknown)) return ("");
 
    if (fParity == kParityPlus) parity = "+";
    else parity = "-";
 
    if(is_info(kTentative)) {
        parity.prepend("(");parity.append(")");
    }
    else if(is_info(kTheo)) {
        parity.prepend("[");parity.append("]");
    }
    else if(is_info(kAbout)) {
        parity.prepend("~");
    }
 
    return parity;
}
 
void tkparity::print()
{
    if(!is_info(kUnknown)) {
        glog << info_o << "parity: " << get_string() << " type: " << get_info_str() << do_endl;
    }
    else {
        glog << warning_o << "parity is unknown: " << do_endl;
    }
}
 
#ifdef HAS_ROOT
ClassImp(tkparity);
#endif
 
tkspin_parity::tkspin_parity() = default;
 
void tkspin_parity::set_from_str(const tkstring &_st)
{
    fJpi_str = tkstring::form("%s",_st.data());
    fJpi_str.remove_all_extra_white_space();
    fJpi_str.replace_all("GE",">=");
    fJpi_str.replace_all("LE","<=");
    fJpi_str.replace_all("GT",">");
    fJpi_str.replace_all("LT","<");
}
 
void tkspin_parity::set_spin(double _spin)
{
    fSpin.set(_spin);
}
 
void tkspin_parity::set_parity(int _parity)
{
    fParity.set(_parity);
}
 
const tkstring &tkspin_parity::get_jpi_str() const
{
    return fJpi_str;
}
 
void tkspin_parity::print()
{
    if(!is_known()) glog << warning_o << "Unknown Jpi: " << fJpi_str << do_endl;
    else glog << info_o << "Jpi: " << setw(10) << fJpi_str << do_endl;
}
 
#ifdef HAS_ROOT
ClassImp(tkspin_parity)
#endif