PileUpMTAlg Class Reference

#include <PileUpMTAlg.h>

Inheritance diagram for PileUpMTAlg:

Public Member Functions
	PileUpMTAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~PileUpMTAlg ()
virtual StatusCode	initialize () override
	uncomment and implement methods as required
virtual StatusCode	execute (const EventContext &ctx) override
	Execute method.
virtual StatusCode	finalize () override
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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

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
StatusCode	get_ei (StoreGateSvc &sg, std::unique_ptr< const xAOD::EventInfo > &ei, std::unique_ptr< xAOD::EventAuxInfo > &eiAux, bool pileup=false) const
unsigned int	get_BCID (int bc, unsigned int central_BCID) const
StatusCode	add_subevt (const std::vector< std::uint32_t > &bcid, SG::WriteHandle< xAOD::EventInfo > &overlaidEvt, SG::WriteHandle< xAOD::EventInfoContainer > &puCont, ServiceHandle< IMinbiasSvc > &mbSvc, xAOD::EventInfo::PileUpType puType, int bc, const EventContext &ctx, unsigned long subevt_id, std::vector< std::uint64_t > &trace)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IMinbiasSvc >	m_lowptMBSvc
	Other useful methods provided by base class are: evtStore() : ServiceHandle to main event data storegate inputMetaStore() : ServiceHandle to input metadata storegate outputMetaStore() : ServiceHandle to output metadata storegate histSvc() : ServiceHandle to output ROOT service (writing TObjects) currentFile() : TFile* to the currently open input file retrieveMetadata(...): See twiki.cern.ch/twiki/bin/view/AtlasProtected/AthAnalysisBase#ReadingMetaDataInCpp.
ServiceHandle< IMinbiasSvc >	m_highptMBSvc
ServiceHandle< IMinbiasSvc >	m_cavernMBSvc
ServiceHandle< IMinbiasSvc >	m_beamhaloMBSvc
ServiceHandle< IMinbiasSvc >	m_beamgasMBSvc
ServiceHandle< IBeamIntensity >	m_beamInt
ServiceHandle< IBeamLuminosity >	m_beamLumi
ServiceHandle< IAthRNGSvc >	m_rngSvc
ToolHandleArray< IPileUpTool >	m_puTools
Gaudi::Property< bool >	m_writeTrace {this, "WriteTrace", false, "Write trace of pileup events used"}
Gaudi::Property< int >	m_skippedHSEvents
Gaudi::Property< float >	m_avgMu {this, "AverageMu", 200, "Average mu"}
Gaudi::Property< float >	m_fracLowPt
Gaudi::Property< float >	m_fracHighPt
Gaudi::Property< float >	m_numCavern
Gaudi::Property< float >	m_numBeamGas
Gaudi::Property< float >	m_numBeamHalo
Gaudi::Property< int >	m_BCSpacing
Gaudi::Property< int >	m_earliestDeltaBC
Gaudi::Property< int >	m_latestDeltaBC
ServiceHandle< ISkipEventIdxSvc >	m_skipEventIdxSvc
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey
SG::WriteHandleKey< xAOD::EventInfo >	m_evtInfoKey
SG::WriteHandleKey< xAOD::EventInfoContainer >	m_evtInfoContKey {""}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Static Private Attributes
static atomic_output m_pileupTrace	ATLAS_THREAD_SAFE {}
static bool m_skiptrace_written	ATLAS_THREAD_SAFE = false

Detailed Description

Definition at line 74 of file PileUpMTAlg.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

PileUpMTAlg()

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

Definition at line 40 of file PileUpMTAlg.cxx.

    : AthAlgorithm(name, pSvcLocator) {}

~PileUpMTAlg()

PileUpMTAlg::~PileUpMTAlg ( )

virtual

Definition at line 43 of file PileUpMTAlg.cxx.

{}

Member Function Documentation

add_subevt()

StatusCode PileUpMTAlg::add_subevt ( const std::vector< std::uint32_t > & bcid, SG::WriteHandle< xAOD::EventInfo > & overlaidEvt, SG::WriteHandle< xAOD::EventInfoContainer > & puCont, ServiceHandle< IMinbiasSvc > & mbSvc, xAOD::EventInfo::PileUpType puType, int bc, const EventContext & ctx, unsigned long subevt_id, std::vector< std::uint64_t > & trace )

