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]                          *
 *                                                                              *
 *    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.          *
 ********************************************************************************/
 
#ifndef tklevel_scheme_H
#define tklevel_scheme_H
 
#include <map>
#include <vector>
#include <functional>
 
#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{};
 
    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;}
 
    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);
    virtual ~tklevel_scheme() = default;
 
    bool select_dataset(const tkstring &_dataset_name);
    bool select_dataset(int _dataset_id=0);
 
    const shared_ptr<tkdataset> &get_dataset() {return fmap_of_dataset[fdatasetid];}
    const std::map<int, shared_ptr<tkdataset>> get_datasets() {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;
        for(const auto &dec : get_decays<T>()) if(_selection(dec)) res.push_back(dec);
        return res;
    }
 
    shared_ptr<tklevel> get_level(const tkstring &_name, bool _exact=true);
 
    shared_ptr<tklevel> get_level(double _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();
 
#ifdef HAS_ROOT
    ClassDef(tklevel_scheme,0);
#endif
};
}
 
#endif