Event.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
 
// Standard library includes
#include <string>
#include <vector>
 
// MARLEY includes
#include "marley/Parity.hh"
#include "marley/Particle.hh"
 
namespace marley {
 
  #ifndef __MAKECINT__
  // TODO: Make these into an enum at some point
  constexpr int HEPEVT_INITIAL_STATE_STATUS_CODE = 3;
  constexpr int HEPEVT_FINAL_STATE_STATUS_CODE = 1;
  constexpr int HEPEVT_MARLEY_INFO_STATUS_CODE = 11;
 
  // Forward declare the JSON class so that we can define a function that
  // creates a JSON representation of a Event. Hide the JSON class from
  // rootcint so that we won't have issues using marley::Event objects with
  // ROOT 5.
  class JSON;
  #endif
 
  class Event {
 
    public:
 
      Event(double Ex = 0.);
 
      Event(const marley::Particle& a,
        const marley::Particle& b, const marley::Particle& c,
        const marley::Particle& d, double Ex, int twoJ,
        const marley::Parity& P);
 
      // Destructor
      ~Event();
 
      Event(const Event& other_event);
 
      Event(Event&& other_event);
 
      Event& operator=(const Event& other_event);
 
      Event& operator=(Event&& other_event);
 
      const marley::Particle& projectile() const;
      const marley::Particle& target() const;
      const marley::Particle& ejectile() const;
      const marley::Particle& residue() const;
 
      marley::Particle& projectile();
      marley::Particle& target();
      marley::Particle& ejectile();
      marley::Particle& residue();
 
      inline const std::vector<marley::Particle*>& get_initial_particles()
        const;
 
      inline std::vector<marley::Particle*>& get_initial_particles();
 
      inline const std::vector<marley::Particle*>& get_final_particles() const;
 
      inline std::vector<marley::Particle*>& get_final_particles();
 
      inline size_t initial_particle_count() const;
 
      inline size_t final_particle_count() const;
 
      inline const marley::Particle& initial_particle( size_t idx ) const;
 
      inline const marley::Particle& final_particle( size_t idx ) const;
 
      inline double Ex() const;
 
      inline int twoJ() const;
 
      inline marley::Parity parity() const;
 
      void add_initial_particle(const marley::Particle& p);
 
      void add_final_particle(const marley::Particle& p);
 
      void write_hepevt(size_t event_num, double flux_avg_tot_xsec,
        std::ostream& out) const;
 
      void print(std::ostream& out) const;
 
      void print_human_readable(std::ostream& out, int num = -1) const;
 
      void read(std::istream& in);
 
      bool read_hepevt(std::istream& in, double* flux_avg_tot_xsec = nullptr);
 
      void clear();
 
      #ifndef __MAKECINT__
      marley::JSON to_json() const;
 
      void from_json(const marley::JSON& json);
      #endif
 
    protected:
 
      std::vector<marley::Particle*> initial_particles_;
 
      std::vector<marley::Particle*> final_particles_;
 
      double Ex_;
 
      int twoJ_;
 
      Parity parity_;
 
      void dump_hepevt_particle(const marley::Particle& p, std::ostream& os,
        int status, int jmohep1 = 0, int jmohep2 = 0) const;
 
      void delete_particles();
  };
 
  // Inline function definitions
  inline double Event::Ex() const { return Ex_; }
  inline int Event::twoJ() const { return twoJ_; }
  inline marley::Parity Event::parity() const { return parity_; }
 
  inline const std::vector<marley::Particle*>& Event::get_initial_particles()
    const { return initial_particles_; }
 
  inline std::vector<marley::Particle*>& Event::get_initial_particles()
    { return initial_particles_; }
 
  inline const std::vector<marley::Particle*>& Event::get_final_particles()
    const { return final_particles_; }
 
  inline std::vector<marley::Particle*>& Event::get_final_particles()
    { return final_particles_; }
 
  inline size_t Event::initial_particle_count() const
    { return initial_particles_.size(); }
 
  inline size_t Event::final_particle_count() const
    { return final_particles_.size(); }
 
  inline const marley::Particle& Event::initial_particle( size_t idx ) const {
    return *initial_particles_.at( idx );
  }
 
  inline const marley::Particle& Event::final_particle( size_t idx ) const {
    return *final_particles_.at( idx );
  }
 
}
 
inline std::ostream& operator<<(std::ostream& out, const marley::Event& e) {
  e.print(out);
  return out;
}
 
inline std::istream& operator>>(std::istream& in, marley::Event& e) {
  e.read(in);
  return in;
}