/data/refman/pasoursint/CMSSW_5_2_9/src/SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h

Go to the documentation of this file.

#ifndef CaloSimAlgos_CaloTDigitizer_h
#define CaloSimAlgos_CaloTDigitizer_h

#include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h"
#include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseHitGenerator.h"
#include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h"
#include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include <cassert>

template<class Traits>
class CaloTDigitizer
{
public:
  typedef typename Traits::ElectronicsSim ElectronicsSim;
  typedef typename Traits::Digi Digi;
  typedef typename Traits::DigiCollection DigiCollection;

  CaloTDigitizer(CaloHitResponse * hitResponse, ElectronicsSim * electronicsSim, bool addNoise)
  :  theHitResponse(hitResponse),
     theNoiseHitGenerator(0),
     theNoiseSignalGenerator(0),
     theElectronicsSim(electronicsSim),
     theDetIds(0),
     addNoise_(addNoise)
  {
  }


  ~CaloTDigitizer() {}

  const std::vector<DetId>&  detIds() const {assert( 0 != theDetIds ) ; return *theDetIds;}
  void setDetIds(const std::vector<DetId> & detIds) {theDetIds = &detIds;}

  void setNoiseHitGenerator(CaloVNoiseHitGenerator * generator) 
  {
    theNoiseHitGenerator = generator;
  }

  void setNoiseSignalGenerator(CaloVNoiseSignalGenerator * generator)
  {
    theNoiseSignalGenerator = generator;
  }

  void setRandomEngine(CLHEP::HepRandomEngine & engine)
  {
    theHitResponse->setRandomEngine(engine);
    theElectronicsSim->setRandomEngine(engine);
  }

  void run(MixCollection<PCaloHit> & input, DigiCollection & output) {
    assert(theDetIds->size() != 0);

    if(theNoiseHitGenerator != 0) addNoiseHits();
    if(theNoiseSignalGenerator != 0) addNoiseSignals();

    theHitResponse->run(input);
    theElectronicsSim->newEvent();

    // reserve space for how many digis we expect
    int nDigisExpected = addNoise_ ? theDetIds->size() : theHitResponse->nSignals();
    output.reserve(nDigisExpected);

    // make a raw digi for evey cell
    for(std::vector<DetId>::const_iterator idItr = theDetIds->begin();
        idItr != theDetIds->end(); ++idItr)
    {
       Digi digi(*idItr);
       CaloSamples * analogSignal = theHitResponse->findSignal(*idItr);
       bool needToDeleteSignal = false;
       // don't bother digitizing if no signal and no noise
       if(analogSignal == 0 && addNoise_) {
         // I guess we need to make a blank signal for this cell.
         // Don't bother storing it anywhere.
         analogSignal = new CaloSamples(theHitResponse->makeBlankSignal(*idItr));
         needToDeleteSignal = true;
       }
       if(analogSignal != 0) { 
         theElectronicsSim->analogToDigital(*analogSignal , digi);
         output.push_back(digi);
         if(needToDeleteSignal) delete analogSignal;
      }
    }

    // free up some memory
    theHitResponse->clear();
  }


  void addNoiseHits()
  {
    std::vector<PCaloHit> noiseHits;
    theNoiseHitGenerator->getNoiseHits(noiseHits);
    for(std::vector<PCaloHit>::const_iterator hitItr = noiseHits.begin(),
        hitEnd = noiseHits.end(); hitItr != hitEnd; ++hitItr)
    {
      theHitResponse->add(*hitItr);
    }
  }

  void addNoiseSignals()
  {
    std::vector<CaloSamples> noiseSignals;
    // noise signals need to be in units of photoelectrons.  Fractional is OK
    theNoiseSignalGenerator->fillEvent();
    theNoiseSignalGenerator->getNoiseSignals(noiseSignals);
    for(std::vector<CaloSamples>::const_iterator signalItr = noiseSignals.begin(),
        signalEnd = noiseSignals.end(); signalItr != signalEnd; ++signalItr)
    {
      theHitResponse->add(*signalItr);
    }
  }

private:
  CaloHitResponse * theHitResponse;
  CaloVNoiseHitGenerator * theNoiseHitGenerator;
  CaloVNoiseSignalGenerator * theNoiseSignalGenerator;
  ElectronicsSim * theElectronicsSim;
  const std::vector<DetId>* theDetIds;
  bool addNoise_;
};

#endif