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	beginRun (const edm::EventSetup &es)
void	endRun ()
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	updateGeometry (const edm::EventSetup &eventSetup)

Private Attributes
bool	debugCS_
double	deliveredLumi
bool	doHFWindow_
std::vector< DetId >	hbheCells
bool	hbhegeo
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_
HEDarkening *	m_HEDarkening
HFRecalibration *	m_HFRecalibration
bool	neutralDensity_
bool	testNumbering_
HcalCoderFactory *	theCoderFactory
const CaloGeometry *	theGeometry
HcalAmplifier *	theHBHEAmplifier
HBHEDigitizer *	theHBHEDigitizer
HcalElectronicsSim *	theHBHEElectronicsSim
HBHEHitFilter	theHBHEHitFilter
HcalAmplifier *	theHBHEQIE11Amplifier
std::vector< DetId >	theHBHEQIE11DetIds
QIE11Digitizer *	theHBHEQIE11Digitizer
HcalElectronicsSim *	theHBHEQIE11ElectronicsSim
HBHEHitFilter	theHBHEQIE11HitFilter
std::vector< DetId >	theHBHEQIE8DetIds
CaloHitResponse *	theHBHEResponse
CaloHitResponse *	theHBHESiPMResponse
HcalAmplifier *	theHFAmplifier
HFDigitizer *	theHFDigitizer
HcalElectronicsSim *	theHFElectronicsSim
HFHitFilter	theHFHitFilter
HcalAmplifier *	theHFQIE10Amplifier
std::vector< DetId >	theHFQIE10DetIds
QIE10Digitizer *	theHFQIE10Digitizer
HcalElectronicsSim *	theHFQIE10ElectronicsSim
HFHitFilter	theHFQIE10HitFilter
CaloHitResponse *	theHFQIE10Response
std::vector< DetId >	theHFQIE8DetIds
CaloHitResponse *	theHFResponse
HcalAmplifier *	theHOAmplifier
HODigitizer *	theHODigitizer
HcalElectronicsSim *	theHOElectronicsSim
HOHitFilter	theHOHitFilter
std::vector< DetId >	theHOHPDDetIds
CaloHitResponse *	theHOResponse
int	theHOSiPMCode
std::vector< DetId >	theHOSiPMDetIds
HODigitizer *	theHOSiPMDigitizer
HOHitFilter	theHOSiPMHitFilter
CaloHitResponse *	theHOSiPMResponse
HPDIonFeedbackSim *	theIonFeedback
HcalSimParameterMap *	theParameterMap
const HcalDDDRecConstants *	theRecNumber
HcalHitRelabeller *	theRelabeller
HcalShapes *	theShapes
HcalTimeSlewSim *	theTimeSlewSim
HcalAmplifier *	theZDCAmplifier
ZDCDigitizer *	theZDCDigitizer
HcalElectronicsSim *	theZDCElectronicsSim
ZDCHitFilter	theZDCHitFilter
CaloHitResponse *	theZDCResponse
bool	zdcgeo

Detailed Description

Definition at line 40 of file HcalDigitizer.h.

Member Typedef Documentation

typedef CaloTDigitizer<HBHEDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HBHEDigitizer

private

Reconstruction algorithm

Definition at line 82 of file HcalDigitizer.h.

typedef CaloTDigitizer<HFDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer

private

Definition at line 84 of file HcalDigitizer.h.

typedef CaloTDigitizer<HODigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer

private

Definition at line 83 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE10DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer

private

Definition at line 86 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE11DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer

private

Definition at line 87 of file HcalDigitizer.h.

typedef CaloTDigitizer<ZDCDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer

private

Definition at line 85 of file HcalDigitizer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 38 of file HcalDigitizer.cc.

