#include <HcalDigitizer.h>

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

void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *)

void	finalizeEvent (edm::Event &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *)

	HcalDigitizer (const edm::ParameterSet &ps, edm::ConsumesCollector &iC)

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

void	setHBHENoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setHFNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setHONoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setQIE10NoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setQIE11NoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setZDCNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

virtual	~HcalDigitizer ()

Private Types
typedef CaloTDigitizer< HBHEDigitizerTraits, CaloTDigitizerQIE8Run >	HBHEDigitizer

typedef CaloTDigitizer< HFDigitizerTraits, CaloTDigitizerQIE8Run >	HFDigitizer

typedef CaloTDigitizer< HODigitizerTraits, CaloTDigitizerQIE8Run >	HODigitizer

typedef CaloTDigitizer< HcalQIE10DigitizerTraits, CaloTDigitizerQIE1011Run >	QIE10Digitizer

typedef CaloTDigitizer< HcalQIE11DigitizerTraits, CaloTDigitizerQIE1011Run >	QIE11Digitizer

typedef CaloTDigitizer< ZDCDigitizerTraits, CaloTDigitizerQIE8Run >	ZDCDigitizer

Private Member Functions
void	accumulateCaloHits (edm::Handle< std::vector< PCaloHit >> const &hcalHits, edm::Handle< std::vector< PCaloHit >> const &zdcHits, int bunchCrossing, CLHEP::HepRandomEngine , const HcalTopology h)

void	buildHBHEQIECells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)

void	buildHFQIECells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)

void	buildHOSiPMCells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)

void	checkGeometry (const edm::EventSetup &eventSetup)

void	darkening (std::vector< PCaloHit > &hcalHits)

void	fillFakeHits ()
	some hits in each subdetector, just for testing purposes More...

void	setup (const edm::EventSetup &es)

void	updateGeometry (const edm::EventSetup &eventSetup)

Private Attributes
bool	agingFlagHB

bool	agingFlagHE

bool	debugCS_

double	deliveredLumi

bool	doHFWindow_

std::vector< DetId >	hbheCells

bool	hbhegeo

const HcalTimeSlew *	hcalTimeSlew_delay_

bool	hfgeo

std::string	hitsProducer_

bool	hogeo

bool	ignoreTime_

std::vector< PCaloHit >	injectedHits_

std::vector< int >	injectedHitsCells_

std::vector< double >	injectedHitsEnergy_

std::vector< double >	injectedHitsTime_

bool	injectTestHits_

bool	isHCAL

bool	isZDC

bool	killHE_

const HBHEDarkening *	m_HBDarkening

const HBHEDarkening *	m_HEDarkening

std::unique_ptr< HFRecalibration >	m_HFRecalibration

bool	testNumbering_

std::unique_ptr< HcalCoderFactory >	theCoderFactory

const CaloGeometry *	theGeometry

edm::ESWatcher< CaloGeometryRecord >	theGeometryWatcher_

std::unique_ptr< HcalAmplifier >	theHBHEAmplifier

std::unique_ptr< HBHEDigitizer >	theHBHEDigitizer

std::unique_ptr< HcalElectronicsSim >	theHBHEElectronicsSim

HBHEHitFilter	theHBHEHitFilter

std::unique_ptr< HcalAmplifier >	theHBHEQIE11Amplifier

std::vector< DetId >	theHBHEQIE11DetIds

std::unique_ptr< QIE11Digitizer >	theHBHEQIE11Digitizer

std::unique_ptr< HcalElectronicsSim >	theHBHEQIE11ElectronicsSim

HBHEHitFilter	theHBHEQIE11HitFilter

std::vector< DetId >	theHBHEQIE8DetIds

std::unique_ptr< CaloHitResponse >	theHBHEResponse

std::unique_ptr< HcalSiPMHitResponse >	theHBHESiPMResponse

std::unique_ptr< HcalAmplifier >	theHFAmplifier

std::unique_ptr< HFDigitizer >	theHFDigitizer

std::unique_ptr< HcalElectronicsSim >	theHFElectronicsSim

HFHitFilter	theHFHitFilter

std::unique_ptr< HcalAmplifier >	theHFQIE10Amplifier

std::vector< DetId >	theHFQIE10DetIds

std::unique_ptr< QIE10Digitizer >	theHFQIE10Digitizer

std::unique_ptr< HcalElectronicsSim >	theHFQIE10ElectronicsSim

HFHitFilter	theHFQIE10HitFilter

std::unique_ptr< CaloHitResponse >	theHFQIE10Response

std::vector< DetId >	theHFQIE8DetIds

std::unique_ptr< CaloHitResponse >	theHFResponse

std::unique_ptr< HcalAmplifier >	theHOAmplifier

std::unique_ptr< HODigitizer >	theHODigitizer

std::unique_ptr< HcalElectronicsSim >	theHOElectronicsSim

HOHitFilter	theHOHitFilter

std::vector< DetId >	theHOHPDDetIds

std::unique_ptr< CaloHitResponse >	theHOResponse

int	theHOSiPMCode

std::vector< DetId >	theHOSiPMDetIds

std::unique_ptr< HODigitizer >	theHOSiPMDigitizer

HOHitFilter	theHOSiPMHitFilter

std::unique_ptr< HcalSiPMHitResponse >	theHOSiPMResponse

std::unique_ptr< HPDIonFeedbackSim >	theIonFeedback

HcalSimParameterMap	theParameterMap

const HcalDDDRecConstants *	theRecNumber

edm::ESWatcher< HcalRecNumberingRecord >	theRecNumberWatcher_

std::unique_ptr< HcalHitRelabeller >	theRelabeller

HcalShapes	theShapes

std::unique_ptr< HcalTimeSlewSim >	theTimeSlewSim

std::unique_ptr< HcalAmplifier >	theZDCAmplifier

std::unique_ptr< ZDCDigitizer >	theZDCDigitizer

std::unique_ptr< HcalElectronicsSim >	theZDCElectronicsSim

ZDCHitFilter	theZDCHitFilter

std::unique_ptr< CaloHitResponse >	theZDCResponse

bool	zdcgeo

Detailed Description

Definition at line 46 of file HcalDigitizer.h.

Member Typedef Documentation

◆ HBHEDigitizer

typedef CaloTDigitizer<HBHEDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HBHEDigitizer

private

Reconstruction algorithm

Definition at line 91 of file HcalDigitizer.h.

◆ HFDigitizer

typedef CaloTDigitizer<HFDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer

private

Definition at line 93 of file HcalDigitizer.h.

◆ HODigitizer

typedef CaloTDigitizer<HODigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer

private

Definition at line 92 of file HcalDigitizer.h.

◆ QIE10Digitizer

typedef CaloTDigitizer<HcalQIE10DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer

private

