#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 More...

TTree *	m_outputTree {}
	the output tree More...

int	m_eventNum {}

std::vector< float >	m_s_pX
	global position x of the step More...

std::vector< float >	m_s_pY
	global position y of the step More...

std::vector< float >	m_s_pZ
	global position z of the step More...

std::vector< float >	m_s_pR
	global position z of the step More...

std::vector< int >	m_s_volumeID
	volume identification More...

std::vector< int >	m_s_boundaryID
	boundary identification More...

std::vector< int >	m_s_layerID
	layer identification More...

std::vector< int >	m_s_approachID
	approach identification More...

std::vector< int >	m_s_sensitiveID
	sensitive identification More...

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.

22 : base_class(name, svc) {

23 }

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);
   }
  
 }