MergeMcEventCollTool Class Reference

a PileUpTool to merge MC truth collection in the overlay store More...

#include <MergeMcEventCollTool.h>

Inheritance diagram for MergeMcEventCollTool:

Collaboration diagram for MergeMcEventCollTool:

Public Member Functions
	MergeMcEventCollTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int nInputEvents) override final
	called before the subevts loop. More...
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the subevts loop. More...
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	called for each active bunch-crossing to process current SubEvents bunchXing is in ns More...
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing More...

Private Types
enum	puType {   INTIME, OUTOFTIME, RESTOFMB, CAVERN,   NOPUTYPE }
typedef enum MergeMcEventCollTool::puType	puType
typedef std::map< std::pair< int, int >, int >	PileUpBackgroundMap

Private Member Functions
StatusCode	processEvent (const McEventCollection *pMcEvtColl, const double currentEventTime, const int currentBkgEventIndex, int pileupType)
StatusCode	processFirstSubEvent (const McEventCollection *pMcEvtColl)
StatusCode	processUnfilteredEvent (const McEventCollection *pMcEvtColl, const double currentEventTime, const int currentBkgEventIndex, int pileupType)
StatusCode	processTruthFilteredEvent (const McEventCollection *pMcEvtColl, const double currentEventTime, const int currentBkgEventIndex, int pileupType)
StatusCode	compressOutputMcEventCollection ()
void	printDetailsOfMergedMcEventCollection () const
StatusCode	saveHeavyIonInfo (const McEventCollection *pMcEvtColl)
MergeMcEventCollTool::puType	classifyVertex (const HepMC::ConstGenParticlePtr &pCurrentVertexParticle, const HepMC::ConstGenVertexPtr &pCurrentParticleProductionVertex, double currentEventTime)
bool	isInitialCollisionVertex (const HepMC::ConstGenVertexPtr &pCurrentVertex) const
bool	isTruthFiltertedMcEventCollection (const McEventCollection *pMcEvtColl) const
void	updateClassificationMap (int signal_process_id, int event_number, int hack, int classification, bool firstUpdateForThisEvent)

Private Attributes
PileUpBackgroundMap	m_backgroundClassificationMap
ServiceHandle< PileUpMergeSvc >	m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Handle for the PileUpMergeSvc (provides input McEventCollections)"}
McEventCollection *	m_pOvrlMcEvColl {}
StringProperty	m_truthCollInputKey {this, "TruthCollInputKey", "TruthEvent", "Name of input McEventCollection"}
StringProperty	m_truthCollOutputKey {this, "TruthCollOutputKey", "TruthEvent", "Name of output McEventCollection"}
BooleanProperty	m_keepUnstable {this, "KeepUnstable", false, "Do not cut unstable particles"}
DoubleProperty	m_absEtaMax {this, "AbsEtaMax", 5.0, "Eta cut-off for INTIME GenParticles"}
DoubleProperty	m_absEtaMax_outOfTime {this,"OutOfTimeAbsEtaMax", 3.0, "Eta cut-off for OUTOFTIME GenParticles"}
DoubleProperty	m_lowTimeToKeep {this, "LowTimeToKeep", -51.0, "leading edge in ns of the time window to keep if SaveOutOfTimePileUp is true"}
DoubleProperty	m_highTimeToKeep {this, "HighTimeToKeep", 51.0, "trailing edge in ns of the time window to keep if SaveOutOfTimePileUp is true"}
DoubleProperty	m_rRange {this, "rRange", 20.0*Gaudi::Units::mm, "rRange of production vertex in mm"}
double	m_r2Range {400.0}
DoubleProperty	m_zRange {this, "zRange", 200.0*Gaudi::Units::mm, "z range of production vertex in mm"}
DoubleProperty	m_ptMin {this, "ptMin", 0.4*Gaudi::Units::GeV, "Minimum threshold for pT for selected pileup particles in MeV"}
DoubleProperty	m_minKinE {this, "EKinMin", 1.0*Gaudi::Units::MeV, "Minimum threshold for Kinetic Energy of selected cavern events in MeV"}
BooleanProperty	m_saveInTimePileup {this, "SaveInTimeMinBias", true, "save min bias particles in the t0 xing"}
BooleanProperty	m_saveOutOfTimePileup {this, "SaveOutOfTimeMinBias", true, "save out of time min bias particles in the [LowTimeToKeep:HighTimeToKeep] range"}
BooleanProperty	m_saveRestOfPileup {this, "SaveRestOfMinBias", false, "save the rest of out of time min bias particles as well"}
BooleanProperty	m_saveCavernBackground {this, "SaveCavernBackground", true, "save the cavern background as well"}
BooleanProperty	m_doSlimming {this, "DoSlimming", true, "flag to do the slimming or save everything"}
bool	m_saveType [NOPUTYPE] ={}
unsigned int	m_startingIndexForBackground {0}
bool	m_newevent {true}
unsigned int	m_nInputMcEventColls {0}
unsigned int	m_nBkgEventsReadSoFar {0}
BooleanProperty	m_addBackgroundCollisionVertices {this, "AddBackgroundCollisionVertices", true, "ensure that the collision GenVertex objects of minbias background events are saved."}
BooleanProperty	m_compressOutputCollection {this, "CompressOutputCollection", false, "Remove all empty GenEvents from the output McEventCollection"}
BooleanProperty	m_onlySaveSignalTruth {this, "OnlySaveSignalTruth", false, "Just save the Signal GenEvent"}
int	m_signal_event_number {0}

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing More...
virtual StatusCode	processAllSubEvents (const EventContext &ctx)=0
	dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...
virtual bool	filterPassed () const override
	dummy implementation of passing filter More...
virtual void	resetFilter () override
	dummy implementation of filter reset More...
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

a PileUpTool to merge MC truth collection in the overlay store

$Id:

Author

jchap.nosp@m.man@.nosp@m.cern..nosp@m.ch

Definition at line 28 of file MergeMcEventCollTool.h.

Member Typedef Documentation

PileUpBackgroundMap

