#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
virtual void	add (const PCaloHit &hit, CLHEP::HepRandomEngine *) override
	process a single SimHit More...

virtual void	add (const CaloSamples &signal)

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

	HcalSiPMHitResponse (const CaloVSimParameterMap parameterMap, const CaloShapes shapes)

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

virtual CaloSamples	makeBlankSignal (const DetId &detId) const

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

virtual	~HcalSiPMHitResponse ()

Public Member Functions inherited from CaloHitResponse
void	add (const CaloSamples &signal)
	add a signal, in units of pe More...

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)

	CaloHitResponse (const CaloVSimParameterMap parameterMap, const CaloShapes shapes)

void	clear ()
	frees up memory More...

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

void	initHBHEScale ()

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...

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	setHBHEScale (std::string &)

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

void	setHitFilter (const CaloVHitFilter *filter)
	if you want to reject hits, for example, from a certain subdetector, set this More...

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...

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...

Static Public Member Functions
static double	Y11TimePDF (double t)

Protected Types
typedef std::multiset < PCaloHit, PCaloHitCompareTimes >	SortedHitSet

Protected Member Functions
virtual void	differentiatePreciseSamples (CaloSamples &samples, double diffNorm=1.0) const

double	generatePhotonTime (CLHEP::HepRandomEngine *) const

virtual CaloSamples	makeSiPMSignal (const DetId &id, const PCaloHit &hit, int &integral, CLHEP::HepRandomEngine *) const

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

Private Attributes
photonTimeMap	precisionTimedPhotons

float	theDiffNorm

double	theRecoveryTime

HcalSiPM *	theSiPM

HcalTDCParameters	theTDCParams

int const	TIMEMULT

float const	Y11MAX

float const	Y11RANGE

float const	Y11TIMETORISE

Additional Inherited Members
Protected Attributes inherited from CaloHitResponse
bool	changeScale

float	hcal_en_scale [100][72][4]

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 27 of file HcalSiPMHitResponse.h.

Member Typedef Documentation

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

Definition at line 35 of file HcalSiPMHitResponse.h.

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

Definition at line 36 of file HcalSiPMHitResponse.h.

typedef std::multiset<PCaloHit, PCaloHitCompareTimes> HcalSiPMHitResponse::SortedHitSet

protected

Definition at line 53 of file HcalSiPMHitResponse.h.

Constructor & Destructor Documentation

HcalSiPMHitResponse::HcalSiPMHitResponse	(	const CaloVSimParameterMap *	parameterMap,
		const CaloShapes *	shapes
	)

Definition at line 20 of file HcalSiPMHitResponse.cc.

References theSiPM.

                                                 :
   CaloHitResponse(parameterMap, shapes), theSiPM(), theRecoveryTime(250.), 
   TIMEMULT(1), Y11RANGE(80.), Y11MAX(0.04), Y11TIMETORISE(16.65) {
   theSiPM = new HcalSiPM(2500);
 }

HcalSiPMHitResponse::~HcalSiPMHitResponse ( )

virtual

Definition at line 27 of file HcalSiPMHitResponse.cc.

References theSiPM.

                                           {
   if (theSiPM)
     delete theSiPM;
 }

Member Function Documentation

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

overridevirtual

process a single SimHit

Reimplemented from CaloHitResponse.

Definition at line 71 of file HcalSiPMHitResponse.cc.

References CaloVHitFilter::accepts(), CaloHitResponse::analogSignalAmplitude(), CaloHitResponse::BUNCHSPACE, CaloVHitCorrection::delay(), HcalTDCParameters::deltaT(), PCaloHit::energy(), generatePhotonTime(), PCaloHit::id(), edm::isNotFinite(), LogDebug, HcalTDCParameters::nbins(), interactiveExample::photons, precisionTimedPhotons, CaloVSimParameterMap::simParameters(), findQualityFiles::size, CaloHitResponse::theHitCorrection, CaloHitResponse::theHitFilter, CaloHitResponse::theParameterMap, CaloHitResponse::thePhaseShift_, theTDCParams, PCaloHit::time(), TIMEMULT, CaloHitResponse::timeOfFlight(), tzero, and Y11TIMETORISE.

