ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
ZDC_PileUpTool Class Reference

#include <ZDC_PileUpTool.h>

Inheritance diagram for ZDC_PileUpTool:
Collaboration diagram for ZDC_PileUpTool:

Public Member Functions

 ZDC_PileUpTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual StatusCode initialize () override final
 
void initializePbPb2015 ()
 
void initializeLHCf2022 ()
 
void initializePbPb2023 ()
 
virtual StatusCode finalize () override final
 
virtual StatusCode prepareEvent (const EventContext &ctx, const unsigned int nInputEvents) override final
 called before the subevts loop. Not (necessarily) able to access SubEvents More...
 
virtual StatusCode processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
 called for each active bunch-crossing to process current SubEvents bunchXing is in ns More...
 
virtual StatusCode mergeEvent (const EventContext &ctx) override final
 return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing More...
 
virtual StatusCode processAllSubEvents (const EventContext &ctx) override final
 

Private Member Functions

void fillContainer (TimedHitCollection< ZDC_SimFiberHit > &, CLHEP::HepRandomEngine *, xAOD::ZdcModuleContainer *)
 
void fillContainer (const ZDC_SimFiberHit_Collection *, CLHEP::HepRandomEngine *, xAOD::ZdcModuleContainer *)
 
TimedHitCollection< ZDC_SimFiberHit > doZDClightGuideCuts (const ZDC_SimFiberHit_Collection *hitCollection)
 
void createAndStoreWaveform (const ZDC_SimFiberHit &hit, CLHEP::HepRandomEngine *, xAOD::ZdcModuleContainer *)
 
void addEmptyWaveforms (xAOD::ZdcModuleContainer *zdcModuleContainer, CLHEP::HepRandomEngine *rndEngine)
 
std::vector< short unsigned int > generateWaveform (std::shared_ptr< ZDCWaveformSampler > wfSampler, float amplitude, float t0)
 
void SetDumps (bool, bool)
 

Private Attributes

ZDC_SimFiberHit_Collection * m_mergedFiberHitList {}
 
const ZdcID * m_ZdcID
 
std::unique_ptr< xAOD::ZdcModuleContainer > m_ZdcModuleContainer
 
std::unique_ptr< xAOD::ZdcModuleAuxContainer > m_ZdcModuleAuxContainer
 
ServiceHandle< PileUpMergeSvc > m_mergeSvc {this, "mergeSvc", "PileUpMergeSvc", ""}
 
ServiceHandle< IAthRNGSvc > m_randomSvc {this, "RndmSvc", "AthRNGSvc", ""}
 
Gaudi::Property< std::string > m_randomStreamName {this, "RandomStreamName", "ZDCRndEng", ""}
 
SG::ReadHandleKey< ZDC_SimFiberHit_Collection > m_SimFiberHitCollectionKey {this, "ZDC_SimFiberHit_CollectionName", "ZDC_SimFiberHit_Collection"}
 
SG::WriteHandleKey< xAOD::ZdcModuleContainer > m_ZdcModuleContainerName {this, "ZdcModuleContainerName", "ZdcModules"}
 
SG::WriteHandleKey< xAOD::ZdcModuleContainer > m_ZdcSumsContainerName {this, "ZdcSumsContainerName", "ZdcSums"}
 
Gaudi::Property< std::string > m_HitCollectionName
 
Gaudi::Property< std::string > m_outputContainerName
 
Gaudi::Property< std::string > m_configuration {this, "configuration" , "PbPb2023", "Named configuration to be used. Overwrites other properties if used" }
 
Gaudi::Property< int > m_Pedestal {this, "Pedestal" , 100 , "DC offset of the pulse in ADC" }
 
Gaudi::Property< int > m_numTimeBins {this, "MaxTimeBin" , 7 , "The number of time-slices after digitization(Typically 5 or 7)" }
 
Gaudi::Property< double > m_freqMHz {this, "freqMHz" , 40 , "Digitizer frequence in MHz" }
 
Gaudi::Property< double > m_zdct0 {this, "zdct0" , 40 , "Start time of the pulse in the digitization window" }
 
Gaudi::Property< double > m_rpdt0 {this, "rpdt0" , 40 , "Start time of the pulse in the digitization window" }
 
Gaudi::Property< double > m_zdcRiseTime {this, "zdcRiseTime" , 4 , "Rise time of the ZDC pulses" }
 
Gaudi::Property< double > m_zdcFallTime {this, "zdcFallTime" , 0.5 , "Fall time of the ZDC pulses" }
 
Gaudi::Property< double > m_rpdRiseTime {this, "rpdRiseTime" , 4 , "Rise time of the RPD pulses" }
 
Gaudi::Property< double > m_rpdFallTime {this, "rpdFallTime" , 0.5 , "Fall time of the RPD pulses" }
 
Gaudi::Property< double > m_qsfRiseTime {this, "qsfRiseTime" , 4 , "Rise time of the RPD pulses" }
 
Gaudi::Property< double > m_qsfFallTime {this, "qsfFallTime" , 4 , "Rise time of the RPD pulses" }
 
Gaudi::Property< double > m_qsfFilter {this, "qsfFilter" , 4 , "Rise time of the RPD pulses" }
 
Gaudi::Property< float > m_zdcAdcPerPhoton {this, "zdcAdcPerPhoton" , 0.000498 , "ADC counts per detected photon in the ZDCs" }
 
Gaudi::Property< bool > m_LTQuadStepFilt {this, "LTQuadStepFilt" , false , "Use LT Quad Step Filter waveform for ZDC channels" }
 
Gaudi::Property< bool > m_delayChannels {this, "delayChannels" , false , "Include delayed channels in the output" }
 
Gaudi::Property< bool > m_doRPD {this, "doRPD" , false , "Include RPD channels in the output" }
 
Gaudi::Property< bool > m_doBRAN {this, "doBRAN" , false , "Include BRAN channels in the output" }
 
Gaudi::Property< std::vector< float > > m_rpdAdcPerPhoton {this, "rpdAdcPerPhoton", {5.25 , 1.7}, "ADC counts per detected photon in the RPDs"}
 

structors and AlgTool implementation

virtual bool toProcess (int bunchXing) const override
 the method this base class helps implementing More...
 
virtual StatusCode processAllSubEvents (const EventContext &ctx)=0
 dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...
 
virtual bool filterPassed () const override
 dummy implementation of passing filter More...
 
virtual void resetFilter () override
 dummy implementation of filter reset More...
 