private

Definition at line 89 of file PileUpMTAlg.cxx.

                                   {
  // Keep the code to add and process a subevent in one place
  const unsigned int bc_idx = bc - m_earliestDeltaBC;
  StoreGateSvc* sg = mbSvc->getMinbias(ctx, subevt_id);
  std::unique_ptr<const xAOD::EventInfo> ei;
  std::unique_ptr<xAOD::EventAuxInfo> eiAux;
  ATH_CHECK(get_ei(*sg, ei, eiAux, true));
  xAOD::EventInfo mb_to_modify(*ei);
  if (m_writeTrace) {
    trace.push_back(mb_to_modify.eventNumber());
  }
  mb_to_modify.setBCID(bcid[bc_idx]);
  try {
    addSubEvent(overlaidEvt.ptr(), &mb_to_modify, bc * m_BCSpacing, puType,
                puCont.ptr(), m_evtInfoContKey.key(), sg);
  } catch (const std::exception& e) {
    ATH_MSG_ERROR("Caught exception adding subevent: " << e.what());
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

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

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 PileUpMTAlg::execute ( const EventContext & ctx )

overridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 185 of file PileUpMTAlg.cxx.

                                                       {
  using PUType = xAOD::EventInfo::PileUpType;
  std::string trace_buf{};  // Hold trace of events.
  auto trace = std::back_inserter(trace_buf);
  ATH_MSG_DEBUG("Executing " << name() << "...");
  const auto& evtID = ctx.eventID();
 
  ATH_CHECK(evtStore().retrieve());
  setFilterPassed(false, ctx);  // optional: start with algorithm not passed
 
  // Code based on PileUpEventLoopMgr and PileUpToolsAlg (trying to extract the
  // core merging code) Read hard scatter
  std::unique_ptr<const xAOD::EventInfo> hsEvt = nullptr;
  std::unique_ptr<xAOD::EventAuxInfo> hsEvtAux = nullptr;
  ATH_CHECK(get_ei(*evtStore(), hsEvt, hsEvtAux));
 
  // Setup overlaid event
  SG::WriteHandle<xAOD::EventInfo> overlaidEvt(m_evtInfoKey, ctx);
  ATH_CHECK(overlaidEvt.record(std::make_unique<xAOD::EventInfo>(),
                               std::make_unique<xAOD::EventAuxInfo>()));
  *overlaidEvt = *hsEvt;  // copy in hard scatter
  overlaidEvt->setEvtStore(evtStore().get());
  overlaidEvt->clearSubEvents();
 
  // This was the problem. Need to fix overlaidEvt using context run and lb
  // number
  overlaidEvt->setRunNumber(evtID.run_number());
  overlaidEvt->setLumiBlock(evtID.lumi_block());
  overlaidEvt->setEventNumber(evtID.event_number());
  overlaidEvt->setBCID(evtID.bunch_crossing_id());
  overlaidEvt->setTimeStamp(evtID.time_stamp());
  overlaidEvt->setTimeStampNSOffset(evtID.time_stamp_ns_offset());
  // Set beam spot info
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
  if (!beamSpotHandle.isValid()) {
    ATH_MSG_ERROR("Beam spot information not valid");
    return StatusCode::FAILURE;
  }
 
  overlaidEvt->setBeamPos(beamSpotHandle->beamPos()[Amg::x],
                          beamSpotHandle->beamPos()[Amg::y],
                          beamSpotHandle->beamPos()[Amg::z]);
  overlaidEvt->setBeamPosSigma(beamSpotHandle->beamSigma(0),
                               beamSpotHandle->beamSigma(1),
                               beamSpotHandle->beamSigma(2));
  overlaidEvt->setBeamPosSigmaXY(beamSpotHandle->beamSigmaXY());
  overlaidEvt->setBeamTiltXZ(beamSpotHandle->beamTilt(0));
  overlaidEvt->setBeamTiltYZ(beamSpotHandle->beamTilt(1));
  overlaidEvt->setBeamStatus(beamSpotHandle->beamStatus());
 
  // Pileup container
  SG::WriteHandle<xAOD::EventInfoContainer> puCont(m_evtInfoContKey, ctx);
  ATH_CHECK(puCont.record(std::make_unique<xAOD::EventInfoContainer>(),
                          std::make_unique<xAOD::EventInfoAuxContainer>()));
 
  // Get crossing number
  m_beamInt->selectT0(ctx);
  overlaidEvt->setBCID(m_beamInt->getCurrentT0BunchCrossing());
 
  // Set simulation bit
  overlaidEvt->setEventTypeBitmask(hsEvt->eventTypeBitmask() |
                                   xAOD::EventInfo::IS_SIMULATION);
 
  // Set properties
  bool sf_updated = false;
  float lumi_sf = m_beamLumi->scaleFactor(evtID.run_number(),
                                          evtID.lumi_block(), sf_updated);
  float cur_avg_mu = lumi_sf * m_avgMu;
  overlaidEvt->setAverageInteractionsPerCrossing(cur_avg_mu);
  overlaidEvt->setActualInteractionsPerCrossing(m_beamInt->normFactor(0) *
                                                cur_avg_mu);
 
  // Trace
  if (m_writeTrace) {
    std::format_to(trace,
                   "Idx: {} Run: {} LB: {} EVT: {} "
                   "HS ID: {}\n",
                   ctx.evt(), evtID.run_number(), evtID.lumi_block(),
                   evtID.event_number(), m_lowptMBSvc->get_hs_id(ctx));
    auto bunch_pattern =
        rv::closed_iota(m_earliestDeltaBC.value(), m_latestDeltaBC.value()) |
        rv::transform(
            [this](int bc) { return int(m_beamInt->normFactor(bc)); }) |
#if RANGE_V3_VERSION >= 1200
        rv::chunk_by(std::equal_to{}) |
#else
        rv::group_by(std::equal_to{}) |
#endif
        rv::transform([](const auto& rng) {
          return std::format("{}{}", rng.size(), rng[0] == 0 ? 'E' : 'F');
        }) |
        ranges::to<std::vector<std::string>>;
    // Manual join using std::ostringstream as std::format does not support ranges
    std::string joined_pattern;
    for (size_t i = 0; i < bunch_pattern.size(); ++i) {
      joined_pattern += bunch_pattern[i];
      if (i + 1 < bunch_pattern.size()) {
        joined_pattern += " ";
      }
    }
 
    std::format_to(trace,
                   "mu = {}, central BCID = {}, bunch pattern = [{}]\n",
                   cur_avg_mu, m_beamInt->getCurrentT0BunchCrossing(),
                   joined_pattern);
  }
  // Copy subevents
  if (!hsEvt->subEvents().empty()) {
    for (const SubEvent& se : hsEvt->subEvents()) {
      addSubEvent(overlaidEvt.ptr(), se, puCont.ptr(), m_evtInfoContKey.key(),
                  evtStore().get());
    }
  } else {
    // if no subevents, add original event
    addSubEvent(overlaidEvt.ptr(), hsEvt.get(), 0, xAOD::EventInfo::Signal,
                puCont.ptr(), m_evtInfoContKey.key(), evtStore().get());
  }
 
  // Initialize MinbiasSvcs
  if (m_fracLowPt != 0) {
    ATH_CHECK(m_lowptMBSvc->beginHardScatter(ctx));
  }
  if (m_fracHighPt != 0) {
    ATH_CHECK(m_highptMBSvc->beginHardScatter(ctx));
  }
  if (m_numCavern != 0) {
    ATH_CHECK(m_cavernMBSvc->beginHardScatter(ctx));
  }
  if (m_numBeamHalo != 0) {
    ATH_CHECK(m_beamhaloMBSvc->beginHardScatter(ctx));
  }
  if (m_numBeamGas != 0) {
    ATH_CHECK(m_beamgasMBSvc->beginHardScatter(ctx));
  }
 
  std::uint32_t central_bcid = overlaidEvt->bcid();
  std::vector<std::uint32_t> bcid{};
  bcid.reserve(m_latestDeltaBC - m_earliestDeltaBC + 1);
 
  for (int bc = m_earliestDeltaBC; bc <= m_latestDeltaBC; ++bc) {
    bcid.push_back(get_BCID(bc, central_bcid));
  }
 
  // Setup tools
  for (auto&& tool : m_puTools) {
    // Reset filter -- Don't know if this is necessary
    tool->resetFilter();
  }
 
  // Now add the events
  std::uint64_t low_pt_count = 0;
  std::uint64_t high_pt_count = 0;
  std::uint64_t cavern_count = 0;
  std::uint64_t beam_halo_count = 0;
  std::uint64_t beam_gas_count = 0;
  auto now = std::chrono::high_resolution_clock::now();
  for (int bc = m_earliestDeltaBC; bc <= m_latestDeltaBC; ++bc) {
    if (m_beamInt->normFactor(bc) == 0.) {
      // skip empty bunch crossings
      continue;
    }
    std::vector<std::uint64_t> subevts_vec{};
    if (m_fracLowPt != 0) {
      if (m_writeTrace) {
        std::format_to(trace, "\tBC {:03} : LOW PT {} ", bc,
                       m_lowptMBSvc->getNumForBunch(ctx, bc));
      }
      for (std::size_t i = 0; i < m_lowptMBSvc->getNumForBunch(ctx, bc); ++i) {
        ATH_CHECK(add_subevt(bcid, overlaidEvt, puCont, m_lowptMBSvc,
                             PUType::MinimumBias, bc, ctx, low_pt_count,
                             subevts_vec));
        ++low_pt_count;
      }
    }
    if (m_fracHighPt != 0) {
      if (m_writeTrace) {
        std::format_to(trace, "HIGH PT {} | ",
                       m_highptMBSvc->getNumForBunch(ctx, bc));
      }
      for (std::size_t i = 0; i < m_highptMBSvc->getNumForBunch(ctx, bc); ++i) {
        ATH_CHECK(add_subevt(bcid, overlaidEvt, puCont, m_highptMBSvc,
                             PUType::HighPtMinimumBias, bc, ctx, high_pt_count,
                             subevts_vec));
        ++high_pt_count;
      }
    }
    if (m_numCavern != 0) {
      if (m_writeTrace) {
        std::format_to(trace, "CAVERN {} | ",
                       m_cavernMBSvc->getNumForBunch(ctx, bc));
      }
      for (std::size_t i = 0; i < m_cavernMBSvc->getNumForBunch(ctx, bc); ++i) {
        ATH_CHECK(add_subevt(bcid, overlaidEvt, puCont, m_cavernMBSvc,
                             PUType::Cavern, bc, ctx, cavern_count,
                             subevts_vec));
        ++cavern_count;
      }
    }
    if (m_numBeamHalo != 0) {
      if (m_writeTrace) {
        std::format_to(trace, "BEAM HALO {} | ",
                       m_beamhaloMBSvc->getNumForBunch(ctx, bc));
      }
      for (std::size_t i = 0; i < m_beamhaloMBSvc->getNumForBunch(ctx, bc);
           ++i) {
        ATH_CHECK(add_subevt(bcid, overlaidEvt, puCont, m_beamhaloMBSvc,
                             PUType::HaloGas, bc, ctx, beam_halo_count,
                             subevts_vec));
        ++beam_halo_count;
      }
    }
    if (m_numBeamGas != 0) {
      if (m_writeTrace) {
        std::format_to(trace, "BEAM GAS {} | ",
                       m_beamgasMBSvc->getNumForBunch(ctx, bc));
      }
      for (std::size_t i = 0; i < m_beamgasMBSvc->getNumForBunch(ctx, bc);
           ++i) {
        ATH_CHECK(add_subevt(bcid, overlaidEvt, puCont, m_beamgasMBSvc,
                             PUType::HaloGas, bc, ctx, beam_gas_count,
                             subevts_vec));
        ++beam_gas_count;
      }
    }
    if (m_writeTrace) {
      std::format_to(trace, "TOTAL {} | HASH {:08X}\n", subevts_vec.size(),
                     xxh3::hash64(subevts_vec));
    }
  }
  if (m_writeTrace) {
    std::format_to(trace, "\n");
    m_pileupTrace.print(trace_buf);
  }
 
  for (auto&& tool : m_puTools) {
    try {
      ATH_CHECK(tool->processAllSubEvents(ctx));
    } catch (const std::exception& e) {
      ATH_MSG_ERROR("Caught exception running " << tool.name() << ": "
                                                << e.what());
      return StatusCode::FAILURE;
    }
    // Propagate filter result
    if (!tool->filterPassed()) {
      setFilterPassed(false, ctx);
    }
  }
  ATH_MSG_DEBUG(std::format("***** Took {:%OMm %OSs} to process all subevents",
                            std::chrono::high_resolution_clock::now() - now));
  //
  // Save hash (direct copy from PileUpEventLoopMgr)
  PileUpHashHelper pileUpHashHelper;
  pileUpHashHelper.addToHashSource(overlaidEvt.cptr());
  ATH_MSG_VERBOSE("Pile-up hash source:" << pileUpHashHelper.hashSource());
 
  // Calculate and set hash
  uuid_t pileUpHash;
  pileUpHashHelper.calculateHash(pileUpHash);
  overlaidEvt->setPileUpMixtureID(
      PileUpHashHelper::uuidToPileUpMixtureId(pileUpHash));
  ATH_MSG_DEBUG("PileUpMixtureID = " << overlaidEvt->pileUpMixtureID());
 
  setFilterPassed(true, ctx);  // if got here, assume that means algorithm passed
  if (m_fracLowPt != 0) {
    ATH_CHECK(m_lowptMBSvc->endHardScatter(ctx));
  }
  if (m_fracHighPt != 0) {
    ATH_CHECK(m_highptMBSvc->endHardScatter(ctx));
  }
  if (m_numCavern != 0) {
    ATH_CHECK(m_cavernMBSvc->endHardScatter(ctx));
  }
  if (m_numBeamHalo != 0) {
    ATH_CHECK(m_beamhaloMBSvc->endHardScatter(ctx));
  }
  if (m_numBeamGas != 0) {
    ATH_CHECK(m_beamgasMBSvc->endHardScatter(ctx));
  }
  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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

finalize()

StatusCode PileUpMTAlg::finalize ( )

overridevirtual

Definition at line 176 of file PileUpMTAlg.cxx.

                                 {
  ATH_MSG_DEBUG("Finalizing " << name() << "...");
  //
  // Things that happen once at the end of the event loop go here
  //
 
  return StatusCode::SUCCESS;
}

get_BCID()

unsigned int PileUpMTAlg::get_BCID ( int bc, unsigned int central_BCID ) const

inlineprivate

Definition at line 153 of file PileUpMTAlg.h.

                                                                        {
    constexpr int maxBCPerOrbit = 3564;  // FIXME may need update
    return static_cast<unsigned int>((bc + static_cast<int>(central_BCID)) %
                                     maxBCPerOrbit);
  }

get_ei()

StatusCode PileUpMTAlg::get_ei ( StoreGateSvc & sg, std::unique_ptr< const xAOD::EventInfo > & ei, std::unique_ptr< xAOD::EventAuxInfo > & eiAux, bool pileup = false ) const

private

Definition at line 45 of file PileUpMTAlg.cxx.

                                                  {
  std::string key = pileup ? "EventInfo" : "HSEventInfo";
  auto newEi = std::make_unique<xAOD::EventInfo>();
  auto eiAux = std::make_unique<xAOD::EventAuxInfo>();
  newEi->setStore(eiAux.get());
  SG::ReadHandle<xAOD::EventInfo> ei_h(key, sg.name());
  const xAOD::EventInfo* ei = ei_h.get();
  if (ei != nullptr) {
    *newEi = *ei;
  } else {
    ATH_MSG_ERROR("Couldn't find xAOD::EventInfo. " << sg.name());
    ATH_MSG_ERROR(sg.dump());
    return StatusCode::FAILURE;
  }
  // Use attribute list if EventInfo doesn't have event numbers set
  if (newEi->eventNumber() == 0) {
    const auto* attr_list_p = sg.tryConstRetrieve<AthenaAttributeList>("Input");
    if (attr_list_p != nullptr) {
      if (attr_list_p->size() <= 6) {
        ATH_MSG_WARNING("Read Input attribute list but size <= 6");
      } else {
        const AthenaAttributeList& attr_list = *attr_list_p;
        const auto runNum = attr_list["RunNumber"].data<unsigned>();
        const auto evtNum = attr_list["EventNumber"].data<unsigned long long>();
        const auto lbNum = attr_list["LumiBlockN"].data<unsigned>();
        newEi->setRunNumber(runNum);
        newEi->setLumiBlock(lbNum);
        newEi->setEventNumber(evtNum);
      }
    } else {
      ATH_MSG_WARNING(
          "Could not read Input attribute list and EventInfo has no event "
          "number");
    }
  }
  newEi->setEvtStore(&sg);
  ei_ = std::move(newEi);
  ei_aux_ = std::move(eiAux);
  return StatusCode::SUCCESS;
}

initialize()

StatusCode PileUpMTAlg::initialize ( )

overridevirtual

uncomment and implement methods as required

Definition at line 117 of file PileUpMTAlg.cxx.

                                   {
  using namespace std::chrono;
  ATH_MSG_DEBUG("Initializing " << name() << "...");
  if (m_writeTrace) {
    std::string filename = std::format("pileup_trace_skipping-{}_{:%Y-%m-%dT%H%M}.txt",
                                       m_skippedHSEvents.value(),
                                       system_clock::now());
    if (!m_pileupTrace.init(filename)) {
      ATH_MSG_ERROR("Cannot append to file " << filename);
      return StatusCode::FAILURE;
    }
  }
  ATH_CHECK(m_skipEventIdxSvc.retrieve());
  ATH_CHECK(m_rngSvc.retrieve());
  if (m_fracLowPt != 0) {
    ATH_CHECK(m_lowptMBSvc.retrieve());
  }
  if (m_fracHighPt != 0) {
    ATH_CHECK(m_highptMBSvc.retrieve());
  }
  if (m_numCavern != 0) {
    ATH_CHECK(m_cavernMBSvc.retrieve());
  }
  if (m_numBeamGas != 0) {
    ATH_CHECK(m_beamgasMBSvc.retrieve());
  }
  if (m_numBeamHalo != 0) {
    ATH_CHECK(m_beamhaloMBSvc.retrieve());
  }
  ATH_CHECK(m_beamInt.retrieve());
  ATH_CHECK(m_beamLumi.retrieve());
  ATH_CHECK(m_puTools.retrieve());
 
  m_evtInfoContKey = "PileUpEventInfo";
  ATH_CHECK(m_evtInfoKey.initialize());
  ATH_CHECK(m_evtInfoContKey.initialize());
  ATH_CHECK(m_beamSpotKey.initialize());
 
  // Trace skipped events
  if (m_writeTrace) {
    auto handler = [](ISkipEventIdxSvc::EvtIter it,
                      ISkipEventIdxSvc::EvtIter end) -> StatusCode {
      std::string trace_buf{};
      auto trace = std::back_inserter(trace_buf);
      for (; it != end; ++it) {
        std::format_to(trace, "SKIPPING Run: {} LB: {} EVT: {} HS ID: {}\n",
                       it->runNum, it->lbNum, it->evtNum, it->evtIdx);
      }
      m_pileupTrace.print(trace_buf);
      return StatusCode::SUCCESS;
    };
    if (!m_skiptrace_written) {
      ATH_CHECK(m_skipEventIdxSvc->registerCallback(handler));
      m_skiptrace_written = true;
    }
  }
  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.

isClonable()

virtual bool PileUpMTAlg::isClonable ( ) const

inlineoverridevirtual

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented from AthCommonAlgorithm< Gaudi::Algorithm >.

Definition at line 87 of file PileUpMTAlg.h.

{ return true; }

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

{ return false; }

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.

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

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

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

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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.

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

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

bool m_skiptrace_written PileUpMTAlg::ATLAS_THREAD_SAFE = false

inlinestaticprivate

Definition at line 166 of file PileUpMTAlg.h.

ATLAS_THREAD_SAFE [2/2]

atomic_output m_pileupTrace PileUpMTAlg::ATLAS_THREAD_SAFE {}

inlinestaticprivate

Definition at line 165 of file PileUpMTAlg.h.

{};

m_avgMu

Gaudi::Property<float> PileUpMTAlg::m_avgMu {this, "AverageMu", 200, "Average mu"}

private

Definition at line 121 of file PileUpMTAlg.h.

{this, "AverageMu", 200, "Average mu"};

m_BCSpacing

Gaudi::Property<int> PileUpMTAlg::m_BCSpacing

private

Initial value:

{this, "BCSpacing", 25,
                                   "Bunch crossing spacing in ns"}

Definition at line 132 of file PileUpMTAlg.h.

                                {this, "BCSpacing", 25,
                                   "Bunch crossing spacing in ns"};

m_beamgasMBSvc

ServiceHandle<IMinbiasSvc> PileUpMTAlg::m_beamgasMBSvc

private

Initial value:

{
      this, "BeamGasMinbiasSvc", "", "MinbiasSvc for beam gas background"}

Definition at line 108 of file PileUpMTAlg.h.

                                           {
      this, "BeamGasMinbiasSvc", "", "MinbiasSvc for beam gas background"};

m_beamhaloMBSvc

ServiceHandle<IMinbiasSvc> PileUpMTAlg::m_beamhaloMBSvc

private

Initial value:

{
      this, "BeamHaloMinbiasSvc", "", "MinbiasSvc for beam halo background"}

Definition at line 106 of file PileUpMTAlg.h.

                                            {
      this, "BeamHaloMinbiasSvc", "", "MinbiasSvc for beam halo background"};

m_beamInt

ServiceHandle<IBeamIntensity> PileUpMTAlg::m_beamInt

private

Initial value:

{this, "BeamIntSvc", "FlatBM",
                                          "Beam intensity service"}

Definition at line 110 of file PileUpMTAlg.h.

                                         {this, "BeamIntSvc", "FlatBM",
                                          "Beam intensity service"};

m_beamLumi

ServiceHandle<IBeamLuminosity> PileUpMTAlg::m_beamLumi

private

Initial value:

{
      this, "BeamLumiSvc", "LumiProfileSvc", "Beam luminosity service"}

Definition at line 112 of file PileUpMTAlg.h.

                                           {
      this, "BeamLumiSvc", "LumiProfileSvc", "Beam luminosity service"};

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> PileUpMTAlg::m_beamSpotKey

private

Initial value:

{
      this, "BeamSpotKey", "BeamSpotData", "Beam spot info key"}

Definition at line 143 of file PileUpMTAlg.h.

                                                      {
      this, "BeamSpotKey", "BeamSpotData", "Beam spot info key"};

m_cavernMBSvc

ServiceHandle<IMinbiasSvc> PileUpMTAlg::m_cavernMBSvc

private

Initial value:

{this, "CavernMinbiasSvc", "",
                                           "MinbiasSvc for cavern background"}

Definition at line 104 of file PileUpMTAlg.h.

                                          {this, "CavernMinbiasSvc", "",
                                           "MinbiasSvc for cavern background"};

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_earliestDeltaBC

Gaudi::Property<int> PileUpMTAlg::m_earliestDeltaBC

private

Initial value:

{
      this, "EarliestDeltaBC", -32,
      "Earliest bunch crossing to consider (as delta)"}

Definition at line 134 of file PileUpMTAlg.h.

                                      {
      this, "EarliestDeltaBC", -32,
      "Earliest bunch crossing to consider (as delta)"};

m_evtInfoContKey

SG::WriteHandleKey<xAOD::EventInfoContainer> PileUpMTAlg::m_evtInfoContKey {""}

private

Definition at line 147 of file PileUpMTAlg.h.

{""};

m_evtInfoKey

SG::WriteHandleKey<xAOD::EventInfo> PileUpMTAlg::m_evtInfoKey

private

Initial value:

{
      this, "EventInfoKey", "OverlayEvent", "Overlay EventInfo key"}

Definition at line 145 of file PileUpMTAlg.h.

                                              {
      this, "EventInfoKey", "OverlayEvent", "Overlay EventInfo key"};

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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_fracHighPt

Gaudi::Property<float> PileUpMTAlg::m_fracHighPt

private

Initial value:

{this, "FracHighPt", 0.,
                                      "Fraction of pileup that has high pT"}

Definition at line 124 of file PileUpMTAlg.h.

                                   {this, "FracHighPt", 0.,
                                      "Fraction of pileup that has high pT"};

m_fracLowPt

Gaudi::Property<float> PileUpMTAlg::m_fracLowPt

private

Initial value:

{this, "FracLowPt", 0.,
                                     "Fraction of pileup that has low pT"}

Definition at line 122 of file PileUpMTAlg.h.

                                  {this, "FracLowPt", 0.,
                                     "Fraction of pileup that has low pT"};

m_highptMBSvc

ServiceHandle<IMinbiasSvc> PileUpMTAlg::m_highptMBSvc

private

Initial value:

{this, "HighPtMinbiasSvc", "",
                                           "MinbiasSvc for high pT minbias"}

Definition at line 102 of file PileUpMTAlg.h.

                                          {this, "HighPtMinbiasSvc", "",
                                           "MinbiasSvc for high pT minbias"};

m_latestDeltaBC

Gaudi::Property<int> PileUpMTAlg::m_latestDeltaBC

private

Initial value:

{
      this, "LatestDeltaBC", +6,
      "Latest bunch crossing to consider (as delta)"}

Definition at line 137 of file PileUpMTAlg.h.

                                    {
      this, "LatestDeltaBC", +6,
      "Latest bunch crossing to consider (as delta)"};

m_lowptMBSvc

ServiceHandle<IMinbiasSvc> PileUpMTAlg::m_lowptMBSvc

private

Initial value:

{this, "LowPtMinbiasSvc", "",
                                          "MinbiasSvc for low pT minbias"}

Other useful methods provided by base class are: evtStore() : ServiceHandle to main event data storegate inputMetaStore() : ServiceHandle to input metadata storegate outputMetaStore() : ServiceHandle to output metadata storegate histSvc() : ServiceHandle to output ROOT service (writing TObjects) currentFile() : TFile* to the currently open input file retrieveMetadata(...): See twiki.cern.ch/twiki/bin/view/AtlasProtected/AthAnalysisBase#ReadingMetaDataInCpp.

Definition at line 100 of file PileUpMTAlg.h.

                                         {this, "LowPtMinbiasSvc", "",
                                          "MinbiasSvc for low pT minbias"};

m_numBeamGas

Gaudi::Property<float> PileUpMTAlg::m_numBeamGas

private

Initial value:

{
      this, "NumBeamGas", 0., "Number of beam gas background events per BC"}

Definition at line 128 of file PileUpMTAlg.h.

                                   {
      this, "NumBeamGas", 0., "Number of beam gas background events per BC"};

m_numBeamHalo

Gaudi::Property<float> PileUpMTAlg::m_numBeamHalo

private

Initial value:

{
      this, "NumBeamHalo", 0., "Number of beam halo background events per BC"}

Definition at line 130 of file PileUpMTAlg.h.

                                    {
      this, "NumBeamHalo", 0., "Number of beam halo background events per BC"};

m_numCavern

Gaudi::Property<float> PileUpMTAlg::m_numCavern

private

Initial value:

{
      this, "NumCavern", 0., "Number of cavern background events per BC"}

Definition at line 126 of file PileUpMTAlg.h.

                                  {
      this, "NumCavern", 0., "Number of cavern background events per BC"};

m_puTools

ToolHandleArray<IPileUpTool> PileUpMTAlg::m_puTools

private

Initial value:

{
      this, "PileUpTools", {}, "Pileup tools"}

Definition at line 116 of file PileUpMTAlg.h.

                                        {
      this, "PileUpTools", {}, "Pileup tools"};

m_rngSvc

ServiceHandle<IAthRNGSvc> PileUpMTAlg::m_rngSvc

private

Initial value:

{this, "RNGSvc", "AthRNGSvc/PileupRNG",
                                     "RNG service for pile-up digitization"}

Definition at line 114 of file PileUpMTAlg.h.

                                    {this, "RNGSvc", "AthRNGSvc/PileupRNG",
                                     "RNG service for pile-up digitization"};

m_skipEventIdxSvc

ServiceHandle<ISkipEventIdxSvc> PileUpMTAlg::m_skipEventIdxSvc

private

Initial value:

{
      this, "SkipEvtIdxSvc", "SkipEventIdxSvc",
      "Skipped event index (run / lb num) provider"}

Definition at line 140 of file PileUpMTAlg.h.

                                                   {
      this, "SkipEvtIdxSvc", "SkipEventIdxSvc",
      "Skipped event index (run / lb num) provider"};

m_skippedHSEvents

Gaudi::Property<int> PileUpMTAlg::m_skippedHSEvents

private

Initial value:

{this, "SkippedHSEvents", 0,
                                         "Number of skipped HS events"}

Definition at line 119 of file PileUpMTAlg.h.

                                      {this, "SkippedHSEvents", 0,
                                         "Number of skipped HS events"};

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_writeTrace

Gaudi::Property<bool> PileUpMTAlg::m_writeTrace {this, "WriteTrace", false, "Write trace of pileup events used"}

private

Definition at line 118 of file PileUpMTAlg.h.

{this, "WriteTrace", false, "Write trace of pileup events used"};

---

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

• PileUpMTAlg.h
• PileUpMTAlg.cxx