tkdecay.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 "tkdecay.h"
#include "tklevel.h"
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
 
array<tkstring,6> tkdecay::decay_type_str = {"undefined", "beta", "ec", "alpha", "particle", "gamma"};
 
tkdecay::tkdecay(int _id, int _from_id, int _to_id, const tkdb_table::measure_data_struct &_struc, decay_type _type) :
    tkproperty_list("decay"),
    fdecay_id(_id),
    fdecay_level_from_id(_from_id),
    fdecay_level_to_id(_to_id),
    fdecay_type(_type)
{
    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(tkstring::form("%s decay energy",decay_type_str.at(fdecay_type).data()));
    add_property("energy",energy);
}
 
double tkdecay::get_energy(const tkunit_manager::units_keys _unit)
{
    return get("energy")->get_value(_unit);
}
 
void tkdecay::print(const tkstring &_option) const
{
    // in line printout
    if(_option.contains("tab")) {
        std::cout << std::setw(15) << left << fdecay_id << std::setw(15) << left << get_energy_meas()->get_value();
        if(get_energy_meas()->get_error()>0.) std::cout << std::setw(15) << left << get_energy_meas()->get_error() << std::endl;
        else std::cout << " " << std::setw(15) << left << " " << std::endl;
    }
    else {
        if(not _option.contains("quiet")) glog << info;
        glog << get_energy_meas();
        if(has_property("mult")) glog << ", mult " << get_property("mult");
        for(auto &prop: fProperties) {
            if(prop.first=="energy") continue;
            if(prop.first=="mult") continue;
            if(prop.second.type=="TEXT") {
                glog << ", " << prop.second.value;
                if(!prop.second.unit.is_empty()) cout << " " << prop.second.unit;
            }
            else glog << ", " << get(prop.first).get();
        }
        if(is_uncertain()) {
            glog << " uncertain decay tag: " << funcertain_decay;
        }
        if(_option.contains("levto")) {
            glog << " final level: " << flevelto->get_spin_parity_str() << " (";
            if(flevelto->is_energy_offset()) glog << flevelto->get_offset_bandhead()<<"+";
            auto save_precision = cout.precision();
            glog << setprecision(flevelto->get_energy_measure()->get_exp_error_precision(flevelto->get_energy_measure()->get_value())) <<  flevelto->get_energy(tkunit_manager::keV,true) << " keV)";
            cout.precision(save_precision);
        }
        glog << do_endl;
        if(has_comment()&&_option.contains("com")) {
            tkstring _comment = get_comment().copy().replace_all("\n","\n             ");
            glog << comment << _comment << do_endl;
        }
    }
}
 
#ifdef HAS_ROOT
ClassImp(tkdecay);
#endif
 
void tkgammadecay::set_relative_intensity(tkdb_table::measure_data_struct &_struc)
{
    shared_ptr<tkmeasure> RI = make_shared<tkmeasure>(_struc.value,_struc.unit);
    RI->set(_struc.value,_struc.unit);
    RI->set_info(tkproperty::kKnown);
    if(_struc.err>0.) RI->set_error(_struc.err);
    if(!_struc.info.is_empty()) RI->set_info_tag(_struc.info);
    RI->set_type("RI");
    add_property("RI",RI);
}
 
void tkgammadecay::set_relative_intensity(double _val, double _unc)
{
    auto RI = get("RI");
    if(!RI) {
        shared_ptr<tkmeasure> RI = make_shared<tkmeasure>(_val,"%");
        RI->set(_val,"%");
        RI->set_info(tkproperty::kKnown);
        if(_unc>0.) RI->set_error(_unc);
        RI->set_type("RI");
        add_property("RI",RI);
    }
    else {
        RI->set(_val);
        if(_unc>0.) RI->set_error(_unc);
    }
}
 
void tkgammadecay::set_multipolarity(const tkstring &_mul)
{
    add_property_str("mult",_mul,"");
}
 
void tkgammadecay::set_mixing_ratio(tkdb_table::measure_data_struct &_struc)
{
    shared_ptr<tkmeasure> MR = make_shared<tkmeasure>(_struc.value,_struc.unit);
    MR->set(_struc.value,_struc.unit);
    MR->set_info(tkproperty::kKnown);
    if(_struc.err>0.) MR->set_error(_struc.err);
    else if(_struc.err_low>0. && _struc.err_high>0.) MR->set_error(_struc.err_low,_struc.err_high);
    if(!_struc.info.is_empty()) MR->set_info_tag(_struc.info);
    MR->set_type("mix ratio");
    add_property("mix ratio",MR);
}
 
void tkgammadecay::set_conv_coeff(tkdb_table::measure_data_struct &_struc)
{
    shared_ptr<tkmeasure> CC = make_shared<tkmeasure>(_struc.value,_struc.unit);
    CC->set(_struc.value,_struc.unit);
    CC->set_info(tkproperty::kKnown);
    if(_struc.err>0.) CC->set_error(_struc.err);
    if(!_struc.info.is_empty()) CC->set_info_tag(_struc.info);
    CC->set_type("conv");
    add_property("conv",CC);
}
 
void tkgammadecay::set_transition_probability(tkdb_table::measure_data_struct &_struc)
{
    tkstring name = _struc.info;
    tkstring type = name.tokenize(";").front().remove_all("TYPE=");
    shared_ptr<tkmeasure> B = make_shared<tkmeasure>(_struc.value,_struc.unit);
    B->set_info(tkproperty::kKnown);
    if(_struc.err>0.) B->set_error(_struc.err);
    else if(_struc.err_low>0. && _struc.err_high>0.) B->set_error(_struc.err_low,_struc.err_high);
    if(!_struc.info.is_empty()) B->set_info_tag(_struc.info);
    B->set_type(type);
    add_property(type,B);
}
 
double tkgammadecay::get_relative_intensity()
{
    if(!has_property("RI")) return std::nan("1");
    return get("RI")->get_value();
}
 
double tkgammadecay::get_mixing_ratio()
{
    if(!has_property("mix ratio")) return std::nan("1");
    return get("mix ratio")->get_value();
}
 
double tkgammadecay::get_conv_coeff()
{
    if(!has_property("conv")) return std::nan("1");
    return get("conv")->get_value();
}
 
shared_ptr<tkmeasure> tkgammadecay::get_trans_prob_measure(bool _elec, int _L, bool _WU)
{
    tkstring name = "B";
    if(_elec) name += "E";
    else name += "M";
    name += to_string(_L);
    if(_WU) name += "W";
    return get(name);
}
 
double tkgammadecay::get_trans_prob(bool _elec, int _L, bool _WU)
{
    auto meas = get_trans_prob_measure(_elec, _L, _WU);
    if(!meas) return std::nan("1");
    return meas->get_value();
}