Referenced by finalizeHits(), counter.Counter::register(), and run().

                                                                                {
     if (!edm::isNotFinite(hit.time()) &&
     ((theHitFilter == 0) || (theHitFilter->accepts(hit)))) {
       HcalDetId id(hit.id());
       const HcalSimParameters& pars = dynamic_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));
       double signal(analogSignalAmplitude(id, hit.energy(), pars, engine));
       unsigned int photons(signal + 0.5);
       double time( hit.time() );
 
       if (photons > 0)
     if (precisionTimedPhotons.find(id)==precisionTimedPhotons.end()) {
       precisionTimedPhotons.insert(
         std::pair<DetId, photonTimeHist >(id, 
           photonTimeHist(theTDCParams.nbins() * TIMEMULT *
                  pars.readoutFrameSize(), 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;
       if (theHitCorrection != 0)
     time += theHitCorrection->delay(hit, engine);
       LogDebug("HcalSiPMHitResponse") << " corrected time: " << time;
       LogDebug("HcalSiPMHitResponse") << " timePhase: " << pars.timePhase()
         << " tof: " << timeOfFlight(id)
         << " binOfMaximum: " << pars.binOfMaximum()
         << " phaseShift: " << thePhaseShift_;
       double tzero(Y11TIMETORISE + pars.timePhase() - 
            (hit.time() - timeOfFlight(id)) - 
            BUNCHSPACE*( pars.binOfMaximum() - thePhaseShift_));
       LogDebug("HcalSiPMHitResponse") << " tzero: " << tzero;
       // tzero += BUNCHSPACE*pars.binOfMaximum() + 75.;
       //move it back 25ns to bin 4
       tzero += BUNCHSPACE*pars.binOfMaximum() + 50.;
       LogDebug("HcalSiPMHitResponse") << " corrected tzero: " << tzero << '\n';
       double t_pe(0.);
       int t_bin(0);
       for (unsigned int pe(0); pe<photons; ++pe) {
     t_pe = generatePhotonTime(engine);
     t_bin = int((t_pe + tzero)/(theTDCParams.deltaT()/TIMEMULT) + 0.5);
     LogDebug("HcalSiPMHitResponse") << "t_pe: " << t_pe << " t_pe + tzero: " << (t_pe+tzero)
           << " 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 )

virtual

Definition at line 61 of file HcalSiPMHitResponse.cc.

References CaloHitResponse::findSignal(), CaloSamples::id(), and CaloHitResponse::theAnalogSignalMap.

Referenced by counter.Counter::register().

                                                        {
   DetId id(signal.id());
   CaloSamples * oldSignal = findSignal(id);
   if (oldSignal == 0) {
     theAnalogSignalMap[id] = signal;
   } else {
     (*oldSignal) += signal;
   }
 }

void HcalSiPMHitResponse::differentiatePreciseSamples	(	CaloSamples &	samples,
		double	diffNorm = `1.0`
	)		const

protectedvirtual

Definition at line 288 of file HcalSiPMHitResponse.cc.

References i, CaloSamples::preciseAtMod(), CaloSamples::preciseDeltaT(), and CaloSamples::preciseSize().

                                                      {
   static double const invdt(1./samples.preciseDeltaT());
   // double dy(0.);
   for (int i(0); i < samples.preciseSize(); ++i) {
     // dy = samples.preciseAt(i+1) - samples.preciseAt(i);
     samples.preciseAtMod(i) *= invdt*diffNorm;
   }
 }

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

overridevirtual

Finalize hits.

Reimplemented from CaloHitResponse.

Definition at line 36 of file HcalSiPMHitResponse.cc.

References add(), i, CaloSamples::id(), keep, CaloHitResponse::keepBlank(), LogDebug, makeSiPMSignal(), precisionTimedPhotons, CaloSamples::size(), and findQualityFiles::size.

                                                                    {
 
   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;
     // std::cout << HcalDetId(signal.id()) << ' ' << signal;
     if (keep) add(signal);
   }
 }

double HcalSiPMHitResponse::generatePhotonTime ( CLHEP::HepRandomEngine * engine ) const

protected

Definition at line 298 of file HcalSiPMHitResponse.cc.

References mps_fire::result, Y11MAX, Y11RANGE, and Y11TimePDF().

Referenced by add().

                                                                                  {
   double result(0.);
   while (true) {
     result = CLHEP::RandFlat::shoot(engine, Y11RANGE);
     if (CLHEP::RandFlat::shoot(engine, Y11MAX) < Y11TimePDF(result))
       return result;
   }
 }

void HcalSiPMHitResponse::initializeHits ( )

virtual

Initialize hits.

Reimplemented from CaloHitResponse.

Definition at line 32 of file HcalSiPMHitResponse.cc.

References precisionTimedPhotons.

                                          {
   precisionTimedPhotons.clear();
 }

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

virtual

Definition at line 159 of file HcalSiPMHitResponse.cc.

References CaloSimParameters::binOfMaximum(), HcalTDCParameters::deltaT(), HcalTDCParameters::nbins(), HLT_FULL_cff::parameters, CaloSimParameters::readoutFrameSize(), mps_fire::result, CaloVSimParameterMap::simParameters(), CaloHitResponse::theParameterMap, and theTDCParams.

Referenced by makeSiPMSignal().

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

CaloSamples HcalSiPMHitResponse::makeSiPMSignal	(	const DetId &	id,
		const PCaloHit &	hit,
		int &	integral,
		CLHEP::HepRandomEngine *	engine
	)		const

protectedvirtual

Definition at line 169 of file HcalSiPMHitResponse.cc.

References CaloHitResponse::analogSignalAmplitude(), newFWLiteAna::bin, CaloSimParameters::binOfMaximum(), CaloHitResponse::BUNCHSPACE, CaloVHitCorrection::delay(), PCaloHit::energy(), HcalSiPM::hitCells(), makeBlankSignal(), interactiveExample::photons, HcalSimParameters::pixels(), mps_fire::result, HcalSiPM::setNCells(), PCaloHit::setTime(), CaloShapes::shape(), CaloVSimParameterMap::simParameters(), CaloSamples::size(), CaloHitResponse::theHitCorrection, CaloHitResponse::theParameterMap, CaloHitResponse::thePhaseShift_, CaloHitResponse::theShapes, theSiPM, PCaloHit::time(), CaloHitResponse::timeOfFlight(), CaloSimParameters::timePhase(), and tzero.

Referenced by finalizeHits(), and run().

                                                                                     {
   
   PCaloHit hit = inHit;
   if (theHitCorrection != 0) {
     hit.setTime(hit.time() + theHitCorrection->delay(hit, engine));
   }
 
   const HcalSimParameters& pars = dynamic_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));
   theSiPM->setNCells(pars.pixels());
 
   double signal = analogSignalAmplitude(id, hit.energy(), pars, engine);
   int photons = static_cast<int>(signal + 0.5);
   int pixels = theSiPM->hitCells(engine, photons, integral);
   integral += pixels;
   signal = double(pixels);
 
   CaloSamples result(makeBlankSignal(id));
 
   if(pixels > 0)
   {
     const CaloVShape * shape = theShapes->shape(id);
     double jitter = hit.time() - timeOfFlight(id);
 
     const double tzero = pars.timePhase() - jitter -
       BUNCHSPACE*(pars.binOfMaximum() - thePhaseShift_);
     double binTime = tzero;
 
     for (int bin = 0; bin < result.size(); bin++) {
       result[bin] += (*shape)(binTime)*signal;
       binTime += BUNCHSPACE;
     }
   }
 
   return result;
 }

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

protectedvirtual

Definition at line 208 of file HcalSiPMHitResponse.cc.

References HcalTDCParameters::deltaT(), HcalSimParameters::doSiPMSmearing(), dt, alignCSCRings::e, HcalSiPM::hitCells(), makeBlankSignal(), HcalTDCParameters::nbins(), HcalSimParameters::pixels(), CaloSamples::preciseAtMod(), CaloSamples::preciseSize(), EnergyCorrector::pt, CaloSamples::resetPrecise(), HcalSiPM::setNCells(), HcalSiPM::setTau(), CaloVSimParameterMap::simParameters(), CaloHitResponse::theParameterMap, theSiPM, theTDCParams, and TIMEMULT.

                                                                                     {
   const HcalSimParameters& pars = dynamic_cast<const HcalSimParameters&>(theParameterMap->simParameters(id));  
   theSiPM->setNCells(pars.pixels());
   theSiPM->setTau(5.);
   //use to make signal
   CaloSamples signal( makeBlankSignal(id) );
   double const dt(theTDCParams.deltaT()/TIMEMULT);
   double const invdt(1./theTDCParams.deltaT());
   int sampleBin(0), preciseBin(0);
   signal.resetPrecise();
   unsigned int pe(0);
   double hitPixels(0.), elapsedTime(0.);
   unsigned int sumPE(0);
   double sumHits(0.);
 
   HcalSiPMShape sipmPulseShape;
 
   std::list< std::pair<double, double> > pulses;
   std::list< std::pair<double, double> >::iterator pulse;
   double timeDiff, pulseBit;
   // std::cout << HcalDetId(id) << '\n';
   for (unsigned int pt(0); pt < photons.size(); ++pt) {
     pe = photons[pt];
     sumPE += pe;
     preciseBin = pt/TIMEMULT;
     sampleBin = preciseBin/theTDCParams.nbins();
     if (pe > 0) {
       hitPixels = theSiPM->hitCells(engine, pe, 0., elapsedTime);
       sumHits += hitPixels;
       // std::cout << " elapsedTime: " << elapsedTime
       //        << " sampleBin: " << sampleBin
       //        << " preciseBin: " << preciseBin
       //        << " pe: " << pe 
       //        << " hitPixels: " << hitPixels 
       //        << '\n';
       if (pars.doSiPMSmearing()) {
     pulses.push_back( std::pair<double, double>(elapsedTime, hitPixels) );
       } else {
     signal[sampleBin] += hitPixels;
     hitPixels *= invdt;
     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;
     // std::cout << "pulse t: " << pulse->first 
     //      << " pulse A: " << pulse->second
     //      << " timeDiff: " << timeDiff
     //      << " pulseBit: " << pulseBit 
     //      << '\n';
     signal[sampleBin] += pulseBit;
     signal.preciseAtMod(preciseBin) += pulseBit*invdt;
     if (sipmPulseShape(timeDiff) < 1e-6)
       pulse = pulses.erase(pulse);
     else
       ++pulse;
       }
     }
     elapsedTime += dt;
   }
 
   // differentiatePreciseSamples(signal, 1.);
 
   // std::cout << "sum pe: " << sumPE 
   //        << " sum sipm pixels: " << sumHits
   //        << std::endl;
   
   return signal;
 }

void HcalSiPMHitResponse::run	(	MixCollection< PCaloHit > &	hits,
		CLHEP::HepRandomEngine *	engine
	)

overridevirtual

Complete cell digitization.

Reimplemented from CaloHitResponse.

Definition at line 127 of file HcalSiPMHitResponse.cc.

References CaloVHitFilter::accepts(), add(), HcalSiPMRecovery::addToHistory(), MixCollection< T >::begin(), HcalSiPMRecovery::clearHistory(), MixCollection< T >::end(), HcalSiPMRecovery::getIntegral(), i, edm::isNotFinite(), makeSiPMSignal(), CaloHitResponse::theHitFilter, CaloHitResponse::theMaxBunch, CaloHitResponse::theMinBunch, theRecoveryTime, and PCaloHit::time().

                                                                                           {
   typedef std::multiset <const PCaloHit *, PCaloHitCompareTimes> SortedHitSet;
 
   std::map< DetId, SortedHitSet > sortedhits;
   for (MixCollection<PCaloHit>::MixItr hitItr = hits.begin();
        hitItr != hits.end(); ++hitItr) {
     if (!((hitItr.bunch() < theMinBunch) || (hitItr.bunch() > theMaxBunch)) &&
         !(edm::isNotFinite(hitItr->time())) &&
         ((theHitFilter == 0) || (theHitFilter->accepts(*hitItr)))) {
       DetId id(hitItr->id());
       if (sortedhits.find(id)==sortedhits.end())
         sortedhits.insert(std::pair<DetId, SortedHitSet>(id, SortedHitSet()));
       sortedhits[id].insert(&(*hitItr));
     }
   }
   int pixelIntegral, oldIntegral;
   HcalSiPMRecovery pixelHistory(theRecoveryTime);
   for (std::map<DetId, SortedHitSet>::iterator i = sortedhits.begin(); 
        i!=sortedhits.end(); ++i) {
     pixelHistory.clearHistory();
     for (SortedHitSet::iterator itr = i->second.begin(); 
      itr != i->second.end(); ++itr) {
       const PCaloHit& hit = **itr;
       pixelIntegral = pixelHistory.getIntegral(hit.time());
       oldIntegral = pixelIntegral;
       CaloSamples signal(makeSiPMSignal(i->first, hit, pixelIntegral, engine));
       pixelHistory.addToHistory(hit.time(), pixelIntegral-oldIntegral);
       add(signal);
     }
   }
 }

double HcalSiPMHitResponse::Y11TimePDF ( double t )

static

Definition at line 307 of file HcalSiPMHitResponse.cc.

References create_public_lumi_plots::exp, and funct::pow().

Referenced by generatePhotonTime().

                                                {
   return exp(-0.0635-0.1518*t)*pow(t, 2.528)/2485.9;
 }

Member Data Documentation

photonTimeMap HcalSiPMHitResponse::precisionTimedPhotons

private

Definition at line 72 of file HcalSiPMHitResponse.h.

Referenced by add(), finalizeHits(), and initializeHits().

float HcalSiPMHitResponse::theDiffNorm

private

Definition at line 70 of file HcalSiPMHitResponse.h.

double HcalSiPMHitResponse::theRecoveryTime

private

Definition at line 65 of file HcalSiPMHitResponse.h.

Referenced by run().

HcalSiPM* HcalSiPMHitResponse::theSiPM

private

Definition at line 64 of file HcalSiPMHitResponse.h.

Referenced by HcalSiPMHitResponse(), makeSiPMSignal(), and ~HcalSiPMHitResponse().

HcalTDCParameters HcalSiPMHitResponse::theTDCParams

private

Definition at line 73 of file HcalSiPMHitResponse.h.

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

int const HcalSiPMHitResponse::TIMEMULT

private

Definition at line 66 of file HcalSiPMHitResponse.h.

Referenced by add(), and makeSiPMSignal().

float const HcalSiPMHitResponse::Y11MAX

private

Definition at line 68 of file HcalSiPMHitResponse.h.

Referenced by generatePhotonTime().

float const HcalSiPMHitResponse::Y11RANGE

private

Definition at line 67 of file HcalSiPMHitResponse.h.

Referenced by generatePhotonTime().

float const HcalSiPMHitResponse::Y11TIMETORISE

private

Definition at line 69 of file HcalSiPMHitResponse.h.

Referenced by add().

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation