McVtxFilterTool Class Reference

AlgTool which filters an input McEventCollection and outputs a new one from the decay patterns it has been setup with. More...

#include <McVtxFilterTool.h>

Inheritance diagram for McVtxFilterTool:

Collaboration diagram for McVtxFilterTool:

Classes
struct	VtxType

Public Member Functions
	McVtxFilterTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~McVtxFilterTool ()
	Destructor:
virtual StatusCode	initialize ()
	Athena Algorithm's Hooks.
virtual StatusCode	execute ()
void	displayOptions () const
	Display the decay pattern of each McVtxFilter this Tool is embedding.
void	stats () const
	Display the statistics for each McVtxFilter this Tool is embedding.
virtual bool	isAccepted (const HepMC::ConstGenVertexPtr &vtx) const
	Return true if one of the McVtxFilters accept this GenVertex.
virtual void	filterMcEventCollection (const McEventCollection *mcCollection, McEventCollection *filterColl)
	Filter the McEventCollection according to the list of McVtxFilter embedded in this AlgTool, and fill the output McEventCollection.
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 ()
	I/O operators.

Protected Member Functions
	McVtxFilterTool ()
	Default constructor:
void	addVertex (const HepMC::ConstGenVertexPtr &vtx, HepMC::GenEvent *evt, const VtxType::Flag vtxType=VtxType::IsNotRootVertex, bool isSignal=false) const
	Add the vertex to the event : nothing very special, just to factorize code Input GenVertex is const because we add a copy of it to the GenEvent.
bool	keepParticle (const VtxType::Flag vtxType, const HepMC::ConstGenParticlePtr &p) const
	Helper function: return true if we are at a root vertex (i.e., a vertex that satisfies one of the chosen decay modes) and if the PDG of the particle is in the m_particles list (or the m_particle list is empty).
void	setupFilters (Gaudi::Details::PropertyBase &decayPatterns)
	Callback method to ensure consistency of filters.
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
StringProperty	m_mcEventsName
	Location of the McEventCollection to be filtered.
StringProperty	m_mcEventsOutputName
	Output McEventCollection location (filtered from the McEventCollection)
StringArrayProperty	m_decayPatterns
	Patterns of the decays to look for (ex: "23 -> -5 + 5" )
BooleanArrayProperty	m_matchSigns
	Booleans to setup each of the McVtxFilter::matchSign.
BooleanArrayProperty	m_matchBranches
	Booleans to setup each of the McVtxFilter::matchBranch.
DataVector< McVtxFilter >	m_filters
	Filters.
std::vector< double >	m_counter
	Stores the total number of filtered vertices for each McVtxFilter.
BooleanProperty	m_doSignalProcessVtx
	Switch to include or not the signal_process_vertex into the McEventCollection (default = true)
BooleanProperty	m_fillTree
	Switch to fill the entire tree from a decay vertex.
LongArrayProperty	m_particles
	List of outgoing particles from the decay vertex to include.

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

AlgTool which filters an input McEventCollection and outputs a new one from the decay patterns it has been setup with.

The decay patterns describe the decay vertices one is looking for and are modeled via a simple std::string. One can specify multiple decay patterns and modify them at the jobOption level via the property "DecayPatterns". One can also explicitly specify to record the signal process vertex of the input McEventCollection into the new one, even if it does not satisfy a single decay pattern in the list of decay vertices to look for.

Note that the real work of the filtering is performed by the McVtxFilter class which is located in the AnalysisUtils package.

Added new properties:

• "FillTree" jobOption allows one to save the HepMC tree of outgoing
  particles from decay vertices chosen by the "DecayPatterns" jobOption.
  
• "KeepParticles" specifies PDG codes of outgoing particles to keep from
  decay vertices specified by "DecayPatterns".
  

ex. suppose have processes like:
u + ubar -> gluon(->jet(s)) + photon(->e+/e- + bremsstrahlung photons)

and want to filter out only the jet(s) from the gluon. Use these jobOptions

