#include <HcalDigitizer.h>

Public Member Functions
void	beginRun (const edm::EventSetup &es)

void	endRun ()

	HcalDigitizer (const edm::ParameterSet &ps)

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

void	setHBHENoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setHFNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setHONoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

void	setZDCNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)

virtual	~HcalDigitizer ()

Private Types
typedef CaloTDigitizer < HBHEDigitizerTraits >	HBHEDigitizer

typedef CaloTDigitizer < HFDigitizerTraits >	HFDigitizer

typedef CaloTDigitizer < HODigitizerTraits >	HODigitizer

typedef CaloTDigitizer < ZDCDigitizerTraits >	ZDCDigitizer

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

void	checkGeometry (const edm::EventSetup &eventSetup)

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

void	updateGeometry (const edm::EventSetup &eventSetup)

Private Attributes
bool	hbhegeo

bool	hfgeo

std::string	hitsProducer_

bool	hogeo

bool	isHCAL

bool	isZDC

HcalCoderFactory *	theCoderFactory

const CaloGeometry *	theGeometry

HcalAmplifier *	theHBHEAmplifier

std::vector< DetId >	theHBHEDetIds

HBHEDigitizer *	theHBHEDigitizer

HcalElectronicsSim *	theHBHEElectronicsSim

HBHEHitFilter	theHBHEHitFilter

CaloHitResponse *	theHBHEResponse

HBHEDigitizer *	theHBHESiPMDigitizer

CaloHitResponse *	theHBHESiPMResponse

HcalAmplifier *	theHFAmplifier

HFDigitizer *	theHFDigitizer

HcalElectronicsSim *	theHFElectronicsSim

HFHitFilter	theHFHitFilter

CaloHitResponse *	theHFResponse

HcalHitCorrection *	theHitCorrection

HcalAmplifier *	theHOAmplifier

HODigitizer *	theHODigitizer

HcalElectronicsSim *	theHOElectronicsSim

HOHitFilter	theHOHitFilter

std::vector< DetId >	theHOHPDDetIds

CaloHitResponse *	theHOResponse

int	theHOSiPMCode

std::vector< DetId >	theHOSiPMDetIds

HODigitizer *	theHOSiPMDigitizer

HcalHitFilter	theHOSiPMHitFilter

CaloHitResponse *	theHOSiPMResponse

HPDIonFeedbackSim *	theIonFeedback

CaloVNoiseSignalGenerator *	theNoiseGenerator

CaloVNoiseHitGenerator *	theNoiseHitGenerator

HcalSimParameterMap *	theParameterMap

HcalShapes *	theShapes

HcalTimeSlewSim *	theTimeSlewSim

HcalAmplifier *	theZDCAmplifier

ZDCDigitizer *	theZDCDigitizer

HcalElectronicsSim *	theZDCElectronicsSim

ZDCHitFilter	theZDCHitFilter

CaloHitResponse *	theZDCResponse

bool	zdcgeo

Detailed Description

Definition at line 26 of file HcalDigitizer.h.

Member Typedef Documentation

typedef CaloTDigitizer<HBHEDigitizerTraits> HcalDigitizer::HBHEDigitizer

private

Reconstruction algorithm

Definition at line 55 of file HcalDigitizer.h.

typedef CaloTDigitizer<HFDigitizerTraits> HcalDigitizer::HFDigitizer

private

Definition at line 57 of file HcalDigitizer.h.

typedef CaloTDigitizer<HODigitizerTraits> HcalDigitizer::HODigitizer

private

Definition at line 56 of file HcalDigitizer.h.

typedef CaloTDigitizer<ZDCDigitizerTraits> HcalDigitizer::ZDCDigitizer

private

Definition at line 58 of file HcalDigitizer.h.

Constructor & Destructor Documentation

HcalDigitizer::HcalDigitizer ( const edm::ParameterSet & ps )

explicit

Definition at line 81 of file HcalDigitizer.cc.

