#include <HcalSiPMHitResponse.h>

Inheritance diagram for HcalSiPMHitResponse:

Public Types
typedef std::vector< unsigned int >	photonTimeHist

typedef std::map< DetId, photonTimeHist >	photonTimeMap

Public Types inherited from CaloHitResponse
enum	{ BUNCHSPACE = 25 }

typedef std::map< DetId, CaloSamples >	AnalogSignalMap

Public Member Functions
void	add (const PCaloHit &hit, CLHEP::HepRandomEngine *) override
	process a single SimHit More...

void	add (const CaloSamples &signal) override
	add a signal, in units of pe More...

virtual void	addPEnoise (CLHEP::HepRandomEngine *engine)

void	finalizeHits (CLHEP::HepRandomEngine *) override
	Finalize hits. More...

virtual int	getReadoutFrameSize (const DetId &id) const

	HcalSiPMHitResponse (const CaloVSimParameterMap parameterMap, const CaloShapes shapes, bool PreMix1=false, bool HighFidelity=true)

void	initializeHits () override
	Initialize hits. More...

virtual CaloSamples	makeBlankSignal (const DetId &detId) const

virtual void	setDetIds (const std::vector< DetId > &detIds)

	~HcalSiPMHitResponse () override

Public Member Functions inherited from CaloHitResponse
void	addHit (const PCaloHit *hit, CaloSamples &frame) const
	adds the amplitude for a single hit to the frame More...

double	analogSignalAmplitude (const DetId &id, float energy, const CaloSimParameters &parameters, CLHEP::HepRandomEngine *) const

	CaloHitResponse (const CaloVSimParameterMap parameterMap, const CaloVShape shape, bool PreMix1=false, bool HighFidelity=false)

	CaloHitResponse (const CaloVSimParameterMap parameterMap, const CaloShapes shapes, bool PreMix1=false, bool HighFidelity=false)

void	clear ()
	frees up memory More...

CaloSamples *	findSignal (const DetId &detId)
	users can look for the signal for a given cell More...

int	getReadoutFrameSize (const DetId &id) const

virtual bool	keepBlank () const

virtual CaloSamples	makeAnalogSignal (const PCaloHit &inputHit, CLHEP::HepRandomEngine *) const
	creates the signal corresponding to this hit More...

CaloSamples	makeBlankSignal (const DetId &detId) const
	creates an empty signal for this DetId More...

int	nSignals () const
	number of signals in the current cache More...

virtual void	run (const MixCollection< PCaloHit > &hits, CLHEP::HepRandomEngine *)
	Complete cell digitization. More...

void	setBunchRange (int minBunch, int maxBunch)
	tells it which pileup bunches to do More...

void	setGeometry (const CaloGeometry *geometry)
	geometry needed for time-of-flight More...

void	setHitCorrection (const CaloVHitCorrection *hitCorrection)
	If you want to correct hits, for attenuation or delay, set this. More...

void	setHitFilter (const CaloVHitFilter *filter)

void	setIgnoreGeantTime (bool gt)

void	setPECorrection (const CaloVPECorrection *peCorrection)
	if you want to correct the photoelectrons More...

void	setPhaseShift (const double &thePhaseShift)
	setting the phase shift for asynchronous trigger (e.g. test beams) More...

void	setStorePrecise (bool sp)

double	timeOfFlight (const DetId &detId) const

bool	withinBunchRange (int bunchCrossing) const
	check if crossing is within bunch range: More...

virtual	~CaloHitResponse ()
	doesn't delete the pointers passed in More...

Protected Member Functions
virtual CaloSamples	makeSiPMSignal (DetId const &id, photonTimeHist const &photons, CLHEP::HepRandomEngine *)

Private Attributes
double	dt

bool	HighFidelityPreMix

double	invdt

int	nbins

photonTimeMap	precisionTimedPhotons

bool	PreMixDigis

std::map< int, HcalSiPMShape >	shapeMap

const std::vector< DetId > *	theDetIds

HcalSiPM	theSiPM

Additional Inherited Members
Static Public Attributes inherited from CaloHitResponse
static constexpr double	dt = 0.5

static constexpr int	invdt = 2

Protected Attributes inherited from CaloHitResponse
bool	highFidelityPreMix

bool	ignoreTime

bool	preMixDigis

bool	storePrecise

AnalogSignalMap	theAnalogSignalMap

const CaloGeometry *	theGeometry

const CaloVHitCorrection *	theHitCorrection

const CaloVHitFilter *	theHitFilter