DecayPatterns   = [ "-2+2 -> 21 + 22" ] # select the process     
ParticlesToKeep = [ 21 ]             # only keep outgoing gluon      
FillTree        = True               # keep all decay products of the gluon

Definition at line 71 of file McVtxFilterTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

McVtxFilterTool() [1/2]

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

Constructor with parameters:

Public methods:

Constructors

Definition at line 34 of file McVtxFilterTool.cxx.

                                             : 
  AthAlgTool( type, name, parent )
{
  //
  // Property declaration
  // 
  //declareProperty( "Property", m_nProperty );
 
  declareProperty( "McEvents",
           m_mcEventsName = "TruthEvent",
           "Location of the McEventCollection to be filtered" );
 
  declareProperty( "McEventsOutput", 
           m_mcEventsOutputName = "GEN_AOD",
           "Output McEventCollection location (filtered from the "
           "McEventCollection)" );
 
  declareProperty( "DecayPatterns", 
           m_decayPatterns,
           "List of decay patterns the tool will try to match. \n\t"
           "ex: 23 -> -5 + 5 to select Z bosons into bbbar pairs" );
 
  m_decayPatterns.declareUpdateHandler( &McVtxFilterTool::setupFilters, 
                    this );
 
  declareProperty( "MatchSigns", 
           m_matchSigns,
           "List of booleans with which the tool will setup "
           "McVtxFilters. This will setup the McVtxFilter::matchSign "
           "data member." );
  m_matchSigns.declareUpdateHandler( &McVtxFilterTool::setupFilters, 
                     this );
 
  declareProperty( "MatchBranches", 
           m_matchBranches,
           "List of booleans with which the tool will setup "
           "McVtxFilters. This will setup the "
           "McVtxFilter::matchBranches data member." );
 
  m_matchBranches.declareUpdateHandler( &McVtxFilterTool::setupFilters, 
                    this );
 
  declareProperty( "DoSignalProcessVtx", 
           m_doSignalProcessVtx = true,
           "Switch to include or not the signal_process_vertex into "
           "the McEventCollection (default = true).\n" 
           "Note that this is close to useless as the HEPEVT structure"
           " does not hold this kind of informations..." );
 
  declareProperty( "FillTree",        
           m_fillTree = false,
           "Switch to fill the entire decay tree from a decay "
           "vertex.\n"
           "This can be usefull to record for example the whole shower "
           "from a gluon or a quark. In that case, you may want to add "
           "the according PDG ids into the list of particles to keep" );
 
  declareProperty( "ParticlesToKeep", 
           m_particles,
           "List of outgoing particles from the decay vertex to "
           "include. This property has to be configured in sync. with "
           "the 'FillTree' one." );
 
  declareInterface<IMcVtxFilterTool>(this);
}

~McVtxFilterTool()

McVtxFilterTool::~McVtxFilterTool ( )

virtual

Destructor:

Destructor.

Definition at line 104 of file McVtxFilterTool.cxx.

{ 
  ATH_MSG_DEBUG("Calling destructor");
}

McVtxFilterTool() [2/2]

McVtxFilterTool::McVtxFilterTool ( )

protected

Default constructor:

Member Function Documentation

addVertex()

void McVtxFilterTool::addVertex ( const HepMC::ConstGenVertexPtr & vtx, HepMC::GenEvent * evt, const VtxType::Flag vtxType = VtxType::IsNotRootVertex, bool isSignal = false ) const

protected

Add the vertex to the event : nothing very special, just to factorize code Input GenVertex is const because we add a copy of it to the GenEvent.

Const methods:

The last parameter is used here to add (or not) the whole decay tree at a given vertex. (Default: just add the vertex, not the whole tree of children)

Fill the parent branch

Fill the children branch

Definition at line 271 of file McVtxFilterTool.cxx.

