tklevel.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 "tklevel.h"
#include "tkstring.h"
#include "tklog.h"
 
using namespace  std;
 
namespace tkn {
}
 
using namespace tkn;
 
tklevel::tklevel(int _id, const tkdb_table::measure_data_struct &_struc) :
    tkproperty_list("level"),
    flevel_id(_id),
    fspin_parity(make_shared<tkspin_parity>())
{
    shared_ptr<tkmeasure> energy = make_shared<tkmeasure>(_struc.value,_struc.unit);
    if(_struc.value>=0.) energy->set_info(tkproperty::kKnown);
    if(_struc.err>0.) energy->set_error(_struc.err);
    else if(_struc.err_low>0. && _struc.err_high>0.) energy->set_error(_struc.err_low,_struc.err_high);
    if(!_struc.info.is_empty()) energy->set_info_tag(_struc.info);
    energy->set_type("Level energy");
    add_property("energy",energy);
 
    if(energy->get_info_tag().contains(";OFF=")) {
        int idx = energy->get_info_tag().index(";OFF=");
        tkstring offset = energy->get_info_tag().substr(idx+5,1);
        set_energy_offset(offset);
    }
}
 
void tklevel::set_lifetime(tkdb_table::measure_data_struct &_struc)
{
    shared_ptr<tkmeasure> lifetime = make_shared<tkmeasure>(_struc.value,_struc.unit);
    lifetime->set_info(tkproperty::kKnown);
    if(_struc.err>0.) lifetime->set_error(_struc.err);
    else if(_struc.err_low>0. && _struc.err_high>0.) lifetime->set_error(_struc.err_low,_struc.err_high);
    if(!_struc.info.is_empty()) lifetime->set_info_tag(_struc.info);
    if(lifetime->get_info_tag().contains("STABLE")) fis_stable = true;
    lifetime->set_type("lifetime");
    add_property("lifetime",lifetime,tkstring::form("%g",lifetime->get_value()));
 
    if(lifetime->get_info_tag().contains(";ISO=")) {
        fis_isomer = true;
        int idx = lifetime->get_info_tag().index(";ISO=");
        fisomer_level = lifetime->get_info_tag().substr(idx+6,1).atoi(); // ex= ;ISO=M1 => 1
        if(fisomer_level==0) fisomer_level = 1;
    }
}
 
void tklevel::set_jpi(double _spin, int _parity, const tkstring &_jpi_str)
{
    if(_spin>=0) fspin_parity->set_spin(_spin);
    if(_parity>=0) fspin_parity->set_parity(_parity);
    fspin_parity->set_from_str(_jpi_str);
    add_property_str("spin_parity",_jpi_str,"");
}
 
double tklevel::get_energy(const tkunit_manager::units_keys _unit, bool _with_offset)
{
    if(gunits->get_type(_unit)!=tkunit_manager::units_type::kEnergy){
        glog << error << gunits->get_name(_unit) << " is not of 'energy' type (returns nan(1))" << do_endl;
        return std::nan("1");
    }
    if(get("energy")->get_unit()=="") {
        cout << fenergy_offset << endl;
        cout << fbelongs_to_nucleus << endl;
        print();
    }
    if(is_energy_offset() && !_with_offset) {
        glog << warning << "Level is only known relatively to an offset, use the _with_offset option to get the relative energy" << do_endl;
        return std::nan("1");
    }
    return get("energy")->get_value(_unit);
}
 
double tklevel::get_lifetime(const tkunit_manager::units_keys _unit)
{
    if(!has_property("lifetime")) return std::nan("1");
    if(gunits->get_type(_unit)!=tkunit_manager::units_type::kTime&&gunits->get_type(_unit)!=tkunit_manager::units_type::kEnergy){
        glog << error << gunits->get_name(_unit) << " is not of 'time' or 'energy' type (returns nan(1))" << do_endl;
        return std::nan("1");
    }
    return get("lifetime")->get_value(_unit);
}
 
tkstring tklevel::get_lifetime_str()
{
    if(!has_property("lifetime")) return "";
    tkstring lifetime_str;
 
    if(is_stable())
        lifetime_str = "STABLE";
    else {
        vector<tkunit_manager::units_keys> units{tkunit_manager::y, tkunit_manager::d, tkunit_manager::h, tkunit_manager::min,
                                                 tkunit_manager::s, tkunit_manager::ms, tkunit_manager::us, tkunit_manager::ns,
                                                 tkunit_manager::ps, tkunit_manager::fs, tkunit_manager::as,
                                                 tkunit_manager::MeV, tkunit_manager::keV, tkunit_manager::eV};
 
        for(auto &unit: units) {
            double lifetime = get_lifetime(unit);
            if(lifetime>1.) {
                lifetime_str = tkstring::Form("%.3g %s",lifetime,std::get<0>(tkunit_manager::funits_properties.at(unit)).data());
                break;
            }
        }
    }
 
    return lifetime_str;
}
 
 
bool tklevel::is_yrast(bool _with_tentative)
{
    if(_with_tentative) return fisYrast_uncertain;
    else return fisYrast_exact;
}
 
 
void tklevel::print(const tkstring &_option)
{
    // in line printout
    if(_option.contains("tab")){
        std::cout << std::setw(15) << left << flevel_id;
        if(is_energy_offset()) std::cout << get_offset_bandhead() << "+";
        std::cout << std::setw(15)<< left << get_energy_measure()->get_value();
        if(get_energy_measure()->get_error()>0.)
            std::cout << std::setw(15)<< left << get_energy_measure()->get_error();
        else
            std::cout << std::setw(15)<< left << " ";
        if(fspin_parity)
            std::cout << std::setw(15)<< left << fspin_parity->get_jpi_str();
        if(get_lifetime_measure() && get_lifetime_measure()->get_value()>0.) {
            std::cout << std::setw(15)<< left <<  get_lifetime_measure()->get_value();
            if(get_lifetime_measure()->get_error()>0.)
                std::cout << std::setw(15)<< left << get_lifetime_measure()->get_error();
            else
                std::cout << std::setw(15)<< left << " ";
            std::cout << std::setw(15) << left  <<  get_lifetime_measure()->get_unit();
        }
        else {
            std::cout << std::setw(15)<< left <<  " "
                      << std::setw(15)<< left <<  " "
                      << std::setw(15)<< left <<  " ";
        }
        std::cout << std::endl;
    }
    else {
        glog << info << get_energy_measure();
        if(fspin_parity)
            glog << " ; Jpi: " << setw(4) << fspin_parity->get_jpi_str();
        if(get_lifetime_measure() && get_lifetime_measure()->get_value()>0.)
            glog << " ; " << get_lifetime_measure();
        if(is_isomer()) {
            if(get_isomer_level()==1) glog << " [1rst isomer]";
            else if(get_isomer_level()==2) glog << " [2nd isomer]";
            else if(get_isomer_level()==3) glog << " [3rd isomer]";
            else glog << " [" << get_isomer_level() << "th isomer]";
        }
        if(is_uncertain()) {
            glog << " uncertain level tag: " << funcertain_level;
        }
        glog << do_endl;
 
        if(has_comment() && _option.contains("com")) {
            tkstring _comment = get_comment();
            _comment.replace_all("\n","\n             ");
            glog << comment << _comment << do_endl;
        }
    }
}
 
#ifdef HAS_ROOT
ClassImp(tklevel);
#endif