Changeset 3555 for trunk/MagicSoft/Mars/mcalib

Timestamp:

03/19/04 19:37:51 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/mcalib

Files:

• MCalibrationChargeCalc.cc (modified) (5 diffs)
• MCalibrationChargeCalc.h (modified) (2 diffs)
• MCalibrationChargePix.cc (modified) (3 diffs)
• MCalibrationChargePix.h (modified) (4 diffs)

trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc

@@ -389 +389 @@
 
 
-// --------------------------------------------------------------------------
-//
-// Calculate the integral of the FADC time slices and store them as a new
-// pixel in the MCerPhotEvt container.
-//
 Int_t MCalibrationChargeCalc::Process()
 {
   return kTRUE;
 }
+
+// --------------------------------------------------------------------------
+//  
+// Finalize pedestals: 
+// 
+// * Retrieve pedestal and pedestal RMS from MPedestalPix
+// * Retrieve total entries from MPedestalCam
+// * sum up pedestal and pedestalRMS for the average pixel
+// * set pedestal*number of used samples in MCalibrationChargePix
+// * set pedestal RMS * sqrt of number of used samples in MCalibrationChargePix
+// 
+//
+void MCalibrationChargeCalc::FinalizePedestals(MPedestalPix &ped, MCalibrationChargePix &cal,
+                                               Float_t &avped, Float_t &avrms, Float_t &avnum)
+{
+  
+  //
+  // get the pedestals
+  //
+  const Float_t pedes  = ped.GetPedestal();
+  const Float_t prms   = ped.GetPedestalRms();
+  const Float_t num    = TMath::Sqrt((Float_t)fPedestals->GetTotalEntries());
+
+  //
+  // Calculate the average pedestal
+  //
+  avped += pedes;
+  avrms += prms;
+  avnum++;
+  
+  //
+  // set them in the calibration camera
+  //
+  if (cal.IsHiGainSaturation())
+    {
+      cal.SetPedestal(pedes* fNumLoGainSamples,
+                      prms * fSqrtLoGainSamples,
+                      prms * fNumLoGainSamples / num);
+      cal.CalcLoGainPedestal((Float_t)fNumLoGainSamples);
+    }
+  else
+    {
+      cal.SetPedestal(pedes* fNumHiGainSamples,
+                      prms * fSqrtHiGainSamples,
+                      prms * fNumHiGainSamples / num);
+    }
+  
+}
+
+
 
 Int_t MCalibrationChargeCalc::PostProcess()
@@ -417 +462 @@
 
       MCalibrationChargePix &pix = (*fCam)[pixid];
-      MBadPixelsPix         &bad = (*fBadPixels)[pixid];
-
       //
       // Check if the pixel has been excluded from the fits
@@ -425 +468 @@
         continue;
 
-      //
-      // get the pedestals
-      //
-      const Float_t ped    = (*fPedestals)[pixid].GetPedestal();
-      const Float_t prms   = (*fPedestals)[pixid].GetPedestalRms();
-      const Float_t num    = TMath::Sqrt((Float_t)fPedestals->GetTotalEntries());
+      MPedestalPix &ped = (*fPedestals)[pixid];
+
 
       if (fGeom->GetPixRatio(pixid) == 1.)
-      {
-          avinnerped  += ped;
-          avinnerprms += prms;
-          avinnernum++;
-      }
+        FinalizePedestals(ped,pix,avinnerped,avinnerprms,avinnernum);
       else
-      {
-          avouterped  += ped;
-          avouterprms += prms;
-          avouternum++;
-      }
-      //
-      // set them in the calibration camera
-      //
-      if (pix.IsHiGainSaturation())
-      {
-          pix.SetPedestal(ped  * fNumLoGainSamples,
-                          prms * fSqrtLoGainSamples,
-                          prms * fNumLoGainSamples / num);
-          pix.SetNumLoGainSamples(fNumLoGainSamples);
-          pix.ApplyLoGainConversion();
-      }
-      else
-      {
-          pix.SetPedestal(ped  * fNumHiGainSamples,
-                          prms * fSqrtHiGainSamples,
-                          prms * fNumHiGainSamples / num);
-      }
+        FinalizePedestals(ped,pix,avouterped,avouterprms,avouternum);
+
+
+      MBadPixelsPix         &bad = (*fBadPixels)[pixid];
 
       pix.CheckChargeValidity (&bad);
