JiveXML::TruthTrackRetriever Class Reference

Retrieves the McEventCollection or the TrackRecordCollection in simulated cosmics. More...

#include <TruthTrackRetriever.h>

Inheritance diagram for JiveXML::TruthTrackRetriever:

Collaboration diagram for JiveXML::TruthTrackRetriever:

Public Member Functions
	TruthTrackRetriever (const std::string &type, const std::string &name, const IInterface *parent)
	Standard Constructor.
virtual StatusCode	retrieve (ToolHandle< IFormatTool > &FormatTool)
	Retrieve all the data.
virtual std::string	dataTypeName () const
	Return the name of the data type.
StatusCode	initialize ()
	Default AthAlgTool methods.

Private Attributes
const std::string	m_typeName
	The data type that is generated by this retriever.
std::string	m_McEvtCollName
	Storegate key for the McEventCollection (different between RDO/ESD and AOD).
double	m_MinPtCut
	Minimum pT for a particle to get accepted.
double	m_MinRhoCut
	Minium radius of the end-vertex for the particle to get accepted.

Detailed Description

Retrieves the McEventCollection or the TrackRecordCollection in simulated cosmics.

• Properties
  • StoreGateKey = TruthEvent : Storegate key for the McEventCollection (different between RDO/ESD and AOD).

• UnstableMinPtCut = 100*MeV Minimum pT for a particle to get accepted.

• UnstableMinRhoCut = 40*mm Minium radius of the end-vertex for the particle to get accepted.

• Retrieved Data
  • code : the PDG ID of the particle
  • id : the particle barcode
  • pt : transverse momentum
  • eta, phi : \(\eta\) and \(\phi\) of the momentum vector
  • rhoVertex,phiVertex,zVertex : position of the production vertex in \(\rho\), \(\phi\) and \(z\)
  • rhoEndVertex,phiEndVertex,zEndVertex : position of the end-vertex in \(\rho\), \(\phi\) and \(z\)

Definition at line 40 of file TruthTrackRetriever.h.

Constructor & Destructor Documentation

TruthTrackRetriever()

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

Standard Constructor.

This is the standard AthAlgTool constructor.

Parameters

type	AlgTool type name
name	AlgTool instance name
parent	AlgTools parent owning this tool

Definition at line 24 of file TruthTrackRetriever.cxx.

                                                                                                              :
    base_class(type,name,parent),
    m_typeName("STr")
  {
    declareProperty("StoreGateKey", m_McEvtCollName = "TruthEvent", "Name of the McEventCollection");
    declareProperty("UnstableMinPtCut",     m_MinPtCut = 100*Gaudi::Units::MeV, "Minimum pT for an unstable particle to get accepted");
    declareProperty("UnstableMinRhoCut",    m_MinRhoCut = 40*Gaudi::Units::mm, "Minium radius of the end-vertex for unstable particle to get accepted");
 
  }

Member Function Documentation

dataTypeName()

virtual std::string JiveXML::TruthTrackRetriever::dataTypeName ( ) const

inlinevirtual

Return the name of the data type.

Definition at line 51 of file TruthTrackRetriever.h.

{ return m_typeName; };

initialize()

StatusCode JiveXML::TruthTrackRetriever::initialize

(

)

Default AthAlgTool methods.

Initialize before event loop.

Definition at line 37 of file TruthTrackRetriever.cxx.

                                            {
    //Nothing to do here
    return StatusCode::SUCCESS;
  }

retrieve()

StatusCode JiveXML::TruthTrackRetriever::retrieve ( ToolHandle< IFormatTool > & FormatTool )

virtual

Retrieve all the data.

Loop over all true particles and get their basic parameters.

Parameters

FormatTool

the tool that will create formated output from the DataMap