Definition at line 95 of file HcalDigitizer.h.

◆ QIE11Digitizer

typedef CaloTDigitizer<HcalQIE11DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer

private

Definition at line 96 of file HcalDigitizer.h.

◆ ZDCDigitizer

typedef CaloTDigitizer<ZDCDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer

private

Definition at line 94 of file HcalDigitizer.h.

Constructor & Destructor Documentation

◆ HcalDigitizer()

HcalDigitizer::HcalDigitizer	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 38 of file HcalDigitizer.cc.

     : theGeometry(nullptr),
       theRecNumber(nullptr),
       theParameterMap(ps),
       theShapes(),
       theHBHEResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
       theHBHESiPMResponse(std::make_unique<HcalSiPMHitResponse>(
           &theParameterMap, &theShapes, ps.getParameter<bool>("HcalPreMixStage1"), true)),
       theHOResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
       theHOSiPMResponse(std::make_unique<HcalSiPMHitResponse>(
           &theParameterMap, &theShapes, ps.getParameter<bool>("HcalPreMixStage1"), false)),
       theHFResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
       theHFQIE10Response(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
       theZDCResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
       theHBHEAmplifier(nullptr),
       theHFAmplifier(nullptr),
       theHOAmplifier(nullptr),
       theZDCAmplifier(nullptr),
       theHFQIE10Amplifier(nullptr),
       theHBHEQIE11Amplifier(nullptr),
       theIonFeedback(nullptr),
       theCoderFactory(nullptr),
       theHBHEElectronicsSim(nullptr),
       theHFElectronicsSim(nullptr),
       theHOElectronicsSim(nullptr),
       theZDCElectronicsSim(nullptr),
       theHFQIE10ElectronicsSim(nullptr),
       theHBHEQIE11ElectronicsSim(nullptr),
       theHBHEHitFilter(),
       theHBHEQIE11HitFilter(),
       theHFHitFilter(),
       theHFQIE10HitFilter(),
       theHOHitFilter(),
       theHOSiPMHitFilter(),
       theZDCHitFilter(),
       theHBHEDigitizer(nullptr),
       theHODigitizer(nullptr),
       theHOSiPMDigitizer(nullptr),
       theHFDigitizer(nullptr),
       theZDCDigitizer(nullptr),
       theHFQIE10Digitizer(nullptr),
       theHBHEQIE11Digitizer(nullptr),
       theRelabeller(nullptr),
       isZDC(true),
       isHCAL(true),
       zdcgeo(true),
       hbhegeo(true),
       hogeo(true),
       hfgeo(true),
       doHFWindow_(ps.getParameter<bool>("doHFWindow")),
       killHE_(ps.getParameter<bool>("killHE")),
       debugCS_(ps.getParameter<bool>("debugCaloSamples")),
       ignoreTime_(ps.getParameter<bool>("ignoreGeantTime")),
       injectTestHits_(ps.getParameter<bool>("injectTestHits")),
       hitsProducer_(ps.getParameter<std::string>("hitsProducer")),
       theHOSiPMCode(ps.getParameter<edm::ParameterSet>("ho").getParameter<int>("siPMCode")),
       deliveredLumi(0.),
       agingFlagHB(ps.getParameter<bool>("HBDarkening")),
       agingFlagHE(ps.getParameter<bool>("HEDarkening")),
       m_HBDarkening(nullptr),
       m_HEDarkening(nullptr),
       m_HFRecalibration(nullptr),
       injectedHitsEnergy_(ps.getParameter<std::vector<double>>("injectTestHitsEnergy")),
       injectedHitsTime_(ps.getParameter<std::vector<double>>("injectTestHitsTime")),
       injectedHitsCells_(ps.getParameter<std::vector<int>>("injectTestHitsCells")) {
   iC.consumes<std::vector<PCaloHit>>(edm::InputTag(hitsProducer_, "ZDCHITS"));
   iC.consumes<std::vector<PCaloHit>>(edm::InputTag(hitsProducer_, "HcalHits"));
  
   bool doNoise = ps.getParameter<bool>("doNoise");
  
   bool PreMix1 = ps.getParameter<bool>("HcalPreMixStage1");  // special threshold/pedestal treatment
   bool PreMix2 = ps.getParameter<bool>("HcalPreMixStage2");  // special threshold/pedestal treatment
   bool doEmpty = ps.getParameter<bool>("doEmpty");
   deliveredLumi = ps.getParameter<double>("DelivLuminosity");
   bool agingFlagHF = ps.getParameter<bool>("HFDarkening");
   double minFCToDelay = ps.getParameter<double>("minFCToDelay");
  
   if (PreMix1 && PreMix2) {
     throw cms::Exception("Configuration") << "HcalDigitizer cannot operate in PreMixing digitization and "
                                              "PreMixing\n"
                                              "digi combination modes at the same time.  Please set one mode to "
                                              "False\n"
                                              "in the configuration file.";
   }
  
   // need to make copies, because they might get different noise generators
   theHBHEAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
   theHFAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
   theHOAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
   theZDCAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
   theHFQIE10Amplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
   theHBHEQIE11Amplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
  
   theCoderFactory = std::make_unique<HcalCoderFactory>(HcalCoderFactory::DB);
  
   theHBHEElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap, theHBHEAmplifier.get(), theCoderFactory.get(), PreMix1);
   theHFElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap, theHFAmplifier.get(), theCoderFactory.get(), PreMix1);
   theHOElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap, theHOAmplifier.get(), theCoderFactory.get(), PreMix1);
   theZDCElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap, theZDCAmplifier.get(), theCoderFactory.get(), PreMix1);
   theHFQIE10ElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap,
                                            theHFQIE10Amplifier.get(),
                                            theCoderFactory.get(),
                                            PreMix1);  // should this use a different coder factory?
   theHBHEQIE11ElectronicsSim =
       std::make_unique<HcalElectronicsSim>(&theParameterMap,
                                            theHBHEQIE11Amplifier.get(),
                                            theCoderFactory.get(),
                                            PreMix1);  // should this use a different coder factory?
  
   bool doHOHPD = (theHOSiPMCode != 1);
   bool doHOSiPM = (theHOSiPMCode != 0);
   if (doHOHPD) {
     theHOResponse = std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes);
     theHOResponse->setHitFilter(&theHOHitFilter);
     theHODigitizer = std::make_unique<HODigitizer>(theHOResponse.get(), theHOElectronicsSim.get(), doEmpty);
   }
   if (doHOSiPM) {
     theHOSiPMResponse->setHitFilter(&theHOSiPMHitFilter);
     theHOSiPMDigitizer = std::make_unique<HODigitizer>(theHOSiPMResponse.get(), theHOElectronicsSim.get(), doEmpty);
   }
  
   theHBHEResponse->setHitFilter(&theHBHEHitFilter);
   theHBHESiPMResponse->setHitFilter(&theHBHEQIE11HitFilter);
  
   // QIE8 and QIE11 can coexist in HBHE
   theHBHEQIE11Digitizer =
       std::make_unique<QIE11Digitizer>(theHBHESiPMResponse.get(), theHBHEQIE11ElectronicsSim.get(), doEmpty);
   theHBHEDigitizer = std::make_unique<HBHEDigitizer>(theHBHEResponse.get(), theHBHEElectronicsSim.get(), doEmpty);
  
   bool doTimeSlew = ps.getParameter<bool>("doTimeSlew");
   // initialize: they won't be called later if flag is set
   hcalTimeSlew_delay_ = nullptr;
   theTimeSlewSim.reset(nullptr);
   if (doTimeSlew) {
     // no time slewing for HF
     theTimeSlewSim = std::make_unique<HcalTimeSlewSim>(&theParameterMap, minFCToDelay);
     theHBHEAmplifier->setTimeSlewSim(theTimeSlewSim.get());
     theHBHEQIE11Amplifier->setTimeSlewSim(theTimeSlewSim.get());
     theHOAmplifier->setTimeSlewSim(theTimeSlewSim.get());
     theZDCAmplifier->setTimeSlewSim(theTimeSlewSim.get());
   }
  
   theHFResponse->setHitFilter(&theHFHitFilter);
   theHFQIE10Response->setHitFilter(&theHFQIE10HitFilter);
   theZDCResponse->setHitFilter(&theZDCHitFilter);
  
   // QIE8 and QIE10 can coexist in HF
   theHFQIE10Digitizer =
       std::make_unique<QIE10Digitizer>(theHFQIE10Response.get(), theHFQIE10ElectronicsSim.get(), doEmpty);
   theHFDigitizer = std::make_unique<HFDigitizer>(theHFResponse.get(), theHFElectronicsSim.get(), doEmpty);
  
   theZDCDigitizer = std::make_unique<ZDCDigitizer>(theZDCResponse.get(), theZDCElectronicsSim.get(), doEmpty);
  
   testNumbering_ = ps.getParameter<bool>("TestNumbering");
   //  std::cout << "Flag to see if Hit Relabeller to be initiated " <<
   //  testNumbering_ << std::endl;
   if (testNumbering_)
     theRelabeller = std::make_unique<HcalHitRelabeller>(ps.getParameter<bool>("doNeutralDensityFilter"));
  
   if (ps.getParameter<bool>("doIonFeedback") && theHBHEResponse) {
     theIonFeedback = std::make_unique<HPDIonFeedbackSim>(ps, &theShapes);
     theHBHEResponse->setPECorrection(theIonFeedback.get());
     if (ps.getParameter<bool>("doThermalNoise")) {
       theHBHEAmplifier->setIonFeedbackSim(theIonFeedback.get());
     }
   }
  
   // option to save CaloSamples as event product for debugging
   if (debugCS_) {
     if (theHBHEDigitizer)
       theHBHEDigitizer->setDebugCaloSamples(true);
     if (theHBHEQIE11Digitizer)
       theHBHEQIE11Digitizer->setDebugCaloSamples(true);
     if (theHODigitizer)
       theHODigitizer->setDebugCaloSamples(true);
     if (theHOSiPMDigitizer)
       theHOSiPMDigitizer->setDebugCaloSamples(true);
     if (theHFDigitizer)
       theHFDigitizer->setDebugCaloSamples(true);
     if (theHFQIE10Digitizer)
       theHFQIE10Digitizer->setDebugCaloSamples(true);
     theZDCDigitizer->setDebugCaloSamples(true);
   }
  
   // option to ignore Geant time distribution in SimHits, for debugging
   if (ignoreTime_) {
     theHBHEResponse->setIgnoreGeantTime(ignoreTime_);
     theHBHESiPMResponse->setIgnoreGeantTime(ignoreTime_);
     theHOResponse->setIgnoreGeantTime(ignoreTime_);
     theHOSiPMResponse->setIgnoreGeantTime(ignoreTime_);
     theHFResponse->setIgnoreGeantTime(ignoreTime_);
     theHFQIE10Response->setIgnoreGeantTime(ignoreTime_);
     theZDCResponse->setIgnoreGeantTime(ignoreTime_);
   }
  
   if (agingFlagHF)
     m_HFRecalibration = std::make_unique<HFRecalibration>(ps.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
 }

