Changeset 3671 for trunk/MagicSoft/Mars

Timestamp:

04/06/04 16:54:53 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• mcalib/MCalibrationPix.cc (modified) (5 diffs)
• mcalib/MCalibrationPix.h (modified) (2 diffs)
• mcalib/MHCalibrationCam.cc (modified) (9 diffs)

trunk/MagicSoft/Mars/Changelog

@@ -154 +154 @@
      - updated and enlarged documentation
 
-   * mcalib/MCalibrationPix.h
+   * mcalib/MCalibrationPix.[h,cc]
    * mcalib/MHCalibrationChargePINDiode.cc
    * mcalib/MHCalibrationChargeCam.[h,cc]
      - rename Setter for fMeanVar from SetMeanErr() to SetMeanVar()
      - rename arrays of fAverageSigmaErr to AverageSigmaVar
+     - add Getters to the relative variance
+
 
  2004/04/05: Nadia Tonello

trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc

@@ -127 +127 @@
 // --------------------------------------------------------------------------
 //
+// Get the Relative Variance of either High Gain or Low Gain Mean 
+// depending on IsHighGainSaturation()
+//
+// If variance is smaller than 0. return -1.
+//
+Float_t MCalibrationPix::GetMeanRelVar()  const
+{
+
+  if (IsHiGainSaturation())
+    if (fLoGainMeanVar < 0.)
+      return -1.;
+    else
+      return fLoGainMeanVar / (fLoGainMean * fLoGainMean);
+  else
+    if (fHiGainMeanVar < 0.)
+      return -1.;
+    else
+      return fHiGainMeanVar / (fHiGainMean * fHiGainMean);
+}
+
+// --------------------------------------------------------------------------
+//
+// Get the Relative Variance of either High Gain or Low Gain Sigma 
+// depending on IsHighGainSaturation()
+//
+// If variance is smaller than 0. return -1.
+//
+Float_t MCalibrationPix::GetSigmaRelVar()  const
+{
+
+  if (IsHiGainSaturation())
+    if (fLoGainSigmaVar < 0.)
+      return -1.;
+    else
+      return fLoGainSigmaVar / (fLoGainSigma * fLoGainSigma);
+  else
+    if (fHiGainSigmaVar < 0.)
+      return -1.;
+    else
+      return fHiGainSigmaVar / (fHiGainSigma * fHiGainSigma);
+}
+
+// --------------------------------------------------------------------------
+//
 // Get the High Gain Mean Error: Takes square root of fHiGainMeanVar
 //
 Float_t MCalibrationPix::GetHiGainMeanErr()  const
 {
-  return TMath::Sqrt(fHiGainMeanVar);
-}
+  if (fLoGainMeanVar < 0.)
+    return -1.;
+
+  return TMath::Sqrt(fLoGainMeanVar);
+}
+
 
 // --------------------------------------------------------------------------
@@ -140 +188 @@
 Float_t MCalibrationPix::GetHiGainSigmaErr()  const
 {
+  if (fHiGainSigmaVar < 0.)
+    return -1.;
+
   return TMath::Sqrt(fHiGainSigmaVar);
 }
@@ -145 +196 @@
 // --------------------------------------------------------------------------
 //
-// Get the Low Gain Mean Error: Takes square root of fHiGainMeanVar
+// Get the Low Gain Mean Error: Takes square root of fLoGainMeanVar
 //
 Float_t MCalibrationPix::GetLoGainMeanErr()  const
 {
+  if (fLoGainMeanVar < 0.)
+    return -1.;
+
   return TMath::Sqrt(fLoGainMeanVar);
 }
 
-
 // --------------------------------------------------------------------------
 //
@@ -159 +212 @@
 Float_t MCalibrationPix::GetLoGainSigmaErr()  const
 {
+  if (fLoGainSigmaVar < 0.)
+    return -1.;
+
   return TMath::Sqrt(fLoGainSigmaVar);
 }
@@ -168 +224 @@
 Bool_t MCalibrationPix::IsHiGainSaturation()    const
 { 
-   return TESTBIT(fFlags,kHiGainSaturation);  
+  return TESTBIT(fFlags,kHiGainSaturation);  
 }
 

trunk/MagicSoft/Mars/mcalib/MCalibrationPix.h

@@ -41 +41 @@
 
   void SetHiGainMean      ( const Float_t f ) { fHiGainMean      = f;   }
-  void SetHiGainMeanErr   ( const Float_t f ) { fHiGainMeanVar   = f*f; }
+  void SetHiGainMeanVar   ( const Float_t f ) { fHiGainMeanVar   = f; }
   void SetHiGainProb      ( const Float_t f ) { fHiGainProb      = f;   }
   void SetHiGainSigma     ( const Float_t f ) { fHiGainSigma     = f;   }
-  void SetHiGainSigmaErr  ( const Float_t f ) { fHiGainSigmaVar  = f*f; }
+  void SetHiGainSigmaVar  ( const Float_t f ) { fHiGainSigmaVar  = f; }
   void SetHiGainNumPickup ( const Float_t f ) { fHiGainNumPickup = f;   }
 
   void SetLoGainMean      ( const Float_t f ) { fLoGainMean      = f;   }
