ActsMaterialTrackWriterSvc Class Reference

#include <ActsMaterialTrackWriterSvc.h>

Inheritance diagram for ActsMaterialTrackWriterSvc:

Collaboration diagram for ActsMaterialTrackWriterSvc:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
	ActsMaterialTrackWriterSvc (const std::string &name, ISvcLocator *svc)
virtual void	write (const Acts::RecordedMaterialTrack &mTrack) override

Private Member Functions
void	writerThread ()
void	doWrite (const Acts::RecordedMaterialTrack &mTrack)

Private Attributes
std::deque< Acts::RecordedMaterialTrack >	m_mTracks
std::mutex	m_writeMutex
std::thread	m_writeThread
std::atomic< bool >	m_doEnd
TFile *	p_tFile {}
TTree *	p_tree {}
float	m_v_x {}
	start global x
float	m_v_y {}
	start global y
float	m_v_z {}
	start global z
float	m_v_px {}
	start global momentum x
float	m_v_py {}
	start global momentum y
float	m_v_pz {}
	start global momentum z
float	m_v_phi {}
	start phi direction
float	m_v_eta {}
	start eta direction
float	m_tX0 {}
	thickness in X0/L0
float	m_tL0 {}
	thickness in X0/L0
std::vector< float >	m_step_sx
	step x (start) position (optional)
std::vector< float >	m_step_sy
	step y (start) position (optional)
std::vector< float >	m_step_sz
	step z (start) position (optional)
std::vector< float >	m_step_x
	step x position
std::vector< float >	m_step_y
	step y position
std::vector< float >	m_step_z
	step z position
std::vector< float >	m_step_ex
	step x (end) position (optional)
std::vector< float >	m_step_ey
	step y (end) position (optional)
std::vector< float >	m_step_ez
	step z (end) position (optional)
std::vector< float >	m_step_dx
	step x direction
std::vector< float >	m_step_dy
	step y direction
std::vector< float >	m_step_dz
	step z direction
std::vector< float >	m_step_length
	step length
std::vector< float >	m_step_X0
	step material x0
std::vector< float >	m_step_L0
	step material l0
std::vector< float >	m_step_A
	step material A
std::vector< float >	m_step_Z
	step material Z
std::vector< float >	m_step_rho
	step material rho
std::vector< std::uint64_t >	m_sur_id
	ID of the suface associated with the step.
std::vector< int32_t >	m_sur_type
	Type of the suface associated with the step.
std::vector< float >	m_sur_x
	x position of the center of the suface associated with the step
std::vector< float >	m_sur_y
	y position of the center of the suface associated with the step
std::vector< float >	m_sur_z
	z position of the center of the suface associated with the step
std::vector< float >	m_sur_range_min
	Min range of the suface associated with the step.
std::vector< float >	m_sur_range_max
	Max range of the suface associated with the step.
std::vector< std::uint64_t >	m_vol_id
	ID of the volume associated with the step.
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc
Gaudi::Property< std::string >	m_filePath {this, "FilePath", "MaterialTracks.root", "Output root file for charged particle"}
Gaudi::Property< std::string >	m_treeName {this, "TreeName", "material-tracks", ""}
Gaudi::Property< bool >	m_storeSurface {this, "StoreSurface", true, "Store the surface info in the root file"}
Gaudi::Property< bool >	m_storeVolume {this, "StoreVolume", true, "Store the volume info in the root file"}
Gaudi::Property< size_t >	m_maxQueueSize {this, "MaxQueueSize", 5000, "Limit the write queue to this size"}

Detailed Description

Definition at line 24 of file ActsMaterialTrackWriterSvc.h.

Constructor & Destructor Documentation

ActsMaterialTrackWriterSvc()

ActsMaterialTrackWriterSvc::ActsMaterialTrackWriterSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 25 of file ActsMaterialTrackWriterSvc.cxx.

: base_class(name, svc),
  m_trackingGeometrySvc("ActsTrackingGeometrySvc", name) {
}

Member Function Documentation

doWrite()

void ActsMaterialTrackWriterSvc::doWrite ( const Acts::RecordedMaterialTrack & mTrack )

private

Definition at line 171 of file ActsMaterialTrackWriterSvc.cxx.