References edm::ConsumesCollector::consumes(), HcalCoderFactory::DB, debugCS_, deliveredLumi, DataMixerDataOnData_cff::doEmpty, DigiDM_cff::doNoise, hcalUnsuppressedDigis_cfi::doTimeSlew, Exception, edm::ParameterSet::getParameter(), hcalTimeSlew_delay_, hitsProducer_, ignoreTime_, HLT_FULL_cff::InputTag, m_HFRecalibration, hcalUnsuppressedDigis_cfi::minFCToDelay, testNumbering_, theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEHitFilter, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHBHEQIE11HitFilter, theHBHEResponse, theHBHESiPMResponse, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFHitFilter, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHFQIE10HitFilter, theHFQIE10Response, theHFResponse, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOHitFilter, theHOResponse, theHOSiPMCode, theHOSiPMDigitizer, theHOSiPMHitFilter, theHOSiPMResponse, theIonFeedback, theParameterMap, theRelabeller, theShapes, theTimeSlewSim, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, theZDCHitFilter, and theZDCResponse.

◆ ~HcalDigitizer()

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 242 of file HcalDigitizer.cc.

242 {}

Member Function Documentation

◆ accumulate() [1/2]

void HcalDigitizer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 415 of file HcalDigitizer.cc.

                                                                                                                {
   // Step A: Get Inputs
   edm::InputTag zdcTag(hitsProducer_, "ZDCHITS");
   edm::Handle<std::vector<PCaloHit>> zdcHandle;
   e.getByLabel(zdcTag, zdcHandle);
   isZDC = zdcHandle.isValid();
  
   edm::InputTag hcalTag(hitsProducer_, "HcalHits");
   edm::Handle<std::vector<PCaloHit>> hcalHandle;
   e.getByLabel(hcalTag, hcalHandle);
   isHCAL = hcalHandle.isValid() or injectTestHits_;
  
   edm::ESHandle<HcalTopology> htopo;
   eventSetup.get<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology *htopoP = htopo.product();
  
   accumulateCaloHits(hcalHandle, zdcHandle, 0, engine, htopoP);
 }

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, edm::EventSetup::get(), get, hitsProducer_, injectTestHits_, isHCAL, edm::HandleBase::isValid(), isZDC, or, and edm::ESHandle< T >::product().

