Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc (revision 5199) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc (revision 5200) @@ -413,15 +413,10 @@ Float_t MCalibrationChargePix::GetConvertedRSigma() const { - - Float_t rsigma = 0.; - if (IsHiGainSaturation()) - rsigma = TMath::Sqrt(fLoGainRSigmaSquare)*fConversionHiLo; - else - rsigma = TMath::Sqrt(fHiGainRSigmaSquare); - - if (rsigma < 0) + if (fRSigmaSquare < 0) return -1; - return rsigma ; + const Float_t rsigma = TMath::Sqrt(fRSigmaSquare); + + return IsHiGainSaturation() ? rsigma*fConversionHiLo : rsigma ; } @@ -440,29 +435,108 @@ { - Float_t rsigmavar = 0.; + if (fRSigmaSquareVar < 0) + return -1; + // // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) // + const Float_t rsigmaVar = 0.25 * fRSigmaSquareVar / fRSigmaSquare; + if (IsHiGainSaturation()) - rsigmavar = 0.25 * fLoGainRSigmaSquareVar / fLoGainRSigmaSquare; - else - rsigmavar = 0.25 * fHiGainRSigmaSquareVar / fHiGainRSigmaSquare; - - if (rsigmavar < 0) + return TMath::Sqrt(rsigmaVar/fRSigmaSquare + GetConversionHiLoRelVar()) * GetRSigma(); + else + return TMath::Sqrt(rsigmaVar); + +} + +// -------------------------------------------------------------------------- +// +// Get the reduced Sigma: +// - If fRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1. +// +Float_t MCalibrationChargePix::GetRSigma() const +{ + if (fRSigmaSquare < 0) return -1; - if (IsHiGainSaturation()) - return TMath::Sqrt(rsigmavar/fLoGainRSigmaSquare + GetConversionHiLoRelVar()) * GetLoGainRSigma(); - else - return TMath::Sqrt(rsigmavar); - -} - - + return TMath::Sqrt(fRSigmaSquare); + +} + +// -------------------------------------------------------------------------- +// +// Get the error of the reduced Sigma: +// - If fRSigmaSquareVar is smaller than 0 (i.e. has not yet been set), return -1. +// - Calculate the absolute variance of the reduced sigma with the formula: +// reduced sigma variance = 0.25 * fRSigmaSquareVar / fRSigmaSquare +// +Float_t MCalibrationChargePix::GetRSigmaErr() const +{ + + if (fRSigmaSquareVar < 0) + return -1; + + // + // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) + // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) + // + return TMath::Sqrt(0.25 * fRSigmaSquareVar / fRSigmaSquare); + +} + +// -------------------------------------------------------------------------- +// +// Get the reduced Sigma per Charge: +// - If GetRSigma() is smaller or equal 0. (i.e. has not yet been set), return -1. +// - If GetMean() is 0. or -1. (i.e. has not yet been set), return -1. +// - Return GetRSigma() / GetMean() +// +Float_t MCalibrationChargePix::GetRSigmaPerCharge() const +{ + + const Float_t rsigma = GetRSigma(); + + if (rsigma <= 0) + return -1.; + + + const Float_t mean = GetMean(); + + if (mean == 0. || mean == -1.) + return -1.; + + return rsigma / mean; +} + + +// -------------------------------------------------------------------------- +// +// Get the error of the reduced Sigma per Charge: +// - If GetRSigmaRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. +// - If GetMeanRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. +// - Return the propagated error of GetRSigmaPerCharge() +// +Float_t MCalibrationChargePix::GetRSigmaPerChargeErr() const +{ + + const Float_t rsigmarelvar = GetRSigmaRelVar(); + + if (rsigmarelvar <= 0) + return -1.; + + + const Float_t meanrelvar = GetMeanRelVar(); + + if (meanrelvar <= 0.) + return -1.; + + return TMath::Sqrt(rsigmarelvar + meanrelvar) * GetRSigmaPerCharge(); +} + // -------------------------------------------------------------------------- // // Get the reduced Sigma Square: -// - If fLoGainRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1. +// - If fRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1. // - Test bit kHiGainSaturation: // If yes, return fRSigmaSquare, multiplied with fConversionHiLo^2, @@ -471,15 +545,8 @@ Float_t MCalibrationChargePix::GetConvertedRSigmaSquare() const { - - Float_t rsigmasquare = 0.; - if (IsHiGainSaturation()) - rsigmasquare = fLoGainRSigmaSquare*fConversionHiLo*fConversionHiLo; - else - rsigmasquare = fHiGainRSigmaSquare; - - if (rsigmasquare < 0) + if (fRSigmaSquare < 0) return -1; - return rsigmasquare ; + return IsHiGainSaturation() ? fRSigmaSquare*fConversionHiLo*fConversionHiLo : fRSigmaSquare ; } @@ -494,8 +561,8 @@ // Else returns the relative variance of the reduced sigma // -Float_t MCalibrationChargePix::GetHiGainRSigmaRelVar() const -{ - - if (fHiGainRSigmaSquareVar < 0) +Float_t MCalibrationChargePix::GetRSigmaRelVar() const +{ + + if (fRSigmaSquareVar < 0) return -1; @@ -504,197 +571,7 @@ // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) // - return 0.25 * fHiGainRSigmaSquareVar / ( fHiGainRSigmaSquare * fHiGainRSigmaSquare ); - -} - -// -------------------------------------------------------------------------- -// -// Get the relative variance of the reduced Sigma: -// - If fRSigmaSquareVar is smaller than 0 (i.e. has not yet been set), return -1. -// - Calculate the relative variance of the reduced sigma squares with the formula: -// reduced sigma rel. variance = 0.25 * fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare -// - Test bit kHiGainSaturation: -// If yes, returns the sum of the relative variances of the reduced sigma and fConversionHiLo -// Else returns the relative variance of the reduced sigma -// -Float_t MCalibrationChargePix::GetLoGainRSigmaRelVar() const -{ - - if (fLoGainRSigmaSquareVar < 0) - return -1; - - // - // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) - // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) - // - return 0.25 * fLoGainRSigmaSquareVar / ( fLoGainRSigmaSquare * fLoGainRSigmaSquare ); - -} - -// -------------------------------------------------------------------------- -// -// Get the reduced Sigma: -// - If fHiGainRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1. -// -Float_t MCalibrationChargePix::GetHiGainRSigma() const -{ - if (fHiGainRSigmaSquare < 0) - return -1; - - return TMath::Sqrt(fHiGainRSigmaSquare); - -} - -// -------------------------------------------------------------------------- -// -// Get the error of the reduced Sigma: -// - If fHiGainRSigmaSquareVar is smaller than 0 (i.e. has not yet been set), return -1. -// - Calculate the absolute variance of the reduced sigma with the formula: -// reduced sigma variance = 0.25 * fHiGainRSigmaSquareVar / fHiGainRSigmaSquare -// -Float_t MCalibrationChargePix::GetHiGainRSigmaErr() const -{ - - if (fHiGainRSigmaSquareVar < 0) - return -1; - - // - // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) - // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) - // - return TMath::Sqrt(0.25 * fHiGainRSigmaSquareVar / fHiGainRSigmaSquare); - -} - -// -------------------------------------------------------------------------- -// -// Get the reduced Sigma per Charge: -// - If GetHiGainRSigma() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - If GetMean() is 0. or -1. (i.e. has not yet been set), return -1. -// - Return GetHiGainRSigma() / GetMean() -// -Float_t MCalibrationChargePix::GetHiGainRSigmaPerCharge() const -{ - - const Float_t rsigma = GetHiGainRSigma(); - - if (rsigma <= 0) - return -1.; - - - const Float_t mean = GetHiGainMean(); - - if (mean == 0. || mean == -1.) - return -1.; - - return rsigma / mean; -} - - -// -------------------------------------------------------------------------- -// -// Get the error of the reduced Sigma per Charge: -// - If GetHiGainRSigmaRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - If GetMeanRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - Return the propagated error of GetHiGainRSigmaPerCharge() -// -Float_t MCalibrationChargePix::GetHiGainRSigmaPerChargeErr() const -{ - - const Float_t rsigmarelvar = GetHiGainRSigmaRelVar(); - - if (rsigmarelvar <= 0) - return -1.; - - const Float_t meanrelvar = GetHiGainMeanRelVar(); - - if (meanrelvar <= 0.) - return -1.; - - return TMath::Sqrt(rsigmarelvar + meanrelvar) * GetHiGainRSigmaPerCharge(); -} - -// -------------------------------------------------------------------------- -// -// Get the reduced Sigma: -// - If fLoGainRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1. -// -Float_t MCalibrationChargePix::GetLoGainRSigma() const -{ - if (fLoGainRSigmaSquare < 0) - return -1; - - return TMath::Sqrt(fLoGainRSigmaSquare); - -} - -// -------------------------------------------------------------------------- -// -// Get the error of the reduced Sigma: -// - If fLoGainRSigmaSquareVar is smaller than 0 (i.e. has not yet been set), return -1. -// - Calculate the absolute variance of the reduced sigma with the formula: -// reduced sigma variance = 0.25 * fLoGainRSigmaSquareVar / fLoGainRSigmaSquare -// -Float_t MCalibrationChargePix::GetLoGainRSigmaErr() const -{ - - if (fLoGainRSigmaSquareVar < 0) - return -1; - - // - // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) - // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) - // - return TMath::Sqrt(0.25 * fLoGainRSigmaSquareVar / fLoGainRSigmaSquare); - -} - -// -------------------------------------------------------------------------- -// -// Get the reduced Sigma per Charge: -// - If GetLoGainRSigma() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - If GetMean() is 0. or -1. (i.e. has not yet been set), return -1. -// - Return GetLoGainRSigma() / GetMean() -// -Float_t MCalibrationChargePix::GetLoGainRSigmaPerCharge() const -{ - - const Float_t rsigma = GetLoGainRSigma(); - - if (rsigma <= 0) - return -1.; - - - const Float_t mean = GetLoGainMean(); - - if (mean == 0. || mean == -1.) - return -1.; - - return rsigma / mean; -} - - -// -------------------------------------------------------------------------- -// -// Get the error of the reduced Sigma per Charge: -// - If GetLoGainRSigmaRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - If GetMeanRelVar() is smaller or equal 0. (i.e. has not yet been set), return -1. -// - Return the propagated error of GetLoGainRSigmaPerCharge() -// -Float_t MCalibrationChargePix::GetLoGainRSigmaPerChargeErr() const -{ - - const Float_t rsigmarelvar = GetLoGainRSigmaRelVar(); - - if (rsigmarelvar <= 0) - return -1.; - - const Float_t meanrelvar = GetLoGainMeanRelVar(); - - if (meanrelvar <= 0.) - return -1.; - - return TMath::Sqrt(rsigmarelvar + meanrelvar) * GetLoGainRSigmaPerCharge(); -} + return 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare ); + +} // -------------------------------------------------------------------------- @@ -704,22 +581,9 @@ // - Else returns the square root of fPheFFactorMethodVar // -Float_t MCalibrationChargePix::GetHiGainPheFFactorMethodErr() const -{ - if (fHiGainPheFFactorMethodVar < 0.) - return -1.; - return TMath::Sqrt(fHiGainPheFFactorMethodVar); -} - -// -------------------------------------------------------------------------- -// -// Get the error on the number of photo-electrons (F-Factor Method): -// - If fPheFFactorMethodVar is smaller than 0 (i.e. has not yet been set), return -1. -// - Else returns the square root of fPheFFactorMethodVar -// -Float_t MCalibrationChargePix::GetLoGainPheFFactorMethodErr() const -{ - if (fLoGainPheFFactorMethodVar < 0.) - return -1.; - return TMath::Sqrt(fLoGainPheFFactorMethodVar); +Float_t MCalibrationChargePix::GetPheFFactorMethodErr() const +{ + if (fPheFFactorMethodVar < 0.) + return -1.; + return TMath::Sqrt(fPheFFactorMethodVar); } @@ -744,29 +608,12 @@ // - Else returns fPheFFactorMethodVar / fPheFFactorMethod^2 // -Float_t MCalibrationChargePix::GetHiGainPheFFactorMethodRelVar() const -{ - if (fHiGainPheFFactorMethodVar < 0.) - return -1.; - if (fHiGainPheFFactorMethod == 0.) - return -1.; - - return fHiGainPheFFactorMethodVar / (fHiGainPheFFactorMethod * fHiGainPheFFactorMethod); -} - -// -------------------------------------------------------------------------- -// -// Get the relative variance on the number of photo-electrons (F-Factor Method): -// - If fPheFFactorMethodVar is smaller than 0 (i.e. has not yet been set), return -1. -// - If fPheFFactorMethod is 0, return -1. -// - Else returns fPheFFactorMethodVar / fPheFFactorMethod^2 -// -Float_t MCalibrationChargePix::GetLoGainPheFFactorMethodRelVar() const -{ - if (fLoGainPheFFactorMethodVar < 0.) - return -1.; - if (fLoGainPheFFactorMethod == 0.) - return -1.; - - return fLoGainPheFFactorMethodVar / (fLoGainPheFFactorMethod * fLoGainPheFFactorMethod); +Float_t MCalibrationChargePix::GetPheFFactorMethodRelVar() const +{ + if (fPheFFactorMethodVar < 0.) + return -1.; + if (fPheFFactorMethod == 0.) + return -1.; + + return fPheFFactorMethodVar / (fPheFFactorMethod * fPheFFactorMethod); } @@ -820,8 +667,8 @@ // in GetRSigma() and GetRSigmaErr() // -Bool_t MCalibrationChargePix::CalcHiGainReducedSigma() -{ - - if (GetHiGainSigma() < 0.) +Bool_t MCalibrationChargePix::CalcReducedSigma() +{ + + if (GetSigma() < 0.) return kFALSE; @@ -829,8 +676,8 @@ return kFALSE; - const Float_t sigma = fHiGainSigma ; - const Float_t sigmavar = fHiGainSigmaVar; - const Float_t pedRmsSquare = fPedRms*fPedRms; - const Float_t pedRmsSquareVar = 0.25*fPedVar*pedRmsSquare; + const Float_t sigma = IsHiGainSaturation() ? fLoGainSigma : fHiGainSigma ; + const Float_t sigmavar = IsHiGainSaturation() ? fLoGainSigmaVar : fHiGainSigmaVar; + const Float_t pedRmsSquare = IsHiGainSaturation() ? fLoGainPedRmsSquare : fPedRms*fPedRms; + const Float_t pedRmsSquareVar = IsHiGainSaturation() ? fLoGainPedRmsSquareVar : 0.25*fPedVar*pedRmsSquare; if (IsDebug()) @@ -851,14 +698,14 @@ // Calculate the reduced sigmas // - fHiGainRSigmaSquare = sigmaSquare - pedRmsSquare; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Red.Sigma Square: " << fHiGainRSigmaSquare - << endl; - } - - if (fHiGainRSigmaSquare <= 0.) + fRSigmaSquare = sigmaSquare - pedRmsSquare; + + if (IsDebug()) + { + *fLog << dbginf << "ID: " << GetPixId() + << " Red.Sigma Square: " << fRSigmaSquare + << endl; + } + + if (fRSigmaSquare <= 0.) { if (IsDebug()) @@ -870,97 +717,10 @@ - fHiGainRSigmaSquareVar = 4. * (sigmaSquareVar + pedRmsSquareVar); - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Var.Red.Sigma Square: " << fHiGainRSigmaSquareVar - << endl; - } - - return kTRUE; -} - -// ---------------------------------------------------------------------------- -// -// - If fSigma is smaller than 0 (i.e. has not yet been set), return kFALSE -// - If fPedRms is smaller than 0 (i.e. has not yet been set), return kFALSE -// -// Calculate the reduced sigma of the low-Gain FADC slices: -// - Test bit IsHiGainSaturation() for the Sigma: -// If yes, take fLoGainSigma and fLoGainSigmaVar -// If no , take fHiGainSigma and fHiGainSigmaVar -// -// - Test bit IsHiGainSaturation() for the pedRMS: -// If yes, take fLoGainPedRmsSquare and fLoGainPedRmsSquareVar -// If no , take fPedRms and fPedVar -// -// - Calculate the reduced sigma with the formula: -// fRSigmaSquare = Sigma*Sigma - pedRMS*pedRMS -// -// - If fRSigmaSquare is smaller than 0, give a warning and return kFALSE -// -// - Calculate the variance of the reduced sigma with the formula: -// fRSigmaSquareVar = 4.* (sigmaVar*Sigma*Sigma + pedRmsVar*pedRMS*pedRMS) -// -// A back-transformation to the corr. amplification factor of the High-Gain is done -// in GetRSigma() and GetRSigmaErr() -// -Bool_t MCalibrationChargePix::CalcLoGainReducedSigma() -{ - - if (GetLoGainSigma() < 0.) - return kFALSE; - - if (fLoGainPedRmsSquare < 0.) - return kFALSE; - - const Float_t sigma = fLoGainSigma ; - const Float_t sigmavar = fLoGainSigmaVar ; - const Float_t pedRmsSquare = fLoGainPedRmsSquare ; - const Float_t pedRmsSquareVar = fLoGainPedRmsSquareVar ; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " HiGainSaturation: " << IsHiGainSaturation() - << " Sigma: " << sigma - << " Var.Sigma: " << sigmavar - << " PedRmsSquare: " << pedRmsSquare - << " pedRmsSquareVar: " << pedRmsSquareVar - << endl; - } - - const Float_t sigmaSquare = sigma * sigma; - const Float_t sigmaSquareVar = 4. * sigmavar * sigmaSquare; - - // - // Calculate the reduced sigmas - // - fLoGainRSigmaSquare = sigmaSquare - pedRmsSquare; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Red.Sigma Square: " << fLoGainRSigmaSquare - << endl; - } - - if (fLoGainRSigmaSquare <= 0.) - { - if (IsDebug()) - *fLog << warn - << "WARNING: Cannot calculate the reduced sigma: smaller than 0 in pixel " - << fPixId << endl; - return kFALSE; - } - - - fLoGainRSigmaSquareVar = 4. * (sigmaSquareVar + pedRmsSquareVar); - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Var.Red.Sigma Square: " << fLoGainRSigmaSquareVar + fRSigmaSquareVar = 4. * (sigmaSquareVar + pedRmsSquareVar); + + if (IsDebug()) + { + *fLog << dbginf << "ID: " << GetPixId() + << " Var.Red.Sigma Square: " << fRSigmaSquareVar << endl; } @@ -995,8 +755,8 @@ // set kFFactorMethodValid to kFALSE and return kFALSE // -Bool_t MCalibrationChargePix::CalcHiGainFFactor() -{ - - if (fHiGainRSigmaSquare < 0.) +Bool_t MCalibrationChargePix::CalcFFactor() +{ + + if (fRSigmaSquare < 0.) return kFALSE; @@ -1004,16 +764,16 @@ // Square all variables in order to avoid applications of square root // - const Float_t meanSquare = GetHiGainMean() * GetHiGainMean(); - const Float_t meanSquareRelVar = 4.* GetHiGainMeanRelVar(); + const Float_t meanSquare = GetMean() * GetMean(); + const Float_t meanSquareRelVar = 4.* GetMeanRelVar(); const Float_t ffactorsquare = gkFFactor * gkFFactor; const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar(); - const Float_t rsigmaSquareRelVar = fHiGainRSigmaSquareVar / fHiGainRSigmaSquare / fHiGainRSigmaSquare; + const Float_t rsigmaSquareRelVar = fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare; // // Calculate the number of phe's from the F-Factor method // (independent on Hi Gain or Lo Gain) // - fHiGainPheFFactorMethod = ffactorsquare * meanSquare / fHiGainRSigmaSquare; + fPheFFactorMethod = ffactorsquare * meanSquare / fRSigmaSquare; if (IsDebug()) @@ -1022,10 +782,10 @@ << " F-Factor Square: " << ffactorsquare << " Mean Square: " << meanSquare - << " Red.Sigma Square: " << fHiGainRSigmaSquare - << " Photo-electrons: " << fHiGainPheFFactorMethod - << endl; - } - - if (fHiGainPheFFactorMethod < fPheFFactorMethodLimit) + << " Red.Sigma Square: " << fRSigmaSquare + << " Photo-electrons: " << fPheFFactorMethod + << endl; + } + + if (fPheFFactorMethod < fPheFFactorMethodLimit) return kFALSE; @@ -1033,6 +793,6 @@ // Calculate the Error of Nphe // - const Float_t pheRelVar = ffactorsquareRelVar + meanSquareRelVar + rsigmaSquareRelVar; - fHiGainPheFFactorMethodVar = pheRelVar * fHiGainPheFFactorMethod * fHiGainPheFFactorMethod; + const Float_t pheRelVar = ffactorsquareRelVar + meanSquareRelVar + rsigmaSquareRelVar; + fPheFFactorMethodVar = pheRelVar * fPheFFactorMethod * fPheFFactorMethod; if (IsDebug()) @@ -1046,88 +806,5 @@ } - if (fHiGainPheFFactorMethodVar < 0. ) - return kFALSE; - - return kTRUE; -} - -// ------------------------------------------------------------------ -// -// If fRSigmaSquare is smaller than 0 (i.e. has not yet been set), -// return kFALSE -// -// Calculate the number of photo-electrons with the F-Factor method: -// - Test bit IsLoGainSaturation() for the Mean Sum of FADC slices: -// If yes, take fLoGainMean and fLoGainMeanVar -// If no , take fHiGainMean and fHiGainMeanVar -// -// - Test bit IsHiGainSaturation() for the pedRMS: -// If yes, take fLoGainPedRmsSquare and fLoGainPedRmsSquareVar -// If no , take fPedRms and fPedVar -// -// - Calculate the number of photo-electrons with the formula: -// fPheFFactorMethod = gkFFactor*gkFFactor * Mean * Mean / fRSigmaSquare -// -// - Calculate the Variance on the photo-electrons with the formula: -// fPheFFactorMethodVar = ( 4. * gkFFactorErr * gkFFactorErr / ( gkFFactor * gkFFactor ) -// + 4. * Mean Var. / ( Mean * Mean ) -// + fRSigmaSquareVar / fRSigmaSquare -// ) * fPheFFactorMethod * fPheFFactorMethod -// -// - If fPheFFactorMethod is less than fPheFFactorMethodLimit, -// set kFFactorMethodValid to kFALSE and return kFALSE -// -Bool_t MCalibrationChargePix::CalcLoGainFFactor() -{ - - if (fLoGainRSigmaSquare < 0.) - return kFALSE; - - // - // Square all variables in order to avoid applications of square root - // - const Float_t meanSquare = GetLoGainMean() * GetLoGainMean(); - const Float_t meanSquareRelVar = 4.* GetLoGainMeanRelVar(); - - const Float_t ffactorsquare = gkFFactor * gkFFactor; - const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar(); - - const Float_t rsigmaSquareRelVar = fLoGainRSigmaSquareVar / fLoGainRSigmaSquare / fLoGainRSigmaSquare; - // - // Calculate the number of phe's from the F-Factor method - // (independent on Lo Gain or Lo Gain) - // - fLoGainPheFFactorMethod = ffactorsquare * meanSquare / fLoGainRSigmaSquare; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " F-Factor Square: " << ffactorsquare - << " Mean Square: " << meanSquare - << " Red.Sigma Square: " << fLoGainRSigmaSquare - << " Photo-electrons: " << fLoGainPheFFactorMethod - << endl; - } - - if (fLoGainPheFFactorMethod < fPheFFactorMethodLimit) - return kFALSE; - - // - // Calculate the Error of Nphe - // - const Float_t pheRelVar = ffactorsquareRelVar + meanSquareRelVar + rsigmaSquareRelVar; - fLoGainPheFFactorMethodVar = pheRelVar * fLoGainPheFFactorMethod * fLoGainPheFFactorMethod; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Rel.Var.F-Factor Square: " << ffactorsquareRelVar - << " Rel.Var. Mean Square: " << meanSquareRelVar - << " Rel.Var. Red.Sigma Square: " << rsigmaSquareRelVar - << " Rel.Var. Photo-electrons: " << pheRelVar - << endl; - } - - if (fLoGainPheFFactorMethodVar < 0. ) + if (fPheFFactorMethodVar < 0. ) return kFALSE; @@ -1164,16 +841,16 @@ // return kTRUE // -Bool_t MCalibrationChargePix::CalcHiGainConvFFactor() -{ - - if (fHiGainPheFFactorMethod <= 0.) +Bool_t MCalibrationChargePix::CalcConvFFactor() +{ + + if (fPheFFactorMethod <= 0.) return kFALSE; - const Float_t convmean = GetHiGainMean(); + const Float_t convmean = GetConvertedMean(); if (convmean <= 0.) return kFALSE; - fHiGainMeanConvFADC2Phe = fHiGainPheFFactorMethod / convmean; + fMeanConvFADC2Phe = fPheFFactorMethod / convmean; if (IsDebug()) @@ -1181,10 +858,10 @@ *fLog << dbginf << "ID: " << GetPixId() << " Converted Mean: " << convmean - << " Conversion FADC2Phe: " << fHiGainMeanConvFADC2Phe + << " Conversion FADC2Phe: " << fMeanConvFADC2Phe << endl; } const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar(); - const Float_t rsigmaSquareRelVar = fHiGainRSigmaSquareVar / fHiGainRSigmaSquare / fHiGainRSigmaSquare; + const Float_t rsigmaSquareRelVar = fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare; // // In the calculation of the number of phe's one mean square has already been used. @@ -1192,6 +869,6 @@ // the errors, but have to take account of this cancellation: // - Float_t convrelvar = ffactorsquareRelVar + GetHiGainMeanRelVar() + rsigmaSquareRelVar; - const Float_t limit = fConvFFactorRelVarLimit; + Float_t convrelvar = ffactorsquareRelVar + GetMeanRelVar() + rsigmaSquareRelVar; + const Float_t limit = IsHiGainSaturation() ? fConvFFactorRelVarLimit * 4. : fConvFFactorRelVarLimit; // @@ -1199,6 +876,6 @@ // have a fRSigmaSquareVar, calculate their error directly! // - if (fHiGainRSigmaSquareVar < 0.) - convrelvar = GetHiGainMeanRelVar() + GetHiGainPheFFactorMethodRelVar(); + if (fRSigmaSquareVar < 0.) + convrelvar = GetMeanRelVar() + GetPheFFactorMethodRelVar(); if (IsDebug()) @@ -1206,5 +883,5 @@ *fLog << dbginf << "ID: " << GetPixId() << " Rel.Var.Red.Sigma: " << rsigmaSquareRelVar - << " Rel.Var.Mean: " << GetHiGainMeanRelVar() + << " Rel.Var.Mean: " << GetMeanRelVar() << " Rel.Var.F-Factor: " << ffactorsquareRelVar << " Rel.Var.Conversion FADC2Phe: " << convrelvar @@ -1219,5 +896,5 @@ } - fHiGainMeanConvFADC2PheVar = convrelvar * fHiGainMeanConvFADC2Phe * fHiGainMeanConvFADC2Phe; + fMeanConvFADC2PheVar = convrelvar * fMeanConvFADC2Phe * fMeanConvFADC2Phe; SetFFactorMethodValid(kTRUE); @@ -1225,94 +902,4 @@ } -// ------------------------------------------------------------------ -// -// If fPheFFactorMethod is smaller than 0 (i.e. has not yet been set), -// return kFALSE -// -// If GetCovertedMean() is smaller than 0 (i.e. has not yet been set), -// return kFALSE -// -// Calculate fMeanConvFADC2Phe with the following formula: -// -// fMeanConvFADC2Phe = fPheFFactorMethod / GetConvMean(); -// -// Calculate the rel. variance of fMeanConvFADC2Phe, taking into account that -// in the calculation of the number of phe's one mean square has already been used. -// Now, dividing by another mean, one mean calcels out, one cannot directly propagate -// the errors, but instead havs to take into account this cancellation: -// -// convrelvar = ffactorsquareRelVar + GetMeanRelVar() + rsigmaSquareRelVar; -// -// If confrelvar is smaller than 0. or greater than fConvFFactorRelVarLimit, -// return kFALSE -// -// Calculate the variance of fMeanConvFADC2Phe with the formula: -// -// fMeanConvFADC2PheVar = convrelvar * fMeanConvFADC2Phe * fMeanConvFADC2Phe; -// -// Set kFFactorMethodValid to kTRUE and -// return kTRUE -// -Bool_t MCalibrationChargePix::CalcLoGainConvFFactor() -{ - - if (fLoGainPheFFactorMethod <= 0.) - return kFALSE; - - const Float_t convmean = GetConvertedLoGainMean(); - - if (convmean <= 0.) - return kFALSE; - - fLoGainMeanConvFADC2Phe = fLoGainPheFFactorMethod / convmean; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Converted Mean: " << convmean - << " Conversion FADC2Phe: " << fLoGainMeanConvFADC2Phe - << endl; - } - - const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar(); - const Float_t rsigmaSquareRelVar = fLoGainRSigmaSquareVar / fLoGainRSigmaSquare / fLoGainRSigmaSquare; - // - // In the calculation of the number of phe's one mean square has already been used. - // Now, we divide by another mean, so one mean calcels out, we cannot directly propagate - // the errors, but have to take account of this cancellation: - // - Float_t convrelvar = ffactorsquareRelVar + GetConvertedLoGainMeanRelVar() + rsigmaSquareRelVar; - const Float_t limit = fConvFFactorRelVarLimit; - - // - // Also have to take into account the pixels labelled MBadPixelsPix::kChargeSigmaNotValid which do not - // have a fRSigmaSquareVar, calculate their error directly! - // - if (fLoGainRSigmaSquareVar < 0.) - convrelvar = GetConvertedLoGainMeanRelVar() + GetLoGainPheFFactorMethodRelVar(); - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Rel.Var.Red.Sigma: " << rsigmaSquareRelVar - << " Rel.Var.Mean: " << GetLoGainMeanRelVar() - << " Rel.Var.F-Factor: " << ffactorsquareRelVar - << " Rel.Var.Conversion FADC2Phe: " << convrelvar - << endl; - } - - if (convrelvar > limit || convrelvar < 0.) - { - *fLog << warn << GetDescriptor() << ": Conv. F-Factor Method Rel. Var.: " - << Form("%4.3f out of limits: [0,%3.2f] in pixel:%4i",convrelvar,limit,fPixId) << endl; - return kFALSE; - } - - fLoGainMeanConvFADC2PheVar = convrelvar * fLoGainMeanConvFADC2Phe * fLoGainMeanConvFADC2Phe; - - SetFFactorMethodValid(kTRUE); - return kTRUE; -} - // ---------------------------------------------------------------------------------- // @@ -1324,5 +911,5 @@ // Calculate the error of the total F-Factor // -Bool_t MCalibrationChargePix::CalcHiGainMeanFFactor( const Float_t nphotons, const Float_t nphotonsrelvar ) +Bool_t MCalibrationChargePix::CalcMeanFFactor( const Float_t nphotons, const Float_t nphotonsrelvar ) { @@ -1333,6 +920,6 @@ << " Number photons: " << nphotons << " Rel.Var.Number photons: " << nphotonsrelvar - << " Red.Sigma Square: " << fHiGainRSigmaSquare - << " Mean: " << GetHiGainMean() + << " Red.Sigma Square: " << fRSigmaSquare + << " Mean: " << GetMean() << endl; } @@ -1351,14 +938,14 @@ } - fHiGainMeanFFactorFADC2Phot = TMath::Sqrt(fHiGainRSigmaSquare * nphotons) / GetHiGainMean() ; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " F-Factor FADC2Phot: " << fHiGainMeanFFactorFADC2Phot - << endl; - } - - if (fHiGainMeanFFactorFADC2Phot < 0.) + fMeanFFactorFADC2Phot = TMath::Sqrt(fRSigmaSquare * nphotons) / GetMean() ; + + if (IsDebug()) + { + *fLog << dbginf << "ID: " << GetPixId() + << " F-Factor FADC2Phot: " << fMeanFFactorFADC2Phot + << endl; + } + + if (fMeanFFactorFADC2Phot < 0.) { *fLog << warn << GetDescriptor() << ": F-Factor photons to FADC counts smaller than 0." << endl; @@ -1366,85 +953,15 @@ } - const Float_t ffactorrelvar = 0.25 * fHiGainRSigmaSquareVar / ( fHiGainRSigmaSquare * fHiGainRSigmaSquare) - + GetHiGainMeanRelVar() + const Float_t ffactorrelvar = 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare) + + GetMeanRelVar() + 0.25 * nphotonsrelvar; - fHiGainMeanFFactorFADC2PhotVar = ffactorrelvar * fHiGainMeanFFactorFADC2Phot * fHiGainMeanFFactorFADC2Phot; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Rel.Var.Red.Sigma: " << 0.25 * fHiGainRSigmaSquareVar / ( fHiGainRSigmaSquare * fHiGainRSigmaSquare) - << " Rel.Var.Mean: " << GetHiGainMeanRelVar() - << " Rel.Var.photons: " << 0.25 * nphotonsrelvar - << " Rel.Var.F-Factor FADC2Phot: " << ffactorrelvar - << endl; - } - - return kTRUE; -} - -// ---------------------------------------------------------------------------------- -// -// If photflux is smaller or equal 0, return kFALSE -// -// Calculate the total F-Factor with the formula: -// fMeanFFactorFADC2Phot = Sqrt ( fRSigmaSquare ) / GetMean() * sqrt(nphotons) -// -// Calculate the error of the total F-Factor -// -Bool_t MCalibrationChargePix::CalcLoGainMeanFFactor( const Float_t nphotons, const Float_t nphotonsrelvar ) -{ - - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Number photons: " << nphotons - << " Rel.Var.Number photons: " << nphotonsrelvar - << " Red.Sigma Square: " << fLoGainRSigmaSquare - << " Mean: " << GetLoGainMean() - << endl; - } - - - if (nphotons <= 0.) - { - *fLog << warn << GetDescriptor() << ": Assumed photon flux is smaller or equal 0." << endl; - return kFALSE; - } - - if (nphotonsrelvar < 0.) - { - *fLog << warn << GetDescriptor() << ": Assumed photon flux variance is smaller than 0." << endl; - return kFALSE; - } - - fLoGainMeanFFactorFADC2Phot = TMath::Sqrt(fLoGainRSigmaSquare * nphotons) / GetLoGainMean() ; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " F-Factor FADC2Phot: " << fLoGainMeanFFactorFADC2Phot - << endl; - } - - if (fLoGainMeanFFactorFADC2Phot < 0.) - { - *fLog << warn << GetDescriptor() << ": F-Factor photons to FADC counts smaller than 0." << endl; - return kFALSE; - } - - const Float_t ffactorrelvar = 0.25 * fLoGainRSigmaSquareVar / ( fLoGainRSigmaSquare * fLoGainRSigmaSquare) - + GetLoGainMeanRelVar() - + 0.25 * nphotonsrelvar; - - fLoGainMeanFFactorFADC2PhotVar = ffactorrelvar * fLoGainMeanFFactorFADC2Phot * fLoGainMeanFFactorFADC2Phot; - - if (IsDebug()) - { - *fLog << dbginf << "ID: " << GetPixId() - << " Rel.Var.Red.Sigma: " << 0.25 * fLoGainRSigmaSquareVar / ( fLoGainRSigmaSquare * fLoGainRSigmaSquare) - << " Rel.Var.Mean: " << GetLoGainMeanRelVar() + fMeanFFactorFADC2PhotVar = ffactorrelvar * fMeanFFactorFADC2Phot * fMeanFFactorFADC2Phot; + + if (IsDebug()) + { + *fLog << dbginf << "ID: " << GetPixId() + << " Rel.Var.Red.Sigma: " << 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare) + << " Rel.Var.Mean: " << GetMeanRelVar() << " Rel.Var.photons: " << 0.25 * nphotonsrelvar << " Rel.Var.F-Factor FADC2Phot: " << ffactorrelvar