Changeset 5199

Timestamp:

10/07/04 15:34:32 (20 years ago)

Author:

gaug

Message:

*** empty log message ***

File:

• trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc (modified) (27 diffs)

trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc

@@ -413 +413 @@
 Float_t MCalibrationChargePix::GetConvertedRSigma()  const
 {
-  if (fRSigmaSquare < 0)
+
+  Float_t rsigma = 0.;
+  if (IsHiGainSaturation())
+    rsigma = TMath::Sqrt(fLoGainRSigmaSquare)*fConversionHiLo;
+  else 
+    rsigma = TMath::Sqrt(fHiGainRSigmaSquare);
+
+  if (rsigma < 0)
     return -1;
 
-  const Float_t rsigma = TMath::Sqrt(fRSigmaSquare);
-  
-  return IsHiGainSaturation() ? rsigma*fConversionHiLo : rsigma ;
+  return rsigma ;
 } 
 
@@ -435 +440 @@
 {
 
-  if (fRSigmaSquareVar < 0)
-    return -1;
-
+  Float_t rsigmavar = 0.;
   //
   // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma)
   // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma)
   //
-  const Float_t rsigmaVar = 0.25 * fRSigmaSquareVar / fRSigmaSquare;
-
   if (IsHiGainSaturation())
-    return TMath::Sqrt(rsigmaVar/fRSigmaSquare + GetConversionHiLoRelVar()) * GetRSigma();
+    rsigmavar = 0.25 * fLoGainRSigmaSquareVar / fLoGainRSigmaSquare;
+  else 
+    rsigmavar = 0.25 * fHiGainRSigmaSquareVar / fHiGainRSigmaSquare;
+
+  if (rsigmavar < 0)
+    return -1;
+
+  if (IsHiGainSaturation())
+    return TMath::Sqrt(rsigmavar/fLoGainRSigmaSquare + GetConversionHiLoRelVar()) * GetLoGainRSigma();
   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;
-
-  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();
-} 
-
+    return TMath::Sqrt(rsigmavar);
+
+}
+
+ 
 // --------------------------------------------------------------------------
 //
 // Get the reduced Sigma Square: 
-// - If fRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1.
+// - If fLoGainRSigmaSquare is smaller than 0 (i.e. has not yet been set), return -1.
 // - Test bit kHiGainSaturation: 
 //   If yes, return fRSigmaSquare, multiplied with fConversionHiLo^2, 
@@ -545 +471 @@
 Float_t MCalibrationChargePix::GetConvertedRSigmaSquare()  const
 {
-  if (fRSigmaSquare < 0)
+  
+  Float_t rsigmasquare = 0.;
+  if (IsHiGainSaturation())
+    rsigmasquare = fLoGainRSigmaSquare*fConversionHiLo*fConversionHiLo;
+  else 
+    rsigmasquare = fHiGainRSigmaSquare;
+
+  if (rsigmasquare < 0)
     return -1;
 
-  return IsHiGainSaturation() ? fRSigmaSquare*fConversionHiLo*fConversionHiLo : fRSigmaSquare ;
+  return rsigmasquare ;
 } 
 
@@ -561 +494 @@
 //   Else returns the relative variance of the reduced sigma
 //
-Float_t MCalibrationChargePix::GetRSigmaRelVar()  const
-{
-
-  if (fRSigmaSquareVar < 0)
+Float_t MCalibrationChargePix::GetHiGainRSigmaRelVar()  const
+{
+
+  if (fHiGainRSigmaSquareVar < 0)
     return -1;
 
@@ -571 +504 @@
   // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma)
   //
-  return 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare );
-
-}
+  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();
+} 
 
 // --------------------------------------------------------------------------
@@ -581 +704 @@
 // - Else returns the square root of fPheFFactorMethodVar
 //
-Float_t MCalibrationChargePix::GetPheFFactorMethodErr()  const
-{
-  if (fPheFFactorMethodVar < 0.)
-    return -1.;
-  return TMath::Sqrt(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);
 }
 
