BkgStreamsCache Class Reference

In-memory cache for pileup events. More...

#include <BkgStreamsCache.h>

Inheritance diagram for BkgStreamsCache:

Collaboration diagram for BkgStreamsCache:

Public Member Functions
	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
	inform cache that we start overlaying a new event
virtual void	resetEvtsPerXingScaleFactor (float sf) override final
	reset scale factor at new run/lumiblk
virtual StatusCode	addSubEvts (unsigned int iXing, xAOD::EventInfo *overlaidEvent, int t0BinCenter) override final
	Read input events in bkg stores and link them to overlay store.
virtual StatusCode	addSubEvts (unsigned int iXing, xAOD::EventInfo *overEvent, int t0BinCenter, bool loadEventProxies, unsigned int) override final
	Read input events in bkg stores and link them to overlay store.
virtual unsigned int	nStores () const override final
	how many stores in this cache
long	collXing ()
	meant to be used (mainly) via m_f_collDistr
long	collXingPoisson ()
unsigned int	numberOfBkgForBunchCrossingIgnoringBeamIntensity (unsigned int iXing) const
	meant to be used via m_f_numberOfBackgroundForBunchCrossing
unsigned int	numberOfBkgForBunchCrossingDefaultImpl (unsigned int iXing) const
unsigned int	numberOfCavernBkgForBunchCrossing (unsigned int iXing) const

Private Types
typedef std::vector< PileUpStream >	StreamVector

Private Member Functions
const xAOD::EventInfo *	nextEvent (bool isCentralBunchCrossing)
	get next bkg event from cache
StatusCode	nextEvent_passive (bool isCentralBunchCrossing)
	as nextEvent except don't actually load anything
PileUpStream *	current ()
	get current (last asked) stream
unsigned int	setNEvtsXing (unsigned int iXing)
unsigned int	nEvtsXing (unsigned int iXing) const
bool	alreadyInUse (StreamVector::size_type iStream)
void	PileUpEventTypeHandler (Gaudi::Details::PropertyBase &)

Private Attributes
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
Gaudi::Property< float >	m_collXing
Gaudi::Property< float >	m_occupationFraction
Gaudi::Property< std::string >	m_collDistrName
Gaudi::Property< float >	m_readDownscale
Gaudi::Property< std::string >	m_randomStreamName
Gaudi::CheckedProperty< unsigned short >	m_pileUpEventTypeProp
Gaudi::Property< unsigned short >	m_subtractBC0
Gaudi::Property< bool >	m_ignoreBM
Gaudi::Property< bool >	m_ignoreSF
Gaudi::Property< bool >	m_forceReadForBC0
xAOD::EventInfo::PileUpType	m_pileUpEventType
	the type of events in this cache
CLHEP::RandFlat *	m_readEventRand {nullptr}
	read a new event every downscaleFactor accesses
CLHEP::RandFlat *	m_chooseEventRand {nullptr}
	pickup an event store at random from the cache
CLHEP::RandPoisson *	m_collXingPoisson {nullptr}
	set number of collisions per bunch crossing (if Poisson distribution chosen)
std::function< long() >	m_f_collDistr
	function returning the number of collisions per bunch crossing before bunch structure modulation
std::function< unsigned int(unsigned int) >	m_f_numberOfBackgroundForBunchCrossing
	function returning the number of bkg events per bunch crossing after bunch structure modulation
float	m_collXingSF {1.0}
	float scaling number of collisions per bunch crossing
int	m_zeroXing {-1}
	offset of BC=0 xing
IBeamIntensity *	m_beamInt {nullptr}
	pointer to the IBeamIntensity distribution tool

Detailed Description

In-memory cache for pileup events.

Definition at line 35 of file BkgStreamsCache.h.

Member Typedef Documentation

StreamVector

typedef std::vector<PileUpStream> BkgStreamsCache::StreamVector

private

Definition at line 97 of file BkgStreamsCache.h.

Constructor & Destructor Documentation

BkgStreamsCache()

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

Definition at line 26 of file BkgStreamsCache.cxx.

  : base_class( type, name, parent )
{
  m_pileUpEventTypeProp.verifier().setUpper(xAOD::EventInfo::PileUp_NTYPES-2);
}

~BkgStreamsCache()

BkgStreamsCache::~BkgStreamsCache ( )

virtual

Definition at line 34 of file BkgStreamsCache.cxx.

