HcalDigitizer Class Reference

#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
const edm::ESGetToken< HcalDbService, HcalDbRecord >	conditionsToken_
bool	debugCS_
double	deliveredLumi
bool	doHFWindow_
std::vector< DetId >	hbheCells
bool	hbhegeo
const HcalTimeSlew *	hcalTimeSlew_delay_
const edm::ESGetToken< HcalTimeSlew, HcalTimeSlewRecord >	hcalTimeSlew_delay_token_
edm::EDGetTokenT< std::vector< PCaloHit > >	hcalToken_
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
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord >	m_HBDarkeningToken
const HBHEDarkening *	m_HEDarkening
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord >	m_HEDarkeningToken
std::unique_ptr< HFRecalibration >	m_HFRecalibration
edm::ESGetToken< HcalMCParams, HcalMCParamsRcd >	mcParamsToken_
const edm::ESGetToken< HcalQIETypes, HcalQIETypesRcd >	qieTypesToken_
bool	testNumbering_
std::unique_ptr< HcalCoderFactory >	theCoderFactory
const CaloGeometry *	theGeometry
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	theGeometryToken
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
const edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord >	theRecNumberToken
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
const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	topoToken_
bool	zdcgeo
edm::EDGetTokenT< std::vector< PCaloHit > >	zdcToken_

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 103 of file HcalDigitizer.h.

HFDigitizer

typedef CaloTDigitizer<HFDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer

private

Definition at line 105 of file HcalDigitizer.h.

HODigitizer

typedef CaloTDigitizer<HODigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer

private

Definition at line 104 of file HcalDigitizer.h.

QIE10Digitizer

typedef CaloTDigitizer<HcalQIE10DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer

private

Definition at line 107 of file HcalDigitizer.h.

QIE11Digitizer

typedef CaloTDigitizer<HcalQIE11DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer

private

Definition at line 108 of file HcalDigitizer.h.

ZDCDigitizer

typedef CaloTDigitizer<ZDCDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer

private

Definition at line 106 of file HcalDigitizer.h.

Constructor & Destructor Documentation

HcalDigitizer()

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

explicit

Definition at line 34 of file HcalDigitizer.cc.

References agingFlagHB, agingFlagHE, HcalCoderFactory::DB, debugCS_, deliveredLumi, DataMixerDataOnData_cff::doEmpty, DigiDM_cff::doNoise, hcalUnsuppressedDigis_cfi::doTimeSlew, edm::ConsumesCollector::esConsumes(), Exception, edm::ParameterSet::getParameter(), hcalTimeSlew_delay_, ignoreTime_, m_HBDarkeningToken, m_HEDarkeningToken, m_HFRecalibration, mcParamsToken_, 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.

    : conditionsToken_(iC.esConsumes()),
      topoToken_(iC.esConsumes()),
      hcalTimeSlew_delay_token_(iC.esConsumes(edm::ESInputTag("", "HBHE"))),
      theGeometryToken(iC.esConsumes()),
      theRecNumberToken(iC.esConsumes()),
      qieTypesToken_(iC.esConsumes()),
      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, ps.getParameter<bool>("HcalPreMixStage1"), true)),
      theZDCResponse(std::make_unique<CaloHitResponse>(
          &theParameterMap, &theShapes, ps.getParameter<bool>("HcalPreMixStage1"), false)),
      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")),
      zdcToken_(iC.consumes(edm::InputTag(hitsProducer_, "ZDCHITS"))),
      hcalToken_(iC.consumes(edm::InputTag(hitsProducer_, "HcalHits"))),
      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")) {
  if (agingFlagHB) {
    m_HBDarkeningToken = iC.esConsumes(edm::ESInputTag("", "HB"));
  }
  if (agingFlagHE) {
    m_HEDarkeningToken = iC.esConsumes(edm::ESInputTag("", "HE"));
  }
  if (theHOSiPMCode == 2) {
    mcParamsToken_ = iC.esConsumes();
  }

  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");
  //  edm::LogVerbatim("HcalSim") << "Flag to see if Hit Relabeller to be initiated " << testNumbering_;
  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"));
}