{
  ATH_MSG_VERBOSE("In McVtxFilterTool::addVertex( vtxType= "<<vtxType<< " )");
#ifdef HEPMC3
  HepMC::GenVertexPtr vtx = (evt == srcVtx->parent_event()) ? std::const_pointer_cast<HepMC3::GenVertex>(srcVtx) : nullptr ;
  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 (isSignal)  HepMC::set_signal_process_vertex(evt, vtx );
  for ( const auto& parent:  srcVtx->particles_in()) {
    HepMC::GenParticlePtr  mother = (evt == parent->parent_event()) ? std::const_pointer_cast<HepMC3::GenParticle>(parent) : nullptr ;
    if ( ! mother ) {
      mother = HepMC::newGenParticlePtr();
      vtx->add_particle_in( mother );
      mother->set_momentum( parent->momentum() );
      mother->set_generated_mass( parent->generated_mass() );
      mother->set_pdg_id( parent->pdg_id() );
      mother->set_status( parent->status() );
      HepMC::set_flow(mother, HepMC::flow(parent) );
      HepMC::set_polarization(mother, HepMC::polarization(parent) );
      HepMC::suggest_barcode(mother,HepMC::barcode(parent) );
 
    } else {
    // set the mother's decay to our (new) vertex
    vtx->add_particle_in( std::move(mother) );
    }
  }//> loop over ingoing particles
  
  for ( const auto& child: srcVtx->particles_out()) {
    HepMC::GenParticlePtr daughter = (evt == child->parent_event()) ? std::const_pointer_cast<HepMC3::GenParticle>(child) : nullptr ;
    if ( !daughter ) {
      if ( !keepParticle( vtxType, child ) ) {
    // only include selected particles via the "ParticlesToKeep" property
    ATH_MSG_VERBOSE("Skipping outgoing particle id|particle: ["
            << child->pdg_id() << "|" 
            << child << "]");
      } else {
    daughter = HepMC::newGenParticlePtr();
      // set the daughter's production vertex to our new vertex
        vtx->add_particle_out( daughter );
    daughter->set_momentum( child->momentum() );
        daughter->set_generated_mass( child->generated_mass() );
    daughter->set_pdg_id( child->pdg_id() );
    daughter->set_status( child->status() );
    HepMC::set_flow(daughter, HepMC::flow(child) );
    HepMC::set_polarization(daughter, HepMC::polarization(child) );
    HepMC::suggest_barcode(daughter,HepMC::barcode(child) );
 
      }
    }
  
    if ( m_fillTree && keepParticle( vtxType, child ) ) {
      auto decayVertex = child->end_vertex();
      if ( decayVertex ) {
    // recursively fill the tree with all decay vertices and final state
    // particles of selected outgoing particles lines
    // => We are no longer sitting at the decay vertex so we tell it
    // via the IsNotRootVertex flag
    addVertex( decayVertex, evt, VtxType::IsNotRootVertex );
      }
    }
  }//> loop over outgoing particles
#else
  HepMC::GenVertex * vtx = evt->barcode_to_vertex(srcVtx->barcode());
  if ( 0 == vtx ) {
    vtx = HepMC::newGenVertexPtr();
    vtx->set_position( srcVtx->position() );
    vtx->set_id( srcVtx->id() );
    vtx->suggest_barcode( srcVtx->barcode() );
    vtx->weights() = srcVtx->weights();
    evt->add_vertex(vtx);
  }
  if (isSignal)  HepMC::set_signal_process_vertex(evt, vtx );
  for ( HepMC::GenVertex::particles_in_const_iterator parent = srcVtx->particles_in_const_begin();
    parent != srcVtx->particles_in_const_end();
    ++parent ) {
    HepMC::GenParticle * mother = evt->barcode_to_particle( (*parent)->barcode() );
    if ( 0 == mother ) {
      mother = HepMC::newGenParticlePtr();
      mother->set_momentum( (*parent)->momentum() );
      mother->set_generated_mass( (*parent)->generated_mass() );
      mother->set_pdg_id( (*parent)->pdg_id() );
      mother->set_status( (*parent)->status() );
      mother->set_flow( (*parent)->flow() );
      mother->set_polarization( (*parent)->polarization() );
      mother->suggest_barcode( (*parent)->barcode() );
 
    }
    // set the mother's decay to our (new) vertex
    vtx->add_particle_in( mother );
    
  }//> loop over ingoing particles
  
  for ( HepMC::GenVertex::particles_out_const_iterator child = srcVtx->particles_out_const_begin();
    child != srcVtx->particles_out_const_end();
    ++child ) {
    HepMC::GenParticle * daughter = evt->barcode_to_particle( (*child)->barcode() );
    if ( 0 == daughter ) {
      if ( !keepParticle( vtxType, *child ) ) {
    // only include selected particles via the "ParticlesToKeep" property
    ATH_MSG_VERBOSE("Skipping outgoing particle : "<< (*child));
      } else {
    daughter = HepMC::newGenParticlePtr();
    daughter->set_momentum( (*child)->momentum() );
   daughter->set_generated_mass( (*child)->generated_mass() );
    daughter->set_pdg_id( (*child)->pdg_id() );
    daughter->set_status( (*child)->status() );
    daughter->set_flow( (*child)->flow() );
    daughter->set_polarization( (*child)->polarization() );
    daughter->suggest_barcode( (*child)->barcode() );
 
      }
    }
    if ( daughter ) {
      // set the daughter's production vertex to our new vertex
      vtx->add_particle_out( daughter );
    }
 
    if ( m_fillTree && keepParticle( vtxType, *child ) ) {
      const HepMC::GenVertex * decayVertex = (*child)->end_vertex();
      if ( 0 != decayVertex ) {
    // recursively fill the tree with all decay vertices and final state
    // particles of selected outgoing particles lines
    // => We are no longer sitting at the decay vertex so we tell it
    // via the IsNotRootVertex flag
    addVertex( decayVertex, evt, VtxType::IsNotRootVertex );
      }
    }
  }//> loop over outgoing particles
#endif
 
  }

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