int	theMaxBunch

int	theMinBunch

const CaloVSimParameterMap *	theParameterMap

const CaloVPECorrection *	thePECorrection

double	thePhaseShift_

const CaloVShape *	theShape

const CaloShapes *	theShapes

Detailed Description

Definition at line 22 of file HcalSiPMHitResponse.h.

Member Typedef Documentation

typedef std::vector<unsigned int> HcalSiPMHitResponse::photonTimeHist

Definition at line 31 of file HcalSiPMHitResponse.h.

typedef std::map<DetId, photonTimeHist> HcalSiPMHitResponse::photonTimeMap

Definition at line 32 of file HcalSiPMHitResponse.h.

Constructor & Destructor Documentation

HcalSiPMHitResponse::HcalSiPMHitResponse	(	const CaloVSimParameterMap *	parameterMap,
		const CaloShapes *	shapes,
		bool	PreMix1 = `false`,
		bool	HighFidelity = `true`
	)

Definition at line 19 of file HcalSiPMHitResponse.cc.

References HcalShapes::HAMAMATSU, HcalShapes::HE2017, HcalShapes::HE2018, shapeMap, and HcalShapes::ZECOTEK.

     : CaloHitResponse(parameterMap, shapes),
       theSiPM(),
       PreMixDigis(PreMix1),
       HighFidelityPreMix(HighFidelity),
       nbins((PreMixDigis and HighFidelityPreMix) ? 1 : BUNCHSPACE * HcalPulseShapes::invDeltaTSiPM_),
       dt(HcalPulseShapes::deltaTSiPM_),
       invdt(HcalPulseShapes::invDeltaTSiPM_) {
   //fill shape map
   shapeMap.emplace(HcalShapes::ZECOTEK, HcalShapes::ZECOTEK);
   shapeMap.emplace(HcalShapes::HAMAMATSU, HcalShapes::HAMAMATSU);
   shapeMap.emplace(HcalShapes::HE2017, HcalShapes::HE2017);
   shapeMap.emplace(HcalShapes::HE2018, HcalShapes::HE2018);
 }

HcalSiPMHitResponse::~HcalSiPMHitResponse ( )

override

Definition at line 37 of file HcalSiPMHitResponse.cc.

37 {}

Member Function Documentation

void HcalSiPMHitResponse::add	(	const PCaloHit &	hit,
		CLHEP::HepRandomEngine *	engine
	)

overridevirtual

process a single SimHit

Reimplemented from CaloHitResponse.

Definition at line 100 of file HcalSiPMHitResponse.cc.

References CaloVHitFilter::accepts(), CaloHitResponse::analogSignalAmplitude(), CaloHitResponse::BUNCHSPACE, dt, PCaloHit::energy(), HcalPulseShapes::generatePhotonTime(), getReadoutFrameSize(), gpuClustering::id, PCaloHit::id(), CaloHitResponse::ignoreTime, invdt, edm::isNotFinite(), LogDebug, nbins, interactiveExample::photons, precisionTimedPhotons, CaloVSimParameterMap::simParameters(), findQualityFiles::size, CaloHitResponse::theHitFilter, CaloHitResponse::theParameterMap, CaloHitResponse::thePhaseShift_, PCaloHit::time(), CaloHitResponse::timeOfFlight(), and tzero.

