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);
 
      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 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);
 
      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_; 
 
      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 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_);
  }
}