{
  delete m_collXingPoisson;
  delete m_chooseEventRand;
  delete m_readEventRand;
}

Member Function Documentation

addSubEvts() [1/2]

StatusCode BkgStreamsCache::addSubEvts ( unsigned int iXing, xAOD::EventInfo * overEvent, int t0BinCenter, bool loadEventProxies, unsigned int BCID )

finaloverridevirtual

Read input events in bkg stores and link them to overlay store.

Parameters

iXing	offset to first xing number (=0 first Xing, =nXings for last xing)
overlaidEvent	reference to resulting overlaid event
t0BinCenter	time wrto t0 of current bin center in ns
loadEventProxies	should we load the event proxies or not.
BCID	bunch-crossing ID of signal bunch crossing

Definition at line 327 of file BkgStreamsCache.cxx.

{
  for (unsigned int iEvt=0; iEvt<nEvtsXing(iXing); ++iEvt)
    {
      // check if we're picking events for the central bunch-crossing,
      // so we can choose to only use fresh events here.
      bool isCentralBunchCrossing((0==t0BinCenter)&&m_forceReadForBC0);
      // increment event iterators
      if(!loadEventProxies)        {
          return this->nextEvent_passive(isCentralBunchCrossing);
      }
      const xAOD::EventInfo* pBkgEvent = nextEvent( isCentralBunchCrossing ); //FIXME update this for the case where loadProxies=False
 
      //check input selector is not empty
      PileUpStream* currStream(this->current());
      if (0 == pBkgEvent || 0 == currStream)
        {
          // This is the end of the loop. No more events in the selection
          ATH_MSG_INFO ( "end of loop: background cache has no more events" );
          return StatusCode::FAILURE;
        }
      StoreGateSvc* pBkgStore = &(currStream->store());
      ATH_MSG_DEBUG ( "added event " <<  pBkgEvent->eventNumber()
                      << " run " << pBkgEvent->runNumber()
                      << " from store "
                      << pBkgStore->name()
                      << " @ Xing " << iXing );
 
      //  register as sub event of the overlaid
 
      // get the SG container for subevents infos
      xAOD::EventInfoContainer  *subEvCnt (nullptr);
      ATH_CHECK( overEvent->evtStore()->retrieve(subEvCnt, c_pileUpEventInfoContName) );
      // add subevent
      addSubEvent( overEvent, pBkgEvent, t0BinCenter, m_pileUpEventType, subEvCnt, c_pileUpEventInfoContName );
      subEvCnt->back()->setBCID( BCID );
      subEvCnt->back()->setEvtStore( pBkgStore );
               
#ifdef DEBUG_PILEUP
      const xAOD::EventInfo* pStoreInfo(nullptr);
      if (pBkgStore->retrieve(pStoreInfo).isSuccess() && pStoreInfo &&
          pBkgEvent->eventNumber() != pStoreInfo->eventNumber())
        {
          ATH_MSG_ERROR ( "added event " <<  pBkgEvent->eventNumber()
                          << " run " << pBkgEvent->runNumber()
                          << " differ from current store "
                          << pBkgStore->name()
                          << " event " <<  pStoreInfo->eventNumber()
                          << " run " << pStoreInfo->runNumber()
                          );
          assert(1);
        }
#endif
    } //loop over evts in xing
  return StatusCode::SUCCESS;
}

addSubEvts() [2/2]

StatusCode BkgStreamsCache::addSubEvts ( unsigned int iXing, xAOD::EventInfo * overlaidEvent, int t0BinCenter )

finaloverridevirtual

Read input events in bkg stores and link them to overlay store.

Parameters

iXing	offset to first xing number (=0 first Xing, =nXings for last xing)
overlaidEvent	reference to resulting overlaid event
t0BinCenter	time wrto t0 of current bin center in ns

Definition at line 319 of file BkgStreamsCache.cxx.

{
  return this->addSubEvts(iXing, overEvent, t0BinCenter, true, 0);
}

alreadyInUse()

bool BkgStreamsCache::alreadyInUse ( StreamVector::size_type iStream )

private

Definition at line 199 of file BkgStreamsCache.cxx.

{
  assert(iS<m_usedStreams.size());
  bool inUse(m_usedStreams[iS]);
  if (!inUse) m_usedStreams[iS] = true;
#ifndef NDEBUG
  ATH_MSG_VERBOSE ( "alreadyInUse: store " << iS  << ' '
                    << (inUse ? "already" : "not yet") << " in use" );
#endif
  return inUse;
}