References edm::ConsumesCollector::consumes(), HcalCoderFactory::DB, debugCS_, deliveredLumi, Exception, edm::ParameterSet::getParameter(), hitsProducer_, ignoreTime_, HLT_FULL_cff::InputTag, m_HEDarkening, m_HFRecalibration, CaloTDigitizer< Traits, runHelper >::setDebugCaloSamples(), CaloHitResponse::setHitFilter(), CaloHitResponse::setIgnoreGeantTime(), HcalAmplifier::setIonFeedbackSim(), CaloHitResponse::setPECorrection(), HcalAmplifier::setTimeSlewSim(), 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(0),
  theRecNumber(0),
  theParameterMap(new HcalSimParameterMap(ps)),
  theShapes(new HcalShapes()),
  theHBHEResponse(new CaloHitResponse(theParameterMap, theShapes)),
  theHBHESiPMResponse(new HcalSiPMHitResponse(theParameterMap, theShapes, ps.getParameter<bool>("HcalPreMixStage1"))),
  theHOResponse(new CaloHitResponse(theParameterMap, theShapes)),   
  theHOSiPMResponse(new HcalSiPMHitResponse(theParameterMap, theShapes)),
  theHFResponse(new CaloHitResponse(theParameterMap, theShapes)),
  theHFQIE10Response(new CaloHitResponse(theParameterMap, theShapes)),
  theZDCResponse(new CaloHitResponse(theParameterMap, theShapes)),
  theHBHEAmplifier(0),
  theHFAmplifier(0),
  theHOAmplifier(0),
  theZDCAmplifier(0),
  theHFQIE10Amplifier(0),
  theHBHEQIE11Amplifier(0),
  theIonFeedback(0),
  theCoderFactory(0),
  theHBHEElectronicsSim(0),
  theHFElectronicsSim(0),
  theHOElectronicsSim(0),
  theZDCElectronicsSim(0),
  theHFQIE10ElectronicsSim(0),
  theHBHEQIE11ElectronicsSim(0),
  theHBHEHitFilter(),
  theHBHEQIE11HitFilter(),
  theHFHitFilter(),
  theHFQIE10HitFilter(),
  theHOHitFilter(),
  theHOSiPMHitFilter(),
  theZDCHitFilter(),
  theHBHEDigitizer(0),
  theHODigitizer(0),
  theHOSiPMDigitizer(0),
  theHFDigitizer(0),
  theZDCDigitizer(0),
  theHFQIE10Digitizer(0),
  theHBHEQIE11Digitizer(0),
  theRelabeller(0),
  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.),
  m_HEDarkening(0),
  m_HFRecalibration(0),
  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 agingFlagHE = ps.getParameter<bool>("HEDarkening");
  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 = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);
  theHFAmplifier = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);
  theHOAmplifier = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);
  theZDCAmplifier = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);
  theHFQIE10Amplifier = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);
  theHBHEQIE11Amplifier = new HcalAmplifier(theParameterMap, doNoise, PreMix1, PreMix2);

  theCoderFactory = new HcalCoderFactory(HcalCoderFactory::DB);

  theHBHEElectronicsSim = new HcalElectronicsSim(theHBHEAmplifier, theCoderFactory, PreMix1);
  theHFElectronicsSim = new HcalElectronicsSim(theHFAmplifier, theCoderFactory, PreMix1);
  theHOElectronicsSim = new HcalElectronicsSim(theHOAmplifier, theCoderFactory, PreMix1);
  theZDCElectronicsSim = new HcalElectronicsSim(theZDCAmplifier, theCoderFactory, PreMix1);
  theHFQIE10ElectronicsSim = new HcalElectronicsSim(theHFQIE10Amplifier, theCoderFactory, PreMix1); //should this use a different coder factory?
  theHBHEQIE11ElectronicsSim = new HcalElectronicsSim(theHBHEQIE11Amplifier, theCoderFactory, PreMix1); //should this use a different coder factory?

  bool doHOHPD = (theHOSiPMCode != 1);
  bool doHOSiPM = (theHOSiPMCode != 0);
  if(doHOHPD) {
    theHOResponse = new CaloHitResponse(theParameterMap, theShapes);
    theHOResponse->setHitFilter(&theHOHitFilter);
    theHODigitizer = new HODigitizer(theHOResponse, theHOElectronicsSim, doEmpty);
  }
  if(doHOSiPM) {
    theHOSiPMResponse = new HcalSiPMHitResponse(theParameterMap, theShapes);
    theHOSiPMResponse->setHitFilter(&theHOSiPMHitFilter);
    theHOSiPMDigitizer = new HODigitizer(theHOSiPMResponse, theHOElectronicsSim, doEmpty);
  }
  
  theHBHEResponse->setHitFilter(&theHBHEHitFilter);
  theHBHESiPMResponse->setHitFilter(&theHBHEQIE11HitFilter);
  
  //QIE8 and QIE11 can coexist in HBHE
  theHBHEQIE11Digitizer = new QIE11Digitizer(theHBHESiPMResponse, theHBHEQIE11ElectronicsSim, doEmpty);
  theHBHEDigitizer = new HBHEDigitizer(theHBHEResponse, theHBHEElectronicsSim, doEmpty);

  bool doTimeSlew = ps.getParameter<bool>("doTimeSlew");
  //initialize: they won't be called later if flag is set
  theTimeSlewSim = 0;
  if(doTimeSlew) {
    // no time slewing for HF
    theTimeSlewSim = new HcalTimeSlewSim(theParameterMap,minFCToDelay);
    theHBHEAmplifier->setTimeSlewSim(theTimeSlewSim);
    theHBHEQIE11Amplifier->setTimeSlewSim(theTimeSlewSim);
    theHOAmplifier->setTimeSlewSim(theTimeSlewSim);
    theZDCAmplifier->setTimeSlewSim(theTimeSlewSim);
  }

  theHFResponse->setHitFilter(&theHFHitFilter);
  theHFQIE10Response->setHitFilter(&theHFQIE10HitFilter);
  theZDCResponse->setHitFilter(&theZDCHitFilter);
  
  //QIE8 and QIE10 can coexist in HF
  theHFQIE10Digitizer = new QIE10Digitizer(theHFQIE10Response, theHFQIE10ElectronicsSim, doEmpty);
  theHFDigitizer = new HFDigitizer(theHFResponse, theHFElectronicsSim, doEmpty);

  theZDCDigitizer = new ZDCDigitizer(theZDCResponse, theZDCElectronicsSim, doEmpty);

  testNumbering_ = ps.getParameter<bool>("TestNumbering");
