BatchedMinbiasSvc Class Reference

#include <BatchedMinbiasSvc.h>

Inheritance diagram for BatchedMinbiasSvc:

Collaboration diagram for BatchedMinbiasSvc:

Public Member Functions
	BatchedMinbiasSvc (const std::string &name, ISvcLocator *svc)
	Constructor. More...
	~BatchedMinbiasSvc ()
	Destructor. More...
StatusCode	initialize () override
	AthService initialize. More...
StatusCode	beginHardScatter (const EventContext &ctx) override
StoreGateSvc *	getMinbias (const EventContext &ctx, std::uint64_t mb_id) override
std::size_t	getNumForBunch (const EventContext &ctx, int bunch) const override
virtual std::int64_t	get_hs_id (const EventContext &ctx) const override
StatusCode	endHardScatter (const EventContext &ctx) override

Private Types
using	SGHandle = ServiceHandle< StoreGateSvc >
using	SGHandleArray = std::vector< SGHandle >

Private Member Functions
int	event_to_batch (std::int64_t hs_id)
std::size_t	calcMBRequired (std::int64_t hs_id, std::size_t slot, unsigned int run, unsigned int lumi, std::uint64_t event)

Private Attributes
Gaudi::Property< std::uint64_t >	m_seed
Gaudi::Property< bool >	m_onDemandMB
Gaudi::Property< bool >	m_usePoisson
Gaudi::Property< bool >	m_useBeamInt
Gaudi::Property< bool >	m_useBeamLumi
Gaudi::Property< int >	m_MBBatchSize
Gaudi::Property< int >	m_NSimultaneousBatches
Gaudi::Property< int >	m_HSBatchSize
Gaudi::Property< int >	m_skippedHSEvents
Gaudi::Property< float >	m_nPerBunch
Gaudi::Property< int >	m_earliestDeltaBC
Gaudi::Property< int >	m_latestDeltaBC
Gaudi::Property< std::vector< int > >	m_actualNHSEventsPerBatch
ServiceHandle< ISkipEventIdxSvc >	m_skipEventIdxSvc
ServiceHandle< IEvtSelector >	m_bkgEventSelector
ServiceHandle< IBeamIntensity >	m_beamInt
ServiceHandle< IBeamLuminosity >	m_beamLumi
ServiceHandle< ActiveStoreSvc >	m_activeStoreSvc
SGHandle	m_spare_store
IEvtSelector::Context *	m_bkg_evt_sel_ctx
std::vector< std::vector< std::uint64_t > >	m_num_mb_by_bunch
std::vector< std::vector< std::uint64_t > >	m_idx_lists
std::map< int, std::unique_ptr< SGHandleArray > >	m_cache
std::map< int, std::mutex >	m_cache_mtxs
std::mutex	m_reading_batch_mtx
std::deque< std::unique_ptr< SGHandleArray > >	m_empty_caches
std::mutex	m_empty_caches_mtx
std::vector< std::unique_ptr< std::atomic_int > >	m_batch_use_count
std::atomic_int	m_last_loaded_batch

Detailed Description

Definition at line 28 of file BatchedMinbiasSvc.h.

Member Typedef Documentation

SGHandle

using BatchedMinbiasSvc::SGHandle = ServiceHandle<StoreGateSvc>

private

Definition at line 49 of file BatchedMinbiasSvc.h.

SGHandleArray

using BatchedMinbiasSvc::SGHandleArray = std::vector<SGHandle>

private

Definition at line 50 of file BatchedMinbiasSvc.h.

Constructor & Destructor Documentation

BatchedMinbiasSvc()

BatchedMinbiasSvc::BatchedMinbiasSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Constructor.

Definition at line 32 of file BatchedMinbiasSvc.cxx.

    : base_class(name, svc),
      m_bkg_evt_sel_ctx(nullptr),
      m_last_loaded_batch() {}

~BatchedMinbiasSvc()

BatchedMinbiasSvc::~BatchedMinbiasSvc

(

)

Destructor.

Definition at line 37 of file BatchedMinbiasSvc.cxx.

{}

Member Function Documentation

beginHardScatter()

StatusCode BatchedMinbiasSvc::beginHardScatter ( const EventContext &  ctx )

override