collXing()

long BkgStreamsCache::collXing ( )

inline

meant to be used (mainly) via m_f_collDistr

Definition at line 80 of file BkgStreamsCache.h.

{ return m_collXing; }

collXingPoisson()

long BkgStreamsCache::collXingPoisson

(

)

Definition at line 121 of file BkgStreamsCache.cxx.

{
  if (!m_collXingPoisson) { return collXing(); }
  return m_collXingPoisson->fire(m_collXing * m_collXingSF);
}

current()

PileUpStream * BkgStreamsCache::current ( )

private

get current (last asked) stream

Definition at line 211 of file BkgStreamsCache.cxx.

{
  if (m_cursor != m_streams.end()) return &*m_cursor;
  //      m_cursor->isNotEmpty()) return &*m_cursor;
  else return 0; //FIXME should reomve empty stream and keep going
}

finalize()

StatusCode BkgStreamsCache::finalize ( )

finaloverridevirtual

Definition at line 386 of file BkgStreamsCache.cxx.

{
  StatusCode sc(StatusCode::SUCCESS);
  ATH_MSG_DEBUG ( "Finalizing " << name()
                  << " - cache for events of type "
                  << xAOD::EventInfo::PileUpType2Name(m_pileUpEventType) );
  while (sc.isSuccess() && m_streams.size()>0)
    {
      sc=m_streams.back().finalize();
      m_streams.pop_back();
    }
  return sc;
}

initialize()

StatusCode BkgStreamsCache::initialize ( )

finaloverridevirtual

Definition at line 218 of file BkgStreamsCache.cxx.

{
  ATH_MSG_DEBUG (  "Initializing " << name()
                   << " - cache for events of type "
                   << xAOD::EventInfo::PileUpType2Name(m_pileUpEventType) );
 
  PileUpEventTypeHandler(m_pileUpEventTypeProp);
 
  //create random number generators
  ATH_CHECK(m_atRndmSvc.retrieve());
  CLHEP::HepRandomEngine* collEng(m_atRndmSvc->GetEngine(m_randomStreamName.value()));
  if( 0 == collEng )
    {
      ATH_MSG_ERROR (  "can not get random stream " << m_randomStreamName.value() );
      return StatusCode::FAILURE;
    }
 
  //setup distribution to read a new event every downscaleFactor accesses
  //notice how we pass collEng by reference. If ! CLHEP will take ownership...
  m_readEventRand = new CLHEP::RandFlat(*(collEng),
                                        0.0, double(m_readDownscale));
 
  // select collision distribution functions
  if (m_collDistrName.value() == "Fixed")
    {
      m_f_collDistr = std::bind(&BkgStreamsCache::collXing, this);
      using namespace std::placeholders;
      if(m_ignoreBM.value())
        {
          m_f_numberOfBackgroundForBunchCrossing = std::bind(&BkgStreamsCache::numberOfBkgForBunchCrossingIgnoringBeamIntensity, this, _1);
        }
      else
        {
          m_f_numberOfBackgroundForBunchCrossing = std::bind(&BkgStreamsCache::numberOfCavernBkgForBunchCrossing, this, _1);
        }
      return StatusCode::SUCCESS;
    }
  if (m_collDistrName.value() == "Poisson")
    {
      //pass collEng by reference. If Not CLHEP will take ownership...
      m_collXingPoisson = new CLHEP::RandPoisson(*(collEng), m_collXing);
      // m_f_collDistr will call m_collXingPoisson->fire(m_collXing)  USED TO BE boost::bind(&CLHEP::RandPoisson::fire, m_collXingPoisson);
      m_f_collDistr = std::bind(&BkgStreamsCache::collXingPoisson, this);
      using namespace std::placeholders;
      if(m_ignoreBM.value())
        {
          m_f_numberOfBackgroundForBunchCrossing = std::bind(&BkgStreamsCache::numberOfBkgForBunchCrossingIgnoringBeamIntensity, this, _1);
        }
      else
        {
          m_f_numberOfBackgroundForBunchCrossing = std::bind(&BkgStreamsCache::numberOfBkgForBunchCrossingDefaultImpl, this, _1);
        }
      return StatusCode::SUCCESS;
    }
  ATH_MSG_ERROR (  m_collDistrName
                   << " is not a know collision distribution function" );
  return StatusCode::FAILURE;
}

