EtaPtFilterTool Class Reference

#include <EtaPtFilterTool.h>

Inheritance diagram for EtaPtFilterTool:

Collaboration diagram for EtaPtFilterTool:

Public Member Functions
	EtaPtFilterTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~EtaPtFilterTool ()
	Destructor:
StatusCode	buildMcAod (const McEventCollection *in, McEventCollection *out)
	This method will check the validity of the input McEventCollection and build a filtered one from the strategy implemented by this concrete tool.
StatusCode	initialize ()
	Athena Algorithm's Hooks.
StatusCode	execute ()
StatusCode	finalize ()
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Inline methods:

Protected Types
using	ParticleMap_t
using	VertexMap_t
typedef ToolHandle< IMcVtxFilterTool >	McVtxFilterTool_t
typedef ToolHandle< ITruthIsolationTool >	IsolTool_t

Protected Member Functions
	EtaPtFilterTool ()
	Default constructor:
StatusCode	buildGenEvent (const HepMC::GenEvent *in, HepMC::GenEvent *out)
	This method will check the validity of the input HepMC::GenEvent and build a filtered one from the strategy implemented by this concrete tool.
bool	isAccepted (const HepMC::ConstGenParticlePtr &mcPart) const
	Check if a given particle is within the acceptance (pt+eta)
bool	isAccepted (const HepMC::ConstGenVertexPtr &vtx) const
	Check if a given vertex has at least one in-going or out-going particle within the acceptance (pt+eta)
StatusCode	addVertex (const HepMC::ConstGenVertexPtr &srcVtx, HepMC::GenEvent *evt, VertexMap_t &vmap, ParticleMap_t &pmap, bool isSignalVertex=false) const
	Helper method to copy a given vertex and add it to a GenEvent.
bool	isPartonVertex (const HepMC::ConstGenVertexPtr &vtx) const
bool	isFromHardScattering (const HepMC::ConstGenVertexPtr &vtx) const
StatusCode	initializeTool ()
	Method to initialize the tool: we need to check the validity of the parameters given for the inner and outer eta regions.
void	setupInnerEtaRegionCuts (Gaudi::Details::PropertyBase &innerEtaRegionCuts)
	Callback function to setup the "InnerEtaRegionCuts" property.
void	setupOuterEtaRegionCuts (Gaudi::Details::PropertyBase &outerEtaRegionCuts)
	Callback function to setup the "OuterEtaRegionCuts" property.
virtual StatusCode	finalizeTool ()
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
DoubleArrayProperty	m_innerEtaRegionCuts
	vector of cuts parameters for the inner region delimited in |eta| 0-th element is the minimum |eta| of this region 1-st element is the maximum |eta| of this region 2-nd element is the minimum pt for the stable particles to be accepted
DoubleArrayProperty	m_outerEtaRegionCuts
	vector of cuts parameters for the outer region delimited in |eta| 0-th element is the minimum |eta| of this region 1-st element is the maximum |eta| of this region 2-nd element is the minimum pt for the stable particles to be accepted
BooleanProperty	m_onlyGenerator
	Switch to only include particles from generation and reject particles from detector simulation (Geant4)
BooleanProperty	m_butKeepAllGeneratorStable
	Switch to keep all stable generator particles (IsGenStable) regardless what eta or pt cuts are defined.
BooleanProperty	m_keepDocumentaries
	Switch to keep all generator particles which are documentaries (statuscode == 3)
BooleanProperty	m_keepAllLeptons
	Switch to keep all leptons - i.e.
std::map< int, double >	m_isol_energies
McVtxFilterTool_t	m_mcVtxFilterTool
	Pointer to the McVtxFilterTool to be able to select additional vertices on some decay pattern criterion.
IsolTool_t	m_isolationTool
	Pointer to the TruthIsolationTool to be able to compute transverse energy isolations for various isolation cones cuts.
BooleanProperty	m_doEtIsolation
	Switch to compute or not the Et-isolations for TruthParticle (and their underlying HepMC::GenParticle).
SG::ReadHandleKey< McEventCollection >	m_mcEventsReadHandleKey {this,"McEvents","TruthEvent","ReadHandleKey for input McEventCollection one wants to filter"}
	ReadHandleKey for the input McEventCollection one wants to filter.
