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 More...
virtual void	resetEvtsPerXingScaleFactor (float sf) override final
	reset scale factor at new run/lumiblk More...
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. More...
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. More...
virtual unsigned int	nStores () const override final
	how many stores in this cache More...
long	collXing ()
	meant to be used (mainly) via m_f_collDistr More...
long	collXingPoisson ()
unsigned int	numberOfBkgForBunchCrossingIgnoringBeamIntensity (unsigned int iXing) const
	meant to be used via m_f_numberOfBackgroundForBunchCrossing More...
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 More...
StatusCode	nextEvent_passive (bool isCentralBunchCrossing)
	as nextEvent except don't actually load anything More...
PileUpStream *	current ()
	get current (last asked) stream More...
unsigned int	setNEvtsXing (unsigned int iXing)
unsigned int	nEvtsXing (unsigned int iXing) const
bool	alreadyInUse (StreamVector::size_type iStream)

Private Attributes
StreamVector::iterator	m_cursor
StreamVector	m_streams
std::vector< bool >	m_usedStreams
unsigned int	m_nXings
unsigned int	m_nStores
std::vector< unsigned int >	m_nEvtsXing

Properties
Gaudi::Property< float >	m_collXing
Gaudi::Property< float >	m_occupationFraction
	The maximum fraction of bunch-crossings which will be occupied. More...
Gaudi::Property< std::string >	m_collDistrName
	select collision distribution More...
ServiceHandle< IEvtSelector >	m_selecName
Gaudi::Property< float >	m_readDownscale
	read downscale factor (average number of times a min bias is reused) More...
ServiceHandle< IAtRndmGenSvc >	m_atRndmSvc
	IAtRndmGenSvc controlling the distribution of bkg events per bunch crossing. More...
Gaudi::Property< std::string >	m_randomStreamName
	the IAtRndmGenSvc stream to generate number of bkg events per bunch crossing More...
Gaudi::CheckedProperty< unsigned short >	m_pileUpEventTypeProp
	the type of events in this cache More...
xAOD::EventInfo::PileUpType	m_pileUpEventType
	the type of events in this cache More...
Gaudi::Property< unsigned short >	m_subtractBC0
	subtract from number of events at bunch xing = 0 More...
Gaudi::Property< bool >	m_ignoreBM
	ignore the PileUpEventLoopMgr beam intensity tool More...
CLHEP::RandFlat *	m_readEventRand
	read a new event every downscaleFactor accesses More...
CLHEP::RandFlat *	m_chooseEventRand
	pickup an event store at random from the cache More...
CLHEP::RandPoisson *	m_collXingPoisson
	set number of collisions per bunch crossing (if Poisson distribution chosen) More...
std::function< long() >	m_f_collDistr
	function returning the number of collisions per bunch crossing before bunch structure modulation More...
std::function< unsigned int(unsigned int) >	m_f_numberOfBackgroundForBunchCrossing
	function returning the number of bkg events per bunch crossing after bunch structure modulation More...
float	m_collXingSF
	float scaling number of collisions per bunch crossing More...
Gaudi::Property< bool >	m_ignoreSF
	bool apply scaling number of collisions per bunch crossing ? More...
int	m_zeroXing
	offset of BC=0 xing More...
IBeamIntensity *	m_beamInt
	pointer to the IBeamIntensity distribution tool More...
Gaudi::Property< bool >	m_forceReadForBC0
	Force events used in the central bunch crossing to be refreshed. More...
void	PileUpEventTypeHandler (Gaudi::Details::PropertyBase &)

Detailed Description

In-memory cache for pileup events.

Definition at line 36 of file BkgStreamsCache.h.

Member Typedef Documentation

StreamVector

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

private

Definition at line 98 of file BkgStreamsCache.h.

Constructor & Destructor Documentation

BkgStreamsCache()

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

