Changeset 4241


Ignore:
Timestamp:
05/30/04 13:49:30 (20 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r4235 r4241  
    1818
    1919                                                 -*-*- END OF LINE -*-*-
     20
     21 2004/05/30: Markus Gaug
     22
     23   * mcalib/MCalibrationQEPix.[h,cc]
     24     - added more documentation (plots)
     25     - separated calls for light guides eff. , QE, and coll. eff.
     26   
    2027
    2128 2004/05/28: Markus Gaug

  • trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.cc

    r4223 r4241  
    101101//                             40.       0.236
    102102//                             60.       0.234
    103 // (from D.Paneque et al., NIM A 504, 2003, 109-115
     103// (from D.Paneque et al., NIM A 504, 2003, 109-115, see following figure with the
     104//  photon spectra at 2200 m altitude:)
     105//
     106//Begin_Html
     107/*
     108<img src="images/Photon_spectrum.png">
     109*/
     110//End_Html
    104111//
    105112// * PMT photoelectron collection efficiency: 0.9
    … …  
    144151/*
    145152<img src="images/JuergensMeasurementWithCosThetaCurve.png">
     153*/
     154//End_Html
     155//
     156// The Quantum efficiencies for individual colours have been taken from:
     157// D. Paneque et al., A Method to enhance the sensitivity of photomultipliers
     158//                    of air Cherenkov Telescopes, NIM A 504, 2003, 109-115
     159// (see following figure)
     160//
     161//Begin_Html
     162/*
     163<img src="images/QE_Paneque.png">
    146164*/
    147165//End_Html
    … …  
    178196const Float_t MCalibrationQEPix::gkDefaultAverageQEErr = 0.02 ; 
    179197const Float_t MCalibrationQEPix::gkPMTCollectionEff    = 0.90 ;
    180 const Float_t MCalibrationQEPix::gkLightGuidesEff      = 0.94 ;
    181198const Float_t MCalibrationQEPix::gkPMTCollectionEffErr = 0.01 ;
    182 const Float_t MCalibrationQEPix::gkLightGuidesEffErr   = 0.03 ;
     199const Float_t MCalibrationQEPix::gkLightGuidesEffGreen    = 0.94 ;
     200const Float_t MCalibrationQEPix::gkLightGuidesEffGreenErr = 0.03 ;
     201const Float_t MCalibrationQEPix::gkLightGuidesEffBlue     = 0.94 ;
     202const Float_t MCalibrationQEPix::gkLightGuidesEffBlueErr  = 0.03 ;
     203const Float_t MCalibrationQEPix::gkLightGuidesEffUV       = 0.94 ;
     204const Float_t MCalibrationQEPix::gkLightGuidesEffUVErr    = 0.03 ;
     205const Float_t MCalibrationQEPix::gkLightGuidesEffCT1      = 0.94 ;
     206const Float_t MCalibrationQEPix::gkLightGuidesEffCT1Err   = 0.03 ;
    183207// --------------------------------------------------------------------------
    184208//
    … …  
    224248  if (IsBlindPixelMethodValid (col))
    225249  {
    226     const Float_t newavqe    =   GetQEBlindPixel(col)       / GetDefaultQE (col) ;
    227     const Float_t newavqevar = ( GetQEBlindPixelRelVar(col) + GetDefaultQERelVar(col) ) * newavqe * newavqe;
     250    const Float_t newavqe    =   GetQEBlindPixel      (col) / GetDefaultQE      (col)
     251                               / GetLightGuidesEff    (col) / GetPMTCollectionEff();
     252    const Float_t newavqevar = ( GetQEBlindPixelRelVar(col) + GetDefaultQERelVar(col)
     253                               + GetLightGuidesEffRelVar(col) + GetPMTCollectionEffRelVar()  )
     254                               * newavqe * newavqe;
    228255    const Float_t weight     = 1./newavqevar;
    229256
    … …  
    246273  if (IsCombinedMethodValid (col))
    247274  {
    248     const Float_t newavqe    =   GetQECombined(col)       / GetDefaultQE (col) ;
    249     const Float_t newavqevar = ( GetQECombinedRelVar(col) + GetDefaultQERelVar(col) ) * newavqe * newavqe;
     275    const Float_t newavqe    =   GetQECombined(col)       / GetDefaultQE (col)
     276                               / GetLightGuidesEff    (col) / GetPMTCollectionEff();
     277    const Float_t newavqevar = ( GetQECombinedRelVar(col) + GetDefaultQERelVar(col)
     278                               + GetLightGuidesEffRelVar(col) + GetPMTCollectionEffRelVar()  )
     279                               * newavqe * newavqe;
    250280    const Float_t weight     = 1./newavqevar;
    251281    wav  += newavqe * weight;
    … …  
    268298  if (IsFFactorMethodValid (col))
    269299  {
    270     const Float_t newavqe    =   GetQEFFactor(col)       / GetDefaultQE (col) ;
    271     const Float_t newavqevar = ( GetQEFFactorRelVar(col) + GetDefaultQERelVar(col) ) * newavqe * newavqe;
     300    const Float_t newavqe    =   GetQEFFactor(col)       / GetDefaultQE (col)
     301                               / GetLightGuidesEff    (col) / GetPMTCollectionEff();
     302    const Float_t newavqevar = ( GetQEFFactorRelVar(col) + GetDefaultQERelVar(col)
     303                               + GetLightGuidesEffRelVar(col) + GetPMTCollectionEffRelVar()  )
     304                               * newavqe * newavqe;
    272305    const Float_t weight     = 1./newavqevar;
    273306
    … …  
    293326  if (IsPINDiodeMethodValid (col))
    294327  {
    295     const Float_t newavqe    =   GetQEPINDiode(col)       / GetDefaultQE (col) ;
    296     const Float_t newavqevar = ( GetQEPINDiodeRelVar(col) + GetDefaultQERelVar(col) ) * newavqe * newavqe;
     328    const Float_t newavqe    =   GetQEPINDiode(col)       / GetDefaultQE (col)
     329                               / GetLightGuidesEff    (col) / GetPMTCollectionEff();
     330    const Float_t newavqevar = ( GetQEPINDiodeRelVar(col) + GetDefaultQERelVar(col)
     331                               + GetLightGuidesEffRelVar(col) + GetPMTCollectionEffRelVar()  )
     332                               * newavqe * newavqe;
    297333    const Float_t weight     = 1./newavqevar;
    298334    wav  += newavqe *weight;
    … …  
    394430//
    395431// Return the average Default QE (depending on zenith angle)
     432// FIXME: The zenith angle dependency is not yet implemented
    396433//
    397434const Float_t MCalibrationQEPix::GetAverageQE( const Float_t zenith ) const
    … …  
    404441//
    405442// Return the relative variance of the average Default QE (depending on zenith angle)
     443// FIXME: The zenith angle dependency is not yet implemented
    406444//
    407445const Float_t MCalibrationQEPix::GetAverageQERelVar( const Float_t zenith ) const
    … …  
    413451//
    414452// Return the relative variance of the average normalization (Blind Pixel Method)
     453// FIXME: The zenith angle dependency is not yet implemented
    415454//
    416455const Float_t MCalibrationQEPix::GetAvNormBlindPixelRelVar( ) const
    … …  
    422461//
    423462// Return the relative variance of the average normalization (Combined Method)
     463// FIXME: The zenith angle dependency is not yet implemented
    424464//
    425465const Float_t MCalibrationQEPix::GetAvNormCombinedRelVar( ) const
    … …  
    440480//
    441481// Return the relative variance of the average normalization (PIN Diode Method)
     482// FIXME: The zenith angle dependency is not yet implemented
    442483//
    443484const Float_t MCalibrationQEPix::GetAvNormPINDiodeRelVar( ) const
    … …  
    455496    {
    456497    case MCalibrationCam::kGREEN:
    457       return gkDefaultQEGreen * gkPMTCollectionEff * gkLightGuidesEff;
     498      return gkDefaultQEGreen;
    458499      break;
    459500    case MCalibrationCam::kBLUE:
    460       return gkDefaultQEBlue * gkPMTCollectionEff * gkLightGuidesEff;
     501      return gkDefaultQEBlue;
    461502      break;
    462503    case MCalibrationCam::kUV:
    463       return gkDefaultQEUV * gkPMTCollectionEff * gkLightGuidesEff;
     504      return gkDefaultQEUV;
    464505      break;
    465506    case MCalibrationCam::kCT1:
    466       return gkDefaultQECT1 * gkPMTCollectionEff * gkLightGuidesEff;
     507      return gkDefaultQECT1;
    467508      break;
    468509    default:
    469       return gkDefaultQECT1 * gkPMTCollectionEff * gkLightGuidesEff;
     510      return gkDefaultQECT1;
    470511      break;
    471512    }
    … …  
    479520Float_t MCalibrationQEPix::GetDefaultQERelVar( const MCalibrationCam::PulserColor_t col )  const
    480521{
    481 
    482   Float_t collpluslgrelvar = gkPMTCollectionEffErr * gkPMTCollectionEffErr
    483                            / gkPMTCollectionEff / gkPMTCollectionEff;
    484  
    485   collpluslgrelvar        += gkLightGuidesEffErr   * gkLightGuidesEffErr
    486                            / gkLightGuidesEff   / gkLightGuidesEffErr;
    487522
    488523  switch (col)
    489524    {
    490525    case MCalibrationCam::kGREEN:
    491       return collpluslgrelvar + gkDefaultQEGreenErr * gkDefaultQEGreenErr / (gkDefaultQEGreen * gkDefaultQEGreen );
     526      return gkDefaultQEGreenErr * gkDefaultQEGreenErr / (gkDefaultQEGreen * gkDefaultQEGreen );
    492527      break;
    493528    case MCalibrationCam::kBLUE:
    494       return collpluslgrelvar + gkDefaultQEBlueErr  * gkDefaultQEBlueErr  / (gkDefaultQEBlue  * gkDefaultQEBlue  );
     529      return gkDefaultQEBlueErr  * gkDefaultQEBlueErr  / (gkDefaultQEBlue  * gkDefaultQEBlue  );
    495530      break;
    496531    case MCalibrationCam::kUV:
    497       return collpluslgrelvar + gkDefaultQEUVErr    * gkDefaultQEUVErr    / (gkDefaultQEUV    * gkDefaultQEUV    );
     532      return gkDefaultQEUVErr    * gkDefaultQEUVErr    / (gkDefaultQEUV    * gkDefaultQEUV    );
    498533      break;
    499534    case MCalibrationCam::kCT1:
    500       return collpluslgrelvar + gkDefaultQECT1Err   * gkDefaultQECT1Err   / (gkDefaultQECT1   * gkDefaultQECT1   );
     535      return gkDefaultQECT1Err   * gkDefaultQECT1Err   / (gkDefaultQECT1   * gkDefaultQECT1   );
    501536      break;
    502537    default:
    503       return collpluslgrelvar + gkDefaultQECT1Err   * gkDefaultQECT1Err   / (gkDefaultQECT1   * gkDefaultQECT1   );
     538      return gkDefaultQECT1Err   * gkDefaultQECT1Err   / (gkDefaultQECT1   * gkDefaultQECT1   );
    504539      break;
    505540    }
    506541  return -1.;
    507542}
     543
     544// ------------------------------------------------------------------------------
     545//
     546// Get the light guides efficiency depending on the pulser colour "col"
     547// FIXME: Lacking detailed measurement, these number are not yet available
     548//        for the individual colours and therefore, only one same number is
     549//        returned, namely gkLightGuidesEff
     550//
     551Float_t MCalibrationQEPix::GetLightGuidesEff( const MCalibrationCam::PulserColor_t col )  const
     552{
     553  switch (col)
     554    {
     555    case MCalibrationCam::kGREEN:
     556      return gkLightGuidesEffGreen;
     557      break;
     558    case MCalibrationCam::kBLUE:
     559      return gkLightGuidesEffBlue;
     560      break;
     561    case MCalibrationCam::kUV:
     562      return gkLightGuidesEffUV;
     563      break;
     564    case MCalibrationCam::kCT1:
     565      return gkLightGuidesEffCT1;
     566      break;
     567    default:
     568      return gkLightGuidesEffCT1;
     569      break;
     570    }
     571  return -1.;
     572}
     573
     574// ------------------------------------------------------------------------------
     575//
     576// Get the relative variance of the light guides efficiency depending on the
     577// pulser colour "col"
     578// FIXME: Lacking detailed measurement, these number are not yet available
     579//        for the individual colours and therefore, only one same number is
     580//        returned, namely gkLightGuidesEffErr^2 / gkLightGuidesEff^2
     581//
     582Float_t MCalibrationQEPix::GetLightGuidesEffRelVar( const MCalibrationCam::PulserColor_t col )  const
     583{
     584
     585  switch (col)
     586    {
     587    case MCalibrationCam::kGREEN:
     588      return gkLightGuidesEffGreenErr * gkLightGuidesEffGreenErr / gkLightGuidesEffGreen / gkLightGuidesEffGreen;
     589      break;
     590    case MCalibrationCam::kBLUE:
     591      return gkLightGuidesEffBlueErr  * gkLightGuidesEffBlueErr / gkLightGuidesEffBlue / gkLightGuidesEffBlue;
     592      break;
     593    case MCalibrationCam::kUV:
     594      return gkLightGuidesEffUVErr  * gkLightGuidesEffUVErr / gkLightGuidesEffUV / gkLightGuidesEffUV;
     595      break;
     596    case MCalibrationCam::kCT1:
     597      return gkLightGuidesEffCT1Err * gkLightGuidesEffCT1Err / gkLightGuidesEffCT1 / gkLightGuidesEffCT1;
     598      break;
     599    default:
     600      return gkLightGuidesEffCT1Err * gkLightGuidesEffCT1Err / gkLightGuidesEffCT1 / gkLightGuidesEffCT1;
     601      break;
     602    }
     603  return -1.;
     604}
     605
     606// ------------------------------------------------------------------------------
     607//
     608// Get the light guides efficiency for Cherenkov spectra,
     609// depending on the zenith angle of the telescope
     610// FIXME: Lacking detailed measurement, these number are not yet available
     611//        for the individual colours and therefore, only one same number is
     612//        returned, namely gkLightGuidesEffBlue
     613//
     614Float_t MCalibrationQEPix::GetLightGuidesEff( const Float_t zenith )  const
     615{
     616  return gkLightGuidesEffBlue;
     617}
     618
     619
     620// ------------------------------------------------------------------------------
     621//
     622// Get the relative variance of the light guides efficiency for Cherenkov spectra
     623// depending on the zenith angle of the telescope
     624// FIXME: Lacking detailed measurement, these number are not yet available
     625//        for the individual colours and therefore, only one same number is
     626//        returned, namely gkLightGuidesEffBlueErr^2 / gkLightGuidesBlueEff^2
     627//
     628Float_t MCalibrationQEPix::GetLightGuidesEffRelVar( const Float_t zenith )  const
     629{
     630  return gkLightGuidesEffBlueErr  * gkLightGuidesEffBlueErr / gkLightGuidesEffBlue / gkLightGuidesEffBlue;
     631}
     632
     633
    508634
    509635// ------------------------------------------------------------------------------
    … …  
    848974  return ( GetAvNormPINDiodeRelVar()  + GetAverageQERelVar(zenith))
    849975    * GetQECascadesPINDiode(zenith) * GetQECascadesPINDiode(zenith);
     976}
     977
     978// -----------------------------------------------------------------
     979//
     980// Return the overall collection efficiency of the PMT
     981//
     982Float_t MCalibrationQEPix::GetPMTCollectionEff() const
     983{
     984  return gkPMTCollectionEff;
     985}
     986
     987// -----------------------------------------------------------------
     988//
     989// Return the relative variance of the collection efficiency of the PMT
     990//
     991Float_t MCalibrationQEPix::GetPMTCollectionEffRelVar() const
     992{
     993  return gkPMTCollectionEffErr * gkPMTCollectionEffErr / gkPMTCollectionEff / gkPMTCollectionEff;
    850994}
    851995

  • trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.h

    r4223 r4241  
    3030  static const Float_t gkDefaultQEUVErr;      //! Uncertainty Def. QE  at 370 nm (now set to: 0.07)
    3131  static const Float_t gkDefaultQECT1Err;     //! Uncertainty Def. QE  at 370 nm (now set to: 0.07)
     32  static const Float_t gkLightGuidesEffGreen;    //! Default Light guides efficiency at 520 nm
     33  static const Float_t gkLightGuidesEffGreenErr; //! Uncertainty Def. Light guides efficiency at 520 nm
     34  static const Float_t gkLightGuidesEffBlue;     //! Default Light guides efficiency at 460 nm
     35  static const Float_t gkLightGuidesEffBlueErr;  //! Uncertainty Def. Light guides efficiency at 460 nm
     36  static const Float_t gkLightGuidesEffUV;       //! Default Light guides efficiency at 370 nm
     37  static const Float_t gkLightGuidesEffUVErr;    //! Uncertainty Def. Light guides efficiency at 370 nm
     38  static const Float_t gkLightGuidesEffCT1;      //! Default Light guides efficiency at 370 nm
     39  static const Float_t gkLightGuidesEffCT1Err;   //! Uncertainty Def. Light guides efficiency at 370 nm
    3240  static const Float_t gkPMTCollectionEff;    //! Default Collection efficiency of the PMTs
    33   static const Float_t gkLightGuidesEff;      //! Default overall Light guides efficiency
    3441  static const Float_t gkPMTCollectionEffErr; //! Uncertainty Def. Collection efficiency of the PMTs (0.01)
    35   static const Float_t gkLightGuidesEffErr;   //! Uncertainty Def.overall Light guides efficiency (0.03)
    3642 
    3743  TArrayF fQEBlindPixel;                     // Calibrated QEs    (Blind Pixel Method)
    … …  
    7177  const Float_t GetAvNormFFactorRelVar()  const;
    7278  const Float_t GetAvNormPINDiodeRelVar()  const; 
    73  
     79
    7480public:
    7581
    … …  
    8995  Float_t GetDefaultQE                   ( const MCalibrationCam::PulserColor_t col ) const;
    9096  Float_t GetDefaultQERelVar             ( const MCalibrationCam::PulserColor_t col ) const; 
     97  Float_t GetLightGuidesEff              ( const MCalibrationCam::PulserColor_t col ) const;
     98  Float_t GetLightGuidesEffRelVar        ( const MCalibrationCam::PulserColor_t col ) const;
     99  Float_t GetLightGuidesEff              ( const Float_t zenith=0.)                   const;
     100  Float_t GetLightGuidesEffRelVar        ( const Float_t zenith=0.)                   const;
    91101  Float_t GetQEBlindPixel                ( const MCalibrationCam::PulserColor_t col ) const; 
    92102  Float_t GetQEBlindPixelErr             ( const MCalibrationCam::PulserColor_t col ) const;
    … …  
    113123  Float_t GetQEPINDiodeErr               ( const MCalibrationCam::PulserColor_t col ) const;
    114124  Float_t GetQEPINDiodeRelVar            ( const MCalibrationCam::PulserColor_t col ) const; 
     125  Float_t GetPMTCollectionEff()                                                       const;
     126  Float_t GetPMTCollectionEffRelVar()                                                 const;
    115127
    116128  Bool_t  IsAverageQEBlindPixelAvailable ()                                           const;
    … …  
    160172  Bool_t  UpdatePINDiodeMethod  ();
    161173
    162   ClassDef(MCalibrationQEPix, 2)     // Container Quantum Efficieny Calibration Results Pixel
     174  ClassDef(MCalibrationQEPix, 3)     // Container Quantum Efficieny Calibration Results Pixel
    163175};
    164176
Note: See TracChangeset for help on using the changeset viewer.