@@ -509 +526 @@
                               avinnerprms/avinnernum * fSqrtLoGainSamples,
                               avinnerprms/avinnernum * fSqrtLoGainSamples/avinnernum);
-      avinnerpix->SetNumLoGainSamples(fNumLoGainSamples);
-      avinnerpix->ApplyLoGainConversion();
+      avinnerpix->CalcLoGainPedestal((Float_t)fNumLoGainSamples);
   }
   else
@@ -524 +540 @@
                               avouterprms/avouternum * fSqrtLoGainSamples,
                               avouterprms/avouternum * fSqrtLoGainSamples/avouternum);
-      avouterpix->SetNumLoGainSamples(fNumLoGainSamples);
-      avouterpix->ApplyLoGainConversion();
+      avouterpix->CalcLoGainPedestal((Float_t)fNumLoGainSamples);
   }
   else

trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.h

@@ -18 +18 @@
 class MRawRunHeader;
 class MPedestalCam;
+class MPedestalPix;
 class MCalibrationChargePINDiode;
 class MCalibrationChargeBlindPix;
+class MCalibrationChargePix;
 class MCalibrationChargeCam;
 class MCalibrationQECam;
@@ -59 +61 @@
   Int_t  Process();
   Int_t  PostProcess();
+
+  void FinalizePedestals(MPedestalPix &ped, MCalibrationChargePix &cal,
+                         Float_t &avped, Float_t &avrms, Float_t &avnum);
+  
   
 public:

trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc

@@ -177 +177 @@
   fLoGainNumPickup                  =  -1;
 
-  fNumLoGainSamples                 =  -1.;
-
   fPed                              =  -1.;
   fPedRms                           =  -1.;
@@ -708 +706 @@
 }
 
-void MCalibrationChargePix::CalcLoGainPed()
-{
-
-    Float_t pedRmsSquare      = fPedRms * fPedRms;
-    Float_t pedRmsSquareVar   = fPedVar * pedRmsSquare; // fPedRmsErr = fPedErr/2.
-    
-    //
-    // We do not know the Lo Gain Pedestal RMS, so we have to retrieve it 
-    // from the HI GAIN (all calculation per slice up to now):  
-    //
-    // We extract the pure NSB contribution:
-    //
-    const Float_t elecRmsSquare    =    fElectronicPedRms    * fElectronicPedRms;
-    const Float_t elecRmsSquareVar = 4.*fElectronicPedRmsVar * elecRmsSquare;
-    
-    Float_t nsbSquare             =  pedRmsSquare    - elecRmsSquare;
-    Float_t nsbSquareRelVar       = (pedRmsSquareVar + elecRmsSquareVar)
-                                        / (nsbSquare * nsbSquare) ;
-    
-    if (nsbSquare < 0.)
-      nsbSquare = 0.;
-    
-    //
-    // Now, we divide the NSB by the conversion factor and 
-    // add it quadratically to the electronic noise
-    //
-    const Float_t conversionSquare        =    fConversionHiLo    * fConversionHiLo;
-    const Float_t convertedNsbSquare      =    nsbSquare       / conversionSquare;
-    const Float_t convertedNsbSquareVar   =    nsbSquareRelVar
-                                            * convertedNsbSquare * convertedNsbSquare;
-    
-    pedRmsSquare     = convertedNsbSquare    + elecRmsSquare;
-    pedRmsSquareVar  = convertedNsbSquareVar + elecRmsSquareVar;
-    
-    fLoGainPedRms    = TMath::Sqrt(pedRmsSquare);
-    fLoGainPedRmsVar = 0.25 * pedRmsSquareVar /  pedRmsSquare;
-
-}
 
 //
