tkensdf_record.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_record.h"
#include "tklog.h"
 
namespace tkn {
}
 
using namespace  tkn;
using namespace  std;
 
std::string tkensdf_record::BLANK = "                                                                                ";
 
bool tkensdf_record::set_record(const tkstring &_record)
{
    clear();
 
    if(_record.size() != (RSIZE-1)) { // -1 to remove the \n
        glog << error_v << "oups, record size: "<<_record.length()<<" not equal to RSIZE: "<<RSIZE-1<< do_endl;
        return false;
    }
 
    frecord = _record;
    fid = frecord.substr(5,4);
 
    check_record_type();
 
    return true;
}
 
void tkensdf_record::add_continuation_record(const tkstring &_continuation_record)
{
    tkstring rec = _continuation_record;
    rec.erase(0, 9);
    rec.replace_all("'","''");
    if(!fcontinuation_record.is_empty()) fcontinuation_record += "$";
    fcontinuation_record += rec.remove_all_extra_white_space();
}
 
void tkensdf_record::add_comment_record(const tkstring &_record, bool _is_continuation)
{
    tkstring rec = _record;
    rec.erase(0, 9);
    rec.replace_all("'","''");
    if(!_is_continuation && !fcomment_record.empty()) fcomment_record += "\n";
    fcomment_record += rec.remove_all_extra_white_space() + " ";
}
 