~HcalDigitizer()

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 254 of file HcalDigitizer.cc.

{}

Member Function Documentation

accumulate() [1/2]

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

Definition at line 425 of file HcalDigitizer.cc.

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, options_cfi::eventSetup, hcalToken_, injectTestHits_, isHCAL, edm::HandleBase::isValid(), isZDC, or, topoToken_, and zdcToken_.

Referenced by HcalDigiProducer::accumulate().

                                                                                                               {
  // Step A: Get Inputs
  const edm::Handle<std::vector<PCaloHit>> &zdcHandle = e.getHandle(zdcToken_);
  isZDC = zdcHandle.isValid();

  const edm::Handle<std::vector<PCaloHit>> &hcalHandle = e.getHandle(hcalToken_);
  isHCAL = hcalHandle.isValid() or injectTestHits_;

  const HcalTopology *htopoP = &eventSetup.getData(topoToken_);

  accumulateCaloHits(hcalHandle, zdcHandle, 0, engine, htopoP);
}

accumulate() [2/2]

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

Definition at line 438 of file HcalDigitizer.cc.

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, options_cfi::eventSetup, hitsProducer_, isHCAL, edm::HandleBase::isValid(), isZDC, and topoToken_.

                                                             {
  // 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();

  const HcalTopology *htopoP = &eventSetup.getData(topoToken_);

  accumulateCaloHits(hcalHandle, zdcHandle, e.bunchCrossing(), engine, htopoP);
}

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 342 of file HcalDigitizer.cc.

References darkening(), TauDecayModes::dec, doHFWindow_, hbhegeo, HcalEndcap, HcalForward, hfgeo, hogeo, mps_fire::i, l1ctLayer2EG_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().

                                                                   {
  // 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;
        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 EDM_ML_DEBUG
        edm::LogVerbatim("HcalSim") << "HcalDigitizer format " << hid.oldFormat() << " for " << hid;
#endif
        DetId newid = DetId(hid.newForm());
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HcalSim") << "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 ";
  }
}

buildHBHEQIECells()

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

private

Definition at line 716 of file HcalDigitizer.cc.

References options_cfi::eventSetup, HcalQIEType::getValue(), HcalCondObjectContainer< Item >::getValues(), QIE11, QIE8, qieTypesToken_, HcalHitFilter< subdets >::setDetIds(), HcalCondObjectContainerBase::setTopo(), theHBHEDigitizer, theHBHEHitFilter, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHEQIE11HitFilter, theHBHEQIE8DetIds, HcalCondObjectContainerBase::topo(), and topoToken_.

Referenced by updateGeometry().

                                                                                                       {
  // if results are already cached, no need to look again
  if (!theHBHEQIE8DetIds.empty() || !theHBHEQIE11DetIds.empty())
    return;

  // get the QIETypes
  // intentional copy
  HcalQIETypes qieTypes = eventSetup.getData(qieTypesToken_);
  if (qieTypes.topo() == nullptr) {
    qieTypes.setTopo(&eventSetup.getData(topoToken_));
  }

  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);
  }
}

buildHFQIECells()

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

private

Definition at line 680 of file HcalDigitizer.cc.

References options_cfi::eventSetup, HcalQIEType::getValue(), HcalCondObjectContainer< Item >::getValues(), QIE10, QIE8, qieTypesToken_, HcalCondObjectContainerBase::setTopo(), theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, theHFQIE8DetIds, HcalCondObjectContainerBase::topo(), and topoToken_.

Referenced by updateGeometry().

                                                                                                     {
  // if results are already cached, no need to look again
  if (!theHFQIE8DetIds.empty() || !theHFQIE10DetIds.empty())
    return;

  // get the QIETypes
  // intentional copy
  HcalQIETypes qieTypes = eventSetup.getData(qieTypesToken_);
  if (qieTypes.topo() == nullptr) {
    qieTypes.setTopo(&eventSetup.getData(topoToken_));
  }

  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();
  }
}

