an algorithm to merge truth jet collections in the overlay store More...

#include <MergeTruthJetsTool.h>

Inheritance diagram for MergeTruthJetsTool:

Collaboration diagram for MergeTruthJetsTool:

Public Member Functions
	MergeTruthJetsTool (const std::string &type, const std::string &name, const IInterface *parent)
StatusCode	initialize () override final
	Initialize.
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int nInputEvents) override final
	called before the subevts loop.
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the subevts loop.
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
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	Merge the Truth JetContainers using the PileUpMergeSvc.
virtual void	resetFilter () override final
	implementation of filter reset

Private Member Functions
virtual double	processJetContainer (const xAOD::JetContainer inputJetContainer, xAOD::JetContainer outputJetContainer, const double &ptCut, const float &timeOfBCID, int eventNumber)
	JetContainer Loop.

Private Attributes
ServiceHandle< PileUpMergeSvc >	m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
Gaudi::Property< std::string >	m_inputJetCollKey {this, "InputTruthJetCollKey", "AntiKt4TruthJets", ""}
Gaudi::Property< std::string >	m_inTimeOutputJetCollKey {this, "InTimeOutputTruthJetCollKey", "InTimeAntiKt4TruthJets", ""}
Gaudi::Property< std::string >	m_outOfTimeOutputJetCollKey {this, "OutOfTimeTruthJetCollKey", "OutOfTimeAntiKt4TruthJets", ""}
Gaudi::Property< double >	m_inTimePtCut {this, "InTimePtCut", 10.0*Gaudi::Units::GeV, ""}
Gaudi::Property< double >	m_outOfTimePtCut {this, "OutOfTimePtCut", 15.0*Gaudi::Units::GeV, ""}
Gaudi::Property< bool >	m_activateFilter {this, "ActivateFilter", false, ""}
Gaudi::Property< bool >	m_includeSignalJets {this, "IncludeSignalJets", false, ""}
std::unique_ptr< xAOD::JetContainer >	m_inTimeOutputJetContainer {}
std::unique_ptr< xAOD::JetAuxContainer >	m_inTimeOutputJetAuxContainer {}
std::unique_ptr< xAOD::JetContainer >	m_outOfTimeOutputJetContainer {}
std::unique_ptr< xAOD::JetAuxContainer >	m_outOfTimeOutputJetAuxContainer {}
bool	m_first_event {true}
double	m_signal_max_pT {-1.0}
double	m_pileup_max_pT {-1.0}

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

an algorithm to merge truth jet collections in the overlay store

Definition at line 24 of file MergeTruthJetsTool.h.

Constructor & Destructor Documentation

◆ MergeTruthJetsTool()

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

Definition at line 11 of file MergeTruthJetsTool.cxx.

  : PileUpToolBase(type, name, parent)
{
}

Member Function Documentation

◆ filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

49{ return m_filterPassed; }

PileUpToolBase::m_filterPassed

bool m_filterPassed

Definition PileUpToolBase.h:60

◆ initialize()

StatusCode MergeTruthJetsTool::initialize ( )

finaloverridevirtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 18 of file MergeTruthJetsTool.cxx.

{
  ATH_MSG_DEBUG ( "Initializing " << name());
  ATH_CHECK(m_pMergeSvc.retrieve());
  return StatusCode::SUCCESS;
}

◆ mergeEvent()

StatusCode MergeTruthJetsTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

called at the end of the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 94 of file MergeTruthJetsTool.cxx.

{
  ATH_MSG_VERBOSE ( "mergeEvent" );
 
  // Veto event when m_pileup_max_pT>m_signal_max_pT
  if (m_activateFilter && m_pileup_max_pT>m_signal_max_pT) {
    ATH_MSG_INFO ( "Highest pT Jet in Hard-scatter event = " << m_signal_max_pT
                   << ", highest pT jet in a background event = " << m_pileup_max_pT
                   << ". Therefore filtering this hard-scatter event." );
    m_filterPassed = false;
  }
 
  ATH_CHECK( evtStore()->record( std::move( m_inTimeOutputJetContainer ),
                                 m_inTimeOutputJetCollKey ) );
  ATH_CHECK( evtStore()->record( std::move( m_inTimeOutputJetAuxContainer
                                            ), m_inTimeOutputJetCollKey + "Aux." ) );
 
  ATH_CHECK( evtStore()->record( std::move( m_outOfTimeOutputJetContainer
                                            ), m_outOfTimeOutputJetCollKey ) );
  ATH_CHECK( evtStore()->record( std::move(
                                           m_outOfTimeOutputJetAuxContainer ), m_outOfTimeOutputJetCollKey + "Aux."
                                 ) );
 
  return StatusCode::SUCCESS;
}

