#include <SiPixelDigitizer.h>

Inheritance diagram for cms::SiPixelDigitizer:

Public Member Functions
void	accumulate (edm::Event const &e, edm::EventSetup const &c) override

void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, edm::StreamID const &) override

virtual void	beginJob ()

void	finalizeEvent (edm::Event &e, edm::EventSetup const &c) override

PileupMixingContent *	getEventPileupInfo () override

void	initializeEvent (edm::Event const &e, edm::EventSetup const &c) override

	SiPixelDigitizer (const edm::ParameterSet &conf, edm::ProducesCollector, edm::ConsumesCollector &iC)

void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventInfoList, int bunchSpacing) override

	~SiPixelDigitizer () override

Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)

	DigiAccumulatorMixMod ()

	DigiAccumulatorMixMod (DigiAccumulatorMixMod const &)=delete

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)

virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

DigiAccumulatorMixMod const &	operator= (DigiAccumulatorMixMod const &)=delete

virtual	~DigiAccumulatorMixMod ()

Private Types
typedef std::vector< std::string >	vstring

Private Member Functions
void	accumulatePixelHits (edm::Handle< std::vector< PSimHit > >, size_t globalSimHitIndex, const unsigned int tofBin, edm::EventSetup const &c)

Private Attributes
std::unique_ptr< SiPixelDigitizerAlgorithm >	_pixeldigialgo

bool	applyLateReweighting_

std::map< std::string, size_t >	crossingSimHitIndexOffset_
	Offset to add to the index of each sim hit to account for which crossing it's in. More...

std::map< unsigned int, PixelGeomDetUnit const * >	detectorUnits

bool	firstFinalizeEvent_

bool	firstInitializeEvent_

const std::string	hitsProducer

bool	makeDigiSimLinks_

const int	NumberOfEndcapDisks

const TrackerGeometry *	pDD = nullptr

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	pDDToken_

std::unique_ptr< PileupMixingContent >	PileupInfo_

const bool	pilotBlades

const MagneticField *	pSetup = nullptr

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	pSetupToken_

CLHEP::HepRandomEngine *	randomEngine_ = nullptr

const bool	store_SimHitEntryExitPoints_

const vstring	trackerContainers

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Detailed Description

Definition at line 44 of file SiPixelDigitizer.h.

Member Typedef Documentation

◆ vstring

typedef std::vector<std::string> cms::SiPixelDigitizer::vstring

private

Definition at line 90 of file SiPixelDigitizer.h.

Constructor & Destructor Documentation

◆ SiPixelDigitizer()

SiPixelDigitizer::SiPixelDigitizer	(	const edm::ParameterSet &	conf,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 82 of file SiPixelDigitizer.cc.

References _pixeldigialgo, SiStripOfflineCRack_cfg::alias, applyLateReweighting_, edm::ConsumesCollector::consumes(), Exception, hitsProducer, ProducerED_cfi::InputTag, edm::Service< T >::isAvailable(), NumberOfEndcapDisks, edm::ProducesCollector::produces(), store_SimHitEntryExitPoints_, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, and trackerContainers.

       : firstInitializeEvent_(true),
         firstFinalizeEvent_(true),
         applyLateReweighting_(
             iConfig.exists("applyLateReweighting") ? iConfig.getParameter<bool>("applyLateReweighting") : false),
         store_SimHitEntryExitPoints_(iConfig.exists("store_SimHitEntryExitPoints")
                                          ? iConfig.getParameter<bool>("store_SimHitEntryExitPoints")
                                          : false),
         _pixeldigialgo(),
         hitsProducer(iConfig.getParameter<std::string>("hitsProducer")),
         trackerContainers(iConfig.getParameter<std::vector<std::string> >("RoutList")),
         pilotBlades(iConfig.exists("enablePilotBlades") ? iConfig.getParameter<bool>("enablePilotBlades") : false),
         NumberOfEndcapDisks(iConfig.exists("NumPixelEndcap") ? iConfig.getParameter<int>("NumPixelEndcap") : 2),
         tTopoToken_(iC.esConsumes()),
         pDDToken_(iC.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("PixGeometryType")))),
         pSetupToken_(iC.esConsumes()) {
     edm::LogInfo("PixelDigitizer ") << "Enter the Pixel Digitizer";
 
     edm::LogInfo("PixelDigitizer ") << " applyLateReweighting_ " << applyLateReweighting_;
 
     const std::string alias("simSiPixelDigis");
 
     producesCollector.produces<edm::DetSetVector<PixelDigi> >().setBranchAlias(alias);
     producesCollector.produces<edm::DetSetVector<PixelDigiSimLink> >().setBranchAlias(alias + "siPixelDigiSimLink");
     if (store_SimHitEntryExitPoints_)
       producesCollector.produces<edm::DetSetVector<PixelSimHitExtraInfo> >().setBranchAlias(alias +
                                                                                             "siPixelExtraSimHit");
 
     for (auto const& trackerContainer : trackerContainers) {
       edm::InputTag tag(hitsProducer, trackerContainer);
       iC.consumes<std::vector<PSimHit> >(edm::InputTag(hitsProducer, trackerContainer));
     }
     edm::Service<edm::RandomNumberGenerator> rng;
     if (!rng.isAvailable()) {
       throw cms::Exception("Configuration")
           << "SiPixelDigitizer requires the RandomNumberGeneratorService\n"
              "which is not present in the configuration file.  You must add the service\n"
              "in the configuration file or remove the modules that require it.";
     }
 
     _pixeldigialgo = std::make_unique<SiPixelDigitizerAlgorithm>(iConfig, iC);
     if (NumberOfEndcapDisks != 2)
       producesCollector.produces<PixelFEDChannelCollection>();
   }

