SimPmtM64Oxford Class Reference

#include <SimPmtM64Oxford.h>

Inheritance diagram for SimPmtM64Oxford:

List of all members.

Public Member Functions
	SimPmtM64Oxford (PlexPixelSpotId tube, VldContext context, TRandom *random=NULL)
virtual	~SimPmtM64Oxford ()
virtual void	Reset (const VldContext &context)
virtual void	SimulateCharges ()
virtual void	SimulatePmt ()
virtual void	Config (Registry &config)
Protected Member Functions
virtual Float_t	GenChargeFromPE (Int_t pixel, Int_t spot, Float_t pe)
virtual UInt_t	SimFirstDynodes (Int_t pixel, Int_t nPe)
virtual UInt_t	SimLaterDynodes (Int_t pixel, Int_t neToD3)
virtual Bool_t	CalStageGains ()
virtual void	SimulateAnodeEffects ()
virtual Float_t	GenNonlinearCharge (Int_t pixel, Float_t inCharge)
Static Protected Attributes
static Bool_t	fsPmtDoChargeSmear = true
Private Attributes
Bool_t	fStagesBuilt
Double_t	fStageGains [65][13]
Double_t	fSkippingGain [65]
Bool_t	fOneSpot
VldContext	fLastVldContext
Static Private Attributes
static const Double_t	gkDefaultStageGains [13]
static const Double_t	gkDefaultSecEmmRatio = 4.5
static const Double_t	gkNLWindowBefore = 1.8056 * Munits::ns
static const Double_t	gkNLWindowAfter = 0.9841 * Munits::ns
static Double_t	fsDynodeSkipRate = 0.00
static Double_t	fsNLThreshold = 5
static Double_t	fsNonlinearityScale = 1.5

---

Detailed Description

Definition at line 14 of file SimPmtM64Oxford.h.

---

Constructor & Destructor Documentation

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

Definition at line 38 of file SimPmtM64Oxford.cxx.

References Msg::kFatal, Msg::kWarning, and MSG.

                                                  : 
  SimPmtM64Full(tube,context,random)
{
  // check if multiple spots are active on the tube (probably 
  // fNSpots == 1) i'm trusting that, at the very least, fNSpots is
  //  always  non-zero & positive
  fOneSpot = true;

  fStagesBuilt = false;
      
  if (fNSpots != 1) {
    fOneSpot = false;
    MSG("DetSim",Msg::kWarning) << "This PMT has " << fNSpots 
                                << " spots! Ready for a rough ride?" 
                                << endl;
  }

  //Do some safty checks... hopefully i'll rewrite sensitive bits 
  //with vectors, then we shouldn't need this. But for now: 
  if (fNPixels > 64) {
    //were in big trouble... there pixel arrays going out of bounds
    MSG("DetSim",Msg::kFatal) << "Too many pixels! /n"
                              << "Cant continue without memory carnage!"
                              << endl;
    assert(0);  //Die in dishonor
  }
  
  
  Reset(context);

}

virtual SimPmtM64Oxford::~SimPmtM64Oxford

(

)

[inline, virtual]

Definition at line 21 of file SimPmtM64Oxford.h.

{};

---

Member Function Documentation

Bool_t SimPmtM64Oxford::CalStageGains

(

)

[protected, virtual]

Definition at line 122 of file SimPmtM64Oxford.cxx.

References SimPmt::fNPixels, SimPmt::fNSpots, fOneSpot, fSkippingGain, fStageGains, SimPmt::GetGainAndWidth(), gkDefaultSecEmmRatio, gkDefaultStageGains, Msg::kInfo, and MSG.

Referenced by Reset().

