tknucleus.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 "tknucleus.h"
#include "sqlite3.h"
#include "tklog.h"
#include "tkstring.h"
#include "tkmanager.h"
 
namespace tkn {
}
 
using namespace tkn;
 
vector<int> tknucleus::fmagic_number_list{2,8,20,28,50,82,126};
 
tknucleus::tknucleus(int _Z, int _A) : tkproperty_list("nucleus")
{
    tkstring symbol = gmanager->get_element_symbol(_Z);
    if(symbol.empty()) {
        glog << warning << "Unknown nucleus. No properties loaded " << tkstring::form("(%d,%d)",_Z,_A) << do_endl;
        fZ = _Z;
        fN = _A-_Z;
        fA = _A;
        return;
    }
    symbol.prepend(tkstring::form("%d",_A));
    if(!gmanager->known_nucleus(symbol)){
        glog << warning << "Unknown nucleus. No properties loaded (" << symbol << ")" << do_endl;
        return;
    }
    const tknucleus & nuc = *gmanager->get_nucleus(symbol).get(); // vérifier que ca fasse une copie et pas une reference
    (*this) = nuc;
}
 
tknucleus::tknucleus(int _Z) : tkproperty_list("nucleus")
{
    if(!gmanager->known_element(_Z))  glog << warning << "Unknown element. No properties loaded" << do_endl;
    else {
        shared_ptr<tknucleus> bestnuc;
        for(const auto &nuc: gmanager->get_nuclei_for_z(_Z)) {
            if(bestnuc==nullptr) bestnuc = nuc;
            else if(isnan(bestnuc->get_lifetime()) || (nuc->get_lifetime()>bestnuc->get_lifetime())) bestnuc = nuc;
            else if(nuc->get_lifetime() == bestnuc->get_lifetime() && nuc->get_abundance()>bestnuc->get_abundance()) bestnuc = nuc;
        }
        const tknucleus & nuc = *bestnuc.get();
        (*this) = nuc;
    }
}
 
tknucleus::tknucleus(const char *_symbol) : tkproperty_list("nucleus")
{
    if(!gmanager->known_nucleus(tkstring(_symbol))) {
        int z;
        if(gmanager->known_element(tkstring(_symbol),z)) {
            if(!tkstring(_symbol).is_alpha()) {
                glog << warning << "Unknown nucleus. TkN will choose one for you ;)" << do_endl;
            }
            const tknucleus nuc(z);
            (*this) = nuc;
            return;
        }
    }
    const tknucleus & nuc = *gmanager->get_nucleus(_symbol).get();
    (*this) = nuc;
}
 
void tknucleus::set_name(const char *_name)
{
    fSymbol = _name;
    felement_symbol = fSymbol.extract_alpha();
    fA = fSymbol.atoi();
}
 
bool tknucleus::is_z_magic(){
    if(std::find(fmagic_number_list.begin(), fmagic_number_list.end(), fZ) != fmagic_number_list.end()) return true;
    return false;
}
 
bool tknucleus::is_n_magic(){
    if(std::find(fmagic_number_list.begin(), fmagic_number_list.end(), fN) != fmagic_number_list.end()) return true;
    return false;
}
 
shared_ptr<tklevel_scheme> tknucleus::get_level_scheme()
{
    return gmanager->get_level_scheme(get_symbol(), get_z(), get_a());
}
 
double tknucleus::get_radius() const
{
    if(!has_property("radius")) return -1.;
    return get("radius")->get_value();
}
 
double tknucleus::get_magnetic_dipole()
{
    if(!has_property("magnetic_dipole")) return -1.;
    return get("magnetic_dipole")->get_value();
}
 
double tknucleus::get_electric_quadrupole()
{
    if(!has_property("electric_quadrupole")) return -1.;
    return get("electric_quadrupole")->get_value();
}
 
double tknucleus::get_abundance() const
{
    if(!has_property("abundance")) return -1.;
    return get("abundance")->get_value();
}
 
double tknucleus::get_mass_excess(const tkunit_manager::units_keys _unit)
{
    if(!has_property("mass_excess")) return std::nan("1");
    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");
    }
    return get("mass_excess")->get_value(_unit);
}
 
double tknucleus::get_binding_energy_over_a(const tkunit_manager::units_keys _unit)
{
    if(!has_property("binding_energy_overA")) return std::nan("1");
    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");
    }
    return get("binding_energy_overA")->get_value(_unit);
}
 
double tknucleus::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);
}
 
 
 
double tknucleus::get_fission_yield(tkstring _parent, bool _cumulative) {
    if(!_parent.begins_with("FY")) _parent.prepend("FY");
    if(_cumulative) _parent.prepend("c");
    if(!has_property(_parent)) return 0.;
    return get(_parent)->get_value();
}
 
tkstring tknucleus::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;
}
 
shared_ptr<tklevel> tknucleus::get_ground_state()
{
    if(!get_level_scheme()->get_levels().empty())
        return get_level_scheme()->get_levels().front();
    return nullptr;
}
 
bool tknucleus::is_bound() const
{
    if(!has_property("binding_energy_overA")) return false;
    return get("binding_energy_overA")->get_value()>0;
}
 
vector<pair<tkstring, double>> tknucleus::get_decay_modes()
{
    vector<pair<tkstring, double>> decay_list;
    auto decays = get_decay_mode_str();
    auto tokkens = decays.replace_all("[","]").tokenize("]");
    for(auto &dec: tokkens) {
        auto tokk = dec.tokenize(";");
        decay_list.push_back({tokk.front(),tokk.back().atof()});
    }
    return decay_list;
}
 
void tknucleus::print() const
{
    glog << info << fSymbol << " (Z=" << fZ <<", N=" << fN << ") properties:" << do_endl;
    glog << info << "Ground state configuration: ";
    if(get_jpi().is_empty()) glog << "Unkown" << do_endl;
    else glog << get_jpi() << do_endl;
    if(is_stable()) glog << info << "Stable nucleus, abundance: " << tkstring::form("%3.2f",get_abundance()) << " %" << do_endl;
    else {
        glog << info << "Radioactive nucleus:"<<do_endl;
        if(get_lifetime_measure()) glog << info << get_lifetime_measure() << do_endl;
        glog << info << "Decay: " << get_property("decay_modes") << do_endl;
    }
}
 
 
#ifdef HAS_ROOT
ClassImp(tknucleus);
#endif