Gaudi::Property< int > m_firstXing
 
Gaudi::Property< int > m_lastXing
 
Gaudi::Property< int > m_vetoPileUpTruthLinks
 
bool m_filterPassed {true}
 

Detailed Description

Definition at line 32 of file ZDC_PileUpTool.h.

Constructor & Destructor Documentation

◆ ZDC_PileUpTool()

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

Definition at line 22 of file ZDC_PileUpTool.cxx.

24  :
25  PileUpToolBase(type, name, parent)
26 {
27 }

Member Function Documentation

◆ addEmptyWaveforms()

void ZDC_PileUpTool::addEmptyWaveforms ( xAOD::ZdcModuleContainer *  zdcModuleContainer,
CLHEP::HepRandomEngine *  rndEngine 
)
private

Definition at line 273 of file ZDC_PileUpTool.cxx.

273  {
274  //Initialize bools to keep track of what modules/channels we have seen
275  bool zdcFound[2][4] = {{}};
276  bool rpdFound[2][16] = {{}};
277  bool branFound[2] = {};
278  for(auto module : *zdcModuleContainer){
279  int iside = (module->zdcSide() == -1) ? 0 : 1;
280  int mod = module->zdcModule();
281  if(mod < 4){ //ZDC
282  zdcFound[iside][mod] = true;
283  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found ZDC side " << module->zdcSide() << " module " << mod);
284  }else if(mod == 4){ //RPD
285  rpdFound[iside][module->zdcChannel()] = true;
286  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found RPD side " << module->zdcSide() << " channel " << module->zdcChannel());
287  }else{//BRAN
288  branFound[iside] = true;
289  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found BRAN side " << module->zdcSide() );
290  }
291  }
292 
293  for(int iside : {0,1}){
294  int side = (iside == 0) ? -1 : 1;
295  for(int mod = 0; mod < 4; mod++){
296  if(!zdcFound[iside][mod]){
297  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for ZDC side " << side << " module " << mod);
298  createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, mod, ZdcIDType::SINGLECHANNEL, 0), 0, 0), rndEngine, zdcModuleContainer);
299  }
300  }
301  for(int channel = 0; channel < 16; channel++){
302  if(!rpdFound[iside][channel] && m_doRPD){
303  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for RPD side " << side << " channel " << channel);
304  createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, 4, ZdcIDType::MULTICHANNEL, channel), 0, 0), rndEngine, zdcModuleContainer);
305  }
306  }
307  if(!branFound[iside] && m_doBRAN){
308  ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for BRAN side " << side );
309  createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, 5, ZdcIDType::SINGLECHANNEL, 0), 0, 0), rndEngine, zdcModuleContainer);
310  }
311  }
312 }

◆ createAndStoreWaveform()

void ZDC_PileUpTool::createAndStoreWaveform ( const ZDC_SimFiberHit &  hit,
CLHEP::HepRandomEngine *  rndEngine,
xAOD::ZdcModuleContainer *  zdcModuleContainer 
)
private

Definition at line 364 of file ZDC_PileUpTool.cxx.

364  {
365  Identifier id = hit.getID( );
366  int side = m_ZdcID->side(id);
367  int module = m_ZdcID->module(id);
368  int channel = m_ZdcID->channel(id);
369 
370  if(module == 4 && !m_doRPD) return;
371  if(module == 5 && !m_doBRAN) return;
372 
373  //Here we have to switch the type of the RPD from ACTIVE to MULTICHANNEL
374  //TODO: Either change the channel numbering in the geometry, or the analysis
375  if(module == 4) id = m_ZdcID->channel_id(side,module,ZdcIDType::MULTICHANNEL,channel);
376 
377  //Create a new ZdcModule to store the waveforms
378  xAOD::ZdcModule* zdc = new xAOD::ZdcModule();
379  zdcModuleContainer->push_back(xAOD::ZdcModuleContainer::unique_type(zdc));
380  zdcModuleContainer->back()->setZdcId(id.get_identifier32().get_compact());
381  zdcModuleContainer->back()->setZdcSide(side);
382  zdcModuleContainer->back()->setZdcModule(module);
383  zdcModuleContainer->back()->setZdcType(m_ZdcID->type(id));
384  zdcModuleContainer->back()->setZdcChannel(channel);
385 
386  ATH_MSG_DEBUG( "Digitizing Side " << side <<
387  " Module " << module <<
388  " Channel " << channel <<
389  ", whith " << hit.getNPhotons() << " photons" );
390 
391  uint iSide = (side == -1) ? 0 : 1;
392  float amplitude = 0, t0 = 0;
393  bool doHighGain = true;
394  std::shared_ptr<ZDCWaveformBase> waveformPtr;
395  std::shared_ptr<ZDCWaveformSampler> wfSampler;
396 
397  if(module < 4){//It's a ZDC channel
398  amplitude = CLHEP::RandPoissonQ::shoot(rndEngine, hit.getNPhotons())*m_zdcAdcPerPhoton;
399 
400  if(m_LTQuadStepFilt){
401  waveformPtr = std::make_shared<ZDCWaveformLTLinStep>("zdc",m_qsfRiseTime,m_qsfFallTime,m_qsfFilter);
402  }else{
403  waveformPtr = std::make_shared<ZDCWaveformFermiExp>("zdc",m_zdcRiseTime,m_zdcFallTime);
404  }
405  wfSampler = std::make_shared<ZDCWaveformSampler>(m_freqMHz, 0, m_numTimeBins, 12, m_Pedestal, waveformPtr);
406  t0 = m_zdct0;
407 
408  }else{ //It's an RPD channel
409  // ATH_MSG_INFO("Digitizing RPD " << side << ", channel " << channel << " with " << hit.getNPhotons() << " and " << m_rpdAdcPerPhoton[iSide] << " amplification");
410  amplitude = CLHEP::RandPoissonQ::shoot(rndEngine, hit.getNPhotons())*m_rpdAdcPerPhoton[iSide];
411  waveformPtr = std::make_shared<ZDCWaveformFermiExp>("rpd",m_rpdRiseTime,m_rpdFallTime);
412  wfSampler = std::make_shared<ZDCWaveformSampler>(m_freqMHz, 0, m_numTimeBins, 12, m_Pedestal, waveformPtr);
413  t0 = m_rpdt0;
414  doHighGain = false;
415  }
416 
417  //Record the number of photons that lead to this waveform
418  SG::Accessor<unsigned int> nPhotonsAcc ("nPhotons");
419  nPhotonsAcc (*zdc) = hit.getNPhotons();
420 
421  //Generate in time waveforms
422  zdc->setWaveform("g0data", generateWaveform(wfSampler, amplitude, t0));
423  if(doHighGain) zdc->setWaveform("g1data", generateWaveform(wfSampler, 10*amplitude, t0));
424 
425  //Generate delayed waveforms
426  if(m_delayChannels){
427  float timeBinWidth = 1000.0/m_freqMHz;
428  zdc->setWaveform("g0d1data", generateWaveform(wfSampler, 10*amplitude, t0+timeBinWidth/2));
429  if(doHighGain) zdc->setWaveform("g1d1data", generateWaveform(wfSampler, 10*amplitude, t0+timeBinWidth/2));
430  }
431 
432 }