void tkensdf_record::check_record_type()
{
    tkstring field6 = fid.substr(0,1);
    tkstring field7 = fid.substr(1,1);
    tkstring field9 = fid.substr(3,1);
 
    f_is_continuation_record = false;
 
    // gamma record
    if(fid.match("* G ")) {
        ftype = kgamma;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Comment record
    if( !field7.is_empty() && ( field7.equal_to("C",tkstring::ECaseCompare::kIgnoreCase) ||
                               field7.equal_to("D",tkstring::ECaseCompare::kIgnoreCase) ||
                               field7.equal_to("T",tkstring::ECaseCompare::kIgnoreCase) ) ) {
        ftype = kcomment;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Level record
    if(fid.match("* L ")) {
        ftype = klevel;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // history record
    if(fid.match("* H ")) {
        ftype = khistory;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // EC record
    if(fid.match("* E ")) {
        ftype = kec;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Beta record
    if(fid.match("* B ")) {
        ftype = kbeta;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Termination record
    if(frecord.is_empty()) {
        ftype = kend;
        return;
    }
    // identification record
    if(fid.match("*   ")) {
        ftype = kident;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // X-ref record
    if(fid.match("  X*") && !field9.is_empty()) {
        ftype = kxref;
        return;
    }
    // Production normalization record
    if(fid.match("*PN*")) {
        ftype = kprodnorm;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Normalization record
    if(fid.match("  N*")) {
        ftype = knorm;
        return;
    }
    // Q-value record
    if(fid.match("* Q ")) {
        ftype = kq_value;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // Parent record
    if(fid.match("  P*")) {
        ftype = kparent;
        return;
    }
    // Alpha record
    if(fid.match("* A ")) {
        ftype = kalpha;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // particle record
    if( (fid.match("*  *") || fid.match("* D*")) && (field9.equal_to("N") || field9.equal_to("P") || field9.equal_to("A")) ) {
        ftype = kparticle;
        if(!field6.is_empty()) f_is_continuation_record = true;
        return;
    }
    // reference record
    if(fid.match("  R ")) {
        ftype = kreference;
        return;
    }
    ftype = kunknown;
}
 
bool tkensdf_record::decode_energy(const tkstring &_st)
{
    // Check if the level includes an offset
    size_t index=0;
 
    tkstring tmp_e = _st.substr(0,10);
    tkstring tmp_de = _st.substr(10,2);
 
    tmp_e.remove_all(" ");
    tmp_de.remove_all(" ");
 
    // check if this is a resonance level => ignored
    if(tmp_e.begins_with("SN+")) {
        tmp_e.erase(0,3);
        return false;
    }
    // check if this is a resonance level => ignored
    if(tmp_e.begins_with("SP+")) {
        tmp_e.erase(0,3);
        return false;
    }
 
    // check if the level is at an undefined energy
    if(tmp_e.substr(0,1).is_alpha()) {
        fenergy.info += ";OFF=" + tmp_e;
        set_offset(tmp_e.substr(0,1));
        tmp_e.erase(0,1);
        if(tmp_e.is_empty()) {
            tmp_e="0";
        }
        else if(tmp_e.substr(0,1)=="+"){
            tmp_e.erase(0,1);
        }
    }
 
    // check if the energy is only known relatively to a level of unknwon energy
    index = tmp_e.index("+");
    if(index != std::string::npos && tmp_e.substr(index-1,1).to_lower() != "e") {
        tkstring offset = tmp_e.substr(index+1);
        fenergy.info += ";OFF=" + offset;
        set_offset(offset);
        tmp_e.erase(index);
    }
 
    // check if the energy is only temptative
    index = tmp_e.index("(");
    if(index != std::string::npos) {
        tmp_e.remove_all("("); tmp_e.remove_all(")");
        fenergy.info += ";VAL=()";
    }
    // check if something is remaining
    if(tmp_e.empty()) {
        return false;
    }
 
    fenergy.unit = "KEV";
    fenergy.value = tmp_e.atof();
 
    fenergy.filled = true;
 
    // cases LT,GT,LE,GE,AP,CA,SY
    if(tmp_de.is_alpha()) {
        fenergy.info += ";ERR=" + tmp_de;
        tmp_de="";
    }
 
    if(fenergy.value>0.) {
        if(tmp_de.is_empty()) fenergy.info += ";ERR=?";
        double precision = tkstring::get_precision(tmp_e);
        fenergy.err = tmp_de.atof()*precision;
    }
 
    return true;
}
 
bool tkensdf_record::decode_lifetime(const tkstring &_st, const tkstring &_st_ms)
{
    tkstring tmp_lt = _st.substr(0,10);
 
    if(tmp_lt.is_empty()) return false;
 
    if(fglobal_time_unit=="skip") return false;
 
    if(tmp_lt.contains("?")) {
        flifetime.info = "? ";
        tmp_lt.remove_all("?");
    }
 
    if(tmp_lt.contains("STABLE")) {
        flifetime.value = 3.2E23;
        flifetime.unit = "S";
        flifetime.info += ";STABLE";
    }
    else {
        auto tokens_lt = tmp_lt.tokenize(" ");
        if(tokens_lt.size() !=2 && fglobal_time_unit.is_empty()) {
            // in this specific case, the most probable scenario is that this field has been used for something else than lifetime
            //            glog << error << "problem in decoding life time in record: " << frecord << " (no unit given)" << do_endl;
            return false;
        }
        flifetime.value = tokens_lt.front().atof();
        if(tokens_lt.size() !=2 && !fglobal_time_unit.is_empty()) flifetime.unit = fglobal_time_unit;
        else flifetime.unit = tokens_lt.back();
        if(flifetime.unit.equal_to("m",tkstring::ECaseCompare::kIgnoreCase)) flifetime.unit = "MIN";
 
        tkstring lt_err = _st.substr(10,6).strip_all_extra_white_space();
        if(!lt_err.is_empty()) {
 
            if(lt_err.is_alpha()) {
                flifetime.info += ";ERR=" + lt_err;
            }
            else {
                // define precision according to the value string
                double precision = tkstring::get_precision(tokens_lt.front());
 
                // check if asym errors
                if(lt_err.contains("+") && lt_err.contains("-")) {
                    bool inv = lt_err.index("-") <  lt_err.index("+");
                    lt_err.replace_all("+"," ");
                    lt_err.replace_all("-"," ");
                    auto tokens_lt_err = lt_err.tokenize(" ");
                    if(tokens_lt_err.size()!=2) {
                        glog << error << " bad asymetric error decoding in record " << frecord << do_endl;
                        return false;
                    }
                    tkstring err_low_str = tokens_lt_err.back();
                    tkstring err_high_str = tokens_lt_err.front();
                    if(inv) {
                        err_low_str = tokens_lt_err.front();
                        err_high_str  = tokens_lt_err.back();
                    }
 
                    flifetime.err_low = err_low_str.atof()*precision;
                    flifetime.err_high = err_high_str.atof()*precision;
                }
                else {
                    flifetime.err = lt_err.atof()*precision;
                }
            }
        }
        else
            flifetime.info += ";ERR=?";
    }
 
    if(!_st_ms.is_empty()) {
        flifetime.info += ";ISO=" + _st_ms;
    }
 
    flifetime.filled = true;
 
    return true;
}
 
void tkensdf_record::clear()
{
    fenergy.clear();
    flifetime.clear();
 
    frecord = "";
    ftype = kunknown;
    f_is_continuation_record = false;
    fcontinuation_record = "";
    fcomment_record = "";
 
    fUncertain_record = "";
 
    fisknown_woth_offset = false;
    fOffset="";
}
 
void tkensdf_record::print(std::ostream &out) const
{
    out << "Record: " <<  frecord << std::endl;
}