Changeset 3664 for trunk/MagicSoft/Mars


Ignore:
Timestamp:
04/06/04 12:16:14 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3663 r3664  
    2525       GetConvertedLoGain*() for better clarity
    2626
     27   * mcalib/MCalibrationChargeCam.[h,cc]
     28     - updated and enlarged documentation
    2729
    2830 2004/04/05: Markus Gaug

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

    r3662 r3664  
    851851  // F-Factor calibration
    852852  //
    853   if (fCam->CalcMeanFluxPhotonsFFactorMethod(*fGeom, *fBadPixels))
     853  if (fCam->CalcFluxPhotonsFFactorMethod(*fGeom, *fBadPixels))
    854854  {
    855855    fCam->ApplyFFactorCalibration(*fGeom,*fBadPixels);

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

    r3662 r3664  
    155155    fAverageSectors   = new TClonesArray("MCalibrationChargePix",1);
    156156
    157     fMeanFluxPhesInnerPixel       = 0.;
    158     fMeanFluxPhesInnerPixelVar    = 0.;
    159     fMeanFluxPhesOuterPixel       = 0.;
    160     fMeanFluxPhesOuterPixelVar    = 0.;
     157    fFluxPhesInnerPixel       = 0.;
     158    fFluxPhesInnerPixelVar    = 0.;
     159    fFluxPhesOuterPixel       = 0.;
     160    fFluxPhesOuterPixelVar    = 0.;
    161161   
    162162    CLRBIT(fFlags,kBlindPixelMethodValid);
    … …  
    195195{
    196196
    197   fMeanFluxPhesInnerPixel       = 0.;
    198   fMeanFluxPhesInnerPixelVar    = 0.;
    199   fMeanFluxPhesOuterPixel       = 0.;
    200   fMeanFluxPhesOuterPixelVar    = 0.;
     197  fFluxPhesInnerPixel       = 0.;
     198  fFluxPhesInnerPixelVar    = 0.;
     199  fFluxPhesOuterPixel       = 0.;
     200  fFluxPhesOuterPixelVar    = 0.;
    201201
    202202  CLRBIT(fFlags,kBlindPixelMethodValid);
    … …  
    224224}
    225225
    226 Float_t MCalibrationChargeCam::GetMeanFluxPhesInnerPixelErr()   const
    227 {
    228   if (fMeanFluxPhesInnerPixelVar <= 0.)
     226Float_t MCalibrationChargeCam::GetFluxPhesInnerPixelErr()   const
     227{
     228  if (fFluxPhesInnerPixelVar <= 0.)
    229229    return -1.;
    230   return TMath::Sqrt(fMeanFluxPhesInnerPixelVar);
    231 }
    232 
    233 Float_t MCalibrationChargeCam::GetMeanFluxPhesOuterPixelErr()   const
    234 {
    235   if (fMeanFluxPhesOuterPixelVar <= 0.)
     230  return TMath::Sqrt(fFluxPhesInnerPixelVar);
     231}
     232
     233Float_t MCalibrationChargeCam::GetFluxPhesOuterPixelErr()   const
     234{
     235  if (fFluxPhesOuterPixelVar <= 0.)
    236236    return -1.;
    237   return TMath::Sqrt(fMeanFluxPhesOuterPixelVar);
    238 }
    239 
    240 Float_t MCalibrationChargeCam::GetMeanFluxPhotonsInnerPixelErr()   const
    241 {
    242   if (fMeanFluxPhotonsInnerPixelVar <= 0.)
     237  return TMath::Sqrt(fFluxPhesOuterPixelVar);
     238}
     239
     240Float_t MCalibrationChargeCam::GetFluxPhotonsInnerPixelErr()   const
     241{
     242  if (fFluxPhotonsInnerPixelVar <= 0.)
    243243    return -1.;
    244   return TMath::Sqrt(fMeanFluxPhotonsInnerPixelVar);
    245 }
    246 
    247 Float_t MCalibrationChargeCam::GetMeanFluxPhotonsOuterPixelErr()   const
    248 {
    249   if (fMeanFluxPhotonsOuterPixelVar <= 0.)
     244  return TMath::Sqrt(fFluxPhotonsInnerPixelVar);
     245}
     246
     247Float_t MCalibrationChargeCam::GetFluxPhotonsOuterPixelErr()   const
     248{
     249  if (fFluxPhotonsOuterPixelVar <= 0.)
    250250    return -1.;
    251   return TMath::Sqrt(fMeanFluxPhotonsOuterPixelVar);
     251  return TMath::Sqrt(fFluxPhotonsOuterPixelVar);
    252252}
    253253
    … …  
    675675// which are fPheFFactorRelLimit sigmas from the mean.
    676676//
    677 Bool_t MCalibrationChargeCam::CalcMeanFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad)
     677Bool_t MCalibrationChargeCam::CalcFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad)
    678678{
    679679
    … …  
    737737  else
    738738    {
    739       fMeanFluxPhesInnerPixel    = sumphesinner/sumweightsinner;
    740       fMeanFluxPhesInnerPixelVar = (1./sumweightsinner)*fMeanFluxPhesInnerPixel*fMeanFluxPhesInnerPixel;
     739      fFluxPhesInnerPixel    = sumphesinner/sumweightsinner;
     740      fFluxPhesInnerPixelVar = (1./sumweightsinner)*fFluxPhesInnerPixel*fFluxPhesInnerPixel;
    741741    }
    742742
    … …  
    748748  else
    749749    {
    750       fMeanFluxPhesOuterPixel    = sumphesouter/sumweightsouter;
    751       fMeanFluxPhesOuterPixelVar = (1./sumweightsouter)*fMeanFluxPhesOuterPixel*fMeanFluxPhesOuterPixel;
    752     }
    753 
    754   Float_t meanFluxPhotonsRelVar  = fMeanFluxPhesInnerPixelVar
    755                                 / (fMeanFluxPhesInnerPixel * fMeanFluxPhesInnerPixel);
    756 
    757   fMeanFluxPhotonsInnerPixel    =  fMeanFluxPhesInnerPixel/fAverageQE;
    758   fMeanFluxPhotonsInnerPixelVar =  (meanFluxPhotonsRelVar + avQERelVar)
    759                                  * fMeanFluxPhotonsInnerPixel * fMeanFluxPhotonsInnerPixel;
    760 
    761   fMeanFluxPhotonsOuterPixel    = 4. *fMeanFluxPhotonsInnerPixel;
    762   fMeanFluxPhotonsOuterPixelVar = 16.*fMeanFluxPhotonsInnerPixelVar; 
     750      fFluxPhesOuterPixel    = sumphesouter/sumweightsouter;
     751      fFluxPhesOuterPixelVar = (1./sumweightsouter)*fFluxPhesOuterPixel*fFluxPhesOuterPixel;
     752    }
     753
     754  Float_t meanFluxPhotonsRelVar  = fFluxPhesInnerPixelVar
     755                                / (fFluxPhesInnerPixel * fFluxPhesInnerPixel);
     756
     757  fFluxPhotonsInnerPixel    =  fFluxPhesInnerPixel/fAverageQE;
     758  fFluxPhotonsInnerPixelVar =  (meanFluxPhotonsRelVar + avQERelVar)
     759                                 * fFluxPhotonsInnerPixel * fFluxPhotonsInnerPixel;
     760
     761  fFluxPhotonsOuterPixel    = 4. *fFluxPhotonsInnerPixel;
     762  fFluxPhotonsOuterPixelVar = 16.*fFluxPhotonsInnerPixelVar; 
    763763 
    764764  *fLog << inf << " Mean number of photo-electrons from inner pixels (F-Factor Method): "
    765         << fMeanFluxPhesInnerPixel << " +- " << GetMeanFluxPhesInnerPixelErr() << endl;
     765        << fFluxPhesInnerPixel << " +- " << GetFluxPhesInnerPixelErr() << endl;
    766766
    767767  *fLog << inf << " Mean number of photons from inner pixels (F-Factor Method): "
    768         << fMeanFluxPhotonsInnerPixel << " +- " << GetMeanFluxPhotonsInnerPixelErr() << endl;
     768        << fFluxPhotonsInnerPixel << " +- " << GetFluxPhotonsInnerPixelErr() << endl;
    769769
    770770  //
    771771  // Here starts the second loop discarting pixels out of the range:
    772772  //
    773   const Float_t innervar = (Float_t)validinner*fPheFFactorRelVarLimit*fMeanFluxPhesInnerPixelVar;
    774   const Float_t outervar = (Float_t)validouter*fPheFFactorRelVarLimit*fMeanFluxPhesOuterPixelVar;
     773  const Float_t innervar = (Float_t)validinner*fPheFFactorRelVarLimit*fFluxPhesInnerPixelVar;
     774  const Float_t outervar = (Float_t)validouter*fPheFFactorRelVarLimit*fFluxPhesOuterPixelVar;
    775775 
    776776  Float_t innererr;
    … …  
    797797    }
    798798
    799   const Float_t lowerpheinnerlimit = fMeanFluxPhesInnerPixel - innererr;
    800   const Float_t upperpheinnerlimit = fMeanFluxPhesInnerPixel + innererr;
    801 
    802   const Float_t lowerpheouterlimit = fMeanFluxPhesOuterPixel - outererr;
    803   const Float_t upperpheouterlimit = fMeanFluxPhesOuterPixel + outererr;
     799  const Float_t lowerpheinnerlimit = fFluxPhesInnerPixel - innererr;
     800  const Float_t upperpheinnerlimit = fFluxPhesInnerPixel + innererr;
     801
     802  const Float_t lowerpheouterlimit = fFluxPhesOuterPixel - outererr;
     803  const Float_t upperpheouterlimit = fFluxPhesOuterPixel + outererr;
    804804
    805805  sumweightsinner = 0.;
    … …  
    871871  else
    872872    {
    873       fMeanFluxPhesInnerPixel    = sumphesinner/sumweightsinner;
    874       fMeanFluxPhesInnerPixelVar = (1./sumweightsinner)*fMeanFluxPhesInnerPixel*fMeanFluxPhesInnerPixel;
     873      fFluxPhesInnerPixel    = sumphesinner/sumweightsinner;
     874      fFluxPhesInnerPixelVar = (1./sumweightsinner)*fFluxPhesInnerPixel*fFluxPhesInnerPixel;
    875875
    876876    }
    … …  
    883883  else
    884884    {
    885       fMeanFluxPhesOuterPixel    = sumphesouter/sumweightsouter;
    886       fMeanFluxPhesOuterPixelVar = (1./sumweightsouter)*fMeanFluxPhesOuterPixel*fMeanFluxPhesOuterPixel;
    887     }
    888 
    889   meanFluxPhotonsRelVar = fMeanFluxPhesInnerPixelVar
    890                        / (fMeanFluxPhesInnerPixel    * fMeanFluxPhesInnerPixel);
    891 
    892   fMeanFluxPhotonsInnerPixel    =  fMeanFluxPhesInnerPixel/fAverageQE;
    893   fMeanFluxPhotonsInnerPixelVar =  (meanFluxPhotonsRelVar + avQERelVar)
    894                                  * fMeanFluxPhotonsInnerPixel * fMeanFluxPhotonsInnerPixel;
    895 
    896   fMeanFluxPhotonsOuterPixel    = 4. *fMeanFluxPhotonsInnerPixel;
    897   fMeanFluxPhotonsOuterPixelVar = 16.*fMeanFluxPhotonsInnerPixelVar; 
     885      fFluxPhesOuterPixel    = sumphesouter/sumweightsouter;
     886      fFluxPhesOuterPixelVar = (1./sumweightsouter)*fFluxPhesOuterPixel*fFluxPhesOuterPixel;
     887    }
     888
     889  meanFluxPhotonsRelVar = fFluxPhesInnerPixelVar
     890                       / (fFluxPhesInnerPixel    * fFluxPhesInnerPixel);
     891
     892  fFluxPhotonsInnerPixel    =  fFluxPhesInnerPixel/fAverageQE;
     893  fFluxPhotonsInnerPixelVar =  (meanFluxPhotonsRelVar + avQERelVar)
     894                                 * fFluxPhotonsInnerPixel * fFluxPhotonsInnerPixel;
     895
     896  fFluxPhotonsOuterPixel    = 4. *fFluxPhotonsInnerPixel;
     897  fFluxPhotonsOuterPixelVar = 16.*fFluxPhotonsInnerPixelVar; 
    898898
    899899  *fLog << inf << " Mean number of photo-electrons from inner pixels (F-Factor Method): "
    900         << fMeanFluxPhesInnerPixel << " +- " << GetMeanFluxPhesInnerPixelErr() << endl;
     900        << fFluxPhesInnerPixel << " +- " << GetFluxPhesInnerPixelErr() << endl;
    901901
    902902  *fLog << inf << " Mean number of photons from inner pixels (F-Factor Method): "
    903         << fMeanFluxPhotonsInnerPixel << " +- " << GetMeanFluxPhotonsInnerPixelErr() << endl;
     903        << fFluxPhotonsInnerPixel << " +- " << GetFluxPhotonsInnerPixelErr() << endl;
    904904
    905905  return kTRUE;
    … …  
    909909{
    910910
    911   const Float_t meanphotRelVar  = fMeanFluxPhotonsInnerPixelVar
    912                                /( fMeanFluxPhotonsInnerPixel    * fMeanFluxPhotonsInnerPixel );
     911  const Float_t meanphotRelVar  = fFluxPhotonsInnerPixelVar
     912                               /( fFluxPhotonsInnerPixel    * fFluxPhotonsInnerPixel );
    913913
    914914  TIter Next(fPixels);
    … …  
    938938     
    939939      if (ratio == 1.)
    940         conv               = fMeanFluxPhotonsInnerPixel / pix->GetMean();
     940        conv               = fFluxPhotonsInnerPixel / pix->GetMean();
    941941      else
    942         conv               = fMeanFluxPhotonsOuterPixel / pix->GetMean();
     942        conv               = fFluxPhotonsOuterPixel / pix->GetMean();
    943943
    944944      if (conv <= 0.)
    … …  
    968968      //
    969969      const Float_t totalFFactor  =  (pix->GetRSigma()/pix->GetMean())
    970                                     *TMath::Sqrt(fMeanFluxPhotonsInnerPixel);
     970                                    *TMath::Sqrt(fFluxPhotonsInnerPixel);
    971971     
    972972      //

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

    r3651 r3664  
    1616private:
    1717 
    18   static const Float_t fgAverageQE;              // The default for fAverageQE    (now set to: 0.18)
    19   static const Float_t fgAverageQEErr;           // The default for fAverageQEErr (now set to: 0.02)
    20   static const Float_t fgConvFFactorRelErrLimit; // The default for fConvFFactorRelErrLimit (now set to: 0.35)
    21   static const Float_t fgPheFFactorRelErrLimit;  // The default for fPheFFactorRelErrLimit  (now set to: 5.)
     18  static const Float_t fgAverageQE;              //! Default for fAverageQE              (now set to: 0.18)
     19  static const Float_t fgAverageQEErr;           //! Default for fAverageQEErr          (now set to: 0.02)
     20  static const Float_t fgConvFFactorRelErrLimit; //! Default for fConvFFactorRelErrLimit (now set to: 0.35)
     21  static const Float_t fgPheFFactorRelErrLimit;  //! Default for fPheFFactorRelErrLimit  (now set to: 5.)
    2222 
    23   Float_t fAverageQE;                // The average quantum efficieny (see Class description)
    24   Float_t fAverageQEVar;             // The error of the average quantum efficieny (see Class description)
    25   Float_t fConvFFactorRelVarLimit;   // Acceptance limit for rel. error of conversion factor (FFactor method)
    26   Float_t fPheFFactorRelVarLimit;    // Acceptance limit for number of phe's w.r.t mean number (in variances)
     23  Float_t fAverageQE;                // Average quantum efficieny (see Class description)
     24  Float_t fAverageQEVar;             // Error av. quantum eff.    (see Class description)
     25  Float_t fConvFFactorRelVarLimit;   // Acceptance limit rel. error conv. factor (F-Factor method)
     26  Float_t fPheFFactorRelVarLimit;    // Acceptance limit number phe's w.r.t its mean (in variances)
    2727 
    28   TH1D* fOffsets;                    //!
    29   TH1D* fSlopes;                     //!
    30  
    31   TH2D* fOffvsSlope;                 //!
     28  TH1D* fOffsets;                    //! Histogram with Higain-vs-LoGain fit result Offsets
     29  TH1D* fSlopes;                     //! Histogram with Higain-vs-LoGain fit result Slopes
     30  TH2D* fOffvsSlope;                 //! Histogram with Higain-vs-LoGain fit result Offsets vs. Slopes
    3231
    3332  enum  { kFFactorMethodValid, kBlindPixelMethodValid, kPINDiodeMethodValid, kCombinedMethodValid };
    3433
    35   Float_t fMeanFluxPhesInnerPixel;        //  The mean number of photo-electrons in an INNER PIXEL
    36   Float_t fMeanFluxPhesInnerPixelVar;     //  The variance of the number of photo-electrons INNER PIXEL 
    37   Float_t fMeanFluxPhesOuterPixel;        //  The mean number of photo-electrons in an INNER PIXEL
    38   Float_t fMeanFluxPhesOuterPixelVar;     //  The variance of the number of photo-electrons INNER PIXEL 
    39 
    40   Float_t fMeanFluxPhotonsInnerPixel;     //  The mean number of photo-electrons in an INNER PIXEL
    41   Float_t fMeanFluxPhotonsInnerPixelVar;  //  The variance of the number of photo-electrons INNER PIXEL 
    42   Float_t fMeanFluxPhotonsOuterPixel;     //  The mean number of photo-electrons in an INNER PIXEL
    43   Float_t fMeanFluxPhotonsOuterPixelVar;  //  The variance of the number of photo-electrons INNER PIXEL 
    44  
    45   Byte_t fFlags;                          // Byte to hold the flags
     34  Float_t fFluxPhesInnerPixel;       // Mean nr.  photo-electrons in INNER PIXEL
     35  Float_t fFluxPhesInnerPixelVar;    // Variance nr. photo-electrons INNER PIXEL 
     36  Float_t fFluxPhesOuterPixel;       // Mean nr. photo-electrons in an OUTER PIXEL
     37  Float_t fFluxPhesOuterPixelVar;    // Variance nr, photo-electrons OUTER PIXEL 
     38  Float_t fFluxPhotonsInnerPixel;    // Mean nr. photo-electrons in INNER PIXEL
     39  Float_t fFluxPhotonsInnerPixelVar; // Variance nr. photo-electrons INNER PIXEL 
     40  Float_t fFluxPhotonsOuterPixel;    // Mean nr. photo-electrons in OUTER PIXEL
     41  Float_t fFluxPhotonsOuterPixelVar; // Variance nr. photo-electrons OUTER PIXEL 
     42  Byte_t fFlags;                     // Bit-fieldto hold the flags
    4643 
    4744public:
    … …  
    5350
    5451  // Setters   
    55   void SetAverageQE(          const Float_t qe= fgAverageQE,
    56                               const Float_t err=fgAverageQEErr)         { fAverageQE    = qe;           
    57                                                                           fAverageQEVar = err*err; }
     52  void SetAverageQE             ( const Float_t q=fgAverageQE,
     53                                  const Float_t e=fgAverageQEErr)      { fAverageQE = q; fAverageQEVar = e*e; }
     54  void SetBlindPixelMethodValid ( const Bool_t  b=kTRUE                    );
    5855  void SetConvFFactorRelErrLimit( const Float_t f=fgConvFFactorRelErrLimit ) { fConvFFactorRelVarLimit = f*f; }
    59   void SetPheFFactorRelErrLimit (  const Float_t f=fgPheFFactorRelErrLimit )     { fPheFFactorRelVarLimit = f*f;    } 
    60 
    61   void SetFFactorMethodValid(    const Bool_t b = kTRUE );
    62   void SetBlindPixelMethodValid( const Bool_t b = kTRUE );
    63   void SetPINDiodeMethodValid(   const Bool_t b = kTRUE ); 
     56  void SetFFactorMethodValid    ( const Bool_t  b=kTRUE                    );
     57  void SetPheFFactorRelErrLimit ( const Float_t f=fgPheFFactorRelErrLimit  ) { fPheFFactorRelVarLimit  = f*f; } 
     58  void SetPINDiodeMethodValid   ( const Bool_t  b=kTRUE                    ); 
    6459
    6560  // Getters
    66   Bool_t  GetConversionFactorFFactor(    Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
    67   Bool_t  GetConversionFactorBlindPixel( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
    68   Bool_t  GetConversionFactorPINDiode(  Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
    69   Bool_t  GetConversionFactorCombined(  Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
     61  Bool_t  GetConversionFactorFFactor    ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
     62  Bool_t  GetConversionFactorBlindPixel ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
     63  Bool_t  GetConversionFactorPINDiode   ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
     64  Bool_t  GetConversionFactorCombined   ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
    7065
    71   Float_t GetMeanFluxPhesInnerPixel()     const { return fMeanFluxPhesInnerPixel;     }
    72   Float_t GetMeanFluxPhesInnerPixelErr()  const;
    73   Float_t GetMeanFluxPhesOuterPixel()     const { return fMeanFluxPhesOuterPixel;     }
    74   Float_t GetMeanFluxPhesOuterPixelErr()  const;
     66  Float_t GetFluxPhesInnerPixel()        const { return fFluxPhesInnerPixel;    }
     67  Float_t GetFluxPhesInnerPixelErr()     const;
     68  Float_t GetFluxPhesOuterPixel()        const { return fFluxPhesOuterPixel;    }
     69  Float_t GetFluxPhesOuterPixelErr()     const;
     70  Float_t GetFluxPhotonsInnerPixel()     const { return fFluxPhotonsInnerPixel; }
     71  Float_t GetFluxPhotonsInnerPixelErr()  const;
     72  Float_t GetFluxPhotonsOuterPixel()     const { return fFluxPhotonsOuterPixel; }
     73  Float_t GetFluxPhotonsOuterPixelErr()  const;
    7574
    76   Float_t GetMeanFluxPhotonsInnerPixel()     const { return fMeanFluxPhotonsInnerPixel;     }
    77   Float_t GetMeanFluxPhotonsInnerPixelErr()  const;
    78   Float_t GetMeanFluxPhotonsOuterPixel()     const { return fMeanFluxPhotonsOuterPixel;     }
    79   Float_t GetMeanFluxPhotonsOuterPixelErr()  const;
    80 
    81   Bool_t IsBlindPixelMethodValid()   const;
    82   Bool_t IsPINDiodeMethodValid()     const; 
     75  Bool_t IsBlindPixelMethodValid()       const;
     76  Bool_t IsPINDiodeMethodValid()         const; 
    8377
    8478  // Prints
    85   void Print(Option_t *o="") const;
     79  void Print(Option_t *o="")             const;
    8680 
    8781  // Draws
    88   void DrawPixelContent(Int_t num) const;   
     82  void DrawPixelContent(Int_t num)       const;   
    8983//  void DrawHiLoFits();
    9084 
    … …  
    9286  Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
    9387
    94   Bool_t CalcMeanFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad); 
     88  Bool_t CalcFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad); 
    9589
    96   void   ApplyPINDiodeCalibration(const MGeomCam &geom,
    97                                   const MBadPixelsCam &bad,
    98                                   const MCalibrationChargePINDiode &pindiode);
    99   void   ApplyBlindPixelCalibration(const MGeomCam &geom,
    100                                     const MBadPixelsCam &bad,
    101                                     const MCalibrationChargeBlindPix &blindpix);
    102   void   ApplyFFactorCalibration(const MGeomCam &geom, const MBadPixelsCam &bad);
     90  void   ApplyPINDiodeCalibration   ( const MGeomCam &geom,
     91                                      const MBadPixelsCam &bad,
     92                                      const MCalibrationChargePINDiode &pindiode );
     93  void   ApplyBlindPixelCalibration ( const MGeomCam &geom,
     94                                      const MBadPixelsCam &bad,
     95                                      const MCalibrationChargeBlindPix &blindpix );
     96  void   ApplyFFactorCalibration    ( const MGeomCam &geom,
     97                                      const MBadPixelsCam &bad                   );
    10398
    104   ClassDef(MCalibrationChargeCam, 1)    // Container for calibration of the camera
     99  ClassDef(MCalibrationChargeCam, 1)    // Container Charge Calibration Results Camera
    105100};
    106101
Note: See TracChangeset for help on using the changeset viewer.