References HcalCoderFactory::DB, edm::hlt::Exception, HcalDigitizerImpl::fillSiPMCells(), edm::RandomNumberGenerator::getEngine(), edm::ParameterSet::getParameter(), hitsProducer_, edm::Service< T >::isAvailable(), HcalAmplifier::setHFtuningParameter(), CaloHitResponse::setHitFilter(), HcalAmplifier::setHOtuningParameter(), CaloTDigitizer< Traits >::setNoiseHitGenerator(), CaloTDigitizer< Traits >::setNoiseSignalGenerator(), CaloHitResponse::setPECorrection(), HcalTimeSlewSim::setRandomEngine(), HPDIonFeedbackSim::setRandomEngine(), HcalHitCorrection::setRandomEngine(), CaloTDigitizer< Traits >::setRandomEngine(), HcalAmplifier::setTimeSlewSim(), HcalAmplifier::setUseOldHF(), HcalAmplifier::setUseOldHO(), theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEHitFilter, theHBHEResponse, theHBHESiPMDigitizer, theHBHESiPMResponse, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFHitFilter, theHFResponse, theHitCorrection, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOHitFilter, theHOResponse, theHOSiPMCode, theHOSiPMDigitizer, theHOSiPMHitFilter, theHOSiPMResponse, theIonFeedback, theNoiseGenerator, theNoiseHitGenerator, theParameterMap, theShapes, theTimeSlewSim, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, theZDCHitFilter, and theZDCResponse.

 : theGeometry(0),
   theParameterMap(new HcalSimParameterMap(ps)),
   theShapes(new HcalShapes()),
   theHBHEResponse(0),
   theHBHESiPMResponse(0),
   theHOResponse(0),   
   theHOSiPMResponse(0),
   theHFResponse(new CaloHitResponse(theParameterMap, theShapes)),
   theZDCResponse(new CaloHitResponse(theParameterMap, theShapes)),
   theHBHEAmplifier(0),
   theHFAmplifier(0),
   theHOAmplifier(0),
   theZDCAmplifier(0),
   theIonFeedback(0),
   theCoderFactory(0),
   theHBHEElectronicsSim(0),
   theHFElectronicsSim(0),
   theHOElectronicsSim(0),
   theZDCElectronicsSim(0),
   theHBHEHitFilter(),
   theHFHitFilter(ps.getParameter<bool>("doHFWindow")),
   theHOHitFilter(),
   theHOSiPMHitFilter(HcalOuter),
   theZDCHitFilter(),
   theHitCorrection(0),
   theNoiseGenerator(0),
   theNoiseHitGenerator(0),
   theHBHEDigitizer(0),
   theHBHESiPMDigitizer(0),
   theHODigitizer(0),
   theHOSiPMDigitizer(0),
   theHFDigitizer(0),
   theZDCDigitizer(0),
   theHBHEDetIds(),
   theHOHPDDetIds(),
   theHOSiPMDetIds(),
   isZDC(true),
   isHCAL(true),
   zdcgeo(true),
   hbhegeo(true),
   hogeo(true),
   hfgeo(true),
   theHOSiPMCode(ps.getParameter<edm::ParameterSet>("ho").getParameter<int>("siPMCode"))
 {
   bool doNoise = ps.getParameter<bool>("doNoise");
   bool useOldNoiseHB = ps.getParameter<bool>("useOldHB");
   bool useOldNoiseHE = ps.getParameter<bool>("useOldHE");
   bool useOldNoiseHF = ps.getParameter<bool>("useOldHF");
   bool useOldNoiseHO = ps.getParameter<bool>("useOldHO");
   bool doEmpty = ps.getParameter<bool>("doEmpty");
   double HBtp = ps.getParameter<double>("HBTuningParameter");
   double HEtp = ps.getParameter<double>("HETuningParameter");
   double HFtp = ps.getParameter<double>("HFTuningParameter");
   double HOtp = ps.getParameter<double>("HOTuningParameter");
 
   // need to make copies, because they might get different noise generators
   theHBHEAmplifier = new HcalAmplifier(theParameterMap, doNoise);
   theHFAmplifier = new HcalAmplifier(theParameterMap, doNoise);
   theHOAmplifier = new HcalAmplifier(theParameterMap, doNoise);
   theZDCAmplifier = new HcalAmplifier(theParameterMap, doNoise);
   theHBHEAmplifier->setHBtuningParameter(HBtp);
   theHBHEAmplifier->setHEtuningParameter(HEtp);
   theHFAmplifier->setHFtuningParameter(HFtp);
   theHOAmplifier->setHOtuningParameter(HOtp);
   theHBHEAmplifier->setUseOldHB(useOldNoiseHB);
   theHBHEAmplifier->setUseOldHE(useOldNoiseHE);
   theHFAmplifier->setUseOldHF(useOldNoiseHF);
   theHOAmplifier->setUseOldHO(useOldNoiseHO);
 
   theCoderFactory = new HcalCoderFactory(HcalCoderFactory::DB);
   theHBHEElectronicsSim = new HcalElectronicsSim(theHBHEAmplifier, theCoderFactory);
   theHFElectronicsSim = new HcalElectronicsSim(theHFAmplifier, theCoderFactory);
   theHOElectronicsSim = new HcalElectronicsSim(theHOAmplifier, theCoderFactory);
   theZDCElectronicsSim = new HcalElectronicsSim(theZDCAmplifier, theCoderFactory);
 
   // a code of 1 means make all cells SiPM
   std::vector<int> hbSiPMCells(ps.getParameter<edm::ParameterSet>("hb").getParameter<std::vector<int> >("siPMCells"));
   //std::vector<int> hoSiPMCells(ps.getParameter<edm::ParameterSet>("ho").getParameter<std::vector<int> >("siPMCells"));
   // 0 means none, 1 means all, and 2 means use hardcoded
 
   bool doHBHEHPD = hbSiPMCells.empty() || (hbSiPMCells[0] != 1);
   bool doHOHPD = (theHOSiPMCode != 1);
   bool doHBHESiPM = !hbSiPMCells.empty();
   bool doHOSiPM = (theHOSiPMCode != 0);
   if(doHBHEHPD)
   {
     theHBHEResponse = new CaloHitResponse(theParameterMap, theShapes);
     theHBHEResponse->setHitFilter(&theHBHEHitFilter);
     theHBHEDigitizer = new HBHEDigitizer(theHBHEResponse, theHBHEElectronicsSim, doEmpty);
   }
   if(doHOHPD) 
   {
     theHOResponse = new CaloHitResponse(theParameterMap, theShapes);
     theHOResponse->setHitFilter(&theHOHitFilter);
     theHODigitizer = new HODigitizer(theHOResponse, theHOElectronicsSim, doEmpty);
   }
 
   if(doHBHESiPM)
   {
     theHBHESiPMResponse = new HcalSiPMHitResponse(theParameterMap, theShapes);
     theHBHESiPMResponse->setHitFilter(&theHBHEHitFilter);
     theHBHESiPMDigitizer = new HBHEDigitizer(theHBHESiPMResponse, theHBHEElectronicsSim, doEmpty);
   }
   if(doHOSiPM)
   {
     theHOSiPMResponse = new HcalSiPMHitResponse(theParameterMap, theShapes);
     theHOSiPMResponse->setHitFilter(&theHOSiPMHitFilter);
     theHOSiPMDigitizer = new HODigitizer(theHOSiPMResponse, theHOElectronicsSim, doEmpty);
   }
 
   // if both are present, fill the SiPM cells now
   if(doHBHEHPD && doHBHESiPM)
   {
     HcalDigitizerImpl::fillSiPMCells(hbSiPMCells, theHBHESiPMDigitizer);
   }
 
   theHFResponse->setHitFilter(&theHFHitFilter);
   theZDCResponse->setHitFilter(&theZDCHitFilter);
 
   bool doTimeSlew = ps.getParameter<bool>("doTimeSlew");
   if(doTimeSlew) {
     // no time slewing for HF
     /*  
     theHitCorrection = new HcalHitCorrection(theParameterMap);
     if(theHBHEResponse) theHBHEResponse->setHitCorrection(theHitCorrection);
     if(theHBHESiPMResponse) theHBHESiPMResponse->setHitCorrection(theHitCorrection);
     if(theHOResponse) theHOResponse->setHitCorrection(theHitCorrection);
     if(theHOSiPMResponse) theHOSiPMResponse->setHitCorrection(theHitCorrection);
     theZDCResponse->setHitCorrection(theHitCorrection);
     */ 
     theTimeSlewSim = new HcalTimeSlewSim(theParameterMap);
     theHBHEAmplifier->setTimeSlewSim(theTimeSlewSim);
     theHOAmplifier->setTimeSlewSim(theTimeSlewSim);
     theZDCAmplifier->setTimeSlewSim(theTimeSlewSim);
   }
 
   theHFDigitizer = new HFDigitizer(theHFResponse, theHFElectronicsSim, doEmpty);
   theZDCDigitizer = new ZDCDigitizer(theZDCResponse, theZDCElectronicsSim, doEmpty);
 
   bool doHPDNoise = ps.getParameter<bool>("doHPDNoise");
   if(doHPDNoise) {
     //edm::ParameterSet hpdNoisePset = ps.getParameter<edm::ParameterSet>("HPDNoiseLibrary");
     theNoiseGenerator = new HPDNoiseGenerator(ps); 
     if(theHBHEDigitizer) theHBHEDigitizer->setNoiseSignalGenerator(theNoiseGenerator);
     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setNoiseSignalGenerator(theNoiseGenerator);
   }
 
   if(ps.getParameter<bool>("doIonFeedback") && theHBHEResponse)
   {
     theIonFeedback = new HPDIonFeedbackSim(ps, theShapes);
     theHBHEResponse->setPECorrection(theIonFeedback);
     if(ps.getParameter<bool>("doThermalNoise"))
     {
       theHBHEAmplifier->setIonFeedbackSim(theIonFeedback);
     }
   }
 
   if(ps.getParameter<bool>("injectTestHits") ){
     theNoiseHitGenerator = new HcalTestHitGenerator(ps);
     if(theHBHEDigitizer) theHBHEDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
     if(theHODigitizer) theHODigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
     if(theHOSiPMDigitizer) theHOSiPMDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
     theHFDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
     theZDCDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
   }
 
   edm::Service<edm::RandomNumberGenerator> rng;
   if ( ! rng.isAvailable()) {
     throw cms::Exception("Configuration")
       << "HcalDigitizer requires the RandomNumberGeneratorService\n"
          "which is not present in the configuration file.  You must add the service\n"
          "in the configuration file or remove the modules that require it.";
   }
 
   CLHEP::HepRandomEngine& engine = rng->getEngine();
   if(theHBHEDigitizer) theHBHEDigitizer->setRandomEngine(engine);
   if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setRandomEngine(engine);
   if(theHODigitizer) theHODigitizer->setRandomEngine(engine);
   if(theHOSiPMDigitizer) theHOSiPMDigitizer->setRandomEngine(engine);
   if(theIonFeedback) theIonFeedback->setRandomEngine(engine);
   if(theTimeSlewSim) theTimeSlewSim->setRandomEngine(engine);
   theHFDigitizer->setRandomEngine(engine);
   theZDCDigitizer->setRandomEngine(engine);
 
   if (theHitCorrection!=0) theHitCorrection->setRandomEngine(engine);
 
   hitsProducer_ = ps.getParameter<std::string>("hitsProducer");
 }

