Changeset 3007 for trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc

Timestamp:

02/02/04 22:52:53 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

File:

• trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc (modified) (19 diffs)

trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc

@@ -30 +30 @@
 // (offset) value of one Pixel (PMT).                                      //
 //                                                                         //
-/////////////////////////////////////////////////////////////////////////////
-#include "MCalibrationPix.h"
-#include "MCalibrationConfig.h"
-
-#include "MLog.h"
-#include "MLogManip.h"
-
-ClassImp(MCalibrationPix);
-
-using namespace std;
-
-// --------------------------------------------------------------------------
-//
-// Default Constructor: 
-//
 // The following values are initialized to meaningful values:
 //
@@ -54 +39 @@
 //   Error F-Factor = 2.*0.02   = 0.04
 //
+/////////////////////////////////////////////////////////////////////////////
+#include "MCalibrationPix.h"
+#include "MCalibrationConfig.h"
+
+#include "MLog.h"
+#include "MLogManip.h"
+
+ClassImp(MCalibrationPix);
+
+using namespace std;
+
+const Float_t MCalibrationPix::gkElectronicPedRms    = 1.5;
+const Float_t MCalibrationPix::gkErrElectronicPedRms = 0.3;
+const Float_t MCalibrationPix::gkFFactor             = 1.32;
+const Float_t MCalibrationPix::gkFFactorError        = 0.04;
+const Float_t MCalibrationPix::gkChargeLimit         = 3.;
+const Float_t MCalibrationPix::gkChargeErrLimit      = 0.;
+const Float_t MCalibrationPix::gkChargeRelErrLimit   = 1.;
+const Float_t MCalibrationPix::gkTimeLimit           = 1.5;
+const Float_t MCalibrationPix::gkTimeErrLimit        = 3.;
+
+// --------------------------------------------------------------------------
+//
+// Default Constructor: 
+//
 MCalibrationPix::MCalibrationPix(const char *name, const char *title)
     : fPixId(-1),
-      fElectronicPedRms(1.5),
-      fErrElectronicPedRms(0.3),
-      fFactor(1.32),
-      fFactorError(0.04),
-      fChargeLimit(3.),
-      fChargeErrLimit(0.),
-      fChargeRelErrLimit(1.),
       fFlags(0)
 {
@@ -101 +104 @@
   CLRBIT(fFlags, kHiGainSaturation);
   CLRBIT(fFlags, kExcluded);
-  CLRBIT(fFlags, kFitValid);
+  CLRBIT(fFlags, kChargeFitValid);
+  CLRBIT(fFlags, kTimeFitValid);
   CLRBIT(fFlags, kFitted);
   CLRBIT(fFlags, kBlindPixelMethodValid);
@@ -117 +121 @@
   fErrPedRms                        =   0.;
   fTime                             =  -1.;
+  fErrTime                          =  -1.;
   fSigmaTime                        =  -1.;
-  fTimeChiSquare                    =  -1.;
+  fTimeProb                         =  -1.;
+  fTimeFirstHiGain                  =   0 ;
+  fTimeLastHiGain                   =   0 ;
+  fTimeFirstLoGain                  =   0 ;
+  fTimeLastLoGain                   =   0 ;
+
   fPheFFactorMethod                 =  -1.;
   fPheFFactorMethodError            =  -1.;
@@ -231 +241 @@
 // Set the Excluded Bit from outside 
 //
-void MCalibrationPix::SetFitValid(Bool_t b )    
-{ 
-  b ?  SETBIT(fFlags, kFitValid) : CLRBIT(fFlags, kFitValid); 
+void MCalibrationPix::SetChargeFitValid(Bool_t b )    
+{ 
+  b ?  SETBIT(fFlags, kChargeFitValid) : CLRBIT(fFlags, kChargeFitValid); 
+}
+
+// --------------------------------------------------------------------------
+//
+// Set the Excluded Bit from outside 
+//
+void MCalibrationPix::SetTimeFitValid(Bool_t b )    
+{ 
+  b ?  SETBIT(fFlags, kTimeFitValid) : CLRBIT(fFlags, kTimeFitValid); 
 }
 
@@ -271 +290 @@
   b ?  SETBIT(fFlags, kPINDiodeMethodValid) : CLRBIT(fFlags, kPINDiodeMethodValid); 
 }
+
+void MCalibrationPix::SetAbsTimeBordersHiGain(Byte_t f, Byte_t l)
+{
+
+  fTimeFirstHiGain = f;
+  fTimeLastHiGain  = l;
+  
+}
+
+void MCalibrationPix::SetAbsTimeBordersLoGain(Byte_t f, Byte_t l)
+{
+
+  fTimeFirstLoGain = f;
+  fTimeLastLoGain  = l;
+  
+}
+
 
 
@@ -278 +314 @@
  }
 