◆ doZDClightGuideCuts()

TimedHitCollection< ZDC_SimFiberHit > ZDC_PileUpTool::doZDClightGuideCuts ( const ZDC_SimFiberHit_Collection *  hitCollection)
private

Definition at line 314 of file ZDC_PileUpTool.cxx.

314  {
315 
316  ZDC_SimFiberHit* newHits[2][4] = {{nullptr}};
317  ZDC_SimFiberHit_Collection* newCollection = new ZDC_SimFiberHit_Collection("ZDC_SimFiberHit_Collection_Temp");
318 
319  for(ZDC_SimFiberHit hit : *hitCollection){
320  Identifier id = hit.getID();
321  //Translate side from -1,1 to 0,1 to index ZDC hits
322  int side = (m_ZdcID->side( id ) < 0 ) ? 0 : 1;
323  int module = m_ZdcID->module( id );
324 
325  //ZDCs are module 0-3, just insert this hit unmodified and move on
326  if(module > 3){
327  newCollection->Insert(hit);
328  continue;
329  }
330 
331  //TODO: Implement a method to get the efficiency of this location to multiply hit.getNphotons() and hit.getEdep()
332  //based on the channel retrieved by m_ZdcID->channel( id ) and some efficiency map
333  float efficiency = 1.0; //For now we will just use 100% efficiency
334 
335  if(!newHits[side][module]){
336  //The module hasn't been seen yet, create a new hit with values modified by the efficiency factor
337  //The ID is modified because we initially used channel to denote the position of the rods for these efficiency cuts
338  //Now that that's done, we make sure the type is SINGLECHANNEL and the channel is 0
339  newHits[side][module] = new ZDC_SimFiberHit(m_ZdcID->channel_id(m_ZdcID->side(id), module, ZdcIDType::SINGLECHANNEL, 0), efficiency * hit.getNPhotons(), efficiency * hit.getEdep());
340  }else{
341  //The module has been seen, add the photons and energy from this new hit to it
342  newHits[side][module]->Add( efficiency*hit.getNPhotons(), efficiency*hit.getEdep());
343  }
344  }//end loop over hits
345 
346  for(int side : {0,1}){
347  for(int module = 0; module < 4; module++){
348  //Make sure the hit exists before attempting to insert it
349  //If it doesn't we will take care of this module in addEmptyWaveforms
350  if(newHits[side][module]){
351  newCollection->Insert(*(newHits[side][module]));
352  }
353  }
354  }
355 
356  //Now insert one hit per detector in the new collection
357  TimedHitCollection<ZDC_SimFiberHit> newTimedCollection;
358  newTimedCollection.insert(0.0, newCollection);
359 
360  return newTimedCollection;
361 }

◆ fillContainer() [1/2]

void ZDC_PileUpTool::fillContainer ( const ZDC_SimFiberHit_Collection *  ZDC_SimFiberHit_Collection,
CLHEP::HepRandomEngine *  rndEngine,
xAOD::ZdcModuleContainer *  zdcModuleContainer 
)
private

Definition at line 263 of file ZDC_PileUpTool.cxx.

263  {
264  ZDC_SimFiberHit_ConstIterator it = ZDC_SimFiberHit_Collection->begin();
265  ZDC_SimFiberHit_ConstIterator itend = ZDC_SimFiberHit_Collection->end();
266 
267  for (; it != itend; ++it) {
268  createAndStoreWaveform(*it, rndEngine, zdcModuleContainer);
269  }
270  addEmptyWaveforms(zdcModuleContainer, rndEngine);
271 }

◆ fillContainer() [2/2]

void ZDC_PileUpTool::fillContainer ( TimedHitCollection< ZDC_SimFiberHit > &  thpczdc,
CLHEP::HepRandomEngine *  rndEngine,
xAOD::ZdcModuleContainer *  zdcModuleContainer 
)
private

Definition at line 253 of file ZDC_PileUpTool.cxx.

253  {
254  TimedHitCollection<ZDC_SimFiberHit> thpc = thpczdc;
255  TimedHitCollection<ZDC_SimFiberHit>::const_iterator i, e, it;
256  while (thpc.nextDetectorElement(i, e)) for (it = i; it != e; ++it) {
257  createAndStoreWaveform(*(*it), rndEngine, zdcModuleContainer);
258  }
259  addEmptyWaveforms(zdcModuleContainer, rndEngine);
260 }

◆ filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const
inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

49 { return m_filterPassed; }

◆ finalize()

virtual StatusCode ZDC_PileUpTool::finalize ( )
inlinefinaloverridevirtual

Definition at line 44 of file ZDC_PileUpTool.h.

44 { return StatusCode::SUCCESS; }

◆ generateWaveform()

std::vector< short unsigned int > ZDC_PileUpTool::generateWaveform ( std::shared_ptr< ZDCWaveformSampler >  wfSampler,
float  amplitude,
float  t0 
)
private

Definition at line 434 of file ZDC_PileUpTool.cxx.

434  {
435  std::vector<unsigned int> wf = wfSampler->Generate(amplitude, t0);
436  std::vector<short unsigned int> retVal;
437  for(uint sample = 0; sample < wf.size(); sample++){
438  retVal.push_back(wf[sample]);
439  }
440  return retVal;
441 }

◆ initialize()

StatusCode ZDC_PileUpTool::initialize ( )
finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 29 of file ZDC_PileUpTool.cxx.

