PhotonTransport Unveiled

Report to MC task force, Oct 28 2003
Nathaniel Tagg n.tagg1@physics.ox.ac.uk

How it works:

Each box above is a "PhotonTransportModule", a class that has an interface call (much like a job module).

These steps are inter-related, so not all combinations will work together flawlessly (although they will work).

Brief description:

PhotonComputer: Computes how many photons to simulate. Uses the energy of the DigiScintHit, Birk's constant, calibration constants, etc.
(You're allowed to specify the number in any way. E.g. number of blue photons to start with, E.g. number of DigiPE to get at each end of the strip)

Blue Tracker: Starts a photon along the DigiScintHit track and propagates until it hits the fibre.
       (Returns FALSE if the photon doesn't hit the fibre.)

Wls Model: Converts an incoming blue photon to a green photon.
    (Returns FALSE if the photon doesn't get captured)

Green Tracker: Carries the green photon down the fibre. Calculates attenuation, photocathode efficiency, etc.
    (Returns FALSE if the photon doesn't make a DigiPE)

The last three modules, the "simulation elements" each require the module to give a "prescale" value. This can be used by the PhotonComputer. For instance: the GreenTracker can prescale by the maximum quantum efficiency of the phototube, say 20%. Then, only 20% of the blue photons need be generated. This value is used by the PhotonComputer.

The Models So Far

In my experimentation, I have focused on three simulation sets:

Full: (Slow but good)

-Blue photons, if they hit the fibre, are reflected off or refracted into the core of the fibre. They are absorbed along the chord of their transit with the wavelength-dependent absoption spectrum of the WLS fibre material
Green photons are created at the blue photon absorption points and emitted isotropically. The photons are refracted or reflected off the double-cladding of the WLS fibre.
Green photons are carried to the PMT photocathode (using the wavelength-dependent absoption spectrum of the WLS and clear fibres) and areconverted to photoelectrons using the (you guessed it) wavelength-dependent photocathode quantum efficiency.

Simple: (Easy to understand, pretty fast)

Blue photons are created along the particle track, and are bounced around until they are absorbed on the walls or in the scintillator or until they hit the green fibre. The attenuation length and reflectivity are assumed to be single numbers.
Blue photons can reflect off the fibre. If not, they are assumed to be absorbed at a random (volume-weighted) radius.
Green photons are emitted isotropically. Photons are refracted or reflected off the double cladding.
Green photons are transmitted to the PMT photocathode. Absoption in the green and clear fibres is computed using a double-exponential. Conversion in the PMT is assumed to be a simple probability.

Fast: (recommended for production work)

Green photons are created near the particle track using a PDF of blue photon absoption positions and times.
Green photons are created isotropically and homogeneously in the WLS fibre cross-section.
Green photons are transmitted to the PMT photocathode. Absoption in the green and clear fibres is computed using a double-exponential. Conversion in the PMT is assumed to be a simple probability

The Fast and the Simple models were tuned to match the Full model.

Computers So Far:

Default: Simple: computes number of blue photons from Birk's law. All strips identical:

NBlue = 1 photon/eV * bluePrescale * greenPrescale * wlsPrescale * dE/(1+dEdx*kBirks)

MuonComputer: Same, but multiplies the above by a strip-to-strip decalibration:
* CalMuonCalibration.fC0 / CalADCtoPE.gain

Model Comparison

Blue Photons: Pure distribution.

Blue photons: Strip end effects

Points: Massaged CalDet data via Paul Miyagawa

Green Photons:

Reconstruction Effects:

Using only digits with 1 DigiScintHit per strip on cosmic ray data,
and both ends with at least 1 pe:

GMINOS: 1.65792 +/- 0.0138313

Photon:  1.75338 +/- 0.0149253

Note: Roy claims a value of 1.77 for real data. Reconstruction effects have NOT been included in this fit!

Work/ TO DO

Need a noise generator!

Need some final optical numbers:
    - Reflectivity of the mirrored ends in ND
    - Decay constant of the fluror (true, not effective)
    - Birks' constant for hadrons/muons
    - How to deal with very low energy particles (protons at ~0 path length)

Truthifier:

What should this look like?

What questions will people want to ask?

Should it be persistable? Should each module build it's own?



class Truthifier : public TObject

{

 public:

  Truthifier( const MomNavigator* mom ) { Reset(mom); };

  void Reset( const MomNavigator* mom );



  //////////////////////////////////////////////

  // Forward tracking: Particle->...->Digit



  // Hit->Signal

  const std::vector<const DigiSignal*>& GetSignalVector(const DigiScintHit* hit);



  // Signal->Digit

  const
RawDigit*                      
GetRawDigit(const DigiSignal* signal);



  // Hit->Signal->Digit

  const std::vector<const RawDigit*>&   GetRawDigitVector(const DigiScintHit* hit);



  // Track->Hit->Signal->Digit





  //////////////////////////////////////////////

  // Backward tracking: Digit->...->Particle



  // Digit->Signal.

  const DigiSignal* GetSignal( const CandDigitHandle& cdh );

  const DigiSignal* GetSignal( const RawDigit* digit );



  // Some common things one would want to know:

  DigiSignal::DigiPmtTruth_t GetSignalTruthFlags( const CandDigitHandle& cdh );

  DigiSignal::DigiPmtTruth_t GetSignalTruthFlags( const RawDigit* digit );

  // or even simpler (as an example)

  Bool_t DigitIsOnlyCrosstalk( const CandDigitHandle& cdh );

  Bool_t DigitIsOnlyCrosstalk( const RawDigit* digit );



  // Signal->Hit is available from the DigiSignal class.

  Float_t IsSignalFromParticle( Int_t particleID,  const DigiSignal* signal );

  Float_t IsSignalFromTrack   ( Int_t trackID,  const DigiSignal* signal );



  // Digit->Hit. Some useful things

  const DigiScintHit* GetBiggestHit( const CandDigitHandle& cdh );

  const DigiScintHit* GetBiggestHit( const RawDigit* digit );



  Float_t IsDigitFromParticle( Int_t particleID,  const CandDigitHandle& cdh );

  Float_t IsDigitFromParticle( Int_t particleID,  const RawDigit* digit );



  Float_t IsDigitFromTrack( Int_t trackID,  const CandDigitHandle& cdh );

  Float_t IsDigitFromTrack( Int_t trackID,  const RawDigit* digit );



  // Prints out the whole blessed mess.

  virtual void Print(const Option_t* = "") const;



}