◆ ~SiPixelDigitizer()

SiPixelDigitizer::~SiPixelDigitizer ( )

override

Definition at line 129 of file SiPixelDigitizer.cc.

129 { edm::LogInfo("PixelDigitizer ") << "Destruct the Pixel Digitizer"; }

edm::LogInfo

Log< level::Info, false > LogInfo

Definition: MessageLogger.h:131

Member Function Documentation

◆ accumulate() [1/2]

void SiPixelDigitizer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 213 of file SiPixelDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, PixelDigiSimLink::HighTof, hitsProducer, mps_fire::i, iEvent, PixelDigiSimLink::LowTof, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, and trackerContainers.

                                                                                        {
     // Step A: Get Inputs
     for (vstring::const_iterator i = trackerContainers.begin(), iEnd = trackerContainers.end(); i != iEnd; ++i) {
       edm::Handle<std::vector<PSimHit> > simHits;
       edm::InputTag tag(hitsProducer, *i);
 
       iEvent.getByLabel(tag, simHits);
       unsigned int tofBin = PixelDigiSimLink::LowTof;
       if ((*i).find(std::string("HighTof")) != std::string::npos)
         tofBin = PixelDigiSimLink::HighTof;
       accumulatePixelHits(simHits, crossingSimHitIndexOffset_[tag.encode()], tofBin, iSetup);
       // Now that the hits have been processed, I'll add the amount of hits in this crossing on to
       // the global counter. Next time accumulateStripHits() is called it will count the sim hits
       // as though they were on the end of this collection.
       // Note that this is only used for creating digi-sim links (if configured to do so).
       //       std::cout << "index offset, current hit count = " << crossingSimHitIndexOffset_[tag.encode()] << ", " << simHits->size() << std::endl;
       if (simHits.isValid())
         crossingSimHitIndexOffset_[tag.encode()] += simHits->size();
     }
   }

◆ accumulate() [2/2]

void SiPixelDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		edm::StreamID const &	streamID
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 234 of file SiPixelDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, PixelDigiSimLink::HighTof, hitsProducer, mps_fire::i, iEvent, PixelDigiSimLink::LowTof, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, and trackerContainers.

                                                                  {
     // Step A: Get Inputs
     for (vstring::const_iterator i = trackerContainers.begin(), iEnd = trackerContainers.end(); i != iEnd; ++i) {
       edm::Handle<std::vector<PSimHit> > simHits;
       edm::InputTag tag(hitsProducer, *i);
 
       iEvent.getByLabel(tag, simHits);
       unsigned int tofBin = PixelDigiSimLink::LowTof;
       if ((*i).find(std::string("HighTof")) != std::string::npos)
         tofBin = PixelDigiSimLink::HighTof;
       accumulatePixelHits(simHits, crossingSimHitIndexOffset_[tag.encode()], tofBin, iSetup);
       // Now that the hits have been processed, I'll add the amount of hits in this crossing on to
       // the global counter. Next time accumulateStripHits() is called it will count the sim hits
       // as though they were on the end of this collection.
       // Note that this is only used for creating digi-sim links (if configured to do so).
       //       std::cout << "index offset, current hit count = " << crossingSimHitIndexOffset_[tag.encode()] << ", " << simHits->size() << std::endl;
       if (simHits.isValid())
         crossingSimHitIndexOffset_[tag.encode()] += simHits->size();
     }
   }

