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

Member Typedef Documentation

typedef CaloTDigitizer<HBHEDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HBHEDigitizer

private

Reconstruction algorithm

Definition at line 83 of file HcalDigitizer.h.

typedef CaloTDigitizer<HFDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer

private

Definition at line 85 of file HcalDigitizer.h.

typedef CaloTDigitizer<HODigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer

private

Definition at line 84 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE10DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer

private

Definition at line 87 of file HcalDigitizer.h.

typedef CaloTDigitizer<HcalQIE11DigitizerTraits,CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer

private

Definition at line 88 of file HcalDigitizer.h.

typedef CaloTDigitizer<ZDCDigitizerTraits,CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer

private

Definition at line 86 of file HcalDigitizer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 40 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, 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(nullptr),
  theRecNumber(nullptr),
  theParameterMap(new HcalSimParameterMap(ps)),
  theShapes(new HcalShapes()),
  theHBHEResponse(new CaloHitResponse(theParameterMap, theShapes)),
  theHBHESiPMResponse(new HcalSiPMHitResponse(theParameterMap, theShapes, ps.getParameter<bool>("HcalPreMixStage1"), true)),
  theHOResponse(new CaloHitResponse(theParameterMap, theShapes)),   
  theHOSiPMResponse(new HcalSiPMHitResponse(theParameterMap, theShapes, ps.getParameter<bool>("HcalPreMixStage1"), false)),
  theHFResponse(new CaloHitResponse(theParameterMap, theShapes)),
  theHFQIE10Response(new CaloHitResponse(theParameterMap, theShapes)),
  theZDCResponse(new 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 = 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->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
  hcalTimeSlew_delay_ = nullptr;
  theTimeSlewSim = nullptr;
  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.getParameter<bool>("doNeutralDensityFilter"));

  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(agingFlagHF) m_HFRecalibration.reset(new HFRecalibration(ps.getParameter<edm::ParameterSet>("HFRecalParameterBlock")));
}

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 220 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, theIonFeedback, theParameterMap, theRelabeller, theTimeSlewSim, 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;
  if(theTimeSlewSim) delete theTimeSlewSim;
  if(theIonFeedback) delete theIonFeedback;
}

Member Function Documentation

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

Definition at line 402 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 421 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 327 of file HcalDigitizer.cc.

References CaloTDigitizer< Traits, runHelper >::add(), 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(), 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_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::beginRun

(

const edm::EventSetup &

es

)

Definition at line 531 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::beginRun().

                                                     {
  checkGeometry(es);
  theShapes->beginRun(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::buildHBHEQIECells ( const std::vector< DetId > &  allCells, const edm::EventSetup &  eventSetup  )

private

Definition at line 692 of file HcalDigitizer.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::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.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 {
        delete theHBHEDigitizer;
        theHBHEDigitizer = nullptr;
    }
    
    if(!theHBHEQIE11DetIds.empty()) theHBHEQIE11Digitizer->setDetIds(theHBHEQIE11DetIds);
    else {
        delete theHBHEQIE11Digitizer;
        theHBHEQIE11Digitizer = nullptr;
    }
    
    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 653 of file HcalDigitizer.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::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.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 {
        delete theHFDigitizer;
        theHFDigitizer = nullptr;
    }
    
    if(!theHFQIE10DetIds.empty()) theHFQIE10Digitizer->setDetIds(theHFQIE10DetIds);
    else {
        delete theHFQIE10Digitizer;
        theHFQIE10Digitizer = nullptr;
    }
}

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

private

Definition at line 738 of file HcalDigitizer.cc.

References edm::EventSetup::get(), HcalShapes::HAMAMATSU, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< T >::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()==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 {
      delete theHODigitizer;
      theHODigitizer = nullptr;
    }
    
    if(!theHOSiPMDetIds.empty()) theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
    else {
      delete theHOSiPMDigitizer;
      theHOSiPMDigitizer = nullptr;
    }
    
    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 562 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 796 of file HcalDigitizer.cc.

References HBHEDarkening::degradation(), deliveredLumi, particleFlowClusterECALTimeSelected_cfi::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::endRun

(

)

Definition at line 557 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 *
	)

Definition at line 440 of file HcalDigitizer.cc.