HcalDigitizer::~HcalDigitizer ( )

virtual

Definition at line 273 of file HcalDigitizer.cc.

References theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEResponse, theHBHESiPMDigitizer, theHBHESiPMResponse, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFResponse, theHitCorrection, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOResponse, theHOSiPMDigitizer, theHOSiPMResponse, theNoiseGenerator, theParameterMap, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, and theZDCResponse.

                               {
   delete theHBHEDigitizer;
   delete theHBHESiPMDigitizer;
   delete theHODigitizer;
   delete theHOSiPMDigitizer;
   delete theHFDigitizer;
   delete theZDCDigitizer;
   delete theParameterMap;
   delete theHBHEResponse;
   delete theHBHESiPMResponse;
   delete theHOResponse;
   delete theHOSiPMResponse;
   delete theHFResponse;
   delete theZDCResponse;
   delete theHBHEElectronicsSim;
   delete theHFElectronicsSim;
   delete theHOElectronicsSim;
   delete theZDCElectronicsSim;
   delete theHBHEAmplifier;
   delete theHFAmplifier;
   delete theHOAmplifier;
   delete theZDCAmplifier;
   delete theCoderFactory;
   delete theHitCorrection;
   delete theNoiseGenerator;
 }

Member Function Documentation

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

Definition at line 432 of file HcalDigitizer.cc.

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