{
  Bool_t success = false;

  //Calculate the default total Gain 
  Double_t DefaultTubeGain = 1;  
  for (Int_t i = 1; i <= 12; i++) {
    DefaultTubeGain *= gkDefaultStageGains[i];
  }

  
  for (Int_t pix = 1 ; pix <= fNPixels ; pix++){
    
    //Initialise the stage gains for each pixels
    for (Int_t i = 0; i <= 12; i++) {
      fStageGains[pix][i] = gkDefaultStageGains[i];
    } 
    
    //Get the gain and width from the database 
    Double_t thisPixelGain = 0;
    Double_t thisPixelWidth = 0;
    
    if ( fOneSpot ) {  
      
      success = GetGainAndWidth(pix, 1, thisPixelGain, thisPixelWidth);
      //cout << "pixel: " << pix << endl;
      //cout << "Gain set to " << thisPixelGain << endl;
      //cout << "Width set to " << thisPixelWidth << endl;;
    }  

    else{      
      //Sum over active spots
      //  as far as i know, there should only ever be one active spot.
      Double_t tempGain = 0;
      Double_t tempWidth = 0;
      Int_t nActiveSpots = 0;
      
      for (Int_t spotit = 1; spotit <= fNSpots; spotit++){
        GetGainAndWidth(pix, spotit, tempGain, tempWidth);
        if (( tempGain > 0 ) && ( tempWidth > 0 )){
          thisPixelGain += tempGain;
          thisPixelWidth += tempWidth;
          nActiveSpots++;
        } //if (spot is okay)
      }  //for (spots)
      
      thisPixelGain /= nActiveSpots;
      thisPixelWidth /= nActiveSpots;
      
    }  // >1 spots (else)

    // Truncate gains to 3 * 10^6 (should be much less)
    if (thisPixelGain > 3e6){
      MSG("DetSim",Msg::kInfo  ) << "Huge gain in DB: " << thisPixelGain 
                                 << "\tTruncating to 3e6" << endl;
      thisPixelGain = 3e6; 
    }
    //Calculate secondary emission (amplification at D1) correction
    //here we are modeling variation in the width of the 1pe peak 
    //as being entirely due to an variation in the first stage gain
  
    //first compute true (as opposed to effective) SecEmmRatio
    //See NuMi NOTE-Scint-934 for details
    
    Double_t secEmmCrtn = 1;
    Double_t effSecEmmRatio = 1/( thisPixelWidth*thisPixelWidth );   //(rho)
    
    //quick(er) method (accurate to ~0.6%, which is plenty)
    //secEmmCrtn = ( (effSecEmmRatio + 0.25) / (gkDefaultSecEmmRatio + 0.25) );

    //cout << "recal : "<< secEmmCrtn <<endl;
    
    //full, slow(er) method
    secEmmCrtn = effSecEmmRatio * ( 1. + sqrt( 1. + 1./effSecEmmRatio ) );
    secEmmCrtn /= gkDefaultSecEmmRatio * (1. + sqrt(1.+1./gkDefaultSecEmmRatio ) );
    //cout << "full recal : "<< secEmmCrtn <<endl;

    fStageGains[pix][1] *= secEmmCrtn; 

    //do inverse correction to other stages to renormalise gain

    secEmmCrtn = pow(secEmmCrtn, 1./11.); 
    
    //cout << "inv recal = "<< 1./secEmmCrtn << endl;

    for(Int_t i = 2; i <= 12; i++){
      fStageGains[pix][i] /= secEmmCrtn;
    } //for (dynodes 2->12)
   
    //calculate skipping gain 
    // using g(skip) = ( g(1)^(1/beta) + g(2)^(1/beta) )^beta
    // with beta = 0.890199
    
    const Double_t beta = 0.890199;  //Measured at test stand

      //cout << "D1 :" <<  fStageGains[pix][1] << endl;
      //cout << "D2 :" <<  fStageGains[pix][2] << endl;

    fSkippingGain[pix] = pow( fStageGains[pix][1], 1./ beta )
      + pow( fStageGains[pix][2], 1./ beta );

    //cout << "skipping gain :" << fSkippingGain[pix] << endl;

    fSkippingGain[pix] = pow( fSkippingGain[pix], beta ); 

    //cout << "skipping gain " << fSkippingGain[pix] << endl;


    //Re-calculate pixel gain

    Double_t gainRatio = 0;
    gainRatio = thisPixelGain / DefaultTubeGain ;
    //cout << "gainratio " << gainRatio << endl;
    
    gainRatio = pow(gainRatio, 1./12.);
    
    //apply correction
    
    for (Int_t i = 0; i <= 12; i++) {
      fStageGains[pix][i] *= gainRatio;
    } 

   
    //Fix the Dynode skipping gains  
    fSkippingGain[pix] =  fSkippingGain[pix] * gainRatio * gainRatio;
    
  } //for (pix)
  
  return success;
}

