McVtxFilter Class Reference

McVtxFilter allows to select HepMC::GenParticle based on the decay pattern. More...

#include <McVtxFilter.h>

Inheritance diagram for McVtxFilter:

Collaboration diagram for McVtxFilter:

Public Member Functions
	McVtxFilter ()
	Default constructor:
	McVtxFilter (const McVtxFilter &rhs)
	Copy constructor:
	McVtxFilter (const std::string &decayPattern, const bool matchSign=false, const bool matchBranches=false)
	Constructor with parameters:
	McVtxFilter (const bool matchSign, const bool matchBranches)
	Constructor with parameters:
virtual	~McVtxFilter ()
	Destructor:
McVtxFilter &	operator= (const McVtxFilter &rhs)
	Assignment operator:
virtual bool	isAccepted (HepMC::ConstGenVertexPtr vtx) const
	Main filter method.
void	dump (std::ostream &out=std::cout) const
	Dump to std::ostream (default = std::cout) the decay pattern the filter one is looking for.
bool	isFullVtx () const
	returns true if the vertex filter requires a parent AND a child list ie: returns false if the filter looks only for a lonely particle (eg: a photon or an electron, see TruthParticleAlgs for a concrete example)
bool	matchSign () const
	return true if the filter discriminates the sign of the particles
bool	matchBranches () const
	return true if the filter strictly matchs the number of output particles eg: a vertex t->Wbgg won't be selected if matchBranches == true and decay pattern = "#id 6[24,5]"
const std::string &	decayPattern () const
	return the decay pattern used by this filter
const DataVector< const ParticleCandidateList > &	parentList () const
	return the list of particle candidates for the input particles (parent)
const DataVector< const ParticleCandidateList > &	childList () const
	return the list of particle candidates for the output particles (child)
virtual void	setFilter (const IFilterCuts *filter)
	Set filter cut options.
void	setMatchSign (const bool matchSign)
	Set if one wants to discriminate the sign of the particles.
void	setMatchBranches (const bool matchVtxBranches)
	Set if one wants to strictly match the number of output particles.
void	setDecayPattern (const std::string &decayPattern)
	Set the decay pattern to look for : it correctly setups the parent and children according to the LaTeX-like string which is given as argument.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Member Functions
bool	checkParentBranch (HepMC::ConstGenVertexPtr vtx) const
	Check if the parent branch fulfills the requirements.
bool	checkChildBranch (HepMC::ConstGenVertexPtr vtx) const
	Check if the child branch fulfills the requirements.
bool	checkTwoBodyDecay (HepMC::ConstGenVertexPtr vtx) const
	Check the branches for the special case of a 1->2 body decay (there is some room for optimisation in that particular case).

Protected Attributes
bool	m_matchSign
	Discrimination between particles and conjugates.
bool	m_matchBranches
	Tell if one wants a strict vertex branches matching.
std::string	m_decayPattern
	The decay pattern one looks for.
DataVector< const ParticleCandidateList >	m_parentList
	The list of the matching particles Ids : each item in DataVector stands for an entering branch to the vertex.
DataVector< const ParticleCandidateList >	m_childList
	The list of the matching particles Ids : each item in DataVector stands for an out-going branch to the vertex.

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

McVtxFilter allows to select HepMC::GenParticle based on the decay pattern.

Hopefully one will be able to also select the particles by pt (in a coming patch). It uses internally the DecayPattern class to build the filtering decision The basic modus operandi is to loop on HepMC::GenVertex (of a given HepMC::GenEvent) to select the ones which are of interest (and fulfill the decay pattern).

Definition at line 44 of file McVtxFilter.h.

Constructor & Destructor Documentation

McVtxFilter() [1/4]

McVtxFilter::McVtxFilter

(

)

Default constructor:

Public methods:

Constructors

Definition at line 32 of file McVtxFilter.cxx.

                         : 
  IFilterCuts(),
  AthMessaging ( "McVtxFilter" ),
  m_matchSign( false ),
  m_matchBranches( false ),
  m_decayPattern( "" ),
  m_parentList(),
  m_childList()
{}