buildHOSiPMCells()

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

private

Definition at line 757 of file HcalDigitizer.cc.

References options_cfi::eventSetup, HcalCondObjectContainer< Item >::getValues(), HcalShapes::HAMAMATSU, mcParamsToken_, HcalHitFilter< subdets >::setDetIds(), HcalSimParameterMap::setHOHamamatsuDetIds(), HcalSimParameterMap::setHOZecotekDetIds(), HcalCondObjectContainerBase::setTopo(), HcalMCParam::signalShape(), theHODigitizer, theHOHitFilter, theHOHPDDetIds, theHOSiPMCode, theHOSiPMDetIds, theHOSiPMDigitizer, theHOSiPMHitFilter, theParameterMap, HcalCondObjectContainerBase::topo(), topoToken_, and HcalShapes::ZECOTEK.

Referenced by updateGeometry().

                                                                                                      {
  // 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;

    // intentional copy
    HcalMCParams mcParams = eventSetup.getData(mcParamsToken_);
    if (mcParams.topo() == nullptr) {
      mcParams.setTopo(&eventSetup.getData(topoToken_));
    }

    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;
  }
}

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 575 of file HcalDigitizer.cc.

References edm::ESWatcher< T >::check(), options_cfi::eventSetup, or, theGeometry, theGeometryToken, theGeometryWatcher_, theHBHEResponse, theHBHESiPMResponse, theHFQIE10Response, theHFResponse, theHOResponse, theHOSiPMResponse, theRecNumber, theRecNumberToken, theRecNumberWatcher_, theRelabeller, theZDCResponse, and updateGeometry().

Referenced by setup().

                                                                 {
  theGeometry = &eventSetup.getData(theGeometryToken);
  theRecNumber = &eventSetup.getData(theRecNumberToken);

  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);
  }
}

darkening()

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

private

Definition at line 812 of file HcalDigitizer.cc.

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().

                                                           {
  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);
  }
}

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 457 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::finalizeEvent().

                                                                                                            {
  // 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() ? theHFQIE10Response.get()->getReadoutFrameSize(theHFQIE10DetIds[0])
                                : 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 EDM_ML_DEBUG
  edm::LogVerbatim("HcalSim") << "\nHCAL HBHE digis : " << hbheResult->size();
  edm::LogVerbatim("HcalSim") << "HCAL HO   digis : " << hoResult->size();
  edm::LogVerbatim("HcalSim") << "HCAL HF   digis : " << hfResult->size();
  edm::LogVerbatim("HcalSim") << "HCAL ZDC  digis : " << zdcResult->size();
  edm::LogVerbatim("HcalSim") << "HCAL HF QIE10 digis : " << hfQIE10Result->size();
  edm::LogVerbatim("HcalSim") << "HCAL HBHE QIE11 digis : " << hbheQIE11Result->size();
#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 EDM_ML_DEBUG
  edm::LogVerbatim("HcalSim") << "\n========>  HcalDigitizer e.put\n";
#endif
}

initializeEvent()

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

Produces the EDM products,

Definition at line 305 of file HcalDigitizer.cc.

References submitPVValidationJobs::conditions, conditionsToken_, options_cfi::eventSetup, 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().

                                                                                      {
  setup(eventSetup);

  // get the appropriate gains, noises, & widths for this event
  const HcalDbService *conditions = &eventSetup.getData(conditionsToken_);

  theShapes.setDbService(conditions);

  theHBHEAmplifier->setDbService(conditions);
  theHFAmplifier->setDbService(conditions);
  theHOAmplifier->setDbService(conditions);
  theZDCAmplifier->setDbService(conditions);
  theHFQIE10Amplifier->setDbService(conditions);
  theHBHEQIE11Amplifier->setDbService(conditions);

  theHFQIE10ElectronicsSim->setDbService(conditions);
  theHBHEQIE11ElectronicsSim->setDbService(conditions);

  theCoderFactory->setDbService(conditions);
  theParameterMap.setDbService(conditions);

  // 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();
}

