ROOTTreeInfo.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2019-2025  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGenRoot_ROOTTreeInfo_h
#define CepGenRoot_ROOTTreeInfo_h
 
#include <TFile.h>
#include <TTree.h>
 
#include "CepGen/Event/Event.h"
 
namespace ROOT {
  class CepGenRun {
  public:
    static constexpr const char* TREE_NAME = "run";  
 
    static CepGenRun load(TFile*, const std::string& run_tree = TREE_NAME);
    static CepGenRun load(const std::string&, const std::string& run_tree = TREE_NAME);
 
    double sqrt_s{-1.};                
    double xsect{-1.};                 
    double errxsect{-1.};              
    unsigned int num_events{0};        
    unsigned int litigious_events{0};  
    std::string process_name;          
    std::string process_parameters;    
 
    explicit CepGenRun();
    void clear();                                                       
    void create();                                                      
    inline TTree* tree() const { return tree_.get(); }                  
    void fill() const;                                                  
    void attach(TFile* file, const std::string& run_tree = TREE_NAME);  
    void attach(const std::string& filename, const std::string& run_tree = TREE_NAME) {
      attach(TFile::Open(filename.data()), run_tree);
    }
    void attach(const std::string& filename, const std::string& run_tree = TREE_NAME) {…}
 
  private:
    std::shared_ptr<TTree> tree_;  
  };
 
  class CepGenEvent {
  public:
    CepGenEvent() { clear(); }
 
    // book a large enough number to allow the large multiplicity of excited proton fragmentation products
    static constexpr size_t MAX_PART = 5000;            
    static constexpr const char* TREE_NAME = "events";  
 
    static CepGenEvent load(TFile*, const std::string& events_tree = TREE_NAME);
    static CepGenEvent load(const std::string&, const std::string& events_tree = TREE_NAME);
 
    cepgen::Event::EventMetadata metadata;
    float gen_time{-1.};        
    float tot_time{-1.};        
    float weight{-1.};          
    int np{0};                  
    double pt[MAX_PART];        
    double eta[MAX_PART];       
    double phi[MAX_PART];       
    double rapidity[MAX_PART];  
    double E[MAX_PART];         
    double m[MAX_PART];         
    double charge[MAX_PART];    
    int pdg_id[MAX_PART];       
    int parent1[MAX_PART];      
    int parent2[MAX_PART];      
    int stable[MAX_PART];       
    int role[MAX_PART];         
    int status[MAX_PART];       
 
    void clear();                                
    TTree* tree() const { return tree_.get(); }  
    void create();                               
 
    void attach();                                                      
    void attach(TFile* f, const std::string& events_tree = TREE_NAME);  
    void attach(const std::string& filename, const std::string& events_tree = TREE_NAME);
 
    // direct cepgen::Event I/O helpers
 
    void fill(const cepgen::Event&, bool compress = false);  
    bool next(cepgen::Event&);                               
 
  private:
    std::shared_ptr<TTree> tree_;  
    std::unique_ptr<TFile> file_;
    bool tree_attached_{false};
    unsigned long long num_read_events_{0ull};
  };
}  // namespace ROOT
 
#endif
    void create();                                {…}
  class CepGenEvent {…};
    void fill() const;                                                   {…}
  class CepGenRun {…};
namespace ROOT {…}