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]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *   
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#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) {
        auto new_RI = make_shared<tkmeasure>(_val,"%");
        new_RI->set(_val,"%");
        new_RI->set_info(tkproperty::kKnown);
        if(_unc>0.) new_RI->set_error(_unc);
        new_RI->set_type("RI");
        add_property("RI",new_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();
}