RootTrajectoryWriter.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file RootTrajectoryWriter.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2019 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <mutex>
#include <vector>

#include "ACTFW/EventData/Track.hpp"
#include "ACTFW/Framework/WriterT.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"

class TFile;
class TTree;

namespace FW {

class RootTrajectoryWriter final : public WriterT<TrajectoryContainer> {
 public:
  struct Config {
    std::string inputParticles;     
    std::string inputTrajectories;  
    std::string outputDir;          
    std::string outputFilename = "tracks.root";  
    std::string outputTreename = "tracks";       
    std::string fileMode = "RECREATE";           
    TFile* rootFile = nullptr;                   
  };

  RootTrajectoryWriter(const Config& cfg, Acts::Logging::Level lvl);

  ~RootTrajectoryWriter() final override;

  ProcessCode endRun() final override;

 protected:
  ProcessCode writeT(const AlgorithmContext& ctx,
                     const TrajectoryContainer& trajectories) final override;

 private:
  Config m_cfg;             
  std::mutex m_writeMutex;  
  TFile* m_outputFile{nullptr};  
  TTree* m_outputTree{nullptr};  
  int m_eventNr{0};              
  int m_trajNr{0};               

  unsigned long m_t_barcode{0};  
  int m_t_charge{0};             
  float m_t_time{0};             
  float m_t_vx{-99.};            
  float m_t_vy{-99.};            
  float m_t_vz{-99.};            
  float m_t_px{-99.};            
  float m_t_py{-99.};            
  float m_t_pz{-99.};            
  float m_t_theta{-99.};         
  float m_t_phi{-99.};           
  float m_t_pT{-99.};            
  float m_t_eta{-99.};           

  std::vector<float> m_t_x;  
  std::vector<float> m_t_y;  
  std::vector<float> m_t_z;  
  std::vector<float> m_t_r;  
  std::vector<float>
      m_t_dx;  
  std::vector<float>
      m_t_dy;  
  std::vector<float>
      m_t_dz;  

  std::vector<float> m_t_eLOC0;   
  std::vector<float> m_t_eLOC1;   
  std::vector<float> m_t_ePHI;    
  std::vector<float> m_t_eTHETA;  
  std::vector<float> m_t_eQOP;    
  std::vector<float> m_t_eT;      

  int m_nStates{0};                 
  int m_nMeasurements{0};           
  std::vector<int> m_volumeID;      
  std::vector<int> m_layerID;       
  std::vector<int> m_moduleID;      
  std::vector<float> m_lx_hit;      
  std::vector<float> m_ly_hit;      
  std::vector<float> m_x_hit;       
  std::vector<float> m_y_hit;       
  std::vector<float> m_z_hit;       
  std::vector<float> m_res_x_hit;   
  std::vector<float> m_res_y_hit;   
  std::vector<float> m_err_x_hit;   
  std::vector<float> m_err_y_hit;   
  std::vector<float> m_pull_x_hit;  
  std::vector<float> m_pull_y_hit;  
  std::vector<int> m_dim_hit;       

  bool m_hasFittedParams;        
  float m_eLOC0_fit{-99.};       
  float m_eLOC1_fit{-99.};       
  float m_ePHI_fit{-99.};        
  float m_eTHETA_fit{-99.};      
  float m_eQOP_fit{-99.};        
  float m_eT_fit{-99.};          
  float m_err_eLOC0_fit{-99.};   
  float m_err_eLOC1_fit{-99.};   
  float m_err_ePHI_fit{-99.};    
  float m_err_eTHETA_fit{-99.};  
  float m_err_eQOP_fit{-99.};    
  float m_err_eT_fit{-99.};      