@@ -844 +804 @@
 
 
-void MCalibrationChargePix::ApplyLoGainConversion()
-{
-  
-  fElectronicPedRms       = gkElectronicPedRms    * TMath::Sqrt(fNumLoGainSamples);
-  fElectronicPedRmsVar    = gkElectronicPedRmsErr * gkElectronicPedRmsErr * fNumLoGainSamples;
-  
-  CalcLoGainPed();
-}
-
-
+void MCalibrationChargePix::CalcLoGainPedestal(Float_t logainsamples)
+{
+
+  fElectronicPedRms       = gkElectronicPedRms    * TMath::Sqrt(logainsamples);
+  fElectronicPedRmsVar    = gkElectronicPedRmsErr * gkElectronicPedRmsErr * logainsamples;
+  
+  Float_t pedRmsSquare      = fPedRms * fPedRms;
+  Float_t pedRmsSquareVar   = fPedVar * pedRmsSquare; // fPedRmsErr = fPedErr/2.
+  
+  //
+  // We do not know the Lo Gain Pedestal RMS, so we have to retrieve it 
+  // from the HI GAIN (all calculation per slice up to now):  
+  //
+  // We extract the pure NSB contribution:
+  //
+  const Float_t elecRmsSquare    =    fElectronicPedRms    * fElectronicPedRms;
+  const Float_t elecRmsSquareVar = 4.*fElectronicPedRmsVar * elecRmsSquare;
+  
+  Float_t nsbSquare             =  pedRmsSquare    - elecRmsSquare;
+  Float_t nsbSquareRelVar       = (pedRmsSquareVar + elecRmsSquareVar)
+                                 / (nsbSquare * nsbSquare) ;
+  
+  if (nsbSquare < 0.)
+    nsbSquare = 0.;
+  
+  //
+  // Now, we divide the NSB by the conversion factor and 
+  // add it quadratically to the electronic noise
+  //
+  const Float_t conversionSquare        =    fConversionHiLo    * fConversionHiLo;
+  const Float_t convertedNsbSquare      =    nsbSquare       / conversionSquare;
+  const Float_t convertedNsbSquareVar   =    nsbSquareRelVar
+                                            * convertedNsbSquare * convertedNsbSquare;
+    
+  pedRmsSquare     = convertedNsbSquare    + elecRmsSquare;
+  pedRmsSquareVar  = convertedNsbSquareVar + elecRmsSquareVar;
+  
+  fLoGainPedRms    = TMath::Sqrt(pedRmsSquare);
+  fLoGainPedRmsVar = 0.25 * pedRmsSquareVar /  pedRmsSquare;
+  
+}
+ 
+ 
+ 

trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.h

@@ -109 +109 @@
   Float_t fConversionHiLoVar;               // The error of the conversion factor between Hi Gain and Lo Gain  
 
-  Float_t fNumLoGainSamples;
-
-  Float_t   fHiGainNumPickup;
-  Float_t   fLoGainNumPickup;
+  Float_t fHiGainNumPickup;
+  Float_t fLoGainNumPickup;
 
   enum  { kHiGainSaturation, kLoGainSaturation,
@@ -121 +119 @@
           kPINDiodeMethodValid, kCombinedMethodValid };
 
-  void CalcLoGainPed();
-  
 public:
 
@@ -170 +166 @@
   void SetAbsTimeMean           ( const Float_t f ) { fAbsTimeMean           = f; }
   void SetAbsTimeRms            ( const Float_t f ) { fAbsTimeRms            = f; }
-
-  void SetNumLoGainSamples      ( const Float_t f ) { fNumLoGainSamples      = f; }
 
   // Conversion Factors
@@ -283 +277 @@
 
   // Miscellaneous
-  void  ApplyLoGainConversion();
-
   void CheckChargeValidity ( MBadPixelsPix *bad );
   void CheckTimeValidity   ( MBadPixelsPix *bad );
+
+  void  CalcLoGainPedestal(const Float_t logainsamples);
   Bool_t CalcReducedSigma();
   Bool_t CalcFFactorMethod();