displayOptions()

void McVtxFilterTool::displayOptions ( ) const

virtual

Display the decay pattern of each McVtxFilter this Tool is embedding.

Const methods:

Implements IMcVtxFilterTool.

Definition at line 162 of file McVtxFilterTool.cxx.

{
  msg(MSG::INFO)
    << "Options for " << name() << " :" << endmsg
    << "\tDecay Patterns: [ ";
  for (const auto & itr : m_decayPatterns.value()) {
    msg(MSG::INFO) << itr << "; ";
  }
  msg(MSG::INFO) << "]" << endmsg;
 
  msg(MSG::INFO) << "Particles to keep: [";
  for (long itr : m_particles.value()) {
    msg(MSG::INFO) << itr << ", ";
  }
  msg(MSG::INFO) << "]" << endmsg;
}

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 McVtxFilterTool::execute ( )

virtual

Implements IMcVtxFilterTool.

Definition at line 126 of file McVtxFilterTool.cxx.

{  
  StatusCode sc = StatusCode::SUCCESS;
 
  ATH_MSG_DEBUG("Executing " << name() << "...");
 
  ATH_MSG_VERBOSE("Retrieve the McEventCollection to be filtered for");
  const McEventCollection * mcColl = nullptr;
  sc = evtStore()->retrieve( mcColl, m_mcEventsName );
 
  if ( sc.isFailure() || nullptr == mcColl ) {
    msg(MSG::ERROR)
      << "Failed to retrieve McEventCollection at : "
      << m_mcEventsName
      << endmsg
      << "because : sc= " << ( sc.isFailure() ? "FAILURE" : "OK" ) 
      << " and mcEvent= " << mcColl
      << endmsg;
    return StatusCode::SUCCESS;
  } 
 
  ATH_MSG_VERBOSE("Create a new McEventCollection which will hold the "\
          "filtered GenEvent");
  McEventCollection * filteredColl = new McEventCollection;
  sc = evtStore()->record(filteredColl, m_mcEventsOutputName, true);
  sc = evtStore()->setConst(filteredColl);
  ATH_MSG_VERBOSE("Recorded and locked in StoreGate");
  
  filterMcEventCollection( mcColl, filteredColl );
  return sc;
}

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