  int m_nPredicted{0};      
  std::vector<bool> m_prt;  
  std::vector<float> m_eLOC0_prt;       
  std::vector<float> m_eLOC1_prt;       
  std::vector<float> m_ePHI_prt;        
  std::vector<float> m_eTHETA_prt;      
  std::vector<float> m_eQOP_prt;        
  std::vector<float> m_eT_prt;          
  std::vector<float> m_res_eLOC0_prt;   
  std::vector<float> m_res_eLOC1_prt;   
  std::vector<float> m_res_ePHI_prt;    
  std::vector<float> m_res_eTHETA_prt;  
  std::vector<float> m_res_eQOP_prt;    
  std::vector<float> m_res_eT_prt;      
  std::vector<float> m_err_eLOC0_prt;   
  std::vector<float> m_err_eLOC1_prt;   
  std::vector<float> m_err_ePHI_prt;    
  std::vector<float> m_err_eTHETA_prt;  
  std::vector<float> m_err_eQOP_prt;    
  std::vector<float> m_err_eT_prt;      
  std::vector<float> m_pull_eLOC0_prt;  
  std::vector<float> m_pull_eLOC1_prt;  
  std::vector<float> m_pull_ePHI_prt;   
  std::vector<float> m_pull_eTHETA_prt;  
  std::vector<float> m_pull_eQOP_prt;    
  std::vector<float> m_pull_eT_prt;      
  std::vector<float> m_x_prt;            
  std::vector<float> m_y_prt;            
  std::vector<float> m_z_prt;            
  std::vector<float> m_px_prt;           
  std::vector<float> m_py_prt;           
  std::vector<float> m_pz_prt;           
  std::vector<float> m_eta_prt;          
  std::vector<float> m_pT_prt;           

  int m_nFiltered{0};              
  std::vector<bool> m_flt;         
  std::vector<float> m_eLOC0_flt;  
  std::vector<float> m_eLOC1_flt;  
  std::vector<float> m_ePHI_flt;   
  std::vector<float> m_eTHETA_flt;       
  std::vector<float> m_eQOP_flt;         
  std::vector<float> m_eT_flt;           
  std::vector<float> m_res_eLOC0_flt;    
  std::vector<float> m_res_eLOC1_flt;    
  std::vector<float> m_res_ePHI_flt;     
  std::vector<float> m_res_eTHETA_flt;   
  std::vector<float> m_res_eQOP_flt;     
  std::vector<float> m_res_eT_flt;       
  std::vector<float> m_err_eLOC0_flt;    
  std::vector<float> m_err_eLOC1_flt;    
  std::vector<float> m_err_ePHI_flt;     
  std::vector<float> m_err_eTHETA_flt;   
  std::vector<float> m_err_eQOP_flt;     
  std::vector<float> m_err_eT_flt;       
  std::vector<float> m_pull_eLOC0_flt;   
  std::vector<float> m_pull_eLOC1_flt;   
  std::vector<float> m_pull_ePHI_flt;    
  std::vector<float> m_pull_eTHETA_flt;  
  std::vector<float> m_pull_eQOP_flt;    
  std::vector<float> m_pull_eT_flt;      
  std::vector<float> m_x_flt;            
  std::vector<float> m_y_flt;            
  std::vector<float> m_z_flt;            
  std::vector<float> m_px_flt;           
  std::vector<float> m_py_flt;           
  std::vector<float> m_pz_flt;           
  std::vector<float> m_eta_flt;          
  std::vector<float> m_pT_flt;           
  std::vector<float> m_chi2;             

  int m_nSmoothed{0};              
  std::vector<bool> m_smt;         
  std::vector<float> m_eLOC0_smt;  
  std::vector<float> m_eLOC1_smt;  
  std::vector<float> m_ePHI_smt;   
  std::vector<float> m_eTHETA_smt;       
  std::vector<float> m_eQOP_smt;         
  std::vector<float> m_eT_smt;           
  std::vector<float> m_res_eLOC0_smt;    
  std::vector<float> m_res_eLOC1_smt;    
  std::vector<float> m_res_ePHI_smt;     
  std::vector<float> m_res_eTHETA_smt;   
  std::vector<float> m_res_eQOP_smt;     
  std::vector<float> m_res_eT_smt;       
  std::vector<float> m_err_eLOC0_smt;    
  std::vector<float> m_err_eLOC1_smt;    
  std::vector<float> m_err_ePHI_smt;     
  std::vector<float> m_err_eTHETA_smt;   
  std::vector<float> m_err_eQOP_smt;     
  std::vector<float> m_err_eT_smt;       
  std::vector<float> m_pull_eLOC0_smt;   
  std::vector<float> m_pull_eLOC1_smt;   
  std::vector<float> m_pull_ePHI_smt;    
  std::vector<float> m_pull_eTHETA_smt;  
  std::vector<float> m_pull_eQOP_smt;    
  std::vector<float> m_pull_eT_smt;      
  std::vector<float> m_x_smt;            
  std::vector<float> m_y_smt;            
  std::vector<float> m_z_smt;            
  std::vector<float> m_px_smt;           
  std::vector<float> m_py_smt;           
  std::vector<float> m_pz_smt;           
  std::vector<float> m_eta_smt;          
  std::vector<float> m_pT_smt;           
};

}  // namespace FW