Referenced by counter.Counter::register().

                                                                                {
   if (!edm::isNotFinite(hit.time()) && ((theHitFilter == nullptr) || (theHitFilter->accepts(hit)))) {
     HcalDetId id(hit.id());
     const HcalSimParameters& pars = dynamic_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));
     //divide out mean of crosstalk distribution 1/(1-lambda) = multiply by (1-lambda)
     double signal(analogSignalAmplitude(id, hit.energy(), pars, engine) * (1 - pars.sipmCrossTalk(id)));
     unsigned int photons(signal + 0.5);
     double tof(timeOfFlight(id));
     double time(hit.time());
     if (ignoreTime)
       time = tof;
 
     if (photons > 0)
       if (precisionTimedPhotons.find(id) == precisionTimedPhotons.end()) {
         precisionTimedPhotons.insert(
             std::pair<DetId, photonTimeHist>(id, photonTimeHist(nbins * getReadoutFrameSize(id), 0)));
       }
 
     LogDebug("HcalSiPMHitResponse") << id;
     LogDebug("HcalSiPMHitResponse") << " fCtoGeV: " << pars.fCtoGeV(id)
                                     << " samplingFactor: " << pars.samplingFactor(id)
                                     << " photoelectronsToAnalog: " << pars.photoelectronsToAnalog(id)
                                     << " simHitToPhotoelectrons: " << pars.simHitToPhotoelectrons(id);
     LogDebug("HcalSiPMHitResponse") << " energy: " << hit.energy() << " photons: " << photons << " time: " << time;
     LogDebug("HcalSiPMHitResponse") << " timePhase: " << pars.timePhase() << " tof: " << tof
                                     << " binOfMaximum: " << pars.binOfMaximum() << " phaseShift: " << thePhaseShift_;
     double tzero(0.0 + pars.timePhase() - (time - tof) - BUNCHSPACE * (pars.binOfMaximum() - thePhaseShift_));
     LogDebug("HcalSiPMHitResponse") << " tzero: " << tzero;
     double tzero_bin(-tzero * invdt);
     LogDebug("HcalSiPMHitResponse") << " corrected tzero: " << tzero_bin << '\n';
     double t_pe(0.);
     int t_bin(0);
     unsigned signalShape = pars.signalShape(id);
     for (unsigned int pe(0); pe < photons; ++pe) {
       t_pe = HcalPulseShapes::generatePhotonTime(engine, signalShape);
       t_bin = int(t_pe * invdt + tzero_bin + 0.5);
       LogDebug("HcalSiPMHitResponse") << "t_pe: " << t_pe << " t_pe + tzero: " << (t_pe + tzero_bin * dt)
                                       << " t_bin: " << t_bin << '\n';
       if ((t_bin >= 0) && (static_cast<unsigned int>(t_bin) < precisionTimedPhotons[id].size()))
         precisionTimedPhotons[id][t_bin] += 1;
     }
   }
 }

void HcalSiPMHitResponse::add ( const CaloSamples & signal )

overridevirtual

add a signal, in units of pe

Reimplemented from CaloHitResponse.

Definition at line 83 of file HcalSiPMHitResponse.cc.

References CaloHitResponse::add(), cms::cuda::assert(), getReadoutFrameSize(), HighFidelityPreMix, mps_fire::i, gpuClustering::id, CaloSamples::id(), nbins, interactiveExample::photons, precisionTimedPhotons, and CaloSamples::size().

Referenced by counter.Counter::register().

                                                        {
   if (!HighFidelityPreMix) {
     CaloHitResponse::add(signal);
     return;
   }
   DetId id(signal.id());
   int photonTimeHistSize = nbins * getReadoutFrameSize(id);
   assert(photonTimeHistSize == signal.size());
   if (precisionTimedPhotons.find(id) == precisionTimedPhotons.end()) {
     precisionTimedPhotons.insert(std::pair<DetId, photonTimeHist>(id, photonTimeHist(photonTimeHistSize, 0)));
   }
   for (int i = 0; i < signal.size(); ++i) {
     unsigned int photons(signal[i] + 0.5);
     precisionTimedPhotons[id][i] += photons;
   }
 }

void HcalSiPMHitResponse::addPEnoise ( CLHEP::HepRandomEngine * engine )

virtual

Definition at line 144 of file HcalSiPMHitResponse.cc.

References dt, getReadoutFrameSize(), gpuClustering::id, LogDebug, nbins, HcalSimParameters::photoelectronsToAnalog(), interactiveExample::photons, precisionTimedPhotons, CaloVSimParameterMap::simParameters(), HcalSimParameters::sipmDarkCurrentuA(), theDetIds, and CaloHitResponse::theParameterMap.

Referenced by finalizeHits().

                                                                  {
   // Add SiPM dark current noise to all cells
   for (std::vector<DetId>::const_iterator idItr = theDetIds->begin(); idItr != theDetIds->end(); ++idItr) {
     HcalDetId id(*idItr);
     const HcalSimParameters& pars = static_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));
 
     // uA * ns / (fC/pe) = pe!
     double dc_pe_avg = pars.sipmDarkCurrentuA(id) * dt / pars.photoelectronsToAnalog(id);
 
     if (dc_pe_avg <= 0.)
       continue;
 
     int nPreciseBins = nbins * getReadoutFrameSize(id);
 
     unsigned int sumnoisePE(0);
     double elapsedTime(0.);
     for (int tprecise(0); tprecise < nPreciseBins; ++tprecise) {
       int noisepe = CLHEP::RandPoissonQ::shoot(engine, dc_pe_avg);  // add dark current noise
 
       if (noisepe > 0) {
         if (precisionTimedPhotons.find(id) == precisionTimedPhotons.end()) {
           photonTimeHist photons(nPreciseBins, 0);
           photons[tprecise] = noisepe;
           precisionTimedPhotons.insert(std::pair<DetId, photonTimeHist>(id, photons));
         } else {
           precisionTimedPhotons[id][tprecise] += noisepe;
         }
 
         sumnoisePE += noisepe;
       }
       elapsedTime += dt;
 
     }  // precise time loop
 
     LogDebug("HcalSiPMHitResponse") << id;
     LogDebug("HcalSiPMHitResponse") << " total noise (PEs): " << sumnoisePE;
 
   }  // detId loop
 }  // HcalSiPMHitResponse::addPEnoise()