SG::WriteHandleKey< McEventCollection >	m_mcEventsOutputWriteHandleKey {this,"McEventsOutput","GEN_AOD","WriteHandleKey for the output McEventCollection which has been filtered"}
	Location of the output McEventCollection which has been filtered.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 23 of file EtaPtFilterTool.h.

Member Typedef Documentation

IsolTool_t

typedef ToolHandle<ITruthIsolationTool> TruthParticleFilterBaseTool::IsolTool_t

protectedinherited

Definition at line 80 of file TruthParticleFilterBaseTool.h.

McVtxFilterTool_t

typedef ToolHandle<IMcVtxFilterTool> TruthParticleFilterBaseTool::McVtxFilterTool_t

protectedinherited

Definition at line 74 of file TruthParticleFilterBaseTool.h.

ParticleMap_t

using EtaPtFilterTool::ParticleMap_t

protected

Initial value:

 std::unordered_map<const HepMC::GenParticle*,
                                           HepMC::GenParticlePtr>

Definition at line 53 of file EtaPtFilterTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

VertexMap_t

using EtaPtFilterTool::VertexMap_t

protected

Initial value:

 std::unordered_map<const HepMC::GenVertex*,
                                         HepMC::GenVertexPtr>

Definition at line 55 of file EtaPtFilterTool.h.

Constructor & Destructor Documentation

EtaPtFilterTool() [1/2]

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

Constructor with parameters:

Constructors.

Definition at line 34 of file EtaPtFilterTool.cxx.

                                             : 
  TruthParticleFilterBaseTool( type, name, parent )
{
  //
  // Property declaration
  // 
  //declareProperty( "Property", m_nProperty );
 
  declareProperty( "InnerEtaRegionCuts", 
           m_innerEtaRegionCuts,
           "Vector of cuts parameters for the inner region.\n"
           "Two first elements are minimum and maximum |eta| values "
           "for this inner region.\n"
           "Third element is the minimum pT for the stable particles "
           "to be accepted." );
  // defaults
  std::vector<double> innerEtaRegionCuts;
  innerEtaRegionCuts.push_back( 0.0     ); // minimum |eta|
  innerEtaRegionCuts.push_back( 3.5     ); // maximum |eta|
  innerEtaRegionCuts.push_back( 0.3*GeV ); // minimum pT of particles
  m_innerEtaRegionCuts.set( innerEtaRegionCuts );
 
  m_innerEtaRegionCuts.declareUpdateHandler( &EtaPtFilterTool::setupInnerEtaRegionCuts,
                         this );
  
  declareProperty( "OuterEtaRegionCuts", 
           m_outerEtaRegionCuts,
           "Vector of cuts parameters for the outer region.\n"
           "Two first elements are minimum and maximum |eta| values "
           "for this outer region.\n"
           "Third element is the minimum pT for the stable particles "
           "to be accepted." );
  // defaults
  std::vector<double> outerEtaRegionCuts;
  outerEtaRegionCuts.push_back( 3.5     ); // minimum |eta|
  outerEtaRegionCuts.push_back( 5.5     ); // maximum |eta|
  outerEtaRegionCuts.push_back( 1.0*GeV ); // minimum pT of particles
  m_outerEtaRegionCuts.set( outerEtaRegionCuts );
 
  m_outerEtaRegionCuts.declareUpdateHandler( &EtaPtFilterTool::setupOuterEtaRegionCuts,
                         this );
 
  // switches
  declareProperty( "OnlyGenerator",      
           m_onlyGenerator = false,
           "Switch to only include particles from generation and "
           "reject particles from detector simulation (Geant4)" );
 
 
  declareProperty( "ButKeepAllGeneratorStable",      
           m_butKeepAllGeneratorStable = true,
           "Switch to keep all generated stable particles (they sum to "
           "14 TeV) regardless of the eta and pt cuts defined for the "
           "remaining particles" );
 
 
  declareProperty( "KeepDocumentaries",      
           m_keepDocumentaries = true,
           "Switch to keep *all* generator particles which are "
           "documentaries (statuscode == 3)" );
 
  declareProperty( "KeepAllLeptons",
       m_keepAllLeptons = true,
           "Switch to keep *all* leptons - i.e. do not apply kinematic cuts on them");
 
}

~EtaPtFilterTool()

EtaPtFilterTool::~EtaPtFilterTool ( )

