SimPmtM64 Class Reference

#include <SimPmtM64.h>

Inheritance diagram for SimPmtM64:

List of all members.

Public Member Functions
	SimPmtM64 (PlexPixelSpotId tube, VldContext context, TRandom *random=NULL)
virtual	~SimPmtM64 ()
virtual void	Reset (const VldContext &context)
virtual Pmt_t	GetType () const
virtual void	Print (Option_t *option="") const
virtual Int_t	TimeToBucket (Double_t time)
virtual Double_t	BucketToStartTime (Int_t bucket)
virtual Double_t	BucketToStopTime (Int_t bucket)
virtual Float_t	GetBucketDuration (Int_t bucket=0)
virtual Float_t	GetDynodeGain () const
virtual void	SimulateOpticalXtalk ()
virtual Float_t	GenDarkNoiseCharge (Int_t pixel, Float_t timeWindow)
virtual Float_t	GenNonlinearCharge (Int_t pixel, Float_t inCharge)
virtual Float_t	GenChargeFromPE (Int_t pixel, Int_t spot, Float_t pe)
virtual Float_t	GenElectricalCrosstalk (Int_t injPixel, Int_t xtalkPixel, Float_t injCharge)
Public Attributes
SimQieClock	fQieClock
float	fPixelGains [65]
float	fPixelSecEmm [65]
Static Public Attributes
SimPmtM64CrosstalkTable *	fsCrosstalkTable = NULL

---

Constructor & Destructor Documentation

SimPmtM64::SimPmtM64 (  PlexPixelSpotId  tube, VldContext  context, TRandom *  random = NULL )