29  {
30 
31  ATH_MSG_DEBUG ( "ZDC_PileUpTool::initialize() called" );
32 
33  const ZdcID* zdcId = nullptr;
34  if (detStore()->retrieve( zdcId ).isFailure() ) {
35  ATH_MSG_ERROR("execute: Could not retrieve ZdcID object from the detector store");
36  return StatusCode::FAILURE;
37  }
38  else {
39  ATH_MSG_DEBUG("execute: retrieved ZdcID");
40  }
41  m_ZdcID = zdcId;
42 
43  ATH_CHECK(m_randomSvc.retrieve());
44  ATH_MSG_DEBUG ( "Retrieved RandomNumber Service" );
45 
46  ATH_CHECK(m_SimFiberHitCollectionKey.initialize());
47  ATH_CHECK(m_ZdcModuleContainerName.initialize());
48  ATH_CHECK(m_ZdcSumsContainerName.initialize());
49 
50  ATH_MSG_INFO("ZDC_PileUpTool configuration = " << m_configuration);
51 
52  if(m_configuration == "PbPb2015"){
53  initializePbPb2015();
54  }else if(m_configuration == "LHCf2022"){
55  initializeLHCf2022();
56  }else if(m_configuration == "PbPb2023"){
57  initializePbPb2023();
58  }
59 
60  m_mergedFiberHitList = new ZDC_SimFiberHit_Collection("mergedFiberHitList");
61 
62  return StatusCode::SUCCESS;
63 }

◆ initializeLHCf2022()

void ZDC_PileUpTool::initializeLHCf2022 ( )

Definition at line 80 of file ZDC_PileUpTool.cxx.

80  {
81 
82  m_Pedestal = 100;
83  m_numTimeBins = 24;
84  m_freqMHz = 320;
85  m_delayChannels = false;
86  m_LTQuadStepFilt = false;
87  m_doRPD = false;
88  m_doBRAN = false;
89  m_zdct0 = 28;
90  m_rpdt0 = 28;
91  m_zdcRiseTime = 1;
92  m_zdcFallTime = 5.5;
93  m_zdcAdcPerPhoton = 0.000498;
94 }

◆ initializePbPb2015()

void ZDC_PileUpTool::initializePbPb2015 ( )

Definition at line 65 of file ZDC_PileUpTool.cxx.

65  {
66 
67  m_Pedestal = 100;
68  m_numTimeBins = 7;
69  m_freqMHz = 80;
70  m_delayChannels = true;
71  m_LTQuadStepFilt = true;
72  m_doRPD = false;
73  m_doBRAN = false;
74  m_zdct0 = 28;
75  m_qsfRiseTime = 0.5;
76  m_qsfFallTime = 11;
77  m_qsfFilter = 15;
78 }

◆ initializePbPb2023()

void ZDC_PileUpTool::initializePbPb2023 ( )

Definition at line 96 of file ZDC_PileUpTool.cxx.

96  {
97 
98  m_Pedestal = 100;
99  m_numTimeBins = 24;
100  m_freqMHz = 320;
101  m_delayChannels = false;
102  m_LTQuadStepFilt = false;
103  m_doRPD = true;
104  m_doBRAN = true;
105  m_zdct0 = 31.2;
106  m_rpdt0 = 27.9;
107  m_zdcRiseTime = 1.1;
108  m_zdcFallTime = 4.5;
109  m_rpdRiseTime = 0.8;
110  m_rpdFallTime = 15;
111  m_zdcAdcPerPhoton = 0.000498;
112  m_rpdAdcPerPhoton = {5.25 , 1.7};
113 }

◆ mergeEvent()

StatusCode ZDC_PileUpTool::mergeEvent ( const EventContext &  ctx)
finaloverridevirtual

return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

called at the end of the subevts loop. Not (necessarily) able to access SubEvents

Definition at line 240 of file ZDC_PileUpTool.cxx.

240  {
241 
242  ATHRNG::RNGWrapper* rngWrapper = m_randomSvc->getEngine(this, m_randomStreamName);
243  rngWrapper->setSeed( m_randomStreamName, ctx );
244  CLHEP::HepRandomEngine* rngEngine = rngWrapper->getEngine(ctx);
245  fillContainer(m_mergedFiberHitList, rngEngine, m_ZdcModuleContainer.get());
246 
247  SG::WriteHandle<xAOD::ZdcModuleContainer> moduleContainerH (m_ZdcModuleContainerName, ctx);
248  ATH_CHECK( moduleContainerH.record (std::move(m_ZdcModuleContainer), std::move(m_ZdcModuleAuxContainer)) );
249 
250  return StatusCode::SUCCESS;
251 }

◆ prepareEvent()

StatusCode ZDC_PileUpTool::prepareEvent ( const EventContext &  ctx,
const unsigned int  nInputEvents 
)
finaloverridevirtual

called before the subevts loop. Not (necessarily) able to access SubEvents

Definition at line 190 of file ZDC_PileUpTool.cxx.

190  {
191 
192  ATH_MSG_DEBUG ( "ZDC_PileUpTool::prepareEvent() called for " << nInputEvents << " input events" );
193 
194  m_ZdcModuleContainer = std::make_unique<xAOD::ZdcModuleContainer>();
195  m_ZdcModuleAuxContainer = std::make_unique<xAOD::ZdcModuleAuxContainer>();
196  m_ZdcModuleContainer->setStore( m_ZdcModuleAuxContainer.get() );
197 
198  SG::AuxElement::Accessor<std::vector<uint16_t>> g0acc("g0data");
199  SG::AuxElement::Accessor<std::vector<uint16_t>> g1acc("g1data");
200  SG::AuxElement::Accessor<std::vector<uint16_t>> g0d1acc("g0d1data");
201  SG::AuxElement::Accessor<std::vector<uint16_t>> g1d1acc("g1d1data");
202 
203  m_mergedFiberHitList->clear();
204 
205  return StatusCode::SUCCESS;
206 }

◆ processAllSubEvents() [1/2]

StatusCode ZDC_PileUpTool::processAllSubEvents ( const EventContext &  ctx)
finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 115 of file ZDC_PileUpTool.cxx.