virtual

Destructor:

Destructor.

Definition at line 105 of file EtaPtFilterTool.cxx.

{ 
  ATH_MSG_DEBUG("Calling destructor");
}

EtaPtFilterTool() [2/2]

EtaPtFilterTool::EtaPtFilterTool ( )

protected

Default constructor:

Member Function Documentation

addVertex()

StatusCode EtaPtFilterTool::addVertex ( const HepMC::ConstGenVertexPtr & srcVtx, HepMC::GenEvent * evt, VertexMap_t & vmap, ParticleMap_t & pmap, bool isSignalVertex = false ) const

protected

Helper method to copy a given vertex and add it to a GenEvent.

Fill the parent branch

Fill the children branch

Definition at line 295 of file EtaPtFilterTool.cxx.

{
  if ( 0 == srcVtx || 0 == evt ) {
    ATH_MSG_ERROR("In addVertex(vtx,evt) : INVALID pointer given !!" << endmsg  << " vtx: " << srcVtx << endmsg << " evt: " << evt);
    return StatusCode::FAILURE;
  }
#ifdef HEPMC3
  HepMC::GenVertexPtr& vtx = vmap[srcVtx.get()];
  if ( !vtx ) {
    vtx = HepMC::newGenVertexPtr();
    evt->add_vertex(vtx); 
    vtx->set_position( srcVtx->position() );
    vtx->set_status( srcVtx->status() );
    HepMC::suggest_barcode(vtx, HepMC::barcode(srcVtx));
    vtx->add_attribute("weights",srcVtx->attribute<HepMC3::VectorDoubleAttribute> ("weights"));
    if (isSignalVertex) HepMC::set_signal_process_vertex(evt,vtx);
  }
  for ( auto  parent:  srcVtx->particles_in()) {
    HepMC::GenParticlePtr& p = pmap[parent.get()];
    if ( !p ) {
      p = HepMC::newGenParticlePtr();
      vtx->add_particle_in( p );
      p->set_momentum( parent->momentum() );
      p->set_generated_mass( parent->generated_mass() );
      p->set_pdg_id( parent->pdg_id() );
      p->set_status( parent->status() );
      HepMC::set_flow(p, HepMC::flow(parent) );
      HepMC::set_polarization(p, HepMC::polarization( parent) );
      HepMC::suggest_barcode(p, HepMC::barcode(parent));
    }
    // set the mother's decay to our (new) vertex
    vtx->add_particle_in( p );
    
  }//> loop over ingoing particles
  
  for (auto child: srcVtx->particles_out()) {
    HepMC::GenParticlePtr& p = pmap[child.get()];
    if ( !p ) {
      p = HepMC::newGenParticlePtr();
      vtx->add_particle_out( p );
      p->set_momentum( child->momentum() );
      p->set_generated_mass( child->generated_mass() );
      p->set_pdg_id( child->pdg_id() );
      p->set_status( child->status() );
      HepMC::set_flow(p, HepMC::flow(child) );
      HepMC::set_polarization(p, HepMC::polarization(child) );
      HepMC::suggest_barcode(p, HepMC::barcode(child) );
    }
    // set the daughter's production vertex to our new vertex
    vtx->add_particle_out( p );
  }//> loop over outgoing particles
#else
 
  HepMC::GenVertexPtr& vtx = vmap[srcVtx];
  if ( !vtx ) {
    vtx = new HepMC::GenVertex();
    vtx->set_position( srcVtx->position() );
    vtx->set_id( srcVtx->id() );
    vtx->suggest_barcode( srcVtx->barcode() );
    vtx->weights() = srcVtx->weights();
    evt->add_vertex(vtx);
    if (isSignalVertex) evt->set_signal_process_vertex(vtx);
  }

  for ( HepMC::GenVertex::particles_in_const_iterator 
      parent    = srcVtx->particles_in_const_begin(),
      parentEnd = srcVtx->particles_in_const_end();
    parent != parentEnd;
    ++parent ) {
    HepMC::GenParticlePtr& p = pmap[*parent];
    if ( !p ) {
      p = new HepMC::GenParticle;
      p->set_momentum( (*parent)->momentum() );
      p->set_generated_mass( (*parent)->generated_mass() );
      p->set_pdg_id( (*parent)->pdg_id() );
      p->set_status( (*parent)->status() );
      p->set_flow( (*parent)->flow() );
      p->set_polarization( (*parent)->polarization() );
      p->suggest_barcode( (*parent)->barcode() );
    }
    // set the mother's decay to our (new) vertex
    vtx->add_particle_in( p );
    
  }//> loop over ingoing particles
  
  for ( HepMC::GenVertex::particles_out_const_iterator 
      child = srcVtx->particles_out_const_begin(),
      childEnd = srcVtx->particles_out_const_end();
    child != childEnd;
    ++child ) {
    HepMC::GenParticlePtr& p = pmap[*child];
    if ( !p ) {
      p = new HepMC::GenParticle;
      p->set_momentum( (*child)->momentum() );
      p->set_generated_mass( (*child)->generated_mass() );
      p->set_pdg_id( (*child)->pdg_id() );
      p->set_status( (*child)->status() );
      p->set_flow( (*child)->flow() );
      p->set_polarization( (*child)->polarization() );
      p->suggest_barcode( (*child)->barcode() );
    }
 
    // set the daughter's production vertex to our new vertex
    vtx->add_particle_out( p );
 
  }//> loop over outgoing particles
#endif
 
  return StatusCode::SUCCESS;
}

