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
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
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
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
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

Definition at line 34 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 24 of file ZDC_PileUpTool.cxx.

                                       :
  PileUpToolBase(type, name, parent)
{
}

Member Function Documentation

addEmptyWaveforms()

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

private

Definition at line 275 of file ZDC_PileUpTool.cxx.

                                                                                                                 {
  //Initialize bools to keep track of what modules/channels we have seen
  bool zdcFound[2][4] =  {{}};
  bool rpdFound[2][16] = {{}};
  bool branFound[2] = {};
  for(auto module : *zdcModuleContainer){
    int iside = (module->zdcSide() == -1) ? 0 : 1;
    int mod = module->zdcModule();
    if(mod < 4){ //ZDC
      zdcFound[iside][mod] = true;
      ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found ZDC side " << module->zdcSide() << " module " << mod);
    }else if(mod == 4){ //RPD
      rpdFound[iside][module->zdcChannel()] = true;
      ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found RPD side " << module->zdcSide() << " channel " << module->zdcChannel());
    }else{//BRAN
      branFound[iside] = true;
      ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Found BRAN side " << module->zdcSide() );
    }
  }
 
  for(int iside : {0,1}){
    int side = (iside == 0) ? -1 : 1;
    for(int mod = 0; mod < 4; mod++){
      if(!zdcFound[iside][mod]){
        ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for ZDC side " << side << " module " << mod);
        createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, mod, ZdcIDType::SINGLECHANNEL, 0), 0, 0), rndEngine, zdcModuleContainer);
      }
    }
    for(int channel = 0; channel < 16; channel++){
      if(!rpdFound[iside][channel] && m_doRPD){
        ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for RPD side " << side << " channel " << channel);
        createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, 4, ZdcIDType::MULTICHANNEL, channel), 0, 0), rndEngine, zdcModuleContainer);
      }
    }
    if(!branFound[iside] && m_doBRAN){
      ATH_MSG_DEBUG("ZDC_PileUpTool::addEmptyWaveforms Creating empty waveform for BRAN side " << side );
      createAndStoreWaveform(ZDC_SimFiberHit( m_ZdcID->channel_id(side, 5, ZdcIDType::SINGLECHANNEL, 0), 0, 0), rndEngine, zdcModuleContainer);
    }
  }
}

createAndStoreWaveform()

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

private