-  void SetLoGainMeanErr   ( const Float_t f ) { fLoGainMeanVar   = f*f; }
+  void SetLoGainMeanVar   ( const Float_t f ) { fLoGainMeanVar   = f; }
   void SetLoGainProb      ( const Float_t f ) { fLoGainProb      = f;   }
   void SetLoGainSigma     ( const Float_t f ) { fLoGainSigma     = f;   }
-  void SetLoGainSigmaErr  ( const Float_t f ) { fLoGainSigmaVar  = f*f; }
+  void SetLoGainSigmaVar  ( const Float_t f ) { fLoGainSigmaVar  = f; }
   void SetLoGainNumPickup ( const Float_t f ) { fLoGainNumPickup = f;   }
 
   void SetMean       ( const Float_t f ) { IsHiGainSaturation() ? fLoGainMean = f       : fHiGainMean = f      ; }
-  void SetMeanErr    ( const Float_t f ) { IsHiGainSaturation() ? fLoGainMeanVar = f*f  : fHiGainMeanVar = f*f ; }
+  void SetMeanVar    ( const Float_t f ) { IsHiGainSaturation() ? fLoGainMeanVar = f    : fHiGainMeanVar = f  ;  }
   void SetProb       ( const Float_t f ) { IsHiGainSaturation() ? fLoGainProb = f       : fHiGainProb = f      ; }
   void SetSigma      ( const Float_t f ) { IsHiGainSaturation() ? fLoGainSigma = f      : fHiGainSigma = f     ; }
-  void SetSigmaErr   ( const Float_t f ) { IsHiGainSaturation() ? fLoGainSigmaVar = f*f : fHiGainSigmaVar = f*f; }
+  void SetSigmaVar   ( const Float_t f ) { IsHiGainSaturation() ? fLoGainSigmaVar = f   : fHiGainSigmaVar = f  ; }
   void SetNumPickup  ( const Float_t f ) { IsHiGainSaturation() ? fLoGainNumPickup = f  : fHiGainNumPickup = f ; }
   
@@ -82 +82 @@
   Float_t GetMean       () const { return IsHiGainSaturation() ? GetLoGainMean()      : GetHiGainMean()     ; }
   Float_t GetMeanErr    () const { return IsHiGainSaturation() ? GetLoGainMeanErr()   : GetHiGainMeanErr()  ; }
+  Float_t GetMeanRelVar () const;
   Float_t GetProb       () const { return IsHiGainSaturation() ? GetLoGainProb()      : GetHiGainProb()     ; }
   Float_t GetSigma      () const { return IsHiGainSaturation() ? GetLoGainSigma()     : GetHiGainSigma()    ; }
   Float_t GetSigmaErr   () const { return IsHiGainSaturation() ? GetLoGainSigmaErr()  : GetHiGainSigmaErr() ; }
+  Float_t GetSigmaRelVar() const;
   Float_t GetNumPickup  () const { return IsHiGainSaturation() ? GetLoGainNumPickup() : GetHiGainNumPickup(); }
 

trunk/MagicSoft/Mars/mcalib/MHCalibrationCam.cc

@@ -309 +309 @@
   cam->fAverageAreaSat         = fAverageAreaSat;
   cam->fAverageAreaSigma       = fAverageAreaSigma;      
-  cam->fAverageAreaSigmaErr    = fAverageAreaSigmaErr;   
+  cam->fAverageAreaSigmaVar    = fAverageAreaSigmaVar;   
   cam->fAverageAreaRelSigma    = fAverageAreaRelSigma;
-  cam->fAverageAreaRelSigmaErr = fAverageAreaRelSigmaErr;   
+  cam->fAverageAreaRelSigmaVar = fAverageAreaRelSigmaVar;   
   cam->fAverageSectorNum       = fAverageSectorNum;      
 
@@ -408 +408 @@
   fAverageAreaSat.        Set(nareas);           
   fAverageAreaSigma.      Set(nareas);      
-  fAverageAreaSigmaErr.   Set(nareas);   
+  fAverageAreaSigmaVar.   Set(nareas);   
   fAverageAreaRelSigma.   Set(nareas);   
-  fAverageAreaRelSigmaErr.Set(nareas);
+  fAverageAreaRelSigmaVar.Set(nareas);
   fAverageSectorNum.      Set(nsectors);
 
@@ -644 +644 @@
       MCalibrationPix &pix    = (*fCam).GetAverageArea(j);
 
-      fAverageAreaSigma[j]    = pix.GetSigma    () * TMath::Sqrt((Float_t)fAverageAreaNum[j]);
-      fAverageAreaSigmaErr[j] = pix.GetSigmaErr () * TMath::Sqrt((Float_t)fAverageAreaNum[j]);
+      const Float_t numsqr    = TMath::Sqrt((Float_t)fAverageAreaNum[j]);
+      fAverageAreaSigma[j]    = pix.GetSigma    () * numsqr;
+      fAverageAreaSigmaVar[j] = pix.GetSigmaErr () * pix.GetSigmaErr() * numsqr;
 
       pix.SetSigma   (fAverageAreaSigma[j]);