Referenced by HcalDigiProducer::accumulate().

◆ accumulate() [2/2]

void HcalDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 434 of file HcalDigitizer.cc.

                                                              {
   // Step A: Get Inputs
   edm::InputTag zdcTag(hitsProducer_, "ZDCHITS");
   edm::Handle<std::vector<PCaloHit>> zdcHandle;
   e.getByLabel(zdcTag, zdcHandle);
   isZDC = zdcHandle.isValid();
  
   edm::InputTag hcalTag(hitsProducer_, "HcalHits");
   edm::Handle<std::vector<PCaloHit>> hcalHandle;
   e.getByLabel(hcalTag, hcalHandle);
   isHCAL = hcalHandle.isValid();
  
   edm::ESHandle<HcalTopology> htopo;
   eventSetup.get<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology *htopoP = htopo.product();
  
   accumulateCaloHits(hcalHandle, zdcHandle, e.bunchCrossing(), engine, htopoP);
 }

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, edm::EventSetup::get(), get, hitsProducer_, isHCAL, edm::HandleBase::isValid(), isZDC, and edm::ESHandle< T >::product().

◆ accumulateCaloHits()

void HcalDigitizer::accumulateCaloHits	(	edm::Handle< std::vector< PCaloHit >> const &	hcalHits,
		edm::Handle< std::vector< PCaloHit >> const &	zdcHits,
		int	bunchCrossing,
		CLHEP::HepRandomEngine *	engine,
		const HcalTopology *	h
	)

private

Definition at line 331 of file HcalDigitizer.cc.

                                                                    {
   // Step A: pass in inputs, and accumulate digis
   if (isHCAL) {
     std::vector<PCaloHit> hcalHitsOrig = *hcalHandle.product();
     if (injectTestHits_)
       hcalHitsOrig = injectedHits_;
     std::vector<PCaloHit> hcalHits;
     hcalHits.reserve(hcalHitsOrig.size());
  
     // evaluate darkening before relabeling
     if (testNumbering_) {
       if (m_HBDarkening || m_HEDarkening || m_HFRecalibration) {
         darkening(hcalHitsOrig);
       }
       // Relabel PCaloHits if necessary
       edm::LogInfo("HcalDigitizer") << "Calling Relabeller";
       theRelabeller->process(hcalHitsOrig);
     }
  
     // eliminate bad hits
     for (unsigned int i = 0; i < hcalHitsOrig.size(); i++) {
       DetId id(hcalHitsOrig[i].id());
       HcalDetId hid(id);
       if (!htopoP->validHcal(hid)) {
         edm::LogError("HcalDigitizer") << "bad hcal id found in digitizer. Skipping " << id.rawId() << " " << hid
                                        << std::endl;
         continue;
       } else if (hid.subdet() == HcalForward && !doHFWindow_ && hcalHitsOrig[i].depth() != 0) {
         // skip HF window hits unless desired
         continue;
       } else if (killHE_ && hid.subdet() == HcalEndcap) {
         // remove HE hits if asked for (phase 2)
         continue;
       } else {
 #ifdef DebugLog
         std::cout << "HcalDigitizer format " << hid.oldFormat() << " for " << hid << std::endl;
 #endif
         DetId newid = DetId(hid.newForm());
 #ifdef DebugLog
         std::cout << "Hit " << i << " out of " << hcalHits.size() << " " << std::hex << id.rawId() << " --> "
                   << newid.rawId() << std::dec << " " << HcalDetId(newid.rawId()) << '\n';
 #endif
         hcalHitsOrig[i].setID(newid.rawId());
         hcalHits.push_back(hcalHitsOrig[i]);
       }
     }
  
     if (hbhegeo) {
       if (theHBHEDigitizer)
         theHBHEDigitizer->add(hcalHits, bunchCrossing, engine);
       if (theHBHEQIE11Digitizer)
         theHBHEQIE11Digitizer->add(hcalHits, bunchCrossing, engine);
     }
  
     if (hogeo) {
       if (theHODigitizer)
         theHODigitizer->add(hcalHits, bunchCrossing, engine);
       if (theHOSiPMDigitizer)
         theHOSiPMDigitizer->add(hcalHits, bunchCrossing, engine);
     }
  
     if (hfgeo) {
       if (theHFDigitizer)
         theHFDigitizer->add(hcalHits, bunchCrossing, engine);
       if (theHFQIE10Digitizer)
         theHFQIE10Digitizer->add(hcalHits, bunchCrossing, engine);
     }
   } else {
     edm::LogInfo("HcalDigitizer") << "We don't have HCAL hit collection available ";
   }
  
   if (isZDC) {
     if (zdcgeo) {
       theZDCDigitizer->add(*zdcHandle.product(), bunchCrossing, engine);
     }
   } else {
     edm::LogInfo("HcalDigitizer") << "We don't have ZDC hit collection available ";
   }
 }

References gather_cfg::cout, darkening(), TauDecayModes::dec, doHFWindow_, hbhegeo, HcalEndcap, HcalForward, hfgeo, hogeo, mps_fire::i, triggerObjects_cff::id, injectedHits_, injectTestHits_, isHCAL, isZDC, killHE_, m_HBDarkening, m_HEDarkening, m_HFRecalibration, HcalDetId::newForm(), HcalDetId::oldFormat(), DetId::rawId(), HcalDetId::subdet(), testNumbering_, theHBHEDigitizer, theHBHEQIE11Digitizer, theHFDigitizer, theHFQIE10Digitizer, theHODigitizer, theHOSiPMDigitizer, theRelabeller, theZDCDigitizer, HcalTopology::validHcal(), and zdcgeo.

Referenced by accumulate().

◆ buildHBHEQIECells()

void HcalDigitizer::buildHBHEQIECells	(	const std::vector< DetId > &	allCells,
		const edm::EventSetup &	eventSetup
	)

private

Definition at line 730 of file HcalDigitizer.cc.

                                                                                                        {
   // if results are already cached, no need to look again
   if (!theHBHEQIE8DetIds.empty() || !theHBHEQIE11DetIds.empty())
     return;
  
   // get the QIETypes
   edm::ESHandle<HcalQIETypes> q;
   eventSetup.get<HcalQIETypesRcd>().get(q);
   edm::ESHandle<HcalTopology> htopo;
   eventSetup.get<HcalRecNumberingRecord>().get(htopo);
  
   HcalQIETypes qieTypes(*q.product());
   if (qieTypes.topo() == nullptr) {
     qieTypes.setTopo(htopo.product());
   }
  
   for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
     HcalQIENum qieType = HcalQIENum(qieTypes.getValues(*detItr)->getValue());
     if (qieType == QIE8) {
       theHBHEQIE8DetIds.push_back(*detItr);
     } else if (qieType == QIE11) {
       theHBHEQIE11DetIds.push_back(*detItr);
     } else {  // default is QIE8
       theHBHEQIE8DetIds.push_back(*detItr);
     }
   }
  
   if (!theHBHEQIE8DetIds.empty())
     theHBHEDigitizer->setDetIds(theHBHEQIE8DetIds);
   else {
     theHBHEDigitizer.reset();
   }
  
   if (!theHBHEQIE11DetIds.empty())
     theHBHEQIE11Digitizer->setDetIds(theHBHEQIE11DetIds);
   else {
     theHBHEQIE11Digitizer.reset();
   }
  
   if (!theHBHEQIE8DetIds.empty() && !theHBHEQIE11DetIds.empty()) {
     theHBHEHitFilter.setDetIds(theHBHEQIE8DetIds);
     theHBHEQIE11HitFilter.setDetIds(theHBHEQIE11DetIds);
   }
 }

