tklevel.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_H
#define tklevel_H
 
#include "tkn_config.h"
 
#ifdef HAS_ROOT
#include "TClass.h"
#endif
 
#include "tkdb_table.h"
#include "tkproperty_list.h"
#include "tkmeasure.h"
#include "tkspin_parity.h"
#include "tkdecay.h"
 
namespace tkn {

class tklevel : public tkproperty_list {
   friend class tkdataset;
   friend class tklevel_scheme;
 
protected:
   int flevel_id = -1;
   tkstring fbelongs_to_nucleus = "";
 
   shared_ptr<tkspin_parity> fspin_parity;
 
   bool fis_stable = false;
   bool fis_isomer = false;
   int fisomer_level = 0;
 
   bool fisYrast_exact = false;
   bool fisYrast_uncertain = false;
 
   vector<shared_ptr<tkdecay>> fdecays_down;
   vector<shared_ptr<tkdecay>> fdecays_up;
 
   tkstring fcomment{};
   bool fhas_comment = false;
 
   tkstring funcertain_level{};
 
   tkstring fenergy_offset = "";
 
public:
   tklevel(int _id, const tkdb_table::measure_data_struct &_struc);
   virtual ~tklevel() override = default;

   shared_ptr<tkmeasure> get_energy_measure() { return get("energy"); }
   double get_energy(const tkunit_manager::units_keys _unit = tkunit_manager::units_keys::keV, bool _with_offset = false);

   bool is_energy_offset() { return (!fenergy_offset.is_empty()); }
   tkstring get_offset_bandhead() { return fenergy_offset; }

   shared_ptr<tkmeasure> get_lifetime_measure() { return get("lifetime"); }
   double get_lifetime(const tkunit_manager::units_keys _unit = tkunit_manager::units_keys::s);
   tkstring get_lifetime_str();

   shared_ptr<tkmeasure> get_magnetic_dipole_measure() { return get("magnetic_dipole"); }
   double get_magnetic_dipole();

   shared_ptr<tkmeasure> get_electric_quadrupole_measure() { return get("electric_quadrupole"); }
   double get_electric_quadrupole();

   shared_ptr<tkspin_parity> get_spin_parity() { return fspin_parity; }
   const tkstring &get_spin_parity_str() { return fspin_parity->get_jpi_str(); }

   const vector<shared_ptr<tkdecay>> &get_decays_down() const { return fdecays_down; }
   const vector<shared_ptr<tkdecay>> &get_decays_up() const { return fdecays_up; }

   bool is_stable() { return fis_stable; }
   bool is_isomer() { return fisomer_level; }
   int get_isomer_level() { return fisomer_level; }

   bool is_yrast(bool _with_tentative = false);

   bool has_comment() { return fhas_comment; }
   const tkstring &get_comment() { return fcomment; }
   bool is_uncertain() { return !funcertain_level.is_empty(); }

   void print(const tkstring &_option = "");

   int get_id() { return flevel_id; }

   void set_energy_offset(const tkstring &_offset) { fenergy_offset = _offset; }

   void set_lifetime(tkdb_table::measure_data_struct &_struc);
   void set_magnetic_dipole(tkdb_table::measure_data_struct &_struc);
   void set_electric_quadrupole(tkdb_table::measure_data_struct &_struc);
   void set_jpi(double _spin, int _parity, const tkstring &_jpi_str);

   void add_decay_down(shared_ptr<tkdecay> _dec) { fdecays_down.push_back(_dec); }
   void add_decay_up(shared_ptr<tkdecay> _dec) { fdecays_up.push_back(_dec); }

   void set_comment(const tkstring &_comment)
   {
      fcomment = _comment;
      fhas_comment = true;
   }

   void set_uncertain_level(const tkstring &_uncertain) { funcertain_level = _uncertain; }
 
#ifdef HAS_ROOT
   ClassDefOverride(tklevel, 0);
#endif
};
} // namespace tkn
 
#endif