Definition at line 28 of file BkgStreamsCache.cxx.

  : base_class( type, name, parent )
  , m_nXings(0)
  , m_nStores(0)
  , m_collXing(23.0)
  , m_occupationFraction(1.0)
  , m_collDistrName("Poisson")
  , m_selecName("FakeEventSelector", name)
  , m_readDownscale(150)
  , m_atRndmSvc("AtRndmGenSvc", name)
  , m_randomStreamName("PileUpCollXingStream")
  , m_pileUpEventTypeProp(0)
  , m_pileUpEventType(xAOD::EventInfo::PileUpType::Signal)
  , m_subtractBC0(0)
  , m_ignoreBM(false)
  , m_readEventRand(nullptr)
  , m_chooseEventRand(nullptr)
  , m_collXingPoisson(nullptr)
  , m_f_collDistr(0)
  , m_f_numberOfBackgroundForBunchCrossing(0)
  , m_collXingSF(1.0)
  , m_ignoreSF(false)
  , m_zeroXing(-1)
  , m_beamInt(nullptr)
  , m_forceReadForBC0(true)
{
  declareProperty("CollPerXing", m_collXing, "(average) number of collisions per beam crossing");
  declareProperty("OccupationFraction", m_occupationFraction, "The maximum fraction of bunch-crossings which will be occupied.");
  declareProperty("CollDistribution", m_collDistrName, "nEvts/Xings can be either Fixed at CollPerXing or Poisson with average CollPerXing");
  declareProperty("EventSelector", m_selecName);
  declareProperty("PileUpEventType", m_pileUpEventTypeProp, "Type of the pileup events in this cache: 0:Signal, 1:MinimumBias, 2:Cavern, 3:HaloGas, 4:ZeroBias. Default=0 (Signal, Invalid)");
  declareProperty("ReadDownscaleFactor", m_readDownscale, "read one event every downscaleFactor accesses (asymptotically -> number of times an event in the cache will be reused)");
  declareProperty("RndmGenSvc", m_atRndmSvc, "IAtRndmGenSvc controlling the distribution of bkg events/xing");
  declareProperty("RndmStreamName", m_randomStreamName, "IAtRndmGenSvc stream used as engine for our various random distributions, including the CollPerXing one ");
  declareProperty("SubtractBC0", m_subtractBC0, "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_pileUpEventTypeProp.verifier().setUpper(xAOD::EventInfo::PileUp_NTYPES-2);
  m_pileUpEventTypeProp.declareUpdateHandler(&BkgStreamsCache::PileUpEventTypeHandler, this);
  declareProperty("IgnoreBeamInt", m_ignoreBM, "Default=False, set to True to ignore the PileUpEventLoopMgr beam intensity tool in setting the number of events per xing.");
  declareProperty("IgnoreBeamLumi", m_ignoreSF, "Default=False, set to True to ignore the PileUpEventLoopMgr beam luminosity tool in setting the number of events per xing.");
  declareProperty("ForceReadForBC0",m_forceReadForBC0,"Force events used in the central bunch crossing to be refreshed");
}

~BkgStreamsCache()

BkgStreamsCache::~BkgStreamsCache ( )

virtual

Definition at line 72 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 365 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) );
      // temporary EI instance to modify BCID before adding the EI
      xAOD::EventInfo   tmp_ei( *pBkgEvent );
      tmp_ei.setBCID( BCID );
      tmp_ei.setEvtStore(pBkgStore);
      // add subevent
      addSubEvent( overEvent, &tmp_ei, t0BinCenter, m_pileUpEventType, subEvCnt, c_pileUpEventInfoContName );
               
#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 357 of file BkgStreamsCache.cxx.

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

alreadyInUse()

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

private

Definition at line 237 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 81 of file BkgStreamsCache.h.

{ return m_collXing; }

collXingPoisson()

long BkgStreamsCache::collXingPoisson

(

)

Definition at line 159 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 249 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 426 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 256 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 315 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 165 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 185 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 212 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 78 of file BkgStreamsCache.h.

{ return m_nStores; }

numberOfBkgForBunchCrossingDefaultImpl()

unsigned int BkgStreamsCache::numberOfBkgForBunchCrossingDefaultImpl

(

unsigned int

iXing

)

const

Definition at line 324 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 320 of file BkgStreamsCache.cxx.

{
  return m_f_collDistr();
}

numberOfCavernBkgForBunchCrossing()

unsigned int BkgStreamsCache::numberOfCavernBkgForBunchCrossing

(

unsigned int

iXing

)

const

Definition at line 328 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 80 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 154 of file BkgStreamsCache.cxx.

{
  if (!m_ignoreSF) m_collXingSF = sf;
}

setNEvtsXing()

unsigned int BkgStreamsCache::setNEvtsXing ( unsigned int  iXing )

private

