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]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#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;
}

 * @details The ground state is defined as the first level (lowest energy) in the default dataset.
 * @see tklevel_scheme::get_levels()
 */
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;
}

 * and the ratio as a double. A ratio value of -1 means that the value or decay is uncertain
 */
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;
}


 * [ INFO     ] 12C (Z=6, N=6) properties:
 * [ INFO     ] Ground state configuration: 0+
 * [ INFO     ] Stable nucleus, abundance: 98.93 %
 * ```
 */
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 << "Unknown" << 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