buildGenEvent()

StatusCode EtaPtFilterTool::buildGenEvent ( const HepMC::GenEvent * in, HepMC::GenEvent * out )

protected

This method will check the validity of the input HepMC::GenEvent and build a filtered one from the strategy implemented by this concrete tool.

Const methods:

Definition at line 155 of file EtaPtFilterTool.cxx.

{
  if (  nullptr == in || nullptr == out ) {
    ATH_MSG_ERROR("Invalid pointer to GenEvent !!" << endmsg
          << "  in: " << in << endmsg
          << " out: " << out);
    return StatusCode::FAILURE;
  }
 
  // loop over vertices
  VertexMap_t vmap;
  ParticleMap_t pmap;
  auto spv =  HepMC::signal_process_vertex(in); //AV To be removed in the future
#ifdef HEPMC3
  for ( auto vtx: in->vertices() ) {
#else
  for ( HepMC::GenEvent::vertex_const_iterator vtxit = in->vertices_begin(); vtxit != in->vertices_end();  ++vtxit ) {
    auto vtx=*vtxit;
#endif
    bool isSignalVertex = (vtx == spv);
    if ( !isAccepted(vtx) && !isSignalVertex ) {
      // no in-going nor out-going particles at this vertex matches 
      // the requirements nor it is a signal process vertex : ==> Skip it
      continue;
    }
    
    if ( addVertex( vtx, out, vmap, pmap, isSignalVertex ).isFailure() )
    {
      ATH_MSG_WARNING("Could not add vertex " << vtx );
    }
 
  } //> end loop over vertices
  
  return StatusCode::SUCCESS;
}

buildMcAod()

StatusCode EtaPtFilterTool::buildMcAod ( const McEventCollection * in, McEventCollection * out )

virtual

This method will check the validity of the input McEventCollection and build a filtered one from the strategy implemented by this concrete tool.

Implements ITruthParticleFilterTool.

Definition at line 111 of file EtaPtFilterTool.cxx.

{
  if ( !in || !out ) {
    ATH_MSG_ERROR("Invalid pointer to McEventCollection !" << endmsg
          << "  in: " << in << endmsg
          << " out: " << out);
    return StatusCode::FAILURE;
  }
 
  for ( unsigned int iEvt = 0; iEvt != in->size(); ++iEvt ) {
    const HepMC::GenEvent * inEvt = (*in)[iEvt];
    if ( 0 == inEvt ) {
      ATH_MSG_WARNING
        ("Could not launch filtering procedure for GenEvent number ["
         << iEvt << "] from McEventCollection ["
         << m_mcEventsReadHandleKey.key() << " !!"
         << endmsg
         << "  inEvt: " << inEvt);
      continue;
    }
    HepMC::GenEvent* outEvt = HepMC::copyemptyGenEvent( inEvt);
 
    if ( buildGenEvent( inEvt, outEvt ).isFailure() ) {
      ATH_MSG_ERROR("Could filter GenEvent number [" << iEvt 
            << "] from McEventCollection ["     << m_mcEventsReadHandleKey.key() 
            << "] !!");
      delete outEvt;
      outEvt = 0;
      continue;
    }
 
    TruthHelper::copyBeamParticles (*inEvt, *outEvt);
 
    out->push_back( outEvt );
  }
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TruthParticleFilterBaseTool::execute ( )

virtualinherited

Implements ITruthParticleFilterTool.

Definition at line 120 of file TruthParticleFilterBaseTool.cxx.

{  
  ATH_MSG_DEBUG("Executing " << name() << "...");
 
  //Setup Handle to read input container
  SG::ReadHandle<McEventCollection> mcEventsReadHandle(m_mcEventsReadHandleKey);
 
  if (!mcEventsReadHandle.isValid()){
    ATH_MSG_ERROR("Invalid ReadHandle to McEventColleciton with key: " << m_mcEventsReadHandleKey.key());
    return StatusCode::FAILURE;
  }
 
  //Setup WriteHandle, and then record new McEventCollection.
  SG::WriteHandle<McEventCollection> mcEventsOutputWriteHandle(m_mcEventsOutputWriteHandleKey);
  ATH_CHECK(mcEventsOutputWriteHandle.record(std::make_unique<McEventCollection>()));  
  
  if (!mcEventsOutputWriteHandle.isValid()){
    ATH_MSG_ERROR("Invalid WriteHamdle for McEventCollection with key ["
                  <<m_mcEventsOutputWriteHandleKey.key()  << "] !!");
    return StatusCode::FAILURE;
  }
  
  // Compute isolation for gamma/lepton.
  if ( m_doEtIsolation.value() ) {
    ATH_MSG_VERBOSE("Computing Et isolations...");
    if ( m_isolationTool->buildEtIsolations(m_mcEventsReadHandleKey.key()).isFailure() ) {
      ATH_MSG_ERROR("Could not compute Et isolations !!");
      return StatusCode::FAILURE;
    }
  } //> end do Et-isolation
 
    if ( this->buildMcAod( mcEventsReadHandle.ptr(), mcEventsOutputWriteHandle.ptr() ).isFailure() ) {
    ATH_MSG_ERROR("Could not buildMcAod(in,out) !!");
    return StatusCode::FAILURE;
  }
 
  // We have slimmed the mcEventsOutputWriteHandle.
  // To not bias the map of isolation energies for this GenEvent, we alias
  // it to its original one
  if ( m_doEtIsolation.value() &&
       !m_isolationTool->registerAlias( m_mcEventsOutputWriteHandleKey.key(), 
                                        m_mcEventsReadHandleKey.key() 
                                        ).isSuccess() ) {
    ATH_MSG_WARNING("Could not create an alias in the map of "\
            "isolation energies !");
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode TruthParticleFilterBaseTool::finalize ( )

virtualinherited

Implements ITruthParticleFilterTool.

Definition at line 105 of file TruthParticleFilterBaseTool.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
 
  m_mcVtxFilterTool->stats();
 
  // Give the concrete (derived) tool a chance to finalize itself
  if ( finalizeTool().isFailure() ) {
    ATH_MSG_ERROR("Could not finalize concrete tool !");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

finalizeTool()

StatusCode TruthParticleFilterBaseTool::finalizeTool ( )

inlineprotectedvirtualinherited

Definition at line 124 of file TruthParticleFilterBaseTool.h.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TruthParticleFilterBaseTool::initialize ( )

virtualinherited

Athena Algorithm's Hooks.

Retrieves a private AlgTool to filter a McEventCollection

Retrieves the isolation tool (public, to be used also in TruthParticleCnvTool)

Implements ITruthParticleFilterTool.

Definition at line 65 of file TruthParticleFilterBaseTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");

  if ( !m_mcVtxFilterTool.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Creation of algTool IMcVtxFilterTool FAILED !");
    return StatusCode::FAILURE;
  }

  if( m_doEtIsolation.value()) {
    ATH_CHECK(m_isolationTool.retrieve());
  }
  else {
    m_isolationTool.disable();
  }
 
  //initialize DataHandleKeys
  ATH_CHECK(m_mcEventsReadHandleKey.initialize());
  ATH_CHECK(m_mcEventsOutputWriteHandleKey.initialize());
  
  ATH_MSG_INFO
    (" DoEtIsolations: [" << std::boolalpha << m_doEtIsolation.value()
     << "]" << endmsg
     << " McEvents:       [" << m_mcEventsReadHandleKey.key() << "]" << endmsg
     << " McEventsOutput: [" << m_mcEventsOutputWriteHandleKey.key() << "]");
  
  // Give the concrete (derived) tool a chance to initialize itself
  if ( initializeTool().isFailure() ) {
    ATH_MSG_ERROR("Could not initialize concrete tool !");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("Options of the McVtxFilterTool:");
  m_mcVtxFilterTool->displayOptions();
 
  return StatusCode::SUCCESS;
}

initializeTool()

StatusCode EtaPtFilterTool::initializeTool ( )

protectedvirtual

Method to initialize the tool: we need to check the validity of the parameters given for the inner and outer eta regions.

Non-const methods:

Reimplemented from TruthParticleFilterBaseTool.

Definition at line 459 of file EtaPtFilterTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  // make sure the properties are synchronised
  setupInnerEtaRegionCuts(m_innerEtaRegionCuts);
  setupOuterEtaRegionCuts(m_outerEtaRegionCuts);
 
  if ( m_innerEtaRegionCuts.value().size() != 3 ||
       m_outerEtaRegionCuts.value().size() != 3 ) {
    ATH_MSG_ERROR
      ("Wrong size for eta regions cut :" << endmsg
       << "\tinner region: " << m_innerEtaRegionCuts.value().size()
       << endmsg
       << "\touter region: " << m_outerEtaRegionCuts.value().size()
       << endmsg
       << "You have to provide a list of cuts of the form : " << endmsg
       << " |etaMin| |etaMax| ptMin");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO
    ("Inner Eta region cuts : nCuts = " 
     << m_innerEtaRegionCuts.value().size()
     << endmsg
     << "\tetaMin = " << m_innerEtaRegionCuts.value()[0] << endmsg
     << "\tetaMax = " << m_innerEtaRegionCuts.value()[1] << endmsg
     << "\tPtMin  = " << m_innerEtaRegionCuts.value()[2] << endmsg
     << "Outer Eta region cuts : nCuts = " 
     << m_outerEtaRegionCuts.value().size()
     << endmsg
     << "\tetaMin = " << m_outerEtaRegionCuts.value()[0] << endmsg
     << "\tetaMax = " << m_outerEtaRegionCuts.value()[1] << endmsg
     << "\tPtMin  = " << m_outerEtaRegionCuts.value()[2]);
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & ITruthParticleFilterTool::interfaceID ( )

inlinestaticinherited

Inline methods:

Definition at line 70 of file ITruthParticleFilterTool.h.

{ 
   return IID_ITruthParticleFilterTool; 
}

isAccepted() [1/2]

bool EtaPtFilterTool::isAccepted ( const HepMC::ConstGenParticlePtr & mcPart ) const

protected

Check if a given particle is within the acceptance (pt+eta)

Definition at line 191 of file EtaPtFilterTool.cxx.

{
  if ( ! mc ) {
    return false;
  }
 
  if ( m_butKeepAllGeneratorStable.value() ) {
    // static IsGenStable isStable;
    if ( MC::isStable(mc) ) {
      return true;
    }
  }
 
  if ( m_onlyGenerator.value() ) {
    // helper class to know if a GenParticle has been produced at Generator 
    // level. ie: not at simulation level (Geant4)
 
    if ( HepMC::is_simulation_particle(mc) ) {
      return false;
    }
  }
 
  if ( m_keepDocumentaries.value() ) {
    if ( !MC::isPhysical(mc) ) {
      return true;
    }
  }
 
  // Skip kinematic cuts for leptons
  if ( m_keepAllLeptons.value() ) {
    if ( MC::isLepton(mc) ) {
      return true;
    }
  }
 
  const HepMC::FourVector hlv = mc->momentum();
  const double pt             = hlv.perp();
  const double eta            = hlv.pseudoRapidity();
  if ( ( std::abs( eta )  >=  m_innerEtaRegionCuts.value()[0] && 
     std::abs( eta )  <   m_innerEtaRegionCuts.value()[1] &&
     pt               >   m_innerEtaRegionCuts.value()[2] ) 
       
       ||
       
       ( std::abs( eta )  >=  m_outerEtaRegionCuts.value()[0] && 
     std::abs( eta )  <   m_outerEtaRegionCuts.value()[1] &&
     pt               >   m_outerEtaRegionCuts.value()[2] ) ) {
    return true;
  } else {
    return false;
  }
}

isAccepted() [2/2]

bool EtaPtFilterTool::isAccepted ( const HepMC::ConstGenVertexPtr & vtx ) const

protected

Check if a given vertex has at least one in-going or out-going particle within the acceptance (pt+eta)

Definition at line 244 of file EtaPtFilterTool.cxx.

{
  if ( !vtx ) {
    return false;
  }
 
  // check if this vertex looks like a vertex from the hard-scattering
  if ( isFromHardScattering(vtx) ) {
    return true;
  }
 
  // check if this vertex matches some decay pattern given 
  // to the McVtxFilterTool
  if ( m_mcVtxFilterTool->isAccepted(vtx) ) {
    return true;
  }
 
  // ///////////////////////////////////////////////////////////////////////
  // Now we check if at least one in- or out-going particle can be accepted.
  // If yes, then we accept the entire vertex
  //
#ifdef HEPMC3
  // check the parent branch
  for ( const auto& p: vtx->particles_in() ) {
    if ( isAccepted(p) ) {
      return true;
    }
  }//> end loop over parents
#else
  // check the parent branch
  for ( HepMC::GenVertex::particles_in_const_iterator 
      p    = vtx->particles_in_const_begin(),
      pEnd = vtx->particles_in_const_end();
    p != pEnd;
    ++p ) {
    if ( isAccepted(*p) ) {
      return true;
    }
  }//> end loop over parents
#endif  
  
  // check the child branch
  for ( auto p :  *vtx) {
    if ( isAccepted(p) ) {
      return true;
    }
  }//> end loop over children
 
  return false;
}

isFromHardScattering()

bool EtaPtFilterTool::isFromHardScattering ( const HepMC::ConstGenVertexPtr & vtx ) const

protected

Definition at line 441 of file EtaPtFilterTool.cxx.

{
  int partonsin = 0;
  int showerout = 0;
#ifdef HEPMC3  
  for (auto& p: vtx->particles_in()) if (MC::isQuark(p) || MC::isGluon(p)) partonsin++;
#else
  for (auto p = vtx->particles_in_const_begin();p!=vtx->particles_in_const_end();++p ) if (MC::isQuark(*p) || MC::isGluon(*p)) partonsin++;
#endif
  for (auto& p: *vtx) if (p->pdg_id() == 91||p->pdg_id() == 92||p->pdg_id() == 94)  showerout++;
  
  return isPartonVertex(vtx) && (partonsin >= 2) &&  (showerout == 0);
}

isPartonVertex()

bool EtaPtFilterTool::isPartonVertex ( const HepMC::ConstGenVertexPtr & vtx ) const

protected

Definition at line 417 of file EtaPtFilterTool.cxx.

{
 if (!vtx) return false;
#ifdef HEPMC3
 for (auto& p: vtx->particles_in()) {
   if (MC::isHadron(p)&&!MC::isBeam(p)) return false;
   auto pv = p->production_vertex();
   if (pv && !isPartonVertex(pv)) return false;
 }
 for (auto& p: vtx->particles_out()) {
   if (MC::isHadron(p)&&!MC::isBeam(p)) return false;
 }
#else
 for ( auto  p = vtx->particles_in_const_begin(), parentEnd = vtx->particles_in_const_end(); p != parentEnd; ++p ) {
   if (MC::isHadron(*p)&&!MC::isBeam(*p)) return false;
   auto pv = (*p)->production_vertex();
   if (pv && !isPartonVertex(pv)) return false;
}
for ( auto  p = vtx->particles_out_const_begin(), parentEnd = vtx->particles_out_const_end(); p != parentEnd; ++p ) {
   if (MC::isHadron(*p)&&!MC::isBeam(*p)) return false;
 }
#endif 
 return true;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setupInnerEtaRegionCuts()

void EtaPtFilterTool::setupInnerEtaRegionCuts ( Gaudi::Details::PropertyBase & innerEtaRegionCuts )

protected

Callback function to setup the "InnerEtaRegionCuts" property.

Definition at line 497 of file EtaPtFilterTool.cxx.

{
  return;
}

setupOuterEtaRegionCuts()

void EtaPtFilterTool::setupOuterEtaRegionCuts ( Gaudi::Details::PropertyBase & outerEtaRegionCuts )

protected

Callback function to setup the "OuterEtaRegionCuts" property.

Definition at line 502 of file EtaPtFilterTool.cxx.

{
  return;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_butKeepAllGeneratorStable

BooleanProperty EtaPtFilterTool::m_butKeepAllGeneratorStable

protected

Switch to keep all stable generator particles (IsGenStable) regardless what eta or pt cuts are defined.

Definition at line 136 of file EtaPtFilterTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doEtIsolation

BooleanProperty TruthParticleFilterBaseTool::m_doEtIsolation

protectedinherited

Switch to compute or not the Et-isolations for TruthParticle (and their underlying HepMC::GenParticle).

Default is to not compute these Et-isolations (and save CPU)

Definition at line 94 of file TruthParticleFilterBaseTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_innerEtaRegionCuts

DoubleArrayProperty EtaPtFilterTool::m_innerEtaRegionCuts

protected

vector of cuts parameters for the inner region delimited in |eta| 0-th element is the minimum |eta| of this region 1-st element is the maximum |eta| of this region 2-nd element is the minimum pt for the stable particles to be accepted

Definition at line 119 of file EtaPtFilterTool.h.

m_isol_energies

std::map<int,double> EtaPtFilterTool::m_isol_energies

protected

Definition at line 149 of file EtaPtFilterTool.h.

m_isolationTool

IsolTool_t TruthParticleFilterBaseTool::m_isolationTool

protectedinherited

Pointer to the TruthIsolationTool to be able to compute transverse energy isolations for various isolation cones cuts.

See McParticleEvent/TruthParticleParameters.h for cone cuts.

Definition at line 85 of file TruthParticleFilterBaseTool.h.

m_keepAllLeptons

BooleanProperty EtaPtFilterTool::m_keepAllLeptons

protected

Switch to keep all leptons - i.e.

do not apply kinematic cuts on them

Definition at line 145 of file EtaPtFilterTool.h.

m_keepDocumentaries

BooleanProperty EtaPtFilterTool::m_keepDocumentaries

protected

Switch to keep all generator particles which are documentaries (statuscode == 3)

Definition at line 141 of file EtaPtFilterTool.h.

m_mcEventsOutputWriteHandleKey

SG::WriteHandleKey<McEventCollection> TruthParticleFilterBaseTool::m_mcEventsOutputWriteHandleKey {this,"McEventsOutput","GEN_AOD","WriteHandleKey for the output McEventCollection which has been filtered"}

protectedinherited

Location of the output McEventCollection which has been filtered.

Definition at line 104 of file TruthParticleFilterBaseTool.h.

{this,"McEventsOutput","GEN_AOD","WriteHandleKey for the output McEventCollection which has been filtered"};

m_mcEventsReadHandleKey

SG::ReadHandleKey<McEventCollection> TruthParticleFilterBaseTool::m_mcEventsReadHandleKey {this,"McEvents","TruthEvent","ReadHandleKey for input McEventCollection one wants to filter"}

protectedinherited

ReadHandleKey for the input McEventCollection one wants to filter.

Definition at line 100 of file TruthParticleFilterBaseTool.h.

{this,"McEvents","TruthEvent","ReadHandleKey for input  McEventCollection one wants to filter"};

m_mcVtxFilterTool

McVtxFilterTool_t TruthParticleFilterBaseTool::m_mcVtxFilterTool

protectedinherited

Pointer to the McVtxFilterTool to be able to select additional vertices on some decay pattern criterion.

Definition at line 78 of file TruthParticleFilterBaseTool.h.

m_onlyGenerator

BooleanProperty EtaPtFilterTool::m_onlyGenerator

protected

Switch to only include particles from generation and reject particles from detector simulation (Geant4)

Definition at line 131 of file EtaPtFilterTool.h.

m_outerEtaRegionCuts

DoubleArrayProperty EtaPtFilterTool::m_outerEtaRegionCuts

protected

vector of cuts parameters for the outer region delimited in |eta| 0-th element is the minimum |eta| of this region 1-st element is the maximum |eta| of this region 2-nd element is the minimum pt for the stable particles to be accepted

Definition at line 126 of file EtaPtFilterTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• EtaPtFilterTool.h
• EtaPtFilterTool.cxx