PhotonCaldetNoise.cxx

Go to the documentation of this file.

#include "PhotonCaldetNoise.h"
#include "PhotonTransportMaker.h"
#include "ScintPhoton.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"
#include "Digitization/DigiSignal.h"

CVSID( " $Id: PhotonCaldetNoise.cxx,v 1.4 2006/12/01 20:12:11 rhatcher Exp $" );

ClassImp(PhotonCaldetNoise)
PhotonTransportMakerProxy<PhotonCaldetNoise>
        gPhotonCaldetNoiseProxy("photonCaldetNoise"); 


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

// Configure the model.
void 
PhotonCaldetNoise::Configure( const Registry& r )
{
  // The other classses in the model need configuring:
  ScintPhoton::Configure(r);

  MSG("Photon",Msg::kDebug) << "Configuring CaldetNoise." << std::endl;

  double tmpd;
  if (r.Get("DarkNoiseRate",tmpd))        fDarkNoiseRate = tmpd; 
  if (r.Get("GreenNoiseRate",tmpd))       fGreenNoiseRate = tmpd;
  if (r.Get("NoiseWindow",tmpd))          fNoiseWindow = tmpd;
}

void 
PhotonCaldetNoise::Reset( const VldContext& )
{
  // Ensure tables are up-to-date.
}


void   
PhotonCaldetNoise::MakeNoise( std::vector<DigiPE*> &peList,
                               Double_t t_start,
                               Double_t t_end )
{

  // Work out our window.
  double t1 = t_start - fNoiseWindow*0.5;
  double t2 = t_end   + fNoiseWindow*0.5;
  double dt = t2-t1;

  MSG("Photon",Msg::kDebug) << "Computing noise for window at" << t1 
                            << " s for " << (t2-t1)/Munits::ns << " ns." << std::endl;

  PlexHandle plex(fContext);
  // Get a list of PMTs from the Plex.
  const std::vector<PlexPixelSpotId>& tubes = plex.GetAllTubes();
  
  // How many PMT hits would we expect?
  Double_t pmtHits = (double)tubes.size() * dt * fDarkNoiseRate;
  // Now find the number that DID happen...
  Int_t nPmtHits = fRandom->Poisson(pmtHits);
  MSG("Photon",Msg::kDebug) << "Creating " << nPmtHits << " dark noise hits.\n";
  
  // Create the hits.
  for(int i=0; i<nPmtHits; i++) {
    // Pick a tube at random.
    Int_t whichPmt = fRandom->Integer((int)tubes.size());
    // Pick a pixelspot.
    PlexPixelSpotId psid = tubes[whichPmt];
    if(psid.GetElecType()==ElecType::kQIE) {
      psid.SetPixel(fRandom->Integer(64));
      psid.SetSpot(1);      
    }
    if(psid.GetElecType()==ElecType::kVA) {
      psid.SetPixel(fRandom->Integer(16));
      psid.SetSpot(fRandom->Integer(8)+1);      
    }
    if(psid.IsValid()) {
      DigiPE* pe = new DigiPE( fRandom->Uniform(t1,t2),
                               psid,
                               DigiSignal::kDarkNoise ); // No Scint Hit associated with the PE.
      peList.push_back(pe);
    }
  }

  // Get list of strip ends from the Plex.  
  const std::vector<PlexStripEndId>& stripEnds = plex.GetAllStripEnds();

  // How many fibre hits would we expect?
  Double_t fibreHits = (double)stripEnds.size() * dt * fGreenNoiseRate;
  // Now find the number that DID happen...
  Int_t nGreenHits = fRandom->Poisson(fibreHits);
  MSG("Photon",Msg::kDebug) << "Creating " << nGreenHits << " green WLS noise hits.\n";
  
  // Create the hits.
  for(int i=0; i<nGreenHits; i++) {
    // Pick a strip end at random.
    Int_t whichSeid = fRandom->Integer((int)stripEnds.size());
    
    PlexPixelSpotId psid = plex.GetPixelSpotId(stripEnds[whichSeid]);

    if(psid.IsValid()) {  
      DigiPE* pe =  new DigiPE( fRandom->Uniform(t1,t2),
                                psid,
                                DigiSignal::kFibreLight ); // No Scint Hit associated with the PE.
      peList.push_back(pe);
    }
  }

  
}


void PhotonCaldetNoise::Print(Option_t*option) const
{
  if(option[0]=='n') {
    MSG("Photon",Msg::kInfo) << "-<NoiseMaker>          PhotonCaldetNoise:-----" << endl;  
    //FIXME
  }
}

---