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

typedef CaloTDigitizer<HBHEDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HBHEDigitizer

private

Reconstruction algorithm

Definition at line 89 of file HcalDigitizer.h.

typedef CaloTDigitizer<HFDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer

private

Definition at line 91 of file HcalDigitizer.h.

typedef CaloTDigitizer<HODigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer

private

Definition at line 90 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE10DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer

private

Definition at line 93 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE11DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer

private

Definition at line 94 of file HcalDigitizer.h.

typedef CaloTDigitizer<ZDCDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer

private

Definition at line 92 of file HcalDigitizer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 37 of file HcalDigitizer.cc.

References edm::ConsumesCollector::consumes(), HcalCoderFactory::DB, debugCS_, deliveredLumi, hcalUnsuppressedDigis_cfi::doEmpty, hcalUnsuppressedDigis_cfi::doNoise, hcalUnsuppressedDigis_cfi::doTimeSlew, Exception, edm::ParameterSet::getParameter(), hcalTimeSlew_delay_, hitsProducer_, ignoreTime_, 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.

                                                                                :
  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>(theHBHEAmplifier.get(), theCoderFactory.get(), PreMix1);
  theHFElectronicsSim = std::make_unique<HcalElectronicsSim>(theHFAmplifier.get(), theCoderFactory.get(), PreMix1);
  theHOElectronicsSim = std::make_unique<HcalElectronicsSim>(theHOAmplifier.get(), theCoderFactory.get(), PreMix1);
  theZDCElectronicsSim = std::make_unique<HcalElectronicsSim>(theZDCAmplifier.get(), theCoderFactory.get(), PreMix1);
  theHFQIE10ElectronicsSim = std::make_unique<HcalElectronicsSim>(theHFQIE10Amplifier.get(), theCoderFactory.get(), PreMix1); //should this use a different coder factory?
  theHBHEQIE11ElectronicsSim = std::make_unique<HcalElectronicsSim>(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.reset(new HFRecalibration(ps.getParameter<edm::ParameterSet>("HFRecalParameterBlock")));
}

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 217 of file HcalDigitizer.cc.

                              {
}

Member Function Documentation

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

Definition at line 372 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::accumulate().

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

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

Definition at line 391 of file HcalDigitizer.cc.

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

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

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

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

                                                                                                                                                                                                                       {

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

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

private

Definition at line 655 of file HcalDigitizer.cc.

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

Referenced by updateGeometry().

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

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

private

Definition at line 618 of file HcalDigitizer.cc.

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

Referenced by updateGeometry().

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

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

private

Definition at line 699 of file HcalDigitizer.cc.

References edm::EventSetup::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().

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

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

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

Referenced by setup().

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

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

private

Definition at line 755 of file HcalDigitizer.cc.

References HBHEDarkening::degradation(), deliveredLumi, egammaForCoreTracking_cff::depth, HcalBarrel, HcalEndcap, HcalForward, 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); 
  }
  
}

void HcalDigitizer::fillFakeHits ( )

private

some hits in each subdetector, just for testing purposes

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

Definition at line 410 of file HcalDigitizer.cc.

References gather_cfg::cout, debugCS_, hbhegeo, hfgeo, hogeo, injectedHits_, injectTestHits_, isHCAL, isZDC, HcalDataFrameContainer< QIE11DataFrame >::MAXSAMPLES, HcalDataFrameContainer< QIE10DataFrame >::MAXSAMPLES, eostools::move(), edm::Event::put(), CaloSimParameters::readoutFrameSize(), HcalSimParameterMap::simParameters(), theHBHEDigitizer, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHESiPMResponse, theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, theHODigitizer, theHOSiPMDigitizer, theParameterMap, 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() ? 
      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

}

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

Produces the EDM products,

Definition at line 264 of file HcalDigitizer.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::product(), 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
  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();

}

void HcalDigitizer::setHBHENoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 221 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);
}

void HcalDigitizer::setHFNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 235 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);
}

void HcalDigitizer::setHONoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 249 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);
}

void HcalDigitizer::setQIE10NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 242 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);
}

void HcalDigitizer::setQIE11NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 228 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);
}

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

private

Definition at line 501 of file HcalDigitizer.cc.

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