typedef std::map<std::pair<int,int>, int> MergeMcEventCollTool::PileUpBackgroundMap

private

Definition at line 77 of file MergeMcEventCollTool.h.

puType

typedef enum MergeMcEventCollTool::puType MergeMcEventCollTool::puType

private

Member Enumeration Documentation

puType

enum MergeMcEventCollTool::puType

private

Enumerator
INTIME
OUTOFTIME
RESTOFMB
CAVERN
NOPUTYPE

Definition at line 54 of file MergeMcEventCollTool.h.

{ INTIME, OUTOFTIME, RESTOFMB, CAVERN, NOPUTYPE } puType;

Constructor & Destructor Documentation

MergeMcEventCollTool()

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

Definition at line 70 of file MergeMcEventCollTool.cxx.

                                                                     :
  PileUpToolBase(type, name, parent)
{
}

Member Function Documentation

classifyVertex()

MergeMcEventCollTool::puType MergeMcEventCollTool::classifyVertex ( const HepMC::ConstGenParticlePtr &  pCurrentVertexParticle, const HepMC::ConstGenVertexPtr &  pCurrentParticleProductionVertex, double  currentEventTime  )

private

cut to select between minbias and cavern background pileup events

Definition at line 512 of file MergeMcEventCollTool.cxx.

                                                                                                                                                                                                                 {
  //=======================================================================
  //handle the slimming case
  //=======================================================================
  puType particleClassification(NOPUTYPE);
  if ( pCurrentParticleProductionVertex ) {
    //throw away unstable particles and particles outside eta cut
    if ( m_keepUnstable || MC::isSimStable(pCurrentVertexParticle) ) {
      if ( std::abs(pCurrentParticleProductionVertex->position().z()) < m_zRange ) {
        const float xi((pCurrentParticleProductionVertex->position()).x());
        const float yi((pCurrentParticleProductionVertex->position()).y());
        if ( !m_doSlimming || ( (xi*xi + yi*yi < m_r2Range) && (pCurrentVertexParticle->momentum().perp() > m_ptMin) ) ) {
          const double eta(pCurrentVertexParticle->momentum().pseudoRapidity());
          if ( !m_doSlimming || (std::abs(eta) <= m_absEtaMax) ) {
            const bool currentEventIsInTime((m_lowTimeToKeep<=currentEventTime) && (currentEventTime<=m_highTimeToKeep));
            if ( currentEventIsInTime ) {
              // cout << "the Time is " << currentEventTime << std::endl;
              if ( 0.0==currentEventTime ) {
                particleClassification=INTIME;
              }
              else if (std::abs(eta) <= m_absEtaMax_outOfTime) {
                particleClassification=OUTOFTIME;
              }
              else {
                particleClassification=RESTOFMB;
              }
            }
            else {
              particleClassification=RESTOFMB;
            }
          } // r2 && eta cut
        } // ptmin cut
      } // zrange cut
      else {
        // select cavern events
        double mass(pCurrentVertexParticle->momentum().m());
        if ( mass < 0.0 ) { mass = 0.0; }
        const double kineticEnergy(pCurrentVertexParticle->momentum().e() - mass);
        if ( !m_doSlimming || ( (kineticEnergy > m_minKinE) && (MC::charge(pCurrentVertexParticle->pdg_id()) != 0) ) ) {
          particleClassification=CAVERN;
        }
      } // zrange cut
    } // keep unstable
  } // pCurrentParticleProductionVertex is not NULL
  return particleClassification;
}

compressOutputMcEventCollection()

StatusCode MergeMcEventCollTool::compressOutputMcEventCollection ( )

private

