rootoutput.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2020
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_ROOTOUTPUT_H_
#define SRC_INCLUDE_SMASH_ROOTOUTPUT_H_
 
#include <memory>
#include <string>
#include <vector>
 
#include <boost/filesystem.hpp>
#include "TFile.h"
#include "TTree.h"
 
#include "configuration.h"
#include "forwarddeclarations.h"
#include "outputinterface.h"
#include "outputparameters.h"
 
namespace smash {
class Particles;
 
class RootOutput : public OutputInterface {
 public:
  RootOutput(const bf::path &path, const std::string &name,
             const OutputParameters &out_par);
 
  ~RootOutput();
 
  void at_eventstart(const Particles &particles, const int event_number,
                     const EventInfo &event) override;
  void at_eventend(const Particles &particles, const int event_number,
                   const EventInfo &event) override;
  void at_intermediate_time(const Particles &particles,
                            const std::unique_ptr<Clock> &clock,
                            const DensityParameters &dens_param,
                            const EventInfo &event) override;
  void at_interaction(const Action &action, const double density) override;
 
 private:
  const bf::path filename_;
  bf::path filename_unfinished_;
  std::unique_ptr<TFile> root_out_file_;
  TTree *particles_tree_;
  TTree *collisions_tree_;
  template <typename T>
  void particles_to_tree(T &particles);
  void collisions_to_tree(const ParticleList &incoming,
                          const ParticleList &outgoing, const double weight,
                          const double partial_weight);
  int output_counter_ = 0;
  int current_event_ = 0;
 
  static const int max_buffer_size_;
 
  std::vector<double> p0_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> px_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> py_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> pz_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> t_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> x_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> y_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> z_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> formation_time_ =
      std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> xsec_factor_ = std::vector<double>(max_buffer_size_, 0.0);
  std::vector<double> time_last_coll_ =
      std::vector<double>(max_buffer_size_, 0.0);
  std::vector<int> pdgcode_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> charge_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> coll_per_part_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> proc_id_origin_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> proc_type_origin_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> pdg_mother1_ = std::vector<int>(max_buffer_size_, 0);
  std::vector<int> pdg_mother2_ = std::vector<int>(max_buffer_size_, 0);
  int npart_, tcounter_, ev_, nin_, nout_, test_p_;
  double wgt_, par_wgt_, impact_b_, modus_l_, current_t_;
  double E_kinetic_tot_, E_fields_tot_, E_tot_;
  bool empty_event_;
 
  bool write_collisions_;
 
  bool write_particles_;
 
  bool write_initial_conditions_;
 
  OutputOnlyFinal particles_only_final_;
 
  int autosave_frequency_;
 
  const bool part_extended_;
  const bool coll_extended_;
  const bool ic_extended_;
 
  void init_trees();
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_ROOTOUTPUT_H_