void SimPmtM64Oxford::Config

(

Registry &

config

)

[virtual]

Reimplemented from SimPmtM64Full.

Definition at line 635 of file SimPmtM64Oxford.cxx.

References SimPmtM64Full::Config(), fsDynodeSkipRate, fsNLThreshold, fsNonlinearityScale, fsPmtDoChargeSmear, SimPmt::fsPmtDoNonlinearity, and Registry::Get().

{
  double dtmp;
  int itmp;
  if(config.Get("pmtDoChargeSmear",itmp)) fsPmtDoChargeSmear = itmp;
  if(config.Get("pmtM64DynodeSkipRate",dtmp)) fsDynodeSkipRate = dtmp;
  if(config.Get("pmtM64NLThreshold",dtmp)) fsNLThreshold = dtmp;
  if(config.Get("pmtM64NonlinearityScale",dtmp)) fsNonlinearityScale =dtmp;

  SimPmtM64Full::Config(config);

  // A non linearity scale of zero is equivalent to no nonlinearity,
  // so turn it off now because it would also cause a FPE.
  // this is quicker than checking each time we go past.  
  if (0 == fsNonlinearityScale) fsPmtDoNonlinearity = 0;
}

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

Reimplemented from SimPmtM64.

Definition at line 255 of file SimPmtM64Oxford.cxx.

References Munits::e_SI, Msg::kError, Msg::kInfo, MSG, SimFirstDynodes(), and SimLaterDynodes().

Referenced by SimulateCharges().

{
  if (spot != 1) {
    MSG("DetSim",Msg::kError) << "Amplifiying a pe in spot "<< spot 
                              << "! This is okay... /n"
                              << "But Non-linearity will fail" 
                              << endl;
  } // spot != 1

  if (pe <= 0) return 0;  
  
  Int_t nPe = (Int_t) pe;

  if (nPe > 1200){
    //Scream like a baby
    MSG("DetSim",Msg::kInfo  ) << "BIG pulse seen: " << nPe 
                               << " photoelectons."
                               << "\tTruncating to 1200" << endl;
    nPe = 1200;
  }
  //this process is divided into two stages: 
  //the first dynodes, where individual photons count
  //the later dynodes, where we don't notice individual photons
  
  
  UInt_t neFromD2 = SimFirstDynodes(pixel, nPe);
  UInt_t neToAnode = SimLaterDynodes(pixel, neFromD2);
  
  return neToAnode * Munits::e_SI;

}

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

Reimplemented from SimPmtM64.

Definition at line 569 of file SimPmtM64Oxford.cxx.

References Munits::e_SI, fsNLThreshold, and fsNonlinearityScale.

Referenced by SimulateAnodeEffects().

{
  //Debug
  //if (fsNonlinearityScale == 0) {cout << "fsnls: exactly 0" << endl;}
  //else {cout << "fsnls: " << fsNonlinearityScale << endl;} 

  //Note on Tuning parameters: threshold(fsNLThreshold) and dGdQ
 
  //Threshold in terms of (approx) number of pes in window.
  //For pulses similar in shape to the oxford test stand, and a ~3ns window
  //the non-linearity `turns on' for pulses sizes (in pe) of ~7 times
  //this threshold.
  
  //dGdQ is the (Default) rate at which the gain drops off at threshold
  //increasing fsNonlinearityScale -> NL turns on more quickly

  Float_t scaleNL = 1.;
  const Float_t qInPe = linCharge / (1e6 * Munits::e_SI);  

  const Float_t dGdQ = 3.9e-3; //Best tune from Test Stand  

  //Exponential drop off model:
  if (qInPe > fsNLThreshold) {
    const Float_t alpha = 2 * dGdQ * fsNonlinearityScale;  
    //makes everything  easier to read. 
    
    scaleNL = 1 - TMath::Exp( -alpha * (qInPe - fsNLThreshold) );
    scaleNL /= alpha * ( qInPe - fsNLThreshold );  

  }  // if (above threshold)

return linCharge * scaleNL;
  
}