//  std::cout << "Flag to see if Hit Relabeller to be initiated " << testNumbering_ << std::endl;
  if (testNumbering_) theRelabeller=new HcalHitRelabeller(ps);

  if(ps.getParameter<bool>("doIonFeedback") && theHBHEResponse) {
    theIonFeedback = new HPDIonFeedbackSim(ps, theShapes);
    theHBHEResponse->setPECorrection(theIonFeedback);
    if(ps.getParameter<bool>("doThermalNoise")) {
      theHBHEAmplifier->setIonFeedbackSim(theIonFeedback);
    }
  }

  //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(agingFlagHE) m_HEDarkening = new HEDarkening();
  if(agingFlagHF) m_HFRecalibration = new HFRecalibration(ps.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
}

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 217 of file HcalDigitizer.cc.

References theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHBHEResponse, theHBHESiPMResponse, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHFQIE10Response, theHFResponse, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOResponse, theHOSiPMDigitizer, theHOSiPMResponse, theParameterMap, theRelabeller, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, and theZDCResponse.

                              {
  if(theHBHEDigitizer)         delete theHBHEDigitizer;
  if(theHBHEQIE11Digitizer)    delete theHBHEQIE11Digitizer;
  if(theHODigitizer)           delete theHODigitizer;
  if(theHOSiPMDigitizer)       delete theHOSiPMDigitizer;
  if(theHFDigitizer)           delete theHFDigitizer;
  if(theHFQIE10Digitizer)      delete theHFQIE10Digitizer;
  delete theZDCDigitizer;
  delete theParameterMap;
  delete theHBHEResponse;
  delete theHBHESiPMResponse;
  delete theHOResponse;
  delete theHOSiPMResponse;
  delete theHFResponse;
  delete theHFQIE10Response;
  delete theZDCResponse;
  delete theHBHEElectronicsSim;
  delete theHFElectronicsSim;
  delete theHOElectronicsSim;
  delete theZDCElectronicsSim;
  delete theHFQIE10ElectronicsSim;
  delete theHBHEQIE11ElectronicsSim;
  delete theHBHEAmplifier;
  delete theHFAmplifier;
  delete theHOAmplifier;
  delete theZDCAmplifier;
  delete theHFQIE10Amplifier;
  delete theHBHEQIE11Amplifier;
  delete theCoderFactory;
  if (theRelabeller)           delete theRelabeller;
}