115  {
116 
117  ATH_MSG_DEBUG ( "ZDC_PileUpTool::processAllSubEvents()" );
118 
119  ATHRNG::RNGWrapper* rngWrapper = m_randomSvc->getEngine(this, m_randomStreamName);
120  rngWrapper->setSeed( m_randomStreamName, ctx );
121  CLHEP::HepRandomEngine* rngEngine = rngWrapper->getEngine(ctx);
122 
123  /******************************************
124  * retrieve the hit collection list (input)
125  ******************************************/
126 
127  SG::ReadHandle<ZDC_SimFiberHit_Collection> hitCollection(m_SimFiberHitCollectionKey, ctx);
128  if (!hitCollection.isValid()) {
129  ATH_MSG_ERROR("Could not get ZDC_SimFiberHit_Collection container " << hitCollection.name() << " from store " << hitCollection.store());
130  return StatusCode::FAILURE;
131  }
132  ATH_MSG_DEBUG("ZDC_SimFiberHitHitCollection found with " << hitCollection->size() << " hits");
133 
134  /******************************************
135  * Do light guide efficiency cuts on the ZDCs
136  ******************************************/
137  TimedHitCollection<ZDC_SimFiberHit> thpcZDC_Fiber = doZDClightGuideCuts(hitCollection.cptr());
138 
139  /******************************************
140  * Create the output container
141  ******************************************/
142  std::unique_ptr<xAOD::ZdcModuleContainer> moduleContainer( new xAOD::ZdcModuleContainer());
143  std::unique_ptr<xAOD::ZdcModuleAuxContainer> moduleAuxContainer( new xAOD::ZdcModuleAuxContainer() );
144  moduleContainer->setStore( moduleAuxContainer.get() );
145 
146  SG::AuxElement::Accessor<std::vector<uint16_t>> g0acc("g0data");
147  SG::AuxElement::Accessor<std::vector<uint16_t>> g1acc("g1data");
148  if(m_delayChannels){
149  SG::AuxElement::Accessor<std::vector<uint16_t>> g0d1acc("g0d1data");
150  SG::AuxElement::Accessor<std::vector<uint16_t>> g1d1acc("g1d1data");
151  }
152 
153  /******************************************
154  * Create the waveforms
155  ******************************************/
156  fillContainer(thpcZDC_Fiber, rngEngine, moduleContainer.get());
157 
158 
159  /******************************************
160  * Create the zdcSums container
161  ******************************************/
162  std::unique_ptr<xAOD::ZdcModuleContainer> sumsContainer( new xAOD::ZdcModuleContainer());
163  std::unique_ptr<xAOD::ZdcModuleAuxContainer> sumsAuxContainer( new xAOD::ZdcModuleAuxContainer() );
164  sumsContainer->setStore( sumsAuxContainer.get() );
165 
166  static const SG::Accessor<uint16_t> LucrodTriggerSideAmpAcc ("LucrodTriggerSideAmp");
167  for (int iside : {-1, 1}){
168  xAOD::ZdcModule* new_sum = new xAOD::ZdcModule();
169  sumsContainer->push_back(xAOD::ZdcModuleContainer::unique_type(new_sum));
170  new_sum->setZdcSide(iside);
171  LucrodTriggerSideAmpAcc (*new_sum) = 42;
172  }
173 
174  /******************************************
175  * Write the output
176  ******************************************/
177 
178  //Print the module contents
179  ATH_MSG_DEBUG( ZdcModuleToString(*moduleContainer) );
180 
181  auto moduleContainerH = SG::makeHandle( m_ZdcModuleContainerName, ctx );
182  ATH_CHECK( moduleContainerH.record (std::move(moduleContainer), std::move(moduleAuxContainer)) );
183 
184  auto sumsContainerH = SG::makeHandle( m_ZdcSumsContainerName, ctx );
185  ATH_CHECK( sumsContainerH.record (std::move(sumsContainer), std::move(sumsAuxContainer)) );
186 
187  return StatusCode::SUCCESS;
188 }

◆ processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents
inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ processBunchXing()

StatusCode ZDC_PileUpTool::processBunchXing ( int  bunchXing,
SubEventIterator  bSubEvents,
SubEventIterator  eSubEvents 
)
finaloverridevirtual

called for each active bunch-crossing to process current SubEvents bunchXing is in ns

Reimplemented from PileUpToolBase.

Definition at line 209 of file ZDC_PileUpTool.cxx.

211  {
212  ATH_MSG_DEBUG ( "ZDC_PileUpTool::processBunchXing() " << bunchXing );
213  SubEventIterator iEvt = bSubEvents;
214  for (; iEvt!=eSubEvents; ++iEvt) {
215  StoreGateSvc& seStore = *iEvt->ptr()->evtStore();
216  ATH_MSG_VERBOSE("SubEvt StoreGate " << seStore.name() << " :"
217  << " bunch crossing : " << bunchXing
218  << " time offset : " << iEvt->time()
219  << " event number : " << iEvt->ptr()->eventNumber()
220  << " run number : " << iEvt->ptr()->runNumber());
221 
222  const ZDC_SimFiberHit_Collection* tmpColl = 0;
223 
224  if (!seStore.retrieve(tmpColl, m_HitCollectionName).isSuccess()) {
225  ATH_MSG_ERROR ( "SubEvent ZDC_SimFiberHit_Collection not found in StoreGate " << seStore.name() );
226  return StatusCode::FAILURE;
227  }
228  ATH_MSG_DEBUG ( "ZDC_SimFiberHit_Collection found with " << tmpColl->size() << " hits" );
229 
230  ZDC_SimFiberHit_Collection::const_iterator it = tmpColl->begin();
231  ZDC_SimFiberHit_Collection::const_iterator end = tmpColl->end();
232 
233  for (; it!=end; ++it) m_mergedFiberHitList->push_back(*it);
234  }
235 
236  return StatusCode::SUCCESS;
237 }

◆ resetFilter()

virtual void PileUpToolBase::resetFilter ( )
inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

51 { m_filterPassed=true; }

◆ SetDumps()

void ZDC_PileUpTool::SetDumps ( bool  ,
bool   
)
private

◆ toProcess()

virtual bool PileUpToolBase::toProcess ( int  bunchXing) const
inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

32  {
33  //closed interval [m_firstXing,m_lastXing]
34  return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
35  }

Member Data Documentation

◆ m_configuration

Gaudi::Property<std::string> ZDC_PileUpTool::m_configuration {this, "configuration" , "PbPb2023", "Named configuration to be used. Overwrites other properties if used" }
private

Definition at line 91 of file ZDC_PileUpTool.h.

◆ m_delayChannels

Gaudi::Property<bool > ZDC_PileUpTool::m_delayChannels {this, "delayChannels" , false , "Include delayed channels in the output" }
private

Definition at line 106 of file ZDC_PileUpTool.h.

◆ m_doBRAN

Gaudi::Property<bool > ZDC_PileUpTool::m_doBRAN {this, "doBRAN" , false , "Include BRAN channels in the output" }
private

Definition at line 108 of file ZDC_PileUpTool.h.

◆ m_doRPD