Referenced by initializeEvent().

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

void HcalDigitizer::setZDCNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 257 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);
}

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

private

Definition at line 552 of file HcalDigitizer.cc.

References buildHBHEQIECells(), buildHFQIECells(), buildHOSiPMCells(), DetId::Calo, 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, 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);
//  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);
      }
    }
  }
}

Member Data Documentation

bool HcalDigitizer::agingFlagHB

private

Definition at line 166 of file HcalDigitizer.h.

Referenced by setup().

bool HcalDigitizer::agingFlagHE

private

Definition at line 166 of file HcalDigitizer.h.

Referenced by setup().

bool HcalDigitizer::debugCS_

private

Definition at line 157 of file HcalDigitizer.h.

Referenced by finalizeEvent(), and HcalDigitizer().

double HcalDigitizer::deliveredLumi

private

Definition at line 165 of file HcalDigitizer.h.

Referenced by darkening(), and HcalDigitizer().

bool HcalDigitizer::doHFWindow_

private

Definition at line 155 of file HcalDigitizer.h.

Referenced by accumulateCaloHits().

std::vector<DetId> HcalDigitizer::hbheCells

private

Definition at line 147 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::hbhegeo

private

Definition at line 153 of file HcalDigitizer.h.

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

const HcalTimeSlew* HcalDigitizer::hcalTimeSlew_delay_

private

Definition at line 171 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

bool HcalDigitizer::hfgeo

private

Definition at line 153 of file HcalDigitizer.h.

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

std::string HcalDigitizer::hitsProducer_

private

Definition at line 161 of file HcalDigitizer.h.

Referenced by accumulate(), and HcalDigitizer().

bool HcalDigitizer::hogeo

private

Definition at line 153 of file HcalDigitizer.h.

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

bool HcalDigitizer::ignoreTime_

private

Definition at line 158 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::vector<PCaloHit> HcalDigitizer::injectedHits_

private

Definition at line 176 of file HcalDigitizer.h.

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

std::vector<int> HcalDigitizer::injectedHitsCells_

private

Definition at line 175 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsEnergy_

private

Definition at line 173 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsTime_

private

Definition at line 174 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::injectTestHits_

private

Definition at line 159 of file HcalDigitizer.h.

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

bool HcalDigitizer::isHCAL

private

Definition at line 153 of file HcalDigitizer.h.

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

bool HcalDigitizer::isZDC

private

Definition at line 153 of file HcalDigitizer.h.

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

bool HcalDigitizer::killHE_

private

Definition at line 156 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and updateGeometry().

const HBHEDarkening* HcalDigitizer::m_HBDarkening

private

Definition at line 167 of file HcalDigitizer.h.

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

const HBHEDarkening* HcalDigitizer::m_HEDarkening

private

Definition at line 168 of file HcalDigitizer.h.

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

std::unique_ptr<HFRecalibration> HcalDigitizer::m_HFRecalibration

private

Definition at line 169 of file HcalDigitizer.h.

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

bool HcalDigitizer::testNumbering_

private

Definition at line 154 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and HcalDigitizer().

std::unique_ptr<HcalCoderFactory> HcalDigitizer::theCoderFactory

private

Definition at line 117 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

const CaloGeometry* HcalDigitizer::theGeometry

private

Definition at line 77 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

edm::ESWatcher<CaloGeometryRecord> HcalDigitizer::theGeometryWatcher_

private

Definition at line 75 of file HcalDigitizer.h.

Referenced by checkGeometry().

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEAmplifier

private

Definition at line 109 of file HcalDigitizer.h.

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

std::unique_ptr<HBHEDigitizer> HcalDigitizer::theHBHEDigitizer

private

Definition at line 136 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEElectronicsSim

private

Definition at line 119 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHBHENoiseSignalGenerator().

HBHEHitFilter HcalDigitizer::theHBHEHitFilter

private

Definition at line 126 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEQIE11Amplifier

private

Definition at line 114 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHBHEQIE11DetIds

private

Definition at line 148 of file HcalDigitizer.h.

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

std::unique_ptr<QIE11Digitizer> HcalDigitizer::theHBHEQIE11Digitizer

private

Definition at line 142 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEQIE11ElectronicsSim

private

