Index: /trunk/MagicSoft/Mars/Changelog =================================================================== --- /trunk/MagicSoft/Mars/Changelog (revision 3663) +++ /trunk/MagicSoft/Mars/Changelog (revision 3664) @@ -25,4 +25,6 @@ GetConvertedLoGain*() for better clarity + * mcalib/MCalibrationChargeCam.[h,cc] + - updated and enlarged documentation 2004/04/05: Markus Gaug Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc (revision 3663) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc (revision 3664) @@ -851,5 +851,5 @@ // F-Factor calibration // - if (fCam->CalcMeanFluxPhotonsFFactorMethod(*fGeom, *fBadPixels)) + if (fCam->CalcFluxPhotonsFFactorMethod(*fGeom, *fBadPixels)) { fCam->ApplyFFactorCalibration(*fGeom,*fBadPixels); Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.cc (revision 3663) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.cc (revision 3664) @@ -155,8 +155,8 @@ fAverageSectors = new TClonesArray("MCalibrationChargePix",1); - fMeanFluxPhesInnerPixel = 0.; - fMeanFluxPhesInnerPixelVar = 0.; - fMeanFluxPhesOuterPixel = 0.; - fMeanFluxPhesOuterPixelVar = 0.; + fFluxPhesInnerPixel = 0.; + fFluxPhesInnerPixelVar = 0.; + fFluxPhesOuterPixel = 0.; + fFluxPhesOuterPixelVar = 0.; CLRBIT(fFlags,kBlindPixelMethodValid); @@ -195,8 +195,8 @@ { - fMeanFluxPhesInnerPixel = 0.; - fMeanFluxPhesInnerPixelVar = 0.; - fMeanFluxPhesOuterPixel = 0.; - fMeanFluxPhesOuterPixelVar = 0.; + fFluxPhesInnerPixel = 0.; + fFluxPhesInnerPixelVar = 0.; + fFluxPhesOuterPixel = 0.; + fFluxPhesOuterPixelVar = 0.; CLRBIT(fFlags,kBlindPixelMethodValid); @@ -224,30 +224,30 @@ } -Float_t MCalibrationChargeCam::GetMeanFluxPhesInnerPixelErr() const -{ - if (fMeanFluxPhesInnerPixelVar <= 0.) +Float_t MCalibrationChargeCam::GetFluxPhesInnerPixelErr() const +{ + if (fFluxPhesInnerPixelVar <= 0.) return -1.; - return TMath::Sqrt(fMeanFluxPhesInnerPixelVar); -} - -Float_t MCalibrationChargeCam::GetMeanFluxPhesOuterPixelErr() const -{ - if (fMeanFluxPhesOuterPixelVar <= 0.) + return TMath::Sqrt(fFluxPhesInnerPixelVar); +} + +Float_t MCalibrationChargeCam::GetFluxPhesOuterPixelErr() const +{ + if (fFluxPhesOuterPixelVar <= 0.) return -1.; - return TMath::Sqrt(fMeanFluxPhesOuterPixelVar); -} - -Float_t MCalibrationChargeCam::GetMeanFluxPhotonsInnerPixelErr() const -{ - if (fMeanFluxPhotonsInnerPixelVar <= 0.) + return TMath::Sqrt(fFluxPhesOuterPixelVar); +} + +Float_t MCalibrationChargeCam::GetFluxPhotonsInnerPixelErr() const +{ + if (fFluxPhotonsInnerPixelVar <= 0.) return -1.; - return TMath::Sqrt(fMeanFluxPhotonsInnerPixelVar); -} - -Float_t MCalibrationChargeCam::GetMeanFluxPhotonsOuterPixelErr() const -{ - if (fMeanFluxPhotonsOuterPixelVar <= 0.) + return TMath::Sqrt(fFluxPhotonsInnerPixelVar); +} + +Float_t MCalibrationChargeCam::GetFluxPhotonsOuterPixelErr() const +{ + if (fFluxPhotonsOuterPixelVar <= 0.) return -1.; - return TMath::Sqrt(fMeanFluxPhotonsOuterPixelVar); + return TMath::Sqrt(fFluxPhotonsOuterPixelVar); } @@ -675,5 +675,5 @@ // which are fPheFFactorRelLimit sigmas from the mean. // -Bool_t MCalibrationChargeCam::CalcMeanFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad) +Bool_t MCalibrationChargeCam::CalcFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad) { @@ -737,6 +737,6 @@ else { - fMeanFluxPhesInnerPixel = sumphesinner/sumweightsinner; - fMeanFluxPhesInnerPixelVar = (1./sumweightsinner)*fMeanFluxPhesInnerPixel*fMeanFluxPhesInnerPixel; + fFluxPhesInnerPixel = sumphesinner/sumweightsinner; + fFluxPhesInnerPixelVar = (1./sumweightsinner)*fFluxPhesInnerPixel*fFluxPhesInnerPixel; } @@ -748,29 +748,29 @@ else { - fMeanFluxPhesOuterPixel = sumphesouter/sumweightsouter; - fMeanFluxPhesOuterPixelVar = (1./sumweightsouter)*fMeanFluxPhesOuterPixel*fMeanFluxPhesOuterPixel; - } - - Float_t meanFluxPhotonsRelVar = fMeanFluxPhesInnerPixelVar - / (fMeanFluxPhesInnerPixel * fMeanFluxPhesInnerPixel); - - fMeanFluxPhotonsInnerPixel = fMeanFluxPhesInnerPixel/fAverageQE; - fMeanFluxPhotonsInnerPixelVar = (meanFluxPhotonsRelVar + avQERelVar) - * fMeanFluxPhotonsInnerPixel * fMeanFluxPhotonsInnerPixel; - - fMeanFluxPhotonsOuterPixel = 4. *fMeanFluxPhotonsInnerPixel; - fMeanFluxPhotonsOuterPixelVar = 16.*fMeanFluxPhotonsInnerPixelVar; + fFluxPhesOuterPixel = sumphesouter/sumweightsouter; + fFluxPhesOuterPixelVar = (1./sumweightsouter)*fFluxPhesOuterPixel*fFluxPhesOuterPixel; + } + + Float_t meanFluxPhotonsRelVar = fFluxPhesInnerPixelVar + / (fFluxPhesInnerPixel * fFluxPhesInnerPixel); + + fFluxPhotonsInnerPixel = fFluxPhesInnerPixel/fAverageQE; + fFluxPhotonsInnerPixelVar = (meanFluxPhotonsRelVar + avQERelVar) + * fFluxPhotonsInnerPixel * fFluxPhotonsInnerPixel; + + fFluxPhotonsOuterPixel = 4. *fFluxPhotonsInnerPixel; + fFluxPhotonsOuterPixelVar = 16.*fFluxPhotonsInnerPixelVar; *fLog << inf << " Mean number of photo-electrons from inner pixels (F-Factor Method): " - << fMeanFluxPhesInnerPixel << " +- " << GetMeanFluxPhesInnerPixelErr() << endl; + << fFluxPhesInnerPixel << " +- " << GetFluxPhesInnerPixelErr() << endl; *fLog << inf << " Mean number of photons from inner pixels (F-Factor Method): " - << fMeanFluxPhotonsInnerPixel << " +- " << GetMeanFluxPhotonsInnerPixelErr() << endl; + << fFluxPhotonsInnerPixel << " +- " << GetFluxPhotonsInnerPixelErr() << endl; // // Here starts the second loop discarting pixels out of the range: // - const Float_t innervar = (Float_t)validinner*fPheFFactorRelVarLimit*fMeanFluxPhesInnerPixelVar; - const Float_t outervar = (Float_t)validouter*fPheFFactorRelVarLimit*fMeanFluxPhesOuterPixelVar; + const Float_t innervar = (Float_t)validinner*fPheFFactorRelVarLimit*fFluxPhesInnerPixelVar; + const Float_t outervar = (Float_t)validouter*fPheFFactorRelVarLimit*fFluxPhesOuterPixelVar; Float_t innererr; @@ -797,9 +797,9 @@ } - const Float_t lowerpheinnerlimit = fMeanFluxPhesInnerPixel - innererr; - const Float_t upperpheinnerlimit = fMeanFluxPhesInnerPixel + innererr; - - const Float_t lowerpheouterlimit = fMeanFluxPhesOuterPixel - outererr; - const Float_t upperpheouterlimit = fMeanFluxPhesOuterPixel + outererr; + const Float_t lowerpheinnerlimit = fFluxPhesInnerPixel - innererr; + const Float_t upperpheinnerlimit = fFluxPhesInnerPixel + innererr; + + const Float_t lowerpheouterlimit = fFluxPhesOuterPixel - outererr; + const Float_t upperpheouterlimit = fFluxPhesOuterPixel + outererr; sumweightsinner = 0.; @@ -871,6 +871,6 @@ else { - fMeanFluxPhesInnerPixel = sumphesinner/sumweightsinner; - fMeanFluxPhesInnerPixelVar = (1./sumweightsinner)*fMeanFluxPhesInnerPixel*fMeanFluxPhesInnerPixel; + fFluxPhesInnerPixel = sumphesinner/sumweightsinner; + fFluxPhesInnerPixelVar = (1./sumweightsinner)*fFluxPhesInnerPixel*fFluxPhesInnerPixel; } @@ -883,23 +883,23 @@ else { - fMeanFluxPhesOuterPixel = sumphesouter/sumweightsouter; - fMeanFluxPhesOuterPixelVar = (1./sumweightsouter)*fMeanFluxPhesOuterPixel*fMeanFluxPhesOuterPixel; - } - - meanFluxPhotonsRelVar = fMeanFluxPhesInnerPixelVar - / (fMeanFluxPhesInnerPixel * fMeanFluxPhesInnerPixel); - - fMeanFluxPhotonsInnerPixel = fMeanFluxPhesInnerPixel/fAverageQE; - fMeanFluxPhotonsInnerPixelVar = (meanFluxPhotonsRelVar + avQERelVar) - * fMeanFluxPhotonsInnerPixel * fMeanFluxPhotonsInnerPixel; - - fMeanFluxPhotonsOuterPixel = 4. *fMeanFluxPhotonsInnerPixel; - fMeanFluxPhotonsOuterPixelVar = 16.*fMeanFluxPhotonsInnerPixelVar; + fFluxPhesOuterPixel = sumphesouter/sumweightsouter; + fFluxPhesOuterPixelVar = (1./sumweightsouter)*fFluxPhesOuterPixel*fFluxPhesOuterPixel; + } + + meanFluxPhotonsRelVar = fFluxPhesInnerPixelVar + / (fFluxPhesInnerPixel * fFluxPhesInnerPixel); + + fFluxPhotonsInnerPixel = fFluxPhesInnerPixel/fAverageQE; + fFluxPhotonsInnerPixelVar = (meanFluxPhotonsRelVar + avQERelVar) + * fFluxPhotonsInnerPixel * fFluxPhotonsInnerPixel; + + fFluxPhotonsOuterPixel = 4. *fFluxPhotonsInnerPixel; + fFluxPhotonsOuterPixelVar = 16.*fFluxPhotonsInnerPixelVar; *fLog << inf << " Mean number of photo-electrons from inner pixels (F-Factor Method): " - << fMeanFluxPhesInnerPixel << " +- " << GetMeanFluxPhesInnerPixelErr() << endl; + << fFluxPhesInnerPixel << " +- " << GetFluxPhesInnerPixelErr() << endl; *fLog << inf << " Mean number of photons from inner pixels (F-Factor Method): " - << fMeanFluxPhotonsInnerPixel << " +- " << GetMeanFluxPhotonsInnerPixelErr() << endl; + << fFluxPhotonsInnerPixel << " +- " << GetFluxPhotonsInnerPixelErr() << endl; return kTRUE; @@ -909,6 +909,6 @@ { - const Float_t meanphotRelVar = fMeanFluxPhotonsInnerPixelVar - /( fMeanFluxPhotonsInnerPixel * fMeanFluxPhotonsInnerPixel ); + const Float_t meanphotRelVar = fFluxPhotonsInnerPixelVar + /( fFluxPhotonsInnerPixel * fFluxPhotonsInnerPixel ); TIter Next(fPixels); @@ -938,7 +938,7 @@ if (ratio == 1.) - conv = fMeanFluxPhotonsInnerPixel / pix->GetMean(); + conv = fFluxPhotonsInnerPixel / pix->GetMean(); else - conv = fMeanFluxPhotonsOuterPixel / pix->GetMean(); + conv = fFluxPhotonsOuterPixel / pix->GetMean(); if (conv <= 0.) @@ -968,5 +968,5 @@ // const Float_t totalFFactor = (pix->GetRSigma()/pix->GetMean()) - *TMath::Sqrt(fMeanFluxPhotonsInnerPixel); + *TMath::Sqrt(fFluxPhotonsInnerPixel); // Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.h =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.h (revision 3663) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.h (revision 3664) @@ -16,32 +16,29 @@ private: - static const Float_t fgAverageQE; // The default for fAverageQE (now set to: 0.18) - static const Float_t fgAverageQEErr; // The default for fAverageQEErr (now set to: 0.02) - static const Float_t fgConvFFactorRelErrLimit; // The default for fConvFFactorRelErrLimit (now set to: 0.35) - static const Float_t fgPheFFactorRelErrLimit; // The default for fPheFFactorRelErrLimit (now set to: 5.) + static const Float_t fgAverageQE; //! Default for fAverageQE (now set to: 0.18) + static const Float_t fgAverageQEErr; //! Default for fAverageQEErr (now set to: 0.02) + static const Float_t fgConvFFactorRelErrLimit; //! Default for fConvFFactorRelErrLimit (now set to: 0.35) + static const Float_t fgPheFFactorRelErrLimit; //! Default for fPheFFactorRelErrLimit (now set to: 5.) - Float_t fAverageQE; // The average quantum efficieny (see Class description) - Float_t fAverageQEVar; // The error of the average quantum efficieny (see Class description) - Float_t fConvFFactorRelVarLimit; // Acceptance limit for rel. error of conversion factor (FFactor method) - Float_t fPheFFactorRelVarLimit; // Acceptance limit for number of phe's w.r.t mean number (in variances) + Float_t fAverageQE; // Average quantum efficieny (see Class description) + Float_t fAverageQEVar; // Error av. quantum eff. (see Class description) + Float_t fConvFFactorRelVarLimit; // Acceptance limit rel. error conv. factor (F-Factor method) + Float_t fPheFFactorRelVarLimit; // Acceptance limit number phe's w.r.t its mean (in variances) - TH1D* fOffsets; //! - TH1D* fSlopes; //! - - TH2D* fOffvsSlope; //! + TH1D* fOffsets; //! Histogram with Higain-vs-LoGain fit result Offsets + TH1D* fSlopes; //! Histogram with Higain-vs-LoGain fit result Slopes + TH2D* fOffvsSlope; //! Histogram with Higain-vs-LoGain fit result Offsets vs. Slopes enum { kFFactorMethodValid, kBlindPixelMethodValid, kPINDiodeMethodValid, kCombinedMethodValid }; - Float_t fMeanFluxPhesInnerPixel; // The mean number of photo-electrons in an INNER PIXEL - Float_t fMeanFluxPhesInnerPixelVar; // The variance of the number of photo-electrons INNER PIXEL - Float_t fMeanFluxPhesOuterPixel; // The mean number of photo-electrons in an INNER PIXEL - Float_t fMeanFluxPhesOuterPixelVar; // The variance of the number of photo-electrons INNER PIXEL - - Float_t fMeanFluxPhotonsInnerPixel; // The mean number of photo-electrons in an INNER PIXEL - Float_t fMeanFluxPhotonsInnerPixelVar; // The variance of the number of photo-electrons INNER PIXEL - Float_t fMeanFluxPhotonsOuterPixel; // The mean number of photo-electrons in an INNER PIXEL - Float_t fMeanFluxPhotonsOuterPixelVar; // The variance of the number of photo-electrons INNER PIXEL - - Byte_t fFlags; // Byte to hold the flags + Float_t fFluxPhesInnerPixel; // Mean nr. photo-electrons in INNER PIXEL + Float_t fFluxPhesInnerPixelVar; // Variance nr. photo-electrons INNER PIXEL + Float_t fFluxPhesOuterPixel; // Mean nr. photo-electrons in an OUTER PIXEL + Float_t fFluxPhesOuterPixelVar; // Variance nr, photo-electrons OUTER PIXEL + Float_t fFluxPhotonsInnerPixel; // Mean nr. photo-electrons in INNER PIXEL + Float_t fFluxPhotonsInnerPixelVar; // Variance nr. photo-electrons INNER PIXEL + Float_t fFluxPhotonsOuterPixel; // Mean nr. photo-electrons in OUTER PIXEL + Float_t fFluxPhotonsOuterPixelVar; // Variance nr. photo-electrons OUTER PIXEL + Byte_t fFlags; // Bit-fieldto hold the flags public: @@ -53,38 +50,35 @@ // Setters - void SetAverageQE( const Float_t qe= fgAverageQE, - const Float_t err=fgAverageQEErr) { fAverageQE = qe; - fAverageQEVar = err*err; } + void SetAverageQE ( const Float_t q=fgAverageQE, + const Float_t e=fgAverageQEErr) { fAverageQE = q; fAverageQEVar = e*e; } + void SetBlindPixelMethodValid ( const Bool_t b=kTRUE ); void SetConvFFactorRelErrLimit( const Float_t f=fgConvFFactorRelErrLimit ) { fConvFFactorRelVarLimit = f*f; } - void SetPheFFactorRelErrLimit ( const Float_t f=fgPheFFactorRelErrLimit ) { fPheFFactorRelVarLimit = f*f; } - - void SetFFactorMethodValid( const Bool_t b = kTRUE ); - void SetBlindPixelMethodValid( const Bool_t b = kTRUE ); - void SetPINDiodeMethodValid( const Bool_t b = kTRUE ); + void SetFFactorMethodValid ( const Bool_t b=kTRUE ); + void SetPheFFactorRelErrLimit ( const Float_t f=fgPheFFactorRelErrLimit ) { fPheFFactorRelVarLimit = f*f; } + void SetPINDiodeMethodValid ( const Bool_t b=kTRUE ); // Getters - Bool_t GetConversionFactorFFactor( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); - Bool_t GetConversionFactorBlindPixel( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); - Bool_t GetConversionFactorPINDiode( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); - Bool_t GetConversionFactorCombined( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); + Bool_t GetConversionFactorFFactor ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); + Bool_t GetConversionFactorBlindPixel ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); + Bool_t GetConversionFactorPINDiode ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); + Bool_t GetConversionFactorCombined ( Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma ); - Float_t GetMeanFluxPhesInnerPixel() const { return fMeanFluxPhesInnerPixel; } - Float_t GetMeanFluxPhesInnerPixelErr() const; - Float_t GetMeanFluxPhesOuterPixel() const { return fMeanFluxPhesOuterPixel; } - Float_t GetMeanFluxPhesOuterPixelErr() const; + Float_t GetFluxPhesInnerPixel() const { return fFluxPhesInnerPixel; } + Float_t GetFluxPhesInnerPixelErr() const; + Float_t GetFluxPhesOuterPixel() const { return fFluxPhesOuterPixel; } + Float_t GetFluxPhesOuterPixelErr() const; + Float_t GetFluxPhotonsInnerPixel() const { return fFluxPhotonsInnerPixel; } + Float_t GetFluxPhotonsInnerPixelErr() const; + Float_t GetFluxPhotonsOuterPixel() const { return fFluxPhotonsOuterPixel; } + Float_t GetFluxPhotonsOuterPixelErr() const; - Float_t GetMeanFluxPhotonsInnerPixel() const { return fMeanFluxPhotonsInnerPixel; } - Float_t GetMeanFluxPhotonsInnerPixelErr() const; - Float_t GetMeanFluxPhotonsOuterPixel() const { return fMeanFluxPhotonsOuterPixel; } - Float_t GetMeanFluxPhotonsOuterPixelErr() const; - - Bool_t IsBlindPixelMethodValid() const; - Bool_t IsPINDiodeMethodValid() const; + Bool_t IsBlindPixelMethodValid() const; + Bool_t IsPINDiodeMethodValid() const; // Prints - void Print(Option_t *o="") const; + void Print(Option_t *o="") const; // Draws - void DrawPixelContent(Int_t num) const; + void DrawPixelContent(Int_t num) const; // void DrawHiLoFits(); @@ -92,15 +86,16 @@ Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const; - Bool_t CalcMeanFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad); + Bool_t CalcFluxPhotonsFFactorMethod(const MGeomCam &geom, MBadPixelsCam &bad); - void ApplyPINDiodeCalibration(const MGeomCam &geom, - const MBadPixelsCam &bad, - const MCalibrationChargePINDiode &pindiode); - void ApplyBlindPixelCalibration(const MGeomCam &geom, - const MBadPixelsCam &bad, - const MCalibrationChargeBlindPix &blindpix); - void ApplyFFactorCalibration(const MGeomCam &geom, const MBadPixelsCam &bad); + void ApplyPINDiodeCalibration ( const MGeomCam &geom, + const MBadPixelsCam &bad, + const MCalibrationChargePINDiode &pindiode ); + void ApplyBlindPixelCalibration ( const MGeomCam &geom, + const MBadPixelsCam &bad, + const MCalibrationChargeBlindPix &blindpix ); + void ApplyFFactorCalibration ( const MGeomCam &geom, + const MBadPixelsCam &bad ); - ClassDef(MCalibrationChargeCam, 1) // Container for calibration of the camera + ClassDef(MCalibrationChargeCam, 1) // Container Charge Calibration Results Camera };