-      pix.SetSigmaErr(fAverageAreaSigmaErr[j]);
-
-      fAverageAreaRelSigma[j]   = fAverageAreaSigma[j] / pix.GetMean();
-      
-      Float_t relsigmaerr       =  fAverageAreaSigmaErr[j]*fAverageAreaSigmaErr[j] 
-                                / (fAverageAreaSigma[j]   *fAverageAreaSigma[j]   );
-      relsigmaerr               += pix.GetMeanErr()*pix.GetMeanErr() 
-                                / (pix.GetMean()   *pix.GetMean()   );
-      relsigmaerr               *= fAverageAreaRelSigma[j];
-      fAverageAreaRelSigmaErr[j] = TMath::Sqrt(relsigmaerr);
+      pix.SetSigmaVar(fAverageAreaSigmaVar[j]);
+
+      fAverageAreaRelSigma   [j]  = fAverageAreaSigma[j]    / pix.GetMean();
+      fAverageAreaRelSigmaVar[j]  = fAverageAreaSigmaVar[j] / (fAverageAreaSigma[j]*fAverageAreaSigma[j]);
+      fAverageAreaRelSigmaVar[j] += pix.GetMeanRelVar();
+      fAverageAreaRelSigmaVar[j] *= fAverageAreaRelSigma[j];
     }
 }
@@ -717 +714 @@
   //
   pix.SetHiGainMean      ( hist.GetMean()      );
-  pix.SetHiGainMeanErr   ( hist.GetMeanErr()   );
+  pix.SetHiGainMeanVar   ( hist.GetMeanErr() * hist.GetMeanErr()   );
   pix.SetHiGainSigma     ( hist.GetSigma()     );
-  pix.SetHiGainSigmaErr  ( hist.GetSigmaErr()  );
+  pix.SetHiGainSigmaVar  ( hist.GetSigmaErr()* hist.GetSigmaErr()  );
   pix.SetHiGainProb      ( hist.GetProb()      );
   pix.SetHiGainNumPickup ( hist.GetPickup()    );
@@ -780 +777 @@
   //
   pix.SetLoGainMean      ( hist.GetMean()      );
-  pix.SetLoGainMeanErr   ( hist.GetMeanErr()   );
+  pix.SetLoGainMeanVar   ( hist.GetMeanErr()  * hist.GetMeanErr()   );
   pix.SetLoGainSigma     ( hist.GetSigma()     );
-  pix.SetLoGainSigmaErr  ( hist.GetSigmaErr()  );
+  pix.SetLoGainSigmaVar  ( hist.GetSigmaErr() * hist.GetSigmaErr()  );
   pix.SetLoGainProb      ( hist.GetProb()      );
   pix.SetLoGainNumPickup ( hist.GetPickup()    );
@@ -835 +832 @@
       if (!fAverageAreaSat[i])
         DrawAverageSigma(fAverageAreaSat[i], i,
-                         fAverageAreaSigma[i],    fAverageAreaSigmaErr[i],
-                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaErr[i]);
+                         fAverageAreaSigma[i],    fAverageAreaSigmaVar[i],
+                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaVar[i]);
 
       pad->cd(2*(i+1));
@@ -843 +840 @@
       if (fAverageAreaSat[i])
         DrawAverageSigma(fAverageAreaSat[i], i,
-                         fAverageAreaSigma[i], fAverageAreaSigmaErr[i],
-                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaErr[i]);
+                         fAverageAreaSigma[i], fAverageAreaSigmaVar[i],
+                         fAverageAreaRelSigma[i], fAverageAreaRelSigmaVar[i]);
     }
 }
@@ -855 +852 @@
 //
 void MHCalibrationCam::DrawAverageSigma(Bool_t sat, Bool_t inner,
-                                              Float_t sigma, Float_t sigmaerr,
-                                              Float_t relsigma, Float_t relsigmaerr) const 
-{
-  
-  if (sigma != 0)
+                                              Float_t sigma, Float_t sigmavar,
+                                              Float_t relsigma, Float_t relsigmavar) const 
+{
+  
+  if (sigma != 0 && sigmavar >= 0 && relsigmavar >= 0.)
     {
       
@@ -872 +869 @@
                                  " Pixels ", sat ? "Low Gain" : "High Gain");
       TText *txt1 = text->AddText(line1.Data());
-      const TString line2 = Form("#sigma per pix: %2.2f #pm %2.2f",sigma,sigmaerr);
+      const TString line2 = Form("#sigma per pix: %2.2f #pm %2.2f",sigma,TMath::Sqrt(sigmavar));
       TText *txt2 = text->AddText(line2.Data());
-      const TString line3 = Form("Rel. #sigma per pix: %2.2f #pm %2.2f",relsigma,relsigmaerr);
+      const TString line3 = Form("Rel. #sigma per pix: %2.2f #pm %2.2f",relsigma,TMath::Sqrt(relsigmavar));
       TText *txt3 = text->AddText(line3.Data());
       text->Draw("");