@@ -608 +744 @@
 // - Else returns fPheFFactorMethodVar / fPheFFactorMethod^2
 //
-Float_t MCalibrationChargePix::GetPheFFactorMethodRelVar()  const
-{
-  if (fPheFFactorMethodVar < 0.)
-    return -1.;
-  if (fPheFFactorMethod  == 0.)
-    return -1.;
-
-  return fPheFFactorMethodVar / (fPheFFactorMethod * fPheFFactorMethod);
+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);
 }
 
@@ -667 +820 @@
 // in GetRSigma() and GetRSigmaErr()
 //
-Bool_t MCalibrationChargePix::CalcReducedSigma()
-{
-
-  if (GetSigma() < 0.)
+Bool_t MCalibrationChargePix::CalcHiGainReducedSigma()
+{
+
+  if (GetHiGainSigma() < 0.)
     return kFALSE;
   
@@ -676 +829 @@
     return kFALSE;
 
-  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;
+  const Float_t sigma           = fHiGainSigma   ;
+  const Float_t sigmavar        = fHiGainSigmaVar;
+  const Float_t pedRmsSquare    = fPedRms*fPedRms;
+  const Float_t pedRmsSquareVar = 0.25*fPedVar*pedRmsSquare;
 
   if (IsDebug())
@@ -698 +851 @@
   // Calculate the reduced sigmas
   //
-  fRSigmaSquare = sigmaSquare - pedRmsSquare;
-
-  if (IsDebug())
-    {
-      *fLog << dbginf << "ID: " << GetPixId() 
-            << " Red.Sigma Square: " << fRSigmaSquare
-            << endl;
-    }
-  
-  if (fRSigmaSquare <= 0.)
+  fHiGainRSigmaSquare = sigmaSquare - pedRmsSquare;
+
+  if (IsDebug())
+    {
+      *fLog << dbginf << "ID: " << GetPixId() 
+            << " Red.Sigma Square: " << fHiGainRSigmaSquare
+            << endl;
+    }
+  
+  if (fHiGainRSigmaSquare <= 0.)
     {
       if (IsDebug())
@@ -717 +870 @@
 
   
-  fRSigmaSquareVar = 4. * (sigmaSquareVar + pedRmsSquareVar);
-
-  if (IsDebug())
-    {
-      *fLog << dbginf << "ID: " << GetPixId() 
-            << " Var.Red.Sigma Square: " << fRSigmaSquareVar
+  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
             << endl;
     }
@@ -755 +995 @@
 //   set kFFactorMethodValid to kFALSE and return kFALSE
 //
-Bool_t MCalibrationChargePix::CalcFFactor()
-{
-
-  if (fRSigmaSquare < 0.)
+Bool_t MCalibrationChargePix::CalcHiGainFFactor()
+{
+
+  if (fHiGainRSigmaSquare < 0.)
     return kFALSE;
   
@@ -764 +1004 @@
   // Square all variables in order to avoid applications of square root
   //
-  const Float_t meanSquare          =     GetMean()    * GetMean();
-  const Float_t meanSquareRelVar    = 4.* GetMeanRelVar();
+  const Float_t meanSquare          =     GetHiGainMean()    * GetHiGainMean();
+  const Float_t meanSquareRelVar    = 4.* GetHiGainMeanRelVar();
 
   const Float_t ffactorsquare       =     gkFFactor    * gkFFactor;
   const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar();
 
-  const Float_t rsigmaSquareRelVar  =     fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare;
+  const Float_t rsigmaSquareRelVar  =     fHiGainRSigmaSquareVar / fHiGainRSigmaSquare / fHiGainRSigmaSquare;
   //
   // Calculate the number of phe's from the F-Factor method
   // (independent on Hi Gain or Lo Gain)
   //
-  fPheFFactorMethod = ffactorsquare * meanSquare / fRSigmaSquare;
+  fHiGainPheFFactorMethod = ffactorsquare * meanSquare / fHiGainRSigmaSquare;
 
   if (IsDebug())
@@ -782 +1022 @@
             << " F-Factor Square: " << ffactorsquare
             << " Mean Square: " << meanSquare
-            << " Red.Sigma Square: " << fRSigmaSquare
-            << " Photo-electrons: " << fPheFFactorMethod
-            << endl;
-    }
-
-  if (fPheFFactorMethod < fPheFFactorMethodLimit)
+            << " Red.Sigma Square: " << fHiGainRSigmaSquare
+            << " Photo-electrons: " << fHiGainPheFFactorMethod
+            << endl;
+    }
+
+  if (fHiGainPheFFactorMethod < fPheFFactorMethodLimit)
     return kFALSE;
   
@@ -793 +1033 @@
   // Calculate the Error of Nphe
   //
-  const Float_t pheRelVar = ffactorsquareRelVar + meanSquareRelVar + rsigmaSquareRelVar;
-  fPheFFactorMethodVar    = pheRelVar * fPheFFactorMethod * fPheFFactorMethod;
+  const Float_t pheRelVar     = ffactorsquareRelVar + meanSquareRelVar + rsigmaSquareRelVar;
+  fHiGainPheFFactorMethodVar  = pheRelVar * fHiGainPheFFactorMethod * fHiGainPheFFactorMethod;
 
   if (IsDebug())
@@ -806 +1046 @@
     }
 
-  if (fPheFFactorMethodVar < 0. )
+  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. )
     return kFALSE;
 
@@ -841 +1164 @@
 // return kTRUE
 //
-Bool_t MCalibrationChargePix::CalcConvFFactor()
-{
-  
-  if (fPheFFactorMethod <= 0.)
+Bool_t MCalibrationChargePix::CalcHiGainConvFFactor()
+{
+  
+  if (fHiGainPheFFactorMethod <= 0.)
     return kFALSE;
 
-  const Float_t convmean = GetConvertedMean();
+  const Float_t convmean = GetHiGainMean();
 
   if (convmean <= 0.)
     return kFALSE;
   
-  fMeanConvFADC2Phe    =  fPheFFactorMethod / convmean;
+  fHiGainMeanConvFADC2Phe    =  fHiGainPheFFactorMethod / convmean;
 
   if (IsDebug())
@@ -858 +1181 @@
       *fLog << dbginf << "ID: " << GetPixId() 
             << " Converted Mean: " << convmean 
-            << " Conversion FADC2Phe: " << fMeanConvFADC2Phe
+            << " Conversion FADC2Phe: " << fHiGainMeanConvFADC2Phe
             << endl;
     }
 
   const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar();
-  const Float_t rsigmaSquareRelVar  = fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare;
+  const Float_t rsigmaSquareRelVar  = fHiGainRSigmaSquareVar / fHiGainRSigmaSquare / fHiGainRSigmaSquare;
   //
   // In the calculation of the number of phe's one mean square has already been used. 
@@ -869 +1192 @@
   // the errors, but have to take account of this cancellation:
   // 
-  Float_t convrelvar = ffactorsquareRelVar + GetMeanRelVar() + rsigmaSquareRelVar;
-  const Float_t limit = IsHiGainSaturation() ? fConvFFactorRelVarLimit * 4. : fConvFFactorRelVarLimit;
+  Float_t convrelvar = ffactorsquareRelVar + GetHiGainMeanRelVar() + rsigmaSquareRelVar;
+  const Float_t limit = fConvFFactorRelVarLimit;
 
   //
@@ -876 +1199 @@
   // have a fRSigmaSquareVar, calculate their error directly!
   //
-  if (fRSigmaSquareVar < 0.)
-    convrelvar = GetMeanRelVar() + GetPheFFactorMethodRelVar();
+  if (fHiGainRSigmaSquareVar < 0.)
+    convrelvar = GetHiGainMeanRelVar() + GetHiGainPheFFactorMethodRelVar();
 
   if (IsDebug())
@@ -883 +1206 @@
       *fLog << dbginf << "ID: " << GetPixId() 
             << " Rel.Var.Red.Sigma: " << rsigmaSquareRelVar
-            << " Rel.Var.Mean: " << GetMeanRelVar()
+            << " Rel.Var.Mean: " << GetHiGainMeanRelVar()
             << " Rel.Var.F-Factor: " << ffactorsquareRelVar
             << " Rel.Var.Conversion FADC2Phe: " << convrelvar
@@ -896 +1219 @@
     }
   
-  fMeanConvFADC2PheVar =  convrelvar * fMeanConvFADC2Phe * fMeanConvFADC2Phe;
+  fHiGainMeanConvFADC2PheVar =  convrelvar * fHiGainMeanConvFADC2Phe * fHiGainMeanConvFADC2Phe;
   
   SetFFactorMethodValid(kTRUE);
@@ -902 +1225 @@
 }
 