References edm::EventSetup::get(), get, edm::ESHandle< T >::product(), submitPVResolutionJobs::q, QIE11, QIE8, HcalHitFilter< subdets >::setDetIds(), HcalCondObjectContainerBase::setTopo(), theHBHEDigitizer, theHBHEHitFilter, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHEQIE11HitFilter, and theHBHEQIE8DetIds.

Referenced by updateGeometry().

◆ buildHFQIECells()

void HcalDigitizer::buildHFQIECells	(	const std::vector< DetId > &	allCells,
		const edm::EventSetup &	eventSetup
	)

private

Definition at line 690 of file HcalDigitizer.cc.

                                                                                                      {
   // if results are already cached, no need to look again
   if (!theHFQIE8DetIds.empty() || !theHFQIE10DetIds.empty())
     return;
  
   // get the QIETypes
   edm::ESHandle<HcalQIETypes> q;
   eventSetup.get<HcalQIETypesRcd>().get(q);
   edm::ESHandle<HcalTopology> htopo;
   eventSetup.get<HcalRecNumberingRecord>().get(htopo);
  
   HcalQIETypes qieTypes(*q.product());
   if (qieTypes.topo() == nullptr) {
     qieTypes.setTopo(htopo.product());
   }
  
   for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
     HcalQIENum qieType = HcalQIENum(qieTypes.getValues(*detItr)->getValue());
     if (qieType == QIE8) {
       theHFQIE8DetIds.push_back(*detItr);
     } else if (qieType == QIE10) {
       theHFQIE10DetIds.push_back(*detItr);
     } else {  // default is QIE8
       theHFQIE8DetIds.push_back(*detItr);
     }
   }
  
   if (!theHFQIE8DetIds.empty())
     theHFDigitizer->setDetIds(theHFQIE8DetIds);
   else {
     theHFDigitizer.reset();
   }
  
   if (!theHFQIE10DetIds.empty())
     theHFQIE10Digitizer->setDetIds(theHFQIE10DetIds);
   else {
     theHFQIE10Digitizer.reset();
   }
 }

References edm::EventSetup::get(), get, edm::ESHandle< T >::product(), submitPVResolutionJobs::q, QIE10, QIE8, HcalCondObjectContainerBase::setTopo(), theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, and theHFQIE8DetIds.

Referenced by updateGeometry().

◆ buildHOSiPMCells()

void HcalDigitizer::buildHOSiPMCells	(	const std::vector< DetId > &	allCells,
		const edm::EventSetup &	eventSetup
	)

private

Definition at line 775 of file HcalDigitizer.cc.

                                                                                                       {
   // all HPD
  
   if (theHOSiPMCode == 0) {
     theHODigitizer->setDetIds(allCells);
   } else if (theHOSiPMCode == 1) {
     theHOSiPMDigitizer->setDetIds(allCells);
     // FIXME pick Zecotek or hamamatsu?
   } else if (theHOSiPMCode == 2) {
     std::vector<HcalDetId> zecotekDetIds, hamamatsuDetIds;
     edm::ESHandle<HcalMCParams> p;
     eventSetup.get<HcalMCParamsRcd>().get(p);
     edm::ESHandle<HcalTopology> htopo;
     eventSetup.get<HcalRecNumberingRecord>().get(htopo);
  
     HcalMCParams mcParams(*p.product());
     if (mcParams.topo() == nullptr) {
       mcParams.setTopo(htopo.product());
     }
  
     for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
       int shapeType = mcParams.getValues(*detItr)->signalShape();
       if (shapeType == HcalShapes::ZECOTEK) {
         zecotekDetIds.emplace_back(*detItr);
         theHOSiPMDetIds.push_back(*detItr);
       } else if (shapeType == HcalShapes::HAMAMATSU) {
         hamamatsuDetIds.emplace_back(*detItr);
         theHOSiPMDetIds.push_back(*detItr);
       } else {
         theHOHPDDetIds.push_back(*detItr);
       }
     }
  
     if (!theHOHPDDetIds.empty())
       theHODigitizer->setDetIds(theHOHPDDetIds);
     else {
       theHODigitizer.reset();
     }
  
     if (!theHOSiPMDetIds.empty())
       theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
     else {
       theHOSiPMDigitizer.reset();
     }
  
     if (!theHOHPDDetIds.empty() && !theHOSiPMDetIds.empty()) {
       theHOSiPMHitFilter.setDetIds(theHOSiPMDetIds);
       theHOHitFilter.setDetIds(theHOHPDDetIds);
     }
  
     theParameterMap.setHOZecotekDetIds(zecotekDetIds);
     theParameterMap.setHOHamamatsuDetIds(hamamatsuDetIds);
  
     // make sure we don't got through this exercise again
     theHOSiPMCode = -2;
   }
 }

References edm::EventSetup::get(), get, HcalShapes::HAMAMATSU, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< T >::product(), HcalHitFilter< subdets >::setDetIds(), HcalSimParameterMap::setHOHamamatsuDetIds(), HcalSimParameterMap::setHOZecotekDetIds(), HcalCondObjectContainerBase::setTopo(), theHODigitizer, theHOHitFilter, theHOHPDDetIds, theHOSiPMCode, theHOSiPMDetIds, theHOSiPMDigitizer, theHOSiPMHitFilter, theParameterMap, and HcalShapes::ZECOTEK.

Referenced by updateGeometry().

◆ checkGeometry()

void HcalDigitizer::checkGeometry ( const edm::EventSetup & eventSetup )

private

make sure the digitizer has the correct list of all cells that exist in the geometry