setHBHENoiseSignalGenerator()

void HcalDigitizer::setHBHENoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 256 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setHBHENoiseSignalGenerator().

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

setHFNoiseSignalGenerator()

void HcalDigitizer::setHFNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 272 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setHFNoiseSignalGenerator().

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

setHONoiseSignalGenerator()

void HcalDigitizer::setHONoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 288 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setHONoiseSignalGenerator().

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

setQIE10NoiseSignalGenerator()

void HcalDigitizer::setQIE10NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 280 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setQIE10NoiseSignalGenerator().

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

setQIE11NoiseSignalGenerator()

void HcalDigitizer::setQIE11NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 264 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setQIE11NoiseSignalGenerator().

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

setup()

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

private

Definition at line 557 of file HcalDigitizer.cc.

References agingFlagHB, agingFlagHE, checkGeometry(), edm::EventSetup::getData(), hcalTimeSlew_delay_, hcalTimeSlew_delay_token_, m_HBDarkening, m_HBDarkeningToken, m_HEDarkening, m_HEDarkeningToken, theHBHEAmplifier, theHBHEQIE11Amplifier, theHOAmplifier, and theZDCAmplifier.

Referenced by initializeEvent().

                                                 {
  checkGeometry(es);

  if (agingFlagHB) {
    m_HBDarkening = &es.getData(m_HBDarkeningToken);
  }
  if (agingFlagHE) {
    m_HEDarkening = &es.getData(m_HEDarkeningToken);
  }

  hcalTimeSlew_delay_ = &es.getData(hcalTimeSlew_delay_token_);

  theHBHEAmplifier->setTimeSlew(hcalTimeSlew_delay_);
  theHBHEQIE11Amplifier->setTimeSlew(hcalTimeSlew_delay_);
  theHOAmplifier->setTimeSlew(hcalTimeSlew_delay_);
  theZDCAmplifier->setTimeSlew(hcalTimeSlew_delay_);
}

setZDCNoiseSignalGenerator()

void HcalDigitizer::setZDCNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 298 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::setZDCNoiseSignalGenerator().

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

updateGeometry()

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

private

Definition at line 601 of file HcalDigitizer.cc.

References buildHBHEQIECells(), buildHFQIECells(), buildHOSiPMCells(), DetId::Calo, options_cfi::eventSetup, Exception, CaloGeometry::getValidDetIds(), hbheCells, hbhegeo, DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, hfgeo, hogeo, injectedHits_, injectedHitsCells_, injectedHitsEnergy_, injectedHitsTime_, injectTestHits_, killHE_, HcalZDCDetId::SubdetectorId, theGeometry, theHBHEQIE11DetIds, theHBHESiPMResponse, theHOSiPMDigitizer, theHOSiPMResponse, theZDCDigitizer, createJobs::tmp, and zdcgeo.

Referenced by checkGeometry().

                                                                  {
  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);
  //  edm::LogVerbatim("HcalSim") <<"HcalDigitizer::CheckGeometry number of cells: << zdcCells.size();
  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);
      }
    }
  }
}

Member Data Documentation

agingFlagHB

bool HcalDigitizer::agingFlagHB

private

Definition at line 180 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

agingFlagHE

bool HcalDigitizer::agingFlagHE

private

Definition at line 180 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

conditionsToken_

const edm::ESGetToken<HcalDbService, HcalDbRecord> HcalDigitizer::conditionsToken_

private

Definition at line 87 of file HcalDigitizer.h.

Referenced by initializeEvent().

debugCS_

bool HcalDigitizer::debugCS_

private

Definition at line 171 of file HcalDigitizer.h.

Referenced by finalizeEvent(), and HcalDigitizer().

deliveredLumi

double HcalDigitizer::deliveredLumi

private

Definition at line 179 of file HcalDigitizer.h.

Referenced by darkening(), and HcalDigitizer().

doHFWindow_

bool HcalDigitizer::doHFWindow_

private

Definition at line 169 of file HcalDigitizer.h.