Referenced by HcalDigiProducer::beginRun().

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

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

private

Definition at line 493 of file HcalDigitizer.cc.

References edm::EventSetup::get(), HcalShapes::HAMAMATSU, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< class >::product(), HcalHitFilter::setDetIds(), CaloTDigitizer< Traits >::setDetIds(), HcalSimParameterMap::setHOHamamatsuDetIds(), HcalSimParameterMap::setHOZecotekDetIds(), theHODigitizer, 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);
     HcalMCParams mcParams(*p.product());
     for(std::vector<DetId>::const_iterator detItr = allCells.begin();
         detItr != allCells.end(); ++detItr)
     {
       HcalDetId hcalId(*detItr);
       int shapeType = mcParams.getValues(*detItr)->signalShape();
       if(shapeType == HcalShapes::ZECOTEK) {
         zecotekDetIds.push_back(hcalId);
         theHOSiPMDetIds.push_back(*detItr);
       }
       else if(shapeType == HcalShapes::HAMAMATSU) {
         hamamatsuDetIds.push_back(hcalId);
         theHOSiPMDetIds.push_back(*detItr);
       }
       else {
         theHOHPDDetIds.push_back(*detItr);
       }
     }
 
     assert(theHODigitizer);
     assert(theHOSiPMDigitizer);
     theHODigitizer->setDetIds(theHOHPDDetIds);
     theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
     theHOSiPMHitFilter.setDetIds(theHOSiPMDetIds);
     // FIXME not applying a HitFilter to the HPDs, for now
     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 445 of file HcalDigitizer.cc.

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