◆ prepareEvent()

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

finaloverridevirtual

called before the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 25 of file MergeTruthJetsTool.cxx.

{
  ATH_MSG_VERBOSE ( "prepareEvent()" );
  ATH_MSG_DEBUG ( "prepareEvent: there are " << nInputEvents << " subevents in this event." );
  m_first_event = true;
 
  m_inTimeOutputJetContainer = std::make_unique< xAOD::JetContainer >();
  m_inTimeOutputJetAuxContainer = std::make_unique< xAOD::JetAuxContainer >();
  m_inTimeOutputJetContainer->setStore( m_inTimeOutputJetAuxContainer.get() );
 
  m_outOfTimeOutputJetContainer = std::make_unique< xAOD::JetContainer >();
  m_outOfTimeOutputJetAuxContainer = std::make_unique< xAOD::JetAuxContainer >();
  m_outOfTimeOutputJetContainer->setStore( m_outOfTimeOutputJetAuxContainer.get() );
 
  return StatusCode::SUCCESS;
}

◆ processAllSubEvents()

StatusCode MergeTruthJetsTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

Merge the Truth JetContainers using the PileUpMergeSvc.

Reimplemented from PileUpToolBase.

Definition at line 120 of file MergeTruthJetsTool.cxx.

{
  ATH_MSG_VERBOSE ( "processAllSubEvents()" );
 
  m_first_event = true;
 
  m_inTimeOutputJetContainer = std::make_unique< xAOD::JetContainer >();
  m_inTimeOutputJetAuxContainer = std::make_unique< xAOD::JetAuxContainer >();
  m_inTimeOutputJetContainer->setStore( m_inTimeOutputJetAuxContainer.get() );
 
  m_outOfTimeOutputJetContainer = std::make_unique< xAOD::JetContainer >();
  m_outOfTimeOutputJetAuxContainer = std::make_unique< xAOD::JetAuxContainer >();
  m_outOfTimeOutputJetContainer->setStore( m_outOfTimeOutputJetAuxContainer.get() );
 
  typedef PileUpMergeSvc::TimedList<xAOD::JetContainer>::type TruthJetList;
  TruthJetList truthList;
  if ( (m_pMergeSvc->retrieveSubEvtsData(m_inputJetCollKey.value(), truthList)).isSuccess() ) {
    if (!truthList.empty()) {
      //now merge all collections into one
      TruthJetList::const_iterator jetColl_iter(truthList.begin());
      const TruthJetList::const_iterator endOfJetColls(truthList.end());
      while (jetColl_iter!=endOfJetColls) {
        const int eventNumber = (jetColl_iter)->first.index();
        //FIXME we are forced to do a deep copy
        if (static_cast<int>((jetColl_iter)->first.time())==0) {
          if (m_first_event) {
            //FIXME this may not be robust in the case that there is no TruthJet container from the signal event.
            m_signal_max_pT = this->processJetContainer(&(*((jetColl_iter)->second)), nullptr, 0.0, 0.0, eventNumber);
            if(m_includeSignalJets) {
              (void)this->processJetContainer(&(*((jetColl_iter)->second)), m_inTimeOutputJetContainer.get(), m_inTimePtCut, 0.0, eventNumber);
            }
            else {
              ATH_MSG_VERBOSE ( "Don't include signal events in output Truth Jet Containers.");
            }
            m_first_event=false;
            ++jetColl_iter;
            continue;
          }
          const double pileup_this_pT=this->processJetContainer(&(*((jetColl_iter)->second)), m_inTimeOutputJetContainer.get(), m_inTimePtCut, 0.0, eventNumber);
          ATH_MSG_VERBOSE ( "highest jet pT in the current background event = " << pileup_this_pT);
          if (pileup_this_pT>m_pileup_max_pT) m_pileup_max_pT=pileup_this_pT;
          ATH_MSG_DEBUG ( "highest in-time background jet pT so far = " << m_pileup_max_pT);
        }
        else {
          const float timeOfBCID(static_cast<float>((jetColl_iter)->first.time()));
          (void)this->processJetContainer(&(*((jetColl_iter)->second)), m_outOfTimeOutputJetContainer.get(), m_outOfTimePtCut, timeOfBCID, eventNumber);
        }
        //signal is always the first event, so if the first event
        //wasn't in-time, then the signal collection was missing and
        //we should skip further checks.
        if(m_first_event) {m_first_event=false;}
        ++jetColl_iter;
      }
    }
    else {
      ATH_MSG_DEBUG ( "processAllSubEvents: TruthJetList is empty" );
    }
  }
  else {
    ATH_MSG_ERROR ( "processAllSubEvents: Can not find TruthJetList" );
  }
  // Veto event when m_pileup_max_pT>m_signal_max_pT
  if (m_activateFilter && m_pileup_max_pT>m_signal_max_pT) {
    ATH_MSG_INFO ( "Highest pT Jet in Hard-scatter event = " << m_signal_max_pT
                   << ", highest pT jet in a background event = " << m_pileup_max_pT
                   << ". Therefore filtering this hard-scatter event." );
    m_filterPassed = false;
  }
  ATH_CHECK( evtStore()->record( std::move( m_inTimeOutputJetContainer ),
                                 m_inTimeOutputJetCollKey ) );
  ATH_CHECK( evtStore()->record( std::move( m_inTimeOutputJetAuxContainer
                                            ), m_inTimeOutputJetCollKey + "Aux." ) );
 
  ATH_CHECK( evtStore()->record( std::move( m_outOfTimeOutputJetContainer
                                            ), m_outOfTimeOutputJetCollKey ) );
  ATH_CHECK( evtStore()->record( std::move(
                                           m_outOfTimeOutputJetAuxContainer ), m_outOfTimeOutputJetCollKey + "Aux."
                                 ) );
 
  return StatusCode::SUCCESS;
}