McVtxFilter() [2/4]

McVtxFilter::McVtxFilter

(

const McVtxFilter &

rhs

)

Copy constructor:

Definition at line 67 of file McVtxFilter.cxx.

                                                 : 
  IFilterCuts    ( rhs                 ),
  AthMessaging ( "McVtxFilter" ),
  m_matchSign    ( rhs.m_matchSign     ),
  m_matchBranches( rhs.m_matchBranches ),
  m_decayPattern ( rhs.m_decayPattern  ),
  m_parentList(),
  m_childList()
{
  // deep copy of the parent branch
  m_parentList.reserve( rhs.m_parentList.size() );
  for ( DataVector<const ParticleCandidateList>::const_iterator itr = 
      rhs.m_parentList.begin();
    itr != rhs.m_parentList.end();
    ++itr ) {
    m_parentList.push_back( new ParticleCandidateList(**itr) );
  }
 
  // deep copy of the child branch
  m_childList.reserve( rhs.m_childList.size() );
  for ( DataVector<const ParticleCandidateList>::const_iterator itr = 
      rhs.m_childList.begin();
    itr != rhs.m_childList.end();
    ++itr ) {
    m_childList.push_back( new ParticleCandidateList(**itr) );
  }
}

McVtxFilter() [3/4]

McVtxFilter::McVtxFilter	(	const std::string &	decayPattern,
		const bool	matchSign = false,
		const bool	matchBranches = false )

Constructor with parameters:

Definition at line 42 of file McVtxFilter.cxx.

                                         : 
  IFilterCuts(),
  AthMessaging ( "McVtxFilter" ),
  m_matchSign( matchSign ),
  m_matchBranches( matchBranches ),
  m_decayPattern( decayPattern ),
  m_parentList(),
  m_childList()
{
  setDecayPattern(decayPattern);
}

McVtxFilter() [4/4]

McVtxFilter::McVtxFilter	(	const bool	matchSign,
		const bool	matchBranches )

Constructor with parameters:

Definition at line 56 of file McVtxFilter.cxx.

                                         : 
  IFilterCuts(),
  AthMessaging ( "McVtxFilter" ),
  m_matchSign( matchSign ),
  m_matchBranches( matchBranches ),
  m_decayPattern( "" ),
  m_parentList(),
  m_childList()
{}

~McVtxFilter()

McVtxFilter::~McVtxFilter ( )

inlinevirtual

Destructor:

Definition at line 199 of file McVtxFilter.h.

{}

Member Function Documentation

checkChildBranch()

bool McVtxFilter::checkChildBranch ( HepMC::ConstGenVertexPtr vtx ) const

protected

Check if the child branch fulfills the requirements.

Check we aren't in the "any particle" case

Check there is enough outgoing particles in the current vertex

Definition at line 356 of file McVtxFilter.cxx.

{
  ATH_MSG_VERBOSE("In checkChildBranch...");
 
  if ( msgLvl(MSG::VERBOSE) ) {
    HepMC::Print::line(std::cout,vtx);
  }

  if ( m_childList.empty() ) {
    return true;
  }

  if ( static_cast<unsigned int>(vtx->particles_out_size()) < m_childList.size() ) return false;
  ATH_MSG_VERBOSE("Number of list of children : " << m_childList.size());
 
  std::vector<int> childIds;
  for ( auto Part: *vtx) {
    childIds.push_back( Part->pdg_id() );
  }
 
  AnalysisUtils::Permutation<std::vector<int> > permute( &childIds, m_childList.size() );
  std::vector<int> children;
 
  bool accepted = false;
  while ( permute.get(children) && !accepted ) {
    accepted = true;
    const unsigned int iMax = std::min( m_childList.size(), childIds.size() );
    for ( unsigned int i = 0; i != iMax; ++i ) {
      const bool hasInList = m_childList[i]->hasInList( children[i], m_matchSign );
      if ( !hasInList ) {
    // this permutation is not suiting, going to the next one (if any)
    accepted = false;
    break;
      }
    }
  }
 
  ATH_MSG_VERBOSE(">>> CheckChildBranch is DONE : "
                  << ( accepted ? "accept" : "reject" )
                  << " vtx= " << vtx);
  return accepted;
}