Definition at line 580 of file HcalDigitizer.cc.

                                                                  {
   edm::ESHandle<CaloGeometry> geometry;
   eventSetup.get<CaloGeometryRecord>().get(geometry);
   theGeometry = &*geometry;
   edm::ESHandle<HcalDDDRecConstants> pHRNDC;
   eventSetup.get<HcalRecNumberingRecord>().get(pHRNDC);
   theRecNumber = &*pHRNDC;
  
   if (theHBHEResponse)
     theHBHEResponse->setGeometry(theGeometry);
   if (theHBHESiPMResponse)
     theHBHESiPMResponse->setGeometry(theGeometry);
   if (theHOResponse)
     theHOResponse->setGeometry(theGeometry);
   if (theHOSiPMResponse)
     theHOSiPMResponse->setGeometry(theGeometry);
   theHFResponse->setGeometry(theGeometry);
   theHFQIE10Response->setGeometry(theGeometry);
   theZDCResponse->setGeometry(theGeometry);
   if (theRelabeller)
     theRelabeller->setGeometry(theRecNumber);
  
   // See if it's been updated
   bool check1 = theGeometryWatcher_.check(eventSetup);
   bool check2 = theRecNumberWatcher_.check(eventSetup);
   if (check1 or check2) {
     updateGeometry(eventSetup);
   }
 }

References edm::ESWatcher< T >::check(), geometry, edm::EventSetup::get(), get, or, theGeometry, theGeometryWatcher_, theHBHEResponse, theHBHESiPMResponse, theHFQIE10Response, theHFResponse, theHOResponse, theHOSiPMResponse, theRecNumber, theRecNumberWatcher_, theRelabeller, theZDCResponse, and updateGeometry().

Referenced by setup().

◆ darkening()

void HcalDigitizer::darkening ( std::vector< PCaloHit > & hcalHits )

private

Definition at line 833 of file HcalDigitizer.cc.

                                                            {
   for (unsigned int ii = 0; ii < hcalHits.size(); ++ii) {
     uint32_t tmpId = hcalHits[ii].id();
     int det, z, depth, ieta, phi, lay;
     HcalTestNumbering::unpackHcalIndex(tmpId, det, z, depth, ieta, phi, lay);
  
     bool darkened = false;
     float dweight = 1.;
  
     if (det == int(HcalBarrel) && m_HBDarkening) {
       // HB darkening
       dweight = m_HBDarkening->degradation(deliveredLumi, ieta, lay);
       darkened = true;
     } else if (det == int(HcalEndcap) && m_HEDarkening) {
       // HE darkening
       dweight = m_HEDarkening->degradation(deliveredLumi, ieta, lay);
       darkened = true;
     } else if (det == int(HcalForward) && m_HFRecalibration) {
       // HF darkening - approximate: invert recalibration factor
       dweight = 1.0 / m_HFRecalibration->getCorr(ieta, depth, deliveredLumi);
       darkened = true;
     }
  
     // reset hit energy
     if (darkened)
       hcalHits[ii].setEnergy(hcalHits[ii].energy() * dweight);
   }
 }

References HBHEDarkening::degradation(), deliveredLumi, LEDCalibrationChannels::depth, HCALHighEnergyHPDFilter_cfi::energy, HcalBarrel, HcalEndcap, HcalForward, LEDCalibrationChannels::ieta, cuy::ii, m_HBDarkening, m_HEDarkening, m_HFRecalibration, phi, HcalTestNumbering::unpackHcalIndex(), and z.

Referenced by accumulateCaloHits().

◆ fillFakeHits()

void HcalDigitizer::fillFakeHits ( )

private

some hits in each subdetector, just for testing purposes

◆ finalizeEvent()

void HcalDigitizer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 455 of file HcalDigitizer.cc.

                                                                                                             {
   // Step B: Create empty output
   std::unique_ptr<HBHEDigiCollection> hbheResult(new HBHEDigiCollection());
   std::unique_ptr<HODigiCollection> hoResult(new HODigiCollection());
   std::unique_ptr<HFDigiCollection> hfResult(new HFDigiCollection());
   std::unique_ptr<ZDCDigiCollection> zdcResult(new ZDCDigiCollection());
   std::unique_ptr<QIE10DigiCollection> hfQIE10Result(new QIE10DigiCollection(
       !theHFQIE10DetIds.empty() ? theParameterMap.simParameters(theHFQIE10DetIds[0]).readoutFrameSize()
                                 : QIE10DigiCollection::MAXSAMPLES));
   std::unique_ptr<QIE11DigiCollection> hbheQIE11Result(new QIE11DigiCollection(
       !theHBHEQIE11DetIds.empty() ? theHBHESiPMResponse.get()->getReadoutFrameSize(theHBHEQIE11DetIds[0]) :
                                   //      theParameterMap->simParameters(theHBHEQIE11DetIds[0]).readoutFrameSize()
           //      :
           QIE11DigiCollection::MAXSAMPLES));
  
   // Step C: Invoke the algorithm, getting back outputs.
   if (isHCAL && hbhegeo) {
     if (theHBHEDigitizer)
       theHBHEDigitizer->run(*hbheResult, engine);
     if (theHBHEQIE11Digitizer)
       theHBHEQIE11Digitizer->run(*hbheQIE11Result, engine);
   }
   if (isHCAL && hogeo) {
     if (theHODigitizer)
       theHODigitizer->run(*hoResult, engine);
     if (theHOSiPMDigitizer)
       theHOSiPMDigitizer->run(*hoResult, engine);
   }
   if (isHCAL && hfgeo) {
     if (theHFDigitizer)
       theHFDigitizer->run(*hfResult, engine);
     if (theHFQIE10Digitizer)
       theHFQIE10Digitizer->run(*hfQIE10Result, engine);
   }
   if (isZDC && zdcgeo) {
     theZDCDigitizer->run(*zdcResult, engine);
   }
  
   edm::LogInfo("HcalDigitizer") << "HCAL HBHE digis : " << hbheResult->size();
   edm::LogInfo("HcalDigitizer") << "HCAL HO digis   : " << hoResult->size();
   edm::LogInfo("HcalDigitizer") << "HCAL HF digis   : " << hfResult->size();
   edm::LogInfo("HcalDigitizer") << "HCAL ZDC digis  : " << zdcResult->size();
   edm::LogInfo("HcalDigitizer") << "HCAL HF QIE10 digis : " << hfQIE10Result->size();
   edm::LogInfo("HcalDigitizer") << "HCAL HBHE QIE11 digis : " << hbheQIE11Result->size();
  
 #ifdef DebugLog
   std::cout << std::endl;
   std::cout << "HCAL HBHE digis : " << hbheResult->size() << std::endl;
   std::cout << "HCAL HO   digis : " << hoResult->size() << std::endl;
   std::cout << "HCAL HF   digis : " << hfResult->size() << std::endl;
   std::cout << "HCAL ZDC  digis : " << zdcResult->size() << std::endl;
   std::cout << "HCAL HF QIE10 digis : " << hfQIE10Result->size() << std::endl;
   std::cout << "HCAL HBHE QIE11 digis : " << hbheQIE11Result->size() << std::endl;
 #endif
  
   // Step D: Put outputs into event
   e.put(std::move(hbheResult));
   e.put(std::move(hoResult));
   e.put(std::move(hfResult));
   e.put(std::move(zdcResult));
   e.put(std::move(hfQIE10Result), "HFQIE10DigiCollection");
   e.put(std::move(hbheQIE11Result), "HBHEQIE11DigiCollection");
  
   if (debugCS_) {
     std::unique_ptr<CaloSamplesCollection> csResult(new CaloSamplesCollection());
     // smush together all the results
     if (theHBHEDigitizer)
       csResult->insert(
           csResult->end(), theHBHEDigitizer->getCaloSamples().begin(), theHBHEDigitizer->getCaloSamples().end());
     if (theHBHEQIE11Digitizer)
       csResult->insert(csResult->end(),
                        theHBHEQIE11Digitizer->getCaloSamples().begin(),
                        theHBHEQIE11Digitizer->getCaloSamples().end());
     if (theHODigitizer)
       csResult->insert(
           csResult->end(), theHODigitizer->getCaloSamples().begin(), theHODigitizer->getCaloSamples().end());
     if (theHOSiPMDigitizer)
       csResult->insert(
           csResult->end(), theHOSiPMDigitizer->getCaloSamples().begin(), theHOSiPMDigitizer->getCaloSamples().end());
     if (theHFDigitizer)
       csResult->insert(
           csResult->end(), theHFDigitizer->getCaloSamples().begin(), theHFDigitizer->getCaloSamples().end());
     if (theHFQIE10Digitizer)
       csResult->insert(
           csResult->end(), theHFQIE10Digitizer->getCaloSamples().begin(), theHFQIE10Digitizer->getCaloSamples().end());
     csResult->insert(
         csResult->end(), theZDCDigitizer->getCaloSamples().begin(), theZDCDigitizer->getCaloSamples().end());
     e.put(std::move(csResult), "HcalSamples");
   }
  
   if (injectTestHits_) {
     std::unique_ptr<edm::PCaloHitContainer> pcResult(new edm::PCaloHitContainer());
     pcResult->insert(pcResult->end(), injectedHits_.begin(), injectedHits_.end());
     e.put(std::move(pcResult), "HcalHits");
   }
  
 #ifdef DebugLog
   std::cout << std::endl << "========>  HcalDigitizer e.put " << std::endl << std::endl;
 #endif
 }