Definition at line 16 of file SimPmtM64.cxx. : SimPmt(tube,context,random,64,1), fQieClock(context) { // Constructor. // Single global reference to the crosstalk table. // This assumes that the crosstalk table has no validity // changes; may need to change this in the future. // // Note that this is a global memory leak, too. Really should // think about fixing it. if(fsCrosstalkTable == NULL) { fsCrosstalkTable = new SimPmtM64CrosstalkTable(context); }; // Build cache of gains/widths. Double_t g, w; for(Int_t pix = 1; pix <= fNPixels; pix++) { GetGainAndWidth(pix, 1, g, w); // Protect against crazy widths: if(w>0.8) w = 0.8; // The secondary emmission ratio is directly related // to the width of the 1pe peak. // In fact, this is 1/(w^2) where w is the fractional // width of the 1pe peak. Float_t secemm = 1.0/(w*w); if(w>0.8) w = 0.8; fPixelGains[pix] = g; // Gain fPixelSecEmm[pix] = secemm; // secondary emmission ratio. }; }

virtual SimPmtM64::~SimPmtM64 (   )  [inline, virtual]

Definition at line 15 of file SimPmtM64.h. {};

---

Member Function Documentation

Double_t SimPmtM64::BucketToStartTime (  Int_t  bucket  )  [virtual]

Reimplemented from SimPmt. Definition at line 73 of file SimPmtM64.cxx. References fQieClock, and SimQieClock::GetTimeOfBucket(). Referenced by SimPmtM64Oxford::SimulateAnodeEffects(), and SimPmtM64Full::SimulateCharges(). { // Use the QIE clock to assign time buckets. return fQieClock.GetTimeOfBucket(bucket); }

Double_t SimPmtM64::BucketToStopTime (  Int_t  bucket  )  [virtual]

Reimplemented from SimPmt. Definition at line 79 of file SimPmtM64.cxx. References fQieClock, and SimQieClock::GetTimeOfBucket(). Referenced by SimPmtM64Oxford::SimulateAnodeEffects(), and SimPmtM64Full::SimulateCharges(). { // Use the QIE clock to assign time buckets. return fQieClock.GetTimeOfBucket(bucket+1); }

Float_t SimPmtM64::GenChargeFromPE (  Int_t  pixel, Int_t  spot, Float_t  pe )  [virtual]

Reimplemented from SimPmt. Reimplemented in SimPmtM64Oxford. Definition at line 128 of file SimPmtM64.cxx. References fPixelGains, fPixelSecEmm, MSG, and SimPmt::RandomGenPoisson(). Referenced by SimPmtM64Full::SimulateCharges(). { // // Does a single charge simulation. // // First version, by Nathaniel. // Uses the generalized poisson to get the job done. // Shortcut: saves a lot of unneccessary random number generation. // Note that there is no intrinsic charge resolution in the PMT // with this method. if(pe<=0) return 0; Float_t gain = fPixelGains[pixel]; Float_t secemm = fPixelSecEmm[pixel]; // Choose a random number from the spectrum with a peak at the number of expected 2nary pes. Float_t mean2ndaryPe = pe * secemm; Float_t secondary_pe = RandomGenPoisson(mean2ndaryPe); MSG("DetSim",Msg::kVerbose) << "Rolled: " << pe << " pe -> " << secondary_pe / secemm << " charge" << " with " << gain << " gain" << endl; // convert this into charge. Float_t q = (secondary_pe / secemm) // charge in pe at anode * gain // Gain of pixel (unitless) * Munits::e_SI; // e to charge return q; }

Float_t SimPmtM64::GenDarkNoiseCharge (  Int_t  pixel, Float_t  timeWindow )  [virtual]

Reimplemented from SimPmt. Definition at line 159 of file SimPmtM64.cxx. { // // Dark noise simulation. // // Return the charge (in fC) that results from opening an integration gate of duration timeWindow (in Munits). // (This should return zero most of the time). // // No simulation yet. return 0; }

Float_t SimPmtM64::GenElectricalCrosstalk (  Int_t  injPixel, Int_t  xtalkPixel, Float_t  injCharge )  [virtual]

Reimplemented from SimPmt. Definition at line 263 of file SimPmtM64.cxx. References SimPmtM64CrosstalkTable::fElecFrac, SimPmtM64CrosstalkTable::fElecK, and fsCrosstalkTable. { // // Electrical crosstalk simulation. // // If inCharge femtoCoulombs of charge are seen on the anode of injPixel, then // this returns the quantity of charge that will be leaked to xtalkPixel. // This may be a random quantity, or a fixed fraction, depending on the model. // If no charge, do nothing: if(injCharge <= 0) return 0; float frac = fsCrosstalkTable->fElecFrac[injPixel][xPixel]; float k = fsCrosstalkTable->fElecK[injPixel][xPixel]; frac *= fsPmtScaleChargeCrosstalk; // A fraction of the charge leaks. float charge = frac*injCharge; // The fraction might be variable, rather than constant. // If so, choose it from a distribution of width // proportional to the square root of the charge. // Don't bother with variability if it won't matter at the ~ 2 ADC level. const float kMinVariance2 = (2.0*Munits::fC)*(2.0*Munits::fC); float width2 = fabs(k*charge); if(width2 > kMinVariance2 ){ float width = sqrt(width2); return fRandom->Gaus(charge,width); }; return charge; }

Float_t SimPmtM64::GenNonlinearCharge (  Int_t  pixel, Float_t  inCharge )  [virtual]

Reimplemented from SimPmt. Reimplemented in SimPmtM64Oxford, and SimPmtM64ToyNL. Definition at line 173 of file SimPmtM64.cxx. { // // Nonlinearity Simulation. // // Given a charge on the anode, this routine applies // the nonlinearity for the PMT to give a new output charge. // // For a completely linear response, return inCharge. return inCharge; }

Float_t SimPmtM64::GetBucketDuration (  Int_t  bucket = 0  )  [virtual]

Reimplemented from SimPmt. Definition at line 86 of file SimPmtM64.cxx. References SimQieClock::fNDTick, and fQieClock. { return fQieClock.fNDTick; }

virtual Float_t SimPmtM64::GetDynodeGain (   )  const [inline, virtual]

Reimplemented from SimPmt. Definition at line 29 of file SimPmtM64.h. { return 0.8; }; // Gain relative to anode.

virtual Pmt_t SimPmtM64::GetType (   )  const [inline, virtual]

Reimplemented from SimPmt. Definition at line 19 of file SimPmtM64.h. { return SimPmt::kM64; };

void SimPmtM64::Print (  Option_t *  option = ""  )  const [virtual]

Reimplemented from SimPmt. Definition at line 91 of file SimPmtM64.cxx. References PlexPixelSpotId::AsString(), SimPmtBucketIterator::BucketId(), SimPmtBucketIterator::End(), SimPmt::GetCharge(), SimPmt::GetPe(), and SimPmtBucketIterator::Next(). { printf(" SimPmtM64::Print() -- Tube: %s\n",fTube.AsString("t")); SimPmtBucketIterator it(*(SimPmt*)this); printf(" Photoelectrons(Npe) Charge (fC) \n"); for( ; !it.End(); it.Next() ) { int ibucket = it.BucketId(); printf(" ---------------------------Time bucket %d----------------------\n",ibucket); for(int row=0; row < 8; row++) { printf(" %3.0f %3.0f %3.0f %3.0f %3.0f %3.0f %3.0f %3.0f", GetPe(row*8+1,1,ibucket), GetPe(row*8+2,1,ibucket), GetPe(row*8+3,1,ibucket), GetPe(row*8+4,1,ibucket), GetPe(row*8+5,1,ibucket), GetPe(row*8+6,1,ibucket), GetPe(row*8+7,1,ibucket), GetPe(row*8+8,1,ibucket)); printf(" | %5.0f %5.0f %5.0f %5.0f %5.0f %5.0f %5.0f %5.0f", GetCharge(row*8+1,ibucket)/Munits::fC, GetCharge(row*8+2,ibucket)/Munits::fC, GetCharge(row*8+3,ibucket)/Munits::fC, GetCharge(row*8+4,ibucket)/Munits::fC, GetCharge(row*8+5,ibucket)/Munits::fC, GetCharge(row*8+6,ibucket)/Munits::fC, GetCharge(row*8+7,ibucket)/Munits::fC, GetCharge(row*8+8,ibucket)/Munits::fC); printf("\n"); } } printf("\n"); }

void SimPmtM64::Reset (  const VldContext &  context  )  [virtual]

Reimplemented from SimPmt. Reimplemented in SimPmtM64Oxford. Definition at line 53 of file SimPmtM64.cxx. References fQieClock, fsCrosstalkTable, SimPmt::Reset(), SimPmtM64CrosstalkTable::Reset(), and SimQieClock::Reset(). Referenced by SimPmtM64Oxford::Reset(). { // Reset the PMT for a new event. // Reset the clock: fQieClock.Reset(context); // Make sure database is up-to-date if(fsCrosstalkTable) fsCrosstalkTable->Reset(context); else fsCrosstalkTable = new SimPmtM64CrosstalkTable(context); // Reset the data: SimPmt::Reset(context); }

void SimPmtM64::SimulateOpticalXtalk (   )  [virtual]

Reimplemented from SimPmt. Definition at line 189 of file SimPmtM64.cxx. References SimPmtBucketIterator::Bucket(), SimPmt::CopyPEtoPEXtalk(), SimPmtBucketIterator::End(), SimPmtM64CrosstalkTable::fOptDist, SimPmtM64CrosstalkTable::fOptTotProb, fsCrosstalkTable, SimPixelTimeBucket::GetPE(), SimPmtTimeBucket::GetPixelBucket(), SimPmt::MoveOpticalPE(), MSG, SimPmtBucketIterator::Next(), and SimPixelTimeBucket::SetTruthBit(). Referenced by SimPmtM64Oxford::SimulatePmt(). { // // Puts extra PE into pixels they don't belong. // // Hack! // This can be uncommented to make a big dump file of the crosstalk. //static ofstream ofile("m64xtalk.dat"); // Iterate over all time buckets. for(SimPmtBucketIterator it(*this); !it.End(); it.Next()) { SimPmtTimeBucket& pmttb = it.Bucket(); // Iterate over talking pixels. for(Int_t injPix = 1; injPix <= fNPixels; injPix++) { SimPixelTimeBucket& pixtb_inj = pmttb.GetPixelBucket(injPix); // Only one spot (spot 1) per pixel. float injPE = pixtb_inj.GetPE(1); if( injPE > 0) { // There is charge in this spot. // Roll how many pe get crosstalked out of this pixel. float prob = fsCrosstalkTable->fOptTotProb[injPix]; prob *= fsPmtScaleOpticalCrosstalk; // Scale factor. float ttalk = fRandom->Poisson(prob*injPE); // Number of photons talked out int ntalk = TMath::Nint(ttalk); // ditto, as an integer for(int ipe=0;ipe<ntalk;ipe++) { // Move the photons around. // Choose the talked-to pixel. int whichPix = injPix; float r = fRandom->Uniform(); for(Int_t xPix = 1; xPix <= fNPixels; xPix++) { if(r<fsCrosstalkTable->fOptDist[injPix][xPix]) { whichPix=xPix; break; } } if(whichPix==injPix){ MSG("DetSim",Msg::kWarning) << "Random number error choosing xtalk pixel."; continue; } // Debugging hack continued. //ofile << injPix << "\t" // << xpix << "\t" << pixtb_inj.GetPE(injSpot) << endl; SimPixelTimeBucket& pixtb = pmttb.GetPixelBucket(whichPix); // Move a photoelectron. MoveOpticalPE(1, // move 1 pe pixtb_inj,1, // from pix, spot pixtb, 1 ); // to pix, spot pixtb.SetTruthBit(DigiSignal::kCrosstalkOptical); } // Itr over talked pe } } // Itr over inj pixel // Now we're done with all pixels in the bucket. } // it over buckets // whew! // Copy whatever didn't crosstalk. CopyPEtoPEXtalk(); }

Int_t SimPmtM64::TimeToBucket (  Double_t  time  )  [virtual]

Reimplemented from SimPmt. Definition at line 67 of file SimPmtM64.cxx. References fQieClock, and SimQieClock::GetBucketForTime(). { // Use the QIE clock to assign time buckets. return fQieClock.GetBucketForTime(time); }

---

Member Data Documentation

float SimPmtM64::fPixelGains[65]

Definition at line 43 of file SimPmtM64.h. Referenced by GenChargeFromPE().

float SimPmtM64::fPixelSecEmm[65]

Definition at line 44 of file SimPmtM64.h. Referenced by GenChargeFromPE().

SimQieClock SimPmtM64::fQieClock

Definition at line 40 of file SimPmtM64.h. Referenced by BucketToStartTime(), BucketToStopTime(), GetBucketDuration(), Reset(), and TimeToBucket().

SimPmtM64CrosstalkTable * SimPmtM64::fsCrosstalkTable = NULL [static]

Definition at line 14 of file SimPmtM64.cxx. Referenced by GenElectricalCrosstalk(), Reset(), and SimulateOpticalXtalk().

---

The documentation for this class was generated from the following files:

• SimPmtM64.h
• SimPmtM64.cxx

---