Gaudi::Property<bool > ZDC_PileUpTool::m_doRPD {this, "doRPD" , false , "Include RPD channels in the output" }
private

Definition at line 107 of file ZDC_PileUpTool.h.

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}
protectedinherited

Definition at line 60 of file PileUpToolBase.h.

◆ m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing
protectedinherited
Initial value:
{this, "FirstXing", -999,
"First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

◆ m_freqMHz

Gaudi::Property<double> ZDC_PileUpTool::m_freqMHz {this, "freqMHz" , 40 , "Digitizer frequence in MHz" }
private

Definition at line 94 of file ZDC_PileUpTool.h.

◆ m_HitCollectionName

Gaudi::Property<std::string> ZDC_PileUpTool::m_HitCollectionName
private
Initial value:
{this, "HitCollectionName" , "ZDC_SimFiberHit_Collection",
"Name of the input Collection of the simulation Hits"}

Definition at line 86 of file ZDC_PileUpTool.h.

◆ m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing
protectedinherited
Initial value:
{this, "LastXing", 999,
"Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

◆ m_LTQuadStepFilt

Gaudi::Property<bool > ZDC_PileUpTool::m_LTQuadStepFilt {this, "LTQuadStepFilt" , false , "Use LT Quad Step Filter waveform for ZDC channels" }
private

Definition at line 105 of file ZDC_PileUpTool.h.

◆ m_mergedFiberHitList

ZDC_SimFiberHit_Collection* ZDC_PileUpTool::m_mergedFiberHitList {}
private

Definition at line 73 of file ZDC_PileUpTool.h.

◆ m_mergeSvc

ServiceHandle<PileUpMergeSvc> ZDC_PileUpTool::m_mergeSvc {this, "mergeSvc", "PileUpMergeSvc", ""}
private

Definition at line 78 of file ZDC_PileUpTool.h.

◆ m_numTimeBins

Gaudi::Property<int > ZDC_PileUpTool::m_numTimeBins {this, "MaxTimeBin" , 7 , "The number of time-slices after digitization(Typically 5 or 7)" }
private

Definition at line 93 of file ZDC_PileUpTool.h.

◆ m_outputContainerName

Gaudi::Property<std::string> ZDC_PileUpTool::m_outputContainerName
private
Initial value:
{this, "OutputContainerName" , "ZDC_SimModuleContainer",
"Name of the output ZDC module container"}

Definition at line 88 of file ZDC_PileUpTool.h.

◆ m_Pedestal

Gaudi::Property<int > ZDC_PileUpTool::m_Pedestal {this, "Pedestal" , 100 , "DC offset of the pulse in ADC" }
private

Definition at line 92 of file ZDC_PileUpTool.h.

◆ m_qsfFallTime

Gaudi::Property<double> ZDC_PileUpTool::m_qsfFallTime {this, "qsfFallTime" , 4 , "Rise time of the RPD pulses" }
private

Definition at line 102 of file ZDC_PileUpTool.h.

◆ m_qsfFilter

Gaudi::Property<double> ZDC_PileUpTool::m_qsfFilter {this, "qsfFilter" , 4 , "Rise time of the RPD pulses" }
private

Definition at line 103 of file ZDC_PileUpTool.h.

◆ m_qsfRiseTime

Gaudi::Property<double> ZDC_PileUpTool::m_qsfRiseTime {this, "qsfRiseTime" , 4 , "Rise time of the RPD pulses" }
private

Definition at line 101 of file ZDC_PileUpTool.h.

◆ m_randomStreamName

Gaudi::Property<std::string> ZDC_PileUpTool::m_randomStreamName {this, "RandomStreamName", "ZDCRndEng", ""}
private

Definition at line 80 of file ZDC_PileUpTool.h.

◆ m_randomSvc

ServiceHandle<IAthRNGSvc> ZDC_PileUpTool::m_randomSvc {this, "RndmSvc", "AthRNGSvc", ""}
private

Definition at line 79 of file ZDC_PileUpTool.h.

◆ m_rpdAdcPerPhoton

Gaudi::Property<std::vector< float> > ZDC_PileUpTool::m_rpdAdcPerPhoton {this, "rpdAdcPerPhoton", {5.25 , 1.7}, "ADC counts per detected photon in the RPDs"}
private

Definition at line 109 of file ZDC_PileUpTool.h.

◆ m_rpdFallTime

Gaudi::Property<double> ZDC_PileUpTool::m_rpdFallTime {this, "rpdFallTime" , 0.5 , "Fall time of the RPD pulses" }
private

Definition at line 100 of file ZDC_PileUpTool.h.

◆ m_rpdRiseTime

Gaudi::Property<double> ZDC_PileUpTool::m_rpdRiseTime {this, "rpdRiseTime" , 4 , "Rise time of the RPD pulses" }
private

Definition at line 99 of file ZDC_PileUpTool.h.

◆ m_rpdt0

Gaudi::Property<double> ZDC_PileUpTool::m_rpdt0 {this, "rpdt0" , 40 , "Start time of the pulse in the digitization window" }
private

Definition at line 96 of file ZDC_PileUpTool.h.

◆ m_SimFiberHitCollectionKey

SG::ReadHandleKey<ZDC_SimFiberHit_Collection> ZDC_PileUpTool::m_SimFiberHitCollectionKey {this, "ZDC_SimFiberHit_CollectionName", "ZDC_SimFiberHit_Collection"}
private

Definition at line 82 of file ZDC_PileUpTool.h.

◆ m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks
protectedinherited
Initial value:
{this, "VetoPileUpTruthLinks", true,
"Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

◆ m_zdcAdcPerPhoton

Gaudi::Property<float > ZDC_PileUpTool::m_zdcAdcPerPhoton {this, "zdcAdcPerPhoton" , 0.000498 , "ADC counts per detected photon in the ZDCs" }
private

Definition at line 104 of file ZDC_PileUpTool.h.

◆ m_zdcFallTime

Gaudi::Property<double> ZDC_PileUpTool::m_zdcFallTime {this, "zdcFallTime" , 0.5 , "Fall time of the ZDC pulses" }
private

Definition at line 98 of file ZDC_PileUpTool.h.

◆ m_ZdcID

const ZdcID* ZDC_PileUpTool::m_ZdcID
private

Definition at line 74 of file ZDC_PileUpTool.h.

◆ m_ZdcModuleAuxContainer

std::unique_ptr<xAOD::ZdcModuleAuxContainer> ZDC_PileUpTool::m_ZdcModuleAuxContainer
private

Definition at line 76 of file ZDC_PileUpTool.h.

◆ m_ZdcModuleContainer

std::unique_ptr<xAOD::ZdcModuleContainer> ZDC_PileUpTool::m_ZdcModuleContainer
private

Definition at line 75 of file ZDC_PileUpTool.h.

◆ m_ZdcModuleContainerName

SG::WriteHandleKey<xAOD::ZdcModuleContainer> ZDC_PileUpTool::m_ZdcModuleContainerName {this, "ZdcModuleContainerName", "ZdcModules"}
private

Definition at line 83 of file ZDC_PileUpTool.h.

◆ m_zdcRiseTime

Gaudi::Property<double> ZDC_PileUpTool::m_zdcRiseTime {this, "zdcRiseTime" , 4 , "Rise time of the ZDC pulses" }
private

Definition at line 97 of file ZDC_PileUpTool.h.

◆ m_ZdcSumsContainerName

SG::WriteHandleKey<xAOD::ZdcModuleContainer> ZDC_PileUpTool::m_ZdcSumsContainerName {this, "ZdcSumsContainerName", "ZdcSums"}
private

Definition at line 84 of file ZDC_PileUpTool.h.

◆ m_zdct0

Gaudi::Property<double> ZDC_PileUpTool::m_zdct0 {this, "zdct0" , 40 , "Start time of the pulse in the digitization window" }
private

Definition at line 95 of file ZDC_PileUpTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ZDC_SimFiberHit::getNPhotons
int getNPhotons() const
Definition: ZDC_SimFiberHit.h:46
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
ZDC_PileUpTool::m_ZdcModuleContainer
std::unique_ptr< xAOD::ZdcModuleContainer > m_ZdcModuleContainer
Definition: ZDC_PileUpTool.h:75
ZDC_PileUpTool::m_ZdcModuleAuxContainer
std::unique_ptr< xAOD::ZdcModuleAuxContainer > m_ZdcModuleAuxContainer
Definition: ZDC_PileUpTool.h:76
ZDC_PileUpTool::m_randomStreamName
Gaudi::Property< std::string > m_randomStreamName
Definition: ZDC_PileUpTool.h:80
AtlasHitsVector::Insert
void Insert(const T &h)
Definition: AtlasHitsVector.h:73
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
PileUpToolBase::m_filterPassed
bool m_filterPassed
Definition: PileUpToolBase.h:60
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ZDC_PileUpTool::createAndStoreWaveform
void createAndStoreWaveform(const ZDC_SimFiberHit &hit, CLHEP::HepRandomEngine *, xAOD::ZdcModuleContainer *)
Definition: ZDC_PileUpTool.cxx:364
ZDC_PileUpTool::m_configuration
Gaudi::Property< std::string > m_configuration
Definition: ZDC_PileUpTool.h:91
xAOD::ZdcModuleAuxContainer_v2
Auxiliary store for xAOD::ZdcModuleContainer_v2.
Definition: ZdcModuleAuxContainer_v2.h:31
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ZdcID::module
int module(const Identifier &id) const
Definition: ZdcID.h:163
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
xAOD::ZdcModule_v1
Class containing ZDC Module information.
Definition: ZdcModule_v1.h:25
skel.it
it
Definition: skel.GENtoEVGEN.py:423
ZDC_PileUpTool::m_zdct0
Gaudi::Property< double > m_zdct0
Definition: ZDC_PileUpTool.h:95
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ZDC_PileUpTool::generateWaveform
std::vector< short unsigned int > generateWaveform(std::shared_ptr< ZDCWaveformSampler > wfSampler, float amplitude, float t0)
Definition: ZDC_PileUpTool.cxx:434
PileUpToolBase::m_lastXing
Gaudi::Property< int > m_lastXing
Definition: PileUpToolBase.h:56
ZDC_SimFiberHit_ConstIterator
ZDC_SimFiberHit_Collection::const_iterator ZDC_SimFiberHit_ConstIterator
Definition: ZDC_SimFiberHit_Collection.h:24
ZDC_PileUpTool::m_zdcFallTime
Gaudi::Property< double > m_zdcFallTime
Definition: ZDC_PileUpTool.h:98
AtlasHitsVector::begin
const_iterator begin() const
Definition: AtlasHitsVector.h:131
xAOD::ZdcModule_v1::setWaveform
void setWaveform(const std::string &, const std::vector< uint16_t > &)
Definition: ZdcModule_v1.cxx:34
TimedHitCollection::nextDetectorElement
bool nextDetectorElement(const_iterator &b, const_iterator &e)
sets an iterator range with the hits of current detector element returns a bool when done
ZDC_PileUpTool::m_numTimeBins
Gaudi::Property< int > m_numTimeBins
Definition: ZDC_PileUpTool.h:93
ZDC_PileUpTool::m_zdcRiseTime
Gaudi::Property< double > m_zdcRiseTime
Definition: ZDC_PileUpTool.h:97
ZDC_PileUpTool::m_rpdFallTime
Gaudi::Property< double > m_rpdFallTime
Definition: ZDC_PileUpTool.h:100
AtlasHitsVector::const_iterator
CONT::const_iterator const_iterator
Definition: AtlasHitsVector.h:43
AtlasHitsVector::clear
void clear()
Definition: AtlasHitsVector.h:153
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
ZdcID::channel_id
Identifier channel_id(int side, int module, int type, int channel) const
Definition: ZdcID.h:205
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
ZDC_PileUpTool::m_qsfFallTime
Gaudi::Property< double > m_qsfFallTime
Definition: ZDC_PileUpTool.h:102
python.PyAthena.module
module
Definition: PyAthena.py:134
ZDC_PileUpTool::m_zdcAdcPerPhoton
Gaudi::Property< float > m_zdcAdcPerPhoton
Definition: ZDC_PileUpTool.h:104
ZDC_PileUpTool::m_mergedFiberHitList
ZDC_SimFiberHit_Collection * m_mergedFiberHitList
Definition: ZDC_PileUpTool.h:73
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:128
efficiency
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:128
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
TimedHitCollection::insert
void insert(const PileUpTimeEventIndex &timeEventIndex, const AtlasHitsVector< HIT > *inputCollection)
ZDC_PileUpTool::m_HitCollectionName
Gaudi::Property< std::string > m_HitCollectionName
Definition: ZDC_PileUpTool.h:86
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
lumiFormat.i
int i
Definition: lumiFormat.py:92
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
ZDC_PileUpTool::initializePbPb2015
void initializePbPb2015()
Definition: ZDC_PileUpTool.cxx:65
ZDC_PileUpTool::m_ZdcModuleContainerName
SG::WriteHandleKey< xAOD::ZdcModuleContainer > m_ZdcModuleContainerName
Definition: ZDC_PileUpTool.h:83
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ZDC_SimFiberHit::Add
void Add(int nphot, double edep)
Definition: ZDC_SimFiberHit.h:99
ZDC_PileUpTool::m_doRPD
Gaudi::Property< bool > m_doRPD
Definition: ZDC_PileUpTool.h:107
test_pyathena.parent
parent
Definition: test_pyathena.py:15
PileUpToolBase::PileUpToolBase
PileUpToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: PileUpToolBase.cxx:7
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ZDC_PileUpTool::fillContainer
void fillContainer(TimedHitCollection< ZDC_SimFiberHit > &, CLHEP::HepRandomEngine *, xAOD::ZdcModuleContainer *)
Definition: ZDC_PileUpTool.cxx:253
ZDC_PileUpTool::initializePbPb2023
void initializePbPb2023()
Definition: ZDC_PileUpTool.cxx:96
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
ZDC_PileUpTool::m_SimFiberHitCollectionKey
SG::ReadHandleKey< ZDC_SimFiberHit_Collection > m_SimFiberHitCollectionKey
Definition: ZDC_PileUpTool.h:82
ZDC_PileUpTool::doZDClightGuideCuts
TimedHitCollection< ZDC_SimFiberHit > doZDClightGuideCuts(const ZDC_SimFiberHit_Collection *hitCollection)
Definition: ZDC_PileUpTool.cxx:314
ZDCWaveformSampler::Generate
std::vector< unsigned int > Generate(float amplitude)
Definition: ZDCWaveformSampler.h:72
ZDC_PileUpTool::m_freqMHz
Gaudi::Property< double > m_freqMHz
Definition: ZDC_PileUpTool.h:94
ZDC_PileUpTool::m_LTQuadStepFilt
Gaudi::Property< bool > m_LTQuadStepFilt
Definition: ZDC_PileUpTool.h:105
DataVector::unique_type
std::unique_ptr< base_value_type > unique_type
Type of a unique_ptr that can be used to insert elements into this container.
Definition: DataVector.h:828
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
ZDC_PileUpTool::addEmptyWaveforms
void addEmptyWaveforms(xAOD::ZdcModuleContainer *zdcModuleContainer, CLHEP::HepRandomEngine *rndEngine)
Definition: ZDC_PileUpTool.cxx:273
ZDC_PileUpTool::m_qsfRiseTime
Gaudi::Property< double > m_qsfRiseTime
Definition: ZDC_PileUpTool.h:101
xAOD::ZdcModule
ZdcModule_v1 ZdcModule
Definition: ZdcModule.h:15
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
ZDC_PileUpTool::m_rpdAdcPerPhoton
Gaudi::Property< std::vector< float > > m_rpdAdcPerPhoton
Definition: ZDC_PileUpTool.h:109
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
ZDC_PileUpTool::m_randomSvc
ServiceHandle< IAthRNGSvc > m_randomSvc
Definition: ZDC_PileUpTool.h:79
MULTICHANNEL
@ MULTICHANNEL
Definition: ZdcID.h:21
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
xAOD::ZdcModule_v1::setZdcSide
void setZdcSide(int)
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
SINGLECHANNEL
@ SINGLECHANNEL
Definition: ZdcID.h:21
ZDC_PileUpTool::m_rpdRiseTime
Gaudi::Property< double > m_rpdRiseTime
Definition: ZDC_PileUpTool.h:99
AtlasHitsVector::end
const_iterator end() const
Definition: AtlasHitsVector.h:134
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ZdcID::side
int side(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: ZdcID.h:157
TimedHitCollection::const_iterator
TimedVector::const_iterator const_iterator
Definition: TimedHitCollection.h:20
PileUpToolBase::m_firstXing
Gaudi::Property< int > m_firstXing
Definition: PileUpToolBase.h:54
ZdcID::type
int type(const Identifier &id) const
Definition: ZdcID.h:169
ZDC_PileUpTool::m_rpdt0
Gaudi::Property< double > m_rpdt0
Definition: ZDC_PileUpTool.h:96
ZDC_PileUpTool::m_ZdcSumsContainerName
SG::WriteHandleKey< xAOD::ZdcModuleContainer > m_ZdcSumsContainerName
Definition: ZDC_PileUpTool.h:84
AtlasHitsVector::size
size_type size() const
Definition: AtlasHitsVector.h:143
ZDC_SimFiberHit::getID
Identifier getID() const
Definition: ZDC_SimFiberHit.h:44
SubEventIterator
std::vector< xAOD::EventInfo::SubEvent >::const_iterator SubEventIterator
Definition: IPileUpTool.h:22
ZDC_PileUpTool::m_Pedestal
Gaudi::Property< int > m_Pedestal
Definition: ZDC_PileUpTool.h:92
ZDC_SimFiberHit
Definition: ZDC_SimFiberHit.h:11
ZDC_PileUpTool::m_delayChannels
Gaudi::Property< bool > m_delayChannels
Definition: ZDC_PileUpTool.h:106
ZDC_SimFiberHit_Collection
Definition: ZDC_SimFiberHit_Collection.h:16
ZDC_PileUpTool::initializeLHCf2022
void initializeLHCf2022()
Definition: ZDC_PileUpTool.cxx:80
ZDC_PileUpTool::m_doBRAN
Gaudi::Property< bool > m_doBRAN
Definition: ZDC_PileUpTool.h:108
ZdcID
Definition: ZdcID.h:25
ZDC_PileUpTool::m_ZdcID
const ZdcID * m_ZdcID
Definition: ZDC_PileUpTool.h:74
TimedHitCollection
Definition: TimedHitCollection.h:15
ZdcModuleToString
std::string ZdcModuleToString(const xAOD::ZdcModule &zm)
Definition: ZdcModuleToString.cxx:9
AtlasHitsVector::push_back
void push_back(const T &t)
Definition: AtlasHitsVector.h:145
ZdcID::channel
int channel(const Identifier &id) const
Definition: ZdcID.h:175
ZDC_PileUpTool::m_qsfFilter
Gaudi::Property< double > m_qsfFilter
Definition: ZDC_PileUpTool.h:103
Generated on Thu Jul 4 2024 22:10:22 for ATLAS Offline Software by   doxygen 1.8.18