HepMcTupleWriterTool Class Reference

#include <HepMcTupleWriterTool.h>

Inheritance diagram for HepMcTupleWriterTool:

Collaboration diagram for HepMcTupleWriterTool:

Classes
struct	HepMcParticles
	A simple representation of a HepMc particle. More...

Public Member Functions
	HepMcTupleWriterTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~HepMcTupleWriterTool ()
	Destructor:
StatusCode	initialize ()
	Athena Algorithm's Hooks.
StatusCode	execute ()
StatusCode	finalize ()
StatusCode	write (const HepMC::GenEvent *evt)
	Process the HepMC::GenEvent through the I/O backend.

Protected Member Functions
	HepMcTupleWriterTool ()
	Default constructor:
void	setupBackend (Gaudi::Details::PropertyBase &outputFileName)
	Method to configure the back-end to write out the HepMC::GenEvent.
void	bookTuple ()
	book the tuple

Protected Attributes
HepMcParticles	m_particles {}
	our cached particles
ServiceHandle< ITHistSvc >	m_tupleSvc
	Pointer to @ ITHistSvc.
StringProperty	m_mcEventsName
	Location of the McEventCollection to be written out If there is more than 1 HepMC::GenEvent in the McEventCollection we will send warning messages, and just write the first one.
StringProperty	m_outputFileName
	Name of the output tuple file.
StringProperty	m_outputStreamName
	Name of the output tuple stream.
TTree *	m_tuple
	cached pointer to the tuple

Static Protected Attributes
static const int	s_nMax = 2000
	maximum number of particles per event

Detailed Description

Definition at line 30 of file HepMcTupleWriterTool.h.

Constructor & Destructor Documentation

HepMcTupleWriterTool() [1/2]

HepMcTupleWriterTool::HepMcTupleWriterTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters:

Constructors.

Definition at line 28 of file HepMcTupleWriterTool.cxx.

                                                   : 
  base_class( type, name, parent ),
  m_tupleSvc ( "THistSvc",     name ),
  m_tuple    ( nullptr )
{
  //
  // Property declaration
  // 
 
  declareProperty( "Output", 
           m_outputFileName = "hepmc.root", 
           "Name of the output file which will contain the HepMC tuple"
           "\nEx: hepmc.root" );
  m_outputFileName.declareUpdateHandler( &HepMcTupleWriterTool::setupBackend, this );
 
  declareProperty( "OutputStream", 
           m_outputStreamName = "hepmc", 
           "Name of the stream which will contain the HepMC tuple"
           "\nEx: hepmc" );
 
  declareProperty( "McEvents",
           m_mcEventsName = "GEN_EVENT",
           "Input location of the McEventCollection to write out" );
}

~HepMcTupleWriterTool()

HepMcTupleWriterTool::~HepMcTupleWriterTool ( )

virtual

Destructor:

Destructor.

Definition at line 57 of file HepMcTupleWriterTool.cxx.

{ 
  ATH_MSG_DEBUG("Calling destructor");
}

HepMcTupleWriterTool() [2/2]

HepMcTupleWriterTool::HepMcTupleWriterTool ( )

protected

Default constructor:

Member Function Documentation

bookTuple()

void HepMcTupleWriterTool::bookTuple ( )

protected

book the tuple

Definition at line 178 of file HepMcTupleWriterTool.cxx.

{
  const std::string streamName = m_outputStreamName.value();
  TTree* t = new TTree("hepmc","HepMC validation tuple");
  if ( !m_tupleSvc->regTree( "/" + streamName + "/hepmc", t ).isSuccess() ) {
    ATH_MSG_ERROR("Could not register HepMC validation tuple !!");
    delete t; t = nullptr;
    throw GaudiException( "Could not register HepMC validation tuple !!",  name(),  StatusCode::FAILURE );
  }
 
  // booking branches
  t->Branch( "nParts", &m_particles.m_nParticles, "nParts/I" );
 
  t->Branch( "px", m_particles.m_px.data(),  "px[nParts]/D" );
  t->Branch( "py", m_particles.m_py.data(),  "py[nParts]/D" );
  t->Branch( "pz", m_particles.m_pz.data(),  "pz[nParts]/D" );
  t->Branch( "m",  m_particles.m_m.data(),   "m[nParts]/D"  );
  t->Branch( "e",  m_particles.m_ene.data(), "e[nParts]/D"  );
 
  t->Branch( "pdgId", m_particles.m_pdgId.data(),   "pdgId[nParts]/I" );
  t->Branch( "sc",    m_particles.m_status.data(),  "sc[nParts]/I" );
  t->Branch( "bc",    m_particles.m_barcode.data(), "bc[nParts]/I" );
 
  m_tuple = t;
}

execute()

StatusCode HepMcTupleWriterTool::execute

(

)

Definition at line 95 of file HepMcTupleWriterTool.cxx.

{
  // retrieve the McEventCollection
  const McEventCollection * mcEvts = nullptr;
  if ( evtStore()->retrieve( mcEvts, m_mcEventsName ).isFailure() || nullptr == mcEvts ) {
    ATH_MSG_ERROR("Could not retrieve a McEventCollection at [" << m_mcEventsName << "] !!");
    return StatusCode::FAILURE;
  }
 
  if ( mcEvts->empty() ) {
    ATH_MSG_WARNING("McEventCollection at ["<<m_mcEventsName<<"] is EMPTY !!");
    return StatusCode::FAILURE;
  }
 
  const HepMC::GenEvent * evt = mcEvts->front();
  if ( !evt ) {
    ATH_MSG_ERROR("Retrieved NULL pointer to HepMC::GenEvent !!");
    return StatusCode::FAILURE;
  }
 
  return write(evt);
}