Definition at line 124 of file HcalDigitizer.h.

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

HBHEHitFilter HcalDigitizer::theHBHEQIE11HitFilter

private

Definition at line 127 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHBHEQIE8DetIds

private

Definition at line 148 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells().

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHBHEResponse

private

Definition at line 99 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHBHESiPMResponse

private

Definition at line 100 of file HcalDigitizer.h.

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

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFAmplifier

private

Definition at line 110 of file HcalDigitizer.h.

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

std::unique_ptr<HFDigitizer> HcalDigitizer::theHFDigitizer

private

Definition at line 139 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFElectronicsSim

private

Definition at line 120 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHFNoiseSignalGenerator().

HFHitFilter HcalDigitizer::theHFHitFilter

private

Definition at line 128 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFQIE10Amplifier

private

Definition at line 113 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHFQIE10DetIds

private

Definition at line 151 of file HcalDigitizer.h.

Referenced by buildHFQIECells(), and finalizeEvent().

std::unique_ptr<QIE10Digitizer> HcalDigitizer::theHFQIE10Digitizer

private

Definition at line 141 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFQIE10ElectronicsSim

private

Definition at line 123 of file HcalDigitizer.h.

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

HFHitFilter HcalDigitizer::theHFQIE10HitFilter

private

Definition at line 129 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFQIE10Response

private

Definition at line 104 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHFQIE8DetIds

private

Definition at line 151 of file HcalDigitizer.h.

Referenced by buildHFQIECells().

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFResponse

private

Definition at line 103 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHOAmplifier

private

Definition at line 111 of file HcalDigitizer.h.

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

std::unique_ptr<HODigitizer> HcalDigitizer::theHODigitizer

private

Definition at line 137 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHOElectronicsSim

private

Definition at line 121 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHONoiseSignalGenerator().

HOHitFilter HcalDigitizer::theHOHitFilter

private

Definition at line 130 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHOHPDDetIds

private

Definition at line 149 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHOResponse

private

Definition at line 101 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

int HcalDigitizer::theHOSiPMCode

private

Definition at line 163 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHOSiPMDetIds

private

Definition at line 150 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

std::unique_ptr<HODigitizer> HcalDigitizer::theHOSiPMDigitizer

private

Definition at line 138 of file HcalDigitizer.h.

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

HOHitFilter HcalDigitizer::theHOSiPMHitFilter

private

Definition at line 131 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHOSiPMResponse

private

Definition at line 102 of file HcalDigitizer.h.

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

std::unique_ptr<HPDIonFeedbackSim> HcalDigitizer::theIonFeedback

private

Definition at line 116 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

HcalSimParameterMap HcalDigitizer::theParameterMap

private

Definition at line 96 of file HcalDigitizer.h.

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

const HcalDDDRecConstants* HcalDigitizer::theRecNumber

private

Definition at line 78 of file HcalDigitizer.h.

Referenced by checkGeometry().

edm::ESWatcher<HcalRecNumberingRecord> HcalDigitizer::theRecNumberWatcher_

private

Definition at line 76 of file HcalDigitizer.h.

Referenced by checkGeometry().

std::unique_ptr<HcalHitRelabeller> HcalDigitizer::theRelabeller

private

Definition at line 143 of file HcalDigitizer.h.

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

HcalShapes HcalDigitizer::theShapes

private

Definition at line 97 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

std::unique_ptr<HcalTimeSlewSim> HcalDigitizer::theTimeSlewSim

private

Definition at line 134 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::unique_ptr<HcalAmplifier> HcalDigitizer::theZDCAmplifier

private

Definition at line 112 of file HcalDigitizer.h.

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

std::unique_ptr<ZDCDigitizer> HcalDigitizer::theZDCDigitizer

private

Definition at line 140 of file HcalDigitizer.h.

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

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theZDCElectronicsSim

private

Definition at line 122 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setZDCNoiseSignalGenerator().

ZDCHitFilter HcalDigitizer::theZDCHitFilter

private

Definition at line 132 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::unique_ptr<CaloHitResponse> HcalDigitizer::theZDCResponse

private

Definition at line 105 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

bool HcalDigitizer::zdcgeo

private

Definition at line 153 of file HcalDigitizer.h.

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