tklevel_scheme.h

/********************************************************************************
 *   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                                               *
 ********************************************************************************/
 
#ifndef tklevel_scheme_H
#define tklevel_scheme_H
 
#include <algorithm>
#include <functional>
#include <iterator>
#include <map>
#include <vector>
 
#include "tkn_config.h"
#include "tklevel.h"
#include "tkdecay.h"
 
#ifdef HAS_ROOT
#include "TClass.h"
#endif
 
namespace tkn {

class tkdataset {
 
   friend class tklevel;
   friend class tklevel_scheme;
 
protected:
   int fid{};
   int fA{};
   int fZ{};
   tkstring fname{};
   tkstring fnucleus{};
   tkstring fdataset_comment{};
   tkstring fdataset_date{};
   tkstring fdataset_source{};
 
   std::vector<shared_ptr<tklevel>> flevels;
   std::vector<shared_ptr<tkdecay>> fdecays;
   std::map<int, shared_ptr<tklevel>> fmapoflevels;
 
   bool floaded = false;
 
   map<int, shared_ptr<tklevel>> fyrastmap_exact; // 2J -> level
   map<int, shared_ptr<tklevel>> fyrastmap_uncertain;
 
public:
   tkdataset(const tkstring &_nuc, int _zz, int _aa, const tkstring &_name, int _id) : fid(_id), fA(_aa), fZ(_zz), fname(_name), fnucleus(_nuc) {}
   tkdataset() = default;
   virtual ~tkdataset() = default;

   int get_id() const { return fid; }
   const tkstring &get_name() const { return fname; }
   const tkstring &get_nucleus_name() const { return fnucleus; }
   const tkstring &get_comment() const { return fdataset_comment; }
   bool has_comment() const { return !fdataset_comment.is_empty(); }
   const tkstring &get_date() const { return fdataset_date; }
   bool has_date() const { return !fdataset_date.is_empty(); }
   const tkstring &get_source() const { return fdataset_source; }
   bool is_xundl() const { return fdataset_source == "XUNDL"; }

   shared_ptr<tklevel> add_level(double _ener, double _unc, tkstring _unit, tkstring _jpistr);

   shared_ptr<tkgammadecay> add_gamma_decay(shared_ptr<tklevel> _lvlfrom, shared_ptr<tklevel> _lvlto, double _ener = 0., double _unc = 0.);
 
protected:
   void load_dataset();
   const std::vector<shared_ptr<tklevel>> &get_levels() { return flevels; }
   const std::vector<shared_ptr<tkdecay>> &get_decays() { return fdecays; }

   void check_yrast(shared_ptr<tklevel> _lvl);

   void print(const tkstring &_data, const tkstring &_option = "");
};

class tklevel_scheme {
 
protected:
   std::map<tkstring, int> fmap_of_dataset_name_id;
   std::map<int, shared_ptr<tkdataset>> fmap_of_dataset;
 
   bool floaded = false;
 
   int fdatasetid{};
   tkstring fnucleus;
 
   int fA, fZ;
 
public:
   tklevel_scheme(const tkstring &_nuc, int _zz, int _aa, bool _load_default_dataset = true);
   virtual ~tklevel_scheme() = default;

   bool select_dataset(const tkstring &_dataset_name);
   bool select_dataset(int _dataset_id = 0);

   shared_ptr<tklevel> get_ground_state();

   const shared_ptr<tkdataset> &get_dataset() { return fmap_of_dataset[fdatasetid]; }
   const std::map<int, shared_ptr<tkdataset>> &get_datasets() const { return fmap_of_dataset; }

   const std::vector<shared_ptr<tklevel>> &get_levels() { return fmap_of_dataset[fdatasetid]->get_levels(); }
   std::vector<shared_ptr<tklevel>> get_levels(std::function<bool(shared_ptr<tklevel>)> const &_selection);

   const std::vector<shared_ptr<tkdecay>> &get_decays() { return fmap_of_dataset[fdatasetid]->get_decays(); }
   std::vector<shared_ptr<tkdecay>> get_decays(std::function<bool(shared_ptr<tkdecay>)> const &_selection);

   template <typename T>
   const std::vector<shared_ptr<T>> get_decays()
   {
      std::vector<shared_ptr<T>> decays;
      for (const auto &dec : get_decays()) {
         auto test = dynamic_pointer_cast<T>(dec);
         if (test) {
            shared_ptr<T> gam = dynamic_pointer_cast<T>(dec);
            decays.push_back(gam);
         }
      }
      return decays;
   }

   template <typename T>
   const std::vector<shared_ptr<T>> get_decays(const std::function<bool(shared_ptr<T>)> &_selection)
   {
      vector<shared_ptr<T>> res;
      const auto &decays = get_decays<T>();
      std::copy_if(decays.begin(), decays.end(), std::back_inserter(res),
                   [&_selection](const auto &dec) { return _selection(dec); });
      return res;
   }

   shared_ptr<tklevel> get_level(const tkstring &_name, bool _exact = true);

   shared_ptr<tklevel> get_level(double _energy, tkstring _offset = "");
   shared_ptr<tklevel> get_level(double _energy, const char *_offset)
   { return get_level(_energy, tkstring(_offset)); }

   template <typename T>
   const shared_ptr<T> get_decay(const tkstring &_name, bool _exact = true)
   {
      std::vector<tkstring> lvls = _name.tokenize_from_string("->");
      if (lvls.size() != 2) {
         glog << warning << "get_decay(" << _name << ") -- wrong syntax (ex: 2+1->0+1)" << do_endl;
         return nullptr;
      }
      shared_ptr<tklevel> lvl_from = get_level(lvls.at(0), _exact);
      shared_ptr<tklevel> lvl_to = get_level(lvls.at(1), _exact);
      if (!lvl_from) {
         glog << warning << "get_decay(" << _name << ") -- " << lvls.at(0) << " level not found" << do_endl;
         return nullptr;
      }
      if (!lvl_to) {
         glog << warning << "get_decay(" << _name << ") -- " << lvls.at(1) << " level not found" << do_endl;
         return nullptr;
      }
      int lvl_from_id = lvl_from->get_id();
      int lvl_to_id = lvl_to->get_id();
      for (auto dec : get_decays<T>()) {
         if ((dec->get_level_from_id() == lvl_from_id) && (dec->get_level_to_id() == lvl_to_id)) return dec;
      }
      return nullptr;
   }

   template <typename T>
   const shared_ptr<T> get_decay(double _energy)
   {
      shared_ptr<T> clostest_dec;
      double best_ediff = 1e6;
      for (auto &dec : get_decays<T>()) {
         double ediff = abs(dec->get_energy() - _energy);
         if (ediff < best_ediff) {
            best_ediff = ediff;
            clostest_dec = dec;
         }
      }
      return clostest_dec;
   }

   void print(const tkstring &_data = "", const tkstring &_option = "");
 
private:
   void init(bool _load_default_dataset);
 
#ifdef HAS_ROOT
   ClassDef(tklevel_scheme, 0);
#endif
};
} // namespace tkn
 
#endif