Definition at line 366 of file ZDC_PileUpTool.cxx.

                                                                                                                                                  {
  Identifier id = hit.getID( );
  int side = m_ZdcID->side(id);
  int module = m_ZdcID->module(id);
  int channel = m_ZdcID->channel(id);
 
  if(module == 4 && !m_doRPD) return;
  if(module == 5 && !m_doBRAN) return;
 
  //Here we have to switch the type of the RPD from ACTIVE to MULTICHANNEL
  //TODO: Either change the channel numbering in the geometry, or the analysis
  if(module == 4) id = m_ZdcID->channel_id(side,module,ZdcIDType::MULTICHANNEL,channel);
 
  //Create a new ZdcModule to store the waveforms
  xAOD::ZdcModule* zdc = new xAOD::ZdcModule();
  zdcModuleContainer->push_back(xAOD::ZdcModuleContainer::unique_type(zdc));
  zdcModuleContainer->back()->setZdcId(id.get_identifier32().get_compact());
  zdcModuleContainer->back()->setZdcSide(side);
  zdcModuleContainer->back()->setZdcModule(module);
  zdcModuleContainer->back()->setZdcType(m_ZdcID->type(id));
  zdcModuleContainer->back()->setZdcChannel(channel);
 
  ATH_MSG_DEBUG( "Digitizing Side " <<  side << 
                " Module " << module << 
                                " Channel " << channel << 
                ", whith " << hit.getNPhotons() << " photons" );
  
  uint iSide = (side == -1) ? 0 : 1;
  float amplitude = 0, t0 = 0;
  bool doHighGain = true;
  std::shared_ptr<ZDCWaveformBase> waveformPtr;
  std::shared_ptr<ZDCWaveformSampler> wfSampler;
  
  if(module < 4){//It's a ZDC channel
    amplitude = CLHEP::RandPoissonQ::shoot(rndEngine, hit.getNPhotons())*m_zdcAdcPerPhoton;
 
    if(m_LTQuadStepFilt){ 
      waveformPtr = std::make_shared<ZDCWaveformLTLinStep>("zdc",m_qsfRiseTime,m_qsfFallTime,m_qsfFilter);
    }else{
      waveformPtr = std::make_shared<ZDCWaveformFermiExp>("zdc",m_zdcRiseTime,m_zdcFallTime);
    }
    wfSampler = std::make_shared<ZDCWaveformSampler>(m_freqMHz, 0, m_numTimeBins, 12, m_Pedestal, waveformPtr);
    t0 = m_zdct0;
 
  }else{ //It's an RPD channel
    // ATH_MSG_INFO("Digitizing RPD " << side << ", channel " << channel << " with " << hit.getNPhotons() << " and " << m_rpdAdcPerPhoton[iSide] << " amplification");
    amplitude = CLHEP::RandPoissonQ::shoot(rndEngine, hit.getNPhotons())*m_rpdAdcPerPhoton[iSide];
    waveformPtr = std::make_shared<ZDCWaveformFermiExp>("rpd",m_rpdRiseTime,m_rpdFallTime);
    wfSampler = std::make_shared<ZDCWaveformSampler>(m_freqMHz, 0, m_numTimeBins, 12, m_Pedestal, waveformPtr);
    t0 = m_rpdt0;
    doHighGain = false;
  }
 
  //Record the number of photons that lead to this waveform
  SG::Accessor<unsigned int> nPhotonsAcc ("nPhotons");
  nPhotonsAcc (*zdc) = hit.getNPhotons();
 
  //Generate in time waveforms
  zdc->setWaveform("g0data", generateWaveform(wfSampler, amplitude, t0));
  if(doHighGain) zdc->setWaveform("g1data", generateWaveform(wfSampler, 10*amplitude, t0));
 
  //Generate delayed waveforms
  if(m_delayChannels){
    float timeBinWidth = 1000.0/m_freqMHz;
    zdc->setWaveform("g0d1data", generateWaveform(wfSampler, 10*amplitude, t0+timeBinWidth/2));
    if(doHighGain) zdc->setWaveform("g1d1data", generateWaveform(std::move(wfSampler), 10*amplitude, t0+timeBinWidth/2));
  }
 
}

doZDClightGuideCuts()

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

private

Definition at line 316 of file ZDC_PileUpTool.cxx.

                                                                                                                      {
 
  ZDC_SimFiberHit* newHits[2][4] = {{nullptr}};
  ZDC_SimFiberHit_Collection* newCollection = new ZDC_SimFiberHit_Collection("ZDC_SimFiberHit_Collection_Temp");
 
  for(ZDC_SimFiberHit hit : *hitCollection){
    Identifier id = hit.getID();
    //Translate side from -1,1 to 0,1 to index ZDC hits
    int side = (m_ZdcID->side( id ) < 0 ) ? 0 : 1;
    int module = m_ZdcID->module( id );
    
    //ZDCs are module 0-3, just insert this hit unmodified and move on
    if(module > 3){ 
      newCollection->Insert(hit);
      continue;
    }
 
    //TODO: Implement a method to get the efficiency of this location to multiply hit.getNphotons() and hit.getEdep()
    //based on the channel retrieved by m_ZdcID->channel( id ) and some efficiency map
    float efficiency = 1.0; //For now we will just use 100% efficiency
 
    if(!newHits[side][module]){
      //The module hasn't been seen yet, create a new hit with values modified by the efficiency factor
      //The ID is modified because we initially used channel to denote the position of the rods for these efficiency cuts
      //Now that that's done, we make sure the type is SINGLECHANNEL and the channel is 0
      newHits[side][module] = new ZDC_SimFiberHit(m_ZdcID->channel_id(m_ZdcID->side(id), module, ZdcIDType::SINGLECHANNEL, 0), efficiency * hit.getNPhotons(), efficiency * hit.getEdep());
    }else{
      //The module has been seen, add the photons and energy from this new hit to it
      newHits[side][module]->Add( efficiency*hit.getNPhotons(), efficiency*hit.getEdep());
    }
  }//end loop over hits
 
  for(int side : {0,1}){
    for(int module = 0; module < 4; module++){
      //Make sure the hit exists before attempting to insert it
      //If it doesn't we will take care of this module in addEmptyWaveforms
      if(newHits[side][module]){
        newCollection->Insert(*(newHits[side][module]));
      }
    }
  }
 
  //Now insert one hit per detector in the new collection
  TimedHitCollection<ZDC_SimFiberHit> newTimedCollection;
  newTimedCollection.insert(0.0, newCollection);
  //coverity[leaked_storage]
  return newTimedCollection;
}

