ActsPropStepRootWriterSvc Class Reference

#include <ActsPropStepRootWriterSvc.h>

Inheritance diagram for ActsPropStepRootWriterSvc:

Collaboration diagram for ActsPropStepRootWriterSvc:

Public Types
using	StepVector = std::vector<Acts::detail::Step>

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
	ActsPropStepRootWriterSvc (const std::string &name, ISvcLocator *svc)
void	write (const StepVector &steps) override

Private Types
using	queue_item_t = std::pair<size_t, StepVector>

Private Member Functions
void	writeThread ()
void	doWrite (const StepVector &steps, size_t evtNum)
void	end ()

Private Attributes
std::deque< queue_item_t >	m_queue
std::mutex	m_writeMutex
std::thread	m_writeThread
std::atomic< bool >	m_doEnd
Gaudi::Property< std::string >	m_filePath {this, "FilePath", "propsteps.root", "Output root file for charged particle"}
Gaudi::Property< std::string >	m_treeName {this, "TreeName", "propsteps", ""}
TFile *	m_outputFile {}
	the output file
TTree *	m_outputTree {}
	the output tree
int	m_eventNum {}
std::vector< float >	m_s_pX
	global position x of the step
std::vector< float >	m_s_pY
	global position y of the step
std::vector< float >	m_s_pZ
	global position z of the step
std::vector< float >	m_s_pR
	global position z of the step
std::vector< int >	m_s_volumeID
	volume identification
std::vector< int >	m_s_boundaryID
	boundary identification
std::vector< int >	m_s_layerID
	layer identification
std::vector< int >	m_s_approachID
	approach identification
std::vector< int >	m_s_sensitiveID
	sensitive identification

Detailed Description

Definition at line 37 of file ActsPropStepRootWriterSvc.h.

Member Typedef Documentation

queue_item_t

using ActsPropStepRootWriterSvc::queue_item_t = std::pair<size_t, StepVector>

private

Definition at line 51 of file ActsPropStepRootWriterSvc.h.

StepVector

using ActsPropStepRootWriterSvc::StepVector = std::vector<Acts::detail::Step>

Definition at line 45 of file ActsPropStepRootWriterSvc.h.

Constructor & Destructor Documentation

ActsPropStepRootWriterSvc()

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

Definition at line 21 of file ActsPropStepRootWriterSvc.cxx.

: base_class(name, svc) {
}

Member Function Documentation

doWrite()

void ActsPropStepRootWriterSvc::doWrite ( const StepVector & steps, size_t evtNum )

private

Definition at line 120 of file ActsPropStepRootWriterSvc.cxx.

{
  m_eventNum = evtNum;
  m_s_pX.clear();
  m_s_pY.clear();
  m_s_pZ.clear();
  m_s_pR.clear();
  m_s_volumeID.clear();
  m_s_boundaryID.clear();
  m_s_layerID.clear();
  m_s_approachID.clear();
  m_s_sensitiveID.clear();
 
  for(const auto& step : steps) {
      Acts::GeometryIdentifier::Value volumeID    = 0;
      Acts::GeometryIdentifier::Value boundaryID  = 0;
      Acts::GeometryIdentifier::Value layerID     = 0;
      Acts::GeometryIdentifier::Value approachID  = 0;
      Acts::GeometryIdentifier::Value sensitiveID = 0;
      // get the identification from the surface first
      if (step.surface) {
        auto geoID  = step.surface->geometryId();
        sensitiveID = geoID.sensitive();
        approachID  = geoID.approach();
        layerID     = geoID.layer();
        boundaryID  = geoID.boundary();
        volumeID    = geoID.volume();
      }
      // a current volume overwrites the surface tagged one
      if (step.geoID != Acts::GeometryIdentifier()) {
        volumeID = step.geoID.volume();
      }
      // now fill
      m_s_sensitiveID.push_back(sensitiveID);
      m_s_approachID.push_back(approachID);
      m_s_layerID.push_back(layerID);
      m_s_boundaryID.push_back(boundaryID);
      m_s_volumeID.push_back(volumeID);
 
      m_s_pX.push_back(step.position.x());
      m_s_pY.push_back(step.position.y());
      m_s_pZ.push_back(step.position.z());
      m_s_pR.push_back(Acts::VectorHelpers::perp(step.position));
  }
  
  m_outputTree->Fill();
}

end()

void ActsPropStepRootWriterSvc::end ( )

private

Definition at line 169 of file ActsPropStepRootWriterSvc.cxx.

{
  m_outputFile->cd();
  m_outputTree->Write();
  //m_outputFile->Close();
}

finalize()

StatusCode ActsPropStepRootWriterSvc::finalize ( )

overridevirtual

Definition at line 60 of file ActsPropStepRootWriterSvc.cxx.