Referenced by accumulateCaloHits().

hbheCells

std::vector<DetId> HcalDigitizer::hbheCells

private

Definition at line 161 of file HcalDigitizer.h.

Referenced by updateGeometry().

hbhegeo

bool HcalDigitizer::hbhegeo

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

hcalTimeSlew_delay_

const HcalTimeSlew* HcalDigitizer::hcalTimeSlew_delay_

private

Definition at line 188 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

hcalTimeSlew_delay_token_

const edm::ESGetToken<HcalTimeSlew, HcalTimeSlewRecord> HcalDigitizer::hcalTimeSlew_delay_token_

private

Definition at line 91 of file HcalDigitizer.h.

Referenced by setup().

hcalToken_

edm::EDGetTokenT<std::vector<PCaloHit> > HcalDigitizer::hcalToken_

private

Definition at line 183 of file HcalDigitizer.h.

Referenced by accumulate().

hfgeo

bool HcalDigitizer::hfgeo

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

hitsProducer_

std::string HcalDigitizer::hitsProducer_

private

Definition at line 175 of file HcalDigitizer.h.

Referenced by accumulate().

hogeo

bool HcalDigitizer::hogeo

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

ignoreTime_

bool HcalDigitizer::ignoreTime_

private

Definition at line 172 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

injectedHits_

std::vector<PCaloHit> HcalDigitizer::injectedHits_

private

Definition at line 193 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

injectedHitsCells_

std::vector<int> HcalDigitizer::injectedHitsCells_

private

Definition at line 192 of file HcalDigitizer.h.

Referenced by updateGeometry().

injectedHitsEnergy_

std::vector<double> HcalDigitizer::injectedHitsEnergy_

private

Definition at line 190 of file HcalDigitizer.h.

Referenced by updateGeometry().

injectedHitsTime_

std::vector<double> HcalDigitizer::injectedHitsTime_

private

Definition at line 191 of file HcalDigitizer.h.

Referenced by updateGeometry().

injectTestHits_

bool HcalDigitizer::injectTestHits_

private

Definition at line 173 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), finalizeEvent(), and updateGeometry().

isHCAL

bool HcalDigitizer::isHCAL

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), and finalizeEvent().

isZDC

bool HcalDigitizer::isZDC

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), and finalizeEvent().

killHE_

bool HcalDigitizer::killHE_

private

Definition at line 170 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and updateGeometry().

m_HBDarkening

const HBHEDarkening* HcalDigitizer::m_HBDarkening

private

Definition at line 184 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and setup().

m_HBDarkeningToken

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalDigitizer::m_HBDarkeningToken

private

Definition at line 89 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

m_HEDarkening

const HBHEDarkening* HcalDigitizer::m_HEDarkening

private

Definition at line 185 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and setup().

m_HEDarkeningToken

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalDigitizer::m_HEDarkeningToken

private

Definition at line 90 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

m_HFRecalibration

std::unique_ptr<HFRecalibration> HcalDigitizer::m_HFRecalibration

private

Definition at line 186 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and HcalDigitizer().

mcParamsToken_

edm::ESGetToken<HcalMCParams, HcalMCParamsRcd> HcalDigitizer::mcParamsToken_

private

Definition at line 95 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

qieTypesToken_

const edm::ESGetToken<HcalQIETypes, HcalQIETypesRcd> HcalDigitizer::qieTypesToken_

private

Definition at line 94 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and buildHFQIECells().

testNumbering_

bool HcalDigitizer::testNumbering_

private

Definition at line 168 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and HcalDigitizer().

theCoderFactory

std::unique_ptr<HcalCoderFactory> HcalDigitizer::theCoderFactory

private

Definition at line 131 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

theGeometry

const CaloGeometry* HcalDigitizer::theGeometry

private

Definition at line 99 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

theGeometryToken

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> HcalDigitizer::theGeometryToken

private

Definition at line 92 of file HcalDigitizer.h.

Referenced by checkGeometry().

theGeometryWatcher_