filterMcEventCollection()

void McVtxFilterTool::filterMcEventCollection ( const McEventCollection * mcCollection, McEventCollection * filterColl )

virtual

Filter the McEventCollection according to the list of McVtxFilter embedded in this AlgTool, and fill the output McEventCollection.

Non-const methods:

Create a set with ids of copied vertices.

Local copy of the GenEvent from StoreGate

Create the event container, with Signal Process and event number from the GenEvent source

Handling the signal_process_vertex stuff Signal_process_vertex pointer is not set by all generators, but in case it has been set up, one should keep this usefull information, shouldn't we ? So first we check it is present in the original GenEvent, and then we check if it as not already added by any previous McVtxFilter (by chance or because it was just meant to be)

Implements IMcVtxFilterTool.

Definition at line 205 of file McVtxFilterTool.cxx.

{
  if ( nullptr == mcColl ) {
    ATH_MSG_ERROR("McEventCollection is NULL pointer !!");
    return;
  }

  std::set<int> bcToFullVtx;

  const HepMC::GenEvent * evtSrc = (*mcColl->begin());
  
  HepMC::GenEvent * evt = HepMC::copyemptyGenEvent(evtSrc);
  for ( const auto& itrPart: *evtSrc) {
    auto dcyVtx = itrPart->end_vertex();
    if ( !dcyVtx ) continue;
    int vtxBC = HepMC::barcode_or_id(dcyVtx);
    if (bcToFullVtx.count(vtxBC)!=0) continue;
    ATH_MSG_VERBOSE("Doing vtx: " << dcyVtx);
 
    int i = 0;
    for( DataVector<McVtxFilter>::const_iterator filter = m_filters.begin(); filter != m_filters.end(); ++filter,++i ) {
      ATH_MSG_VERBOSE("Processing with filter[" << i << "]...");
      if ( !(*filter)->isAccepted( dcyVtx ) ) continue;
      m_counter[i] += 1;
      ATH_MSG_VERBOSE("Filter[" << i << "] accepted this vtx : " << dcyVtx);
      bcToFullVtx.insert(vtxBC);
      addVertex( dcyVtx, evt, VtxType::IsRootVertex );
      break;
    }//> end loop over filters
  }//> loop over particles
 
  if ( m_doSignalProcessVtx ) {
    auto sigProcVtx = HepMC::signal_process_vertex(evtSrc);
    if ( sigProcVtx ) {
      if ( bcToFullVtx.count(HepMC::barcode_or_id(sigProcVtx)) == 0) {
        addVertex( sigProcVtx, evt,VtxType::IsNotRootVertex, true );
      }//> signal process vertex has to be added
    } else {
      //> Original GenEvent has a NO signal process vertex set-up
      ATH_MSG_DEBUG("You asked to record signal_process_vertex but :" << endmsg << " there is NO signal_process_vertex in this event !!");
    }
  
  } //> end do SignalProcessVtx
 
  TruthHelper::copyBeamParticles (*evtSrc, *evt);
 
  filterColl->push_back(evt);
}

initialize()

StatusCode McVtxFilterTool::initialize ( )

virtual

Athena Algorithm's Hooks.

Implements IMcVtxFilterTool.

Definition at line 111 of file McVtxFilterTool.cxx.