finalize()

StatusCode HepMcTupleWriterTool::finalize

(

)

Definition at line 89 of file HepMcTupleWriterTool.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode HepMcTupleWriterTool::initialize

(

)

Athena Algorithm's Hooks.

Definition at line 64 of file HepMcTupleWriterTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  // Get pointer to StoreGateSvc and cache it :
  if ( !evtStore().retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Unable to retrieve pointer to StoreGateSvc");
    return StatusCode::FAILURE;
  }
 
  // Get pointer to ITHistSvc and cache it :
  if ( !m_tupleSvc.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Unable to retrieve pointer to ITHistSvc");
    return StatusCode::FAILURE;
  }
 
  // setup backend
  setupBackend(m_outputFileName);
 
  // book tuple
  bookTuple();
 
  return StatusCode::SUCCESS;
}

setupBackend()

void HepMcTupleWriterTool::setupBackend ( Gaudi::Details::PropertyBase & outputFileName )

protected

Method to configure the back-end to write out the HepMC::GenEvent.

Non-const methods:

Definition at line 151 of file HepMcTupleWriterTool.cxx.

{
  SmartIF<IProperty> tSvc{m_tupleSvc.get()};
  if ( !tSvc ) {
    ATH_MSG_ERROR("Could not retrieve THistSvc handle !!");
    throw GaudiException( "Could not retrieve THistSvc",   name(),   StatusCode::FAILURE );
  }
 
  const std::string streamName = m_outputStreamName.value();
 
  const std::string propName = "Output";
  StringArrayProperty outputFileName;
  outputFileName.assign( tSvc->getProperty( propName ) );
  std::vector<std::string> updatedProp( outputFileName.value() );
  updatedProp.push_back
    ( streamName+" DATAFILE='"+m_outputFileName.value()+"' "
      "TYP='ROOT' "
      "OPT='RECREATE'" );
  outputFileName.set( updatedProp );
  outputFileName.setName( std::move(propName) );
  if ( !tSvc->setProperty( outputFileName ).isSuccess() ) {
    ATH_MSG_ERROR("Could not configure the THistSvc's output filename ["<< m_outputFileName.value() << "] !!");
    throw GaudiException( "Could not configure THistSvc output file !!",   name(),  StatusCode::FAILURE );
  }
 
  }

write()

StatusCode HepMcTupleWriterTool::write

(

const HepMC::GenEvent *

evt

)

Process the HepMC::GenEvent through the I/O backend.

Non-const methods:

Definition at line 122 of file HepMcTupleWriterTool.cxx.

{
  m_particles.m_nParticles = std::min<std::size_t>( s_nMax, evt->particles_size() );
  std::size_t i = 0;
  for (const auto& p: *evt)
  {
    if (i == static_cast<std::size_t>(m_particles.m_nParticles)) break;
    i++;
    const HepMC::FourVector mom = p->momentum();
    m_particles.m_px [i] = mom.px();
    m_particles.m_py [i] = mom.py();
    m_particles.m_pz [i] = mom.pz();
    m_particles.m_m  [i] = mom.m();
    m_particles.m_ene[i] = mom.e();
 
    m_particles.m_pdgId[i]   = p->pdg_id();
    m_particles.m_status[i]  = p->status();
    m_particles.m_barcode[i] = HepMC::barcode(p);
  }
  // commit event
  m_tuple->Fill();
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_mcEventsName

StringProperty HepMcTupleWriterTool::m_mcEventsName

protected

Location of the McEventCollection to be written out If there is more than 1 HepMC::GenEvent in the McEventCollection we will send warning messages, and just write the first one.

Definition at line 108 of file HepMcTupleWriterTool.h.

m_outputFileName

StringProperty HepMcTupleWriterTool::m_outputFileName

protected

Name of the output tuple file.

Definition at line 111 of file HepMcTupleWriterTool.h.

m_outputStreamName

StringProperty HepMcTupleWriterTool::m_outputStreamName

protected

Name of the output tuple stream.

Definition at line 114 of file HepMcTupleWriterTool.h.

m_particles

HepMcParticles HepMcTupleWriterTool::m_particles {}

protected

our cached particles

Definition at line 99 of file HepMcTupleWriterTool.h.

{};

m_tuple

TTree* HepMcTupleWriterTool::m_tuple

protected

cached pointer to the tuple

Definition at line 117 of file HepMcTupleWriterTool.h.

m_tupleSvc

ServiceHandle<ITHistSvc> HepMcTupleWriterTool::m_tupleSvc

protected

Pointer to @ ITHistSvc.

Definition at line 102 of file HepMcTupleWriterTool.h.

s_nMax

const int HepMcTupleWriterTool::s_nMax = 2000

staticprotected

maximum number of particles per event

Definition at line 84 of file HepMcTupleWriterTool.h.

---

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

• HepMcTupleWriterTool.h
• HepMcTupleWriterTool.cxx