#include <HcalDigitizer.h>

Public Member Functions
	HcalDigitizer (const edm::ParameterSet &ps)
virtual 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)
void	checkGeometry (const edm::EventSetup &eventSetup)
void	fillFakeHits ()
	some hits in each subdetector, just for testing purposes
void	updateGeometry ()
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
CaloVShape *	theHcalIntegratedShape
CaloVShape *	theHcalShape
HcalAmplifier *	theHFAmplifier
HFDigitizer *	theHFDigitizer
HcalElectronicsSim *	theHFElectronicsSim
HFHitFilter	theHFHitFilter
CaloVShape *	theHFIntegratedShape
CaloHitResponse *	theHFResponse
CaloVShape *	theHFShape
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
CaloVShape *	theSiPMIntegratedShape
CaloVShape *	theSiPMShape
HcalAmplifier *	theZDCAmplifier
ZDCDigitizer *	theZDCDigitizer
HcalElectronicsSim *	theZDCElectronicsSim
ZDCHitFilter	theZDCHitFilter
CaloVShape *	theZDCIntegratedShape
CaloHitResponse *	theZDCResponse
CaloVShape *	theZDCShape
bool	zdcgeo

Detailed Description

Definition at line 27 of file HcalDigitizer.h.

Member Typedef Documentation

typedef CaloTDigitizer<HBHEDigitizerTraits> HcalDigitizer::HBHEDigitizer [private]

Reconstruction algorithm

Definition at line 54 of file HcalDigitizer.h.

typedef CaloTDigitizer<HFDigitizerTraits> HcalDigitizer::HFDigitizer [private]

Definition at line 56 of file HcalDigitizer.h.

typedef CaloTDigitizer<HODigitizerTraits> HcalDigitizer::HODigitizer [private]

Definition at line 55 of file HcalDigitizer.h.

typedef CaloTDigitizer<ZDCDigitizerTraits> HcalDigitizer::ZDCDigitizer [private]

Definition at line 57 of file HcalDigitizer.h.

Constructor & Destructor Documentation

HcalDigitizer::HcalDigitizer ( const edm::ParameterSet & ps ) [explicit]

Definition at line 82 of file HcalDigitizer.cc.

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

: theGeometry(0),
  theParameterMap(new HcalSimParameterMap(ps)),
  theHcalShape(0),
  theSiPMShape(0),
  theHFShape(new HFShape()),
  theZDCShape(new ZDCShape()),
  theHcalIntegratedShape(0),
  theSiPMIntegratedShape(0),
  theHFIntegratedShape(new CaloShapeIntegrator(theHFShape)),
  theZDCIntegratedShape(new CaloShapeIntegrator(theZDCShape)),
  theHBHEResponse(0),
  theHBHESiPMResponse(0),
  theHOResponse(0),   
  theHOSiPMResponse(0),
  theHFResponse(new CaloHitResponse(theParameterMap, theHFIntegratedShape)),
  theZDCResponse(new CaloHitResponse(theParameterMap, theZDCIntegratedShape)),
  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 || doHOHPD )
  {
    theHcalShape = new HcalShape();
    theHcalIntegratedShape = new CaloShapeIntegrator(theHcalShape);
  }
  if(doHBHESiPM || doHOSiPM )
  {
    theSiPMShape = new HcalSiPMShape();
    theSiPMIntegratedShape = new CaloShapeIntegrator(theSiPMShape);
  }

  if(doHBHEHPD)
  {
    theHBHEResponse = new CaloHitResponse(theParameterMap, theHcalIntegratedShape);
    theHBHEResponse->setHitFilter(&theHBHEHitFilter);
    theHBHEDigitizer = new HBHEDigitizer(theHBHEResponse, theHBHEElectronicsSim, doEmpty);
  }
  if(doHOHPD) 
  {
    theHOResponse = new CaloHitResponse(theParameterMap, theHcalIntegratedShape);
    theHOResponse->setHitFilter(&theHOHitFilter);
    theHODigitizer = new HODigitizer(theHOResponse, theHOElectronicsSim, doEmpty);
  }

  if(doHBHESiPM)
  {
    theHBHESiPMResponse = new HcalSiPMHitResponse(theParameterMap, theSiPMIntegratedShape);
    theHBHESiPMResponse->setHitFilter(&theHBHEHitFilter);
    theHBHESiPMDigitizer = new HBHEDigitizer(theHBHESiPMResponse, theHBHEElectronicsSim, doEmpty);
  }
  if(doHOSiPM)
  {
    theHOSiPMResponse = new HcalSiPMHitResponse(theParameterMap, theSiPMIntegratedShape);
    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);
  }

  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);
    theHBHEResponse->setPECorrection(theIonFeedback);
    if(ps.getParameter<bool>("doThermalNoise"))
    {
      theHBHEAmplifier->setIonFeedbackSim(theIonFeedback);
      theIonFeedback->setShape(theHcalIntegratedShape);
    }
  }

  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);
  theHFDigitizer->setRandomEngine(engine);
  theZDCDigitizer->setRandomEngine(engine);

  if (theHitCorrection!=0) theHitCorrection->setRandomEngine(engine);

  hitsProducer_ = ps.getParameter<std::string>("hitsProducer");

}