{
  ATH_MSG_VERBOSE("Write to tree");
  size_t mints = mTrack.second.materialInteractions.size();
 
  // Clearing the vector first
  m_step_sx.clear();
  m_step_sy.clear();
  m_step_sz.clear();
  m_step_x.clear();
  m_step_y.clear();
  m_step_z.clear();
  m_step_ex.clear();
  m_step_ey.clear();
  m_step_ez.clear();
  m_step_dx.clear();
  m_step_dy.clear();
  m_step_dz.clear();
  m_step_length.clear();
  m_step_X0.clear();
  m_step_L0.clear();
  m_step_A.clear();
  m_step_Z.clear();
  m_step_rho.clear();
 
  if(m_storeSurface){
    m_sur_id.clear();
    m_sur_type.clear();
    m_sur_x.clear();
    m_sur_y.clear();
    m_sur_z.clear();
    m_sur_range_min.clear();
    m_sur_range_max.clear();
  }
 
  if (m_storeVolume) {
    m_vol_id.clear();
  }  
  // Reserve the vector then
  m_step_sx.reserve(mints);
  m_step_sy.reserve(mints);
  m_step_sz.reserve(mints);
  m_step_x.reserve(mints);
  m_step_y.reserve(mints);
  m_step_ez.reserve(mints);
  m_step_ex.reserve(mints);
  m_step_ey.reserve(mints);
  m_step_ez.reserve(mints);
  m_step_dx.reserve(mints);
  m_step_dy.reserve(mints);
  m_step_dz.reserve(mints);
  m_step_length.reserve(mints);
  m_step_X0.reserve(mints);
  m_step_L0.reserve(mints);
  m_step_A.reserve(mints);
  m_step_Z.reserve(mints);
  m_step_rho.reserve(mints);
 
  if(m_storeSurface){
    m_sur_id.reserve(mints);
    m_sur_type.reserve(mints);
    m_sur_x.reserve(mints);
    m_sur_y.reserve(mints);
    m_sur_z.reserve(mints);
    m_sur_range_min.reserve(mints);
    m_sur_range_max.reserve(mints);
  }
  if (m_storeVolume) {
    m_vol_id.reserve(mints);
  }  
 
  // reset the global counter
  m_tX0 = mTrack.second.materialInX0;
  m_tL0 = mTrack.second.materialInL0;
 
  // set the track information at vertex
  m_v_x   = mTrack.first.first.x();
  m_v_y   = mTrack.first.first.y();
  m_v_z   = mTrack.first.first.z();
  m_v_px  = mTrack.first.second.x();
  m_v_py  = mTrack.first.second.y();
  m_v_pz  = mTrack.first.second.z();
  m_v_phi = phi(mTrack.first.second);
  m_v_eta = eta(mTrack.first.second);
 
  // an now loop over the material
  for (auto& mint : mTrack.second.materialInteractions) {
    // The material step position information
    m_step_x.push_back(mint.position.x());
    m_step_y.push_back(mint.position.y());
    m_step_z.push_back(mint.position.z());
    m_step_dx.push_back(mint.direction.x());
    m_step_dy.push_back(mint.direction.y());
    m_step_dz.push_back(mint.direction.z());
 
    Acts::Vector3 prePos
        = mint.position - 0.5 * mint.pathCorrection * mint.direction;
    Acts::Vector3 posPos
        = mint.position + 0.5 * mint.pathCorrection * mint.direction;
    m_step_sx.push_back(prePos.x());
    m_step_sy.push_back(prePos.y());
    m_step_sz.push_back(prePos.z());
    m_step_ex.push_back(posPos.x());
    m_step_ey.push_back(posPos.y());
    m_step_ez.push_back(posPos.z());
 
    if (m_storeSurface) {
      const Acts::Surface* surface = mint.surface;
      Acts::GeometryIdentifier layerID;
      if (surface) {
        const ActsTrk::GeometryContext& gctx{m_trackingGeometrySvc->getNominalContext()};
        auto sfIntersection = surface
          ->intersect(gctx.context(), mint.position,
                      mint.direction, Acts::BoundaryTolerance::None())
          .closest();
        layerID = surface->geometryId();
        m_sur_id.push_back(layerID.value());
        m_sur_type.push_back(surface->type());
        m_sur_x.push_back(sfIntersection.position().x());
        m_sur_y.push_back(sfIntersection.position().y());
        m_sur_z.push_back(sfIntersection.position().z());
 
        const Acts::SurfaceBounds& surfaceBounds = surface->bounds();
        const Acts::RadialBounds* radialBounds =
            dynamic_cast<const Acts::RadialBounds*>(&surfaceBounds);
        const Acts::CylinderBounds* cylinderBounds =
            dynamic_cast<const Acts::CylinderBounds*>(&surfaceBounds);
 
        if (radialBounds) {
          m_sur_range_min.push_back(radialBounds->rMin());
          m_sur_range_max.push_back(radialBounds->rMax());
        } else if (cylinderBounds) {
          m_sur_range_min.push_back(
              -cylinderBounds->get(Acts::CylinderBounds::eHalfLengthZ));
          m_sur_range_max.push_back(
              cylinderBounds->get(Acts::CylinderBounds::eHalfLengthZ));
        } else {
          m_sur_range_min.push_back(0);
          m_sur_range_max.push_back(0);
        }
      } else {
        m_sur_id.push_back(layerID.withVolume(0)
                           .withBoundary(0)
                           .withLayer(0)
                           .withApproach(0)
                           .withSensitive(0)
                           .value());
        m_sur_type.push_back(-1);
 
        m_sur_x.push_back(0);
        m_sur_y.push_back(0);
        m_sur_z.push_back(0);
        m_sur_range_min.push_back(0);
        m_sur_range_max.push_back(0);
      }
    }
    // store volume information
    if (m_storeVolume) {
      const Acts::InteractionVolume& volume = mint.volume;
      Acts::GeometryIdentifier vlayerID;
      if (!volume.empty()) {
        vlayerID = volume.geometryId();
        m_vol_id.push_back(vlayerID.value());
      } else {
        m_vol_id.push_back(vlayerID.withVolume(0)
                           .withBoundary(0)
                           .withLayer(0)
                           .withApproach(0)
                           .withSensitive(0)
                           .value());
      }
    }
    // the material information
    const auto& mprops = mint.materialSlab;
    m_step_length.push_back(mprops.thickness());
    m_step_X0.push_back(mprops.material().X0());
    m_step_L0.push_back(mprops.material().L0());
    m_step_A.push_back(mprops.material().Ar());
    m_step_Z.push_back(mprops.material().Z());
    m_step_rho.push_back(mprops.material().massDensity());
 
  }
  p_tree->Fill();
  ATH_MSG_VERBOSE("Write complete");
}