References gather_cfg::cout, debugCS_, CaloTDigitizer< Traits, runHelper >::getCaloSamples(), hbhegeo, hfgeo, hogeo, injectedHits_, injectTestHits_, isHCAL, isZDC, HcalDataFrameContainer< QIE11DataFrame >::MAXSAMPLES, HcalDataFrameContainer< QIE10DataFrame >::MAXSAMPLES, eostools::move(), edm::Event::put(), CaloSimParameters::readoutFrameSize(), CaloTDigitizer< Traits, runHelper >::run(), 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() ? 
      ((HcalSiPMHitResponse *)theHBHESiPMResponse)->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 298 of file HcalDigitizer.cc.

References edm::EventSetup::get(), CaloTDigitizer< Traits, runHelper >::initializeHits(), edm::ESHandle< T >::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 255 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 269 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 283 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 276 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 262 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 291 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 578 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(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_.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 160 of file HcalDigitizer.h.

Referenced by beginRun().

bool HcalDigitizer::agingFlagHE

private

Definition at line 160 of file HcalDigitizer.h.

Referenced by beginRun().

bool HcalDigitizer::debugCS_

private

Definition at line 151 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 149 of file HcalDigitizer.h.

Referenced by accumulateCaloHits().

std::vector<DetId> HcalDigitizer::hbheCells

private

Definition at line 141 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::hbhegeo

private

Definition at line 147 of file HcalDigitizer.h.

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

const HcalTimeSlew* HcalDigitizer::hcalTimeSlew_delay_

private

Definition at line 165 of file HcalDigitizer.h.

Referenced by beginRun(), and HcalDigitizer().

bool HcalDigitizer::hfgeo

private

Definition at line 147 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 147 of file HcalDigitizer.h.

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

bool HcalDigitizer::ignoreTime_

private

Definition at line 152 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

std::vector<PCaloHit> HcalDigitizer::injectedHits_

private

Definition at line 170 of file HcalDigitizer.h.

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

std::vector<int> HcalDigitizer::injectedHitsCells_

private

Definition at line 169 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsEnergy_

private

Definition at line 167 of file HcalDigitizer.h.

Referenced by updateGeometry().

std::vector<double> HcalDigitizer::injectedHitsTime_

private

Definition at line 168 of file HcalDigitizer.h.

Referenced by updateGeometry().

bool HcalDigitizer::injectTestHits_

private

Definition at line 153 of file HcalDigitizer.h.

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

bool HcalDigitizer::isHCAL

private

Definition at line 147 of file HcalDigitizer.h.

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

bool HcalDigitizer::isZDC

private

Definition at line 147 of file HcalDigitizer.h.

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

bool HcalDigitizer::killHE_

private

Definition at line 150 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and updateGeometry().

const HBHEDarkening* HcalDigitizer::m_HBDarkening

private

Definition at line 161 of file HcalDigitizer.h.

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

const HBHEDarkening* HcalDigitizer::m_HEDarkening

private

Definition at line 162 of file HcalDigitizer.h.

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

std::unique_ptr<HFRecalibration> HcalDigitizer::m_HFRecalibration

private

Definition at line 163 of file HcalDigitizer.h.

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

bool HcalDigitizer::testNumbering_

private

Definition at line 148 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and HcalDigitizer().

HcalCoderFactory* HcalDigitizer::theCoderFactory

private

Definition at line 111 of file HcalDigitizer.h.

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

const CaloGeometry* HcalDigitizer::theGeometry

private

Definition at line 71 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

HcalAmplifier* HcalDigitizer::theHBHEAmplifier

private

Definition at line 103 of file HcalDigitizer.h.

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

HBHEDigitizer* HcalDigitizer::theHBHEDigitizer

private

Definition at line 130 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHBHEElectronicsSim

private

Definition at line 113 of file HcalDigitizer.h.

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

HBHEHitFilter HcalDigitizer::theHBHEHitFilter

private

Definition at line 120 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

HcalAmplifier* HcalDigitizer::theHBHEQIE11Amplifier

private

Definition at line 108 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHBHEQIE11DetIds

private

Definition at line 142 of file HcalDigitizer.h.

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

QIE11Digitizer* HcalDigitizer::theHBHEQIE11Digitizer

private

Definition at line 136 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHBHEQIE11ElectronicsSim

private

Definition at line 118 of file HcalDigitizer.h.

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

HBHEHitFilter HcalDigitizer::theHBHEQIE11HitFilter

private

Definition at line 121 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHBHEQIE8DetIds

private

Definition at line 142 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells().

CaloHitResponse* HcalDigitizer::theHBHEResponse

private

Definition at line 93 of file HcalDigitizer.h.

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

CaloHitResponse* HcalDigitizer::theHBHESiPMResponse

private

Definition at line 94 of file HcalDigitizer.h.

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

HcalAmplifier* HcalDigitizer::theHFAmplifier

private

Definition at line 104 of file HcalDigitizer.h.

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

HFDigitizer* HcalDigitizer::theHFDigitizer

private

Definition at line 133 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHFElectronicsSim

private

Definition at line 114 of file HcalDigitizer.h.

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

HFHitFilter HcalDigitizer::theHFHitFilter

private

Definition at line 122 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

HcalAmplifier* HcalDigitizer::theHFQIE10Amplifier

private

Definition at line 107 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHFQIE10DetIds

private

Definition at line 145 of file HcalDigitizer.h.

Referenced by buildHFQIECells(), and finalizeEvent().

QIE10Digitizer* HcalDigitizer::theHFQIE10Digitizer

private

Definition at line 135 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHFQIE10ElectronicsSim

private

Definition at line 117 of file HcalDigitizer.h.

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

HFHitFilter HcalDigitizer::theHFQIE10HitFilter

private

Definition at line 123 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

CaloHitResponse* HcalDigitizer::theHFQIE10Response

private

Definition at line 98 of file HcalDigitizer.h.

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

std::vector<DetId> HcalDigitizer::theHFQIE8DetIds

private

Definition at line 145 of file HcalDigitizer.h.

Referenced by buildHFQIECells().

CaloHitResponse* HcalDigitizer::theHFResponse

private

Definition at line 97 of file HcalDigitizer.h.

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

HcalAmplifier* HcalDigitizer::theHOAmplifier

private

Definition at line 105 of file HcalDigitizer.h.

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

HODigitizer* HcalDigitizer::theHODigitizer

private

Definition at line 131 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theHOElectronicsSim

private

Definition at line 115 of file HcalDigitizer.h.

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

HOHitFilter HcalDigitizer::theHOHitFilter

private

Definition at line 124 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

std::vector<DetId> HcalDigitizer::theHOHPDDetIds

private

Definition at line 143 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

CaloHitResponse* HcalDigitizer::theHOResponse

private

Definition at line 95 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 144 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

HODigitizer* HcalDigitizer::theHOSiPMDigitizer

private

Definition at line 132 of file HcalDigitizer.h.

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

HOHitFilter HcalDigitizer::theHOSiPMHitFilter

private

Definition at line 125 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

CaloHitResponse* HcalDigitizer::theHOSiPMResponse

private

Definition at line 96 of file HcalDigitizer.h.

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

HPDIonFeedbackSim* HcalDigitizer::theIonFeedback

private

Definition at line 110 of file HcalDigitizer.h.

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

HcalSimParameterMap* HcalDigitizer::theParameterMap

private

Definition at line 90 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 72 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

HcalHitRelabeller* HcalDigitizer::theRelabeller

private

Definition at line 137 of file HcalDigitizer.h.

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

HcalShapes* HcalDigitizer::theShapes

private

Definition at line 91 of file HcalDigitizer.h.

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

HcalTimeSlewSim* HcalDigitizer::theTimeSlewSim

private

Definition at line 128 of file HcalDigitizer.h.

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

HcalAmplifier* HcalDigitizer::theZDCAmplifier

private

Definition at line 106 of file HcalDigitizer.h.

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

ZDCDigitizer* HcalDigitizer::theZDCDigitizer

private

Definition at line 134 of file HcalDigitizer.h.

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

HcalElectronicsSim* HcalDigitizer::theZDCElectronicsSim

private

Definition at line 116 of file HcalDigitizer.h.

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

ZDCHitFilter HcalDigitizer::theZDCHitFilter

private

Definition at line 126 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

CaloHitResponse* HcalDigitizer::theZDCResponse

private

Definition at line 99 of file HcalDigitizer.h.

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

bool HcalDigitizer::zdcgeo

private

Definition at line 147 of file HcalDigitizer.h.

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