◆ accumulatePixelHits()

void SiPixelDigitizer::accumulatePixelHits	(	edm::Handle< std::vector< PSimHit > >	hSimHits,
		size_t	globalSimHitIndex,
		const unsigned int	tofBin,
		edm::EventSetup const &	c
	)

private

Definition at line 135 of file SiPixelDigitizer.cc.

References _pixeldigialgo, cms::cuda::assert(), detectorUnits, hcalRecHitTable_cff::detId, edm::EventSetup::getData(), MagneticField::inTesla(), GeomDetEnumerators::isTrackerPixel(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogDebug, pSetup, randomEngine_, FastTrackerRecHitCombiner_cfi::simHits, and tTopoToken_.

Referenced by accumulate().

                                                                           {
     if (hSimHits.isValid()) {
       std::set<unsigned int> detIds;
       std::vector<PSimHit> const& simHits = *hSimHits.product();
       const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
       _pixeldigialgo->fillSimHitMaps(simHits, tofBin);
       for (std::vector<PSimHit>::const_iterator it = simHits.begin(), itEnd = simHits.end(); it != itEnd;
            ++it, ++globalSimHitIndex) {
         unsigned int detId = (*it).detUnitId();
         if (detIds.insert(detId).second) {
           // The insert succeeded, so this detector element has not yet been processed.
           assert(detectorUnits[detId]);
           if (detectorUnits[detId] &&
               detectorUnits[detId]
                   ->type()
                   .isTrackerPixel()) {  // this test could be avoided and changed into a check of pixdet!=0
             std::map<unsigned int, PixelGeomDetUnit const*>::iterator itDet = detectorUnits.find(detId);
             if (itDet == detectorUnits.end())
               continue;
             auto pixdet = itDet->second;
             assert(pixdet != nullptr);
             //access to magnetic field in global coordinates
             GlobalVector bfield = pSetup->inTesla(pixdet->surface().position());
             LogDebug("PixelDigitizer ") << "B-field(T) at " << pixdet->surface().position()
                                         << "(cm): " << pSetup->inTesla(pixdet->surface().position());
             _pixeldigialgo->accumulateSimHits(
                 it, itEnd, globalSimHitIndex, tofBin, pixdet, bfield, tTopo, randomEngine_);
           }
         }
       }
     }
   }

◆ beginJob()

virtual void cms::SiPixelDigitizer::beginJob ( void )

inlinevirtual

Definition at line 55 of file SiPixelDigitizer.h.

55 {}

◆ finalizeEvent()

void SiPixelDigitizer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 258 of file SiPixelDigitizer.cc.

References _pixeldigialgo, applyLateReweighting_, edm::DetSet< T >::begin(), TrackerGeometry::detUnits(), edm::DetSet< T >::empty(), edm::DetSet< T >::end(), Exception, firstFinalizeEvent_, edm::EventSetup::getData(), iEvent, eostools::move(), convertSQLitetoXML_cfg::output, pDD, PileupInfo_, randomEngine_, store_SimHitEntryExitPoints_, and tTopoToken_.

                                                                                     {
     const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
     std::vector<edm::DetSet<PixelDigi> > theDigiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > theDigiLinkVector;
     std::vector<edm::DetSet<PixelSimHitExtraInfo> > theExtraSimHitInfoVector;
 
     if (firstFinalizeEvent_) {
       _pixeldigialgo->init_DynIneffDB(iSetup);
       firstFinalizeEvent_ = false;
     }
     _pixeldigialgo->calculateInstlumiFactor(PileupInfo_.get());
 
     if (_pixeldigialgo->killBadFEDChannels()) {
       std::unique_ptr<PixelFEDChannelCollection> PixelFEDChannelCollection_ =
           _pixeldigialgo->chooseScenario(PileupInfo_.get(), randomEngine_);
       if (PixelFEDChannelCollection_ == nullptr) {
         throw cms::Exception("NullPointerError") << "PixelFEDChannelCollection not set in chooseScenario function.\n";
       }
       iEvent.put(std::move(PixelFEDChannelCollection_));
     }
 
     for (const auto& iu : pDD->detUnits()) {
       if (iu->type().isTrackerPixel()) {
         //
 
         edm::DetSet<PixelDigi> collector(iu->geographicalId().rawId());
         edm::DetSet<PixelDigiSimLink> linkcollector(iu->geographicalId().rawId());
         std::vector<PixelDigiAddTempInfo> tempcollector;
         edm::DetSet<PixelSimHitExtraInfo> tempSHcollector(iu->geographicalId().rawId());
 
         _pixeldigialgo->digitize(dynamic_cast<const PixelGeomDetUnit*>(iu),
                                  collector.data,
                                  linkcollector.data,
                                  tempcollector,
                                  tTopo,
                                  randomEngine_);
 
         // transformation of the tempcollector  (October 15, 2021)
         if (!tempcollector.empty()) {
           std::vector<PixelDigiAddTempInfo>::const_iterator loopNewClass;
           unsigned int channelPrevious2 = -1;
           size_t hitFirstOne2 = -1;
           for (loopNewClass = tempcollector.begin(); loopNewClass != tempcollector.end(); ++loopNewClass) {
             //   check if the new SimHit already exists in the class
             //      if yes : add only the Digi info to the existing entry
             //      if not : create a new entry
             //          PixelSimHitExtraInfo(
             //          size_t Hindex, Local3DPoint entryP , Local3DPoint exitP, uint32_t detID, std::vector<unsigned int> ch, std::vector<float> InitCharge)
             //   what about the duplicates : 2 SimHits associated to the same Digis ?
             //
             //
 
             bool checkTwoSimHits = false;
             if (channelPrevious2 == loopNewClass->channel() && hitFirstOne2 != loopNewClass->hitIndex()) {
               // case of one Digi associated to a second SimHit
               checkTwoSimHits = true;
             } else {
               channelPrevious2 = loopNewClass->channel();
               hitFirstOne2 = loopNewClass->hitIndex();
             }
 
             bool checkInTheList = false;
             if (!checkTwoSimHits) {
               std::vector<PixelSimHitExtraInfo>::iterator loopTempSH;
               for (loopTempSH = tempSHcollector.begin(); loopTempSH != tempSHcollector.end(); ++loopTempSH) {
                 if (loopNewClass->hitIndex() == loopTempSH->hitIndex()) {
                   checkInTheList = true;
                   loopTempSH->addDigiInfo(loopNewClass->channel());
                 }
               }
               if (!checkInTheList) {
                 PixelSimHitExtraInfo newSHEntry(loopNewClass->hitIndex(),
                                                 loopNewClass->entryPoint(),
                                                 loopNewClass->exitPoint(),
                                                 loopNewClass->channel());
                 tempSHcollector.push_back(newSHEntry);
               }
             }
           }
         }
 
         if (applyLateReweighting_) {
           // if applyLateReweighting_  is true, the charge reweighting has to be applied on top of the digis
           _pixeldigialgo->lateSignalReweight(
               dynamic_cast<const PixelGeomDetUnit*>(iu), collector.data, tempSHcollector.data, tTopo, randomEngine_);
         }
 
         if (!collector.data.empty()) {
           theDigiVector.push_back(std::move(collector));
         }
         if (!linkcollector.data.empty()) {
           theDigiLinkVector.push_back(std::move(linkcollector));
         }
         if (!tempSHcollector.data.empty()) {
           theExtraSimHitInfoVector.push_back(std::move(tempSHcollector));
         }
       }
     }
     _pixeldigialgo->resetSimHitMaps();
 
     // Step C: create collection with the cache vector of DetSet
     std::unique_ptr<edm::DetSetVector<PixelDigi> > output(new edm::DetSetVector<PixelDigi>(theDigiVector));
     std::unique_ptr<edm::DetSetVector<PixelDigiSimLink> > outputlink(
         new edm::DetSetVector<PixelDigiSimLink>(theDigiLinkVector));
     std::unique_ptr<edm::DetSetVector<PixelSimHitExtraInfo> > outputExtraSim(
         new edm::DetSetVector<PixelSimHitExtraInfo>(theExtraSimHitInfoVector));
 
     // Step D: write output to file
     iEvent.put(std::move(output));
     iEvent.put(std::move(outputlink));
     if (store_SimHitEntryExitPoints_)
       iEvent.put(std::move(outputExtraSim));
 
     randomEngine_ = nullptr;  // to prevent access outside event
   }

◆ getEventPileupInfo()

PileupMixingContent* cms::SiPixelDigitizer::getEventPileupInfo ( )

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 66 of file SiPixelDigitizer.h.

References PileupInfo_.

66 { return PileupInfo_.get(); }

cms::SiPixelDigitizer::PileupInfo_

std::unique_ptr< PileupMixingContent > PileupInfo_

Definition: SiPixelDigitizer.h:98

◆ initializeEvent()

void SiPixelDigitizer::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 171 of file SiPixelDigitizer.cc.

References _pixeldigialgo, cms::cuda::assert(), crossingSimHitIndexOffset_, detectorUnits, hcalRecHitTable_cff::detId, TrackerGeometry::detUnits(), MillePedeFileConverter_cfg::e, firstInitializeEvent_, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), TrackerTopology::layer(), NumberOfEndcapDisks, pDD, pDDToken_, pilotBlades, GeomDetEnumerators::PixelEndcap, pSetup, pSetupToken_, randomEngine_, and tTopoToken_.

                                                                                        {
     if (firstInitializeEvent_) {
       _pixeldigialgo->init(iSetup);
       firstInitializeEvent_ = false;
     }
 
     // Make sure that the first crossing processed starts indexing the sim hits from zero.
     // This variable is used so that the sim hits from all crossing frames have sequential
     // indices used to create the digi-sim link (if configured to do so) rather than starting
     // from zero for each crossing.
     crossingSimHitIndexOffset_.clear();
 
     // Cache random number engine
     edm::Service<edm::RandomNumberGenerator> rng;
     randomEngine_ = &rng->getEngine(e.streamID());
 
     _pixeldigialgo->initializeEvent();
     pDD = &iSetup.getData(pDDToken_);
     pSetup = &iSetup.getData(pSetupToken_);
     const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
     // FIX THIS! We only need to clear and (re)fill this map when the geometry type IOV changes.  Use ESWatcher to determine this.
     if (true) {  // Replace with ESWatcher
       detectorUnits.clear();
       for (const auto& iu : pDD->detUnits()) {
         unsigned int detId = iu->geographicalId().rawId();
         if (iu->type().isTrackerPixel()) {
           auto pixdet = dynamic_cast<const PixelGeomDetUnit*>(iu);
           assert(pixdet != nullptr);
           if (iu->subDetector() ==
               GeomDetEnumerators::SubDetector::PixelEndcap) {  // true ONLY for the phase 0 pixel deetctor
             unsigned int disk = tTopo->layer(detId);           // using the generic layer method
             //if using pilot blades, then allowing it for current detector only
             if ((disk == 3) && ((!pilotBlades) && (NumberOfEndcapDisks == 2)))
               continue;
           }
           detectorUnits.insert(std::make_pair(detId, pixdet));
         }
       }
     }
   }