{
  ATH_MSG_DEBUG("Initializing " << name() << "...");
 
  if ( msgLvl(MSG::DEBUG) ) {
    displayOptions();
  }
 
  // configure the filters with the provided DecayPatterns (from
  // jobO or via the property interface
  setupFilters( m_decayPatterns );
 
  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 & IMcVtxFilterTool::interfaceID ( )

inlinestaticinherited

I/O operators.

Inline methods:

Definition at line 82 of file IMcVtxFilterTool.h.

{ 
   return IID_IMcVtxFilterTool; 
}

isAccepted()

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

virtual

Return true if one of the McVtxFilters accept this GenVertex.

Implements IMcVtxFilterTool.

Definition at line 189 of file McVtxFilterTool.cxx.

{
  for(const auto *filter : m_filters) {
    if ( filter->isAccepted( vtx ) ) {
      return true;
    }
  }//> end loop over McVtxFilters
 
  return false;
}

keepParticle()

bool McVtxFilterTool::keepParticle ( const VtxType::Flag vtxType, const HepMC::ConstGenParticlePtr & p ) const

protected

Helper function: return true if we are at a root vertex (i.e., a vertex that satisfies one of the chosen decay modes) and if the PDG of the particle is in the m_particles list (or the m_particle list is empty).

Definition at line 415 of file McVtxFilterTool.cxx.

{
  // no particle, so no particle to keep. Simple, isn't ?
  if ( nullptr == part ) {
    return false;
  }
 
  // By default, we keep all particles
  if ( m_particles.value().empty() ) {
    return true;
  }
 
  // only filter decay particles of the root vertex
  // ie: the vertex which matches a decay pattern setup by the
  // "DecayPatterns" property.
  if ( vtxType == VtxType::IsNotRootVertex ) {
    return true;
 
  } else if ( vtxType == VtxType::IsRootVertex ) {
    // we are at a Root vertex.
    // And we only keep the outgoing particles which are in our list
    const int pdgId = part->pdg_id();
    return std::find( m_particles.value().begin(), 
            m_particles.value().end(), 
            pdgId ) != m_particles.value().end();
  } else {
    
    // Humm.. we don't know anything about this VtxType...
    // by default we keep all particles
    // But we tell user that something is wrong !
    msg(MSG::WARNING)
      << "In keepParticle: Don't know anything about this VtxType ["
      << vtxType << "] !!"
      << endmsg
      << "We'll keep this particle [ " << part 
      << "] but : Check your jobOption !!"
      << endmsg;
    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();
  }

setupFilters()

void McVtxFilterTool::setupFilters ( Gaudi::Details::PropertyBase & decayPatterns )

protected

Callback method to ensure consistency of filters.

Method to ensure the synchronisation between the filters and the decay patterns they are supposed to match. This is to cope with the case where this tool is called by some parent AlgTool/Algorithm which wants to override the DecayPatterns property given by the JobOptionSvc. We ensure the consistency between those 2 entities by defining a callback function (@setupFilters) to perform the job.

Definition at line 461 of file McVtxFilterTool.cxx.

{
  m_filters.clear();
  m_counter.clear();
  
  const std::vector<std::string>& decayPatterns = m_decayPatterns.value();
  std::vector<bool> matchSigns    = m_matchSigns.value();
  std::vector<bool> matchBranches = m_matchBranches.value();
 
  // Normally, using the Configurables, the lengths of properties should
  // be the same... but who knows. Better test it.
  // On the other hand, for compatibility reasons, we allow the situation
  // where *both* matchSigns and matchBranches are empty.
  // Only after having removed the "old-style" case we can raise an exception.
  const bool oldCfg = ( m_matchSigns.value().empty() &&
            m_matchBranches.value().empty() );
  if ( !oldCfg && 
       ( decayPatterns.size() != matchSigns.size() ||
     decayPatterns.size() != matchBranches.size() ||
     matchSigns.size()    != matchBranches.size() ) ) {
    std::string error;
    error  = "Lengths of ArrayProperty configuring McVtxFilters ";
    error += "are DIFFERING !!";
    msg(MSG::WARNING)
      << "In setupFilter: " << error 
      << endmsg
      << "\t# decayPatterns: " << decayPatterns.size() << endmsg
      << "\t# matchSigns:    " << matchSigns.size()    << endmsg
      << "\t# matchBranches: " << matchBranches.size() << endmsg
      << "Reference size is 'decayPatterns':" << endmsg
      << "\t==> Will fill holes with default values !" << endmsg
      << "\t==> Will drop extra values !"
      << endmsg;
    //throw std::runtime_error(error);
  }
 
  const unsigned int nDecayPatterns = decayPatterns.size();
  m_filters.resize( nDecayPatterns );
  m_counter.resize( nDecayPatterns, 0 );
 
  if ( nDecayPatterns > matchSigns.size() ) {
    // fill it  with default values
    const unsigned int nCount = nDecayPatterns - matchSigns.size();
    std::fill_n( std::back_inserter(matchSigns),
         nCount, // number of times we fill it
         false );// default value
  }
 
  if ( nDecayPatterns > matchBranches.size() ) {
    // fill it  with default values
    const unsigned int nCount = nDecayPatterns - matchBranches.size();
    std::fill_n( std::back_inserter(matchBranches),
         nCount, // number of times we fill it
         false );// default value
  }
 
  for ( unsigned int i = 0; i != nDecayPatterns; ++i ) {
    m_filters[i] = new McVtxFilter( decayPatterns[i],
                    bool(matchSigns[i]),
                    bool(matchBranches[i]) );
  }
 
  }

stats()

void McVtxFilterTool::stats ( ) const

virtual

Display the statistics for each McVtxFilter this Tool is embedding.

Implements IMcVtxFilterTool.

Definition at line 179 of file McVtxFilterTool.cxx.

{
  msg(MSG::INFO) << "Statistics for each filter : " << endmsg;
  for( unsigned int i = 0; i < m_counter.size(); ++i ) {
    msg(MSG::INFO)
      << "\t==> [" << m_decayPatterns.value()[i] << "] accepted " 
      << m_counter[i] << " vertices" << endmsg;
  }
  }

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_counter

std::vector<double> McVtxFilterTool::m_counter

protected

Stores the total number of filtered vertices for each McVtxFilter.

Definition at line 201 of file McVtxFilterTool.h.

m_decayPatterns

StringArrayProperty McVtxFilterTool::m_decayPatterns

protected

Patterns of the decays to look for (ex: "23 -> -5 + 5" )

Definition at line 185 of file McVtxFilterTool.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_doSignalProcessVtx

BooleanProperty McVtxFilterTool::m_doSignalProcessVtx

protected

Switch to include or not the signal_process_vertex into the McEventCollection (default = true)

Definition at line 206 of file McVtxFilterTool.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_fillTree

BooleanProperty McVtxFilterTool::m_fillTree

protected

Switch to fill the entire tree from a decay vertex.

Definition at line 210 of file McVtxFilterTool.h.

m_filters

DataVector<McVtxFilter> McVtxFilterTool::m_filters

protected

Filters.

Definition at line 197 of file McVtxFilterTool.h.

m_matchBranches

BooleanArrayProperty McVtxFilterTool::m_matchBranches

protected

Booleans to setup each of the McVtxFilter::matchBranch.

Definition at line 193 of file McVtxFilterTool.h.

m_matchSigns

BooleanArrayProperty McVtxFilterTool::m_matchSigns

protected

Booleans to setup each of the McVtxFilter::matchSign.

Definition at line 189 of file McVtxFilterTool.h.

m_mcEventsName

StringProperty McVtxFilterTool::m_mcEventsName

protected

Location of the McEventCollection to be filtered.

Definition at line 177 of file McVtxFilterTool.h.

m_mcEventsOutputName

StringProperty McVtxFilterTool::m_mcEventsOutputName

protected

Output McEventCollection location (filtered from the McEventCollection)

Definition at line 181 of file McVtxFilterTool.h.

m_particles

LongArrayProperty McVtxFilterTool::m_particles

protected

List of outgoing particles from the decay vertex to include.

Definition at line 214 of file McVtxFilterTool.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:

• McVtxFilterTool.h
• McVtxFilterTool.cxx