checkParentBranch()

bool McVtxFilter::checkParentBranch ( HepMC::ConstGenVertexPtr vtx ) const

protected

Check if the parent branch fulfills the requirements.

Protected methods:

Check we aren't in the "any particle" case

Check if number of parents is OK

Definition at line 298 of file McVtxFilter.cxx.

{
  ATH_MSG_VERBOSE("In checkParentBranch...");

  if ( m_parentList.empty() ) {
    return true;
  }
  
  if ( msgLvl(MSG::VERBOSE) ) {
    HepMC::Print::line(std::cout,vtx);
  }

  if ( static_cast<unsigned int>(vtx->particles_in_size()) < m_parentList.size() ){
    return false;
  }
 
  if ( msgLvl(MSG::VERBOSE) ) {
    msg() << MSG::VERBOSE
          << "Number of list of parents : "
          << m_parentList.size()
          << endmsg;
    m_parentList.front()->dropList();
  }
 
  std::vector<int> parentIds;
  for ( const auto& Part: vtx->particles_in() ) {
    parentIds.push_back( Part->pdg_id() );
  }
  AnalysisUtils::Permutation<std::vector<int> > permute( &parentIds, m_parentList.size() );
  std::vector<int> parents;
 
  bool accepted = false;
  while ( permute.get(parents) && !accepted ) {
    accepted = true;
    const unsigned int iMax = std::min( m_parentList.size(), parentIds.size() );
    for ( unsigned int i = 0; i != iMax; ++i ) {
      const bool hasInList = m_parentList[i]->hasInList( parents[i],m_matchSign );
      if ( !hasInList ) {
    // this permutation is not suiting, going to the next one (if any)
    accepted = false;
    break;
      }
    }
 
    // everything went fine for this permutation !
    if ( accepted ) {
      break;
    }
  }
 
  ATH_MSG_VERBOSE(">>> CheckParentBranch is DONE : "
                  << ( accepted ? "accept" : "reject" )
                  << " vtx= " << vtx);
  return accepted;
}

checkTwoBodyDecay()

bool McVtxFilter::checkTwoBodyDecay ( HepMC::ConstGenVertexPtr vtx ) const

protected

Check the branches for the special case of a 1->2 body decay (there is some room for optimisation in that particular case).

First check the parent branch matching decision if it doesn't fulfil our requirements, it is not worth continuing the process

Now, handle the child branch

Cache the 2 particle candidate lists

Cache the id of the outgoing particles of the vertex being analysed

Loop over candidates for the 1st child

Loop over candidate for the 2nd child

If the strict match sign has been required, we check if the PDG ids are matching

if we are in a loose sign request, we check only that the absolute values of the pdg IDs are matching

If we are here, then the vertex candidate didn't fulfil the requirements we have setup

Definition at line 401 of file McVtxFilter.cxx.