nEvtsXing()

unsigned int BkgStreamsCache::nEvtsXing ( unsigned int iXing ) const

private

Definition at line 277 of file BkgStreamsCache.cxx.

{
  return (iXing + 1 > m_nEvtsXing.size()) ? 0 : m_nEvtsXing[iXing];
}

newEvent()

void BkgStreamsCache::newEvent ( )

finaloverridevirtual

inform cache that we start overlaying a new event

Definition at line 127 of file BkgStreamsCache.cxx.

{
  ATH_MSG_DEBUG (  "newEvent called resetting used event set" );
  unsigned int totEvts(0);
  do {
    totEvts = 0;
    for (unsigned int iXing=0; iXing<m_nXings; ++iXing) {
      totEvts += setNEvtsXing(iXing);
      if (totEvts > m_nStores) {
        ATH_MSG_WARNING ( "newEvent: number of required evts (" << totEvts << ") exceeds number of available stores "
                          << m_nStores << ". Regenerating bkg sequence for this event \n"
                          << " the total number of bkg events may not exceed average by more than 6 sigmas"
                          );
        break;
      }
    }
  } while(totEvts > m_nStores);
  m_usedStreams.assign(m_streams.size(), false);
}

nextEvent()

const xAOD::EventInfo * BkgStreamsCache::nextEvent ( bool isCentralBunchCrossing )

private

get next bkg event from cache

Definition at line 147 of file BkgStreamsCache.cxx.

{
  const xAOD::EventInfo* pNextEvt(nullptr);
  StreamVector::size_type iS(0);
  do {
    iS = (StreamVector::size_type)m_chooseEventRand->fire();
  } while (alreadyInUse(iS));
 
  //set current store to iS
  m_cursor = m_streams.begin();
  std::advance(m_cursor, iS);
 
  ATH_MSG_DEBUG (  "using store " << iS );
  PileUpStream* pCurrStream(current());
  if (0 != pCurrStream) {
    pCurrStream->store().makeCurrent();
    //read a new event every downscaleFactor accesses
    //force reading of new event if the event is being used for in-time pile-up
    //FIXME a more careful strategy would have the PileUpStreams knowing if
    //they have been used for the central bunch-crossing already.
    bool readEvent(isCentralBunchCrossing || (m_readEventRand->fire()<1.0));
    pNextEvt = pCurrStream->nextEventPre( readEvent );
  }
  return pNextEvt;
}

nextEvent_passive()

StatusCode BkgStreamsCache::nextEvent_passive ( bool isCentralBunchCrossing )

private

as nextEvent except don't actually load anything

Definition at line 174 of file BkgStreamsCache.cxx.