void HcalSiPMHitResponse::finalizeHits ( CLHEP::HepRandomEngine * )

overridevirtual

Finalize hits.

Reimplemented from CaloHitResponse.

Definition at line 51 of file HcalSiPMHitResponse.cc.

References CaloHitResponse::add(), addPEnoise(), HighFidelityPreMix, mps_fire::i, CaloSamples::id(), keep, CaloHitResponse::keepBlank(), LogDebug, makeSiPMSignal(), precisionTimedPhotons, PreMixDigis, CaloSamples::setPreciseSize(), CaloSamples::size(), and findQualityFiles::size.

                                                                    {
   //do not add PE noise for initial premix
   if (!PreMixDigis)
     addPEnoise(engine);
 
   photonTimeMap::iterator channelPhotons;
   for (channelPhotons = precisionTimedPhotons.begin(); channelPhotons != precisionTimedPhotons.end();
        ++channelPhotons) {
     CaloSamples signal(makeSiPMSignal(channelPhotons->first, channelPhotons->second, engine));
     bool keep(keepBlank());
     if (!keep) {
       const unsigned int size(signal.size());
       if (0 != size) {
         for (unsigned int i(0); i != size; ++i) {
           keep = keep || signal[i] > 1.e-7;
         }
       }
     }
 
     LogDebug("HcalSiPMHitResponse") << HcalDetId(signal.id()) << ' ' << signal;
 
     //if we don't want to keep precise info at the end
     if (!HighFidelityPreMix) {
       signal.setPreciseSize(0);
     }
 
     if (keep)
       CaloHitResponse::add(signal);
   }
 }

int HcalSiPMHitResponse::getReadoutFrameSize ( const DetId & id ) const

virtual

Definition at line 41 of file HcalSiPMHitResponse.cc.

References CaloHitResponse::BUNCHSPACE, HighFidelityPreMix, HcalPulseShapes::invDeltaTSiPM_, PreMixDigis, CaloSimParameters::readoutFrameSize(), CaloVSimParameterMap::simParameters(), and CaloHitResponse::theParameterMap.

Referenced by add(), addPEnoise(), and makeBlankSignal().

                                                                   {
   const CaloSimParameters& parameters = theParameterMap->simParameters(id);
   int readoutFrameSize = parameters.readoutFrameSize();
   if (PreMixDigis and HighFidelityPreMix) {
     //preserve fidelity of time info
     readoutFrameSize *= BUNCHSPACE * HcalPulseShapes::invDeltaTSiPM_;
   }
   return readoutFrameSize;
 }

void HcalSiPMHitResponse::initializeHits ( )

overridevirtual

Initialize hits.

Reimplemented from CaloHitResponse.

Definition at line 39 of file HcalSiPMHitResponse.cc.

References precisionTimedPhotons.

39 { precisionTimedPhotons.clear(); }

HcalSiPMHitResponse::precisionTimedPhotons

photonTimeMap precisionTimedPhotons

Definition: HcalSiPMHitResponse.h:60

CaloSamples HcalSiPMHitResponse::makeBlankSignal ( const DetId & detId ) const

virtual

Definition at line 184 of file HcalSiPMHitResponse.cc.

References CaloSimParameters::binOfMaximum(), dt, getReadoutFrameSize(), nbins, CaloSamples::presamples(), mps_fire::result, CaloSamples::setPrecise(), CaloSamples::setPresamples(), CaloVSimParameterMap::simParameters(), and CaloHitResponse::theParameterMap.

Referenced by makeSiPMSignal().

                                                                          {
   const CaloSimParameters& parameters = theParameterMap->simParameters(detId);
   int readoutFrameSize = getReadoutFrameSize(detId);
   int preciseSize(readoutFrameSize * nbins);
   CaloSamples result(detId, readoutFrameSize, preciseSize);
   result.setPresamples(parameters.binOfMaximum() - 1);
   result.setPrecise(result.presamples() * nbins, dt);
   return result;
 }