void SimPmtM64Oxford::Reset

(

const VldContext &

context

)

[virtual]

Reimplemented from SimPmtM64.

Definition at line 108 of file SimPmtM64Oxford.cxx.

References CalStageGains(), SimPmt::fsRebuildGainMap, fStagesBuilt, and SimPmtM64::Reset().

{
  //Do the inherited M64 reset stuff
  SimPmtM64::Reset(context);
  
  //Reset the gains
  if((!fStagesBuilt)||fsRebuildGainMap) {
    CalStageGains();
    fStagesBuilt = true;
  }
}

UInt_t SimPmtM64Oxford::SimFirstDynodes	(	Int_t	pixel,
		Int_t	nPe
	)			[protected, virtual]

Definition at line 291 of file SimPmtM64Oxford.cxx.

References SimPmt::fRandom, fsDynodeSkipRate, fSkippingGain, and fStageGains.

Referenced by GenChargeFromPE().

{
  //bah. maybe i have to burn random numbers in a binomial to 
  //do this transparently
  //i'm pretty sure this does the same thing though 

  //Simulate 'skipping' path
  Float_t meanSkipping = nPe * fsDynodeSkipRate;
  UInt_t neThatSkip = 
    fRandom->Poisson( meanSkipping * fSkippingGain[pixel] );
  
  //simulate 'normal' path
  Float_t meanElectrons = 6.5;
  UInt_t neFromPrevDynode = nPe ;  //values for saftey

  //at dynode 1
  meanElectrons = fStageGains[pixel][1] * nPe * (1 - fsDynodeSkipRate);
  neFromPrevDynode = (UInt_t) fRandom->PoissonD(meanElectrons);

  //& at dynode 2
  meanElectrons = fStageGains[pixel][2] * neFromPrevDynode;
  neFromPrevDynode = (UInt_t) fRandom->PoissonD(meanElectrons);
                              
  //add in skipping electrons
  neFromPrevDynode += neThatSkip;

  return neFromPrevDynode;
}

UInt_t SimPmtM64Oxford::SimLaterDynodes	(	Int_t	pixel,
		Int_t	neToD3
	)			[protected, virtual]

Definition at line 323 of file SimPmtM64Oxford.cxx.

References SimPmt::fRandom, and fStageGains.

Referenced by GenChargeFromPE().

{
//   Int_t switchPoint = 6;
//   //Change this if you want. It must be >= 3  and <= 12 
//   //speed = low, accuracy = high (recommend >5)


//   //At this dynode, switch from simulating each dynode individually
//   // to simulating everything in one go.
//   //It only works for Gaussian statistics!
//   //The main speed issue is with generating Poisson statisics,
//   //so bigger speed increases can be acheived by switching 
//   //at or before dynode 5. But this nessicerily gives bigger errors.
//   //There's no such thing as a free lunch!

//   //saftey net: switchPoint MUST stay within these bounds.
//   if (switchPoint < 3) switchPoint = 3;  
//   if (switchPoint > 12) switchPoint = 12;  
 
//   Float_t meanElectrons = 29.3;  //Value is just for saftey
//   UInt_t neFromPrevDynode = neToD3;
  
//   for (Int_t i = 3; i < switchPoint ; i++) {
//     meanElectrons = fStageGains[pixel][i] * (Float_t) neFromPrevDynode;
//     neFromPrevDynode = fRandom->Poisson(meanElectrons);
//    }

//   //calculate gaussian mean & width. 
//   // see NuMI note 661 for detail relating to the `extraWidth' calculation
  
//   Float_t extraWidth = 1;
//   Float_t gausGain = fStageGains[pixel][switchPoint];
  
//   for (Int_t i = (switchPoint + 1) ; i <= 12; i++ ) {
//     extraWidth = 1. + ( extraWidth * fStageGains[pixel][i] ); 
//     gausGain *= fStageGains[pixel][i];
//   }
  
//   //do gaussian amplification

//   Float_t gausMean = neFromPrevDynode * gausGain;
//   Float_t gausWidth = sqrt(gausMean * extraWidth);
  
//   neFromPrevDynode = UInt_t(fRandom->Gaus(0,1) *gausWidth + gausMean + 0.5 );
  
//..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  
  //  If you want to do everything properly this does the job:

  Float_t meanElectrons = 29.3;  //Value is just for saftey
  UInt_t neFromPrevDynode = neToD3;
  for (Int_t i = 3; i <= 12; i++) {
    meanElectrons = fStageGains[pixel][i] * (Float_t) neFromPrevDynode;
    neFromPrevDynode = (UInt_t) fRandom->PoissonD(meanElectrons);
  }
  
  return neFromPrevDynode;
}