{
  end();
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsPropStepRootWriterSvc::initialize ( )

overridevirtual

Definition at line 26 of file ActsPropStepRootWriterSvc.cxx.

{
 
  std::string filePath = m_filePath;
  m_outputFile = TFile::Open(filePath.c_str(), "RECREATE");
  if(m_outputFile == nullptr) {
    ATH_MSG_ERROR("Unable to open output file at " << m_filePath);
    return StatusCode::FAILURE;
  }
  m_outputFile->cd();
 
  std::string treeName = m_treeName;
  m_outputTree = new TTree(treeName.c_str(), "Acts Propagation Steps");
  if(m_outputTree == nullptr) {
    ATH_MSG_ERROR("Unable to create TTree");
    return StatusCode::FAILURE;
  }
 
  m_outputTree->Branch("event_nr", &m_eventNum);
  m_outputTree->Branch("step_x", &m_s_pX);
  m_outputTree->Branch("step_y", &m_s_pY);
  m_outputTree->Branch("step_z", &m_s_pZ);
  m_outputTree->Branch("step_r", &m_s_pR);
  m_outputTree->Branch("volume_id", &m_s_volumeID);
  m_outputTree->Branch("boundary_id", &m_s_boundaryID);
  m_outputTree->Branch("layer_id", &m_s_layerID);
  m_outputTree->Branch("approach_id", &m_s_approachID);
  m_outputTree->Branch("sensitive_id", &m_s_sensitiveID);
 
 
  return StatusCode::SUCCESS;
}

write()

void ActsPropStepRootWriterSvc::write ( const StepVector & steps )

override

Definition at line 68 of file ActsPropStepRootWriterSvc.cxx.

{
  
  const auto& ctx = Gaudi::Hive::currentContext();
 
  std::lock_guard<std::mutex> lock(m_writeMutex);
 
  //for(size_t i=0;i<ecells.size();++i) {
    //m_queue.emplace_back(ctx.eventID().event_number(), std::move(ecells[i]));
  //}
  doWrite(steps, ctx.eventID().event_number());
}

writeThread()

void ActsPropStepRootWriterSvc::writeThread ( )

private

Definition at line 82 of file ActsPropStepRootWriterSvc.cxx.

{
  using namespace std::chrono_literals;
  // wait until we have events
  while(m_queue.empty()) {
    std::this_thread::sleep_for(2s);
    if (m_doEnd) return;
  }
 
  while(true) {
    std::unique_lock<std::mutex> lock(m_writeMutex);
    
    if (m_queue.empty()) {
      lock.unlock();
      if (!m_doEnd) {
        std::this_thread::sleep_for(0.5s);
        continue;
      } else {
        ATH_MSG_INFO("Writer thread caught termination signal. Shutting down.");
        end();
        return;
      }
    }
 
    queue_item_t queue_item = std::move(m_queue.front());
    m_queue.pop_front();
 
    lock.unlock();
    
    size_t eventNum = queue_item.first;
    StepVector steps = std::move(queue_item.second);
 
    doWrite(steps, eventNum);
  }
 
}

Member Data Documentation

m_doEnd

std::atomic<bool> ActsPropStepRootWriterSvc::m_doEnd

private

Definition at line 57 of file ActsPropStepRootWriterSvc.h.

m_eventNum

int ActsPropStepRootWriterSvc::m_eventNum {}

private

Definition at line 74 of file ActsPropStepRootWriterSvc.h.

{};

m_filePath

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

private

Definition at line 64 of file ActsPropStepRootWriterSvc.h.

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

m_outputFile

TFile* ActsPropStepRootWriterSvc::m_outputFile {}

private

the output file

Definition at line 72 of file ActsPropStepRootWriterSvc.h.

{};    

m_outputTree

TTree* ActsPropStepRootWriterSvc::m_outputTree {}

private

the output tree

Definition at line 73 of file ActsPropStepRootWriterSvc.h.

{};    

m_queue

std::deque<queue_item_t> ActsPropStepRootWriterSvc::m_queue

private

Definition at line 54 of file ActsPropStepRootWriterSvc.h.

m_s_approachID

std::vector<int> ActsPropStepRootWriterSvc::m_s_approachID

private

approach identification

Definition at line 82 of file ActsPropStepRootWriterSvc.h.

m_s_boundaryID

std::vector<int> ActsPropStepRootWriterSvc::m_s_boundaryID

private

boundary identification

Definition at line 80 of file ActsPropStepRootWriterSvc.h.

m_s_layerID

std::vector<int> ActsPropStepRootWriterSvc::m_s_layerID

private

layer identification

Definition at line 81 of file ActsPropStepRootWriterSvc.h.

m_s_pR

std::vector<float> ActsPropStepRootWriterSvc::m_s_pR

private

global position z of the step

Definition at line 78 of file ActsPropStepRootWriterSvc.h.

m_s_pX

std::vector<float> ActsPropStepRootWriterSvc::m_s_pX

private

global position x of the step

Definition at line 75 of file ActsPropStepRootWriterSvc.h.

m_s_pY

std::vector<float> ActsPropStepRootWriterSvc::m_s_pY

private

global position y of the step

Definition at line 76 of file ActsPropStepRootWriterSvc.h.

m_s_pZ

std::vector<float> ActsPropStepRootWriterSvc::m_s_pZ

private

global position z of the step

Definition at line 77 of file ActsPropStepRootWriterSvc.h.

m_s_sensitiveID

std::vector<int> ActsPropStepRootWriterSvc::m_s_sensitiveID

private

sensitive identification

Definition at line 83 of file ActsPropStepRootWriterSvc.h.

m_s_volumeID

std::vector<int> ActsPropStepRootWriterSvc::m_s_volumeID

private

volume identification

Definition at line 79 of file ActsPropStepRootWriterSvc.h.

m_treeName

Gaudi::Property<std::string> ActsPropStepRootWriterSvc::m_treeName {this, "TreeName", "propsteps", ""}

private

Definition at line 65 of file ActsPropStepRootWriterSvc.h.

{this, "TreeName", "propsteps", ""};

m_writeMutex

std::mutex ActsPropStepRootWriterSvc::m_writeMutex

private

Definition at line 55 of file ActsPropStepRootWriterSvc.h.

m_writeThread

std::thread ActsPropStepRootWriterSvc::m_writeThread

private

Definition at line 56 of file ActsPropStepRootWriterSvc.h.

---

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

• ActsPropStepRootWriterSvc.h
• ActsPropStepRootWriterSvc.cxx