Definition at line 560 of file MergeMcEventCollTool.cxx.

                                                                 {
  int currentClassification=int(INTIME);
  if (! m_pOvrlMcEvColl->empty()) {
    DataVector<HepMC::GenEvent>::iterator outputEventItr(m_pOvrlMcEvColl->begin());
    while(outputEventItr!=m_pOvrlMcEvColl->end()) { //as end may change
      const int signal_process_id(HepMC::signal_process_id((*outputEventItr))),event_number((*outputEventItr)->event_number());
      //Check for separators
      if(signal_process_id==0 && event_number==-1) {
        ++outputEventItr;
        ++currentClassification;
        continue;
      }
      if((*outputEventItr)->vertices_empty()) {
        //Delete empty GenEvent
        outputEventItr=m_pOvrlMcEvColl->erase(outputEventItr);
        ATH_MSG_VERBOSE( "compressOutputMcEventCollection() Removed Empty GenEvent #" << event_number << ", signal_process_id(" << signal_process_id << "), category = " << currentClassification);
        continue;
      }
      ++outputEventItr;
    }
  }
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

initialize()

StatusCode MergeMcEventCollTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 77 of file MergeMcEventCollTool.cxx.

                                            {
  ATH_MSG_DEBUG( "Initializing" );
  if (m_doSlimming) {
    //set all m_saveTypes based on properties
    m_saveType[INTIME] = m_saveInTimePileup.value();
    m_saveType[OUTOFTIME] = m_saveOutOfTimePileup.value();
    m_saveType[RESTOFMB] = m_saveRestOfPileup.value();
    m_saveType[CAVERN] = m_saveCavernBackground.value();
  }
  else {
    m_keepUnstable        = true;
    m_saveType[INTIME]    = true;
    m_saveType[OUTOFTIME] = true;
    m_saveType[RESTOFMB]  = true;
    m_saveType[CAVERN]    = true;
  }
  m_r2Range = m_rRange*m_rRange;
 
  return StatusCode::SUCCESS;
}

isInitialCollisionVertex()

bool MergeMcEventCollTool::isInitialCollisionVertex ( const HepMC::ConstGenVertexPtr &  pCurrentVertex ) const

private

Definition at line 497 of file MergeMcEventCollTool.cxx.

                                                                                                       {
//AV: The olde version was too generator specific. 
#ifdef HEPMC3
  for (const auto& pCurrentVertexParticle: pCurrentVertex->particles_in()) {
#else
  auto currentVertexParticleIter = pCurrentVertex->particles_in_const_begin();
  auto  endOfListOfParticlesFromCurrentVertex = pCurrentVertex->particles_in_const_end();
  for( ;currentVertexParticleIter != endOfListOfParticlesFromCurrentVertex; ++currentVertexParticleIter ) {
    auto pCurrentVertexParticle = *currentVertexParticleIter;
#endif
    if (MC::isBeam(pCurrentVertexParticle)) return true;
  }
  return false;
}

isTruthFiltertedMcEventCollection()

bool MergeMcEventCollTool::isTruthFiltertedMcEventCollection ( const McEventCollection *  pMcEvtColl ) const

private

Definition at line 307 of file MergeMcEventCollTool.cxx.

                                                                                                      {
  const HepMC::GenEvent* currentBackgroundEvent = *(pMcEvtColl->begin());
#ifdef HEPMC3
  if (currentBackgroundEvent->particles().size()!=1) return false;
  if (currentBackgroundEvent->particles().at(0)->pdg_id()==999) return true;
#else
  if (currentBackgroundEvent->particles_size()!=1) return false;
  if ((*(currentBackgroundEvent->particles_begin()))->pdg_id()==999) return true;
#endif
  return false;
}

mergeEvent()

StatusCode MergeMcEventCollTool::mergeEvent ( const EventContext &  ctx )

finaloverridevirtual

called at the end of the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 209 of file MergeMcEventCollTool.cxx.

                                                                 {
  ATH_MSG_DEBUG( "mergeEvent" );
  if(m_nBkgEventsReadSoFar+1<m_nInputMcEventColls) {
    ATH_MSG_WARNING( "mergeEvent: Expected " << m_nInputMcEventColls << " subevents, but only saw " << m_nBkgEventsReadSoFar+1 << "! The job will probably crash now..." );
    return StatusCode::FAILURE;
  }
 
  //Remove empty copies of GenEvents
  if(m_compressOutputCollection) CHECK( compressOutputMcEventCollection() );
 
  if(m_backgroundClassificationMap.size()!=m_pOvrlMcEvColl->size()) {
    ATH_MSG_WARNING( "There are " << m_pOvrlMcEvColl->size() << " GenEvents in the McEventCollection, but " << m_backgroundClassificationMap.size() << " entries in the classification map." );
  }
  //Sort the GenEvents in the output McEventCollection according to background classification
 
  std::sort(m_pOvrlMcEvColl->begin(), m_pOvrlMcEvColl->end(), GenEventSorter(m_backgroundClassificationMap));
  ATH_MSG_DEBUG("Sorted McEventCollection OK.");
  if(msgLvl(MSG::DEBUG)) { printDetailsOfMergedMcEventCollection(); }
 
  if(m_pOvrlMcEvColl->at(0)->event_number()!=-2)
    {
      ATH_MSG_FATAL("Signal GenEvent is not first in the list! Something has gone wrong during the GenEvent sorting!");
      return StatusCode::FAILURE;
    }
  //Restore original event number
  m_pOvrlMcEvColl->at(0)->set_event_number(m_signal_event_number);
 
  return StatusCode::SUCCESS;
}

prepareEvent()

StatusCode MergeMcEventCollTool::prepareEvent ( const EventContext &  ctx, unsigned int  nInputEvents  )

finaloverridevirtual

called before the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 98 of file MergeMcEventCollTool.cxx.

                                                                                              {
  //clear the background classification map
  m_backgroundClassificationMap.clear();
  m_newevent=true;
 
  //Check we are getting at least one event
  m_nInputMcEventColls = nInputEvents;
  if (0 == m_nInputMcEventColls) {
    msg(MSG::ERROR)
      << "prepareEvent: TimedTruthList with key "
      << m_truthCollInputKey.value()
      << " is empty" << endmsg;
    return StatusCode::RECOVERABLE;
  }
  ATH_MSG_DEBUG( "prepareEvent: there are " << m_nInputMcEventColls << " subevents in this event.");
 
  return StatusCode::SUCCESS;
}

printDetailsOfMergedMcEventCollection()

void MergeMcEventCollTool::printDetailsOfMergedMcEventCollection ( ) const

private

Definition at line 238 of file MergeMcEventCollTool.cxx.

                                                                       {
  if (! m_pOvrlMcEvColl->empty()) {
    ATH_MSG_INFO ( "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" );
    ATH_MSG_INFO ( "INTIME("<<int(INTIME)<<"), OUTOFTIME("<<int(OUTOFTIME)<<"), RESTOFMB("<<int(RESTOFMB)<<"), CAVERN("<<int(CAVERN)<<"), NOPUTYPE("<<int(NOPUTYPE)<<")" );
    ATH_MSG_INFO ( "Current OUTPUT GenEvent: " );
    auto outputEventItr = m_pOvrlMcEvColl->cbegin();
    while(outputEventItr!=m_pOvrlMcEvColl->cend()) {
      const int signal_process_id(HepMC::signal_process_id((*outputEventItr))), event_number((*outputEventItr)->event_number()), separator_hack(HepMC::mpi((*outputEventItr)));
      const IndexKey key(makekey(signal_process_id,event_number,separator_hack));
      const PileUpBackgroundMap::const_iterator event(m_backgroundClassificationMap.find(key));
      ATH_MSG_INFO ( "GenEvent #"<<event_number<<", signal_process_id="<<signal_process_id<<", category="<<event->second<<", number of Vertices="<<(*outputEventItr)->vertices_size() );
      ++outputEventItr;
    }
    ATH_MSG_INFO ( "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" );
  }
  return;
}

processAllSubEvents() [1/2]

StatusCode MergeMcEventCollTool::processAllSubEvents ( const EventContext &  ctx )

finaloverridevirtual

return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

Reimplemented from PileUpToolBase.

Definition at line 117 of file MergeMcEventCollTool.cxx.

                                                                          {
  ATH_MSG_VERBOSE ( "processAllSubEvents()" );
  if(!m_pMergeSvc) {
    if (!(m_pMergeSvc.retrieve()).isSuccess()) {
      ATH_MSG_FATAL ( "processAllSubEvents: Could not find PileUpMergeSvc" );
      return StatusCode::FAILURE;
    }
  }
 
  //PRECONDITIONS
  //first get the list of McEventCollections
  typedef PileUpMergeSvc::TimedList<McEventCollection>::type TimedTruthList;
  TimedTruthList truthList;
  if (!m_pMergeSvc->retrieveSubEvtsData(m_truthCollInputKey.value(), truthList).isSuccess() ) {
    msg(MSG::ERROR)
      << "execute: Can not find TimedTruthList with key "
      << m_truthCollInputKey.value() << endmsg;
    return StatusCode::RECOVERABLE;
  }
 
  //clear the background classification map
  m_backgroundClassificationMap.clear();
 
  //Check we are getting at least one event
  m_nInputMcEventColls=truthList.size();
  if (0 == m_nInputMcEventColls) {
    msg(MSG::ERROR)
      << "execute: TimedTruthList with key "
      << m_truthCollInputKey.value()
      << " is empty" << endmsg;
    return StatusCode::RECOVERABLE;
  }
  ATH_MSG_DEBUG( "execute: there are " << m_nInputMcEventColls << " subevents in this event.");
  TimedTruthList::iterator timedTruthListIter(truthList.begin()), endOfTimedTruthList(truthList.end());
  //loop over the McEventCollections (each one assumed to containing exactly one GenEvent) of the various input events
  m_newevent=true;
  while (timedTruthListIter != endOfTimedTruthList) {
    const PileUpTimeEventIndex& currentPileUpTimeEventIndex(timedTruthListIter->first);
    const McEventCollection *pBackgroundMcEvtColl(&*(timedTruthListIter->second));
    if (!processEvent(pBackgroundMcEvtColl, currentPileUpTimeEventIndex.time(), currentPileUpTimeEventIndex.index(), static_cast<int>(currentPileUpTimeEventIndex.type())).isSuccess()) {
      ATH_MSG_ERROR ("Failed to process McEventCollection." );
      return StatusCode::FAILURE;
    }
    ++timedTruthListIter;
  } //timed colls
 
  //Remove empty copies of GenEvents
  if(m_compressOutputCollection) CHECK( compressOutputMcEventCollection() );
 
  //Sort the GenEvents in the output McEventCollection according to background classification
  std::sort(m_pOvrlMcEvColl->begin(), m_pOvrlMcEvColl->end(), GenEventSorter(m_backgroundClassificationMap));
 
  if(msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG("Sorted McEventCollection OK.");
    printDetailsOfMergedMcEventCollection();
  }
 
  if(m_pOvrlMcEvColl->at(0)->event_number()!=-2)
    {
      ATH_MSG_FATAL("Signal GenEvent is not first in the list! Something has gone wrong during the GenEvent sorting!");
      return StatusCode::FAILURE;
    }
  //Restore original event number
  m_pOvrlMcEvColl->at(0)->set_event_number(m_signal_event_number);
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents

inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

processBunchXing()

StatusCode MergeMcEventCollTool::processBunchXing ( int  bunchXing, SubEventIterator  bSubEvents, SubEventIterator  eSubEvents  )

finaloverridevirtual

called for each active bunch-crossing to process current SubEvents bunchXing is in ns

Reimplemented from PileUpToolBase.

Definition at line 185 of file MergeMcEventCollTool.cxx.

{
  ATH_MSG_VERBOSE ( "processBunchXing()" );
  SubEventIterator iEvt(bSubEvents);
  //loop over the McEventCollections (each one assumed to containing exactly one GenEvent) of the various input events
  while (iEvt != eSubEvents) {
    const McEventCollection *pMEC(NULL);
    if (!m_pMergeSvc->retrieveSingleSubEvtData(m_truthCollInputKey.value(), pMEC,
                           bunchXing, iEvt).isSuccess()){
      ATH_MSG_ERROR("McEventCollection not found for event key " << m_truthCollInputKey.value());
      return StatusCode::FAILURE;
    }
 
    if (!processEvent(pMEC,iEvt->time(),iEvt->index(), static_cast<int>(iEvt->type())).isSuccess()) {
      ATH_MSG_ERROR ("processBunchXing: Failed to process McEventCollection." );
      return StatusCode::FAILURE;
    }
    ++iEvt;
  }
  return StatusCode::SUCCESS;
}

processEvent()

StatusCode MergeMcEventCollTool::processEvent ( const McEventCollection *  pMcEvtColl, const double  currentEventTime, const int  currentBkgEventIndex, int  pileupType  )

private

Definition at line 319 of file MergeMcEventCollTool.cxx.

                                                                                                                                                                {
  ATH_MSG_VERBOSE ( "processEvent()" );
  if(m_newevent) return processFirstSubEvent(pMcEvtColl);
 
  if (pMcEvtColl->empty() || m_onlySaveSignalTruth) {
    ++m_nBkgEventsReadSoFar;
    return StatusCode::SUCCESS;
  }
  //GenEvt is there
 
  //Examine the properties of the GenEvent - if it looks like a TruthFiltered background event (contains a Geantino?!) 
  //then save the whole event as below, otherwise do the usual classification.
  if(isTruthFiltertedMcEventCollection(pMcEvtColl)) {
    if ( processTruthFilteredEvent(pMcEvtColl,  currentEventTime, currentBkgEventIndex, pileupType).isSuccess() ) {
      ++m_nBkgEventsReadSoFar;
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_ERROR ("Failed to process a Truth Filtered GenEvent.");
    }
  }
  else {
    if ( processUnfilteredEvent(pMcEvtColl,  currentEventTime, currentBkgEventIndex, pileupType).isSuccess() ) {
      ++m_nBkgEventsReadSoFar;
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_ERROR ("Failed to process an Unfiltered GenEvent.");
    }
  }
  //If we make it here something has gone wrong.
  ++m_nBkgEventsReadSoFar;
  return StatusCode::FAILURE;
}

processFirstSubEvent()

StatusCode MergeMcEventCollTool::processFirstSubEvent ( const McEventCollection *  pMcEvtColl )

private

Definition at line 256 of file MergeMcEventCollTool.cxx.

                                                                                         {
  StatusCode sc(StatusCode::FAILURE);
  //Assumes the first sub-event is the signal event
  m_pOvrlMcEvColl = new McEventCollection(*pMcEvtColl);
  m_signal_event_number = m_pOvrlMcEvColl->at(0)->event_number();
  m_pOvrlMcEvColl->at(0)->set_event_number(-2); //Set this to zero for the purposes of sorting. (restore after sorting).
#ifdef HEPMC3
  m_pOvrlMcEvColl->at(0)->add_attribute("BunchCrossingTime",std::make_shared<HepMC3::IntAttribute>(0));
  m_pOvrlMcEvColl->at(0)->add_attribute("PileUpType",std::make_shared<HepMC3::IntAttribute>(0));
#endif
  updateClassificationMap(HepMC::signal_process_id(m_pOvrlMcEvColl->at(0)), m_pOvrlMcEvColl->at(0)->event_number(), 0,- 1, true);
  m_newevent=false; //Now the McEventCollection and classification map are not empty this should be set to false.
  ATH_MSG_DEBUG( "execute: copied original event McEventCollection" );
  const unsigned int nBackgroundMcEventCollections(m_nInputMcEventColls-1); // -1 for original event
  // -> reserve enough space
  unsigned int outCollSize(m_pOvrlMcEvColl->size());
  if(!m_onlySaveSignalTruth) { outCollSize += nBackgroundMcEventCollections; }
  outCollSize += NOPUTYPE-1; // Adding room for the spacers
  m_pOvrlMcEvColl->resize(outCollSize);
  if(!m_onlySaveSignalTruth) { ATH_MSG_DEBUG ( "Number of input SubEvents = " << m_nInputMcEventColls ); }
  ATH_MSG_DEBUG ( "Total Size of Output McEventCollection = " << outCollSize );
 
  //now place the "separator" GenEvents. This is a hack used by clients to find/double-check where the GenEvents
  //of a given type start in the overlay McEventCollection.
 
  // For example if intime and cavern saving is enabled i.e.
  // Configurable          Variable in code         Example Value
  // SaveInTimeMinBias     m_saveType[INTIME]       true
  // SaveOutOfTimeMinBias  m_saveType[OUTOFTIME]    false
  // SaveRestOfMinBias     m_saveType[RESTOFMB]     false
  // SaveCavernBackground  m_saveType[CAVERN]       true
  //If we have two input GenEvents the output collection would look like
  //SIGNAL, INTIME0, INTIME1, SEPARATOR, SEPARATOR, SEPARATOR, CAVERN0, CAVERN1
  unsigned int currentMcEventCollectionIndex(1);
  ATH_MSG_DEBUG ( "Event Type: SIGNAL Starts at Position 0" );
  for (int type(OUTOFTIME); type<NOPUTYPE; ++type) {
    //if a type is enabled leave room to insert the events of that type, otherwise place separator immediately after
    currentMcEventCollectionIndex += 1;
    m_pOvrlMcEvColl->at(currentMcEventCollectionIndex-1) = HepMC::newGenEvent(0, -1); //pid 0 & event_number -1 flags this GenEvent as SEPARATOR
    HepMC::set_mpi(m_pOvrlMcEvColl->at(currentMcEventCollectionIndex-1),type);
    updateClassificationMap(0, -1, type, type, true);
    ATH_MSG_DEBUG ( "Placing Separator for Type: "<<type<<" at Posistion: " << currentMcEventCollectionIndex-1 );
  }
  m_startingIndexForBackground=currentMcEventCollectionIndex;
  m_nBkgEventsReadSoFar=0; //number of input events/eventcolls read so far. Used to build index of output GenEvent in ovrl McEvColl
  sc = evtStore()->record(m_pOvrlMcEvColl, m_truthCollOutputKey);//**BIG TEST**//sc=StatusCode::SUCCESS;
  ATH_MSG_DEBUG( "Starting loop on Background events ... " );
 
  return sc;
}

processTruthFilteredEvent()

StatusCode MergeMcEventCollTool::processTruthFilteredEvent ( const McEventCollection *  pMcEvtColl, const double  currentEventTime, const int  currentBkgEventIndex, int  pileupType  )

private

Definition at line 370 of file MergeMcEventCollTool.cxx.

                                                                                                                                                                             {
  //insert the GenEvent into the overlay McEventCollection.
  ATH_MSG_VERBOSE ( "processTruthFilteredEvent(): Event Type: " << pileupType );
  ATH_CHECK(this->saveHeavyIonInfo(pMcEvtColl));
  m_pOvrlMcEvColl->at(m_startingIndexForBackground+m_nBkgEventsReadSoFar)=new HepMC::GenEvent(**(pMcEvtColl->begin()));
  HepMC::GenEvent& currentBackgroundEvent(*(m_pOvrlMcEvColl->at(m_startingIndexForBackground+m_nBkgEventsReadSoFar)));
  HepMC::fillBarcodesAttribute(&currentBackgroundEvent);
#ifdef HEPMC3
  const int bunchCrossingTime=static_cast<int>(currentEventTime);
  currentBackgroundEvent.add_attribute("BunchCrossingTime",std::make_shared<HepMC3::IntAttribute>(bunchCrossingTime));
  currentBackgroundEvent.add_attribute("PileUpType",std::make_shared<HepMC3::IntAttribute>(pileupType));
#endif
 
  currentBackgroundEvent.set_event_number(currentBkgEventIndex);
  puType currentGenEventClassification(RESTOFMB);
  if ( std::abs(currentEventTime)<51.0 ) {
    currentGenEventClassification = ( std::abs(currentEventTime)<1.0 ) ? INTIME : OUTOFTIME;
  }
  updateClassificationMap(HepMC::signal_process_id(currentBackgroundEvent),
                          currentBackgroundEvent.event_number(),
                          0, currentGenEventClassification, true);
  return StatusCode::SUCCESS;
}

processUnfilteredEvent()

StatusCode MergeMcEventCollTool::processUnfilteredEvent ( const McEventCollection *  pMcEvtColl, const double  currentEventTime, const int  currentBkgEventIndex, int  pileupType  )

private

add the in-coming particles to the in-time minbias vertex only

Definition at line 394 of file MergeMcEventCollTool.cxx.

                                                                                                                                                                          {
  ATH_MSG_VERBOSE ( "processUnfilteredEvent() Event Type: " << pileupType );
  ATH_CHECK(this->saveHeavyIonInfo(pMcEvtColl));
  const HepMC::GenEvent& currentBackgroundEvent(**(pMcEvtColl->begin()));         //background event
  //handle the slimming case
  HepMC::GenVertexPtr  pCopyOfGenVertex{nullptr};
  int  spi = HepMC::signal_process_id(currentBackgroundEvent);
#ifdef HEPMC3
  if ( HepMC::signal_process_vertex(&currentBackgroundEvent) ) pCopyOfGenVertex = std::make_shared<HepMC3::GenVertex> ( HepMC::signal_process_vertex(&currentBackgroundEvent)->data() );
  //insert the GenEvent into the overlay McEventCollection.
  //for configs with pile-up truth, also need to propagate barcodes to GenEvent
  HepMC::GenEvent* evt = m_onlySaveSignalTruth ? new HepMC::GenEvent() : new HepMC::GenEvent(currentBackgroundEvent);
  const int bunchCrossingTime=static_cast<int>(currentEventTime);
  evt->add_attribute("BunchCrossingTime",std::make_shared<HepMC3::IntAttribute>(bunchCrossingTime));
  evt->add_attribute("PileUpType",std::make_shared<HepMC3::IntAttribute>(pileupType));
  //AV Not sure if one should add the vertex here
  evt->set_event_number(currentBkgEventIndex);
  evt->add_vertex(pCopyOfGenVertex);
  HepMC::set_signal_process_vertex(evt,pCopyOfGenVertex);
  HepMC::set_signal_process_id(evt,spi);
  m_pOvrlMcEvColl->at(m_startingIndexForBackground+m_nBkgEventsReadSoFar) =  evt;
  updateClassificationMap(spi, currentBkgEventIndex, 0, RESTOFMB, true);
 
  unsigned int nCollisionVerticesFound(0);
  //loop over vertices in Background GenEvent
  ATH_MSG_VERBOSE( "Starting a vertex loop ... " );
  auto currentVertexIter = currentBackgroundEvent.vertices().begin();
  auto endOfCurrentListOfVertices = currentBackgroundEvent.vertices().end();
#else
  if ( HepMC::signal_process_vertex(&currentBackgroundEvent) ) pCopyOfGenVertex = new HepMC::GenVertex ( *currentBackgroundEvent.signal_process_vertex() );
  //insert the GenEvent into the overlay McEventCollection.
  m_pOvrlMcEvColl->at(m_startingIndexForBackground+m_nBkgEventsReadSoFar) = new HepMC::GenEvent(spi, currentBkgEventIndex, pCopyOfGenVertex );
  updateClassificationMap(spi, currentBkgEventIndex, 0, RESTOFMB, true);
 
  unsigned int nCollisionVerticesFound(0);
  //loop over vertices in Background GenEvent
  ATH_MSG_VERBOSE( "Starting a vertex loop ... " );
  auto currentVertexIter = currentBackgroundEvent.vertices_begin();
  auto endOfCurrentListOfVertices = currentBackgroundEvent.vertices_end();
#endif
  for (; currentVertexIter != endOfCurrentListOfVertices; ++currentVertexIter) {
    const auto&  pCurrentVertex=*currentVertexIter;
    HepMC::GenVertexPtr  pCopyOfVertexForClassification[NOPUTYPE];
    for (int type(INTIME); type<NOPUTYPE; ++type) pCopyOfVertexForClassification[type]=(HepMC::GenVertexPtr )nullptr;
 
    //check for collision vertices for in-time events
    bool isCollisionVertex(false);
    if(m_addBackgroundCollisionVertices && nCollisionVerticesFound<2 && currentEventTime==0.0) {
      isCollisionVertex=isInitialCollisionVertex(pCurrentVertex);
      if(isCollisionVertex) ++nCollisionVerticesFound;
    }
 
    //loop over outgoing particles in the current GenVertex keeping those not classified as NOPUTYPE
    ATH_MSG_VERBOSE( "Starting an outgoing particle loop ... " );
    for (const HepMC::ConstGenParticlePtr& currentVertexParticle: *pCurrentVertex){
      ATH_MSG_VERBOSE( "Found a particle at location " << std::hex << currentVertexParticle << std::dec  << " with PDG ID = " << currentVertexParticle->pdg_id() );
      HepMC::ConstGenVertexPtr  pCurrentParticleProductionVertex = currentVertexParticle->production_vertex();
      puType particleClassification(classifyVertex(currentVertexParticle, pCurrentParticleProductionVertex,currentEventTime));
      //hack to keep the complete vertex information for the interaction vertices of in-time background events
      if(isCollisionVertex && NOPUTYPE==particleClassification) {
        particleClassification=INTIME;
      }
      //add particle to appropriate vertex
      if (particleClassification<NOPUTYPE && m_saveType[particleClassification]) {
        if (!pCopyOfVertexForClassification[particleClassification]) {
          pCopyOfVertexForClassification[particleClassification] =HepMC::newGenVertexPtr(pCurrentVertex->position());
          ATH_MSG_VERBOSE( "Added bkg vertex " << pCopyOfVertexForClassification[particleClassification] << " at position " <<  pCopyOfVertexForClassification[particleClassification] << " for pu type = " << particleClassification );
        }
#ifdef HEPMC3
        pCopyOfVertexForClassification[particleClassification]->add_particle_out(std::make_shared<HepMC3::GenParticle>(currentVertexParticle->data()));
#else
        pCopyOfVertexForClassification[particleClassification]->add_particle_out( new HepMC::GenParticle(*currentVertexParticle) );
#endif
        ATH_MSG_VERBOSE( "Added bkg particle at location " << std::hex << currentVertexParticle << std::dec << " with PDG ID = " << currentVertexParticle->pdg_id() );
      }
    } //particle loop
    if (m_saveType[INTIME] && pCopyOfVertexForClassification[INTIME]) {
#ifdef HEPMC3
 for (const auto& currentVertexParticle:  pCurrentVertex->particles_in()) {
        pCopyOfVertexForClassification[INTIME]->add_particle_in (std::make_shared<HepMC3::GenParticle>(currentVertexParticle->data()));
      }
#else
      HepMC::GenVertex::particles_in_const_iterator currentVertexParticleIter(pCurrentVertex->particles_in_const_begin());
      const HepMC::GenVertex::particles_in_const_iterator endOfListOfParticlesFromCurrentVertex(pCurrentVertex->particles_in_const_end());
      for (; currentVertexParticleIter != endOfListOfParticlesFromCurrentVertex; ++currentVertexParticleIter) {
        pCopyOfVertexForClassification[INTIME]->add_particle_in ( new HepMC::GenParticle(**currentVertexParticleIter) );
      }
#endif
    }
    //keep vertices with outgoing particles
    for (int type(INTIME); type<NOPUTYPE; ++type) {
      if (!pCopyOfVertexForClassification[type]) continue;
      int n_particles_out=pCopyOfVertexForClassification[type]->particles_out_size();
      if (m_saveType[type] && (n_particles_out > 0) ) {
        updateClassificationMap(spi, currentBkgEventIndex, 0, type, false);
      }
    }
  } //vertex loop
 
  return StatusCode::SUCCESS;
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

saveHeavyIonInfo()

StatusCode MergeMcEventCollTool::saveHeavyIonInfo ( const McEventCollection *  pMcEvtColl )

private

Definition at line 354 of file MergeMcEventCollTool.cxx.

{
  if (m_pOvrlMcEvColl->at(0)->heavy_ion()) return StatusCode::SUCCESS;
  if (pMcEvtColl->at(0)->heavy_ion())
    {
//It should be clarified if ne wants to get a copy or the content
#ifdef HEPMC3
     HepMC::GenHeavyIonPtr hinew=std::make_shared<HepMC::GenHeavyIon>(*(pMcEvtColl->at(0)->heavy_ion()));
     m_pOvrlMcEvColl->at(0)->set_heavy_ion(hinew);
#else
      m_pOvrlMcEvColl->at(0)->set_heavy_ion(*(pMcEvtColl->at(0)->heavy_ion()));
#endif
    }
  return StatusCode::SUCCESS;
}

toProcess()

virtual bool PileUpToolBase::toProcess ( int  bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

updateClassificationMap()

void MergeMcEventCollTool::updateClassificationMap ( int  signal_process_id, int  event_number, int  hack, int  classification, bool  firstUpdateForThisEvent = false  )

private

Definition at line 584 of file MergeMcEventCollTool.cxx.

{
  if(m_newevent && !m_backgroundClassificationMap.empty()) {
    ATH_MSG_ERROR( "updateClassidificationMap: GenEvent #" << event_number << ", signal_process_id(" << signal_process_id << "), category = " << classification );
    ATH_MSG_ERROR ("Failed to clear background classification map! Size = "<< m_backgroundClassificationMap.size());
    m_backgroundClassificationMap.clear();
  }
  if(-1==classification && !m_newevent) {
    ATH_MSG_ERROR( "updateClassidificationMap: GenEvent #" << event_number << ", signal_process_id(" << signal_process_id << "), category = " << classification );
    ATH_MSG_FATAL ("Should only ever be one signal event in the background classification map! Bailing out.");
  }
  // Check for separators
  IndexKey key(makekey(signal_process_id,event_number));
  //Check for Separator GenEvents
  if(signal_process_id==0 && event_number==-1) {
    key=makekey(separator_hack,event_number);
  }
  ATH_MSG_VERBOSE( "updateClassidificationMap: GenEvent #" << event_number << ", signal_process_id(" << signal_process_id << "), category = " << classification << ", key = " << key);
  const PileUpBackgroundMap::iterator event(m_backgroundClassificationMap.find(key));
  if(event!=m_backgroundClassificationMap.end()) {
    if(firstUpdateForThisEvent) {
      ATH_MSG_ERROR( "updateClassidificationMap: Repeated KEY! "<< key <<". Previous category = " << event->second );
    }
    else {
      ATH_MSG_DEBUG( "updateClassidificationMap: Updating category for existing key "<< key <<". Previous category = " << event->second << ", new category = " << classification );
    }
    if(int(RESTOFMB)!=event->second) {
      if(event->second<=classification) return;
    }
  }
  m_backgroundClassificationMap[key]=classification;
  return;
}

Member Data Documentation

m_absEtaMax

DoubleProperty MergeMcEventCollTool::m_absEtaMax {this, "AbsEtaMax", 5.0, "Eta cut-off for INTIME GenParticles"}

private

Definition at line 88 of file MergeMcEventCollTool.h.

m_absEtaMax_outOfTime

DoubleProperty MergeMcEventCollTool::m_absEtaMax_outOfTime {this,"OutOfTimeAbsEtaMax", 3.0, "Eta cut-off for OUTOFTIME GenParticles"}

private

Definition at line 89 of file MergeMcEventCollTool.h.

m_addBackgroundCollisionVertices

BooleanProperty MergeMcEventCollTool::m_addBackgroundCollisionVertices {this, "AddBackgroundCollisionVertices", true, "ensure that the collision GenVertex objects of minbias background events are saved."}

private

Definition at line 121 of file MergeMcEventCollTool.h.

m_backgroundClassificationMap

PileUpBackgroundMap MergeMcEventCollTool::m_backgroundClassificationMap

private

Definition at line 78 of file MergeMcEventCollTool.h.

m_compressOutputCollection

BooleanProperty MergeMcEventCollTool::m_compressOutputCollection {this, "CompressOutputCollection", false, "Remove all empty GenEvents from the output McEventCollection"}

private

Definition at line 123 of file MergeMcEventCollTool.h.

m_doSlimming

BooleanProperty MergeMcEventCollTool::m_doSlimming {this, "DoSlimming", true, "flag to do the slimming or save everything"}

private

Definition at line 109 of file MergeMcEventCollTool.h.

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

m_highTimeToKeep

DoubleProperty MergeMcEventCollTool::m_highTimeToKeep {this, "HighTimeToKeep", 51.0, "trailing edge in ns of the time window to keep if SaveOutOfTimePileUp is true"}

private

Definition at line 91 of file MergeMcEventCollTool.h.

m_keepUnstable

BooleanProperty MergeMcEventCollTool::m_keepUnstable {this, "KeepUnstable", false, "Do not cut unstable particles"}

private

Definition at line 87 of file MergeMcEventCollTool.h.

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

m_lowTimeToKeep

DoubleProperty MergeMcEventCollTool::m_lowTimeToKeep {this, "LowTimeToKeep", -51.0, "leading edge in ns of the time window to keep if SaveOutOfTimePileUp is true"}

private

Definition at line 90 of file MergeMcEventCollTool.h.

m_minKinE

DoubleProperty MergeMcEventCollTool::m_minKinE {this, "EKinMin", 1.0*Gaudi::Units::MeV, "Minimum threshold for Kinetic Energy of selected cavern events in MeV"}

private

Definition at line 99 of file MergeMcEventCollTool.h.

m_nBkgEventsReadSoFar

unsigned int MergeMcEventCollTool::m_nBkgEventsReadSoFar {0}

private

Definition at line 119 of file MergeMcEventCollTool.h.

m_newevent

bool MergeMcEventCollTool::m_newevent {true}

private

Definition at line 115 of file MergeMcEventCollTool.h.

m_nInputMcEventColls

unsigned int MergeMcEventCollTool::m_nInputMcEventColls {0}

private

Definition at line 117 of file MergeMcEventCollTool.h.

m_onlySaveSignalTruth

BooleanProperty MergeMcEventCollTool::m_onlySaveSignalTruth {this, "OnlySaveSignalTruth", false, "Just save the Signal GenEvent"}

private

Definition at line 125 of file MergeMcEventCollTool.h.

m_pMergeSvc

ServiceHandle<PileUpMergeSvc> MergeMcEventCollTool::m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Handle for the PileUpMergeSvc (provides input McEventCollections)"}

private

Definition at line 82 of file MergeMcEventCollTool.h.

m_pOvrlMcEvColl

McEventCollection* MergeMcEventCollTool::m_pOvrlMcEvColl {}

private

Definition at line 84 of file MergeMcEventCollTool.h.

m_ptMin

DoubleProperty MergeMcEventCollTool::m_ptMin {this, "ptMin", 0.4*Gaudi::Units::GeV, "Minimum threshold for pT for selected pileup particles in MeV"}

private

Definition at line 98 of file MergeMcEventCollTool.h.

m_r2Range

double MergeMcEventCollTool::m_r2Range {400.0}

private

Definition at line 95 of file MergeMcEventCollTool.h.

m_rRange

DoubleProperty MergeMcEventCollTool::m_rRange {this, "rRange", 20.0*Gaudi::Units::mm, "rRange of production vertex in mm"}

private

Definition at line 93 of file MergeMcEventCollTool.h.

m_saveCavernBackground

BooleanProperty MergeMcEventCollTool::m_saveCavernBackground {this, "SaveCavernBackground", true, "save the cavern background as well"}

private

Definition at line 107 of file MergeMcEventCollTool.h.

m_saveInTimePileup

BooleanProperty MergeMcEventCollTool::m_saveInTimePileup {this, "SaveInTimeMinBias", true, "save min bias particles in the t0 xing"}

private

Definition at line 101 of file MergeMcEventCollTool.h.

m_saveOutOfTimePileup

BooleanProperty MergeMcEventCollTool::m_saveOutOfTimePileup {this, "SaveOutOfTimeMinBias", true, "save out of time min bias particles in the [LowTimeToKeep:HighTimeToKeep] range"}

private

Definition at line 103 of file MergeMcEventCollTool.h.

m_saveRestOfPileup

BooleanProperty MergeMcEventCollTool::m_saveRestOfPileup {this, "SaveRestOfMinBias", false, "save the rest of out of time min bias particles as well"}

private

Definition at line 105 of file MergeMcEventCollTool.h.

m_saveType

bool MergeMcEventCollTool::m_saveType[NOPUTYPE] ={}

private

Definition at line 111 of file MergeMcEventCollTool.h.

m_signal_event_number

int MergeMcEventCollTool::m_signal_event_number {0}

private

Definition at line 127 of file MergeMcEventCollTool.h.

m_startingIndexForBackground

unsigned int MergeMcEventCollTool::m_startingIndexForBackground {0}

private

Definition at line 113 of file MergeMcEventCollTool.h.

m_truthCollInputKey

StringProperty MergeMcEventCollTool::m_truthCollInputKey {this, "TruthCollInputKey", "TruthEvent", "Name of input McEventCollection"}

private

Definition at line 85 of file MergeMcEventCollTool.h.

m_truthCollOutputKey

StringProperty MergeMcEventCollTool::m_truthCollOutputKey {this, "TruthCollOutputKey", "TruthEvent", "Name of output McEventCollection"}

private

Definition at line 86 of file MergeMcEventCollTool.h.

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

m_zRange

DoubleProperty MergeMcEventCollTool::m_zRange {this, "zRange", 200.0*Gaudi::Units::mm, "z range of production vertex in mm"}

private

Definition at line 97 of file MergeMcEventCollTool.h.

---

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

• MergeMcEventCollTool.h
• MergeMcEventCollTool.cxx