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]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include "tklevel.h"
#include "tkstate_time.h"
#include "tkstring.h"
#include "tklog.h"
 
#include <iomanip>
#include <sstream>
#include <string>
 
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(gunits->get_type(lifetime->get_unit_key()) == gunits->kEnergy ? "decay width" : "half-life");
   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;
   }
}
 
namespace {
 
shared_ptr<tkmeasure> make_level_measure(const tkdb_table::measure_data_struct &data,
                                        const tkstring &type)
{
   shared_ptr<tkmeasure> measure;
   if (data.err_low > 0. && data.err_high > 0.)
      measure = make_shared<tkmeasure>(data.value, data.unit, data.err_low, data.err_high);
   else
      measure = make_shared<tkmeasure>(data.value, data.unit, data.err);
   measure->set_info(tkproperty::kKnown);
   if (!data.info.is_empty()) measure->set_info_tag(data.info);
   measure->set_type(type);
   return measure;
}
 
} // namespace
 
void tklevel::set_magnetic_dipole(tkdb_table::measure_data_struct &_struc)
{
   add_property("magnetic_dipole", make_level_measure(_struc, "magnetic dipole moment"));
}
 
void tklevel::set_electric_quadrupole(tkdb_table::measure_data_struct &_struc)
{
   add_property("electric_quadrupole", make_level_measure(_struc, "electric quadrupole moment"));
}
 
double tklevel::get_magnetic_dipole()
{
   if (!has_property("magnetic_dipole")) return std::nan("1");
   return get("magnetic_dipole")->get_value();
}
 
double tklevel::get_electric_quadrupole()
{
   if (!has_property("electric_quadrupole")) return std::nan("1");
   return get("electric_quadrupole")->get_value();
}
 
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 (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_half_life(tkunit_manager::units_keys unit)
{
   return detail::state_time_value(get("lifetime"), is_stable(), unit, false);
}
 
double tklevel::get_mean_lifetime(tkunit_manager::units_keys unit)
{
   return get_half_life(unit) / std::log(2.);
}
 
double tklevel::get_decay_width(tkunit_manager::units_keys unit)
{
   return detail::state_time_value(get("lifetime"), is_stable(), unit, true);
}
 
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 {
      constexpr size_t print_label_width = 14;
      std::ostringstream level_message;
      level_message << std::left << std::setw(print_label_width) << "Nuclear level:";
 
      tkmeasure energy_print = *get_energy_measure();
      energy_print.set_type("energy");
 
      glog << info << level_message.str() << " " << &energy_print;
      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")) {
         const size_t comment_prefix_size = 13;
         const size_t line_offset = comment_prefix_size + print_label_width + 1;
         const std::string first_indent(line_offset - comment_prefix_size, ' ');
         glog << comment << first_indent << wrap_text(get_comment(), line_offset, line_offset) << do_endl;
      }
   }
}
 
#ifdef HAS_ROOT
ClassImp(tklevel);
#endif