fillContainer() [1/2]

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

private

Definition at line 265 of file ZDC_PileUpTool.cxx.

                                                                                                                                                                           {
  ZDC_SimFiberHit_ConstIterator it    = ZDC_SimFiberHit_Collection->begin();
  ZDC_SimFiberHit_ConstIterator itend = ZDC_SimFiberHit_Collection->end();
 
  for (; it != itend; ++it) {
    createAndStoreWaveform(*it, rndEngine, zdcModuleContainer);
  }
  addEmptyWaveforms(zdcModuleContainer, rndEngine);
}

fillContainer() [2/2]

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

private

Definition at line 255 of file ZDC_PileUpTool.cxx.

                                                                                                                                                           {
  TimedHitCollection<ZDC_SimFiberHit> thpc = thpczdc;
  TimedHitCollection<ZDC_SimFiberHit>::const_iterator i, e, it;
  while (thpc.nextDetectorElement(i, e)) for (it = i; it != e; ++it) {
    createAndStoreWaveform(*(*it), rndEngine, zdcModuleContainer);
  }
  addEmptyWaveforms(zdcModuleContainer, rndEngine);
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

finalize()

virtual StatusCode ZDC_PileUpTool::finalize ( )

inlinefinaloverridevirtual

Definition at line 46 of file ZDC_PileUpTool.h.

{ 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 436 of file ZDC_PileUpTool.cxx.

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

initialize()

StatusCode ZDC_PileUpTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 31 of file ZDC_PileUpTool.cxx.

                                      {
 
  ATH_MSG_DEBUG ( "ZDC_PileUpTool::initialize() called" );
 
  const ZdcID* zdcId = nullptr;
  if (detStore()->retrieve( zdcId ).isFailure() ) {
    ATH_MSG_ERROR("execute: Could not retrieve ZdcID object from the detector store");
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG("execute: retrieved ZdcID");
  }
  m_ZdcID = zdcId;
 
  ATH_CHECK(m_randomSvc.retrieve());
  ATH_MSG_DEBUG ( "Retrieved RandomNumber Service" );
 
  ATH_CHECK(m_SimFiberHitCollectionKey.initialize());
  ATH_CHECK(m_ZdcModuleContainerName.initialize());
  ATH_CHECK(m_ZdcSumsContainerName.initialize());
 
  ATH_MSG_INFO("ZDC_PileUpTool configuration = " << m_configuration);
 
  if(m_configuration == "PbPb2015"){
    initializePbPb2015();
  }else if(m_configuration == "LHCf2022"){
    initializeLHCf2022();
  }else if(m_configuration == "PbPb2023"){
    initializePbPb2023();
  }
 
  m_mergedFiberHitList = new ZDC_SimFiberHit_Collection("mergedFiberHitList");
 
  return StatusCode::SUCCESS;
}

initializeLHCf2022()

void ZDC_PileUpTool::initializeLHCf2022

(

)

Definition at line 82 of file ZDC_PileUpTool.cxx.

                                       {
 
  m_Pedestal = 100;
  m_numTimeBins = 24;
  m_freqMHz = 320;
  m_delayChannels = false;
  m_LTQuadStepFilt = false;
  m_doRPD = false;
  m_doBRAN = false;
  m_zdct0 = 28;
  m_rpdt0 = 28;
  m_zdcRiseTime =  1;
  m_zdcFallTime =  5.5;
  m_zdcAdcPerPhoton = 0.000498;
}

initializePbPb2015()

void ZDC_PileUpTool::initializePbPb2015

(

)

Definition at line 67 of file ZDC_PileUpTool.cxx.

                                       {
 
  m_Pedestal = 100;
  m_numTimeBins = 7;
  m_freqMHz = 80;
  m_delayChannels = true;
  m_LTQuadStepFilt = true;
  m_doRPD = false;
  m_doBRAN = false;
  m_zdct0 = 28;
  m_qsfRiseTime =  0.5;
  m_qsfFallTime =  11;
  m_qsfFilter =  15;
}

initializePbPb2023()

void ZDC_PileUpTool::initializePbPb2023

(

)

Definition at line 98 of file ZDC_PileUpTool.cxx.

                                       {
 
  m_Pedestal = 100;
  m_numTimeBins = 24;
  m_freqMHz = 320;
  m_delayChannels = false;
  m_LTQuadStepFilt = false;
  m_doRPD = true;
  m_doBRAN = true;
  m_zdct0 = 31.2;
  m_rpdt0 = 27.9;
  m_zdcRiseTime =  1.1;
  m_zdcFallTime =  4.5;
  m_rpdRiseTime =  0.8;
  m_rpdFallTime =  15;
  m_zdcAdcPerPhoton = 0.000498;
  m_rpdAdcPerPhoton = {5.25 , 1.7};
}

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 242 of file ZDC_PileUpTool.cxx.

                                                            {
 
  ATHRNG::RNGWrapper* rngWrapper = m_randomSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName, ctx );
  CLHEP::HepRandomEngine* rngEngine = rngWrapper->getEngine(ctx);
  fillContainer(m_mergedFiberHitList, rngEngine, m_ZdcModuleContainer.get());
 
  SG::WriteHandle<xAOD::ZdcModuleContainer> moduleContainerH (m_ZdcModuleContainerName, ctx);
  ATH_CHECK( moduleContainerH.record (std::move(m_ZdcModuleContainer), std::move(m_ZdcModuleAuxContainer)) );
 
  return StatusCode::SUCCESS;
}

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 192 of file ZDC_PileUpTool.cxx.

                                                                                            {
 
  ATH_MSG_DEBUG ( "ZDC_PileUpTool::prepareEvent() called for " << nInputEvents << " input events" );
 
  m_ZdcModuleContainer = std::make_unique<xAOD::ZdcModuleContainer>();
  m_ZdcModuleAuxContainer = std::make_unique<xAOD::ZdcModuleAuxContainer>();
  m_ZdcModuleContainer->setStore( m_ZdcModuleAuxContainer.get() );
 
  SG::AuxElement::Accessor<std::vector<uint16_t>> g0acc("g0data");
  SG::AuxElement::Accessor<std::vector<uint16_t>> g1acc("g1data");
  SG::AuxElement::Accessor<std::vector<uint16_t>> g0d1acc("g0d1data");
  SG::AuxElement::Accessor<std::vector<uint16_t>> g1d1acc("g1d1data");
 
  m_mergedFiberHitList->clear();
 
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode ZDC_PileUpTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 117 of file ZDC_PileUpTool.cxx.

                                                                     {
 
  ATH_MSG_DEBUG ( "ZDC_PileUpTool::processAllSubEvents()" );
 
  ATHRNG::RNGWrapper* rngWrapper = m_randomSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName, ctx );
  CLHEP::HepRandomEngine* rngEngine = rngWrapper->getEngine(ctx);
 
  /******************************************
   * retrieve the hit collection list (input)
  ******************************************/
 
  SG::ReadHandle<ZDC_SimFiberHit_Collection> hitCollection(m_SimFiberHitCollectionKey, ctx);
  if (!hitCollection.isValid()) {
    ATH_MSG_ERROR("Could not get ZDC_SimFiberHit_Collection container " << hitCollection.name() << " from store " << hitCollection.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("ZDC_SimFiberHitHitCollection found with " << hitCollection->size() << " hits");
 
  /******************************************
   * Do light guide efficiency cuts on the ZDCs
  ******************************************/
  TimedHitCollection<ZDC_SimFiberHit> thpcZDC_Fiber = doZDClightGuideCuts(hitCollection.cptr());
 
  /******************************************
   * Create the output container
  ******************************************/
  std::unique_ptr<xAOD::ZdcModuleContainer> moduleContainer( new xAOD::ZdcModuleContainer());
  std::unique_ptr<xAOD::ZdcModuleAuxContainer> moduleAuxContainer( new xAOD::ZdcModuleAuxContainer() );
  moduleContainer->setStore( moduleAuxContainer.get() );
 
  SG::AuxElement::Accessor<std::vector<uint16_t>> g0acc("g0data");
  SG::AuxElement::Accessor<std::vector<uint16_t>> g1acc("g1data");
  if(m_delayChannels){
    SG::AuxElement::Accessor<std::vector<uint16_t>> g0d1acc("g0d1data");
    SG::AuxElement::Accessor<std::vector<uint16_t>> g1d1acc("g1d1data");
  }
 
  /******************************************
   * Create the waveforms
  ******************************************/
  fillContainer(thpcZDC_Fiber, rngEngine, moduleContainer.get());
 
 
  /******************************************
   * Create the zdcSums container
  ******************************************/
  std::unique_ptr<xAOD::ZdcModuleContainer> sumsContainer( new xAOD::ZdcModuleContainer());
  std::unique_ptr<xAOD::ZdcModuleAuxContainer> sumsAuxContainer( new xAOD::ZdcModuleAuxContainer() );
  sumsContainer->setStore( sumsAuxContainer.get() );
 
  static const SG::Accessor<uint16_t> LucrodTriggerSideAmpAcc ("LucrodTriggerSideAmp");
  for (int iside : {-1, 0, 1}){
    xAOD::ZdcModule* new_sum = new xAOD::ZdcModule();
    sumsContainer->push_back(xAOD::ZdcModuleContainer::unique_type(new_sum));
    new_sum->setZdcSide(iside);
    LucrodTriggerSideAmpAcc (*new_sum) = 42;
  }
 
  /******************************************
   * Write the output
  ******************************************/
 
  //Print the module contents
  ATH_MSG_DEBUG( ZdcModuleToString(*moduleContainer) );
 
  auto moduleContainerH = SG::makeHandle( m_ZdcModuleContainerName, ctx );
  ATH_CHECK( moduleContainerH.record (std::move(moduleContainer), std::move(moduleAuxContainer)) );
 
  auto sumsContainerH = SG::makeHandle( m_ZdcSumsContainerName, ctx );
  ATH_CHECK( sumsContainerH.record (std::move(sumsContainer), std::move(sumsAuxContainer)) );
 
  return StatusCode::SUCCESS;
}

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 211 of file ZDC_PileUpTool.cxx.

                                                                        {
  ATH_MSG_DEBUG ( "ZDC_PileUpTool::processBunchXing() " << bunchXing );
  SubEventIterator iEvt = bSubEvents;
  for (; iEvt!=eSubEvents; ++iEvt) {
    StoreGateSvc& seStore = *iEvt->ptr()->evtStore();
    ATH_MSG_VERBOSE("SubEvt StoreGate " << seStore.name() << " :"
                    << " bunch crossing : " << bunchXing
                    << " time offset : " << iEvt->time()
                    << " event number : " << iEvt->ptr()->eventNumber()
                    << " run number : " << iEvt->ptr()->runNumber());
 
    const ZDC_SimFiberHit_Collection* tmpColl = 0;
 
    if (!seStore.retrieve(tmpColl, m_HitCollectionName).isSuccess()) {
      ATH_MSG_ERROR ( "SubEvent ZDC_SimFiberHit_Collection not found in StoreGate " << seStore.name() );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG ( "ZDC_SimFiberHit_Collection found with " << tmpColl->size() << " hits" );
 
    ZDC_SimFiberHit_Collection::const_iterator it = tmpColl->begin();
    ZDC_SimFiberHit_Collection::const_iterator end = tmpColl->end();
 
    for (; it!=end; ++it) m_mergedFiberHitList->push_back(*it);
  }
 
  return StatusCode::SUCCESS;
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ 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.

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

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 93 of file ZDC_PileUpTool.h.

{this, "configuration"      , "PbPb2023", "Named configuration to be used. Overwrites other properties if used" };

m_delayChannels

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

private

Definition at line 108 of file ZDC_PileUpTool.h.

{this, "delayChannels"      , false     , "Include delayed channels in the output"                              };

m_doBRAN

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

private

Definition at line 110 of file ZDC_PileUpTool.h.

{this, "doBRAN"             , false     , "Include BRAN channels in the output"                                 };

m_doRPD

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

private

Definition at line 109 of file ZDC_PileUpTool.h.

{this, "doRPD"              , false     , "Include RPD channels in the output"                                  };

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

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.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_freqMHz

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

private

Definition at line 96 of file ZDC_PileUpTool.h.

{this, "freqMHz"            , 40        , "Digitizer frequence in MHz"                                          };

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 88 of file ZDC_PileUpTool.h.

                                              {this, "HitCollectionName" , "ZDC_SimFiberHit_Collection",
      "Name of the input Collection of the simulation Hits"};

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.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

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 107 of file ZDC_PileUpTool.h.

{this, "LTQuadStepFilt"     , false     , "Use LT Quad Step Filter waveform for ZDC channels"                   };

m_mergedFiberHitList

ZDC_SimFiberHit_Collection* ZDC_PileUpTool::m_mergedFiberHitList {}

private

Definition at line 75 of file ZDC_PileUpTool.h.

{};

m_mergeSvc

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

private

Definition at line 80 of file ZDC_PileUpTool.h.

{this, "mergeSvc", "PileUpMergeSvc", ""};

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 95 of file ZDC_PileUpTool.h.

{this, "MaxTimeBin"         , 7         , "The number of time-slices after digitization(Typically 5 or 7)"      };

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 90 of file ZDC_PileUpTool.h.

                                                {this, "OutputContainerName" , "ZDC_SimModuleContainer",
      "Name of the output ZDC module container"};

m_Pedestal

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

private

Definition at line 94 of file ZDC_PileUpTool.h.

{this, "Pedestal"           , 100       , "DC offset of the pulse in ADC"                                       };

m_qsfFallTime

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

private

Definition at line 104 of file ZDC_PileUpTool.h.

{this, "qsfFallTime"        , 4         , "Rise time of the RPD pulses"                                         };

m_qsfFilter

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

private

Definition at line 105 of file ZDC_PileUpTool.h.

{this, "qsfFilter"          , 4         , "Rise time of the RPD pulses"                                         };

m_qsfRiseTime

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

private

Definition at line 103 of file ZDC_PileUpTool.h.

{this, "qsfRiseTime"        , 4         , "Rise time of the RPD pulses"                                         };

m_randomStreamName

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

private

Definition at line 82 of file ZDC_PileUpTool.h.

{this, "RandomStreamName", "ZDCRndEng", ""};

m_randomSvc

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

private

Definition at line 81 of file ZDC_PileUpTool.h.

{this, "RndmSvc", "AthRNGSvc", ""};

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 111 of file ZDC_PileUpTool.h.

{this, "rpdAdcPerPhoton", {5.25 , 1.7}, "ADC counts per detected photon in the RPDs"};

m_rpdFallTime

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

private

Definition at line 102 of file ZDC_PileUpTool.h.

{this, "rpdFallTime"        , 0.5       , "Fall time of the RPD pulses"                                         };

m_rpdRiseTime

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

private

Definition at line 101 of file ZDC_PileUpTool.h.

{this, "rpdRiseTime"        , 4         , "Rise time of the RPD pulses"                                         };

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 98 of file ZDC_PileUpTool.h.

{this, "rpdt0"              , 40        , "Start time of the pulse in the digitization window"                  };

m_SimFiberHitCollectionKey

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

private

Definition at line 84 of file ZDC_PileUpTool.h.

{this, "ZDC_SimFiberHit_CollectionName", "ZDC_SimFiberHit_Collection"};

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.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

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 106 of file ZDC_PileUpTool.h.

{this, "zdcAdcPerPhoton"    , 0.000498  , "ADC counts per detected photon in the ZDCs"                          };

m_zdcFallTime

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

private

Definition at line 100 of file ZDC_PileUpTool.h.

{this, "zdcFallTime"        , 0.5       , "Fall time of the ZDC pulses"                                         };

m_ZdcID

const ZdcID* ZDC_PileUpTool::m_ZdcID {}

private

Definition at line 76 of file ZDC_PileUpTool.h.

{};

m_ZdcModuleAuxContainer

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

private

Definition at line 78 of file ZDC_PileUpTool.h.

m_ZdcModuleContainer

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

private

Definition at line 77 of file ZDC_PileUpTool.h.

m_ZdcModuleContainerName

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

private

Definition at line 85 of file ZDC_PileUpTool.h.

{this, "ZdcModuleContainerName", "ZdcModules"};

m_zdcRiseTime

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

private

Definition at line 99 of file ZDC_PileUpTool.h.

{this, "zdcRiseTime"        , 4         , "Rise time of the ZDC pulses"                                         };

m_ZdcSumsContainerName

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

private

Definition at line 86 of file ZDC_PileUpTool.h.

{this, "ZdcSumsContainerName", "ZdcSums"};

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 97 of file ZDC_PileUpTool.h.

{this, "zdct0"              , 40        , "Start time of the pulse in the digitization window"                  };

---

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

• ZDC_PileUpTool.h
• ZDC_PileUpTool.cxx