RootMaterialTrackWriter.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-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 "Acts/Definitions/Algebra.hpp"
#include "ActsExamples/Framework/ProcessCode.hpp"
#include "ActsExamples/Framework/WriterT.hpp"
#include <Acts/Propagator/MaterialInteractor.hpp>
#include <Acts/Utilities/Logger.hpp>

#include <cstddef>
#include <cstdint>
#include <mutex>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

class TFile;
class TTree;
namespace ActsExamples {
struct AlgorithmContext;
}  // namespace ActsExamples

namespace Acts {
// Using some short hands for Recorded Material
using RecordedMaterial = MaterialInteractor::result_type;
// And recorded material track
// - this is start:  position, start momentum
//   and the Recorded material
using RecordedMaterialTrack =
    std::pair<std::pair<Acts::Vector3, Acts::Vector3>, RecordedMaterial>;
}  // namespace Acts

namespace ActsExamples {

class RootMaterialTrackWriter
    : public WriterT<std::unordered_map<size_t, Acts::RecordedMaterialTrack>> {
 public:
  struct Config {
    std::string collection =
        "material-tracks";                     
    std::string filePath = "";                 
    std::string fileMode = "RECREATE";         
    std::string treeName = "material-tracks";  

    bool recalculateTotals = false;
    bool prePostStep = false;
    bool storeSurface = false;
    bool storeVolume = false;
    bool collapseInteractions = false;
  };

  RootMaterialTrackWriter(const Config& config,
                          Acts::Logging::Level level = Acts::Logging::INFO);

  ~RootMaterialTrackWriter() override;

  ActsExamples::ProcessCode finalize() override;

  const Config& config() const { return m_cfg; }

 protected:
  // This implementation holds the actual writing method
  ProcessCode writeT(
      const AlgorithmContext& ctx,
      const std::unordered_map<size_t, Acts::RecordedMaterialTrack>&
          materialtracks) override;

 private:
  Config m_cfg;
  std::mutex m_writeMutex;
  TFile* m_outputFile = nullptr;
  TTree* m_outputTree = nullptr;

  uint32_t m_eventId = 0;

  float m_v_x = 0;    
  float m_v_y = 0;    
  float m_v_z = 0;    
  float m_v_px = 0;   
  float m_v_py = 0;   
  float m_v_pz = 0;   
  float m_v_phi = 0;  
  float m_v_eta = 0;  
  float m_tX0 = 0;    
  float m_tL0 = 0;    

  std::vector<float> m_step_sx;      
  std::vector<float> m_step_sy;      
  std::vector<float> m_step_sz;      
  std::vector<float> m_step_x;       
  std::vector<float> m_step_y;       
  std::vector<float> m_step_z;       
  std::vector<float> m_step_ex;      
  std::vector<float> m_step_ey;      
  std::vector<float> m_step_ez;      
  std::vector<float> m_step_dx;      
  std::vector<float> m_step_dy;      
  std::vector<float> m_step_dz;      
  std::vector<float> m_step_length;  
  std::vector<float> m_step_X0;      
  std::vector<float> m_step_L0;      
  std::vector<float> m_step_A;       
  std::vector<float> m_step_Z;       
  std::vector<float> m_step_rho;     

  std::vector<std::uint64_t>
      m_sur_id;  
  std::vector<int32_t>
      m_sur_type;              
  std::vector<float> m_sur_x;  

  std::vector<float> m_sur_y;  

  std::vector<float> m_sur_z;  

  std::vector<float>
      m_sur_pathCorrection;  

  std::vector<float>
      m_sur_range_min;  
  std::vector<float>
      m_sur_range_max;  

  std::vector<std::uint64_t>
      m_vol_id;  
};

}  // namespace ActsExamples