finalize()

StatusCode ActsMaterialTrackWriterSvc::finalize ( )

overridevirtual

Definition at line 87 of file ActsMaterialTrackWriterSvc.cxx.

{
 
  ATH_MSG_INFO("Waiting for writer thread to finish.");
  m_doEnd = true;
  m_writeThread.join();
  ATH_MSG_INFO("Writer thread has terminated.");
 
  ATH_MSG_INFO("Closing TFile");
  p_tFile->cd();
  p_tree->FlushBaskets();
  p_tree->AutoSave();
  p_tree->Write();
  p_tFile->Write();
  p_tFile->Close();
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsMaterialTrackWriterSvc::initialize ( )

overridevirtual

Definition at line 31 of file ActsMaterialTrackWriterSvc.cxx.

{
 
  std::string filePath = m_filePath;
  std::string treeName = m_treeName;
  p_tFile = TFile::Open(filePath.c_str(), "RECREATE");
  p_tFile->cd();
  p_tree = new TTree(treeName.c_str(), treeName.c_str());
 
  p_tree->Branch("v_x", &m_v_x);
  p_tree->Branch("v_y", &m_v_y);
  p_tree->Branch("v_z", &m_v_z);
  p_tree->Branch("v_px", &m_v_px);
  p_tree->Branch("v_py", &m_v_py);
  p_tree->Branch("v_pz", &m_v_pz);
  p_tree->Branch("v_phi", &m_v_phi);
  p_tree->Branch("v_eta", &m_v_eta);
 
  p_tree->Branch("t_X0", &m_tX0);
  p_tree->Branch("t_L0", &m_tL0);
 
  p_tree->Branch("mat_x", &m_step_x);
  p_tree->Branch("mat_y", &m_step_y);
  p_tree->Branch("mat_z", &m_step_z);
  p_tree->Branch("mat_dx", &m_step_dx);
  p_tree->Branch("mat_dy", &m_step_dy);
  p_tree->Branch("mat_dz", &m_step_dz);
  p_tree->Branch("mat_step_length", &m_step_length);
  p_tree->Branch("mat_X0", &m_step_X0);
  p_tree->Branch("mat_L0", &m_step_L0);
  p_tree->Branch("mat_A", &m_step_A);
  p_tree->Branch("mat_Z", &m_step_Z);
  p_tree->Branch("mat_rho", &m_step_rho);
 
  if (m_storeSurface) {
    p_tree->Branch("sur_id", &m_sur_id);
    p_tree->Branch("sur_type", &m_sur_type);
    p_tree->Branch("sur_x", &m_sur_x);
    p_tree->Branch("sur_y", &m_sur_y);
    p_tree->Branch("sur_z", &m_sur_z);
    p_tree->Branch("sur_range_min", &m_sur_range_min);
    p_tree->Branch("sur_range_max", &m_sur_range_max);
  }
  if (m_storeVolume) {
    p_tree->Branch("vol_id", &m_vol_id);
  }
 
  ATH_MSG_INFO("Starting writer thread");
  ATH_MSG_DEBUG("Maximum queue size is set to:" << m_maxQueueSize);
  m_doEnd = false;
  m_writeThread = std::thread(&ActsMaterialTrackWriterSvc::writerThread, this);
 
  return StatusCode::SUCCESS;
}

write()

void ActsMaterialTrackWriterSvc::write ( const Acts::RecordedMaterialTrack & mTrack )

overridevirtual

Definition at line 107 of file ActsMaterialTrackWriterSvc.cxx.

{
  std::lock_guard<std::mutex> lock(m_writeMutex);
 
  ATH_MSG_VERBOSE("Appending material track to write queue");
  m_mTracks.push_back(mTrack);
}

writerThread()

void ActsMaterialTrackWriterSvc::writerThread ( )

private

Definition at line 116 of file ActsMaterialTrackWriterSvc.cxx.

{
  using namespace std::chrono_literals;
  // wait until we have events
  while(m_mTracks.size() == 0) {
    std::this_thread::sleep_for(2s);
    if (m_doEnd) return;
  }
 
  ATH_MSG_DEBUG("Begin regular write loop");
  while(true) {
    ATH_MSG_VERBOSE("Obtaining write lock");
    std::unique_lock<std::mutex> lock(m_writeMutex);
 
    if (m_mTracks.empty()) {
      lock.unlock();
      if (!m_doEnd) {
        ATH_MSG_VERBOSE("Queue was empty, delay next execution");
        std::this_thread::sleep_for(0.1s);
        continue;
      } else {
        ATH_MSG_INFO("Writer thread caught termination signal. Shutting down.");
 
        return;
      }
    }
 
 
    if(m_mTracks.size() < m_maxQueueSize) {
      // just pop one
      ATH_MSG_VERBOSE("Queue at " << m_mTracks.size() << "/" << m_maxQueueSize
          << ": Pop entry and write");
      Acts::RecordedMaterialTrack mTrack = std::move(m_mTracks.front());
      m_mTracks.pop_front();
      // writing can now happen without lock
      lock.unlock();
      doWrite(std::move(mTrack));
    }
    else {
      ATH_MSG_DEBUG("Queue at " << m_mTracks.size() << "/" << m_maxQueueSize
          << ": Lock and write until empty");
      while(!m_mTracks.empty()) {
        ATH_MSG_VERBOSE("Pop entry and write");
        // keep the lock!
        Acts::RecordedMaterialTrack mTrack = std::move(m_mTracks.front());
        m_mTracks.pop_front();
        doWrite(std::move(mTrack));
      }
      ATH_MSG_DEBUG("Queue is empty, continue");
 
    }
  }
}

Member Data Documentation

m_doEnd

std::atomic<bool> ActsMaterialTrackWriterSvc::m_doEnd

private

Definition at line 40 of file ActsMaterialTrackWriterSvc.h.

m_filePath

Gaudi::Property<std::string> ActsMaterialTrackWriterSvc::m_filePath {this, "FilePath", "MaterialTracks.root", "Output root file for charged particle"}

private

Definition at line 99 of file ActsMaterialTrackWriterSvc.h.

{this, "FilePath", "MaterialTracks.root", "Output root file for charged particle"};

m_maxQueueSize

Gaudi::Property<size_t> ActsMaterialTrackWriterSvc::m_maxQueueSize {this, "MaxQueueSize", 5000, "Limit the write queue to this size"}

private

Definition at line 103 of file ActsMaterialTrackWriterSvc.h.

{this, "MaxQueueSize", 5000, "Limit the write queue to this size"};

m_mTracks

std::deque<Acts::RecordedMaterialTrack> ActsMaterialTrackWriterSvc::m_mTracks

private

Definition at line 37 of file ActsMaterialTrackWriterSvc.h.

m_step_A

std::vector<float> ActsMaterialTrackWriterSvc::m_step_A

private

step material A

Definition at line 70 of file ActsMaterialTrackWriterSvc.h.

m_step_dx

std::vector<float> ActsMaterialTrackWriterSvc::m_step_dx

private

step x direction

Definition at line 64 of file ActsMaterialTrackWriterSvc.h.

m_step_dy

std::vector<float> ActsMaterialTrackWriterSvc::m_step_dy

private

step y direction

Definition at line 65 of file ActsMaterialTrackWriterSvc.h.

m_step_dz

std::vector<float> ActsMaterialTrackWriterSvc::m_step_dz

private

step z direction

Definition at line 66 of file ActsMaterialTrackWriterSvc.h.

m_step_ex

std::vector<float> ActsMaterialTrackWriterSvc::m_step_ex

private

step x (end) position (optional)

Definition at line 61 of file ActsMaterialTrackWriterSvc.h.

m_step_ey

std::vector<float> ActsMaterialTrackWriterSvc::m_step_ey

private

step y (end) position (optional)

Definition at line 62 of file ActsMaterialTrackWriterSvc.h.

m_step_ez

std::vector<float> ActsMaterialTrackWriterSvc::m_step_ez

private

step z (end) position (optional)

Definition at line 63 of file ActsMaterialTrackWriterSvc.h.

m_step_L0

std::vector<float> ActsMaterialTrackWriterSvc::m_step_L0

private

step material l0

Definition at line 69 of file ActsMaterialTrackWriterSvc.h.

m_step_length

std::vector<float> ActsMaterialTrackWriterSvc::m_step_length

private

step length

Definition at line 67 of file ActsMaterialTrackWriterSvc.h.

m_step_rho

std::vector<float> ActsMaterialTrackWriterSvc::m_step_rho

private

step material rho

Definition at line 72 of file ActsMaterialTrackWriterSvc.h.

m_step_sx

std::vector<float> ActsMaterialTrackWriterSvc::m_step_sx

private

step x (start) position (optional)

Definition at line 55 of file ActsMaterialTrackWriterSvc.h.

m_step_sy

std::vector<float> ActsMaterialTrackWriterSvc::m_step_sy

private

step y (start) position (optional)

Definition at line 56 of file ActsMaterialTrackWriterSvc.h.

m_step_sz

std::vector<float> ActsMaterialTrackWriterSvc::m_step_sz

private

step z (start) position (optional)

Definition at line 57 of file ActsMaterialTrackWriterSvc.h.

m_step_x

std::vector<float> ActsMaterialTrackWriterSvc::m_step_x

private

step x position

Definition at line 58 of file ActsMaterialTrackWriterSvc.h.

m_step_X0

std::vector<float> ActsMaterialTrackWriterSvc::m_step_X0

private

step material x0

Definition at line 68 of file ActsMaterialTrackWriterSvc.h.

m_step_y

std::vector<float> ActsMaterialTrackWriterSvc::m_step_y

private

step y position

Definition at line 59 of file ActsMaterialTrackWriterSvc.h.

m_step_Z

std::vector<float> ActsMaterialTrackWriterSvc::m_step_Z

private

step material Z

Definition at line 71 of file ActsMaterialTrackWriterSvc.h.

m_step_z

std::vector<float> ActsMaterialTrackWriterSvc::m_step_z

private

step z position

Definition at line 60 of file ActsMaterialTrackWriterSvc.h.

m_storeSurface

Gaudi::Property<bool> ActsMaterialTrackWriterSvc::m_storeSurface {this, "StoreSurface", true, "Store the surface info in the root file"}

private

Definition at line 101 of file ActsMaterialTrackWriterSvc.h.

{this, "StoreSurface", true, "Store the surface info in the root file"};

m_storeVolume

Gaudi::Property<bool> ActsMaterialTrackWriterSvc::m_storeVolume {this, "StoreVolume", true, "Store the volume info in the root file"}

private

Definition at line 102 of file ActsMaterialTrackWriterSvc.h.

{this, "StoreVolume", true, "Store the volume info in the root file"};

m_sur_id

std::vector<std::uint64_t> ActsMaterialTrackWriterSvc::m_sur_id

private

ID of the suface associated with the step.

Definition at line 75 of file ActsMaterialTrackWriterSvc.h.

m_sur_range_max

std::vector<float> ActsMaterialTrackWriterSvc::m_sur_range_max

private

Max range of the suface associated with the step.

Definition at line 88 of file ActsMaterialTrackWriterSvc.h.

m_sur_range_min

std::vector<float> ActsMaterialTrackWriterSvc::m_sur_range_min

private

Min range of the suface associated with the step.

Definition at line 86 of file ActsMaterialTrackWriterSvc.h.

m_sur_type

std::vector<int32_t> ActsMaterialTrackWriterSvc::m_sur_type

private

Type of the suface associated with the step.

Definition at line 77 of file ActsMaterialTrackWriterSvc.h.

m_sur_x

std::vector<float> ActsMaterialTrackWriterSvc::m_sur_x

private

x position of the center of the suface associated with the step

Definition at line 78 of file ActsMaterialTrackWriterSvc.h.

m_sur_y

std::vector<float> ActsMaterialTrackWriterSvc::m_sur_y

private

y position of the center of the suface associated with the step

Definition at line 80 of file ActsMaterialTrackWriterSvc.h.

m_sur_z

std::vector<float> ActsMaterialTrackWriterSvc::m_sur_z

private

z position of the center of the suface associated with the step

Definition at line 82 of file ActsMaterialTrackWriterSvc.h.

m_tL0

float ActsMaterialTrackWriterSvc::m_tL0 {}

private

thickness in X0/L0

Definition at line 53 of file ActsMaterialTrackWriterSvc.h.

{};    

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsMaterialTrackWriterSvc::m_trackingGeometrySvc

private

Definition at line 96 of file ActsMaterialTrackWriterSvc.h.

m_treeName

Gaudi::Property<std::string> ActsMaterialTrackWriterSvc::m_treeName {this, "TreeName", "material-tracks", ""}

private

Definition at line 100 of file ActsMaterialTrackWriterSvc.h.

{this, "TreeName", "material-tracks", ""};

m_tX0

float ActsMaterialTrackWriterSvc::m_tX0 {}

private

thickness in X0/L0

Definition at line 52 of file ActsMaterialTrackWriterSvc.h.

{};    

m_v_eta

float ActsMaterialTrackWriterSvc::m_v_eta {}

private

start eta direction

Definition at line 51 of file ActsMaterialTrackWriterSvc.h.

{};  

m_v_phi

float ActsMaterialTrackWriterSvc::m_v_phi {}

private

start phi direction

Definition at line 50 of file ActsMaterialTrackWriterSvc.h.

{};  

m_v_px

float ActsMaterialTrackWriterSvc::m_v_px {}

private

start global momentum x

Definition at line 47 of file ActsMaterialTrackWriterSvc.h.

{};   

m_v_py

float ActsMaterialTrackWriterSvc::m_v_py {}

private

start global momentum y

Definition at line 48 of file ActsMaterialTrackWriterSvc.h.

{};   

m_v_pz

float ActsMaterialTrackWriterSvc::m_v_pz {}

private

start global momentum z

Definition at line 49 of file ActsMaterialTrackWriterSvc.h.

{};   

m_v_x

float ActsMaterialTrackWriterSvc::m_v_x {}

private

start global x

Definition at line 44 of file ActsMaterialTrackWriterSvc.h.

{};    

m_v_y

float ActsMaterialTrackWriterSvc::m_v_y {}

private

start global y

Definition at line 45 of file ActsMaterialTrackWriterSvc.h.

{};    

m_v_z

float ActsMaterialTrackWriterSvc::m_v_z {}

private

start global z

Definition at line 46 of file ActsMaterialTrackWriterSvc.h.

{};    

m_vol_id

std::vector<std::uint64_t> ActsMaterialTrackWriterSvc::m_vol_id

private

ID of the volume associated with the step.

Definition at line 91 of file ActsMaterialTrackWriterSvc.h.

m_writeMutex

std::mutex ActsMaterialTrackWriterSvc::m_writeMutex

private

Definition at line 38 of file ActsMaterialTrackWriterSvc.h.

m_writeThread

std::thread ActsMaterialTrackWriterSvc::m_writeThread

private

Definition at line 39 of file ActsMaterialTrackWriterSvc.h.

p_tFile

TFile* ActsMaterialTrackWriterSvc::p_tFile {}

private

Definition at line 41 of file ActsMaterialTrackWriterSvc.h.

{};

p_tree

TTree* ActsMaterialTrackWriterSvc::p_tree {}

private

Definition at line 42 of file ActsMaterialTrackWriterSvc.h.

{};

---

The documentation for this class was generated from the following files:

• ActsMaterialTrackWriterSvc.h
• ActsMaterialTrackWriterSvc.cxx