Referenced by beginRun().

                                                                   {
   // TODO find a way to avoid doing this every event
   edm::ESHandle<CaloGeometry> geometry;
   eventSetup.get<CaloGeometryRecord>().get(geometry);
   // See if it's been updated
   if(&*geometry != theGeometry)
   {
     theGeometry = &*geometry;
     updateGeometry(eventSetup);
   }
 }

void HcalDigitizer::endRun ( void )

Definition at line 439 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::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

Produces the EDM products,

Definition at line 334 of file HcalDigitizer.cc.

References HcalHitCorrection::clear(), HcalHitCorrection::fillChargeSums(), edm::EventSetup::get(), edm::Event::getByLabel(), hbhegeo, hfgeo, hitsProducer_, hogeo, isHCAL, edm::HandleBase::isValid(), isZDC, edm::Handle< T >::product(), edm::ESHandle< class >::product(), edm::Event::put(), CaloTDigitizer< Traits >::run(), HcalAmplifier::setADCPeds(), HcalAmplifier::setCholesky(), HcalCoderFactory::setDbService(), HcalAmplifier::setDbService(), HcalSimParameterMap::setDbService(), theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHESiPMDigitizer, theHFAmplifier, theHFDigitizer, theHitCorrection, theHOAmplifier, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theZDCAmplifier, theZDCDigitizer, and zdcgeo.

Referenced by HcalDigiProducer::produce(), and edm::DataMixingHcalDigiWorkerProd::putHcal().

                                                                         {
   // 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());
 
   theCoderFactory->setDbService(conditions.product());
   theParameterMap->setDbService(conditions.product());
 
    edm::ESHandle<HcalCholeskyMatrices> refCholesky;
    eventSetup.get<HcalCholeskyMatricesRcd>().get(refCholesky);
    const HcalCholeskyMatrices * myCholesky = refCholesky.product();
   
    edm::ESHandle<HcalPedestals> pedshandle;
    eventSetup.get<HcalPedestalsRcd>().get(pedshandle);
    const HcalPedestals *  myADCPedestals = pedshandle.product();
 
   theHBHEAmplifier->setCholesky(myCholesky);
   theHFAmplifier->setCholesky(myCholesky);
   theHOAmplifier->setCholesky(myCholesky);
   
   theHBHEAmplifier->setADCPeds(myADCPedestals);
   theHFAmplifier->setADCPeds(myADCPedestals);
   theHOAmplifier->setADCPeds(myADCPedestals);
 
 
   // Step A: Get Inputs
   edm::Handle<CrossingFrame<PCaloHit> > cf, zdccf;
 
   // test access to SimHits for HcalHits and ZDC hits
   const std::string zdcHitsName(hitsProducer_+"ZDCHITS");
   e.getByLabel("mix", zdcHitsName , zdccf);
   MixCollection<PCaloHit> * colzdc = 0 ;
   if(zdccf.isValid()){
     colzdc = new MixCollection<PCaloHit>(zdccf.product());
   }else{
     edm::LogInfo("HcalDigitizer") << "We don't have ZDC hit collection available ";
     isZDC = false;
   }
 
   const std::string hcalHitsName(hitsProducer_+"HcalHits");
   e.getByLabel("mix", hcalHitsName ,cf);
   MixCollection<PCaloHit> * col = 0 ;
   if(cf.isValid()){
     col = new MixCollection<PCaloHit>(cf.product());
   }else{
     edm::LogInfo("HcalDigitizer") << "We don't have HCAL hit collection available ";
     isHCAL = false;
   }
 
   if(theHitCorrection != 0)
   {
     theHitCorrection->clear();
     if(isHCAL)
       theHitCorrection->fillChargeSums(*col);
   }
 
   // Step B: Create empty output
   std::auto_ptr<HBHEDigiCollection> hbheResult(new HBHEDigiCollection());
   std::auto_ptr<HODigiCollection> hoResult(new HODigiCollection());
   std::auto_ptr<HFDigiCollection> hfResult(new HFDigiCollection());
   std::auto_ptr<ZDCDigiCollection> zdcResult(new ZDCDigiCollection());
 
   // Step C: Invoke the algorithm, passing in inputs and getting back outputs.
   if(isHCAL&&hbhegeo)
   {
     if(theHBHEDigitizer) theHBHEDigitizer->run(*col, *hbheResult);
     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->run(*col, *hbheResult);
   }
   if(isHCAL&&hogeo)
   {
     if(theHODigitizer) theHODigitizer->run(*col, *hoResult);
     if(theHOSiPMDigitizer) theHOSiPMDigitizer->run(*col, *hoResult);
   }
   if(isHCAL&&hfgeo)
     theHFDigitizer->run(*col, *hfResult);  
   if(isZDC&&zdcgeo) 
     theZDCDigitizer->run(*colzdc, *zdcResult);
   
   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();
   // Step D: Put outputs into event
   e.put(hbheResult);
   e.put(hoResult);
   e.put(hfResult);
   e.put(zdcResult);
 
   if(theHitCorrection) {
     theHitCorrection->clear();
   }
 }