References gather_cfg::cout, debugCS_, MillePedeFileConverter_cfg::e, hbhegeo, hfgeo, hogeo, injectedHits_, injectTestHits_, isHCAL, isZDC, HcalDataFrameContainer< Digi >::MAXSAMPLES, eostools::move(), CaloSimParameters::readoutFrameSize(), HcalSimParameterMap::simParameters(), theHBHEDigitizer, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHESiPMResponse, theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theZDCDigitizer, and zdcgeo.

Referenced by HcalDigiProducer::finalizeEvent().

◆ initializeEvent()

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

Produces the EDM products,

Definition at line 293 of file HcalDigitizer.cc.

                                                                                       {
   setup(eventSetup);
  
   // get the appropriate gains, noises, & widths for this event
   edm::ESHandle<HcalDbService> conditions;
   eventSetup.get<HcalDbRecord>().get(conditions);
  
   theShapes.setDbService(conditions.product());
  
   theHBHEAmplifier->setDbService(conditions.product());
   theHFAmplifier->setDbService(conditions.product());
   theHOAmplifier->setDbService(conditions.product());
   theZDCAmplifier->setDbService(conditions.product());
   theHFQIE10Amplifier->setDbService(conditions.product());
   theHBHEQIE11Amplifier->setDbService(conditions.product());
  
   theHFQIE10ElectronicsSim->setDbService(conditions.product());
   theHBHEQIE11ElectronicsSim->setDbService(conditions.product());
  
   theCoderFactory->setDbService(conditions.product());
   theParameterMap.setDbService(conditions.product());
  
   // initialize hits
   if (theHBHEDigitizer)
     theHBHEDigitizer->initializeHits();
   if (theHBHEQIE11Digitizer)
     theHBHEQIE11Digitizer->initializeHits();
   if (theHODigitizer)
     theHODigitizer->initializeHits();
   if (theHOSiPMDigitizer)
     theHOSiPMDigitizer->initializeHits();
   if (theHFQIE10Digitizer)
     theHFQIE10Digitizer->initializeHits();
   if (theHFDigitizer)
     theHFDigitizer->initializeHits();
   theZDCDigitizer->initializeHits();
 }

References submitPVValidationJobs::conditions, edm::EventSetup::get(), get, HcalShapes::setDbService(), HcalSimParameterMap::setDbService(), setup(), theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHFAmplifier, theHFDigitizer, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHOAmplifier, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theShapes, theZDCAmplifier, and theZDCDigitizer.

Referenced by HcalDigiProducer::initializeEvent().

◆ setHBHENoiseSignalGenerator()

void HcalDigitizer::setHBHENoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 244 of file HcalDigitizer.cc.

                                                                                        {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theHBHEElectronicsSim.get());
   if (theHBHEDigitizer)
     theHBHEDigitizer->setNoiseSignalGenerator(noiseGenerator);
   theHBHEAmplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHBHENoiseSignalGenerator().

◆ setHFNoiseSignalGenerator()

void HcalDigitizer::setHFNoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 260 of file HcalDigitizer.cc.

                                                                                      {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theHFElectronicsSim.get());
   if (theHFDigitizer)
     theHFDigitizer->setNoiseSignalGenerator(noiseGenerator);
   theHFAmplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHFAmplifier, theHFDigitizer, theHFElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHFNoiseSignalGenerator().

◆ setHONoiseSignalGenerator()

void HcalDigitizer::setHONoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 276 of file HcalDigitizer.cc.

                                                                                      {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theHOElectronicsSim.get());
   if (theHODigitizer)
     theHODigitizer->setNoiseSignalGenerator(noiseGenerator);
   if (theHOSiPMDigitizer)
     theHOSiPMDigitizer->setNoiseSignalGenerator(noiseGenerator);
   theHOAmplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOSiPMDigitizer, and theParameterMap.

Referenced by HcalDigiProducer::setHONoiseSignalGenerator().

◆ setQIE10NoiseSignalGenerator()

void HcalDigitizer::setQIE10NoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 268 of file HcalDigitizer.cc.

                                                                                         {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theHFQIE10ElectronicsSim.get());
   if (theHFQIE10Digitizer)
     theHFQIE10Digitizer->setNoiseSignalGenerator(noiseGenerator);
   theHFQIE10Amplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE10NoiseSignalGenerator().

