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"
#include "tkstring.h"
 
#include <cctype>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
 
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;
      constexpr size_t print_label_width = 14;
      std::ostringstream decay_message;
      std::vector<std::string> property_messages;
 
      std::string decay_label = decay_type_str.at(fdecay_type) + " decay:";
      decay_label[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(decay_label[0])));
      decay_message << std::left << std::setw(print_label_width) << decay_label;
 
      tkmeasure energy_print = *get_energy_meas();
      energy_print.set_type("energy");
      std::ostringstream energy_message;
      energy_message << &energy_print;
      property_messages.push_back(energy_message.str());
 
      if (has_property("mult")) {
         std::ostringstream property_message;
         property_message << "mult " << get_property("mult");
         property_messages.push_back(property_message.str());
      }
      for (auto &prop : fProperties) {
         if (prop.first == "energy") continue;
         if (prop.first == "mult") continue;
         std::ostringstream property_message;
         if (prop.second.type == "TEXT") {
            property_message << prop.second.value;
            if (!prop.second.unit.is_empty()) property_message << " " << prop.second.unit;
         } else
            property_message << get(prop.first).get();
         property_messages.push_back(property_message.str());
      }
      if (is_uncertain()) {
         std::ostringstream property_message;
         property_message << "uncertain decay tag: " << funcertain_decay;
         property_messages.push_back(property_message.str());
      }
      if (_option.contains("levto")) {
         std::ostringstream property_message;
         property_message << "final level: " << flevelto->get_spin_parity_str();
 
         tkmeasure final_energy_print = *flevelto->get_energy_measure();
         final_energy_print.set_type(", E");
         property_message << &final_energy_print;
         property_messages.push_back(property_message.str());
      }
      const std::string decay_str = decay_message.str();
      const size_t line_offset = (_option.contains("quiet") ? 16 : 13) + decay_str.length() + 1;
 
      glog << decay_str;
      if (!property_messages.empty()) {
         const std::string property_prefix = "| ";
         glog << " " << property_messages.front();
         for (size_t i = 1; i < property_messages.size(); ++i) {
            glog << "\n"
                 << std::string(line_offset, ' ') << property_prefix;
            for (char c : property_messages.at(i)) {
               glog << c;
               if (c == '\n') glog << std::string(line_offset, ' ') << property_prefix;
            }
         }
      }
      glog << do_endl;
      if (has_comment() && _option.contains("com")) {
         const size_t comment_prefix_size = 13;
         const size_t property_prefix_size = 2;
         const size_t comment_start = line_offset + property_prefix_size;
         const size_t comment_offset = comment_start > comment_prefix_size ? comment_start - comment_prefix_size : 0;
         const std::string first_indent(comment_offset, ' ');
         glog << comment << first_indent << wrap_text(get_comment(), comment_start, comment_start) << 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);
   else if (_struc.err_low > 0. || _struc.err_high > 0.)
      RI->set_error(_struc.err_low, _struc.err_high);
   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);
   else if (_struc.err_low > 0. || _struc.err_high > 0.)
      CC->set_error(_struc.err_low, _struc.err_high);
   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();
}