void SimPmtM64Oxford::SimulateAnodeEffects

(

)

[protected, virtual]

Definition at line 382 of file SimPmtM64Oxford.cxx.

References SimPixelTimeBucket::AddCharge(), SimPmtM64::BucketToStartTime(), SimPmtM64::BucketToStopTime(), Munits::fC, SimPixelTimeBucket::fCharge, SimPmt::fNPixels, SimPmt::fNSpots, fOneSpot, fsPmtDoChargeSmear, SimPmt::fsPmtDoNonlinearity, SimPixelTimeBucket::fTime, GenNonlinearCharge(), SimPmt::GetBucket(), SimPixelTimeBucket::GetCharge(), SimPmtTimeBucket::GetPixelBucket(), gkNLWindowAfter, gkNLWindowBefore, Msg::kError, DigiSignal::kLeakFromNextBucket, DigiSignal::kLeakFromPrevBucket, Msg::kVerbose, MSG, SimPmtM64Full::NextBucketFraction(), SimPmtM64Full::PrevBucketFraction(), and SimPixelTimeBucket::SetTruthBit().

Referenced by SimulatePmt().

{
  //Saftey check: 
  //if there are several spots active then there will be problems  
  Int_t activeSpot = 1; //the only spot considered in NL corrections

  if (!fOneSpot) {
    MSG("DetSim",Msg::kError  ) << "This tube has" << fNSpots 
                                << " spots active! Only PEs in spot " 
                                << activeSpot << " will be considered."
                                << endl;
  } 

  // This uses the time structure of the pe lists to calculate the
  // amount of charge active in the pmt in a window near each pe.
  // this is used to calculate a non linearity correction, which is 
  // subtracted from the pixel bucket charge.

  // The charge is then smeared into nearby buckets using a charge pulse
  // shape t^3 exp[-1.6*t]. 

  // make something to store the pe non-linearity digests
  typedef std::vector<PeNLDigest_t> AllPePixelList_t;
  
  std::vector<AllPePixelList_t> allPeList(fNPixels + 1);  
  // zeroth element is empty, so that AllPeList[n] corresponds to 
  // pixel # n, using pixels numbered 1 -> 64 ( NOT 0 ->63 )

  // Iterate over all time buckets 
  // in each time bucket: add DigiPE summaries to the lists 
  for(SimPmtBucketIterator it(*this); !it.End(); it.Next()) {
    Int_t bucketId = it.BucketId();
    SimPmtTimeBucket& pmtBucket = it.Bucket();
    
    // iterate over pixels 
    for(Int_t pix = 1 ; pix <= fNPixels ; pix++) {
      SimPixelTimeBucket& pixelBucket = pmtBucket.GetPixelBucket(pix);
        Float_t q = 0.;
        if ( pixelBucket.GetTotalPEXtalk() ) {
           q = pixelBucket.GetCharge(); 
           q /= pixelBucket.GetTotalPEXtalk(); 
        }

      //get the pe list associated with this pixel in this time bucket 
      SimPixelTimeBucket::PeList_t& peInThisBkt 
        = pixelBucket.GetDigiPEXtalk(activeSpot);  
      // spot issues... And this time, i cant iterate over spots because
      // that wouldn't be time ordered!
      
      SimPixelTimeBucket::PeList_t::iterator peItr 
        = peInThisBkt.begin();
      
      for (  ; peItr != peInThisBkt.end() ; peItr++ ) {
        
        //make a pe summary
        PeNLDigest_t peInfo(bucketId, peItr->first, q);
        //cout << peInfo.fBucketNo << endl;
  
        //store it in the relevent vector
        allPeList[pix].push_back(peInfo); 

      } //for (pes)
    } //for (pixels)
  } //for (pmt time buckets)
  
  MSG("DetSim",Msg::kVerbose) << "Constructed pe list for non-linearity"
                              << endl;


  // Now we have nice long lists of pe's spanning all time buckets
  // lets nonlinear-ise!
  
  // iterate over pixels
  for(Int_t pix = 1 ; pix <= fNPixels ; pix++) {
    
    // iterate over pes
    AllPePixelList_t::iterator currPeItr = allPeList[pix].begin();
    for (  ; currPeItr != allPeList[pix].end() ; ++currPeItr) {

      //Get the bucketId and some references.
      //Need these for Nonlinearity & charge smearing
      Int_t bucketId = currPeItr->fBucketNo;
      SimPmtTimeBucket& pmtBkt = GetBucket(bucketId);
      SimPixelTimeBucket& pixelBucket = pmtBkt.GetPixelBucket(pix);
      
      Double_t chargeRatio = 1; //if no nonlinearity

      
      if (fsPmtDoNonlinearity){ 
        //Non-linearity
        // count up how much charge is nearby
        Float_t peTime = currPeItr->fTime; 
        Float_t nearbyCharge = 0;
        AllPePixelList_t::iterator  nearbyPeItr = currPeItr;
        Float_t dt = 0;
        
        // look back
        while ( nearbyPeItr != allPeList[pix].begin() ) {
          --nearbyPeItr;
          dt = peTime - nearbyPeItr->fTime;
          if ( dt > gkNLWindowBefore ) break;
          nearbyCharge += nearbyPeItr->fCharge;
          
        } //while (past pes)
        
        //look forward, include current pe
        nearbyPeItr = currPeItr;
        
        while (nearbyPeItr != allPeList[pix].end() ) {
          dt = nearbyPeItr->fTime - peTime;
          if ( dt > gkNLWindowAfter ) break;
          nearbyCharge += nearbyPeItr->fCharge;
          ++nearbyPeItr;
        }  //while (future pes)
        
        
        // calculate NL correction based on this amount
        // newCharge is the nonlinearised charge for all the pes in
        // the window, we want it for just one.
        if (nearbyCharge){
          // because it is possable have pes but no charge
          // (no seconday emission at some stage)
          chargeRatio = GenNonlinearCharge( pix, nearbyCharge );
          chargeRatio /= nearbyCharge;
        }       
                
        // use this correction to reduce the charge in this bucket
        Float_t deltaq = (chargeRatio - 1) * currPeItr->fCharge;
        pixelBucket.AddCharge(deltaq);
      
      } // if (fsDoNonlinearity) 



      if (fsPmtDoChargeSmear){
        //Smear the charge about
        
        // "This smushes charge into the next and previous QIE buckets.  
        // It's assumed that digiPE occours at the peak of the pulse, 
        // which has a shape of t^3 exp(-t*1.6). 
        // Some of the charge gets put into the next and previous buckets.
        // Note that the truth info is lost: you will now get digits with 
        // no signal info... but that's the way it goes, I'm afraid."
        
        Float_t startTime = BucketToStartTime(bucketId);
        Float_t stopTime = BucketToStopTime(bucketId);
        
        SimPmtTimeBucket& nextPmtBucket = GetBucket(bucketId + 1);
        SimPixelTimeBucket& nextPixBucket = nextPmtBucket.GetPixelBucket(pix);
        SimPmtTimeBucket& prevPmtBucket = GetBucket(bucketId - 1); 
        SimPixelTimeBucket& prevPixBucket = prevPmtBucket.GetPixelBucket(pix);
        
        //How much into the adjacent buckets?
        Float_t qNext = currPeItr->fCharge * chargeRatio;
        qNext *= NextBucketFraction ( stopTime - currPeItr->fTime );
        Float_t qPrev = currPeItr->fCharge * chargeRatio;
        qPrev *= PrevBucketFraction ( currPeItr->fTime - startTime );
        
        //cout << "Time from boundary = " << (currPeItr->fTime - startTime) * 1e9 <<endl;
        
        //Add charge to next bucket, and set truth bits if there is a 
        //non-trivial amount.
        nextPixBucket.AddCharge(qNext);
        if ( qNext > 1.0 * Munits::fC ) {
          nextPixBucket.SetTruthBit(DigiSignal::kLeakFromPrevBucket);
        }
        
        //Add charge to previous bucket, and set truth bits if there is a 
        //non-trivial amount.
        prevPixBucket.AddCharge(qPrev);
        if ( qPrev > 1.0 * Munits::fC ) {
          prevPixBucket.SetTruthBit(DigiSignal::kLeakFromNextBucket);
        }
        
        //remove the same amount of charge from the current bucket
        pixelBucket.AddCharge( -(qPrev + qNext) ); 
      
      } // if (fsDoChargeSmear)
    } // for (pes)
  } // for (pixels)
  
  MSG("Detsim",Msg::kVerbose) << "Nonlinearity and Charge smearing done"
                              << endl;
    
}