◆ processBunchXing()

StatusCode MergeTruthJetsTool::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 42 of file MergeTruthJetsTool.cxx.

{
  ATH_MSG_VERBOSE ( "processBunchXing()" );
  SubEventIterator iEvt(bSubEvents);
  while (iEvt != eSubEvents) {
    const xAOD::JetContainer* inputJetContainer(nullptr);
    if (m_pMergeSvc->retrieveSingleSubEvtData(m_inputJetCollKey.value(), inputJetContainer,
                                              bunchXing, iEvt).isSuccess()) {
      ATH_MSG_VERBOSE("Found an xAOD::JetContainer in storeGate.");
      if ( !inputJetContainer ) {
        ATH_MSG_ERROR("Unable to retrieve input jet container: " << m_inputJetCollKey);
        return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG ( "processBunchXing: bunch Crossing = " << bunchXing << " JetContainer size = " << inputJetContainer->size());
      const int eventNumber{iEvt->index()};
      if (bunchXing==0) {
        if (m_first_event) {//FIXME this may not be robust in the case that there is no TruthJet container from the signal event.
          m_signal_max_pT = this->processJetContainer(&(*inputJetContainer), nullptr, 0.0, 0.0, eventNumber);
          ATH_MSG_DEBUG ( "Setting m_signal_max_pT = " << m_signal_max_pT);
          if(m_includeSignalJets) {
            (void)this->processJetContainer(&(*inputJetContainer), m_inTimeOutputJetContainer.get(), m_inTimePtCut, 0.0, eventNumber);
          }
          else {
            ATH_MSG_VERBOSE ( "Don't include signal events in output Truth Jet Containers.");
          }
          m_first_event=false;
          ++iEvt;
          continue;
        }
        const double pileup_this_pT=this->processJetContainer(&(*inputJetContainer), m_inTimeOutputJetContainer.get(), m_inTimePtCut, 0.0, eventNumber);
        ATH_MSG_VERBOSE ( "highest jet pT in the current background event = " << pileup_this_pT);
        if (pileup_this_pT>m_pileup_max_pT) m_pileup_max_pT=pileup_this_pT;
        ATH_MSG_DEBUG ( "highest in-time background jet pT so far = " << m_pileup_max_pT);
      }
      else {
        const float timeOfBCID(static_cast<float>(iEvt->time()));
        (void)this->processJetContainer(&(*inputJetContainer), m_outOfTimeOutputJetContainer.get(), m_outOfTimePtCut, timeOfBCID, eventNumber);
      }
    }
    else {
      ATH_MSG_DEBUG ( "processBunchXing: No JetContainers found." );
    }
    ++iEvt;
  }
  //signal is always the first event, so even if we didn't see
  //anything should set this to false here.
  if(m_first_event) {m_first_event=false;}
  return StatusCode::SUCCESS;
}

◆ processJetContainer()

double MergeTruthJetsTool::processJetContainer	(	const xAOD::JetContainer *	inputJetContainer,
		xAOD::JetContainer *	outputJetContainer,
		const double &	ptCut,
		const float &	timeOfBCID,
		int	eventNumber )

privatevirtual

JetContainer Loop.

Definition at line 203 of file MergeTruthJetsTool.cxx.

{
  const static SG::AuxElement::Accessor< float > timingAccessor("Timing");
  const static SG::AuxElement::Accessor< int > eventNumberAccessor("pileupEventNumber");
  double max_pT=-1.;
  for (const xAOD::Jet *origTruthJet : *inputJetContainer) {
    if (not origTruthJet) continue;
    try {
      if (origTruthJet->pt()<ptCut) {
        ATH_MSG_VERBOSE( "processJetContainer: Jet with pT = " << origTruthJet->pt() << " GeV failed ptCut of " << ptCut << "GeV." );
        continue;
      }
      if (max_pT<origTruthJet->pt()) max_pT=origTruthJet->pt();
      ATH_MSG_VERBOSE( "processJetContainer: Jet with pT = " << origTruthJet->pt() << " GeV passed ptCut of " << ptCut << "GeV." );
    }
    catch (...) {
      ATH_MSG_ERROR ( "Failed to find Truth jet pT for Jet in a BCID at time = " << timeOfBCID );
    }
    if (!outputJetContainer) continue;
    xAOD::Jet* outputTruthJet = new xAOD::Jet();
    outputJetContainer->push_back(outputTruthJet);
    *outputTruthJet = *origTruthJet; // deep-copy
    if (timingAccessor.isAvailable(*origTruthJet)) {
      timingAccessor(*outputTruthJet) = timeOfBCID + timingAccessor(*origTruthJet);
    } else {
      timingAccessor(*outputTruthJet) = timeOfBCID;
    }
    // add the pile-up event number
    eventNumberAccessor(*outputTruthJet) = eventNumber;
  }
  return max_pT;
}

◆ resetFilter()

virtual void MergeTruthJetsTool::resetFilter ( )

inlinefinaloverridevirtual

implementation of filter reset

Reimplemented from PileUpToolBase.

Definition at line 49 of file MergeTruthJetsTool.h.

49{ m_first_event=true; m_signal_max_pT=-1.; m_pileup_max_pT=-1.; m_filterPassed=true; }

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

Member Data Documentation

◆ m_activateFilter

Gaudi::Property<bool> MergeTruthJetsTool::m_activateFilter {this, "ActivateFilter", false, ""}

private

Definition at line 60 of file MergeTruthJetsTool.h.

60{this, "ActivateFilter", false, ""};

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

60{true};

◆ m_first_event

bool MergeTruthJetsTool::m_first_event {true}

private

Definition at line 66 of file MergeTruthJetsTool.h.

66{true};

◆ 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.

54 {this, "FirstXing", -999,

55 "First bunch-crossing in which det is live"};

◆ m_includeSignalJets

Gaudi::Property<bool> MergeTruthJetsTool::m_includeSignalJets {this, "IncludeSignalJets", false, ""}

private

Definition at line 61 of file MergeTruthJetsTool.h.

61{this, "IncludeSignalJets", false, ""};

◆ m_inputJetCollKey

Gaudi::Property<std::string> MergeTruthJetsTool::m_inputJetCollKey {this, "InputTruthJetCollKey", "AntiKt4TruthJets", ""}

private

Definition at line 55 of file MergeTruthJetsTool.h.

55{this, "InputTruthJetCollKey", "AntiKt4TruthJets", ""};

◆ m_inTimeOutputJetAuxContainer

std::unique_ptr< xAOD::JetAuxContainer > MergeTruthJetsTool::m_inTimeOutputJetAuxContainer {}

private

Definition at line 63 of file MergeTruthJetsTool.h.

63{};

◆ m_inTimeOutputJetCollKey

Gaudi::Property<std::string> MergeTruthJetsTool::m_inTimeOutputJetCollKey {this, "InTimeOutputTruthJetCollKey", "InTimeAntiKt4TruthJets", ""}

private

Definition at line 56 of file MergeTruthJetsTool.h.

56{this, "InTimeOutputTruthJetCollKey", "InTimeAntiKt4TruthJets", ""};

◆ m_inTimeOutputJetContainer

std::unique_ptr< xAOD::JetContainer > MergeTruthJetsTool::m_inTimeOutputJetContainer {}

private

Definition at line 62 of file MergeTruthJetsTool.h.

62{};

◆ m_inTimePtCut

Gaudi::Property<double> MergeTruthJetsTool::m_inTimePtCut {this, "InTimePtCut", 10.0*Gaudi::Units::GeV, ""}

private

Definition at line 58 of file MergeTruthJetsTool.h.

58{this, "InTimePtCut", 10.0*Gaudi::Units::GeV, ""};

◆ 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.

56 {this, "LastXing", 999,

57 "Last bunch-crossing in which det is live"};

◆ m_outOfTimeOutputJetAuxContainer

std::unique_ptr< xAOD::JetAuxContainer > MergeTruthJetsTool::m_outOfTimeOutputJetAuxContainer {}

private

Definition at line 65 of file MergeTruthJetsTool.h.

65{};

◆ m_outOfTimeOutputJetCollKey

Gaudi::Property<std::string> MergeTruthJetsTool::m_outOfTimeOutputJetCollKey {this, "OutOfTimeTruthJetCollKey", "OutOfTimeAntiKt4TruthJets", ""}

private

Definition at line 57 of file MergeTruthJetsTool.h.

57{this, "OutOfTimeTruthJetCollKey", "OutOfTimeAntiKt4TruthJets", ""};

◆ m_outOfTimeOutputJetContainer

std::unique_ptr< xAOD::JetContainer > MergeTruthJetsTool::m_outOfTimeOutputJetContainer {}

private

Definition at line 64 of file MergeTruthJetsTool.h.

64{};

◆ m_outOfTimePtCut

Gaudi::Property<double> MergeTruthJetsTool::m_outOfTimePtCut {this, "OutOfTimePtCut", 15.0*Gaudi::Units::GeV, ""}

private

Definition at line 59 of file MergeTruthJetsTool.h.

59{this, "OutOfTimePtCut", 15.0*Gaudi::Units::GeV, ""};

◆ m_pileup_max_pT

double MergeTruthJetsTool::m_pileup_max_pT {-1.0}

private

Definition at line 68 of file MergeTruthJetsTool.h.

68{-1.0};

◆ m_pMergeSvc

ServiceHandle<PileUpMergeSvc> MergeTruthJetsTool::m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

private

Definition at line 54 of file MergeTruthJetsTool.h.

54{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};

◆ m_signal_max_pT

double MergeTruthJetsTool::m_signal_max_pT {-1.0}

private

Definition at line 67 of file MergeTruthJetsTool.h.

67{-1.0};

◆ 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.

58 {this, "VetoPileUpTruthLinks", true,

59 "Ignore links to suppressed pile-up truth"};

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

Public Member Functions

Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Constructor & Destructor Documentation

◆ MergeTruthJetsTool()

Member Function Documentation

◆ filterPassed()

◆ initialize()

◆ mergeEvent()

◆ prepareEvent()

◆ processAllSubEvents()

◆ processBunchXing()

◆ processJetContainer()

◆ resetFilter()

◆ toProcess()

Member Data Documentation

◆ m_activateFilter

◆ m_filterPassed

◆ m_first_event

◆ m_firstXing

◆ m_includeSignalJets

◆ m_inputJetCollKey

◆ m_inTimeOutputJetAuxContainer

◆ m_inTimeOutputJetCollKey

◆ m_inTimeOutputJetContainer

◆ m_inTimePtCut

◆ m_lastXing

◆ m_outOfTimeOutputJetAuxContainer

◆ m_outOfTimeOutputJetCollKey

◆ m_outOfTimeOutputJetContainer

◆ m_outOfTimePtCut

◆ m_pileup_max_pT

◆ m_pMergeSvc

◆ m_signal_max_pT

◆ m_vetoPileUpTruthLinks