HcalDigitizer::~HcalDigitizer ( ) [virtual]

Definition at line 289 of file HcalDigitizer.cc.

References theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEResponse, theHBHESiPMDigitizer, theHBHESiPMResponse, theHcalIntegratedShape, theHcalShape, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFIntegratedShape, theHFResponse, theHFShape, theHitCorrection, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOResponse, theHOSiPMDigitizer, theHOSiPMResponse, theNoiseGenerator, theParameterMap, theSiPMIntegratedShape, theSiPMShape, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, theZDCIntegratedShape, theZDCResponse, and theZDCShape.

                              {
  delete theHBHEDigitizer;
  delete theHBHESiPMDigitizer;
  delete theHODigitizer;
  delete theHOSiPMDigitizer;
  delete theHFDigitizer;
  delete theZDCDigitizer;
  delete theParameterMap;
  delete theHcalShape;
  delete theSiPMShape;
  delete theHFShape;
  delete theZDCShape;
  delete theHcalIntegratedShape;
  delete theSiPMIntegratedShape;
  delete theHFIntegratedShape;
  delete theZDCIntegratedShape;
  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::buildHOSiPMCells ( const std::vector< DetId > & allCells ) [private]

Definition at line 504 of file HcalDigitizer.cc.

References HcalDetId::ieta(), HcalDetId::iphi(), CaloTDigitizer< Traits >::setDetIds(), HcalHitFilter::setDetIds(), HcalSimParameterMap::setHOHamamatsuDetIds(), HcalSimParameterMap::setHOZecotekDetIds(), theHODigitizer, theHOHPDDetIds, theHOSiPMCode, theHOSiPMDetIds, theHOSiPMDigitizer, theHOSiPMHitFilter, and theParameterMap.

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)// hardcode which are SiPM 
  {
    std::vector<HcalDetId> zecotekDetIds;
    std::vector<HcalDetId> hamamatsuDetIds;
    for(std::vector<DetId>::const_iterator detItr = allCells.begin();
        detItr != allCells.end(); ++detItr)
    {
      HcalDetId hcalId(*detItr);
      int ieta = hcalId.ieta();
      int iphi = hcalId.iphi(); 
      if ((ieta>=5 && ieta <= 10 )  && (iphi >=47 && iphi <=52))
      {
        zecotekDetIds.push_back(hcalId);
        theHOSiPMDetIds.push_back(*detItr);
      } 
      else if(((ieta>=5 && ieta <= 10 ) && (iphi >=53 && iphi <=58))
           || ((ieta>=11 && ieta <= 15 )  && (iphi >=59 && iphi <=70))){
        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 456 of file HcalDigitizer.cc.

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

Referenced by produce().

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

void HcalDigitizer::fillFakeHits ( ) [private]

some hits in each subdetector, just for testing purposes

void HcalDigitizer::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)		`[virtual]`

Produces the EDM products,

Definition at line 358 of file HcalDigitizer.cc.

References checkGeometry(), HcalHitCorrection::clear(), HcalHitCorrection::fillChargeSums(), edm::EventSetup::get(), edm::Event::getByLabel(), hbhegeo, hfgeo, hitsProducer_, hogeo, isHCAL, edm::HandleBase::isValid(), isZDC, edm::ESHandle< T >::product(), edm::Handle< T >::product(), edm::Event::put(), CaloTDigitizer< Traits >::run(), HcalAmplifier::setADCPeds(), HcalAmplifier::setCholesky(), HcalSimParameterMap::setDbService(), HcalCoderFactory::setDbService(), HcalAmplifier::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);


  // get the correct geometry
  checkGeometry(eventSetup);
  
  // 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);
}

void HcalDigitizer::setHBHENoiseSignalGenerator ( HcalBaseSignalGenerator * noiseGenerator )

Definition at line 325 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 333 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 341 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 349 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 ( ) [private]

Definition at line 469 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);
  theHFDigitizer->setDetIds(hfCells);
  theZDCDigitizer->setDetIds(zdcCells); 
}