PhotonCompositeGreenTracker.cxx

Go to the documentation of this file.

#include "PhotonCompositeGreenTracker.h"
#include "PhotonTransportMaker.h"
#include "PhotonUtil.h"
#include "Calibrator/Calibrator.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"
#include <cmath>

CVSID( "$Id: PhotonCompositeGreenTracker.cxx,v 1.3 2006/12/01 19:59:25 rhatcher Exp $" );

ClassImp(PhotonCompositeGreenTracker)
PhotonTransportMakerProxy<PhotonCompositeGreenTracker>
       gPhotonCompositeGreenTrackerProxy("photonCompositeGreenTracker"); 


// Constructor
PhotonCompositeGreenTracker::PhotonCompositeGreenTracker() 
{
  Configure(PhotonConfiguration()); // Set up default values.
}

// Configure the model.
void 
PhotonCompositeGreenTracker::Configure( const Registry& r )
{
  // The other classses in the model need configuring:
  MSG("Photon",Msg::kDebug) << "Configuring CompositeGreenTracker." << std::endl;

  double tmpd;
  if (r.Get("FibreIndex",tmpd))           fFibreIndex  = tmpd;
  if (r.Get("ClearFibreIndex",tmpd))      fClearFibreIndex  = tmpd;

  if (r.Get("ReflectorFibreReflec",tmpd)) fReflectorFibreReflec  = tmpd;
  if (r.Get("QuantumEfficiency",tmpd))    fQuantumEfficiency = tmpd;
  if (r.Get("FibreAttenN1",tmpd))        fFibreAttenN1 = tmpd;
  if (r.Get("FibreAttenN2",tmpd))        fFibreAttenN2 = tmpd;
  if (r.Get("FibreAttenLength1",tmpd))   fFibreAttenLength1 = tmpd;
  if (r.Get("FibreAttenLength2",tmpd))   fFibreAttenLength2 = tmpd;
  if (r.Get("ClearFibreAttenN1",tmpd))   fClearFibreAttenN1 = tmpd;
  if (r.Get("ClearFibreAttenN2",tmpd))   fClearFibreAttenN2 = tmpd;
  if (r.Get("ClearFibreAttenLength1",tmpd)) fClearFibreAttenLength1 = tmpd;
  if (r.Get("ClearFibreAttenLength2",tmpd)) fClearFibreAttenLength2 = tmpd ;
  // Set the prescale factors.
  SetGreenPrescaleFactor(fQuantumEfficiency); // Phototube photocathode acceptance.
}