Member Function Documentation

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

Definition at line 397 of file HcalDigitizer.cc.

References accumulateCaloHits(), edm::EventSetup::get(), edm::Event::getByLabel(), hitsProducer_, injectTestHits_, isHCAL, edm::HandleBase::isValid(), isZDC, or, and edm::ESHandle< class >::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 416 of file HcalDigitizer.cc.

References accumulateCaloHits(), PileUpEventPrincipal::bunchCrossing(), edm::EventSetup::get(), PileUpEventPrincipal::getByLabel(), hitsProducer_, isHCAL, edm::HandleBase::isValid(), isZDC, and edm::ESHandle< class >::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 322 of file HcalDigitizer.cc.

References CaloTDigitizer< Traits, runHelper >::add(), gather_cfg::cout, darkening(), TauDecayModes::dec, doHFWindow_, hbhegeo, HcalEndcap, HcalForward, hfgeo, hogeo, i, injectedHits_, injectTestHits_, isHCAL, isZDC, killHE_, m_HEDarkening, m_HFRecalibration, HcalDetId::newForm(), HcalDetId::oldFormat(), HcalHitRelabeller::process(), 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_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::beginRun

(

const edm::EventSetup &

es

)

Definition at line 525 of file HcalDigitizer.cc.

References HcalShapes::beginRun(), checkGeometry(), and theShapes.

Referenced by HcalDigiProducer::beginRun().

                                                     {
  checkGeometry(es);
  theShapes->beginRun(es);
}

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

private

Definition at line 666 of file HcalDigitizer.cc.

References edm::EventSetup::get(), NULL, edm::ESHandle< class >::product(), lumiQueryAPI::q, QIE11, QIE8, HcalHitFilter< subdets >::setDetIds(), CaloTDigitizer< Traits, runHelper >::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.size()>0 || theHBHEQIE11DetIds.size()>0) 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()==0) {
      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.size()>0) theHBHEDigitizer->setDetIds(theHBHEQIE8DetIds);
    else {
        delete theHBHEDigitizer;
        theHBHEDigitizer = NULL;
    }
    
    if(theHBHEQIE11DetIds.size()>0) theHBHEQIE11Digitizer->setDetIds(theHBHEQIE11DetIds);
    else {
        delete theHBHEQIE11Digitizer;
        theHBHEQIE11Digitizer = NULL;
    }
    
    if(theHBHEQIE8DetIds.size()>0 && theHBHEQIE11DetIds.size()>0){
        theHBHEHitFilter.setDetIds(theHBHEQIE8DetIds);
        theHBHEQIE11HitFilter.setDetIds(theHBHEQIE11DetIds);
    }
}

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

private

Definition at line 627 of file HcalDigitizer.cc.

