BkgStreamsCache.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef PILEUPTOOLS_BKGSTREAMSCACHE_H
# define PILEUPTOOLS_BKGSTREAMSCACHE_H
 
#include <string>
#include <vector>
#include <functional>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "GaudiKernel/ServiceHandle.h"
#include "Gaudi/Property.h"
#include "PileUpTools/PileUpStream.h"
#include "PileUpTools/IBkgStreamsCache.h"
 
class IEvtSelector;
class IBeamIntensity;
namespace CLHEP {
  class RandFlat;
  class RandPoisson;
}
 

class BkgStreamsCache :
  public extends<AthAlgTool, IBkgStreamsCache>
{
public:
  BkgStreamsCache( const std::string&, const std::string&, const IInterface*);
  virtual ~BkgStreamsCache();
 
  virtual StatusCode initialize() override final;
  virtual StatusCode finalize() override final;
  virtual StatusCode setup(int firstXing,
                           unsigned int nXings,
                           unsigned int firstStore,
                           IBeamIntensity*) override final;
  virtual void newEvent() override final;
  virtual void resetEvtsPerXingScaleFactor(float sf) override final;
  virtual StatusCode addSubEvts(unsigned int iXing,
                                xAOD::EventInfo* overlaidEvent,
                                int t0BinCenter) override final;
  virtual StatusCode addSubEvts(unsigned int iXing,
                                xAOD::EventInfo* overEvent,
                                int t0BinCenter, bool loadEventProxies, unsigned int /*BCID*/) override final;
  virtual unsigned int nStores() const override final { return m_nStores; }

  long collXing() { return m_collXing; }
  long collXingPoisson();
  unsigned int numberOfBkgForBunchCrossingIgnoringBeamIntensity(unsigned int iXing) const;
  unsigned int numberOfBkgForBunchCrossingDefaultImpl(unsigned int iXing) const;
  unsigned int numberOfCavernBkgForBunchCrossing(unsigned int iXing) const;
private:
  const xAOD::EventInfo* nextEvent(bool isCentralBunchCrossing);
  StatusCode nextEvent_passive(bool isCentralBunchCrossing);
  PileUpStream* current();
 
  unsigned int setNEvtsXing(unsigned int iXing);
  unsigned int nEvtsXing(unsigned int iXing) const;
 
  typedef std::vector<PileUpStream> StreamVector;
  bool alreadyInUse(StreamVector::size_type iStream);
  StreamVector::iterator m_cursor{};
  StreamVector m_streams;
  std::vector<bool> m_usedStreams;
  unsigned int m_nXings{0};
  unsigned int m_nStores{0};
  std::vector<unsigned int> m_nEvtsXing;
 
  ServiceHandle<IEvtSelector> m_selecName{this, "EventSelector", "FakeEventSelector"};
 
  ServiceHandle<IAtRndmGenSvc> m_atRndmSvc{this, "RndmGenSvc", "AtRndmGenSvc",
    "IAtRndmGenSvc controlling the distribution of bkg events/xing"};
 
  Gaudi::Property<float> m_collXing{this, "CollPerXing", 23.0,
    "(average) number of collisions per beam crossing"};
 
  Gaudi::Property<float> m_occupationFraction{this, "OccupationFraction", 1.0,
    "The maximum fraction of bunch-crossings which will be occupied."};
 
  Gaudi::Property<std::string> m_collDistrName{this, "CollDistribution", "Poisson",
    "nEvts/Xings can be either Fixed at CollPerXing or Poisson with average CollPerXing"};
 
  Gaudi::Property<float> m_readDownscale{this, "ReadDownscaleFactor", 150,
    "read one event every downscaleFactor accesses (asymptotically -> number of times "
    "an event in the cache will be reused)"};
 
  Gaudi::Property<std::string> m_randomStreamName{this, "RndmStreamName", "PileUpCollXingStream",
    "IAtRndmGenSvc stream used as engine for our various random distributions, including the CollPerXing one "};
 
  Gaudi::CheckedProperty<unsigned short> m_pileUpEventTypeProp{this, "PileUpEventType", 0,
    &BkgStreamsCache::PileUpEventTypeHandler,
    "Type of the pileup events in this cache: 0:Signal, 1:MinimumBias, 2:Cavern, 3:HaloGas, "
    "4:ZeroBias. Default=0 (Signal, Invalid)"};
  void PileUpEventTypeHandler(Gaudi::Details::PropertyBase&);
 
  Gaudi::Property<unsigned short> m_subtractBC0{this, "SubtractBC0", 0,
    "reduce the number of events at bunch xing t=0 by m_subtractBC0. Default=0, set to 1 when "
    "using the same type of events (e.g. minbias) for original and background streams"};
 
  Gaudi::Property<bool> m_ignoreBM{this, "IgnoreBeamInt", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam intensity "
    "tool in setting the number of events per xing."};
 
  Gaudi::Property<bool> m_ignoreSF{this, "IgnoreBeamLumi", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam luminosity "
    "tool in setting the number of events per xing."};
 
  Gaudi::Property<bool> m_forceReadForBC0{this, "ForceReadForBC0", true,
    "Force events used in the central bunch crossing to be refreshed"};

  xAOD::EventInfo::PileUpType m_pileUpEventType;
  CLHEP::RandFlat* m_readEventRand{nullptr};
  CLHEP::RandFlat* m_chooseEventRand{nullptr};
  CLHEP::RandPoisson* m_collXingPoisson{nullptr};
  std::function< long() > m_f_collDistr;
  std::function< unsigned int(unsigned int) > m_f_numberOfBackgroundForBunchCrossing;
  float m_collXingSF{1.0};
  int m_zeroXing{-1};
  IBeamIntensity* m_beamInt{nullptr};
 
};
 
#endif // PILEUPTOOLS_BKGSTREAMSCACHE_H