Definition at line 286 of file BatchedMinbiasSvc.cxx.

                                                                      {
  using namespace std::chrono_literals;
  bool first_wait = true;
  std::chrono::steady_clock::time_point cache_wait_start{};
  std::chrono::steady_clock::time_point order_wait_start{};
  const std::int64_t hs_id = get_hs_id(ctx);
  const int batch = event_to_batch(hs_id);
  calcMBRequired(hs_id, ctx.slot(),
                 ctx.eventID().run_number(),  // don't need the total, only
                 ctx.eventID().lumi_block(),  // need to populate the arrays
                 ctx.eventID().event_number());
  while (true) {
    if (m_cache.count(batch) != 0) {
      // batch already loaded
      // mutex prevents returning when batch is partially loaded
      m_cache_mtxs[batch].lock();
      m_cache_mtxs[batch].unlock();
      return StatusCode::SUCCESS;
    }
    // prevent batches loading out-of-order
    if (m_last_loaded_batch < (batch - 1)) {
      ATH_MSG_INFO("Waiting to prevent out-of-order loading of batches");
      order_wait_start = std::chrono::steady_clock::now();
      while (m_last_loaded_batch < (batch - 1)) {
        std::this_thread::sleep_for(50ms);
      }
      auto wait_time = std::chrono::steady_clock::now() - order_wait_start;
      ATH_MSG_INFO(std::format(
          "Waited {:%M:%S} to prevent out-of-order loading", wait_time));
    }
    // See if there are any free caches
    // Using try_lock here to avoid reading same batch twice
    std::unique_lock<std::mutex> empty_caches_lock (m_empty_caches_mtx,
                                                    std::try_to_lock);
    if (empty_caches_lock.owns_lock()) {
      if (m_empty_caches.empty()) {
        // Unlock mutex if we got the lock but there were no free caches
        empty_caches_lock.unlock();
        if (first_wait) {
          ATH_MSG_INFO("Waiting for a free cache");
          first_wait = false;
          cache_wait_start = std::chrono::steady_clock::now();
        }
        // Wait 100ms then try again
        std::this_thread::sleep_for(100ms);
        continue;
      }
      if (!first_wait) {
        auto wait_time = std::chrono::steady_clock::now() - cache_wait_start;
        ATH_MSG_INFO(
            std::format("Waited {:%M:%S} for a free cache", wait_time));
      }
      std::scoped_lock reading{m_cache_mtxs[batch], m_reading_batch_mtx};
      if (m_HSBatchSize != 0) {
        ATH_MSG_INFO("Reading next batch in event " << ctx.evt() << ", slot "
                                                    << ctx.slot() << " (hs_id "
                                                    << hs_id << ")");
      }
      auto start_time = std::chrono::system_clock::now();
      m_cache[batch] = std::move(m_empty_caches.front());
      m_empty_caches.pop_front();
      // Remember old store to reset later
      auto* old_store = m_activeStoreSvc->activeStore();
      for (auto&& sg : *m_cache[batch]) {
        // Change active store
        m_activeStoreSvc->setStore(sg.get());
        SG::CurrentEventStore::Push reader_sg_ces(sg.get());
        // Read next event
        ATH_CHECK(sg->clearStore(true));
        if (!(m_bkgEventSelector->next(*m_bkg_evt_sel_ctx)).isSuccess()) {
          ATH_MSG_FATAL("Ran out of minbias events");
          return StatusCode::FAILURE;
        }
        IOpaqueAddress* addr = nullptr;
        if (!m_bkgEventSelector->createAddress(*m_bkg_evt_sel_ctx, addr)
                 .isSuccess()) {
          ATH_MSG_WARNING("Failed to create address. No more events?");
          return StatusCode::FAILURE;
        }
        if (addr == nullptr) {
          ATH_MSG_WARNING("createAddress returned nullptr. No more events?");
          return StatusCode::FAILURE;
        }
        ATH_CHECK(sg->recordAddress(addr));
        ATH_CHECK(sg->loadEventProxies());
        // Read data now if desired
        if (!m_onDemandMB) {
          for (const auto* proxy_ptr : sg->proxies()) {
            if (!proxy_ptr->isValid()) {
              continue;
            }
 
            // Sort of a const_cast, then ->accessData()
            sg->proxy_exact(proxy_ptr->sgkey())->accessData();
          }
        }
      }
      // Reset active store
      m_activeStoreSvc->setStore(old_store);
      if (m_HSBatchSize != 0) {
        ATH_MSG_INFO(std::format(
            "Reading {} events took {:%OMm %OSs}", m_cache[batch]->size(),
            std::chrono::system_clock::now() - start_time));
      }
      m_last_loaded_batch.exchange(batch);
      return StatusCode::SUCCESS;
    }
  }
  return StatusCode::SUCCESS;
}