{
  ATH_MSG_VERBOSE("In checkTwoBodyDecay...");

  const bool parentTree = checkParentBranch( vtx );
  if ( parentTree == false ) {
    return false;
  }

  ATH_MSG_VERBOSE(">>> Check child branch");

  const ParticleCandidateList * children1 = m_childList[0];
  const ParticleCandidateList * children2 = m_childList[1];

//AV It would be a very good idea to have a chack of the number of output particles here.
  const int pdgId1= vtx->particles_out().at(0)->pdg_id();
  const int pdgId2= vtx->particles_out().at(1)->pdg_id();

  for( ParticleCandidateList::const_iterator itr1 = children1->begin();
       itr1 != children1->end();
       ++itr1 ) {
    for( ParticleCandidateList::const_iterator itr2 = children2->begin();
     itr2 != children2->end();
     ++itr2 ) {
      ATH_MSG_VERBOSE("Checking the pair : " << (*itr1) << "/" << (*itr2));

      if ( m_matchSign && 
       ( ( (*itr1) == pdgId1 && (*itr2) == pdgId2 ) ||
         ( (*itr1) == pdgId2 && (*itr2) == pdgId1 ) ) ) {
    ATH_MSG_VERBOSE("Strict sign matching found !");
    return true;
      } else if ( ( std::abs(*itr1) == std::abs(pdgId1) && 
            std::abs(*itr2) == std::abs(pdgId2) )   ||
          ( std::abs(*itr1) == std::abs(pdgId2) && 
            std::abs(*itr2) == std::abs(pdgId1) ) ) {
    ATH_MSG_VERBOSE("Loose sign matching found !");
    return true;
      }
      ATH_MSG_VERBOSE("Checking next pair");
    }//> loop over 2nd child's candidates
  }//> loop over 1st child's candidates

  ATH_MSG_VERBOSE(">>> CheckTwoBodyDecay is DONE.");
  return false;
}

childList()

const DataVector< const ParticleCandidateList > & McVtxFilter::childList ( ) const

inline

return the list of particle candidates for the output particles (child)

Definition at line 236 of file McVtxFilter.h.

{
  return m_childList;
}

decayPattern()

const std::string & McVtxFilter::decayPattern ( ) const

inline

return the decay pattern used by this filter

Definition at line 224 of file McVtxFilter.h.

{
  return m_decayPattern;
}

dump()

void McVtxFilter::dump

(

std::ostream &

out = std::cout

)

const

Dump to std::ostream (default = std::cout) the decay pattern the filter one is looking for.

Definition at line 197 of file McVtxFilter.cxx.