CaloSamples HcalSiPMHitResponse::makeSiPMSignal	(	DetId const &	id,
		photonTimeHist const &	photons,
		CLHEP::HepRandomEngine *	engine
	)

protectedvirtual

Definition at line 194 of file HcalSiPMHitResponse.cc.

References HcalSimParameters::doSiPMSmearing(), dt, alignCSCRings::e, HighFidelityPreMix, HcalSiPM::hitCells(), LogDebug, makeBlankSignal(), nbins, HcalSimParameters::pixels(), CaloSamples::preciseAtMod(), CaloSamples::preciseSize(), PreMixDigis, pulse(), CaloSamples::resetPrecise(), HcalSiPM::setCrossTalk(), HcalSiPM::setNCells(), HcalSiPM::setSaturationPars(), HcalSiPM::setTau(), shapeMap, HcalSimParameters::signalShape(), CaloVSimParameterMap::simParameters(), HcalSimParameters::sipmCrossTalk(), HcalSimParameters::sipmNonlinearity(), HcalSimParameters::sipmTau(), CaloHitResponse::theParameterMap, and theSiPM.

Referenced by finalizeHits().

                                                                               {
   const HcalSimParameters& pars = static_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));
   theSiPM.setNCells(pars.pixels(id));
   theSiPM.setTau(pars.sipmTau());
   theSiPM.setCrossTalk(pars.sipmCrossTalk(id));
   theSiPM.setSaturationPars(pars.sipmNonlinearity(id));
 
   //use to make signal
   CaloSamples signal(makeBlankSignal(id));
   int sampleBin(0), preciseBin(0);
   signal.resetPrecise();
   unsigned int pe(0);
   double hitPixels(0.), elapsedTime(0.);
   unsigned int sumPE(0);
   double sumHits(0.);
 
   auto& sipmPulseShape(shapeMap[pars.signalShape(id)]);
 
   std::list<std::pair<double, double> > pulses;
   std::list<std::pair<double, double> >::iterator pulse;
   double timeDiff, pulseBit;
   LogDebug("HcalSiPMHitResponse") << "makeSiPMSignal for " << HcalDetId(id);
 
   for (unsigned int tbin(0); tbin < photonTimeBins.size(); ++tbin) {
     pe = photonTimeBins[tbin];
     sumPE += pe;
     preciseBin = tbin;
     sampleBin = preciseBin / nbins;
     if (pe > 0) {
       //skip saturation/recovery and pulse smearing for premix stage 1
       if (PreMixDigis and HighFidelityPreMix) {
         signal[sampleBin] += pe;
         signal.preciseAtMod(preciseBin) += pe;
         elapsedTime += dt;
         continue;
       }
 
       hitPixels = theSiPM.hitCells(engine, pe, 0., elapsedTime);
       sumHits += hitPixels;
       LogDebug("HcalSiPMHitResponse") << " elapsedTime: " << elapsedTime << " sampleBin: " << sampleBin
                                       << " preciseBin: " << preciseBin << " pe: " << pe << " hitPixels: " << hitPixels;
       if (pars.doSiPMSmearing()) {
         pulses.push_back(std::pair<double, double>(elapsedTime, hitPixels));
       } else {
         signal[sampleBin] += hitPixels;
         signal.preciseAtMod(preciseBin) += 0.6 * hitPixels;
         if (preciseBin > 0)
           signal.preciseAtMod(preciseBin - 1) += 0.2 * hitPixels;
         if (preciseBin < signal.preciseSize() - 1)
           signal.preciseAtMod(preciseBin + 1) += 0.2 * hitPixels;
       }
     }
 
     if (pars.doSiPMSmearing()) {
       pulse = pulses.begin();
       while (pulse != pulses.end()) {
         timeDiff = elapsedTime - pulse->first;
         pulseBit = sipmPulseShape(timeDiff) * pulse->second;
         LogDebug("HcalSiPMHitResponse") << " pulse t: " << pulse->first << " pulse A: " << pulse->second
                                         << " timeDiff: " << timeDiff << " pulseBit: " << pulseBit;
         signal[sampleBin] += pulseBit;
         signal.preciseAtMod(preciseBin) += pulseBit;
 
         if (timeDiff > 1 && sipmPulseShape(timeDiff) < 1e-7)
           pulse = pulses.erase(pulse);
         else
           ++pulse;
       }
     }
     elapsedTime += dt;
   }
 
   return signal;
 }