Level.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
#include <random>
 
#include "marley/Gamma.hh"
#include "marley/IteratorToPointerMember.hh"
#include "marley/Parity.hh"
 
namespace marley {
 
  class Generator;

  class Level {
    public:

      Level( double E, int twoJ, marley::Parity pi, double half_life );

      inline const std::vector<marley::Gamma>& gammas() const;

      inline std::vector<marley::Gamma>& gammas();

      inline double energy() const;
      inline void set_energy(double E);

      inline int twoJ() const;
      inline void set_twoJ(int twoJ);

      inline marley::Parity parity() const;
      inline void set_parity(marley::Parity pi);

      inline double half_life() const;
      inline void set_half_life( double half_life );

      inline bool has_gammas() const;

      marley::Gamma& add_gamma(const marley::Gamma& gamma);

      marley::Gamma& add_gamma(double energy, double branching_ratio,
        marley::Level* end_lev = nullptr);

      void clear_gammas();

      const marley::Gamma* sample_gamma( marley::Generator& gen,
        double* prob_ptr = nullptr );

      std::string spin_parity_string() const;

      template<typename It> inline static marley::IteratorToPointerMember<It,
        double> make_energy_iterator(It it);
 
    private:
 
      double energy_; 

      int twoJ_;
 
      marley::Parity parity_; 

      double half_life_;

      std::vector< marley::Gamma > gammas_;

      std::discrete_distribution< size_t > gamma_dist_;

      void update_gamma_distribution();
  };
 
  // Inline function definitions
  inline double Level::energy() const { return energy_; }
  inline void Level::set_energy( double E ) { energy_ = E; }
 
  inline int Level::twoJ() const { return twoJ_; }
  inline void Level::set_twoJ(int twoJ) { twoJ_ = twoJ; }
 
  inline marley::Parity Level::parity() const { return parity_; }
  inline void Level::set_parity( marley::Parity pi ) { parity_ = pi; }
 
  inline double Level::half_life() const { return half_life_; }
  inline void Level::set_half_life( double half_life )
    { half_life_ = half_life; }
 
  inline const std::vector< marley::Gamma >& Level::gammas() const
    { return gammas_; }
  inline std::vector< marley::Gamma >& Level::gammas() { return gammas_; }
 
  inline bool Level::has_gammas() const { return !gammas_.empty(); }
 
  template< typename It > inline marley::IteratorToPointerMember< It,
    double > Level::make_energy_iterator( It it )
  {
    return marley::IteratorToPointerMember< It, double >( it,
      &marley::Level::energy_ );
  }
}