edm::ESWatcher<CaloGeometryRecord> HcalDigitizer::theGeometryWatcher_

private

Definition at line 96 of file HcalDigitizer.h.

Referenced by checkGeometry().

theHBHEAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEAmplifier

private

Definition at line 123 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setHBHENoiseSignalGenerator(), and setup().

theHBHEDigitizer

std::unique_ptr<HBHEDigitizer> HcalDigitizer::theHBHEDigitizer

private

Definition at line 150 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHBHEQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHBHENoiseSignalGenerator().

theHBHEElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEElectronicsSim

private

Definition at line 133 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHBHENoiseSignalGenerator().

theHBHEHitFilter

HBHEHitFilter HcalDigitizer::theHBHEHitFilter

private

Definition at line 140 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

theHBHEQIE11Amplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEQIE11Amplifier

private

Definition at line 128 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setQIE11NoiseSignalGenerator(), and setup().

theHBHEQIE11DetIds

std::vector<DetId> HcalDigitizer::theHBHEQIE11DetIds

private

Definition at line 162 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), finalizeEvent(), and updateGeometry().

theHBHEQIE11Digitizer

std::unique_ptr<QIE11Digitizer> HcalDigitizer::theHBHEQIE11Digitizer

private

Definition at line 156 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHBHEQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setQIE11NoiseSignalGenerator().

theHBHEQIE11ElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEQIE11ElectronicsSim

private

Definition at line 138 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE11NoiseSignalGenerator().

theHBHEQIE11HitFilter

HBHEHitFilter HcalDigitizer::theHBHEQIE11HitFilter

private

Definition at line 141 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

theHBHEQIE8DetIds

std::vector<DetId> HcalDigitizer::theHBHEQIE8DetIds

private

Definition at line 162 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells().

theHBHEResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHBHEResponse

private

Definition at line 113 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

theHBHESiPMResponse

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHBHESiPMResponse

private

Definition at line 114 of file HcalDigitizer.h.

Referenced by checkGeometry(), finalizeEvent(), HcalDigitizer(), and updateGeometry().

theHFAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFAmplifier

private

Definition at line 124 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setHFNoiseSignalGenerator().

theHFDigitizer

std::unique_ptr<HFDigitizer> HcalDigitizer::theHFDigitizer

private

Definition at line 153 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHFQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHFNoiseSignalGenerator().

theHFElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFElectronicsSim

private

Definition at line 134 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHFNoiseSignalGenerator().

theHFHitFilter

HFHitFilter HcalDigitizer::theHFHitFilter

private

Definition at line 142 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

theHFQIE10Amplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFQIE10Amplifier

private

Definition at line 127 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

theHFQIE10DetIds

std::vector<DetId> HcalDigitizer::theHFQIE10DetIds

private

Definition at line 165 of file HcalDigitizer.h.

Referenced by buildHFQIECells(), and finalizeEvent().

theHFQIE10Digitizer

std::unique_ptr<QIE10Digitizer> HcalDigitizer::theHFQIE10Digitizer

private

Definition at line 155 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHFQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

theHFQIE10ElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFQIE10ElectronicsSim

private

Definition at line 137 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

theHFQIE10HitFilter

HFHitFilter HcalDigitizer::theHFQIE10HitFilter

private

Definition at line 143 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

theHFQIE10Response

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFQIE10Response

private

Definition at line 118 of file HcalDigitizer.h.

Referenced by checkGeometry(), finalizeEvent(), and HcalDigitizer().

theHFQIE8DetIds

std::vector<DetId> HcalDigitizer::theHFQIE8DetIds

private

Definition at line 165 of file HcalDigitizer.h.

Referenced by buildHFQIECells().

theHFResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFResponse

private

Definition at line 117 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

theHOAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHOAmplifier

private

Definition at line 125 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setHONoiseSignalGenerator(), and setup().

theHODigitizer

std::unique_ptr<HODigitizer> HcalDigitizer::theHODigitizer

private

Definition at line 151 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHOSiPMCells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHONoiseSignalGenerator().

theHOElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHOElectronicsSim

private

Definition at line 135 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHONoiseSignalGenerator().

theHOHitFilter

HOHitFilter HcalDigitizer::theHOHitFilter

private

Definition at line 144 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

theHOHPDDetIds

std::vector<DetId> HcalDigitizer::theHOHPDDetIds

private

Definition at line 163 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

theHOResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHOResponse

private

Definition at line 115 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

theHOSiPMCode

int HcalDigitizer::theHOSiPMCode

private

Definition at line 177 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

theHOSiPMDetIds

std::vector<DetId> HcalDigitizer::theHOSiPMDetIds

private

Definition at line 164 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

theHOSiPMDigitizer

std::unique_ptr<HODigitizer> HcalDigitizer::theHOSiPMDigitizer

private

Definition at line 152 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHOSiPMCells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), setHONoiseSignalGenerator(), and updateGeometry().

theHOSiPMHitFilter

HOHitFilter HcalDigitizer::theHOSiPMHitFilter

private

Definition at line 145 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

theHOSiPMResponse

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHOSiPMResponse

private

Definition at line 116 of file HcalDigitizer.h.

Referenced by checkGeometry(), HcalDigitizer(), and updateGeometry().

theIonFeedback

std::unique_ptr<HPDIonFeedbackSim> HcalDigitizer::theIonFeedback

private

Definition at line 130 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

theParameterMap

HcalSimParameterMap HcalDigitizer::theParameterMap

private

Definition at line 110 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), HcalDigitizer(), initializeEvent(), setHBHENoiseSignalGenerator(), setHFNoiseSignalGenerator(), setHONoiseSignalGenerator(), setQIE10NoiseSignalGenerator(), setQIE11NoiseSignalGenerator(), and setZDCNoiseSignalGenerator().

theRecNumber

const HcalDDDRecConstants* HcalDigitizer::theRecNumber

private

Definition at line 100 of file HcalDigitizer.h.

Referenced by checkGeometry().

theRecNumberToken

const edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> HcalDigitizer::theRecNumberToken

private

Definition at line 93 of file HcalDigitizer.h.

Referenced by checkGeometry().

theRecNumberWatcher_

edm::ESWatcher<HcalRecNumberingRecord> HcalDigitizer::theRecNumberWatcher_

private

Definition at line 97 of file HcalDigitizer.h.

Referenced by checkGeometry().

theRelabeller

std::unique_ptr<HcalHitRelabeller> HcalDigitizer::theRelabeller

private

Definition at line 157 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), checkGeometry(), and HcalDigitizer().

theShapes

HcalShapes HcalDigitizer::theShapes

private

Definition at line 111 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

theTimeSlewSim

std::unique_ptr<HcalTimeSlewSim> HcalDigitizer::theTimeSlewSim

private

Definition at line 148 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

theZDCAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theZDCAmplifier

private

Definition at line 126 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setup(), and setZDCNoiseSignalGenerator().

theZDCDigitizer

std::unique_ptr<ZDCDigitizer> HcalDigitizer::theZDCDigitizer

private

Definition at line 154 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), HcalDigitizer(), initializeEvent(), setZDCNoiseSignalGenerator(), and updateGeometry().

theZDCElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theZDCElectronicsSim

private

Definition at line 136 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setZDCNoiseSignalGenerator().

theZDCHitFilter

ZDCHitFilter HcalDigitizer::theZDCHitFilter

private

Definition at line 146 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

theZDCResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theZDCResponse

private

Definition at line 119 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

topoToken_

const edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> HcalDigitizer::topoToken_

private

Definition at line 88 of file HcalDigitizer.h.

Referenced by accumulate(), buildHBHEQIECells(), buildHFQIECells(), and buildHOSiPMCells().

zdcgeo

bool HcalDigitizer::zdcgeo

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

zdcToken_

edm::EDGetTokenT<std::vector<PCaloHit> > HcalDigitizer::zdcToken_

private

Definition at line 182 of file HcalDigitizer.h.

Referenced by accumulate().