◆ setQIE11NoiseSignalGenerator()

void HcalDigitizer::setQIE11NoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 252 of file HcalDigitizer.cc.

                                                                                         {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theHBHEQIE11ElectronicsSim.get());
   if (theHBHEQIE11Digitizer)
     theHBHEQIE11Digitizer->setNoiseSignalGenerator(noiseGenerator);
   theHBHEQIE11Amplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE11NoiseSignalGenerator().

◆ setup()

void HcalDigitizer::setup ( const edm::EventSetup & es )

private

Definition at line 556 of file HcalDigitizer.cc.

                                                  {
   checkGeometry(es);
  
   if (agingFlagHB) {
     edm::ESHandle<HBHEDarkening> hdark;
     es.get<HBHEDarkeningRecord>().get("HB", hdark);
     m_HBDarkening = &*hdark;
   }
   if (agingFlagHE) {
     edm::ESHandle<HBHEDarkening> hdark;
     es.get<HBHEDarkeningRecord>().get("HE", hdark);
     m_HEDarkening = &*hdark;
   }
  
   edm::ESHandle<HcalTimeSlew> delay;
   es.get<HcalTimeSlewRecord>().get("HBHE", delay);
   hcalTimeSlew_delay_ = &*delay;
  
   theHBHEAmplifier->setTimeSlew(hcalTimeSlew_delay_);
   theHBHEQIE11Amplifier->setTimeSlew(hcalTimeSlew_delay_);
   theHOAmplifier->setTimeSlew(hcalTimeSlew_delay_);
   theZDCAmplifier->setTimeSlew(hcalTimeSlew_delay_);
 }

References agingFlagHB, agingFlagHE, checkGeometry(), phase2TrackerDigitizer_cfi::delay, edm::EventSetup::get(), get, hcalTimeSlew_delay_, m_HBDarkening, m_HEDarkening, theHBHEAmplifier, theHBHEQIE11Amplifier, theHOAmplifier, and theZDCAmplifier.

Referenced by initializeEvent().

◆ setZDCNoiseSignalGenerator()

void HcalDigitizer::setZDCNoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 286 of file HcalDigitizer.cc.

                                                                                       {
   noiseGenerator->setParameterMap(&theParameterMap);
   noiseGenerator->setElectronicsSim(theZDCElectronicsSim.get());
   theZDCDigitizer->setNoiseSignalGenerator(noiseGenerator);
   theZDCAmplifier->setNoiseSignalGenerator(noiseGenerator);
 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theParameterMap, theZDCAmplifier, theZDCDigitizer, and theZDCElectronicsSim.

Referenced by HcalDigiProducer::setZDCNoiseSignalGenerator().

◆ updateGeometry()

void HcalDigitizer::updateGeometry ( const edm::EventSetup & eventSetup )

private

Definition at line 610 of file HcalDigitizer.cc.

                                                                   {
   const std::vector<DetId> &hbCells = theGeometry->getValidDetIds(DetId::Hcal, HcalBarrel);
   const std::vector<DetId> &heCells = theGeometry->getValidDetIds(DetId::Hcal, HcalEndcap);
   const std::vector<DetId> &hoCells = theGeometry->getValidDetIds(DetId::Hcal, HcalOuter);
   const std::vector<DetId> &hfCells = theGeometry->getValidDetIds(DetId::Hcal, HcalForward);
   const std::vector<DetId> &zdcCells = theGeometry->getValidDetIds(DetId::Calo, HcalZDCDetId::SubdetectorId);
   // const std::vector<DetId>& hcalTrigCells =
   // geometry->getValidDetIds(DetId::Hcal, HcalTriggerTower); const
   // std::vector<DetId>& hcalCalib = geometry->getValidDetIds(DetId::Calo,
   // HcalCastorDetId::SubdetectorId);
   //  std::cout<<"HcalDigitizer::CheckGeometry number of cells:
   //  "<<zdcCells.size()<<std::endl;
   if (zdcCells.empty())
     zdcgeo = false;
   if (hbCells.empty() && heCells.empty())
     hbhegeo = false;
   if (hoCells.empty())
     hogeo = false;
   if (hfCells.empty())
     hfgeo = false;
   // combine HB & HE
  
   hbheCells = hbCells;
   if (!killHE_) {
     hbheCells.insert(hbheCells.end(), heCells.begin(), heCells.end());
   }
   // handle mixed QIE8/11 scenario in HBHE
   buildHBHEQIECells(hbheCells, eventSetup);
   if (theHBHESiPMResponse)
     theHBHESiPMResponse->setDetIds(theHBHEQIE11DetIds);
  
   if (theHOSiPMDigitizer) {
     buildHOSiPMCells(hoCells, eventSetup);
     if (theHOSiPMResponse)
       theHOSiPMResponse->setDetIds(hoCells);
   }
  
   // handle mixed QIE8/10 scenario in HF
   buildHFQIECells(hfCells, eventSetup);
  
   theZDCDigitizer->setDetIds(zdcCells);
  
   // fill test hits collection if desired and empty
   if (injectTestHits_ && injectedHits_.empty() && !injectedHitsCells_.empty() && !injectedHitsEnergy_.empty()) {
     // make list of specified cells if desired
     std::vector<DetId> testCells;
     if (injectedHitsCells_.size() >= 4) {
       testCells.reserve(injectedHitsCells_.size() / 4);
       for (unsigned ic = 0; ic < injectedHitsCells_.size(); ic += 4) {
         if (ic + 4 > injectedHitsCells_.size())
           break;
         testCells.push_back(HcalDetId((HcalSubdetector)injectedHitsCells_[ic],
                                       injectedHitsCells_[ic + 1],
                                       injectedHitsCells_[ic + 2],
                                       injectedHitsCells_[ic + 3]));
       }
     } else {
       int testSubdet = injectedHitsCells_[0];
       if (testSubdet == HcalBarrel)
         testCells = hbCells;
       else if (testSubdet == HcalEndcap)
         testCells = heCells;
       else if (testSubdet == HcalForward)
         testCells = hfCells;
       else if (testSubdet == HcalOuter)
         testCells = hoCells;
       else
         throw cms::Exception("Configuration") << "Unknown subdet " << testSubdet << " for HCAL test hit injection";
     }
     bool useHitTimes = (injectedHitsTime_.size() == injectedHitsEnergy_.size());
     injectedHits_.reserve(testCells.size() * injectedHitsEnergy_.size());
     for (unsigned ih = 0; ih < injectedHitsEnergy_.size(); ++ih) {
       double tmp = useHitTimes ? injectedHitsTime_[ih] : 0.;
       for (auto &aCell : testCells) {
         injectedHits_.emplace_back(aCell, injectedHitsEnergy_[ih], tmp);
       }
     }
   }
 }