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 marley {
 
  class Event;
  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, marley::Event& event,
        marley::Generator& gen, int qIon);
 
      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;
}