void SimPmtM64Oxford::SimulateCharges

(

)

[virtual]

Reimplemented from SimPmtM64Full.

Definition at line 606 of file SimPmtM64Oxford.cxx.

References SimPmt::fNPixels, SimPmt::fNSpots, SimPmt::fTotalCharge, and GenChargeFromPE().

Referenced by SimulatePmt().

{
  fTotalCharge =0;
  
  //cout << "PMT total pe " << GetTotalPe() << endl; 

  //Iterate over all time buckets. 
  for(SimPmtBucketIterator it(*this); !it.End(); it.Next()) {
    SimPmtTimeBucket& pmtBucket = it.Bucket();

    //Iterate over pixels
    for(Int_t pix = 1 ; pix <= fNPixels ; pix++) {
      SimPixelTimeBucket& pixelBucket = pmtBucket.GetPixelBucket(pix);
      Float_t nPe = pixelBucket.GetTotalPEXtalk();
      
      //Generate a charge in the pixel bucket
      //iterate over spots (...)
      for (Int_t spot = 1 ; spot <= fNSpots ; spot++){
        Float_t q = GenChargeFromPE( pix, spot, nPe );
        //cout << "Anode charge = " << q << endl;
        pixelBucket.AddCharge(q);
        fTotalCharge += q;
      } //for (spots)
    } //for (pixels)
  } // for (pmt time buckets)
}