{
  out << ">>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<" << std::endl;
  out << ">>> Parents : " << std::endl;
  for ( DataVector<const ParticleCandidateList>::const_iterator itr = m_parentList.begin();
    itr != m_parentList.end();
    ++itr ) {
    out << "\nList for : " << *itr  
    << " (" << (*itr)->size() << ")" << std::endl;
    (*itr)->dropList();
  }
 
  out << ">>> Children : " << std::endl;
  for ( DataVector<const ParticleCandidateList>::const_iterator itr = m_childList.begin();
    itr != m_childList.end();
    ++itr ) {
    out << "\nList for : " << *itr  
    << " (" << (*itr)->size() << ")" << std::endl;
    (*itr)->dropList();
  }
  out << ">>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<" << std::endl;
 
  return;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

isAccepted()

bool McVtxFilter::isAccepted ( HepMC::ConstGenVertexPtr vtx ) const

virtual

Main filter method.

Const methods:

This method takes the decision whether or not the filter has to accept the vertex. It checks if the vertex has the required number of ingoing particles the required number of outgoing particles. Then for each branch (parent child) it checks if the particle can match an asked for particle.

First handle special case where the filter has only 1 child and no parent : one is looking for a stable particle with no end_vertex

Skip vertices which don't match the number of branches we are looking for : check if number of parents and of children is OK

Then handle the case we are looking for a 1->2 body decay

Handle other generic cases

Definition at line 128 of file McVtxFilter.cxx.

{
  ATH_MSG_VERBOSE("In McVtxFilter::isAccepted(...)");
//AV TODO: add here a check to prevent null pointer dereference
  unsigned int number_particles_out = vtx->particles_out_size();
  unsigned int number_particles_in  = vtx->particles_in_size();
  if ( m_childList.size()        == static_cast<unsigned int>( 1 ) &&
       m_parentList.size()       == static_cast<unsigned int>( 0 ) &&
       number_particles_out == static_cast<unsigned int>( 1 ) ) {
    const HepMC::ConstGenParticlePtr& part = vtx->particles_out().front();
    const ParticleCandidateList * item = *( m_childList.begin() );
    if ( item->hasInList( part->pdg_id(),  m_matchSign ) ) {
      return true;
    } else { 
      return false;
    }
  }

  if ( !m_matchBranches ) {
 
    //
    // Test only if there is enough *output* branches to match for
    //
    if ( number_particles_in  < m_parentList.size() ||
     number_particles_out < m_childList.size()  ) {
      return false;
    }
 
  } else {
    //
    // Strict match of output branches
    //
    if ( number_particles_in  != m_parentList.size() ||
     number_particles_out != m_childList.size()  ) {
      return false;
    }
  }

  if ( m_matchBranches                                           &&
       m_parentList.size()       == static_cast<unsigned int>(1) &&
       m_childList.size()        == static_cast<unsigned int>(2) &&
       number_particles_out >= 2 ) {
    return checkTwoBodyDecay( std::move(vtx) );
  } //> two-body decay
 

  ATH_MSG_VERBOSE("trying checkParentBranch(...)");
  if ( checkParentBranch( vtx ) == false ) return false;
 
  ATH_MSG_VERBOSE("trying checkChildBranch(...)");
  if ( checkChildBranch ( std::move(vtx) ) == false ) return false;
 
  ATH_MSG_VERBOSE("McVtxFilter::isAccepted(...) => DONE");
  return true;
}

isFullVtx()

bool McVtxFilter::isFullVtx ( ) const

inline

returns true if the vertex filter requires a parent AND a child list ie: returns false if the filter looks only for a lonely particle (eg: a photon or an electron, see TruthParticleAlgs for a concrete example)

Definition at line 205 of file McVtxFilter.h.

{
  if ( m_parentList.empty() || m_childList.empty() ) {
    return false;
  } else {
    return true;
  }
}

matchBranches()

bool McVtxFilter::matchBranches ( ) const

inline

return true if the filter strictly matchs the number of output particles eg: a vertex t->Wbgg won't be selected if matchBranches == true and decay pattern = "#id 6[24,5]"

Definition at line 219 of file McVtxFilter.h.

{
  return m_matchBranches;
}

matchSign()

bool McVtxFilter::matchSign ( ) const

inline

return true if the filter discriminates the sign of the particles

Definition at line 214 of file McVtxFilter.h.

{
  return m_matchSign;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

operator=()

McVtxFilter & McVtxFilter::operator=

(

const McVtxFilter &

rhs

)

Assignment operator:

Definition at line 95 of file McVtxFilter.cxx.

{
  if ( this != &rhs ) {
    IFilterCuts::operator=(rhs);
    m_matchSign     = rhs.m_matchSign;
    m_matchBranches = rhs.m_matchBranches;
    m_decayPattern  = rhs.m_decayPattern;
 
    // deep copy of the parent branch
    m_parentList.reserve( rhs.m_parentList.size() );
    for ( DataVector<const ParticleCandidateList>::const_iterator itr = 
        rhs.m_parentList.begin();
      itr != rhs.m_parentList.end();
      ++itr ) {
      m_parentList.push_back( new ParticleCandidateList(**itr) );
    }
 
    // deep copy of the child branch
    m_childList.reserve( rhs.m_childList.size() );
    for ( DataVector<const ParticleCandidateList>::const_iterator itr = 
        rhs.m_childList.begin();
      itr != rhs.m_childList.end();
      ++itr ) {
      m_childList.push_back( new ParticleCandidateList(**itr) );
    }
  }
  return *this;
}

parentList()

const DataVector< const ParticleCandidateList > & McVtxFilter::parentList ( ) const

inline

return the list of particle candidates for the input particles (parent)

Definition at line 230 of file McVtxFilter.h.

{
  return m_parentList;
}

setDecayPattern()

void McVtxFilter::setDecayPattern

(

const std::string &

decayPattern

)

Set the decay pattern to look for : it correctly setups the parent and children according to the LaTeX-like string which is given as argument.

Set the filter from a decay pattern.

Definition at line 243 of file McVtxFilter.cxx.

{
  // clear parent and child candidates
  m_parentList.clear();
  m_childList.clear();
 
  m_decayPattern = decayPattern;
  
  DecayParser parser( m_decayPattern );
  
  std::vector<std::vector<std::string> > parents = parser.getParents();
  for(std::vector<std::vector<std::string> >::const_iterator itr = parents.begin();
      itr != parents.end();
      ++itr ) {
    ParticleCandidateList * list = new ParticleCandidateList();
    const std::vector<std::string>::const_iterator candEnd  = itr->end();
    for( std::vector<std::string>::const_iterator candidate = itr->begin();
     candidate != candEnd;
     ++candidate ) {
      int pdgID = parser.pdgId( *candidate );
      list->push_back( pdgID );
    }
    if ( ! list->empty() ) {
      m_parentList.push_back( list );
    } else {
      delete list;
    }
  }
  std::vector<std::vector<std::string> > children = parser.getChildren();
  for(std::vector<std::vector<std::string> >::const_iterator itr = children.begin();
      itr != children.end();
      ++itr ) {
    ParticleCandidateList * list = new ParticleCandidateList();
    const std::vector<std::string>::const_iterator candEnd  = itr->end();
    for( std::vector<std::string>::const_iterator candidate = itr->begin();
     candidate != candEnd;
     ++candidate ) {
      int pdgID = parser.pdgId( *candidate );
      list->push_back( pdgID );
    }
    if ( ! list->empty() ) {
      m_childList.push_back( list );
    } else {
      delete list;
    }
  }
 
  return;
}

setFilter()

void McVtxFilter::setFilter ( const IFilterCuts * filter )

virtual

Set filter cut options.

Non-const methods:

Set filter cut options

Implements IFilterCuts.

Definition at line 228 of file McVtxFilter.cxx.

{
  if ( filter ) {
    const McVtxFilter * vtxFilter = 
      dynamic_cast<const McVtxFilter*>(filter);
    
    if ( vtxFilter ) {
      operator=(*vtxFilter);
    } else {
      ATH_MSG_ERROR("Can't dynamic_cast " << typeid(filter).name() << " to a McVtxFilter");
    }
  } //> filter is a valid pointer
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setMatchBranches()

void McVtxFilter::setMatchBranches ( const bool matchVtxBranches )

inline

Set if one wants to strictly match the number of output particles.

Definition at line 250 of file McVtxFilter.h.

{
  m_matchBranches = matchBranches;
}

setMatchSign()

void McVtxFilter::setMatchSign ( const bool matchSign )

inline

Set if one wants to discriminate the sign of the particles.

Definition at line 245 of file McVtxFilter.h.

{
  m_matchSign = matchSign;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_childList

DataVector<const ParticleCandidateList> McVtxFilter::m_childList

protected

The list of the matching particles Ids : each item in DataVector stands for an out-going branch to the vertex.

Definition at line 186 of file McVtxFilter.h.

m_decayPattern

std::string McVtxFilter::m_decayPattern

protected

The decay pattern one looks for.

Ex: 23 -> -11 + 11 to model a Z0 -> e+ e- decay

Definition at line 178 of file McVtxFilter.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_matchBranches

bool McVtxFilter::m_matchBranches

protected

Tell if one wants a strict vertex branches matching.

This is to cope with radiations in the output branches If true then a decay t->Wbggg will not be kept if one asked for a top into W+b decay... Default : false

Definition at line 174 of file McVtxFilter.h.

m_matchSign

bool McVtxFilter::m_matchSign

protected

Discrimination between particles and conjugates.

Definition at line 167 of file McVtxFilter.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_parentList

DataVector<const ParticleCandidateList> McVtxFilter::m_parentList

protected

The list of the matching particles Ids : each item in DataVector stands for an entering branch to the vertex.

Definition at line 182 of file McVtxFilter.h.

---

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

• McVtxFilter.h
• McVtxFilter.cxx