tkensdf_level_rec.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]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *   
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include "tkensdf_level_rec.h"
#include "tklog.h"
#include "tkproperty.h"
 
namespace tkn {
}
 
using namespace  tkn;
using namespace  std;
 
tkensdf_level_rec::tkensdf_level_rec()
{
    ftype = klevel;
}
 
bool tkensdf_level_rec::set_record(const tkstring &_record)
{
    frecord = _record;
    return true;
}
 
void tkensdf_level_rec::analyse_record()
{
    // check if the level is uncertain
    fUncertain_record = frecord.substr(79,1);
 
    if(! decode_energy(get_energy_str(frecord))) fenergy.value = -1;
 
    decode_jpi(get_jpi_str(frecord));
 
    decode_lifetime(get_lifetime_str(frecord), get_lifetime_metastable_str(frecord));
 
    analyse_continuation_record();
}
 
void tkensdf_level_rec::analyse_continuation_record()
{
    int i=0;
    auto tokens = fcontinuation_record.tokenize("$");
    for(auto &token: tokens) {
        i++;
        if(token.begins_with("FLAG")) continue;
        if(token.begins_with("XREF")) continue;
        if(token.begins_with("BE") || token.begins_with("BM")) {
//            cout<<"BE " << token<<endl;
        }
        else if (token.begins_with("B")) {
//            cout<< token<<endl;
        }
        else if(token.begins_with("CONF")) {
//            cout<< token<<endl;
        }
    }
}
 
void tkensdf_level_rec::clear()
{
    tkensdf_record::clear();
    fSpin.clear();
    fParity.clear();

    fJPi_str            = "";
    fJPi_tentative      = false;
    fJ                  = 0;
    fPi                 = true;
}
 
void tkensdf_level_rec::print(std::ostream &/*out*/) const
{
    glog << info_o << "level: E=" << fenergy.value << "(" << fenergy.err << ")" << " : JPi=" << fJPi_str << do_endl;
}
 
bool tkensdf_level_rec::decode_jpi(const tkstring &_st)
{
    fJPi_str = _st;
    fJPi_str.remove_all_extra_white_space();
    fJPi_str.replace_all("OR",",");
    fJPi_str.replace_all("TO",":");
    fJPi_str.replace_all("AND","&");
 
    // no idea what this means
    if(fJPi_str.contains("NATURAL") || fJPi_str.contains("UNATURAL")) {
        //        cout << "NATURAL/UNATURAL spin type: "<<fJpi_str << endl;
        return false;
    }
    // in case of levels are build on an unkonwn energy level, the unkown level is defined as E=X(Y,Z...) and J=J(J1,J2,J3...)
    // The levels built on this level, are then defined with an energy of E+X and J+2(4,6...)
    if(fJPi_str.substr(0,1).is_alpha() &&
             (!fJPi_str.substr(1,1).is_alpha() || fJPi_str.substr(1,2) == "AP")) {
        //        cout << "alpha spin type: "<<fJpi_str << endl;
        return false;
    }
    // if the spin is either approximative (AP), or in a range (LE or GE)
    if(fJPi_str.contains("AP") || fJPi_str.contains("LE") || fJPi_str.contains("GE") ) {
        //        cout << "operator spin type: "<<fJpi_str << endl;
        fJPi_tentative = true;
    }
    // Means a list of several possibilities
    else if(fJPi_str.contains(",")) {
        //        cout << "OR spin type: "<<fJpi_str << endl;
        fJPi_tentative = true;
    }
    // Means a range of possible spins
    else if(fJPi_str.contains(":")) {
        //        cout << "To spin type: "<<fJpi_str << endl;
        fJPi_tentative = true;
    }
    // case of two spin states are attributed... why, how ?
    else if(fJPi_str.contains("&")) {
        //        cout << "and spin type: "<<fJpi_str << endl;
        return false;
    }
    else if(fJPi_str.is_empty()) {
        //        cout << "empty spin type: "<<fJpi_str << endl;
        return false;
    }
    // normal case
    else {
        //        cout << "normal spin type: "<<fJpi_str << endl;
        fSpin.set(fJPi_str);
        fParity.set(fJPi_str);
        if(fSpin.get_info() == tkproperty::kTentative || fParity.get_info() == tkproperty::kTentative) fJPi_tentative = true;
        else if(fSpin.get_info() == tkproperty::kKnown && fParity.get_info() == tkproperty::kKnown) fJPi_tentative = false;
        else if(fSpin.get_info() == tkproperty::kAbout || fParity.get_info() == tkproperty::kAbout) fJPi_tentative = true;
        else if(fSpin.get_info() == tkproperty::kTheo || fParity.get_info() == tkproperty::kTheo) fJPi_tentative = true;
        else fJPi_tentative = true;
    }
 
    fJ = fSpin.get_value();
    if(fParity.is_parity(tkparity::eparity::kParityPlus)) fPi = false;
    else fPi = true;
 
    return true;
}