-Bool_t MCalibrationPix::IsFitValid() const 
-{
-  return TESTBIT(fFlags, kFitValid);  
+Bool_t MCalibrationPix::IsChargeFitValid() const 
+{
+  return TESTBIT(fFlags, kChargeFitValid);  
+}
+
+Bool_t MCalibrationPix::IsTimeFitValid() const 
+{
+  return TESTBIT(fFlags, kTimeFitValid);  
 }
 
@@ -342 +383 @@
   //    or if the histogram is empty
   //
-  if (fHist->IsFitOK() || fHist->IsEmpty())
+  if (fHist->IsChargeFitOK() || fHist->IsEmpty())
     return kTRUE;
 
@@ -386 +427 @@
 
   if (CheckChargeFitValidity())
-    SETBIT(fFlags,kFitValid);
+    SETBIT(fFlags,kChargeFitValid);
   else
     {
-      CLRBIT(fFlags,kFitValid);
+      CLRBIT(fFlags,kChargeFitValid);
       return kFALSE;
     }
@@ -408 +449 @@
       const Float_t chargeSquareRelErrSquare  = 4.*fErrCharge*fErrCharge / chargeSquare;
 
-      const Float_t fFactorRelErrSquare       = fFactorError * fFactorError / (fFactor * fFactor);
+      const Float_t fFactorRelErrSquare       = gkFFactorError * gkFFactorError / (gkFFactor * gkFFactor);
       //
       // Now the absolute error squares
@@ -415 +456 @@
       const Float_t sigmaSquareErrSquare      = 4.*fErrSigmaCharge*fErrSigmaCharge * sigmaSquare;
 
-      const Float_t elecRmsSquare             =       fElectronicPedRms*   fElectronicPedRms;
-      const Float_t elecRmsSquareErrSquare    = 4.*fErrElectronicPedRms*fErrElectronicPedRms * elecRmsSquare;
+      const Float_t elecRmsSquare             =       gkElectronicPedRms*   gkElectronicPedRms;
+      const Float_t elecRmsSquareErrSquare    = 4.*gkErrElectronicPedRms*gkErrElectronicPedRms * elecRmsSquare;
 
       Float_t pedRmsSquare                    =       fPedRms*   fPedRms;
@@ -477 +518 @@
       // (independent on Hi Gain or Lo Gain)
       //
-      fPheFFactorMethod = fFactor * chargeSquare / fRSigmaSquare;
+      fPheFFactorMethod = gkFFactor * chargeSquare / fRSigmaSquare;
 
       const Float_t pheFFactorRelErrSquare =  fFactorRelErrSquare
@@ -497 +538 @@
                                          * fConversionFFactorMethod * fConversionFFactorMethod;
       
-      if ( IsFitValid()                     &&
+      if ( IsChargeFitValid()               &&
            (fConversionFFactorMethod > 0.) &&
            (fConversionErrorFFactorMethod/fConversionFFactorMethod < 0.1) )
@@ -525 +566 @@
   if (TMath::IsNaN(fCharge)
       || TMath::IsNaN(fErrCharge)
-      || TMath::IsNaN(fErrCharge)
       || TMath::IsNaN(fSigmaCharge)
       || TMath::IsNaN(fErrSigmaCharge)
@@ -543 +583 @@
     equivpedestal /= fConversionHiLo;
       
-  if (fCharge < fChargeLimit*equivpedestal)
+  if (fCharge < gkChargeLimit*equivpedestal)
     {
       *fLog << warn << "WARNING: Fitted Charge is smaller than "
-            << fChargeLimit << " Pedestal RMS in Pixel " << fPixId << endl;
-      return kFALSE;
-    }
-  
-  if (fErrCharge < fChargeErrLimit) 
+            << gkChargeLimit << " Pedestal RMS in Pixel " << fPixId << endl;
+      return kFALSE;
+    }
+  
+  if (fErrCharge < gkChargeErrLimit) 
     {
       *fLog << warn << "WARNING: Error of Fitted Charge is smaller than "
-            << fChargeErrLimit << " in Pixel " << fPixId << endl;
-      return kFALSE;
-    }
-      
-  if (fCharge < fChargeRelErrLimit*fErrCharge) 
+            << gkChargeErrLimit << " in Pixel " << fPixId << endl;
+      return kFALSE;
+    }
+      
+  if (fCharge < gkChargeRelErrLimit*fErrCharge) 
     {
       *fLog << warn << "WARNING: Fitted Charge is smaller than "
-            << fChargeRelErrLimit << "* its error in Pixel " << fPixId << endl;
-      return kFALSE;
-    }
-      
-  if (!fHist->IsFitOK()) 
-    {
-      *fLog << warn << "WARNING: Probability of Fitted Charge too low in Pixel " << fPixId << endl;
+            << gkChargeRelErrLimit << "* its error in Pixel " << fPixId << endl;
+      return kFALSE;
+    }
+      
+  if (!fHist->IsChargeFitOK()) 
+    {
+      *fLog << warn << "WARNING: Probability of Fitted Charge too low in Pixel " 
+            << fPixId << endl;
       return kFALSE;
     }
@@ -572 +613 @@
   if (fSigmaCharge < equivpedestal)
     {
-      *fLog << warn << "WARNING: Sigma of Fitted Charge smaller than Pedestal RMS in Pixel " << fPixId << endl;
+      *fLog << warn << "WARNING: Sigma of Fitted Charge smaller than Pedestal RMS in Pixel " 
+            << fPixId << endl;
       return kFALSE;
     }
@@ -579 +621 @@
 
 //
-// The check returns kTRUE if:
-//
-// The mean arrival time is at least 1.0 slices from the used edge slices 
+// The check return kTRUE if:
+//
+// 0) No value is nan
+// 1) Pixel has a fitted rel. time smaller than 3*FADC slices
+// 2) Pixel has a fit error greater than 0. 
+// 4) Pixel has a fit Probability greater than 0.001 
+// 5) The absolute arrival time is at least 1.0 slices from the used edge slices 
 //
 Bool_t MCalibrationPix::CheckTimeFitValidity()
 {
 
+  if (TMath::IsNaN(fTime)
+      || TMath::IsNaN(fErrTime)
+      || TMath::IsNaN(fSigmaTime)
+      || TMath::IsNaN(fTimeProb))
+    {
+      *fLog << warn << "WARNING: Some of the time fit values are NAN in Pixel " 
+            << fPixId << endl;
+      return kFALSE;
+    }
+  
   if (TESTBIT(fFlags,kExcludeQualityCheck))
     return kTRUE;
 
-  Float_t lowerrange;
-  Float_t upperrange;
+  if (TMath::Abs(fTime) > gkTimeLimit) 
+    {
+      *fLog << warn << "WARNING: Abs(Fitted Rel. Time) is greater than "
+            << gkTimeLimit << " in Pixel " << fPixId << endl;
+      return kFALSE;
+    }
+
+  if (fErrTime > gkTimeErrLimit) 
+    {
+      *fLog << warn << "WARNING: Error of Fitted Time is smaller than "
+            << gkTimeErrLimit << " in Pixel " << fPixId << endl;
+      return kFALSE;
+    }
+
+  if (!fHist->IsTimeFitOK()) 
+    {
+      *fLog << warn << "WARNING: Probability of Fitted Time too low in Pixel " 
+            << fPixId << endl;
+      return kFALSE;
+    }
+
+  Float_t first;
+  Float_t last;
 
   if (TESTBIT(fFlags,kHiGainSaturation))
     {
-      lowerrange = (Float_t)fHist->GetTimeLowerFitRangeLoGain()+1.;
-      upperrange = (Float_t)fHist->GetTimeUpperFitRangeLoGain()+1.;
+      first = (Float_t)fHist->GetAbsTimeFirstLoGain();
+      last = (Float_t)fHist->GetAbsTimeLastLoGain();
+
+      if (first < (Float_t)fTimeFirstLoGain+1)
+        {
+          *fLog << warn 
+                << "WARNING: Some absolute times smaller than limit in Pixel " 
+                << fPixId << " time: " << first << " Limit: " << fTimeFirstLoGain+1 << endl;
+          return kFALSE;
+        }
+
+      if ((Float_t)fTimeLastLoGain-1 > last)
+        {
+          *fLog << warn 
+                << "WARNING: Some absolute times bigger than limit in Pixel " 
+                << fPixId << " time: " << last << " Limit: " << fTimeLastLoGain-1 << endl;
+          return kFALSE;
+        }
+
     }
   else
     {
-      lowerrange = (Float_t)fHist->GetTimeLowerFitRangeHiGain()+1.;
-      upperrange = (Float_t)fHist->GetTimeUpperFitRangeHiGain()+1.;
-    }
-
-
-  if (fTime < lowerrange)
-    {
-      *fLog << warn 
-            << "WARNING: Mean Fitted Time inside or smaller than first used FADC slice in Pixel " 
-            << fPixId << " time: " << fTime << " Range: " << lowerrange << endl;
-      return kFALSE;
-    }
-
-  if (fTime > upperrange)
-    {
-      *fLog << warn 
-            << "WARNING: Mean Fitted Time inside or greater than last used FADC slice in Pixel " 
-            << fPixId << " time: " << fTime << " Range: " << upperrange << endl;
-      return kFALSE;
-    }
+      first = (Float_t)fHist->GetAbsTimeFirstHiGain();
+      last = (Float_t)fHist->GetAbsTimeLastHiGain();
+
+      if (first > ((Float_t)fTimeFirstHiGain+1.))
+        {
+          *fLog << warn 
+                << "WARNING: Some absolute times smaller than limit in Pixel " 
+                << fPixId << " time: " << first << " Limit: " << (Float_t)fTimeFirstHiGain+1. << endl;
+          //          return kFALSE;
+        }
+
+      if (((Float_t)fTimeLastHiGain-1.) > last)
+        {
+          *fLog << warn 
+                << "WARNING: Some absolute times bigger than limit in Pixel " 
+                << fPixId << " time: " << last << " Limit: " << (Float_t)fTimeLastHiGain-1. << endl;
+          //          return kFALSE;
+        }
+
+    }
+
+
 
   return kTRUE;
@@ -662 +758 @@
 // 1) Fit the arrival times
 // 2) Retrieve the results
-// 3) Note that because of the low number of bins, the NDf is sometimes 0, so 
-//    Root does not give a reasonable Probability, the Chisquare is more significant
 //
 // This fit has to be done AFTER the Charges fit, 
@@ -672 +766 @@
 {
 
-  //
-  // Fit the Low Gain
-  //
-  if (TESTBIT(fFlags,kHiGainSaturation))
-    {
-      if(!fHist->FitTimeLoGain())
-        {
-          *fLog << warn << "WARNING: Could not fit Lo Gain times of pixel " << fPixId << endl;
-          //      fHist->PrintTimeFitResult();
-          return kFALSE;
-        }
-    }
-
-  //
-  // Fit the High Gain
-  //
+  if(!fHist->FitTime())
+    {
+      *fLog << warn << "WARNING: Could not fit relative times of pixel " << fPixId << endl;
+      return kFALSE;
+    }
+  
+  fTime          = fHist->GetRelTimeMean();
+  fErrTime       = fHist->GetRelTimeMeanErr();
+  fSigmaTime     = fHist->GetRelTimeSigma();
+  fTimeProb      = fHist->GetRelTimeProb();
+
+  if (CheckTimeFitValidity())
+    SETBIT(fFlags,kTimeFitValid);
   else
-    {
-      if(!fHist->FitTimeHiGain())
-        {
-          *fLog << warn << "WARNING: Could not fit Hi Gain times of pixel " << fPixId << endl;
-          //      fHist->PrintTimeFitResult();
-          return kFALSE;
-        }
-    }
-    
-  fTime          = fHist->GetTimeMean();
-  fSigmaTime     = fHist->GetTimeSigma();
-  fTimeChiSquare = fHist->GetTimeChiSquare();
-  fTimeProb      = fHist->GetTimeProb();
-
-  if (CheckTimeFitValidity())
-    SETBIT(fFlags,kFitValid);
-  else
-    CLRBIT(fFlags,kFitValid);
+    CLRBIT(fFlags,kTimeFitValid);
 
   return kTRUE;