// Creates a green photon from a fibre hit, and tracks to the PMT.
// Returns true if green photon made it, false if attenuated away.
// Takes the blue wavelength (may not be used), position, and time,
// and fills a DigiPE object.
Bool_t 
PhotonCompositeGreenTracker::GreenPhotonToPe( const UgliStripHandle& inStrip,
                                     DigiPhoton*         inGreenPhoton,
                                     DigiPE*             &outPe,
                                     StripEnd::StripEnd_t &outEnd)
{
  outPe = NULL;
  if(!inGreenPhoton) return false;

  // First, figure out which way we're going.
  StripEnd::StripEnd_t dir = 
    (inGreenPhoton->GetCosX()>0) ? StripEnd::kPositive : StripEnd::kNegative;

  StripEnd::StripEnd_t readout = dir; // Assume we're reading out the end it's going.

  // Is the end we've gotten to mirrored? 
  if(inStrip.IsMirrored(dir)) {
    // Ok, then we're going to need to flip it.
    // Does this photon survive the flip?
    if(fRandom->Rndm() > fReflectorFibreReflec) {
      return false;
    }

    // We survived the reflection.
    readout = (dir==StripEnd::kPositive) ? StripEnd::kNegative : StripEnd::kPositive;
  }

  // Find the distance down the clear strip.
  // Note that this distance is used only for attenuation, not for propagation time.
  Double_t clearDist = inStrip.ClearFiber(readout);

  // See if it survives the readout cable. 
  Double_t clearProb = PhotonUtil::DoubleExp(clearDist, 
                                             fClearFibreAttenN1,      fClearFibreAttenN2,
                                             fClearFibreAttenLength1, fClearFibreAttenLength2,
                                             true);
  if(fRandom->Rndm() > clearProb) return false;
   
  
  // The photon is reflecting it's way down the strip.
  // Figure out how far it has to go in each medium.

  double distToCenter = (inGreenPhoton->GetCosX()>0) ? (-inGreenPhoton->X())
    : (inGreenPhoton->X());

  Double_t halfgreen = inStrip.GetHalfLength()         // Distance to end of strip;
                      +inStrip.WlsPigtail(readout); // Pigtail on readout end.


  Double_t greenDist = distToCenter // Distance to center of strip.
                     + halfgreen;


  // Deal with WLS bypass, if any
  double bypassExtra = 0;
  if(inStrip.WlsBypass() >0) {    
    bypassExtra = ( inStrip.PartialLength(StripEnd::kNegative) + 
                    inStrip.PartialLength(StripEnd::kPositive) +
                    inStrip.WlsBypass() - 
                    inStrip.GetHalfLength()*2.0 );

    // place in the middle of the break;
    float x_break =0.5* (inStrip.PartialLength(StripEnd::kNegative) 
                         - inStrip.PartialLength(StripEnd::kPositive) );

    if(inGreenPhoton->X() < x_break) {
      // If the photon is at -ve end and going +ve, it goes through the bypass
      if(dir==StripEnd::kPositive)  greenDist+= bypassExtra;
    } else {
      // If the photon is at +ve end and going -ve, it goes through the bypass
      if(dir==StripEnd::kNegative)  greenDist+= bypassExtra;
    }
  }

  if(readout!=dir) {
    // i.e. we're going towards the mirror end but being read out on the non-mirror end
    greenDist+= inStrip.GetHalfLength()*2.0; // Gotta double back...
    greenDist+= bypassExtra;                 // ... through the ENTIRE green fibre
    greenDist+= inStrip.WlsPigtail(dir)*2.0; // And we have to go through the pigtail, if any
                                             // (N.B. This is for caldet, which has pigtails before the reflector)
  }


  // See if it survives the green fibre:
  double gdir = 1.0;
  if(readout == StripEnd::kNegative) gdir = -1.0;
  Calibrator& Cal = Calibrator::Instance();
  PlexStripEndId seid = inStrip.GetSEId();
  seid.SetEnd(readout);

  double greenProb =1.0-
    (  Cal.DecalAttenCorrected(1.0, inGreenPhoton->X(), seid) 
     / Cal.DecalAttenCorrected(1.0, gdir*halfgreen,     seid) );

  //MSG("mydebug",Msg::kInfo) << "Green survival prob: " << greenProb << endl;

  if(fRandom->Rndm() < greenProb) return false;

  // But... we don't travel in a straight line!
  // We bounce around the fibre a lot. This makes the path length longer.
  double greenBouncedDist = greenDist/ fabs(inGreenPhoton->GetCosX());
  double clearBouncedDist = clearDist/ fabs(inGreenPhoton->GetCosX());
  
  // ASSUME: no loss at connector interfaces

  // PMT: ASSUME:
  // FIXME: Assume 100% quantum efficiency, or efficiency dealt with
  // in photon computation.

  // Build the resultant digipe.
  // Find the time of arrival.
  double time = inGreenPhoton->T()
    + greenBouncedDist * fFibreIndex / Munits::c_light
    + clearBouncedDist * fClearFibreIndex / Munits::c_light;

  PlexHandle plex(fContext);
  PlexPixelSpotId psid = plex.GetPixelSpotId(seid);

  outPe = new DigiPE( time, psid, inGreenPhoton->ParentHit() );
  outEnd = readout;

  return true;  
}

---