calcMBRequired()

std::size_t BatchedMinbiasSvc::calcMBRequired ( std::int64_t  hs_id, std::size_t  slot, unsigned int  run, unsigned int  lumi, std::uint64_t  event  )

private

Definition at line 195 of file BatchedMinbiasSvc.cxx.

                                                                 {
  const int n_bunches = m_latestDeltaBC.value() - m_earliestDeltaBC.value() + 1;
  FastReseededPRNG prng{m_seed.value(), hs_id};
 
  // First apply the beam luminosity SF
  bool sf_updated_throwaway;
  const float beam_lumi_sf =
      m_useBeamLumi ? m_beamLumi->scaleFactor(run, lumi, sf_updated_throwaway)
                    : 1.f;
  std::vector<float> avg_num_mb_by_bunch(n_bunches,
                                         beam_lumi_sf * m_nPerBunch.value());
  // Now update using beam intensities
  if (m_useBeamInt) {
    // Supposed to be once per event, but ends up running once per minbias type
    // per event now
    m_beamInt->selectT0(run, event);
    for (int bunch = m_earliestDeltaBC.value();
         bunch <= m_latestDeltaBC.value(); ++bunch) {
      std::size_t idx = bunch - m_earliestDeltaBC.value();
      avg_num_mb_by_bunch[idx] *= m_beamInt->normFactor(bunch);
    }
  }
 
  std::vector<std::uint64_t>& num_mb_by_bunch = m_num_mb_by_bunch[slot];
  num_mb_by_bunch.clear();
  num_mb_by_bunch.resize(n_bunches);
 
  if (m_usePoisson) {
    std::transform(avg_num_mb_by_bunch.begin(), avg_num_mb_by_bunch.end(),
                   num_mb_by_bunch.begin(), [&prng](float avg) {
                     return std::poisson_distribution<std::uint64_t>(avg)(prng);
                   });
  } else {
    std::transform(avg_num_mb_by_bunch.begin(), avg_num_mb_by_bunch.end(),
                   num_mb_by_bunch.begin(), [](float f) {
                     return static_cast<std::uint64_t>(std::round(f));
                   });
  }
 
  std::uint64_t num_mb = ranges::accumulate(num_mb_by_bunch, 0UL);
  std::vector<std::uint64_t>& index_array = m_idx_lists[slot];
  const std::uint64_t mbBatchSize = m_MBBatchSize.value();
  // Prevent running out of events
  if (num_mb > mbBatchSize) {
    const int center_bunch = -m_earliestDeltaBC.value();
    auto indices =
        rv::iota(0ULL, num_mb_by_bunch.size()) |
        rv::filter([center_bunch, &num_mb_by_bunch](int idx) {
          bool good = idx != center_bunch;  // filter out the central bunch
          good =
              good && num_mb_by_bunch[idx] > 0;  // filter out unfilled bunches
          return good;
        }) |
        ranges::to<std::vector>;
    // sort by distance from central bunch
    ranges::stable_sort(indices, std::greater{},
                        [center_bunch](std::size_t idx) {
                          return std::size_t(std::abs(int(idx) - center_bunch));
                        });
    // subtract from bunches until we aren't using too many events
    for (auto idx : indices) {
      const std::uint64_t max_to_subtract = num_mb - mbBatchSize;
      const std::uint64_t num_subtracted =
          std::min(max_to_subtract, num_mb_by_bunch[idx]);
      num_mb_by_bunch[idx] -= num_subtracted;
      num_mb -= num_subtracted;
      if (num_mb <= mbBatchSize) {
        break;
      }
    }
    // Print an error anyway so we can fix the job
    ATH_MSG_ERROR("We need " << num_mb << " events but the batch size is "
                             << mbBatchSize << ". Restricting to "
                             << mbBatchSize << " events!");
  }
  index_array = rv::ints(0, int(mbBatchSize)) | rv::sample(num_mb, prng) |
                ranges::to<std::vector<std::uint64_t>>;
  ranges::shuffle(index_array, prng);
  ATH_MSG_DEBUG("HS ID " << hs_id << " uses " << num_mb << " events");
  // Disabled until C++ 23 range formatting can be used
  // if (m_HSBatchSize <= 1) {
  //   ATH_MSG_DEBUG(fmt::format("\t\tBy bunch: [{}]\n", fmt::join(num_mb_by_bunch, ", "))
  //                 << fmt::format("\t\tOrder: [{}]", fmt::join(index_array, ", ")));
  // }
  return num_mb;
}

