DecayScheme.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 <iostream>
#include <memory>
#include <vector>
 
#include "marley/Level.hh"
 
namespace HepMC3 {
  class GenEvent;
  class GenParticle;
}
 
namespace marley {
 
  class Generator;

  class DecayScheme {
 
    public:

      enum class FileFormat { native, talys };
 
      inline DecayScheme() : Z_(0), A_(0) {}

      DecayScheme(int Z, int A);

      DecayScheme(int Z, int A, const std::string& filename,
        FileFormat format = FileFormat::talys);

      inline const std::vector<std::unique_ptr<marley::Level> >&
        get_levels() const;

      marley::Level& add_level(const marley::Level& level);

      marley::Level* get_pointer_to_closest_level(double E_level);

      void do_cascade( marley::Level& initial_level, HepMC3::GenEvent& event,
        marley::Generator& gen,
        std::shared_ptr< HepMC3::GenParticle >& residue );

      inline int Z() const;

      inline int A() const;

      void print(std::ostream& out = std::cout) const;

      void read_from_stream(std::istream& in);

      void print_latex_table(std::ostream& ostr = std::cout);

      void print_report(std::ostream& ostr = std::cout) const;

      int pdg() const;
 
    protected:
 
      int Z_; 
      int A_; 

      std::vector< std::unique_ptr<marley::Level> > levels_;

      size_t level_lower_bound_index(double Ex);
 
    private:

      void parse(const std::string& filename,
        FileFormat ff = FileFormat::talys);
 
      // Functions called by the constructor to parse the
      // different nuclear data formats accepted by this class

      void parse_talys(const std::string& filename);

      void parse_native(const std::string& filename);
      // Add more formats as needed
  };
 
  // Inline function definitions
  inline int DecayScheme::Z() const { return Z_; }
  inline int DecayScheme::A() const { return A_; }
 
  inline const std::vector<std::unique_ptr<marley::Level> >&
    DecayScheme::get_levels() const { return levels_; }
}
 
inline std::istream& operator>>(std::istream& in, marley::DecayScheme& ds)
{
  ds.read_from_stream(in);
  return in;
}
 
inline std::ostream& operator<<(std::ostream& out,
  const marley::DecayScheme& ds)
{
  ds.print(out);
  return out;
}