Definition at line 46 of file TruthTrackRetriever.cxx.

                                                                              {
 
    //be verbose
    ATH_MSG_DEBUG( "Retrieving " << dataTypeName() ); 
 
    //Retrieve the collection
    const McEventCollection* McEvtColl = NULL;
    if ( !evtStore()->contains<McEventCollection>( m_McEvtCollName )){ 
      ATH_MSG_DEBUG( "Could not find McEventCollection " << m_McEvtCollName );
      return StatusCode::SUCCESS;
    }
    if( evtStore()->retrieve(McEvtColl, m_McEvtCollName).isFailure() ){
      ATH_MSG_DEBUG( "Could not retrieve McEventCollection " << m_McEvtCollName );
      return StatusCode::SUCCESS;
    }
    
    // Calculate the size
    long NParticles=0;
    McEventCollection::const_iterator McEvtCollItr = McEvtColl->begin(); 
    for ( ; McEvtCollItr != McEvtColl->end(); ++McEvtCollItr)
      NParticles +=  (*McEvtCollItr)->particles_size();
 
    //Show in verbose mode
    ATH_MSG_DEBUG(  "Total number of particles in McEventCollection \""  << m_McEvtCollName << "\" is " << NParticles );
 
    //Reserve space for the output data
    DataVect pt; pt.reserve(NParticles);
    DataVect phi; phi.reserve(NParticles);
    DataVect eta; eta.reserve(NParticles);
    DataVect rhoVertex; rhoVertex.reserve(NParticles);
    DataVect phiVertex; phiVertex.reserve(NParticles);
    DataVect zVertex; zVertex.reserve(NParticles);
    DataVect code; code.reserve(NParticles);
    DataVect id; id.reserve(NParticles);
    DataVect rhoEndVertex; rhoEndVertex.reserve(NParticles);
    DataVect phiEndVertex; phiEndVertex.reserve(NParticles);
    DataVect zEndVertex; zEndVertex.reserve(NParticles);
 
      
    //Now loop events and retrieve
    for ( McEvtCollItr = McEvtColl->begin(); McEvtCollItr != McEvtColl->end(); ++McEvtCollItr){
 
      //Loop over particles in the event
      const auto &barcodes = (*McEvtCollItr)->attribute<HepMC::GenEventBarcodes> (HepMCStr::barcodes);
      std::map<int,int> id_to_barcode_map;
      if (barcodes) id_to_barcode_map = barcodes->id_to_barcode_map();
      for (const auto& particle:  *(*McEvtCollItr) ) {
        
        //Additional cuts for decaying particles
        if ( particle->end_vertex() ) {
          //Reject particles that fail the pt cut
          if ( particle->momentum().perp() < m_MinPtCut) continue ; 
          //Reject particles that fail the minimum end-vertex cut
          if (particle->end_vertex()->position().perp() < m_MinRhoCut ) continue ;
        }
 
        //Get basic parameters (eta, phi, pt, ...)
        pt.emplace_back(particle->momentum().perp()/Gaudi::Units::GeV);
        float thePhi = particle->momentum().phi();
        phi.emplace_back( (thePhi<0) ? thePhi+=2*M_PI : thePhi );
        eta.emplace_back( particle->momentum().pseudoRapidity() );
        code.emplace_back( particle->pdg_id() );
        id.emplace_back( id_to_barcode_map.at(particle->id() ));
 
        // Get the vertex information
        const auto& vertexprod =  particle->production_vertex();
        if (vertexprod) {
          const auto& pos=vertexprod->position();
          rhoVertex.emplace_back( std::sqrt(pos.x()*pos.x()+pos.y()*pos.y()+pos.z()*pos.z())*Gaudi::Units::mm/Gaudi::Units::cm );
          float vtxPhi = pos.phi();
          phiVertex.emplace_back( (vtxPhi<0)? vtxPhi+=2*M_PI : vtxPhi );
          zVertex.emplace_back( pos.z()*Gaudi::Units::mm/Gaudi::Units::cm ); 
        } else {
          rhoVertex.emplace_back( 0. );
          phiVertex.emplace_back( 0. );
          zVertex.emplace_back( 0. ); 
        }
        //Do the same for the end vertex
        const auto& vertexend =  particle->end_vertex();
        if ( vertexend ) {
         const auto& pos=vertexend->position();
         rhoEndVertex.emplace_back(std::sqrt(pos.x()*pos.x()+pos.y()*pos.y()+pos.z()*pos.z())*Gaudi::Units::mm/Gaudi::Units::cm);
         float vtxPhi = pos.phi();
         phiEndVertex.emplace_back( (vtxPhi<0)? vtxPhi+=2*M_PI : vtxPhi );
         zEndVertex.emplace_back(pos.z()*Gaudi::Units::mm/Gaudi::Units::cm); 
        } else {
         rhoEndVertex.emplace_back( 0. );
         phiEndVertex.emplace_back( 0. );
         zEndVertex.emplace_back( 0. ); 
        }
      }
    }
 
    DataMap myDataMap;
    const auto nEntries = pt.size();
    myDataMap["pt"] = std::move(pt);
    myDataMap["phi"] = std::move(phi);
    myDataMap["eta"] = std::move(eta);
    myDataMap["code"] = std::move(code);
    myDataMap["id"] = std::move(id);
    myDataMap["rhoVertex"] = std::move(rhoVertex);
    myDataMap["phiVertex"] = std::move(phiVertex);
    myDataMap["zVertex"] = std::move(zVertex);
    myDataMap["rhoEndVertex"] = std::move(rhoEndVertex);
    myDataMap["phiEndVertex"] = std::move(phiEndVertex);
    myDataMap["zEndVertex"] = std::move(zEndVertex);
 
    //Be verbose
    ATH_MSG_DEBUG( dataTypeName() << ": "<< nEntries );
 
    //forward data to formating tool
    return FormatTool->AddToEvent(dataTypeName(), m_McEvtCollName, &myDataMap);
  }

Member Data Documentation

m_McEvtCollName

std::string JiveXML::TruthTrackRetriever::m_McEvtCollName

private

Storegate key for the McEventCollection (different between RDO/ESD and AOD).

Definition at line 61 of file TruthTrackRetriever.h.

m_MinPtCut

double JiveXML::TruthTrackRetriever::m_MinPtCut

private

Minimum pT for a particle to get accepted.

Definition at line 63 of file TruthTrackRetriever.h.

m_MinRhoCut

double JiveXML::TruthTrackRetriever::m_MinRhoCut

private

Minium radius of the end-vertex for the particle to get accepted.

Definition at line 65 of file TruthTrackRetriever.h.

m_typeName

const std::string JiveXML::TruthTrackRetriever::m_typeName

private

The data type that is generated by this retriever.

Definition at line 58 of file TruthTrackRetriever.h.

---

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

• TruthTrackRetriever.h
• TruthTrackRetriever.cxx