References edm::EventSetup::get(), NULL, edm::ESHandle< class >::product(), lumiQueryAPI::q, QIE10, QIE8, CaloTDigitizer< Traits, runHelper >::setDetIds(), HcalCondObjectContainerBase::setTopo(), theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, and theHFQIE8DetIds.

Referenced by updateGeometry().

                                                                                                      {
    //if results are already cached, no need to look again
    if(theHFQIE8DetIds.size()>0 || theHFQIE10DetIds.size()>0) 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()==0) {
      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.size()>0) theHFDigitizer->setDetIds(theHFQIE8DetIds);
    else {
        delete theHFDigitizer;
        theHFDigitizer = NULL;
    }
    
    if(theHFQIE10DetIds.size()>0) theHFQIE10Digitizer->setDetIds(theHFQIE10DetIds);
    else {
        delete theHFQIE10Digitizer;
        theHFQIE10Digitizer = NULL;
    }
}

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

private

Definition at line 712 of file HcalDigitizer.cc.

References edm::EventSetup::get(), HcalShapes::HAMAMATSU, NULL, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< class >::product(), HcalHitFilter< subdets >::setDetIds(), CaloTDigitizer< Traits, runHelper >::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()==0) {
      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.size()>0) theHODigitizer->setDetIds(theHOHPDDetIds);
    else {
      delete theHODigitizer;
      theHODigitizer = NULL;
    }
    
    if(theHOSiPMDetIds.size()>0) theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
    else {
      delete theHOSiPMDigitizer;
      theHOSiPMDigitizer = NULL;
    }
    
    if(theHOHPDDetIds.size()>0 && theHOSiPMDetIds.size()>0){
      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 536 of file HcalDigitizer.cc.

References geometry, edm::EventSetup::get(), theGeometry, theRecNumber, and updateGeometry().

Referenced by beginRun().

                                                                  {
  // TODO find a way to avoid doing this every event
  edm::ESHandle<CaloGeometry> geometry;
  eventSetup.get<CaloGeometryRecord>().get(geometry);
  edm::ESHandle<HcalDDDRecConstants> pHRNDC;
  eventSetup.get<HcalRecNumberingRecord>().get(pHRNDC);

  // See if it's been updated
  if (&*geometry != theGeometry) {
    theGeometry = &*geometry;
    theRecNumber= &*pHRNDC;
    updateGeometry(eventSetup);
  }
}

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

private

Definition at line 770 of file HcalDigitizer.cc.

References HEDarkening::degradation(), deliveredLumi, HLT_FULL_cff::depth, relval_parameters_module::energy, HFRecalibration::getCorr(), HcalEndcap, HcalForward, cuy::ii, 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(HcalEndcap) && m_HEDarkening){
      //HE darkening
      dweight = m_HEDarkening->degradation(deliveredLumi,ieta,lay-2);//NB:diff. layer count
      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;
    }
    
    //create new hit with darkened energy
    //if(darkened) hcalHits[ii] = PCaloHit(hcalHits[ii].energyEM()*dweight,hcalHits[ii].energyHad()*dweight,hcalHits[ii].time(),hcalHits[ii].geantTrackId(),hcalHits[ii].id());
    
    //reset hit energy
    if(darkened) hcalHits[ii].setEnergy(hcalHits[ii].energy()*dweight); 
  }
  
}

void HcalDigitizer::endRun

(

)

Definition at line 531 of file HcalDigitizer.cc.

References HcalShapes::endRun(), and theShapes.

Referenced by HcalDigiProducer::endRun().

                           {
  theShapes->endRun();
}

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 *	engine
	)

Definition at line 435 of file HcalDigitizer.cc.

