PhotonFullGreenTracker.cxx

Go to the documentation of this file.

#include "PhotonFullGreenTracker.h"
#include "PhotonTransportMaker.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"
#include <cmath>

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

ClassImp(PhotonFullGreenTracker)
PhotonTransportMakerProxy<PhotonFullGreenTracker>
        gPhotonFullGreenTrackerProxy("photonFullGreenTracker"); 


// Constructor
PhotonFullGreenTracker::PhotonFullGreenTracker() :
  fFibreAbsorbTable("PHOTONFIBREABSORB"),
  fPmtEffTable("PHOTONPMTQUANTUMEFFICIENCY")
{
  Configure(PhotonConfiguration());

  if (fFibreAbsorbTable.GetNumRows()<1) {
    MSG("Photon",Msg::kError) << "Can't find data for table PHOTONFIBREABSORB. Aborting!\n";
    assert(0);
  }
  if (fPmtEffTable.GetNumRows()<1) {
    MSG("Photon",Msg::kError) << "Can't find data for table PHOTONPMTQUANTUMEFFICIENCY. Aborting!\n";
    assert(0);
  }
  // Set the prescale factors.
  SetGreenPrescaleFactor(
                         fPmtEffTable.GetMaximum()/100.
                         ); // Phototube photocathode acceptance.
  
}

// Configure the model.
void 
PhotonFullGreenTracker::Configure( const Registry& r )
{
  MSG("Photon",Msg::kDebug) << "Configuring FullGreenTracker." << std::endl;

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


void
PhotonFullGreenTracker::Reset( const VldContext& cx )
{
  fFibreAbsorbTable.Reset(cx);
  fPmtEffTable.Reset(cx);
  // Set the prescale factors.
  SetGreenPrescaleFactor(
                         fPmtEffTable.GetMaximum()/100.
                         ); // 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 
PhotonFullGreenTracker::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;
  }

  // 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 greenDist =
    distToCenter // Distance to center of strip.
    +inStrip.GetHalfLength()         // Distance to end of strip;
    +inStrip.WlsPigtail(readout); // Pigtail on readout end.

  MSG("Photon",Msg::kVerbose) << "Distance to center of strip: " << distToCenter 
                              << "  end= " << readout 
                              << "  halflen=" << inStrip.GetHalfLength()
                              << "  x="<<inGreenPhoton->X() 
                              << "  dx=" << inGreenPhoton->GetCosX() << endl;


  // 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)
  }
 
  // Find the distance down the clear strip.
  Double_t clearDist = inStrip.ClearFiber(readout);

  // But... we don't travel in a straight line!
  // We bounce around the fibre a lot. This makes the path length longer.
  greenDist /= fabs(inGreenPhoton->GetCosX());
  clearDist /= fabs(inGreenPhoton->GetCosX());
  
  MSG("Photon",Msg::kVerbose) << "After pathlength correction: greenDist = " << greenDist
                              << "  clearDist = " << clearDist << endl;


  double wavelength_nm = inGreenPhoton->WaveLength()/Munits::nm;
  if(wavelength_nm==0) wavelength_nm = 520; // Default.
  
  double greenLambda = fFibreAbsorbTable.Interpolate(wavelength_nm);

  // Compute the probablility we just lose it.
  // 1 is no attenuation, 0 is complete loss
  // So, a small number is a small attenuation prob.
  double greenAtten = exp(-greenDist/greenLambda);

  MSG("Photon",Msg::kVerbose) << "Green atten prob = " << greenAtten << endl;
  if(fRandom->Rndm() > greenAtten) return false;

  // Clear fibres:
  // These numbers are from the GMINOS defaults.
  const double lambda_c = 11.4; // meters

  // 1 is no attenuation, 0 is complete loss
  double clearAtten =   exp(-clearDist/lambda_c);
  
  MSG("Photon",Msg::kVerbose) << "Clear atten prob = " << clearAtten << endl;
  if(fRandom->Rndm() > clearAtten) return false;
  
  double eff = fPmtEffTable.Interpolate(wavelength_nm)/100.; // Convert from percent.

  // Apply prescaling.
  double prob = eff / GetGreenPrescaleFactor();
  
  MSG("Photon",Msg::kVerbose) << "Photocathode convert prob (" 
                              << wavelength_nm << " nm) = " << prob << endl;
  if(fRandom->Uniform() > prob) return false; // Didn't convert in cathode.

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

  PlexStripEndId seid =  inStrip.GetSEId();
  seid.SetEnd(readout);

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

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

  return true;  
}

---