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]                          *
 *                                                                              *
 *    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 "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;
}