+// ------------------------------------------------------------------
+//
+// 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;
+}
+
 // ----------------------------------------------------------------------------------
 //
@@ -911 +1324 @@
 // Calculate the error of the total F-Factor
 //
-Bool_t MCalibrationChargePix::CalcMeanFFactor( const Float_t nphotons, const Float_t nphotonsrelvar )
+Bool_t MCalibrationChargePix::CalcHiGainMeanFFactor( const Float_t nphotons, const Float_t nphotonsrelvar )
 {
 
@@ -920 +1333 @@
             << " Number photons: " << nphotons
             << " Rel.Var.Number photons: " << nphotonsrelvar
-            << " Red.Sigma Square: " << fRSigmaSquare
-            << " Mean: " << GetMean()
+            << " Red.Sigma Square: " << fHiGainRSigmaSquare
+            << " Mean: " << GetHiGainMean()
             << endl;
     }
@@ -938 +1351 @@
     }
 
-  fMeanFFactorFADC2Phot =  TMath::Sqrt(fRSigmaSquare * nphotons) / GetMean() ;
-  
-  if (IsDebug())
-    {
-      *fLog << dbginf << "ID: " << GetPixId() 
-            << " F-Factor FADC2Phot: " << fMeanFFactorFADC2Phot
-            << endl;
-    }
-
-  if (fMeanFFactorFADC2Phot < 0.)
+  fHiGainMeanFFactorFADC2Phot =  TMath::Sqrt(fHiGainRSigmaSquare * nphotons) / GetHiGainMean() ;
+  
+  if (IsDebug())
+    {
+      *fLog << dbginf << "ID: " << GetPixId() 
+            << " F-Factor FADC2Phot: " << fHiGainMeanFFactorFADC2Phot
+            << endl;
+    }
+
+  if (fHiGainMeanFFactorFADC2Phot < 0.)
     {
       *fLog << warn << GetDescriptor() << ": F-Factor photons to FADC counts smaller than 0." << endl;
@@ -953 +1366 @@
     }
   
-  const Float_t ffactorrelvar = 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare) 
-                              + GetMeanRelVar() 
+  const Float_t ffactorrelvar = 0.25 * fHiGainRSigmaSquareVar / ( fHiGainRSigmaSquare * fHiGainRSigmaSquare) 
+                              + GetHiGainMeanRelVar() 
                               + 0.25 * nphotonsrelvar;
   
-  fMeanFFactorFADC2PhotVar    = ffactorrelvar * fMeanFFactorFADC2Phot * fMeanFFactorFADC2Phot;
-
-  if (IsDebug())
-    {
-      *fLog << dbginf << "ID: " << GetPixId() 
-            << " Rel.Var.Red.Sigma: " << 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare) 
-            << " Rel.Var.Mean: " << GetMeanRelVar()
+  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()
             << " Rel.Var.photons: " << 0.25 * nphotonsrelvar
             << " Rel.Var.F-Factor FADC2Phot: " << ffactorrelvar