Definition at line 333 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 86 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

IAtRndmGenSvc controlling the distribution of bkg events per bunch crossing.

Definition at line 119 of file BkgStreamsCache.h.

m_beamInt

IBeamIntensity* BkgStreamsCache::m_beamInt

private

pointer to the IBeamIntensity distribution tool

Definition at line 151 of file BkgStreamsCache.h.

m_chooseEventRand

CLHEP::RandFlat* BkgStreamsCache::m_chooseEventRand

private

pickup an event store at random from the cache

Definition at line 135 of file BkgStreamsCache.h.

m_collDistrName

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

private

select collision distribution

Definition at line 114 of file BkgStreamsCache.h.

m_collXing

Gaudi::Property<float> BkgStreamsCache::m_collXing

private

of collisions per bunch crossing (~beam intensity)

Definition at line 110 of file BkgStreamsCache.h.

m_collXingPoisson

CLHEP::RandPoisson* BkgStreamsCache::m_collXingPoisson

private

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

Definition at line 137 of file BkgStreamsCache.h.

m_collXingSF

float BkgStreamsCache::m_collXingSF

private

float scaling number of collisions per bunch crossing

Definition at line 145 of file BkgStreamsCache.h.

m_cursor

StreamVector::iterator BkgStreamsCache::m_cursor

private

Definition at line 100 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 140 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 143 of file BkgStreamsCache.h.

m_forceReadForBC0

Gaudi::Property<bool> BkgStreamsCache::m_forceReadForBC0

private

Force events used in the central bunch crossing to be refreshed.

Definition at line 153 of file BkgStreamsCache.h.

m_ignoreBM

Gaudi::Property<bool> BkgStreamsCache::m_ignoreBM

private

ignore the PileUpEventLoopMgr beam intensity tool

Definition at line 130 of file BkgStreamsCache.h.

m_ignoreSF

Gaudi::Property<bool> BkgStreamsCache::m_ignoreSF

private

bool apply scaling number of collisions per bunch crossing ?

Definition at line 147 of file BkgStreamsCache.h.

m_nEvtsXing

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

private

Definition at line 105 of file BkgStreamsCache.h.

m_nStores

unsigned int BkgStreamsCache::m_nStores

private

Definition at line 104 of file BkgStreamsCache.h.

m_nXings

unsigned int BkgStreamsCache::m_nXings

private

Definition at line 103 of file BkgStreamsCache.h.

m_occupationFraction

Gaudi::Property<float> BkgStreamsCache::m_occupationFraction

private

The maximum fraction of bunch-crossings which will be occupied.

Definition at line 112 of file BkgStreamsCache.h.

m_pileUpEventType

xAOD::EventInfo::PileUpType BkgStreamsCache::m_pileUpEventType

private

the type of events in this cache

Definition at line 126 of file BkgStreamsCache.h.

m_pileUpEventTypeProp

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

private

the type of events in this cache

Definition at line 123 of file BkgStreamsCache.h.

m_randomStreamName

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

private

the IAtRndmGenSvc stream to generate number of bkg events per bunch crossing

Definition at line 121 of file BkgStreamsCache.h.

m_readDownscale

Gaudi::Property<float> BkgStreamsCache::m_readDownscale

private

read downscale factor (average number of times a min bias is reused)

Definition at line 117 of file BkgStreamsCache.h.

m_readEventRand

CLHEP::RandFlat* BkgStreamsCache::m_readEventRand

private

read a new event every downscaleFactor accesses

Definition at line 133 of file BkgStreamsCache.h.

m_selecName

ServiceHandle<IEvtSelector> BkgStreamsCache::m_selecName

private

Definition at line 115 of file BkgStreamsCache.h.

m_streams

StreamVector BkgStreamsCache::m_streams

private

Definition at line 101 of file BkgStreamsCache.h.

m_subtractBC0

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

private

subtract from number of events at bunch xing = 0

Definition at line 128 of file BkgStreamsCache.h.

m_usedStreams

std::vector<bool> BkgStreamsCache::m_usedStreams

private

Definition at line 102 of file BkgStreamsCache.h.

m_zeroXing

int BkgStreamsCache::m_zeroXing

private

offset of BC=0 xing

Definition at line 149 of file BkgStreamsCache.h.

---

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

• BkgStreamsCache.h
• BkgStreamsCache.cxx