ActsExCellWriterSvc Class Reference

#include <ActsExCellWriterSvc.h>

Inheritance diagram for ActsExCellWriterSvc:

Collaboration diagram for ActsExCellWriterSvc:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
	ActsExCellWriterSvc (const std::string &name, ISvcLocator *svc)
void	store (std::vector< Acts::ExtrapolationCell< Acts::TrackParameters >> &ecells) override

Private Types
using	ExCellCharged = Acts::ExtrapolationCell< Acts::TrackParameters >
using	queue_item_t = std::pair< size_t, ExCellCharged >

Private Member Functions
void	doWrite ()

Private Attributes
std::shared_ptr< RootExCellWriter< Acts::TrackParameters > >	m_rootEccWriter
std::deque< queue_item_t >	m_queue
std::mutex	m_chargedMutex
std::thread	m_writeThread
std::atomic< bool >	m_doEnd
Gaudi::Property< std::string >	m_filePath {this, "FilePath", "excells_charged.root", "Output root file for charged particle"}
Gaudi::Property< std::string >	m_treeName {this, "TreeName", "extrapolation_charged", ""}
Gaudi::Property< bool >	m_writeBoundary {this, "WriteBoundary", true, ""}
Gaudi::Property< bool >	m_writeMaterial {this, "WriteMaterial", true, ""}
Gaudi::Property< bool >	m_writeSensitive {this, "WriteSensitive", true, ""}
Gaudi::Property< bool >	m_writePassive {this, "WritePassive", true, ""}

Detailed Description

Definition at line 34 of file ActsExCellWriterSvc.h.

Member Typedef Documentation

ExCellCharged

using ActsExCellWriterSvc::ExCellCharged = Acts::ExtrapolationCell<Acts::TrackParameters>

private

Definition at line 46 of file ActsExCellWriterSvc.h.

queue_item_t

using ActsExCellWriterSvc::queue_item_t = std::pair<size_t, ExCellCharged>

private

Definition at line 48 of file ActsExCellWriterSvc.h.

Constructor & Destructor Documentation

ActsExCellWriterSvc()

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

Definition at line 15 of file ActsExCellWriterSvc.cxx.

: base_class(name, svc) {
}

Member Function Documentation

doWrite()

void ActsExCellWriterSvc::doWrite ( )

private

Definition at line 65 of file ActsExCellWriterSvc.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_chargedMutex);
    
    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.");
        m_rootEccWriter->endRun();
        return;
      }
    }
 
    queue_item_t queue_item = std::move(m_queue.front());
    m_queue.pop_front();
 
    lock.unlock();
    
    size_t eventNum = queue_item.first;
    ExCellCharged ecell = std::move(queue_item.second);
 
    m_rootEccWriter->write(ecell, eventNum);
  }
    
  //std::vector<ExCellCharged> writeBuffer;
  
  //while(true) {
    //std::unique_lock<std::mutex> lock(m_chargedMutex);
    //if (m_exCells.size() < 1000 && !m_doEnd) {
      //lock.unlock();
      //std::this_thread::sleep_for(0.2s);
      //continue;
    //}
 
    //writeBuffer.reserve(m_exCells.size());
    //while(!m_exCells.empty()) {
      //writeBuffer.push_back(std::move(m_exCells.front()));
      //m_exCells.pop_front();
    //}
  
    //lock.unlock();
 
    //for(auto &ecell : writeBuffer) {
      //m_rootEccWriter->write(std::move(ecell));
    //}
    //writeBuffer.clear();
 
    //if (m_doEnd) {
      //lock.lock();
      //while(!m_exCells.empty()) {
        //m_rootEccWriter->write(std::move(m_exCells.front()));
        //m_exCells.pop_front();
      //}
      //lock.unlock();
      //break;
    //}
 
  //}
 
}

finalize()

StatusCode ActsExCellWriterSvc::finalize ( )

overridevirtual

Definition at line 41 of file ActsExCellWriterSvc.cxx.

{
  ATH_MSG_INFO("Waiting for writer thread to finish.");
  m_doEnd = true;
  m_writeThread.join();
  ATH_MSG_INFO("Writer thread has terminated.");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsExCellWriterSvc::initialize ( )

overridevirtual

Definition at line 20 of file ActsExCellWriterSvc.cxx.

{
  RootExCellWriter<Acts::TrackParameters>::Config reccWriterConfig;
  reccWriterConfig.filePath       = m_filePath;
  reccWriterConfig.treeName       = m_treeName;
  reccWriterConfig.writeBoundary  = m_writeBoundary;
  reccWriterConfig.writeMaterial  = m_writeMaterial;
  reccWriterConfig.writeSensitive = m_writeSensitive;
  reccWriterConfig.writePassive   = m_writePassive;
  m_rootEccWriter
      = std::make_shared<RootExCellWriter<Acts::TrackParameters>>(
          reccWriterConfig);
 
  ATH_MSG_INFO("Starting writer thread");
  m_doEnd = false;
  m_writeThread = std::thread(&ActsExCellWriterSvc::doWrite, this);
 
  return StatusCode::SUCCESS;
}

store()

void ActsExCellWriterSvc::store ( std::vector< Acts::ExtrapolationCell< Acts::TrackParameters >> &  ecells )

override

Definition at line 52 of file ActsExCellWriterSvc.cxx.

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

Member Data Documentation

m_chargedMutex

std::mutex ActsExCellWriterSvc::m_chargedMutex

private

Definition at line 52 of file ActsExCellWriterSvc.h.

m_doEnd

std::atomic<bool> ActsExCellWriterSvc::m_doEnd

private

Definition at line 54 of file ActsExCellWriterSvc.h.

m_filePath

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

private

Definition at line 59 of file ActsExCellWriterSvc.h.

m_queue

std::deque<queue_item_t> ActsExCellWriterSvc::m_queue

private

Definition at line 51 of file ActsExCellWriterSvc.h.

m_rootEccWriter

std::shared_ptr<RootExCellWriter<Acts::TrackParameters> > ActsExCellWriterSvc::m_rootEccWriter

private

Definition at line 50 of file ActsExCellWriterSvc.h.

m_treeName

Gaudi::Property<std::string> ActsExCellWriterSvc::m_treeName {this, "TreeName", "extrapolation_charged", ""}

private

Definition at line 60 of file ActsExCellWriterSvc.h.

m_writeBoundary

Gaudi::Property<bool> ActsExCellWriterSvc::m_writeBoundary {this, "WriteBoundary", true, ""}

private

Definition at line 61 of file ActsExCellWriterSvc.h.

m_writeMaterial

Gaudi::Property<bool> ActsExCellWriterSvc::m_writeMaterial {this, "WriteMaterial", true, ""}

private

Definition at line 62 of file ActsExCellWriterSvc.h.

m_writePassive

Gaudi::Property<bool> ActsExCellWriterSvc::m_writePassive {this, "WritePassive", true, ""}

private

Definition at line 64 of file ActsExCellWriterSvc.h.

m_writeSensitive

Gaudi::Property<bool> ActsExCellWriterSvc::m_writeSensitive {this, "WriteSensitive", true, ""}

private

Definition at line 63 of file ActsExCellWriterSvc.h.

m_writeThread

std::thread ActsExCellWriterSvc::m_writeThread

private

Definition at line 53 of file ActsExCellWriterSvc.h.

---

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

• ActsExCellWriterSvc.h
• ActsExCellWriterSvc.cxx