void SimPmtM64Oxford::SimulatePmt

(

)

[virtual]

Reimplemented from SimPmt.

Definition at line 654 of file SimPmtM64Oxford.cxx.

References SimPmt::CopyPEtoPEXtalk(), SimPmt::fsPmtDoChargeCrosstalk, fsPmtDoChargeSmear, SimPmt::fsPmtDoDarkNoise, SimPmt::fsPmtDoNonlinearity, SimPmt::fsPmtDoOpticalCrosstalk, SimulateAnodeEffects(), SimPmt::SimulateChargeCrosstalk(), SimulateCharges(), SimPmt::SimulateDarkNoise(), and SimPmtM64::SimulateOpticalXtalk().

{
  //
  // Reimplemented from SimPmt. Nonlinearity and Charge smearing are both done
  // in a new function SimulateAnodeEffects.
  //
  //cout << "*************************************************************" << endl;
  // cout << "        Start simulation." << endl;
  //cout << "*************************************************************" << endl;
  //Print();
  
  if(fsPmtDoOpticalCrosstalk) SimulateOpticalXtalk();     // Move single PEs around for crosstalk
  else CopyPEtoPEXtalk();  // A null operation.
  
  //cout << "*************************************************************" << endl;
  // cout << "        After Optical." << endl;
  //cout << "*************************************************************" << endl;
  //Print();
  
  SimulateCharges();                                 // Simulate the dynode chain to get anode charge.
  
  //cout << "*************************************************************" << endl;
  //cout << "        After Charges." << endl;
  //cout << "*************************************************************" << endl;
  //Print();
  
  if(fsPmtDoDarkNoise)        SimulateDarkNoise();        // Add some charge to some pixels by dark noise.
  if(fsPmtDoChargeSmear ||
     fsPmtDoNonlinearity   )     SimulateAnodeEffects();     // Apply the nonlinearity
  if(fsPmtDoChargeCrosstalk)  SimulateChargeCrosstalk();  // Crosstalk some charge around.
  //cout << "*************************************************************" << endl;
  //cout << "        Final." << endl;
  //cout << "*************************************************************" << endl;
  //Print();
 }