{
  StreamVector::size_type iS(0);
  do {
    iS = (StreamVector::size_type)m_chooseEventRand->fire();
  } while (alreadyInUse(iS));
 
  //set current store to iS
  m_cursor = m_streams.begin();
  std::advance(m_cursor, iS);
 
  ATH_MSG_DEBUG (  "using store " << iS );
  PileUpStream* pCurrStream(current());
  if (0 != pCurrStream) {
    pCurrStream->store().makeCurrent();
    //read a new event every downscaleFactor accesses
    //force reading of new event if the event is being used for in-time pile-up
    //FIXME a more careful strategy would have the PileUpStreams knowing if
    //they have been used for the central bunch-crossing already.
    bool readEvent(isCentralBunchCrossing || (m_readEventRand->fire()<1.0));
    if(pCurrStream->nextEventPre_Passive(readEvent)) return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

nStores()

virtual unsigned int BkgStreamsCache::nStores ( ) const

inlinefinaloverridevirtual

how many stores in this cache

Definition at line 77 of file BkgStreamsCache.h.

{ return m_nStores; }

numberOfBkgForBunchCrossingDefaultImpl()

unsigned int BkgStreamsCache::numberOfBkgForBunchCrossingDefaultImpl

(

unsigned int

iXing

)

const

Definition at line 286 of file BkgStreamsCache.cxx.

{
  return static_cast<unsigned int>(m_beamInt->normFactor(iXing-m_zeroXing)*static_cast<float>(m_f_collDistr()));
}

numberOfBkgForBunchCrossingIgnoringBeamIntensity()

unsigned int BkgStreamsCache::numberOfBkgForBunchCrossingIgnoringBeamIntensity

(

unsigned int

iXing

)

const

meant to be used via m_f_numberOfBackgroundForBunchCrossing

Definition at line 282 of file BkgStreamsCache.cxx.

{
  return m_f_collDistr();
}

numberOfCavernBkgForBunchCrossing()

unsigned int BkgStreamsCache::numberOfCavernBkgForBunchCrossing

(

unsigned int

iXing

)

const

Definition at line 290 of file BkgStreamsCache.cxx.

{
  return static_cast<unsigned int>(m_beamInt->normFactor(iXing-m_zeroXing)>0.0)*m_f_collDistr();
}

PileUpEventTypeHandler()

void BkgStreamsCache::PileUpEventTypeHandler ( Gaudi::Details::PropertyBase & )

private

Definition at line 42 of file BkgStreamsCache.cxx.

{
   m_pileUpEventType = xAOD::EventInfo::PileUpInt2Type( m_pileUpEventTypeProp.value() );
}

resetEvtsPerXingScaleFactor()

void BkgStreamsCache::resetEvtsPerXingScaleFactor ( float sf )

finaloverridevirtual

reset scale factor at new run/lumiblk

Definition at line 116 of file BkgStreamsCache.cxx.

{
  if (!m_ignoreSF) m_collXingSF = sf;
}

setNEvtsXing()

unsigned int BkgStreamsCache::setNEvtsXing ( unsigned int iXing )

private

Definition at line 295 of file BkgStreamsCache.cxx.

{
  if (iXing + 1 > m_nEvtsXing.size())  m_nEvtsXing.resize(2 * iXing + 1);
  unsigned int nEvts(m_f_numberOfBackgroundForBunchCrossing(iXing));
  //this is done mainly to handle the case in which original and backround
  //events belong to the same stream. Of course we do not want m_nEvtsXing[m_zeroXing]<0
  if ((int)iXing==m_zeroXing)
    {
      unsigned int subValue(m_subtractBC0.value());
      while (nEvts<subValue) nEvts = m_f_numberOfBackgroundForBunchCrossing(iXing);
      nEvts -= subValue;
#ifndef NDEBUG
      ATH_MSG_VERBOSE ( "Subtracted " <<   m_subtractBC0.value()
                        << " events from BC=0 Xing " << iXing << " - Events at BC=0 "
                        << nEvts
                        );
#endif
    }
  ATH_MSG_VERBOSE ( "Will pile-up " <<  nEvts
                    << " events for BCID " << iXing );
  m_nEvtsXing[iXing] = nEvts;
  return nEvts;
}

setup()

StatusCode BkgStreamsCache::setup ( int firstXing, unsigned int nXings, unsigned int firstStore, IBeamIntensity * iBM )

finaloverridevirtual

Parameters

nXings	bunch Xings to be processed
firstStore	id of first store in cache

Definition at line 48 of file BkgStreamsCache.cxx.

{
  assert (0 < nXings);
  m_nXings = nXings;
  m_zeroXing = -firstXing;
  if (m_zeroXing >= (int)nXings) m_zeroXing = -99;
  m_beamInt = (m_ignoreBM.value() ? 0 : iBM);
  float largestElement( ( m_ignoreBM.value() || m_collDistrName.value() == "Fixed" ) ? 1.0 : m_beamInt->largestElementInPattern() );
  //ceil (cmath) rounds up to the nearest integer ceil(1.5)= 2
  float occupiedCrossings = ceil(static_cast<float>(m_nXings) * m_occupationFraction);
  m_nStores = static_cast<unsigned int>(ceil( m_collXing * occupiedCrossings * largestElement));
  if (m_collDistrName.value() == "Poisson")
    {
      //allow for fluctuations in # of overlaid events
      m_nStores += static_cast<unsigned int>(6.0 * sqrt(static_cast<float>(m_nStores)));
    }
 
  //get bkg selectors, stores and iterators
  ATH_MSG_DEBUG ( "Set up " << m_nStores << " stores" );
 
  m_nEvtsXing.reserve(m_nStores);
  m_streams.reserve(m_nStores);
  m_usedStreams.reserve(m_nStores);
  m_usedStreams.assign(m_nStores, false);
 
  const std::string& selecName(m_selecName.name());
  for (unsigned int i=0; i < m_nStores; ++i)
    {
      std::stringstream bufName;
      bufName << "BkgEvent_" << i + firstStore;
      const std::string& streamName(bufName.str());
      try
        {
          m_streams.emplace_back(streamName,serviceLocator(),selecName);
        }
      catch (const std::runtime_error& e)
        {
          ATH_MSG_ERROR ( "Exception thrown while creating PileUpStream "
                          << streamName << " : " << e.what() );
          return StatusCode::FAILURE;
        }
 
      if(!(m_streams.back().setupStore()))
        {
          ATH_MSG_ERROR ( "Can not setup bkg evt store for stream "
                          << streamName );
          return StatusCode::FAILURE;
        }
    }
  m_cursor = m_streams.begin();
 
  CLHEP::HepRandomEngine* collEng(m_atRndmSvc->GetEngine(m_randomStreamName.value()));
  if( !collEng )
    {
      ATH_MSG_ERROR (  "can not get random stream " << m_randomStreamName.value() );
      return StatusCode::FAILURE;
    }
  //setup generator to pickup an event store at random from the cache
  //notice how we pass collEng by reference. If ! CLHEP will take ownership...
  m_chooseEventRand = new CLHEP::RandFlat(*(collEng),
                                          0.0, double(m_nStores));
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_atRndmSvc

ServiceHandle<IAtRndmGenSvc> BkgStreamsCache::m_atRndmSvc

private

Initial value:

{this, "RndmGenSvc", "AtRndmGenSvc",
    "IAtRndmGenSvc controlling the distribution of bkg events/xing"}

Definition at line 108 of file BkgStreamsCache.h.

                                          {this, "RndmGenSvc", "AtRndmGenSvc",
    "IAtRndmGenSvc controlling the distribution of bkg events/xing"};

m_beamInt

IBeamIntensity* BkgStreamsCache::m_beamInt {nullptr}

private

pointer to the IBeamIntensity distribution tool

Definition at line 167 of file BkgStreamsCache.h.

{nullptr};

m_chooseEventRand

CLHEP::RandFlat* BkgStreamsCache::m_chooseEventRand {nullptr}

private

pickup an event store at random from the cache

Definition at line 153 of file BkgStreamsCache.h.

{nullptr};

m_collDistrName

Gaudi::Property<std::string> BkgStreamsCache::m_collDistrName

private

Initial value:

{this, "CollDistribution", "Poisson",
    "nEvts/Xings can be either Fixed at CollPerXing or Poisson with average CollPerXing"}

Definition at line 117 of file BkgStreamsCache.h.

                                          {this, "CollDistribution", "Poisson",
    "nEvts/Xings can be either Fixed at CollPerXing or Poisson with average CollPerXing"};

m_collXing

Gaudi::Property<float> BkgStreamsCache::m_collXing

private

Initial value:

{this, "CollPerXing", 23.0,
    "(average) number of collisions per beam crossing"}

Definition at line 111 of file BkgStreamsCache.h.

                                 {this, "CollPerXing", 23.0,
    "(average) number of collisions per beam crossing"};

m_collXingPoisson

CLHEP::RandPoisson* BkgStreamsCache::m_collXingPoisson {nullptr}

private

set number of collisions per bunch crossing (if Poisson distribution chosen)

Definition at line 155 of file BkgStreamsCache.h.

{nullptr};

m_collXingSF

float BkgStreamsCache::m_collXingSF {1.0}

private

float scaling number of collisions per bunch crossing

Definition at line 163 of file BkgStreamsCache.h.

{1.0};

m_cursor

StreamVector::iterator BkgStreamsCache::m_cursor {}

private

Definition at line 99 of file BkgStreamsCache.h.

{};

m_f_collDistr

std::function< long() > BkgStreamsCache::m_f_collDistr

private

function returning the number of collisions per bunch crossing before bunch structure modulation

Definition at line 158 of file BkgStreamsCache.h.

m_f_numberOfBackgroundForBunchCrossing

std::function< unsigned int(unsigned int) > BkgStreamsCache::m_f_numberOfBackgroundForBunchCrossing

private

function returning the number of bkg events per bunch crossing after bunch structure modulation

Definition at line 161 of file BkgStreamsCache.h.

m_forceReadForBC0

Gaudi::Property<bool> BkgStreamsCache::m_forceReadForBC0

private

Initial value:

{this, "ForceReadForBC0", true,
    "Force events used in the central bunch crossing to be refreshed"}

Definition at line 145 of file BkgStreamsCache.h.

                                       {this, "ForceReadForBC0", true,
    "Force events used in the central bunch crossing to be refreshed"};

m_ignoreBM

Gaudi::Property<bool> BkgStreamsCache::m_ignoreBM

private

Initial value:

{this, "IgnoreBeamInt", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam intensity "
    "tool in setting the number of events per xing."}

Definition at line 137 of file BkgStreamsCache.h.

                                {this, "IgnoreBeamInt", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam intensity "
    "tool in setting the number of events per xing."};

m_ignoreSF

Gaudi::Property<bool> BkgStreamsCache::m_ignoreSF

private

Initial value:

{this, "IgnoreBeamLumi", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam luminosity "
    "tool in setting the number of events per xing."}

Definition at line 141 of file BkgStreamsCache.h.

                                {this, "IgnoreBeamLumi", false,
    "Default=False, set to True to ignore the PileUpEventLoopMgr beam luminosity "
    "tool in setting the number of events per xing."};

m_nEvtsXing

std::vector<unsigned int> BkgStreamsCache::m_nEvtsXing

private

Definition at line 104 of file BkgStreamsCache.h.

m_nStores

unsigned int BkgStreamsCache::m_nStores {0}

private

Definition at line 103 of file BkgStreamsCache.h.

{0};

m_nXings

unsigned int BkgStreamsCache::m_nXings {0}

private

Definition at line 102 of file BkgStreamsCache.h.

{0};

m_occupationFraction

Gaudi::Property<float> BkgStreamsCache::m_occupationFraction

private

Initial value:

{this, "OccupationFraction", 1.0,
    "The maximum fraction of bunch-crossings which will be occupied."}

Definition at line 114 of file BkgStreamsCache.h.

                                           {this, "OccupationFraction", 1.0,
    "The maximum fraction of bunch-crossings which will be occupied."};

m_pileUpEventType

xAOD::EventInfo::PileUpType BkgStreamsCache::m_pileUpEventType

private

the type of events in this cache

Definition at line 149 of file BkgStreamsCache.h.

m_pileUpEventTypeProp

Gaudi::CheckedProperty<unsigned short> BkgStreamsCache::m_pileUpEventTypeProp

private

Initial value:

{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)"}

Definition at line 127 of file BkgStreamsCache.h.

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

m_randomStreamName

Gaudi::Property<std::string> BkgStreamsCache::m_randomStreamName

private

Initial value:

{this, "RndmStreamName", "PileUpCollXingStream",
    "IAtRndmGenSvc stream used as engine for our various random distributions, including the CollPerXing one "}

Definition at line 124 of file BkgStreamsCache.h.

                                             {this, "RndmStreamName", "PileUpCollXingStream",
    "IAtRndmGenSvc stream used as engine for our various random distributions, including the CollPerXing one "};

m_readDownscale

Gaudi::Property<float> BkgStreamsCache::m_readDownscale

private

Initial value:

{this, "ReadDownscaleFactor", 150,
    "read one event every downscaleFactor accesses (asymptotically -> number of times "
    "an event in the cache will be reused)"}

Definition at line 120 of file BkgStreamsCache.h.

                                      {this, "ReadDownscaleFactor", 150,
    "read one event every downscaleFactor accesses (asymptotically -> number of times "
    "an event in the cache will be reused)"};

m_readEventRand

CLHEP::RandFlat* BkgStreamsCache::m_readEventRand {nullptr}

private

read a new event every downscaleFactor accesses

Definition at line 151 of file BkgStreamsCache.h.

{nullptr};

m_selecName

ServiceHandle<IEvtSelector> BkgStreamsCache::m_selecName {this, "EventSelector", "FakeEventSelector"}

private

Definition at line 106 of file BkgStreamsCache.h.

{this, "EventSelector", "FakeEventSelector"};

m_streams

StreamVector BkgStreamsCache::m_streams

private

Definition at line 100 of file BkgStreamsCache.h.

m_subtractBC0

Gaudi::Property<unsigned short> BkgStreamsCache::m_subtractBC0

private

Initial value:

{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"}

Definition at line 133 of file BkgStreamsCache.h.

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

m_usedStreams

std::vector<bool> BkgStreamsCache::m_usedStreams

private

Definition at line 101 of file BkgStreamsCache.h.

m_zeroXing

int BkgStreamsCache::m_zeroXing {-1}

private

offset of BC=0 xing

Definition at line 165 of file BkgStreamsCache.h.

{-1};

---

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

• BkgStreamsCache.h
• BkgStreamsCache.cxx