endHardScatter()

StatusCode BatchedMinbiasSvc::endHardScatter ( const EventContext &  ctx )

override

Definition at line 416 of file BatchedMinbiasSvc.cxx.

                                                                    {
  using namespace std::chrono_literals;
  const std::int64_t hs_id = get_hs_id(ctx);
  const int batch = event_to_batch(hs_id);
  const int uses = m_batch_use_count[batch]->fetch_add(1) + 1;
 
  // If we're done with every event in the batch, clear the stores and return
  // them
  if (uses == m_HSBatchSize.value()) {
    std::unique_ptr temp = std::move(m_cache[batch]);
    m_cache.erase(batch);
    for (auto&& sg : *temp) {
      ATH_CHECK(sg->clearStore());
    }
    std::lock_guard lg{m_empty_caches_mtx};
    m_empty_caches.emplace_back(std::move(temp));
  } else {
    ATH_MSG_DEBUG("BATCH " << batch << ": " << uses << " uses out of "
                           << m_HSBatchSize << "  "
                           << m_actualNHSEventsPerBatch);
  }
  return StatusCode::SUCCESS;
}

event_to_batch()

int BatchedMinbiasSvc::event_to_batch ( std::int64_t  hs_id )

private

Definition at line 39 of file BatchedMinbiasSvc.cxx.

                                                      {
  return int(hs_id / m_HSBatchSize.value());
}

get_hs_id()

virtual std::int64_t BatchedMinbiasSvc::get_hs_id ( const EventContext &  ctx ) const

inlineoverridevirtual

Definition at line 43 of file BatchedMinbiasSvc.h.

                                                               {
    return m_skippedHSEvents.value() + ctx.evt();
  }

getMinbias()

StoreGateSvc * BatchedMinbiasSvc::getMinbias ( const EventContext &  ctx, std::uint64_t  mb_id  )

override

Definition at line 397 of file BatchedMinbiasSvc.cxx.

                                                               {
  const std::int64_t hs_id = get_hs_id(ctx);
  const std::size_t slot = ctx.slot();
  const std::size_t index = m_idx_lists.at(slot).at(mb_id);
  const int batch = event_to_batch(hs_id);
  return m_cache[batch]->at(index).get();
}

getNumForBunch()

std::size_t BatchedMinbiasSvc::getNumForBunch ( const EventContext &  ctx, int  bunch  ) const

override

Definition at line 406 of file BatchedMinbiasSvc.cxx.

                                                               {
  if (bunch < m_earliestDeltaBC.value() || bunch > m_latestDeltaBC.value()) {
    throw std::logic_error(std::format(
        "Tried to request bunch {} which is outside the range [{}, {}]", bunch,
        m_earliestDeltaBC.value(), m_latestDeltaBC.value()));
  }
  return m_num_mb_by_bunch.at(ctx.slot()).at(bunch - m_earliestDeltaBC.value());
}

initialize()

StatusCode BatchedMinbiasSvc::initialize ( )

override

AthService initialize.