void HcalDigitizer::setHBHENoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 301 of file HcalDigitizer.cc.

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

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

void HcalDigitizer::setHFNoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 309 of file HcalDigitizer.cc.

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

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

void HcalDigitizer::setHONoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 317 of file HcalDigitizer.cc.

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

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

void HcalDigitizer::setZDCNoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 325 of file HcalDigitizer.cc.

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

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

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

private

Definition at line 458 of file HcalDigitizer.cc.

References buildHOSiPMCells(), DetId::Calo, HcalDigitizerImpl::fillCells(), CaloGeometry::getValidDetIds(), hbhegeo, DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, hfgeo, hogeo, CaloTDigitizer< Traits >::setDetIds(), CaloHitResponse::setGeometry(), HcalZDCDetId::SubdetectorId, theGeometry, theHBHEDetIds, theHBHEDigitizer, theHBHEResponse, theHBHESiPMDigitizer, theHBHESiPMResponse, theHFDigitizer, theHFResponse, theHOResponse, theHOSiPMResponse, theZDCDigitizer, theZDCResponse, 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);
   theZDCResponse->setGeometry(theGeometry);
 
   const vector<DetId>& hbCells = theGeometry->getValidDetIds(DetId::Hcal, HcalBarrel);
   const vector<DetId>& heCells = theGeometry->getValidDetIds(DetId::Hcal, HcalEndcap);
   const vector<DetId>& hoCells = theGeometry->getValidDetIds(DetId::Hcal, HcalOuter);
   const vector<DetId>& hfCells = theGeometry->getValidDetIds(DetId::Hcal, HcalForward);
   const vector<DetId>& zdcCells = theGeometry->getValidDetIds(DetId::Calo, HcalZDCDetId::SubdetectorId);
   //const vector<DetId>& hcalTrigCells = geometry->getValidDetIds(DetId::Hcal, HcalTriggerTower);
   //const 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
 
 
   theHBHEDetIds = hbCells;
   theHBHEDetIds.insert(theHBHEDetIds.end(), heCells.begin(), heCells.end());
 
   HcalDigitizerImpl::fillCells(theHBHEDetIds, theHBHEDigitizer, theHBHESiPMDigitizer);
   //HcalDigitizerImpl::fillCells(hoCells, theHODigitizer, theHOSiPMDigitizer);
   buildHOSiPMCells(hoCells, eventSetup);
   theHFDigitizer->setDetIds(hfCells);
   theZDCDigitizer->setDetIds(zdcCells); 
 }