---

Member Data Documentation

VldContext SimPmtM64Oxford::fLastVldContext [private]

Definition at line 62 of file SimPmtM64Oxford.h.

Bool_t SimPmtM64Oxford::fOneSpot [private]

Definition at line 58 of file SimPmtM64Oxford.h.

Referenced by CalStageGains(), and SimulateAnodeEffects().

Double_t SimPmtM64Oxford::fsDynodeSkipRate = 0.00 [static, private]

Definition at line 50 of file SimPmtM64Oxford.h.

Referenced by Config(), and SimFirstDynodes().

Double_t SimPmtM64Oxford::fSkippingGain[65] [private]

Definition at line 57 of file SimPmtM64Oxford.h.

Referenced by CalStageGains(), and SimFirstDynodes().

Double_t SimPmtM64Oxford::fsNLThreshold = 5 [static, private]

Definition at line 51 of file SimPmtM64Oxford.h.

Referenced by Config(), and GenNonlinearCharge().

Double_t SimPmtM64Oxford::fsNonlinearityScale = 1.5 [static, private]

Definition at line 52 of file SimPmtM64Oxford.h.

Referenced by Config(), and GenNonlinearCharge().

Bool_t SimPmtM64Oxford::fsPmtDoChargeSmear = true [static, protected]

Definition at line 40 of file SimPmtM64Oxford.h.

Referenced by Config(), SimulateAnodeEffects(), and SimulatePmt().

Double_t SimPmtM64Oxford::fStageGains[65][13] [private]

Definition at line 56 of file SimPmtM64Oxford.h.

Referenced by CalStageGains(), SimFirstDynodes(), and SimLaterDynodes().

Bool_t SimPmtM64Oxford::fStagesBuilt [private]

Definition at line 55 of file SimPmtM64Oxford.h.

Referenced by Reset().

const Double_t SimPmtM64Oxford::gkDefaultSecEmmRatio = 4.5 [static, private]

Definition at line 44 of file SimPmtM64Oxford.h.

Referenced by CalStageGains().

const Double_t SimPmtM64Oxford::gkDefaultStageGains [static, private]

Initial value:

 {0, 6.5397, 4.5583, 4.5583,
                                                          2.4593,  2.4593, 2.4593,
                                                          2.4593,  2.4593, 2.4593,
                                                          2.4593,  2.4593, 4.5583}

Definition at line 43 of file SimPmtM64Oxford.h.

Referenced by CalStageGains().

const Double_t SimPmtM64Oxford::gkNLWindowAfter = 0.9841 * Munits::ns [static, private]

Definition at line 48 of file SimPmtM64Oxford.h.

Referenced by SimulateAnodeEffects().

const Double_t SimPmtM64Oxford::gkNLWindowBefore = 1.8056 * Munits::ns [static, private]

Definition at line 47 of file SimPmtM64Oxford.h.

Referenced by SimulateAnodeEffects().

---

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

• SimPmtM64Oxford.h
• SimPmtM64Oxford.cxx

---