Definition at line 43 of file BatchedMinbiasSvc.cxx.

                                         {
  ATH_CHECK(m_skipEventIdxSvc.retrieve());
  ATH_CHECK(m_beamInt.retrieve());
  ATH_CHECK(m_beamLumi.retrieve());
  std::size_t n_concurrent =
      Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents();
  m_idx_lists.clear();
  m_idx_lists.resize(n_concurrent);
 
  m_num_mb_by_bunch.clear();
  m_num_mb_by_bunch.resize(n_concurrent);
 
  m_cache.clear();
  m_empty_caches.clear();
  m_batch_use_count.clear();
  m_batch_use_count.reserve(m_actualNHSEventsPerBatch.value().size());
  for (std::size_t i = 0; i < m_actualNHSEventsPerBatch.value().size(); ++i) {
    m_batch_use_count.emplace_back(std::make_unique<std::atomic_int>(0));
  }
  ATH_CHECK(m_bkgEventSelector.retrieve());
  ATH_CHECK(m_activeStoreSvc.retrieve());
  // Setup context
  if (!m_bkgEventSelector->createContext(m_bkg_evt_sel_ctx).isSuccess()) {
    ATH_MSG_ERROR("Failed to create background event selector context");
    return StatusCode::FAILURE;
  }
  ATH_CHECK(SmartIF<IService>(m_bkgEventSelector.get())->start());
 
  // Setup proxy provider
  SmartIF<IProxyProviderSvc> proxyProviderSvc{
    serviceLocator()->service(std::format("ProxyProviderSvc/BkgPPSvc_{}", name()))
  };
  ATH_CHECK(proxyProviderSvc.isValid());
 
  // Setup Address Providers
  SmartIF<IAddressProvider> addressProvider{m_bkgEventSelector.get()};
  if (!addressProvider) {
    ATH_MSG_WARNING(
        "Could not cast background event selector to IAddressProvider");
  } else {
    proxyProviderSvc->addProvider(addressProvider);
  }
  // AthenaPoolAddressProviderSvc
  SmartIF<IAddressProvider> athPoolAP{
    serviceLocator()->service(std::format("AthenaPoolAddressProviderSvc/BkgAPAPSvc_{}", name()))
  };
  if (!athPoolAP) {
    ATH_MSG_WARNING(
        "Could not cast AthenaPoolAddressProviderSvc to IAddressProvider");
  } else {
    proxyProviderSvc->addProvider(athPoolAP);
  }
  // AddressRemappingSvc
  SmartIF<IAddressProvider> addRemapAP{
    serviceLocator()->service(std::format("AddressRemappingSvc/BkgARSvc_{}", name()))
  };
  if (!addRemapAP) {
    ATH_MSG_WARNING("Could not cast AddressRemappingSvc to IAddressProvider");
  } else {
    proxyProviderSvc->addProvider(addRemapAP);
  }
 
  int mbBatchSize = m_MBBatchSize.value();
  // setup NSimultaneousBatches vectors of MBBatchSize StoreGates in
  // m_empty_caches
  for (int i = 0; i < m_NSimultaneousBatches.value(); ++i) {
    auto& sgs = m_empty_caches.emplace_back(std::make_unique<SGHandleArray>());
    sgs->reserve(mbBatchSize);
    for (int j = 0; j < mbBatchSize; ++j) {
      // creates / retrieves a different StoreGateSvc for each slot
      auto& sg = sgs->emplace_back(
          std::format("StoreGateSvc/StoreGate_{}_{}_{}", name(), i, j), name());
      ATH_CHECK(sg.retrieve());
      sg->setStoreID(StoreID::PILEUP_STORE);
      sg->setProxyProviderSvc(proxyProviderSvc);
    }
  }
 
  // Setup the spare store for event skipping
  ATH_CHECK(m_spare_store.retrieve());
  m_spare_store->setStoreID(StoreID::PILEUP_STORE);
  m_spare_store->setProxyProviderSvc(proxyProviderSvc);
 
  // Setup the callback for event skipping
  auto skipEvent_callback = [this, mbBatchSize](
                                ISkipEventIdxSvc::EvtIter begin,
                                ISkipEventIdxSvc::EvtIter end) -> StatusCode {
    using namespace std::chrono_literals;
    auto evts = ranges::make_subrange(begin, end);
    ATH_MSG_INFO("Skipping " << end - begin << " HS events.");
    auto batches_all =
        evts | rv::transform([this](const ISkipEventIdxSvc::EvtId& evt) {
          return event_to_batch(evt.evtIdx);
        });
    std::vector<std::tuple<int, int>> batches_with_counts{};
    // Produce a list of batches, and how many times they appear
    for (int batch : batches_all) {
      // First entry
      if (batches_with_counts.empty()) {
        batches_with_counts.emplace_back(batch, 1);
        continue;
      }
      // Subsequent entries
      auto& last_entry = batches_with_counts.back();
      if (batch == std::get<0>(last_entry)) {
        std::get<1>(last_entry) += 1;
        continue;
      }
      batches_with_counts.emplace_back(batch, 1);
    }
 
    // Discard batches
    const int hs_batch_size = m_HSBatchSize.value();
    auto* const old_store = m_activeStoreSvc->activeStore();
    m_activeStoreSvc->setStore(m_spare_store.get());
    ATH_CHECK(m_spare_store->clearStore());
    for (const auto& [batch, count] : batches_with_counts) {
      if (m_cache.count(batch) != 0) {
        // batch is currently loaded, just update the use count
        m_batch_use_count[batch]->fetch_add(count);
        continue;
      }
      // force ordering in background stream
      while (m_last_loaded_batch < batch - 1) {
        std::this_thread::sleep_for(50ms);
      }
      // if we aren't skipping all the hardscatters in the batch, do nothing
      if ((m_batch_use_count[batch]->fetch_add(count) + count) <
          hs_batch_size) {
        continue;
      }
      // otherwise discard the batch
      ATH_MSG_INFO("Discarding batch " << batch);
      std::unique_lock lck{m_reading_batch_mtx};
      if (!m_bkgEventSelector->next(*m_bkg_evt_sel_ctx, mbBatchSize)
               .isSuccess()) {
        ATH_MSG_INFO("Ran out of background events");
        return StatusCode::FAILURE;
      }
      // increment counters
      m_last_loaded_batch.fetch_add(1);
    }
    ATH_CHECK(m_spare_store->clearStore());
    m_activeStoreSvc->setStore(old_store);
    return StatusCode::SUCCESS;
  };
 
  // register callback
  ATH_CHECK(m_skipEventIdxSvc->registerCallback(skipEvent_callback));
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_activeStoreSvc

ServiceHandle<ActiveStoreSvc> BatchedMinbiasSvc::m_activeStoreSvc

private

Initial value:

{
      this, "ActiveStoreSvc", "ActiveStoreSvc", "ActiveStoreSvc"}

Definition at line 97 of file BatchedMinbiasSvc.h.

m_actualNHSEventsPerBatch

Gaudi::Property<std::vector<int> > BatchedMinbiasSvc::m_actualNHSEventsPerBatch

private

Initial value:

{
      this,
      "actualNHSEventsPerBatch",
      {},
      "Dynamic map of actual number of HS events for each batch, in this run."}

Definition at line 83 of file BatchedMinbiasSvc.h.

m_batch_use_count

std::vector<std::unique_ptr<std::atomic_int> > BatchedMinbiasSvc::m_batch_use_count

private

Definition at line 113 of file BatchedMinbiasSvc.h.

m_beamInt

ServiceHandle<IBeamIntensity> BatchedMinbiasSvc::m_beamInt

private

Initial value:

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

Definition at line 93 of file BatchedMinbiasSvc.h.

m_beamLumi

ServiceHandle<IBeamLuminosity> BatchedMinbiasSvc::m_beamLumi

private

Initial value:

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

Definition at line 95 of file BatchedMinbiasSvc.h.

m_bkg_evt_sel_ctx

IEvtSelector::Context* BatchedMinbiasSvc::m_bkg_evt_sel_ctx

private

Definition at line 103 of file BatchedMinbiasSvc.h.

m_bkgEventSelector

ServiceHandle<IEvtSelector> BatchedMinbiasSvc::m_bkgEventSelector

private

Initial value:

{
      this, "BkgEventSelector", {}, "Event selector for minbias events"}

Definition at line 91 of file BatchedMinbiasSvc.h.

m_cache

std::map<int, std::unique_ptr<SGHandleArray> > BatchedMinbiasSvc::m_cache

private

Definition at line 107 of file BatchedMinbiasSvc.h.

m_cache_mtxs

std::map<int, std::mutex> BatchedMinbiasSvc::m_cache_mtxs

private

Definition at line 108 of file BatchedMinbiasSvc.h.

m_earliestDeltaBC

Gaudi::Property<int> BatchedMinbiasSvc::m_earliestDeltaBC

private

Initial value:

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

Definition at line 77 of file BatchedMinbiasSvc.h.

m_empty_caches

std::deque<std::unique_ptr<SGHandleArray> > BatchedMinbiasSvc::m_empty_caches

private

Definition at line 111 of file BatchedMinbiasSvc.h.

m_empty_caches_mtx

std::mutex BatchedMinbiasSvc::m_empty_caches_mtx

private

Definition at line 112 of file BatchedMinbiasSvc.h.

m_HSBatchSize

Gaudi::Property<int> BatchedMinbiasSvc::m_HSBatchSize

private

Initial value:

{
      this, "HSBatchSize", 1,
      "Number of HS events per batch (aka max reuse factor)"}

Definition at line 69 of file BatchedMinbiasSvc.h.

m_idx_lists

std::vector<std::vector<std::uint64_t> > BatchedMinbiasSvc::m_idx_lists

private

Definition at line 106 of file BatchedMinbiasSvc.h.

m_last_loaded_batch

std::atomic_int BatchedMinbiasSvc::m_last_loaded_batch

private

Definition at line 114 of file BatchedMinbiasSvc.h.

m_latestDeltaBC

Gaudi::Property<int> BatchedMinbiasSvc::m_latestDeltaBC

private

Initial value:

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

Definition at line 80 of file BatchedMinbiasSvc.h.

m_MBBatchSize

Gaudi::Property<int> BatchedMinbiasSvc::m_MBBatchSize

private

Initial value:

{
      this, "MBBatchSize", 10000,
      "Number of low pT minbias events to load per batch"}

Definition at line 63 of file BatchedMinbiasSvc.h.

m_nPerBunch

Gaudi::Property<float> BatchedMinbiasSvc::m_nPerBunch

private

Initial value:

{
      this, "AvgMBPerBunch", 0,
      "Average (max) number of minbias events per bunch"}

Definition at line 74 of file BatchedMinbiasSvc.h.

m_NSimultaneousBatches

Gaudi::Property<int> BatchedMinbiasSvc::m_NSimultaneousBatches

private

Initial value:

{
      this, "NSimultaneousBatches", 1,
      "Max number of batches to load simultaneously"}

Definition at line 66 of file BatchedMinbiasSvc.h.

m_num_mb_by_bunch

std::vector<std::vector<std::uint64_t> > BatchedMinbiasSvc::m_num_mb_by_bunch

private

Definition at line 105 of file BatchedMinbiasSvc.h.

m_onDemandMB

Gaudi::Property<bool> BatchedMinbiasSvc::m_onDemandMB

private

Initial value:

{
      this, "OnDemandMB", false,
      "Should minbias event contents be read on demand"}

Definition at line 53 of file BatchedMinbiasSvc.h.

m_reading_batch_mtx

std::mutex BatchedMinbiasSvc::m_reading_batch_mtx

private

Definition at line 110 of file BatchedMinbiasSvc.h.

m_seed

Gaudi::Property<std::uint64_t> BatchedMinbiasSvc::m_seed

private

Initial value:

{this, "Seed", 0,
                                        "Additional seed for PRNGs"}

Definition at line 51 of file BatchedMinbiasSvc.h.

m_skipEventIdxSvc

ServiceHandle<ISkipEventIdxSvc> BatchedMinbiasSvc::m_skipEventIdxSvc

private

Initial value:

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

Definition at line 88 of file BatchedMinbiasSvc.h.

m_skippedHSEvents

Gaudi::Property<int> BatchedMinbiasSvc::m_skippedHSEvents

private

Initial value:

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

Definition at line 72 of file BatchedMinbiasSvc.h.

m_spare_store

SGHandle BatchedMinbiasSvc::m_spare_store

private

Initial value:

{this, "StoreGateSvc",
                         std::format("StoreGateSvc/discards_{}", name()),
                         "StoreGate for discarding events"}

Definition at line 100 of file BatchedMinbiasSvc.h.

m_useBeamInt

Gaudi::Property<bool> BatchedMinbiasSvc::m_useBeamInt

private

Initial value:

{
      this, "UseBeamInt", true, "Whether to use the beam intensity service"}

Definition at line 59 of file BatchedMinbiasSvc.h.

m_useBeamLumi

Gaudi::Property<bool> BatchedMinbiasSvc::m_useBeamLumi

private

Initial value:

{
      this, "UseBeamLumi", true, "Whether to use the beam luminosity service"}

Definition at line 61 of file BatchedMinbiasSvc.h.

m_usePoisson

Gaudi::Property<bool> BatchedMinbiasSvc::m_usePoisson

private

Initial value:

{this, "UsePoisson", true,
                                     "Whether to use a Poisson distribution "
                                     "(if False, use a delta distribution)"}

Definition at line 56 of file BatchedMinbiasSvc.h.

---

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

• BatchedMinbiasSvc.h
• BatchedMinbiasSvc.cxx