References gather_cfg::cout, debugCS_, CaloTDigitizer< Traits, runHelper >::getCaloSamples(), hbhegeo, hfgeo, hogeo, injectedHits_, injectTestHits_, isHCAL, isZDC, HcalDataFrameContainer< QIE10DataFrame >::MAXSAMPLES, HcalDataFrameContainer< QIE11DataFrame >::MAXSAMPLES, eostools::move(), edm::Event::put(), CaloSimParameters::readoutFrameSize(), CaloTDigitizer< Traits, runHelper >::run(), HcalSimParameterMap::simParameters(), theHBHEDigitizer, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, 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.size()>0 ? 
      theParameterMap->simParameters(theHFQIE10DetIds[0]).readoutFrameSize() : 
      QIE10DigiCollection::MAXSAMPLES
    )
  );
  std::unique_ptr<QIE11DigiCollection> hbheQIE11Result(
    new QIE11DigiCollection(
      theHBHEQIE11DetIds.size()>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 293 of file HcalDigitizer.cc.

References edm::EventSetup::get(), CaloTDigitizer< Traits, runHelper >::initializeHits(), edm::ESHandle< class >::product(), HcalCoderFactory::setDbService(), HcalAmplifier::setDbService(), HcalElectronicsSim::setDbService(), HcalSimParameterMap::setDbService(), theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHFAmplifier, theHFDigitizer, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHOAmplifier, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theZDCAmplifier, and theZDCDigitizer.

Referenced by HcalDigiProducer::initializeEvent().

                                                                                      {
  // get the appropriate gains, noises, & widths for this event
  edm::ESHandle<HcalDbService> conditions;
  eventSetup.get<HcalDbRecord>().get(conditions);
  
  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 250 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHBHENoiseSignalGenerator().

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

void HcalDigitizer::setHFNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 264 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theHFAmplifier, theHFDigitizer, theHFElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHFNoiseSignalGenerator().

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

void HcalDigitizer::setHONoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 278 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOSiPMDigitizer, and theParameterMap.

Referenced by HcalDigiProducer::setHONoiseSignalGenerator().

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

void HcalDigitizer::setQIE10NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 271 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE10NoiseSignalGenerator().

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

void HcalDigitizer::setQIE11NoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 257 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE11NoiseSignalGenerator().

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

void HcalDigitizer::setZDCNoiseSignalGenerator

(

HcalBaseSignalGenerator *

noiseGenerator

)

Definition at line 286 of file HcalDigitizer.cc.

References HcalBaseSignalGenerator::setElectronicsSim(), HcalAmplifier::setNoiseSignalGenerator(), CaloTDigitizer< Traits, runHelper >::setNoiseSignalGenerator(), HcalBaseSignalGenerator::setParameterMap(), theParameterMap, theZDCAmplifier, theZDCDigitizer, and theZDCElectronicsSim.

Referenced by HcalDigiProducer::setZDCNoiseSignalGenerator().

                                                                                       {
  noiseGenerator->setParameterMap(theParameterMap);
  noiseGenerator->setElectronicsSim(theZDCElectronicsSim);
  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_, CaloTDigitizer< Traits, runHelper >::setDetIds(), HcalHitRelabeller::setGeometry(), CaloHitResponse::setGeometry(), HcalZDCDetId::SubdetectorId, theGeometry, theHBHEQIE11DetIds, theHBHEResponse, theHBHESiPMResponse, theHFQIE10Response, theHFResponse, theHOResponse, theHOSiPMDigitizer, theHOSiPMResponse, theRecNumber, theRelabeller, theZDCDigitizer, theZDCResponse, tmp, and zdcgeo.

Referenced by checkGeometry().

                                                                    {
  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(theGeometry,theRecNumber);

  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)
    ((HcalSiPMHitResponse *)theHBHESiPMResponse)->setDetIds(theHBHEQIE11DetIds);
  
  if(theHOSiPMDigitizer) {
    buildHOSiPMCells(hoCells, eventSetup);
    if(theHOSiPMResponse)
      ((HcalSiPMHitResponse *)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_.size()==0 && injectedHitsCells_.size()>0 && injectedHitsEnergy_.size()>0){
    //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::debugCS_

private

Definition at line 150 of file HcalDigitizer.h.

Referenced by finalizeEvent(), and HcalDigitizer().

double HcalDigitizer::deliveredLumi

private

Definition at line 159 of file HcalDigitizer.h.

Referenced by darkening(), and HcalDigitizer().

bool HcalDigitizer::doHFWindow_

private

Definition at line 148 of file HcalDigitizer.h.

Referenced by accumulateCaloHits().

std::vector<DetId> HcalDigitizer::hbheCells

private

Definition at line 140 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::hbhegeo

private

Definition at line 146 of file HcalDigitizer.h.

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

bool HcalDigitizer::hfgeo

private

Definition at line 146 of file HcalDigitizer.h.

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

std::string HcalDigitizer::hitsProducer_

private

Definition at line 155 of file HcalDigitizer.h.

Referenced by accumulate(), and HcalDigitizer().

bool HcalDigitizer::hogeo

private

Definition at line 146 of file HcalDigitizer.h.

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

bool HcalDigitizer::ignoreTime_

private

Definition at line 151 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::vector<PCaloHit> HcalDigitizer::injectedHits_

private

Definition at line 166 of file HcalDigitizer.h.

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

std::vector<int> HcalDigitizer::injectedHitsCells_

private

Definition at line 165 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsEnergy_

private

Definition at line 163 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsTime_

private

Definition at line 164 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::injectTestHits_

private

Definition at line 152 of file HcalDigitizer.h.

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

bool HcalDigitizer::isHCAL

private

Definition at line 146 of file HcalDigitizer.h.

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

bool HcalDigitizer::isZDC

private

Definition at line 146 of file HcalDigitizer.h.

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

bool HcalDigitizer::killHE_

private

Definition at line 149 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and updateGeometry().

HEDarkening* HcalDigitizer::m_HEDarkening

private

Definition at line 160 of file HcalDigitizer.h.

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

HFRecalibration* HcalDigitizer::m_HFRecalibration

private

Definition at line 161 of file HcalDigitizer.h.

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

bool HcalDigitizer::neutralDensity_

private

Definition at line 153 of file HcalDigitizer.h.

bool HcalDigitizer::testNumbering_

private

Definition at line 147 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and HcalDigitizer().

HcalCoderFactory* HcalDigitizer::theCoderFactory

private

Definition at line 110 of file HcalDigitizer.h.

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

const CaloGeometry* HcalDigitizer::theGeometry

private

Definition at line 70 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

HcalAmplifier* HcalDigitizer::theHBHEAmplifier

private

Definition at line 102 of file HcalDigitizer.h.

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

HBHEDigitizer* HcalDigitizer::theHBHEDigitizer

private

Definition at line 129 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHBHEElectronicsSim

private

Definition at line 112 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), setHBHENoiseSignalGenerator(), and ~HcalDigitizer().

HBHEHitFilter HcalDigitizer::theHBHEHitFilter

private

Definition at line 119 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

HcalAmplifier* HcalDigitizer::theHBHEQIE11Amplifier

private

Definition at line 107 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHBHEQIE11DetIds

private

Definition at line 141 of file HcalDigitizer.h.

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

QIE11Digitizer* HcalDigitizer::theHBHEQIE11Digitizer

private

Definition at line 135 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHBHEQIE11ElectronicsSim

private

Definition at line 117 of file HcalDigitizer.h.

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

HBHEHitFilter HcalDigitizer::theHBHEQIE11HitFilter

private

Definition at line 120 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHBHEQIE8DetIds

private

Definition at line 141 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells().

CaloHitResponse* HcalDigitizer::theHBHEResponse

private

Definition at line 92 of file HcalDigitizer.h.

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

CaloHitResponse* HcalDigitizer::theHBHESiPMResponse

private

Definition at line 93 of file HcalDigitizer.h.

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

HcalAmplifier* HcalDigitizer::theHFAmplifier

private

Definition at line 103 of file HcalDigitizer.h.

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

HFDigitizer* HcalDigitizer::theHFDigitizer

private

Definition at line 132 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHFElectronicsSim

private

Definition at line 113 of file HcalDigitizer.h.

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

HFHitFilter HcalDigitizer::theHFHitFilter

private

Definition at line 121 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

HcalAmplifier* HcalDigitizer::theHFQIE10Amplifier

private

Definition at line 106 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHFQIE10DetIds

private

Definition at line 144 of file HcalDigitizer.h.

Referenced by buildHFQIECells(), and finalizeEvent().

QIE10Digitizer* HcalDigitizer::theHFQIE10Digitizer

private

Definition at line 134 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHFQIE10ElectronicsSim

private

Definition at line 116 of file HcalDigitizer.h.

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

HFHitFilter HcalDigitizer::theHFQIE10HitFilter

private

Definition at line 122 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

CaloHitResponse* HcalDigitizer::theHFQIE10Response

private

Definition at line 97 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHFQIE8DetIds

private

Definition at line 144 of file HcalDigitizer.h.

Referenced by buildHFQIECells().

CaloHitResponse* HcalDigitizer::theHFResponse

private

Definition at line 96 of file HcalDigitizer.h.

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

HcalAmplifier* HcalDigitizer::theHOAmplifier

private

Definition at line 104 of file HcalDigitizer.h.

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

HODigitizer* HcalDigitizer::theHODigitizer

private

Definition at line 130 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHOElectronicsSim

private

Definition at line 114 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), setHONoiseSignalGenerator(), and ~HcalDigitizer().

HOHitFilter HcalDigitizer::theHOHitFilter

private

Definition at line 123 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHOHPDDetIds

private

Definition at line 142 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

CaloHitResponse* HcalDigitizer::theHOResponse

private

Definition at line 94 of file HcalDigitizer.h.

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

int HcalDigitizer::theHOSiPMCode

private

Definition at line 157 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHOSiPMDetIds

private

Definition at line 143 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

HODigitizer* HcalDigitizer::theHOSiPMDigitizer

private

Definition at line 131 of file HcalDigitizer.h.

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

HOHitFilter HcalDigitizer::theHOSiPMHitFilter

private

Definition at line 124 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

CaloHitResponse* HcalDigitizer::theHOSiPMResponse

private

Definition at line 95 of file HcalDigitizer.h.

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

HPDIonFeedbackSim* HcalDigitizer::theIonFeedback

private

Definition at line 109 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

HcalSimParameterMap* HcalDigitizer::theParameterMap

private

Definition at line 89 of file HcalDigitizer.h.

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

const HcalDDDRecConstants* HcalDigitizer::theRecNumber

private

Definition at line 71 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

HcalHitRelabeller* HcalDigitizer::theRelabeller

private

Definition at line 136 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), HcalDigitizer(), updateGeometry(), and ~HcalDigitizer().

HcalShapes* HcalDigitizer::theShapes

private

Definition at line 90 of file HcalDigitizer.h.

Referenced by beginRun(), endRun(), and HcalDigitizer().

HcalTimeSlewSim* HcalDigitizer::theTimeSlewSim

private

Definition at line 127 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

HcalAmplifier* HcalDigitizer::theZDCAmplifier

private

Definition at line 105 of file HcalDigitizer.h.

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

ZDCDigitizer* HcalDigitizer::theZDCDigitizer

private

Definition at line 133 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theZDCElectronicsSim

private

Definition at line 115 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), setZDCNoiseSignalGenerator(), and ~HcalDigitizer().

ZDCHitFilter HcalDigitizer::theZDCHitFilter

private

Definition at line 125 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

CaloHitResponse* HcalDigitizer::theZDCResponse

private

Definition at line 98 of file HcalDigitizer.h.

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

bool HcalDigitizer::zdcgeo

private

Definition at line 146 of file HcalDigitizer.h.

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