EvtInclusiveDecay Class Reference

#include <EvtInclusiveDecay.h>

Inheritance diagram for EvtInclusiveDecay:

Collaboration diagram for EvtInclusiveDecay:

Classes
struct	ParticleIdCompare

Public Member Functions
	EvtInclusiveDecay (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~EvtInclusiveDecay ()
StatusCode	initialize ()
StatusCode	execute (const EventContext &ctx)
	Execute method.
StatusCode	finalize ()
std::string	xmlpath (void)
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
bool	filterPassed (const EventContext &ctx) const
void	setFilterPassed (bool state, const EventContext &ctx) const
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	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
Event collection accessors (const and non-const)
HepMC::GenEvent *event	ATLAS_NOT_CONST_THREAD_SAFE ()
	Access the current signal event (first in the McEventCollection).
McEventCollection *events	ATLAS_NOT_CONST_THREAD_SAFE ()
	Access the current event's McEventCollection.
const HepMC::GenEvent *	event_const (const EventContext &ctx) const
	Access the current signal event (const).
const McEventCollection *	events_const (const EventContext &ctx) const
	Access the current event's McEventCollection (const).
Particle data accessors
const ServiceHandle< IPartPropSvc >	partPropSvc () const
	Access the particle property service.
const HepPDT::ParticleDataTable &	particleTable () const
	Get a particle data table.
const HepPDT::ParticleDataTable &	pdt () const
	Shorter alias to get a particle data table.
const HepPDT::ParticleData *	particleData (int pid) const
	Access an element in the particle data table.
const EventContext &	getContext () const
	Deprecated methods (use the ones with EventContext).
bool	filterPassed () const
void	setFilterPassed (bool state) const

Protected Member Functions
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
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.

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
DataObjIDColl	m_extendedExtraObjects
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

Features for derived classes to use internally
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc"}
IntegerProperty	m_dsid {this, "Dsid", 999999}
IntegerProperty	m_randomSeed {this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}
	Seed for random number engine.
McEventCollection *	m_mcEvtColl {}
EvtInclusiveAtRndmGen *	m_evtAtRndmGen {}
EvtGen *	m_myEvtGen {}
std::string	m_pdtFile
std::string	m_decayFile
std::string	m_userDecayFile
std::string	m_randomStreamName
std::string	m_inputKeyName
std::string	m_outputKeyName
bool	m_readExisting
bool	m_prohibitFinalStateDecay
bool	m_prohibitReDecay
bool	m_prohibitUnDecay
bool	m_prohibitRemoveSelfDecay
std::vector< int >	m_blackList
std::set< int >	m_blackListSet
bool	m_allowAllKnownDecays
bool	m_allowDefaultBDecays
std::vector< int >	m_whiteList
std::set< int >	m_whiteListSet
bool	m_printHepMCBeforeEvtGen
bool	m_printHepMCAfterEvtGen
bool	m_printHepMCHighlighted
bool	m_printHepMCHighLightTopLevelDecays
bool	m_checkDecayTree
bool	m_checkDecayChannels
std::map< int, long >	m_noDecayChannels
int	m_nRepeatedDecays
int	m_maxNRepeatedDecays
bool	m_applyUserSelection
bool	m_userSelRequireOppositeSignedMu
double	m_userSelMu1MinPt
double	m_userSelMu2MinPt
double	m_userSelMu1MaxEta
double	m_userSelMu2MaxEta
double	m_userSelMinDimuMass
double	m_userSelMaxDimuMass
bool	m_isfHerwig
bool	m_setVMtransversePol
void	reseedRandomEngine (const std::string &streamName, const EventContext &ctx)
CLHEP::HepRandomEngine *	getRandomEngine (const std::string &streamName, unsigned long int randomSeedOffset, const EventContext &ctx) const
CLHEP::HepRandomEngine *	getRandomEngineDuringInitialize (const std::string &streamName, unsigned long int randomSeedOffset, unsigned int conditionsRun=1, unsigned int lbn=1) const
StatusCode	traverseDecayTree (HepMC::GenParticlePtr p, bool isToBeRemoved, std::set< HepMC::GenVertexPtr > &visited, std::set< HepMC::GenParticlePtr, ParticleIdCompare > &toBeDecayed)
void	removeDecayTree (HepMC::GenEvent *hepMC, HepMC::GenParticlePtr p)
void	decayParticle (HepMC::GenEvent *hepMC, HepMC::GenParticlePtr p)
void	addEvtGenDecayTree (HepMC::GenEvent *hepMC, HepMC::GenParticlePtr part, EvtParticle *evtPart, EvtVector4R treeStart, double momentumScaleFactor=1.0)
bool	isToBeDecayed (HepMC::ConstGenParticlePtr p, bool doCrossChecks)
bool	isDefaultB (const int pId) const
bool	passesUserSelection (HepMC::GenEvent *hepMC)
double	invMass (HepMC::ConstGenParticlePtr p1, HepMC::ConstGenParticlePtr p2)
void	printHepMC (HepMC::GenEvent *hepMC, std::set< HepMC::GenParticlePtr, ParticleIdCompare > *particleSet=nullptr)
unsigned int	printTree (HepMC::GenParticlePtr p, std::set< HepMC::GenVertexPtr > &visited, int level, std::set< HepMC::GenParticlePtr, ParticleIdCompare > *particleSet=nullptr)
std::string	pdgName (HepMC::ConstGenParticlePtr p, bool statusHighlighting=false, std::set< HepMC::GenParticlePtr, ParticleIdCompare > *particleSet=nullptr)

Properties
ServiceHandle< IPartPropSvc >	m_ppSvc {this, "PartPropSvc", "PartPropSvc"}
	Handle on the particle property service.
SG::ReadHandleKey< McEventCollection >	m_mcevents_const { this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" }
	Const handle to the MC event collection.
std::string	m_mcEventKey {}
	StoreGate key for the MC event collection (defaults to GEN_EVENT).
BooleanProperty	m_mkMcEvent {this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"}
	Flag to determine if a new MC event collection should be made if it doesn't exist.

Detailed Description

Definition at line 55 of file EvtInclusiveDecay.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EvtInclusiveDecay()

EvtInclusiveDecay::EvtInclusiveDecay	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 56 of file EvtInclusiveDecay.cxx.

                                                                                   :
  GenBase( name, pSvcLocator ),
  m_nRepeatedDecays(0) {
 
  // Basic EvtGen configuration: decay and particle definition files, random number stream
  declareProperty("pdtFile", m_pdtFile = "inclusive.pdt");
  declareProperty("decayFile", m_decayFile = "2014inclusive.dec");
  declareProperty("userDecayFile", m_userDecayFile = "");
  declareProperty("randomStreamName", m_randomStreamName = "EVTGEN");
  declareProperty("inputKeyName", m_inputKeyName = "GEN_EVENT");
  declareProperty("outputKeyName",m_outputKeyName = "GEN_EVENT_EVTGEN");
  declareProperty("readExisting",m_readExisting=false);
 
  // Selection of particles to be decayed
  declareProperty("prohibitFinalStateDecay", m_prohibitFinalStateDecay=false);
  declareProperty("prohibitReDecay", m_prohibitReDecay=false);
  declareProperty("prohibitUnDecay", m_prohibitUnDecay=true);
  declareProperty("prohibitRemoveSelfDecay", m_prohibitRemoveSelfDecay=false);
  declareProperty("blackList",m_blackList);
  declareProperty("allowAllKnownDecays", m_allowAllKnownDecays=true);
  declareProperty("allowDefaultBDecays", m_allowDefaultBDecays=true);
  declareProperty("whiteList",m_whiteList);
 
  // Level of output
  declareProperty("printHepMCBeforeEvtGen", m_printHepMCBeforeEvtGen=false);
  declareProperty("printHepMCAfterEvtGen", m_printHepMCAfterEvtGen=false);
  declareProperty("printHepMCHighlighted", m_printHepMCHighlighted=true);
  declareProperty("printHepMCHighLightTopLevelDecays", m_printHepMCHighLightTopLevelDecays=true);
 
  // Optional checks
  declareProperty("checkDecayTree", m_checkDecayTree=false);
  declareProperty("checkDecayChannels", m_checkDecayChannels=false);
 
  // Repeated decays
  declareProperty("maxNRepeatedDecays", m_maxNRepeatedDecays=1);
 
  // User selection
  declareProperty("applyUserSelection", m_applyUserSelection=false);
  declareProperty("userSelRequireOppositeSignedMu", m_userSelRequireOppositeSignedMu=true);
  declareProperty("userSelMu1MinPt", m_userSelMu1MinPt=0.);
  declareProperty("userSelMu2MinPt", m_userSelMu2MinPt=0.);
  declareProperty("userSelMu1MaxEta", m_userSelMu1MaxEta=102.5);
  declareProperty("userSelMu2MaxEta", m_userSelMu2MaxEta=102.5);
  declareProperty("userSelMinDimuMass", m_userSelMinDimuMass=0.);
  declareProperty("userSelMaxDimuMass", m_userSelMaxDimuMass=-1.); // set to negative to not apply cut
  declareProperty("isfHerwig", m_isfHerwig=false);
  declareProperty("setVMtransversePol", m_setVMtransversePol=false);
 
  // We have decided to blacklist Tau decays because we are not sure whether the polarization
  // would be properly passed to EvtGen
  m_blackList.push_back(15);
}

~EvtInclusiveDecay()

EvtInclusiveDecay::~EvtInclusiveDecay ( )

virtual

Definition at line 111 of file EvtInclusiveDecay.cxx.

                                      {
  delete m_myEvtGen;
  delete m_evtAtRndmGen;
}

Member Function Documentation

addEvtGenDecayTree()

void EvtInclusiveDecay::addEvtGenDecayTree ( HepMC::GenEvent * hepMC, HepMC::GenParticlePtr part, EvtParticle * evtPart, EvtVector4R treeStart, double momentumScaleFactor = 1.0 )

private

Definition at line 451 of file EvtInclusiveDecay.cxx.

                                                                                                                    {
  if(evtPart->getNDaug()!=0) {
    // Add decay vertex, starting from production vertex of particle
    double ct=(evtPart->getDaug(0)->get4Pos()).get(0)+treeStart.get(0);
    double x=(evtPart->getDaug(0)->get4Pos()).get(1)+treeStart.get(1);
    double y=(evtPart->getDaug(0)->get4Pos()).get(2)+treeStart.get(2);
    double z=(evtPart->getDaug(0)->get4Pos()).get(3)+treeStart.get(3);
 
    HepMC::GenVertexPtr end_vtx = HepMC::newGenVertexPtr(HepMC::FourVector(x,y,z,ct));
 
    hepMC->add_vertex(end_vtx);
    end_vtx->add_particle_in(std::move(part));
 
    // Add decay daughter with their own decay trees
    for(uint it=0; it<evtPart->getNDaug(); it++) {
      double e=(evtPart->getDaug(it)->getP4Lab()).get(0) * momentumScaleFactor;
      double px=(evtPart->getDaug(it)->getP4Lab()).get(1) * momentumScaleFactor;
      double py=(evtPart->getDaug(it)->getP4Lab()).get(2) * momentumScaleFactor;
      double pz=(evtPart->getDaug(it)->getP4Lab()).get(3) * momentumScaleFactor;
      int id=EvtPDL::getStdHep(evtPart->getDaug(it)->getId());
      int status=1;
      if(evtPart->getDaug(it)->getNDaug() != 0) status=2;
      HepMC::GenParticlePtr daughter = HepMC::newGenParticlePtr(HepMC::FourVector(px,py,pz,e),id,status);
      end_vtx->add_particle_out(daughter);
      addEvtGenDecayTree(hepMC, std::move(daughter), evtPart->getDaug(it), treeStart, momentumScaleFactor);
    }
  }
}

ATLAS_NOT_CONST_THREAD_SAFE() [1/2]

McEventCollection *events GenBase::ATLAS_NOT_CONST_THREAD_SAFE ( )

inherited

Access the current event's McEventCollection.

Note

This function will make a new McEventCollection if there is not already a valid one and MakeMcEvent=True.

ATLAS_NOT_CONST_THREAD_SAFE() [2/2]

HepMC::GenEvent *event GenBase::ATLAS_NOT_CONST_THREAD_SAFE ( )

inlineinherited

Access the current signal event (first in the McEventCollection).

Note

This function will make a new McEventCollection if there is not already a valid one and MakeMcEvent=True.

Definition at line 76 of file GenBase.h.

                                                      {
    if (events()->empty())
      ATH_MSG_ERROR("McEventCollection is empty during first event access");
    return *(events()->begin());
  }

decayParticle()

void EvtInclusiveDecay::decayParticle ( HepMC::GenEvent * hepMC, HepMC::GenParticlePtr p )

private

Definition at line 413 of file EvtInclusiveDecay.cxx.

                                                                                    {
  ATH_MSG_DEBUG("Decaying particle " << pdgName(part) << " " << part);
  if (msgLvl(MSG::VERBOSE)) HepMC::Print::line(std::cout,part);
 
  // Remove existing decay tree, if any, and flag particle as being decayed by EvtGen
  removeDecayTree(hepMC,part);
  part->set_status(0);
 
  // Create EvtGen version of part and have EvtGen decay it.
  // Since EvtGen uses GeV, convert particles momentum from MeV to GeV.
  int id = part->pdg_id();
  EvtId evtId=EvtPDL::evtIdFromStdHep(id);
  double en =(part->momentum()).e()/1000.;
  double px=(part->momentum()).px()/1000.;
  double py=(part->momentum()).py()/1000.;
  double pz=(part->momentum()).pz()/1000.;
  EvtVector4R evtP(en,px,py,pz);
  EvtParticle* evtPart = EvtParticleFactory::particleFactory(evtId,evtP);
  
  // set transverse polarization to vector mesons (relevant for coherent production of J/Psi etc in UPC)
  if(m_setVMtransversePol && (id==113 || id== 443 || id==100443 || id==553 || id==100553 || id==200553) )evtPart->setVectorSpinDensity();
  
  m_myEvtGen->generateDecay(evtPart);
  if (msgLvl(MSG::VERBOSE)) evtPart->printTree();
  double ct_s = part->production_vertex()->position().t();
  double x_s = part->production_vertex()->position().x();
  double y_s = part->production_vertex()->position().y();
  double z_s = part->production_vertex()->position().z();
 
  EvtVector4R treeStart(ct_s,x_s,y_s,z_s);
  // Add new decay tree to hepMC, converting back from GeV to MeV.
  addEvtGenDecayTree(hepMC, part, evtPart, treeStart, 1000.);
  if(evtPart->getNDaug() !=0) part->set_status(2);
  evtPart->deleteTree();
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

event_const()

const HepMC::GenEvent * GenBase::event_const ( const EventContext & ctx ) const

inlineinherited

Access the current signal event (const).

Definition at line 83 of file GenBase.h.

                                                                    {
    const McEventCollection* coll = events_const(ctx);
    if (coll->empty())
      ATH_MSG_ERROR("Const McEventCollection is empty during first event access");
    return *(coll->begin());
  }

events_const()

const McEventCollection * GenBase::events_const ( const EventContext & ctx ) const

inlineinherited

Access the current event's McEventCollection (const).

Definition at line 97 of file GenBase.h.

                                                                         {
    SG::ReadHandle<McEventCollection> ret = SG::makeHandle(m_mcevents_const, ctx);
    if (!ret.isValid())
      ATH_MSG_ERROR("No McEventCollection found in StoreGate with key " << m_mcevents_const.key());
    return ret.cptr();
  }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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 EvtInclusiveDecay::execute ( const EventContext & ctx )

virtual

Execute method.

Provides access to the EventContext if needed but is non-const as opposed to AthReentrantAlgorithm.

Reimplemented from GenBase.

Definition at line 217 of file EvtInclusiveDecay.cxx.

                                                             {
  ATH_MSG_DEBUG("EvtInclusiveDecay executing");
 
  reseedRandomEngine(m_randomStreamName, ctx);
 
  std::string   key = m_inputKeyName;
  // retrieve event from Transient Store (Storegate)
 
  // Load HepMC info
  // FIXME should be using Read/WriteHandles here
  const McEventCollection* oldmcEvtColl{};
  if(m_readExisting) {
    CHECK(evtStore()->retrieve(oldmcEvtColl, key));
    // Fill the new McEventCollection with a copy of the initial HepMC::GenEvent
    m_mcEvtColl = new McEventCollection(*oldmcEvtColl);
  }
  else {CHECK(evtStore()->retrieve(m_mcEvtColl, key));}
 
  if(m_readExisting) {
    if(m_outputKeyName!=key) {
     CHECK(evtStore()->record( m_mcEvtColl,m_outputKeyName));
    }
  }
 
  McEventCollection::iterator mcItr;
  for( mcItr = m_mcEvtColl->begin(); mcItr != m_mcEvtColl->end(); ++mcItr )   {
    HepMC::GenEvent* hepMC = *mcItr;
 
    // Search HepMC record for particles to be decayed by EvtGen
    // NOTE: In order to ensure repeatability, we use customized a std::set to obtain
    //       an ordered list of particles to be decayed by EvtGen.
    std::set<HepMC::GenVertexPtr> visited;
    std::set<HepMC::GenParticlePtr,ParticleIdCompare> toBeDecayed;
    for (auto p: *hepMC) {
      if ( (!p->production_vertex()) ||
           (p->production_vertex()->particles_in_size() == 0) ) {
        StatusCode sc = traverseDecayTree(std::move(p),false,visited,toBeDecayed);
        if (sc.isFailure())
          return StatusCode::FAILURE;
      }
    }
    // Print HepMC in tree format if desired (before doing anything)
    if (m_printHepMCBeforeEvtGen) {
      msg(MSG::INFO) << "Printing HepMC record at " << hepMC << " BEFORE running EvtGen:" << endmsg;
      if (m_printHepMCHighLightTopLevelDecays)
        printHepMC(hepMC,&toBeDecayed);
      else
        printHepMC(hepMC);
    }
 
 
    // Decay selected particles
    bool eventPassesCuts(false);
    int loopCounter(0);
    while( !eventPassesCuts && loopCounter < m_maxNRepeatedDecays ) {
 
      for (auto p: toBeDecayed) {
        if (p == 0) {
          msg(MSG::ERROR ) << "Overlapping decay tree for particle" << p <<endmsg;
          return StatusCode::FAILURE;
        }
        decayParticle(hepMC,std::move(p));
        HepMC::fillBarcodesAttribute(hepMC);
      }
 
      if(m_applyUserSelection)
        eventPassesCuts = passesUserSelection(hepMC);
      else
        eventPassesCuts = true;
 
      m_nRepeatedDecays++;
      loopCounter++;
    }
 
    // Store the number of decay attempts in event weights std::map, only if repeated decays enabled
 
    if(m_maxNRepeatedDecays > 1) {
      hepMC->weight("nEvtGenDecayAttempts") = loopCounter;
    }
    // Print HepMC in tree format if desired (after finishing all EvtGen decays)
    if (m_printHepMCAfterEvtGen) {
      msg(MSG::INFO)  << "Printing HepMC record at " << hepMC << " AFTER running EvtGen:" << endmsg;
      if (m_printHepMCHighLightTopLevelDecays)
        printHepMC(hepMC,&toBeDecayed);
      else
        printHepMC(hepMC);
    }
  }
 
  if(m_readExisting && m_outputKeyName==key) {
    CHECK(evtStore()->overwrite(m_mcEvtColl, m_outputKeyName));
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

filterPassed() [1/2]

bool AthAlgorithm::filterPassed ( ) const

inherited

Definition at line 94 of file AthAlgorithm.cxx.

                                      {
  return filterPassed( Gaudi::Hive::currentContext() );
}

filterPassed() [2/2]

bool AthAlgorithm::filterPassed ( const EventContext & ctx ) const

inherited

Definition at line 98 of file AthAlgorithm.cxx.

                                                             {
  return execState( ctx ).filterPassed();
}

finalize()

StatusCode EvtInclusiveDecay::finalize

(

)

Definition at line 314 of file EvtInclusiveDecay.cxx.

                                       {
 
  if (m_checkDecayChannels) {
    ATH_MSG_INFO("The following particles were checked and didn't have any decay channels:");
    if (msgLvl(MSG::INFO)) {
      std::cout << std::endl;
      std::cout << " Particle code    Name from HepPDT        # Occurences" << std::endl;
      std::cout << "------------------------------------------------------"  << std::endl;
      for (std::map<int,long>::iterator p = m_noDecayChannels.begin(); p!=m_noDecayChannels.end(); ++p) {
        int id = p->first;
        int count = p->second;
        std::cout << std::setw(14) << id
                  << std::setw(20) << HepPID::particleName(id)
                  << std::setw(20) << count
                  << std::endl;
      }
      std::cout << std::endl;
    }
  }
  ATH_MSG_INFO("Total number of repeated decays: " << m_nRepeatedDecays);
  ATH_MSG_INFO("EvtInclusiveDecay finalized");
  return StatusCode::SUCCESS;
}

getContext()

const EventContext & AthAlgorithm::getContext ( ) const

inherited

Deprecated methods (use the ones with EventContext).

Definition at line 90 of file AthAlgorithm.cxx.

                                                   {
  return Gaudi::Hive::currentContext();
}

getRandomEngine()

CLHEP::HepRandomEngine * EvtInclusiveDecay::getRandomEngine ( const std::string & streamName, unsigned long int randomSeedOffset, const EventContext & ctx ) const

private

Definition at line 191 of file EvtInclusiveDecay.cxx.

{
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
  rngWrapper->setSeed( streamName, ctx.slot(), randomSeedOffset, ctx.eventID().run_number() );
  return rngWrapper->getEngine(ctx);
}

getRandomEngineDuringInitialize()

CLHEP::HepRandomEngine * EvtInclusiveDecay::getRandomEngineDuringInitialize ( const std::string & streamName, unsigned long int randomSeedOffset, unsigned int conditionsRun = 1, unsigned int lbn = 1 ) const

private

Definition at line 200 of file EvtInclusiveDecay.cxx.

{
  const size_t slot=0;
  EventContext ctx;
  ctx.setSlot( slot );
  ctx.setEventID (EventIDBase (conditionsRun,
               EventIDBase::UNDEFEVT,  // event
               EventIDBase::UNDEFNUM,  // timestamp
               EventIDBase::UNDEFNUM,  // timestamp ns
               lbn));
  Atlas::setExtendedEventContext(ctx,
                                 Atlas::ExtendedEventContext( evtStore()->hiveProxyDict(),
                                                              conditionsRun) );
  return getRandomEngine(streamName, randomSeedOffset, ctx);
}

initialize()

StatusCode EvtInclusiveDecay::initialize ( )

virtual

Reimplemented from GenBase.

Definition at line 118 of file EvtInclusiveDecay.cxx.

                                         {
 
  ATH_CHECK( GenBase::initialize() );
  // Get the random number service
  CHECK(m_rndmSvc.retrieve());
 
  msg(MSG::INFO) << "EvtInclusiveDecay initialize" << endmsg;
  msg(MSG::INFO) << "Particle properties definition file = " << m_pdtFile << endmsg;
  msg(MSG::INFO) << "Main decay file                     = " << m_decayFile << endmsg;
  msg(MSG::INFO) << "User decay file                     = " << m_userDecayFile << endmsg;
  msg(MSG::INFO) << "Max number of repeated decays       = " << m_maxNRepeatedDecays << endmsg;
  msg(MSG::INFO) << "EvtInclusiveDecay selection parameters:" << endmsg;
  msg(MSG::INFO) << "* prohibitFinalStateDecay = " << m_prohibitFinalStateDecay << endmsg;
  msg(MSG::INFO) << "* prohibitReDecay         = " << m_prohibitReDecay << endmsg;
  msg(MSG::INFO) << "* prohibitUnDecay         = " << m_prohibitUnDecay << endmsg;
  msg(MSG::INFO) << "* prohibitRemoveSelfDecay = " << m_prohibitRemoveSelfDecay << endmsg;
  msg(MSG::INFO) << "* allowAllKnownDecays     = " << m_allowAllKnownDecays << endmsg;
  msg(MSG::INFO) << "* allowDefaultBDecays     = " << m_allowDefaultBDecays << endmsg;
  msg(MSG::INFO) << "User selection parameters:" << endmsg;
  msg(MSG::INFO) << "* applyUserSelection             = " << m_applyUserSelection << endmsg;
  msg(MSG::INFO) << "* userSelRequireOppositeSignedMu = " << m_userSelRequireOppositeSignedMu << endmsg;
  msg(MSG::INFO) << "* userSelMu1MinPt                = " << m_userSelMu1MinPt << endmsg;
  msg(MSG::INFO) << "* userSelMu2MinPt                = " << m_userSelMu2MinPt << endmsg;
  msg(MSG::INFO) << "* userSelMu1MaxEta               = " << m_userSelMu1MaxEta << endmsg;
  msg(MSG::INFO) << "* userSelMu2MaxEta               = " << m_userSelMu2MaxEta << endmsg;
  msg(MSG::INFO) << "* userSelMinDimuMass             = " << m_userSelMinDimuMass << endmsg;
  msg(MSG::INFO) << "* userSelMaxDimuMass             = " << m_userSelMaxDimuMass << endmsg;
 
  // Initialize and print blackList
  m_blackListSet.insert(m_blackList.begin(),m_blackList.end());
  msg(MSG::INFO) << "* blackList;               = ";
  for (std::set<int>::iterator i = m_blackListSet.begin(); i!=m_blackListSet.end(); ++i)
     msg(MSG::INFO) << (*i) << " ";
  msg(MSG::INFO)<< endmsg;
 
  // Initialize and print whiteList
  m_whiteListSet.insert(m_whiteList.begin(),m_whiteList.end());
  msg(MSG::INFO) << "* whiteList               = ";
  for (std::set<int>::iterator i = m_whiteListSet.begin(); i!=m_whiteListSet.end(); ++i)
    msg(MSG::INFO) << (*i) << " ";
  msg(MSG::INFO) << endmsg;
 
  CLHEP::HepRandomEngine* rndmEngine = getRandomEngineDuringInitialize(m_randomStreamName, m_randomSeed, m_dsid);
  // Obtain random number generator for EvtGen
  m_evtAtRndmGen = new EvtInclusiveAtRndmGen(rndmEngine);
 
  // Create an instance of EvtGen and read particle properties and decay files
  EvtExternalGenList genList(true,xmlpath(),"gamma");
  EvtAbsRadCorr* radCorrEngine = genList.getPhotosModel();
  std::list<EvtDecayBase*> extraModels = genList.getListOfModels();
 
   // Create the EvtGen generator object
  // EvtGen myGenerator("decayFile.dec", "evt.pdl", randomEnginePointer,
  //                    radCorrEngine, &extraModels);
 
 
  m_myEvtGen = new EvtGen( m_decayFile.c_str(), m_pdtFile.c_str(), m_evtAtRndmGen, radCorrEngine, &extraModels);
  if(!m_userDecayFile.empty())
    m_myEvtGen->readUDecay(m_userDecayFile.c_str());
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

invMass()

double EvtInclusiveDecay::invMass ( HepMC::ConstGenParticlePtr p1, HepMC::ConstGenParticlePtr p2 )

private

Definition at line 610 of file EvtInclusiveDecay.cxx.

                                                                                          {
  double p1Px = p1->momentum().px();
  double p1Py = p1->momentum().py();
  double p1Pz = p1->momentum().pz();
  double p1E  = p1->momentum().e();
  double p2Px = p2->momentum().px();
  double p2Py = p2->momentum().py();
  double p2Pz = p2->momentum().pz();
  double p2E  = p2->momentum().e();
  double dimuE = p2E + p1E;
  double dimuPx = p2Px + p1Px;
  double dimuPy = p2Py + p1Py;
  double dimuPz = p2Pz + p1Pz;
  double invMass = std::sqrt(dimuE*dimuE - dimuPx*dimuPx - dimuPy*dimuPy - dimuPz*dimuPz);
 
  return invMass;
}

isDefaultB()

bool EvtInclusiveDecay::isDefaultB ( const int pId ) const

private

Definition at line 558 of file EvtInclusiveDecay.cxx.

                                                      {
  int id = std::abs(pId);
  if ( id == 511   ||
       id == 521   ||
       id == 531   ||
       id == 541   ||
       id == 5122  ||
       id == 5132  ||
       id == 5232  ||
       id == 5112  ||
       id == 5212  ||
       id == 5222 )
    return true;
  else
    return false;
}

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 111 of file AthAlgorithm.h.

{ return false; }

isToBeDecayed()

bool EvtInclusiveDecay::isToBeDecayed ( HepMC::ConstGenParticlePtr p, bool doCrossChecks )

private

Definition at line 489 of file EvtInclusiveDecay.cxx.

                                                                                    {
  int id = p->pdg_id();
  int nDaughters = 0;
  auto v = p->end_vertex();
  if (v) nDaughters = v->particles_out_size();
 
  // Ignore documentation lines
  if (p->status() == 3) return false;
  // And any particles that aren't stable or decayed
  if(!m_isfHerwig && !MC::isPhysical(p)) return false;
 
  // Particularly for Herwig, try to ignore particles that really should
  // be flagged as documentation lines
  double m2 = p->momentum().m2();
  if (m2 < -1.0E-3) {
    ATH_MSG_DEBUG("Ignoring particle " << pdgName(std::move(p)) << " with m^2 = " << m2);
    return false;
  }
 
  // Check whether EvtGen has any decay channels defined for this particle
  EvtId evtId = EvtPDL::evtIdFromStdHep(id);
  // std::cout << "EVTID: " << evtId.getId() << " alias " << evtId.getAlias() << std::endl;
  int nModes = 0;
  if (evtId.getId()>=0)
    //    nModes = EvtDecayTable::getNMode(evtId.getAlias());
    nModes = EvtDecayTable::getInstance()->getNMode(evtId.getAlias());
  if (doCrossChecks) {
    ATH_MSG_VERBOSE("Checking particle " << pdgName(p)
        << " (status = " << p->status()
                    <<") -- " << nModes << " decay modes found");
    if (m_checkDecayChannels && nModes==0) {
      std::map<int,long>::iterator pos = m_noDecayChannels.find(id);
      if (pos != m_noDecayChannels.end())
        (pos->second)++;
      else
        m_noDecayChannels[id] = 1;
    }
  }
 
  // Check prohibit* settings
  if (m_prohibitFinalStateDecay && MC::isStable(p)) return false;
  if (m_prohibitReDecay && nDaughters>0) return false;
  if (m_prohibitUnDecay && nModes==0) return false;
  if (m_prohibitRemoveSelfDecay && nDaughters>0) {
    // For now, check only children - this should be sufficient and checking all
    // descendants would be very expensive.
    for (auto  itd: *v) {
      if (std::abs(itd->pdg_id()) == std::abs(id)) return false;
    }
  }
 
  // Check blackList
  if (m_blackListSet.count(std::abs(id))>0) return false;
 
  // Check allow* settings
  if (m_allowAllKnownDecays && nModes>0) return true;
  if (m_allowDefaultBDecays && isDefaultB(id)) return true;
 
  // Check whiteList
  if (m_whiteListSet.count(std::abs(id))>0) return true;
 
  return false;   // Default is NOT to decay through EvtGen
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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.

particleData()

const HepPDT::ParticleData * GenBase::particleData ( int pid ) const

inlineinherited

Access an element in the particle data table.

Definition at line 124 of file GenBase.h.

                                                        {
    return pdt().particle(HepPDT::ParticleID(std::abs(pid)));
  }

particleTable()

const HepPDT::ParticleDataTable & GenBase::particleTable ( ) const

inlineinherited

Get a particle data table.

Definition at line 116 of file GenBase.h.

                                                       {
    return *(m_ppSvc->PDT());
  }

partPropSvc()

const ServiceHandle< IPartPropSvc > GenBase::partPropSvc ( ) const

inlineinherited

Access the particle property service.

Definition at line 111 of file GenBase.h.

                                                        {
    return m_ppSvc;
  }

passesUserSelection()

bool EvtInclusiveDecay::passesUserSelection ( HepMC::GenEvent * hepMC )

private

Definition at line 580 of file EvtInclusiveDecay.cxx.

                                                                {
  bool passed(false);
  std::vector<HepMC::GenParticlePtr> *muons = new std::vector<HepMC::GenParticlePtr>;
 
  for ( const auto& p:  *hepMC) {
    if( std::abs(p->pdg_id()) == 13 )
      muons->push_back(p);
  }
 
  for (auto muItr1 = muons->begin(); muItr1 != muons->end(); ++muItr1) {
    for (auto muItr2 = muItr1+1; muItr2 != muons->end(); ++muItr2) {
      if( m_userSelRequireOppositeSignedMu && (*muItr1)->pdg_id() * (*muItr2)->pdg_id() > 0)
        continue;
      if( !( (*muItr1)->momentum().perp() > m_userSelMu1MinPt && std::abs((*muItr1)->momentum().pseudoRapidity()) < m_userSelMu1MaxEta &&
             (*muItr2)->momentum().perp() > m_userSelMu2MinPt && std::abs((*muItr2)->momentum().pseudoRapidity()) < m_userSelMu2MaxEta ) &&
          !( (*muItr2)->momentum().perp() > m_userSelMu1MinPt && std::abs((*muItr2)->momentum().pseudoRapidity()) < m_userSelMu1MaxEta &&
             (*muItr1)->momentum().perp() > m_userSelMu2MinPt && std::abs((*muItr1)->momentum().pseudoRapidity()) < m_userSelMu2MaxEta ) )
        continue;
      double dimuMass = invMass((*muItr1),(*muItr2));
      if( !( dimuMass > m_userSelMinDimuMass && (dimuMass < m_userSelMaxDimuMass || m_userSelMaxDimuMass < 0.) ) )
        continue;
      passed = true;
    }
  }
 
  delete muons;
 
  return passed;
}

pdgName()

std::string EvtInclusiveDecay::pdgName ( HepMC::ConstGenParticlePtr p, bool statusHighlighting = false, std::set< HepMC::GenParticlePtr, ParticleIdCompare > * particleSet = nullptr )

private

Definition at line 681 of file EvtInclusiveDecay.cxx.

                                                                                                                                                    {
  std::ostringstream buf;
  bool inlist = false;
  if (particleSet) for (const auto& pinl: *particleSet) if (pinl&&p) if (pinl.get() == p.get()) inlist=true;
  if (statusHighlighting) {
    if ( ((particleSet!=0) && (inlist)) ||
         ((particleSet==0) && isToBeDecayed(p,false)) )
      buf << "\033[7m";   // reverse
    if (p and !MC::isStable(p)) {
      if (MC::isDecayed(p))
        buf << "\033[33m";   // yellow
      else
        buf << "\033[31m";   // red
    }
  }
  if (p){
    buf << p->pdg_id();
    buf << "/" << HepPID::particleName(p->pdg_id());
    if (statusHighlighting) {
      buf << "\033[0m";   // revert color attributes
    }
  }
  return buf.str();
}

pdt()

const HepPDT::ParticleDataTable & GenBase::pdt ( ) const

inlineinherited

Shorter alias to get a particle data table.

Definition at line 121 of file GenBase.h.

{ return particleTable(); }

printHepMC()

void EvtInclusiveDecay::printHepMC ( HepMC::GenEvent * hepMC, std::set< HepMC::GenParticlePtr, ParticleIdCompare > * particleSet = nullptr )

private

Definition at line 634 of file EvtInclusiveDecay.cxx.

                                                                                                                   {
  std::set<HepMC::GenVertexPtr> visited;
  unsigned int nParticlesFound = 0;
  unsigned int nTreesFound = 0;
  for (auto p: *hepMC) {
    if ( (!p->production_vertex()) ||
         (p->production_vertex()->particles_in_size() == 0) ) {
      nTreesFound++;
      std::cout << "\n    Found new partial decay tree:\n" << std::endl;
      unsigned int nParticlesVisited = printTree(std::move(p),visited,1,particleSet);
      std::cout << "\n    " << nParticlesVisited << " particles in this subtree" << std::endl;
      nParticlesFound += nParticlesVisited;
    }
  }
  std::cout << "\n    Total of " << nParticlesFound << " particles found in "
            << nTreesFound << " decay subtrees in HepMC event record\n" << std::endl;
}

printTree()

unsigned int EvtInclusiveDecay::printTree ( HepMC::GenParticlePtr p, std::set< HepMC::GenVertexPtr > & visited, int level, std::set< HepMC::GenParticlePtr, ParticleIdCompare > * particleSet = nullptr )

private

Definition at line 652 of file EvtInclusiveDecay.cxx.

                                                                                                                                                                          {
 
  unsigned int nParticlesVisited = 1;
  for (int i=0; i<level; i++) std::cout << "    ";
  std::cout << pdgName(p,m_printHepMCHighlighted,particleSet);
  auto v = p->end_vertex();
  if (v) {
    if (v->particles_in_size() > 1)
      std::cout << " [interaction: " << v->particles_in_size() << " particles, vertex " << v << "]    -->   ";
    else
      std::cout << "   -->   ";
    if (visited.insert(v).second) {
      for (auto itp: *v) {
        std::cout << pdgName(itp,m_printHepMCHighlighted,particleSet) << "   ";
      }
      std::cout << std::endl;
      for (auto itp: *v) {
        if (itp->end_vertex())
          nParticlesVisited += printTree(std::move(itp), visited, level+1, particleSet);
        else
          nParticlesVisited++;
      }
    } else
      std::cout << "see above" << std::endl;
  } else
    std::cout << "   no decay vertex\n" << std::endl;
  return nParticlesVisited;
}

removeDecayTree()

void EvtInclusiveDecay::removeDecayTree ( HepMC::GenEvent * hepMC, HepMC::GenParticlePtr p )

private

Definition at line 386 of file EvtInclusiveDecay.cxx.

                                                                                   {
  auto v = p->end_vertex();
  if (v) {
    //This is recursive in HepMC3. But explicit deletion is allowed as well.
    hepMC->remove_vertex(std::move(v));
    p->set_status(1);   // For now, flag particle as undecayed (stable)
    ATH_MSG_DEBUG("Removed existing " << pdgName(p) << " " << p  );
  }
}

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

reseedRandomEngine()

void EvtInclusiveDecay::reseedRandomEngine ( const std::string & streamName, const EventContext & ctx )

private

Definition at line 182 of file EvtInclusiveDecay.cxx.

{
  long seeds[7];
  ATHRNG::calculateSeedsMC21(seeds, streamName,  ctx.eventID().event_number(), m_dsid, m_randomSeed);
  m_evtAtRndmGen->getEngine()->setSeeds(seeds, 0); // NOT THREAD-SAFE
}

setFilterPassed() [1/2]

void AthAlgorithm::setFilterPassed ( bool state ) const

inherited

Definition at line 102 of file AthAlgorithm.cxx.

                                                     {
  setFilterPassed( state, Gaudi::Hive::currentContext() );
}

setFilterPassed() [2/2]

void AthAlgorithm::setFilterPassed ( bool state, const EventContext & ctx ) const

inherited

Definition at line 106 of file AthAlgorithm.cxx.

                                                                              {
  execState( ctx ).setFilterPassed(state);
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc.

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

traverseDecayTree()

StatusCode EvtInclusiveDecay::traverseDecayTree ( HepMC::GenParticlePtr p, bool isToBeRemoved, std::set< HepMC::GenVertexPtr > & visited, std::set< HepMC::GenParticlePtr, ParticleIdCompare > & toBeDecayed )

private

Definition at line 347 of file EvtInclusiveDecay.cxx.

                                                                                                            {
  ATH_MSG_VERBOSE("Inspecting: " << pdgName(p) << " " << p);
  if (!isToBeRemoved) {
    if (isToBeDecayed(p,true)) {
      toBeDecayed.insert(p);
      isToBeRemoved = true;
      ATH_MSG_VERBOSE("Selected particle for decay: " << pdgName(p) << " " << p );
 
      // In principle we could stop the recursion here. However, to prevent
      // pathological cases in certain decay trees (in particular from Herwig),
      // we continue in order to mark all descendants of this particle
      // as visited. Thus none of these descendants can be flagged for further
      // decay, even if it has several mothers.
    }
  }
  auto v = p->end_vertex();
  if (v) {
    if (visited.insert(v).second) {
      if ( isToBeRemoved && (v->particles_in_size()>1) && m_checkDecayTree ) {
        ATH_MSG_WARNING("Found particle to be decayed with vertex with >1 incoming mother particles in decay tree");
        ATH_MSG_WARNING( ([&p, &v](){  std::stringstream ss;   HepMC::Print::line(ss,p); HepMC::Print::line(ss,v);  return ss.str();})());
      }
      for (auto itp: *v) {
        ATH_CHECK(traverseDecayTree(std::move(itp),isToBeRemoved,visited,toBeDecayed) );
      }
 
    }
  }
  return StatusCode::SUCCESS;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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);
      }
    }
  }

xmlpath()

std::string EvtInclusiveDecay::xmlpath

(

void

)

Definition at line 720 of file EvtInclusiveDecay.cxx.

                                    {
  return PathResolverFindCalibDirectory( "Pythia8/xmldoc" );
}

Member Data Documentation

m_allowAllKnownDecays

bool EvtInclusiveDecay::m_allowAllKnownDecays

private

Definition at line 126 of file EvtInclusiveDecay.h.

m_allowDefaultBDecays

bool EvtInclusiveDecay::m_allowDefaultBDecays

private

Definition at line 127 of file EvtInclusiveDecay.h.

m_applyUserSelection

bool EvtInclusiveDecay::m_applyUserSelection

private

Definition at line 144 of file EvtInclusiveDecay.h.

m_blackList

std::vector<int> EvtInclusiveDecay::m_blackList

private

Definition at line 123 of file EvtInclusiveDecay.h.

m_blackListSet

std::set<int> EvtInclusiveDecay::m_blackListSet

private

Definition at line 124 of file EvtInclusiveDecay.h.

m_checkDecayChannels

bool EvtInclusiveDecay::m_checkDecayChannels

private

Definition at line 137 of file EvtInclusiveDecay.h.

m_checkDecayTree

bool EvtInclusiveDecay::m_checkDecayTree

private

Definition at line 136 of file EvtInclusiveDecay.h.

m_decayFile

std::string EvtInclusiveDecay::m_decayFile

private

Definition at line 112 of file EvtInclusiveDecay.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dsid

IntegerProperty EvtInclusiveDecay::m_dsid {this, "Dsid", 999999}

private

Definition at line 99 of file EvtInclusiveDecay.h.

{this, "Dsid", 999999};

m_evtAtRndmGen

EvtInclusiveAtRndmGen* EvtInclusiveDecay::m_evtAtRndmGen {}

private

Definition at line 107 of file EvtInclusiveDecay.h.

{};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 114 of file AthAlgorithm.h.

m_inputKeyName

std::string EvtInclusiveDecay::m_inputKeyName

private

Definition at line 115 of file EvtInclusiveDecay.h.

m_isfHerwig

bool EvtInclusiveDecay::m_isfHerwig

private

Definition at line 152 of file EvtInclusiveDecay.h.

m_maxNRepeatedDecays

int EvtInclusiveDecay::m_maxNRepeatedDecays

private

Definition at line 142 of file EvtInclusiveDecay.h.

m_mcEventKey

std::string GenBase::m_mcEventKey {}

protectedinherited

StoreGate key for the MC event collection (defaults to GEN_EVENT).

Definition at line 134 of file GenBase.h.

{};

m_mcevents_const

SG::ReadHandleKey<McEventCollection> GenBase::m_mcevents_const { this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" }

privateinherited

Const handle to the MC event collection.

Definition at line 145 of file GenBase.h.

{ this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" };

m_mcEvtColl

McEventCollection* EvtInclusiveDecay::m_mcEvtColl {}

private

Definition at line 104 of file EvtInclusiveDecay.h.

{};

m_mkMcEvent

BooleanProperty GenBase::m_mkMcEvent {this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"}

protectedinherited

Flag to determine if a new MC event collection should be made if it doesn't exist.

Definition at line 136 of file GenBase.h.

{this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"};

m_myEvtGen

EvtGen* EvtInclusiveDecay::m_myEvtGen {}

private

Definition at line 108 of file EvtInclusiveDecay.h.

{};

m_noDecayChannels

std::map<int,long> EvtInclusiveDecay::m_noDecayChannels

private

Definition at line 138 of file EvtInclusiveDecay.h.

m_nRepeatedDecays

int EvtInclusiveDecay::m_nRepeatedDecays

private

Definition at line 140 of file EvtInclusiveDecay.h.

m_outputKeyName

std::string EvtInclusiveDecay::m_outputKeyName

private

Definition at line 116 of file EvtInclusiveDecay.h.

m_pdtFile

std::string EvtInclusiveDecay::m_pdtFile

private

Definition at line 111 of file EvtInclusiveDecay.h.

m_ppSvc

ServiceHandle<IPartPropSvc> GenBase::m_ppSvc {this, "PartPropSvc", "PartPropSvc"}

privateinherited

Handle on the particle property service.

Definition at line 142 of file GenBase.h.

{this, "PartPropSvc", "PartPropSvc"};

m_printHepMCAfterEvtGen

bool EvtInclusiveDecay::m_printHepMCAfterEvtGen

private

Definition at line 132 of file EvtInclusiveDecay.h.

m_printHepMCBeforeEvtGen

bool EvtInclusiveDecay::m_printHepMCBeforeEvtGen

private

Definition at line 131 of file EvtInclusiveDecay.h.

m_printHepMCHighlighted

bool EvtInclusiveDecay::m_printHepMCHighlighted

private

Definition at line 133 of file EvtInclusiveDecay.h.

m_printHepMCHighLightTopLevelDecays

bool EvtInclusiveDecay::m_printHepMCHighLightTopLevelDecays

private

Definition at line 134 of file EvtInclusiveDecay.h.

m_prohibitFinalStateDecay

bool EvtInclusiveDecay::m_prohibitFinalStateDecay

private

Definition at line 119 of file EvtInclusiveDecay.h.

m_prohibitReDecay

bool EvtInclusiveDecay::m_prohibitReDecay

private

Definition at line 120 of file EvtInclusiveDecay.h.

m_prohibitRemoveSelfDecay

bool EvtInclusiveDecay::m_prohibitRemoveSelfDecay

private

Definition at line 122 of file EvtInclusiveDecay.h.

m_prohibitUnDecay

bool EvtInclusiveDecay::m_prohibitUnDecay

private

Definition at line 121 of file EvtInclusiveDecay.h.

m_randomSeed

IntegerProperty EvtInclusiveDecay::m_randomSeed {this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}

private

Seed for random number engine.

Definition at line 102 of file EvtInclusiveDecay.h.

{this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}; // FIXME make this into an unsigned long int?

m_randomStreamName

std::string EvtInclusiveDecay::m_randomStreamName

private

Definition at line 114 of file EvtInclusiveDecay.h.

m_readExisting

bool EvtInclusiveDecay::m_readExisting

private

Definition at line 118 of file EvtInclusiveDecay.h.

m_rndmSvc

ServiceHandle<IAthRNGSvc> EvtInclusiveDecay::m_rndmSvc {this, "RndmSvc", "AthRNGSvc"}

private

Definition at line 96 of file EvtInclusiveDecay.h.

{this, "RndmSvc", "AthRNGSvc"};

m_setVMtransversePol

bool EvtInclusiveDecay::m_setVMtransversePol

private

Definition at line 153 of file EvtInclusiveDecay.h.

m_userDecayFile

std::string EvtInclusiveDecay::m_userDecayFile

private

Definition at line 113 of file EvtInclusiveDecay.h.

m_userSelMaxDimuMass

double EvtInclusiveDecay::m_userSelMaxDimuMass

private

Definition at line 151 of file EvtInclusiveDecay.h.

m_userSelMinDimuMass

double EvtInclusiveDecay::m_userSelMinDimuMass

private

Definition at line 150 of file EvtInclusiveDecay.h.

m_userSelMu1MaxEta

double EvtInclusiveDecay::m_userSelMu1MaxEta

private

Definition at line 148 of file EvtInclusiveDecay.h.

m_userSelMu1MinPt

double EvtInclusiveDecay::m_userSelMu1MinPt

private

Definition at line 146 of file EvtInclusiveDecay.h.

m_userSelMu2MaxEta

double EvtInclusiveDecay::m_userSelMu2MaxEta

private

Definition at line 149 of file EvtInclusiveDecay.h.

m_userSelMu2MinPt

double EvtInclusiveDecay::m_userSelMu2MinPt

private

Definition at line 147 of file EvtInclusiveDecay.h.

m_userSelRequireOppositeSignedMu

bool EvtInclusiveDecay::m_userSelRequireOppositeSignedMu

private

Definition at line 145 of file EvtInclusiveDecay.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_whiteList

std::vector<int> EvtInclusiveDecay::m_whiteList

private

Definition at line 128 of file EvtInclusiveDecay.h.

m_whiteListSet

std::set<int> EvtInclusiveDecay::m_whiteListSet

private

Definition at line 129 of file EvtInclusiveDecay.h.

---

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

• EvtInclusiveDecay.h
• EvtInclusiveDecay.cxx