◆ StorePileupInformation()

void cms::SiPixelDigitizer::StorePileupInformation	(	std::vector< int > &	numInteractionList,
		std::vector< int > &	bunchCrossingList,
		std::vector< float > &	TrueInteractionList,
		std::vector< edm::EventID > &	eventInfoList,
		int	bunchSpacing
	)

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 57 of file SiPixelDigitizer.h.

References genPUProtons_cfi::bunchCrossingList, hltParticleFlowClusterECAL_cfi::bunchSpacing, and PileupInfo_.

                                                            {
       PileupInfo_ = std::make_unique<PileupMixingContent>(
           numInteractionList, bunchCrossingList, TrueInteractionList, eventInfoList, bunchSpacing);
     }

Member Data Documentation

◆ _pixeldigialgo

std::unique_ptr<SiPixelDigitizerAlgorithm> cms::SiPixelDigitizer::_pixeldigialgo

private

Definition at line 79 of file SiPixelDigitizer.h.

Referenced by accumulatePixelHits(), finalizeEvent(), initializeEvent(), and SiPixelDigitizer().

◆ applyLateReweighting_

bool cms::SiPixelDigitizer::applyLateReweighting_

private

Definition at line 76 of file SiPixelDigitizer.h.

Referenced by finalizeEvent(), and SiPixelDigitizer().

◆ crossingSimHitIndexOffset_

std::map<std::string, size_t> cms::SiPixelDigitizer::crossingSimHitIndexOffset_

private

Offset to add to the index of each sim hit to account for which crossing it's in.

I need to know what each sim hit index will be when the hits from all crossing frames are merged into one collection (assuming the MixingModule is configured to create the crossing frame for all sim hits). To do this I'll record how many hits were in each crossing, and then add that on to the index for a given hit in a given crossing. This assumes that the crossings are processed in the same order here as they are put into the crossing frame, which I'm pretty sure is true.
The key is the name of the sim hit collection.

Definition at line 88 of file SiPixelDigitizer.h.

Referenced by accumulate(), and initializeEvent().