Reference Manual

Go to the documentation of this file.
00001 #include "SimCalorimetry/HcalSimProducers/interface/HcalDigitizer.h"
00002 #include "SimCalorimetry/HcalSimProducers/src/HcalTestHitGenerator.h"
00003 #include "SimDataFormats/CaloHit/interface/PCaloHitContainer.h"
00004 #include "SimCalorimetry/HcalSimAlgos/interface/HcalSimParameterMap.h"
00005 #include "SimCalorimetry/HcalSimAlgos/interface/HcalShape.h"
00006 #include "SimCalorimetry/HcalSimAlgos/interface/HFShape.h"
00007 #include "SimCalorimetry/HcalSimAlgos/interface/ZDCShape.h"
00008 #include "SimCalorimetry/HcalSimAlgos/interface/HcalElectronicsSim.h"
00009 #include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h"
00010 #include "SimCalorimetry/HcalSimAlgos/interface/HcalAmplifier.h"
00011 #include "SimCalorimetry/HcalSimAlgos/interface/HcalCoderFactory.h"
00012 #include "SimCalorimetry/HcalSimAlgos/interface/HcalHitCorrection.h"
00013 #include "SimCalorimetry/HcalSimAlgos/interface/HcalSimParameterMap.h"
00014 #include "SimCalorimetry/HcalSimAlgos/interface/HcalSiPMShape.h"
00015 #include "SimCalorimetry/HcalSimAlgos/interface/HcalSiPMHitResponse.h"
00016 #include "SimCalorimetry/HcalSimAlgos/interface/HPDIonFeedbackSim.h"
00017 #include "DataFormats/Common/interface/Handle.h"
00018 #include "FWCore/Framework/interface/ESHandle.h"
00019 #include "FWCore/Framework/interface/Event.h"
00020 #include "FWCore/Framework/interface/EventSetup.h"
00021 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00022 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00023 #include "SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h"
00024 #include "SimCalorimetry/CaloSimAlgos/interface/CaloShapeIntegrator.h"
00025 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
00026 #include "Geometry/Records/interface/CaloGeometryRecord.h"
00027 #include "CalibFormats/HcalObjects/interface/HcalDbService.h"
00028 #include "CalibFormats/HcalObjects/interface/HcalDbRecord.h"
00029 #include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h"
00030 #include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
00031 #include "FWCore/Utilities/interface/RandomNumberGenerator.h"
00032 #include "FWCore/ServiceRegistry/interface/Service.h"
00033 #include "DataFormats/HcalDetId/interface/HcalZDCDetId.h"
00034 #include "SimCalorimetry/HcalSimAlgos/interface/HPDNoiseGenerator.h"
00035 #include <boost/foreach.hpp>
00036 using namespace std;
00037 
00038 namespace HcalDigitizerImpl {
00039 
00040   template<typename SIPMDIGITIZER>
00041   void fillSiPMCells(const vector<int> & siPMCells, SIPMDIGITIZER * siPMDigitizer)
00042   {
00043     std::vector<DetId> siPMDetIds;
00044     siPMDetIds.reserve(siPMCells.size());
00045     for(std::vector<int>::const_iterator idItr = siPMCells.begin();
00046         idItr != siPMCells.end(); ++idItr)
00047     {
00048       siPMDetIds.push_back(DetId(*idItr));
00049     }
00050     siPMDigitizer->setDetIds(siPMDetIds);
00051   }
00052 
00053   // if both exist, assume the SiPM one has cells filled, and
00054   // assign the rest to the HPD
00055   template<typename HPDDIGITIZER, typename SIPMDIGITIZER>
00056   void fillCells(const vector<DetId>& allCells,
00057                  HPDDIGITIZER * hpdDigitizer,
00058                  SIPMDIGITIZER * siPMDigitizer)
00059   {
00060     // if both digitizers exist, split up the cells
00061     if(siPMDigitizer && hpdDigitizer)
00062     {
00063       std::vector<DetId> siPMDetIds = siPMDigitizer->detIds();
00064       std::sort(siPMDetIds.begin(), siPMDetIds.end());
00065       std::vector<DetId> sortedCells = allCells;
00066       std::sort(sortedCells.begin(), sortedCells.end());
00067       std::vector<DetId> hpdCells;
00068       std::set_difference(sortedCells.begin(), sortedCells.end(),
00069                           siPMDetIds.begin(), siPMDetIds.end(),
00070                           std::back_inserter(hpdCells) );
00071       hpdDigitizer->setDetIds(hpdCells);
00072     }
00073     else
00074     {
00075       if(siPMDigitizer) siPMDigitizer->setDetIds(allCells);
00076       if(hpdDigitizer) hpdDigitizer->setDetIds(allCells);
00077     }
00078   }
00079 } // namespace HcaiDigitizerImpl
00080 
00081 
00082 HcalDigitizer::HcalDigitizer(const edm::ParameterSet& ps) 
00083 : theGeometry(0),
00084   theParameterMap(new HcalSimParameterMap(ps)),
00085   theHcalShape(0),
00086   theSiPMShape(0),
00087   theHFShape(new HFShape()),
00088   theZDCShape(new ZDCShape()),
00089   theHcalIntegratedShape(0),
00090   theSiPMIntegratedShape(0),
00091   theHFIntegratedShape(new CaloShapeIntegrator(theHFShape)),
00092   theZDCIntegratedShape(new CaloShapeIntegrator(theZDCShape)),
00093   theHBHEResponse(0),
00094   theHBHESiPMResponse(0),
00095   theHOResponse(0),   
00096   theHOSiPMResponse(0),
00097   theHFResponse(new CaloHitResponse(theParameterMap, theHFIntegratedShape)),
00098   theZDCResponse(new CaloHitResponse(theParameterMap, theZDCIntegratedShape)),
00099   theHBHEAmplifier(0),
00100   theHFAmplifier(0),
00101   theHOAmplifier(0),
00102   theZDCAmplifier(0),
00103   theIonFeedback(0),
00104   theCoderFactory(0),
00105   theHBHEElectronicsSim(0),
00106   theHFElectronicsSim(0),
00107   theHOElectronicsSim(0),
00108   theZDCElectronicsSim(0),
00109   theHBHEHitFilter(),
00110   theHFHitFilter(ps.getParameter<bool>("doHFWindow")),
00111   theHOHitFilter(),
00112   theHOSiPMHitFilter(HcalOuter),
00113   theZDCHitFilter(),
00114   theHitCorrection(0),
00115   theNoiseGenerator(0),
00116   theNoiseHitGenerator(0),
00117   theHBHEDigitizer(0),
00118   theHBHESiPMDigitizer(0),
00119   theHODigitizer(0),
00120   theHOSiPMDigitizer(0),
00121   theHFDigitizer(0),
00122   theZDCDigitizer(0),
00123   theHBHEDetIds(),
00124   theHOHPDDetIds(),
00125   theHOSiPMDetIds(),
00126   isZDC(true),
00127   isHCAL(true),
00128   zdcgeo(true),
00129   hbhegeo(true),
00130   hogeo(true),
00131   hfgeo(true),
00132   theHOSiPMCode(ps.getParameter<edm::ParameterSet>("ho").getParameter<int>("siPMCode"))
00133 {
00134   bool doNoise = ps.getParameter<bool>("doNoise");
00135   bool useOldNoiseHB = ps.getParameter<bool>("useOldHB");
00136   bool useOldNoiseHE = ps.getParameter<bool>("useOldHE");
00137   bool useOldNoiseHF = ps.getParameter<bool>("useOldHF");
00138   bool useOldNoiseHO = ps.getParameter<bool>("useOldHO");
00139   bool doEmpty = ps.getParameter<bool>("doEmpty");
00140   double HBtp = ps.getParameter<double>("HBTuningParameter");
00141   double HEtp = ps.getParameter<double>("HETuningParameter");
00142   double HFtp = ps.getParameter<double>("HFTuningParameter");
00143   double HOtp = ps.getParameter<double>("HOTuningParameter");
00144 
00145   // need to make copies, because they might get different noise generators
00146   theHBHEAmplifier = new HcalAmplifier(theParameterMap, doNoise);
00147   theHFAmplifier = new HcalAmplifier(theParameterMap, doNoise);
00148   theHOAmplifier = new HcalAmplifier(theParameterMap, doNoise);
00149   theZDCAmplifier = new HcalAmplifier(theParameterMap, doNoise);
00150   theHBHEAmplifier->setHBtuningParameter(HBtp);
00151   theHBHEAmplifier->setHEtuningParameter(HEtp);
00152   theHFAmplifier->setHFtuningParameter(HFtp);
00153   theHOAmplifier->setHOtuningParameter(HOtp);
00154   theHBHEAmplifier->setUseOldHB(useOldNoiseHB);
00155   theHBHEAmplifier->setUseOldHE(useOldNoiseHE);
00156   theHFAmplifier->setUseOldHF(useOldNoiseHF);
00157   theHOAmplifier->setUseOldHO(useOldNoiseHO);
00158 
00159   theCoderFactory = new HcalCoderFactory(HcalCoderFactory::DB);
00160   theHBHEElectronicsSim = new HcalElectronicsSim(theHBHEAmplifier, theCoderFactory);
00161   theHFElectronicsSim = new HcalElectronicsSim(theHFAmplifier, theCoderFactory);
00162   theHOElectronicsSim = new HcalElectronicsSim(theHOAmplifier, theCoderFactory);
00163   theZDCElectronicsSim = new HcalElectronicsSim(theZDCAmplifier, theCoderFactory);
00164 
00165   // a code of 1 means make all cells SiPM
00166   std::vector<int> hbSiPMCells(ps.getParameter<edm::ParameterSet>("hb").getParameter<std::vector<int> >("siPMCells"));
00167   //std::vector<int> hoSiPMCells(ps.getParameter<edm::ParameterSet>("ho").getParameter<std::vector<int> >("siPMCells"));
00168   // 0 means none, 1 means all, and 2 means use hardcoded
00169 
00170   bool doHBHEHPD = hbSiPMCells.empty() || (hbSiPMCells[0] != 1);
00171   bool doHOHPD = (theHOSiPMCode != 1);
00172   bool doHBHESiPM = !hbSiPMCells.empty();
00173   bool doHOSiPM = (theHOSiPMCode != 0);
00174 
00175   if(doHBHEHPD || doHOHPD )
00176   {
00177     theHcalShape = new HcalShape();
00178     theHcalIntegratedShape = new CaloShapeIntegrator(theHcalShape);
00179   }
00180   if(doHBHESiPM || doHOSiPM )
00181   {
00182     theSiPMShape = new HcalSiPMShape();
00183     theSiPMIntegratedShape = new CaloShapeIntegrator(theSiPMShape);
00184   }
00185 
00186   if(doHBHEHPD)
00187   {
00188     theHBHEResponse = new CaloHitResponse(theParameterMap, theHcalIntegratedShape);
00189     theHBHEResponse->setHitFilter(&theHBHEHitFilter);
00190     theHBHEDigitizer = new HBHEDigitizer(theHBHEResponse, theHBHEElectronicsSim, doEmpty);
00191   }
00192   if(doHOHPD) 
00193   {
00194     theHOResponse = new CaloHitResponse(theParameterMap, theHcalIntegratedShape);
00195     theHOResponse->setHitFilter(&theHOHitFilter);
00196     theHODigitizer = new HODigitizer(theHOResponse, theHOElectronicsSim, doEmpty);
00197   }
00198 
00199   if(doHBHESiPM)
00200   {
00201     theHBHESiPMResponse = new HcalSiPMHitResponse(theParameterMap, theSiPMIntegratedShape);
00202     theHBHESiPMResponse->setHitFilter(&theHBHEHitFilter);
00203     theHBHESiPMDigitizer = new HBHEDigitizer(theHBHESiPMResponse, theHBHEElectronicsSim, doEmpty);
00204   }
00205   if(doHOSiPM)
00206   {
00207     theHOSiPMResponse = new HcalSiPMHitResponse(theParameterMap, theSiPMIntegratedShape);
00208     theHOSiPMResponse->setHitFilter(&theHOSiPMHitFilter);
00209     theHOSiPMDigitizer = new HODigitizer(theHOSiPMResponse, theHOElectronicsSim, doEmpty);
00210   }
00211 
00212   // if both are present, fill the SiPM cells now
00213   if(doHBHEHPD && doHBHESiPM)
00214   {
00215     HcalDigitizerImpl::fillSiPMCells(hbSiPMCells, theHBHESiPMDigitizer);
00216   }
00217 
00218 
00219   theHFResponse->setHitFilter(&theHFHitFilter);
00220   theZDCResponse->setHitFilter(&theZDCHitFilter);
00221 
00222   bool doTimeSlew = ps.getParameter<bool>("doTimeSlew");
00223   if(doTimeSlew) {
00224     // no time slewing for HF
00225     theHitCorrection = new HcalHitCorrection(theParameterMap);
00226     if(theHBHEResponse) theHBHEResponse->setHitCorrection(theHitCorrection);
00227     if(theHBHESiPMResponse) theHBHESiPMResponse->setHitCorrection(theHitCorrection);
00228     if(theHOResponse) theHOResponse->setHitCorrection(theHitCorrection);
00229     if(theHOSiPMResponse) theHOSiPMResponse->setHitCorrection(theHitCorrection);
00230     theZDCResponse->setHitCorrection(theHitCorrection);
00231   }
00232 
00233   theHFDigitizer = new HFDigitizer(theHFResponse, theHFElectronicsSim, doEmpty);
00234   theZDCDigitizer = new ZDCDigitizer(theZDCResponse, theZDCElectronicsSim, doEmpty);
00235 
00236   bool doHPDNoise = ps.getParameter<bool>("doHPDNoise");
00237   if(doHPDNoise) {
00238     //edm::ParameterSet hpdNoisePset = ps.getParameter<edm::ParameterSet>("HPDNoiseLibrary");
00239     theNoiseGenerator = new HPDNoiseGenerator(ps); 
00240     if(theHBHEDigitizer) theHBHEDigitizer->setNoiseSignalGenerator(theNoiseGenerator);
00241     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setNoiseSignalGenerator(theNoiseGenerator);
00242   }
00243 
00244   if(ps.getParameter<bool>("doIonFeedback") && theHBHEResponse)
00245   {
00246     theIonFeedback = new HPDIonFeedbackSim(ps);
00247     theHBHEResponse->setPECorrection(theIonFeedback);
00248     if(ps.getParameter<bool>("doThermalNoise"))
00249     {
00250       theHBHEAmplifier->setIonFeedbackSim(theIonFeedback);
00251       theIonFeedback->setShape(theHcalIntegratedShape);
00252     }
00253   }
00254 
00255   if(ps.getParameter<bool>("injectTestHits") ){
00256     theNoiseHitGenerator = new HcalTestHitGenerator(ps);
00257     if(theHBHEDigitizer) theHBHEDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00258     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00259     if(theHODigitizer) theHODigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00260     if(theHOSiPMDigitizer) theHOSiPMDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00261     theHFDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00262     theZDCDigitizer->setNoiseHitGenerator(theNoiseHitGenerator);
00263   }
00264 
00265   edm::Service<edm::RandomNumberGenerator> rng;
00266   if ( ! rng.isAvailable()) {
00267     throw cms::Exception("Configuration")
00268       << "HcalDigitizer requires the RandomNumberGeneratorService\n"
00269          "which is not present in the configuration file.  You must add the service\n"
00270          "in the configuration file or remove the modules that require it.";
00271   }
00272 
00273   CLHEP::HepRandomEngine& engine = rng->getEngine();
00274   if(theHBHEDigitizer) theHBHEDigitizer->setRandomEngine(engine);
00275   if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->setRandomEngine(engine);
00276   if(theHODigitizer) theHODigitizer->setRandomEngine(engine);
00277   if(theHOSiPMDigitizer) theHOSiPMDigitizer->setRandomEngine(engine);
00278   if(theIonFeedback) theIonFeedback->setRandomEngine(engine);
00279   theHFDigitizer->setRandomEngine(engine);
00280   theZDCDigitizer->setRandomEngine(engine);
00281 
00282   if (theHitCorrection!=0) theHitCorrection->setRandomEngine(engine);
00283 
00284   hitsProducer_ = ps.getParameter<std::string>("hitsProducer");
00285 
00286 }
00287 
00288 
00289 HcalDigitizer::~HcalDigitizer() {
00290   delete theHBHEDigitizer;
00291   delete theHBHESiPMDigitizer;
00292   delete theHODigitizer;
00293   delete theHOSiPMDigitizer;
00294   delete theHFDigitizer;
00295   delete theZDCDigitizer;
00296   delete theParameterMap;
00297   delete theHcalShape;
00298   delete theSiPMShape;
00299   delete theHFShape;
00300   delete theZDCShape;
00301   delete theHcalIntegratedShape;
00302   delete theSiPMIntegratedShape;
00303   delete theHFIntegratedShape;
00304   delete theZDCIntegratedShape;
00305   delete theHBHEResponse;
00306   delete theHBHESiPMResponse;
00307   delete theHOResponse;
00308   delete theHOSiPMResponse;
00309   delete theHFResponse;
00310   delete theZDCResponse;
00311   delete theHBHEElectronicsSim;
00312   delete theHFElectronicsSim;
00313   delete theHOElectronicsSim;
00314   delete theZDCElectronicsSim;
00315   delete theHBHEAmplifier;
00316   delete theHFAmplifier;
00317   delete theHOAmplifier;
00318   delete theZDCAmplifier;
00319   delete theCoderFactory;
00320   delete theHitCorrection;
00321   delete theNoiseGenerator;
00322 }
00323 
00324 
00325 void HcalDigitizer::setHBHENoiseSignalGenerator(HcalBaseSignalGenerator * noiseGenerator)
00326 {
00327   noiseGenerator->setParameterMap(theParameterMap);
00328   noiseGenerator->setElectronicsSim(theHBHEElectronicsSim);
00329   theHBHEDigitizer->setNoiseSignalGenerator(noiseGenerator);
00330   theHBHEAmplifier->setNoiseSignalGenerator(noiseGenerator);
00331 }
00332 
00333 void HcalDigitizer::setHFNoiseSignalGenerator(HcalBaseSignalGenerator * noiseGenerator)
00334 {
00335   noiseGenerator->setParameterMap(theParameterMap);
00336   noiseGenerator->setElectronicsSim(theHFElectronicsSim);
00337   theHFDigitizer->setNoiseSignalGenerator(noiseGenerator);
00338   theHFAmplifier->setNoiseSignalGenerator(noiseGenerator);
00339 }
00340 
00341 void HcalDigitizer::setHONoiseSignalGenerator(HcalBaseSignalGenerator * noiseGenerator)
00342 {
00343   noiseGenerator->setParameterMap(theParameterMap);
00344   noiseGenerator->setElectronicsSim(theHOElectronicsSim);
00345   theHODigitizer->setNoiseSignalGenerator(noiseGenerator);
00346   theHOAmplifier->setNoiseSignalGenerator(noiseGenerator);
00347 }
00348 
00349 void HcalDigitizer::setZDCNoiseSignalGenerator(HcalBaseSignalGenerator * noiseGenerator)
00350 {
00351   noiseGenerator->setParameterMap(theParameterMap);
00352   noiseGenerator->setElectronicsSim(theZDCElectronicsSim);
00353   theZDCDigitizer->setNoiseSignalGenerator(noiseGenerator);
00354   theZDCAmplifier->setNoiseSignalGenerator(noiseGenerator);
00355 }
00356 
00357 
00358 void HcalDigitizer::produce(edm::Event& e, const edm::EventSetup& eventSetup) {
00359   // get the appropriate gains, noises, & widths for this event
00360   edm::ESHandle<HcalDbService> conditions;
00361   eventSetup.get<HcalDbRecord>().get(conditions);
00362   theHBHEAmplifier->setDbService(conditions.product());
00363   theHFAmplifier->setDbService(conditions.product());
00364   theHOAmplifier->setDbService(conditions.product());
00365   theZDCAmplifier->setDbService(conditions.product());
00366 
00367   theCoderFactory->setDbService(conditions.product());
00368   theParameterMap->setDbService(conditions.product());
00369 
00370    edm::ESHandle<HcalCholeskyMatrices> refCholesky;
00371    eventSetup.get<HcalCholeskyMatricesRcd>().get(refCholesky);
00372    const HcalCholeskyMatrices * myCholesky = refCholesky.product();
00373   
00374    edm::ESHandle<HcalPedestals> pedshandle;
00375    eventSetup.get<HcalPedestalsRcd>().get(pedshandle);
00376    const HcalPedestals *  myADCPedestals = pedshandle.product();
00377 
00378   theHBHEAmplifier->setCholesky(myCholesky);
00379   theHFAmplifier->setCholesky(myCholesky);
00380   theHOAmplifier->setCholesky(myCholesky);
00381   
00382   theHBHEAmplifier->setADCPeds(myADCPedestals);
00383   theHFAmplifier->setADCPeds(myADCPedestals);
00384   theHOAmplifier->setADCPeds(myADCPedestals);
00385 
00386 
00387   // get the correct geometry
00388   checkGeometry(eventSetup);
00389   
00390   // Step A: Get Inputs
00391   edm::Handle<CrossingFrame<PCaloHit> > cf, zdccf;
00392 
00393   // test access to SimHits for HcalHits and ZDC hits
00394   const std::string zdcHitsName(hitsProducer_+"ZDCHITS");
00395   e.getByLabel("mix", zdcHitsName , zdccf);
00396   MixCollection<PCaloHit> * colzdc = 0 ;
00397   if(zdccf.isValid()){
00398     colzdc = new MixCollection<PCaloHit>(zdccf.product());
00399   }else{
00400     edm::LogInfo("HcalDigitizer") << "We don't have ZDC hit collection available ";
00401     isZDC = false;
00402   }
00403 
00404   const std::string hcalHitsName(hitsProducer_+"HcalHits");
00405   e.getByLabel("mix", hcalHitsName ,cf);
00406   MixCollection<PCaloHit> * col = 0 ;
00407   if(cf.isValid()){
00408     col = new MixCollection<PCaloHit>(cf.product());
00409   }else{
00410     edm::LogInfo("HcalDigitizer") << "We don't have HCAL hit collection available ";
00411     isHCAL = false;
00412   }
00413 
00414   if(theHitCorrection != 0)
00415   {
00416     theHitCorrection->clear();
00417     if(isHCAL)
00418       theHitCorrection->fillChargeSums(*col);
00419   }
00420 
00421   // Step B: Create empty output
00422 
00423   std::auto_ptr<HBHEDigiCollection> hbheResult(new HBHEDigiCollection());
00424   std::auto_ptr<HODigiCollection> hoResult(new HODigiCollection());
00425   std::auto_ptr<HFDigiCollection> hfResult(new HFDigiCollection());
00426   std::auto_ptr<ZDCDigiCollection> zdcResult(new ZDCDigiCollection());
00427 
00428   // Step C: Invoke the algorithm, passing in inputs and getting back outputs.
00429   if(isHCAL&&hbhegeo)
00430   {
00431     if(theHBHEDigitizer) theHBHEDigitizer->run(*col, *hbheResult);
00432     if(theHBHESiPMDigitizer) theHBHESiPMDigitizer->run(*col, *hbheResult);
00433   }
00434   if(isHCAL&&hogeo)
00435   {
00436     if(theHODigitizer) theHODigitizer->run(*col, *hoResult);
00437     if(theHOSiPMDigitizer) theHOSiPMDigitizer->run(*col, *hoResult);
00438   }
00439   if(isHCAL&&hfgeo)
00440     theHFDigitizer->run(*col, *hfResult);  
00441   if(isZDC&&zdcgeo) 
00442     theZDCDigitizer->run(*colzdc, *zdcResult);
00443   
00444   edm::LogInfo("HcalDigitizer") << "HCAL HBHE digis : " << hbheResult->size();
00445   edm::LogInfo("HcalDigitizer") << "HCAL HO digis   : " << hoResult->size();
00446   edm::LogInfo("HcalDigitizer") << "HCAL HF digis   : " << hfResult->size();
00447   edm::LogInfo("HcalDigitizer") << "HCAL ZDC digis   : " << zdcResult->size();
00448 
00449   // Step D: Put outputs into event
00450   e.put(hbheResult);
00451   e.put(hoResult);
00452   e.put(hfResult);
00453   e.put(zdcResult);
00454 }
00455 
00456 
00457 void HcalDigitizer::checkGeometry(const edm::EventSetup & eventSetup) {
00458   // TODO find a way to avoid doing this every event
00459   edm::ESHandle<CaloGeometry> geometry;
00460   eventSetup.get<CaloGeometryRecord>().get(geometry);
00461   // See if it's been updated
00462   if(&*geometry != theGeometry)
00463   {
00464     theGeometry = &*geometry;
00465     updateGeometry();
00466   }
00467 }
00468 
00469 
00470 void  HcalDigitizer::updateGeometry()
00471 {
00472   if(theHBHEResponse) theHBHEResponse->setGeometry(theGeometry);
00473   if(theHBHESiPMResponse) theHBHESiPMResponse->setGeometry(theGeometry);
00474   if(theHOResponse) theHOResponse->setGeometry(theGeometry);
00475   if(theHOSiPMResponse) theHOSiPMResponse->setGeometry(theGeometry);
00476   theHFResponse->setGeometry(theGeometry);
00477   theZDCResponse->setGeometry(theGeometry);
00478 
00479   const vector<DetId>& hbCells = theGeometry->getValidDetIds(DetId::Hcal, HcalBarrel);
00480   const vector<DetId>& heCells = theGeometry->getValidDetIds(DetId::Hcal, HcalEndcap);
00481   const vector<DetId>& hoCells = theGeometry->getValidDetIds(DetId::Hcal, HcalOuter);
00482   const vector<DetId>& hfCells = theGeometry->getValidDetIds(DetId::Hcal, HcalForward);
00483   const vector<DetId>& zdcCells = theGeometry->getValidDetIds(DetId::Calo, HcalZDCDetId::SubdetectorId);
00484   //const vector<DetId>& hcalTrigCells = geometry->getValidDetIds(DetId::Hcal, HcalTriggerTower);
00485   //const vector<DetId>& hcalCalib = geometry->getValidDetIds(DetId::Calo, HcalCastorDetId::SubdetectorId);
00486   //std::cout<<"HcalDigitizer::CheckGeometry number of cells: "<<zdcCells.size()<<std::endl;
00487   if(zdcCells.empty()) zdcgeo = false;
00488   if(hbCells.empty() && heCells.empty()) hbhegeo = false;
00489   if(hoCells.empty()) hogeo = false;
00490   if(hfCells.empty()) hfgeo = false;
00491   // combine HB & HE
00492 
00493 
00494   theHBHEDetIds = hbCells;
00495   theHBHEDetIds.insert(theHBHEDetIds.end(), heCells.begin(), heCells.end());
00496 
00497   HcalDigitizerImpl::fillCells(theHBHEDetIds, theHBHEDigitizer, theHBHESiPMDigitizer);
00498   //HcalDigitizerImpl::fillCells(hoCells, theHODigitizer, theHOSiPMDigitizer);
00499   buildHOSiPMCells(hoCells);
00500   theHFDigitizer->setDetIds(hfCells);
00501   theZDCDigitizer->setDetIds(zdcCells); 
00502 }
00503 
00504 
00505 void HcalDigitizer::buildHOSiPMCells(const std::vector<DetId>& allCells)
00506 {
00507   // all HPD
00508   if(theHOSiPMCode == 0)
00509   {
00510     theHODigitizer->setDetIds(allCells);
00511   }
00512   else if(theHOSiPMCode == 1)
00513   {
00514     theHOSiPMDigitizer->setDetIds(allCells);
00515     // FIXME pick Zecotek or hamamatsu?
00516   } 
00517   else if(theHOSiPMCode == 2)// hardcode which are SiPM 
00518   {
00519     std::vector<HcalDetId> zecotekDetIds;
00520     std::vector<HcalDetId> hamamatsuDetIds;
00521     for(std::vector<DetId>::const_iterator detItr = allCells.begin();
00522         detItr != allCells.end(); ++detItr)
00523     {
00524       HcalDetId hcalId(*detItr);
00525       int ieta = hcalId.ieta();
00526       int iphi = hcalId.iphi(); 
00527       if ((ieta>=5 && ieta <= 10 )  && (iphi >=47 && iphi <=52))
00528       {
00529         zecotekDetIds.push_back(hcalId);
00530         theHOSiPMDetIds.push_back(*detItr);
00531       } 
00532       else if(((ieta>=5 && ieta <= 10 ) && (iphi >=53 && iphi <=58))
00533            || ((ieta>=11 && ieta <= 15 )  && (iphi >=59 && iphi <=70))){
00534         hamamatsuDetIds.push_back(hcalId);
00535         theHOSiPMDetIds.push_back(*detItr);
00536       }
00537       else {
00538         theHOHPDDetIds.push_back(*detItr);
00539       }
00540     }
00541     assert(theHODigitizer);
00542     assert(theHOSiPMDigitizer);
00543     theHODigitizer->setDetIds(theHOHPDDetIds);
00544     theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
00545     theHOSiPMHitFilter.setDetIds(theHOSiPMDetIds);
00546     // FIXME not applying a HitFilter to the HPDs, for now
00547     theParameterMap->setHOZecotekDetIds(zecotekDetIds);
00548     theParameterMap->setHOHamamatsuDetIds(hamamatsuDetIds);
00549 
00550     // make sure we don't got through this exercise again
00551     theHOSiPMCode = -2;
00552   }
00553 }
00554 
00555       
00556     
00557
/data/refman/pasoursint/CMSSW_4_1_8_patch12/src/SimCalorimetry/HcalSimProducers/src/HcalDigitizer.cc
