Changeset 2603

Timestamp:

12/05/03 01:08:44 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• macros/calibration.C (modified) (3 diffs)
• manalysis/MCalibrationBlindPix.cc (modified) (3 diffs)
• manalysis/MCalibrationBlindPix.h (modified) (2 diffs)
• manalysis/MCalibrationCalc.cc (modified) (12 diffs)
• manalysis/MCalibrationCalc.h (modified) (2 diffs)
• manalysis/MCalibrationCam.cc (modified) (19 diffs)
• manalysis/MCalibrationCam.h (modified) (4 diffs)
• manalysis/MCalibrationConfig.h (modified) (2 diffs)
• manalysis/MCalibrationPINDiode.cc (modified) (4 diffs)
• manalysis/MCalibrationPINDiode.h (modified) (2 diffs)
• manalysis/MCalibrationPix.cc (modified) (6 diffs)
• manalysis/MCalibrationPix.h (modified) (2 diffs)
• mhist/MHCalibrationBlindPixel.cc (modified) (20 diffs)
• mhist/MHCalibrationBlindPixel.h (modified) (5 diffs)
• mhist/MHCalibrationConfig.h (modified) (1 diff)
• mhist/MHCalibrationPINDiode.cc (modified) (3 diffs)
• mhist/MHCalibrationPINDiode.h (modified) (2 diffs)
• mhist/MHCalibrationPixel.cc (modified) (19 diffs)
• mhist/MHCalibrationPixel.h (modified) (3 diffs)

trunk/MagicSoft/Mars/Changelog

@@ -9 +9 @@
      - implemented some of Thomas Bretz suggestions to make the code nicer
      - implemented the possibility to have cosmics in the calibration data 
-       and still fit it
-     - conversion HiGain/LoGain now left out (it seems to be already done in 
-        the data)
+       and remove it
+     - implemented the conversion factors for the blind pixel method
 
   * mhist/MHCalibration*

trunk/MagicSoft/Mars/macros/calibration.C

@@ -184 +184 @@
     MHCamera disp10  (geomcam, "MCalibrationCam;pedrms", "Pedestal RMS");
     MHCamera disp11  (geomcam, "MCalibrationCam;rq", "Reduced Charges");
-    MHCamera disp12  (geomcam, "MCalibrationCam;errrq", "Error of Reduced Charges");
+    MHCamera disp12  (geomcam, "MCalibrationCam;rsigma", "Reduced Sigmas");
     MHCamera disp13  (geomcam, "MCalibrationCam;phe", "Nr. of Phe's (F-Factor Method)");
     MHCamera disp14  (geomcam, "MCalibrationCam;convphe", "Conversion Factor (F-Factor Method)");
+    MHCamera disp15  (geomcam, "MCalibrationCam;photons", "Nr. of Photons (Blind Pixel Method)");
+    MHCamera disp16  (geomcam, "MCalibrationCam;convphot", "Conversion Factor (Blind Pixel Method)");
 
     disp1.SetCamContent(*cam, 0);
@@ -200 +202 @@
     disp11.SetCamContent(*cam, 10);
     disp12.SetCamContent(*cam, 11);
-    disp12.SetCamContent(*cam, 12);
-    disp13.SetCamContent(*cam, 13);
+    disp13.SetCamContent(*cam, 12);
+    disp14.SetCamContent(*cam, 13);
+    disp15.SetCamContent(*cam, 14);
+    disp16.SetCamContent(*cam, 15);
+
 
     disp1.SetYTitle("Q [FADC counts]");
-    disp2.SetYTitle("\\Delta_{Q} [FADC counts]");
+    disp2.SetYTitle("\\Delta Q [FADC counts]");
     disp3.SetYTitle("\\sigma_{Q} [FADC counts]");
-    disp4.SetYTitle("\\Delta_{\\sigma_{Q}} [FADC counts]");
+    disp4.SetYTitle("\\Delta {\\sigma_{Q}} [FADC counts]");
     disp5.SetYTitle("P [au]");
     disp6.SetYTitle("T [FADC slices]");
-    disp7.SetYTitle("\\Delta_{T} [FADC slices]");
+    disp7.SetYTitle("\\Delta T [FADC slices]");
     disp8.SetYTitle("P [au]");
     disp9.SetYTitle("P [FADC counts/ slice ]");
     disp10.SetYTitle("RMS_{P} [FADC counts / slice ]");
     disp11.SetYTitle("Q [FADC counts]");
-    disp12.SetYTitle("\\Delta_{Q} [FADC counts]");
+    disp12.SetYTitle("\\sigma^2_{Q} - RMS^2_{P} [FADC counts^2]");
     disp13.SetYTitle("Nr Phe's");
     disp14.SetYTitle("Conversion Factor [Phe/FADC count]");
+    disp15.SetYTitle("Nr Photons");
+    disp16.SetYTitle("Conversion Factor [Ph/FADC count]");
 
     MStatusDisplay *d2 = new MStatusDisplay;
@@ -350 +357 @@
     obj->Draw();
 
+    TCanvas *c6 = &d2->AddTab("Blind Pixel Method");
+    c6->Divide(2, 2);
+
+    c6->cd(1);
+    gStyle->SetOptStat(1111);
+    obj=disp15.DrawCopy("hist");
+
+    c6->cd(3);
+    obj->Draw();
+
+    c6->cd(2);
+    gStyle->SetOptStat(1101);
+    obj=disp16.DrawCopy("hist");
+
+    c6->cd(4);
+    obj->Draw();
+
 
 #endif

trunk/MagicSoft/Mars/manalysis/MCalibrationBlindPix.cc

@@ -59 +59 @@
   fErrLambda = fErrMu0 = fErrMu1 = fErrSigma0 = fErrSigma1 = 0;
   
-  fT = fErrT = 0;
+  fTime = fErrTime = 0;
 }
 
@@ -76 +76 @@
 }
 
-Bool_t MCalibrationBlindPix::FitQ() 
+Bool_t MCalibrationBlindPix::FitCharge() 
 {
   if (!fHist->FitSinglePhe())
@@ -98 +98 @@
 
 
-Bool_t MCalibrationBlindPix::FitT() 
+Bool_t MCalibrationBlindPix::FitTime() 
 {
 
-  if(!fHist->FitT())
+  if(!fHist->FitTime())
     return kFALSE;
 
-  fT    = fHist->GetMeanT();
-  fErrT = fHist->GetMeanTErr();
+  fTime    = fHist->GetMeanTime();
+  fErrTime = fHist->GetMeanTimeErr();
   
   return kTRUE;

trunk/MagicSoft/Mars/manalysis/MCalibrationBlindPix.h

@@ -24 +24 @@
   Float_t fErrSigma1;        // The error of the width of the first phe-peak  
   
-  Float_t fT;                // The mean arrival time after the fit  
-  Float_t fErrT;             // The error of the mean arrival time after the fit
+  Float_t fTime;                // The mean arrival time after the fit  
+  Float_t fErrTime;             // The error of the mean arrival time after the fit
   
   MHCalibrationBlindPixel *fHist; // Pointer to the histograms performing the fits, etc.  
@@ -48 +48 @@
   Float_t GetErrSigma1() const    { return fErrSigma1;  }
 
-  Float_t GetT()         const    { return fT;         }
-  Float_t GetErrT()      const    { return fErrT;      }
+  Float_t GetTime()         const    { return fTime;         }
+  Float_t GetErrTime()      const    { return fErrTime;      }
   
-  Bool_t FillQ(Int_t q)            { return fHist->FillBlindPixelQ(q); }
-  Bool_t FillT(Int_t t)            { return fHist->FillBlindPixelT(t); }  
-  Bool_t FillRQvsT(Float_t rq, Int_t t) { return fHist->FillBlindPixelQvsN(rq,t); }    
+  Bool_t FillCharge(Int_t q)            { return fHist->FillBlindPixelCharge(q); }
+  Bool_t FillTime(Int_t t)            { return fHist->FillBlindPixelTime(t); }  
+  Bool_t FillRChargevsTime(Float_t rq, Int_t t) { return fHist->FillBlindPixelChargevsN(rq,t); }    
   
   Bool_t IsValid()                 { return fLambda > 0. || fErrLambda > 0.; }
   
-  Bool_t FitQ();
-  Bool_t FitT();
+  Bool_t FitCharge();
+  Bool_t FitTime();
   
   virtual void Draw(Option_t *opt="")         { fHist->Draw(opt); }

trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.cc

@@ -53 +53 @@
 //               Every MCalibrationPix holds a histogram class,             //
 //               MHCalibrationPixel which itself hold histograms of type:   //
-//               HQ(npix) (distribution of summed FADC time slice entries)  //
-//               HT(npix) (distribution of position of maximum)             //
-//               HQvsN(npix) (distribution of charges vs. event number.     //
-//                                                                          //
-// PostProcess:  All histograms HQ(npix) are fitted to a Gaussian           //
-//               All histograms HT(npix) are fitted to a Gaussian           //
-//               The histogram HBPQ (blind pixel) is fitted to a single     //
+//               HCharge(npix) (distribution of summed FADC time slice entries)  //
+//               HTime(npix) (distribution of position of maximum)             //
+//               HChargevsN(npix) (distribution of charges vs. event number.     //
+//                                                                          //
+// PostProcess:  All histograms HCharge(npix) are fitted to a Gaussian           //
+//               All histograms HTime(npix) are fitted to a Gaussian           //
+//               The histogram HBlindPixelCharge (blind pixel) is fitted to a single     //
 //                   PhE fit                                                //
-//               The histogram HBPT (blind pixel) is fitted to a Gaussian   //
+//               The histogram HBlindPixelTime (blind pixel) is fitted to a Gaussian   //
 //               The histograms of the PIN Diode are fitted to Gaussians    //
 //                                                                          //
 //               Fits can be excluded via the commands:                     //
-//               MalibrationCam::SetSkipTFits()   (skip all time fits)      //
-//               MalibrationCam::SetSkipBPFits()  (skip all blind pixel fits) //
-//               MalibrationCam::SetSkipPDFits()  (skip all PIN Diode fits) //
+//               MalibrationCam::SetSkipTimeFits()   (skip all time fits)      //
+//               MalibrationCam::SetSkipBlindPixelFits()  (skip all blind pixel fits) //
+//               MalibrationCam::SetSkipPinDiodeFits()  (skip all PIN Diode fits) //
 //                                                                          //
 //////////////////////////////////////////////////////////////////////////////
@@ -94 +94 @@
 
 #include "MTime.h"
+#include "TMath.h"
 
 ClassImp(MCalibrationCalc);
@@ -115 +116 @@
     AddToBranchList("MRawEvtData.fLoGainFadcSamples");
 
-    SETBIT(fFlags, kUseTFits);
-    SETBIT(fFlags, kUseBPFit);
-    SETBIT(fFlags, kUsePDFit);
+    SETBIT(fFlags, kUseTimeFits);
+    SETBIT(fFlags, kUseBlindPixelFit);
+    SETBIT(fFlags, kUsePinDiodeFit);
 }
 
@@ -219 +220 @@
       {
         MCalibrationPix &pix = (*fCalibrations)[i];
-        pix.ChangePixId(i);
+        pix.DefinePixId(i);
       }
     
@@ -244 +245 @@
     MRawEvtPixelIter pixel(fRawEvt);
 
+    // Create a first loop to sort out the cosmics ...
+    // 
+    // This is a very primitive check for the number of cosmicpixs
+    // The cut will be applied in the fit, but for the blind pixel,
+    // we need to remove this event
+    //
+    // FIXME: In the future need a much more sophisticated one!!!
+    //
+    
     while (pixel.Next())
       {
 
+        const Int_t pixid = pixel.GetPixelId();
+
+        Int_t sum = pixel.GetSumHiGainSamples();
+
+        MPedestalPix    &ped = (*fPedestals)[pixid];
+ 
+        Float_t pedes  = ped.GetPedestal();
+        Float_t pedrms = ped.GetPedestalRms();
+        
+        if ((float)sum < (pedes*fNumHiGainSamples)+(1.5*pedrms) )
+           cosmicpix++;
+     }
+
+
+    if (cosmicpix > 50.)
+      {
+        fCosmics++;
+        return kTRUE;
+      }
+
+    pixel.Reset();
+
+    while (pixel.Next())
+      {
+
         UShort_t sat = 0;
+        UShort_t lowgainoverflow = 0;
+
         const Int_t pixid = pixel.GetPixelId();
 
@@ -269 +306 @@
             //         performed in the data?!?
             //
-            sum = (max > gkSaturationLimit              // overflow of LoGain ??? -> GimmeABreak!!!
-                   ? fHistOverFlow++, gkLoGainOverFlow  // OUCH (Florian was maybe right)
-                   : sum  );                            // OUFF (Florian was wrong) !! 
-            //                   : sum*gkConversionHiLo    );          // OUFF (Florian was wrong) !! 
-
-            if (fHistOverFlow) 
-              *fLog << err << dbginf << "Warning: Saturation of LoGain reached! " 
-                    << err << dbginf << "sum = " << sum << endl;
-
+            sum = (max > gkSaturationLimit                // overflow of LoGain ??? -> GimmeABreak!!!
+                   ? lowgainoverflow++, gkLoGainOverFlow  // OUCH (Florian was maybe right)
+                   : sum*gkConversionHiLo    );          // OUFF (Florian was wrong) !! 
+                   //                   : sum  );
+
+            if (lowgainoverflow)
+                { 
+                  *fLog << err << dbginf << "Warning: Saturation of LoGain reached in pixel: " << pixid << " " 
+                        << "   sum = " << sum << endl;
+                    fHistOverFlow++;
+                }
           }
 
@@ -293 +332 @@
         pedrms *= (sat ? fNumLoGainSamples : fNumHiGainSamples );
 
-        // 
-        // This is a very primitive check for the number of cosmicpixs
-        // The cut will be applied in the fit, but for the blind pixel,
-        // we need to remove this event
-        //
-        // FIXME: In the future need a much more sophisticated one!!!
-        //
-
-        if ((float)sum < pedes+4.*pedrms)
-           cosmicpix++;
-
         Float_t rsum      = (float)sum - pedes;
         
@@ -315 +343 @@
             //        the rest of the pixels (which is the case right now)
             //
-            if (cosmicpix < 100.)
-              {
-                if (!blindpixel.FillQ(sum)) 
-                  *fLog << warn << 
-                    "Overflow or Underflow occurred filling Blind Pixel sum = " << sum << endl;
-
-                if (!blindpixel.FillT((int)mid)) 
-                  *fLog << warn << 
-                    "Overflow or Underflow occurred filling Blind Pixel time = " << (int)mid << endl;
-
-                if (!blindpixel.FillRQvsT(rsum,fEvents))
-                  *fLog << warn << 
-                    "Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
-              }
+            if (!blindpixel.FillCharge(sum)) 
+              *fLog << warn << 
+                "Overflow or Underflow occurred filling Blind Pixel sum = " << sum << endl;
+
+            if (!blindpixel.FillTime((int)mid)) 
+              *fLog << warn << 
+                "Overflow or Underflow occurred filling Blind Pixel time = " << (int)mid << endl;
+            
+            if (!blindpixel.FillRChargevsTime(rsum,fEvents))
+              *fLog << warn << 
+                "Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
             
           case gkCalibrationPINDiodeId:
-            if (!pindiode.FillQ(sum)) 
+            if (!pindiode.FillCharge(sum)) 
               *fLog << warn << 
-                "Overflow or Underflow occurred filling HQ: means = " << sum << endl;
-            if (!pindiode.FillT((int)mid)) 
+                "Overflow or Underflow occurred filling HCharge: means = " << sum << endl;
+            if (!pindiode.FillTime((int)mid)) 
               *fLog << warn << 
-                "Overflow or Underflow occurred filling HT: time = " << (int)mid << endl;
-            if (!pindiode.FillRQvsT(rsum,fEvents))
+                "Overflow or Underflow occurred filling HTime: time = " << (int)mid << endl;
+            if (!pindiode.FillRChargevsTime(rsum,fEvents))
               *fLog << warn << 
-                "Overflow or Underflow occurred filling HQvsN: eventnr = " << fEvents << endl;
+                "Overflow or Underflow occurred filling HChargevsN: eventnr = " << fEvents << endl;
 
           default:
 
-            if (!pix.FillQ(sum))
-              *fLog << warn << "Could not fill Q of pixel: " << pixid 
+            if (!pix.FillCharge(sum))
+              *fLog << warn << "Could not fill Charge of pixel: " << pixid 
                     << " signal = " << sum << endl;
 
@@ -350 +375 @@
             // Fill the reduced charge into the control histo for better visibility
             //
-            if (!pix.FillRQvsT(rsum,fEvents))
-              *fLog << warn << "Could not fill red. Q vs. EvtNr of pixel: " << pixid 
+            if (!pix.FillRChargevsTime(rsum,fEvents))
+              *fLog << warn << "Could not fill red. Charge vs. EvtNr of pixel: " << pixid 
                     << " signal = " << rsum  << " event Nr: " << fEvents << endl;
 
 
-            if (!pix.FillT((int)mid)) 
-            *fLog << warn << "Could not fill T of pixel: " << pixid << " time = " << (int)mid << endl;
+            if (!pix.FillTime((int)mid)) 
+            *fLog << warn << "Could not fill Time of pixel: " << pixid << " time = " << (int)mid << endl;
 
 
@@ -362 +387 @@
 
       } /* while (pixel.Next()) */
-
-    if (cosmicpix > 300.)
-        fCosmics++;
 
     return kTRUE;
@@ -389 +411 @@
   // Fit the blind pixel
   //
-  if (TESTBIT(fFlags,kUseBPFit))
+  if (TESTBIT(fFlags,kUseBlindPixelFit))
     {
-      if (!blindpixel.FitQ()) 
+      if (blindpixel.FitCharge())
+        if (!fCalibrations->CalcNrPhotInnerPixel())
+          *fLog << err << dbginf << "Could not calculate Number of photons from the blind pixel " << endl;
+      else
         *fLog << err << dbginf << "Could not fit the blind pixel " << endl;
       
-      if (!blindpixel.FitT())
+      if (!blindpixel.FitTime())
         *fLog << warn << "Could not the Times of the blind pixel " << endl;
 
@@ -412 +437 @@
 
       const Float_t ped    = (*fPedestals)[pixid].GetPedestal() * fNumHiGainSamples;
-      const Float_t prms   = (*fPedestals)[pixid].GetPedestalRms() * fNumHiGainSamples;
+      const Float_t prms   = (*fPedestals)[pixid].GetPedestalRms() * TMath::Sqrt((float)fNumHiGainSamples);
 
       pix.SetPedestal(ped,prms);
 
-      if (TESTBIT(fFlags,kUseTFits))
-        pix.FitT();
+      if (TESTBIT(fFlags,kUseTimeFits))
+        pix.FitTime();
       
-      pix.FitQ();
+      pix.FitCharge();
     }
 

trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.h

@@ -47 +47 @@
   enum
     {
-      kUseTFits = 1,
-      kUseBPFit = 2,
-      kUsePDFit = 3
+      kUseTimeFits = 1,
+      kUseBlindPixelFit = 2,
+      kUsePinDiodeFit = 3
     };
 
@@ -69 +69 @@
   MCalibrationCalc(const char *name=NULL, const char *title=NULL);
 
-  void SetSkipTFits(Bool_t b=kTRUE)
-      {b ? CLRBIT(fFlags, kUseTFits) : SETBIT(fFlags, kUseTFits);}
-  void SetSkipBPFit(Bool_t b=kTRUE)
-      {b ? CLRBIT(fFlags, kUseBPFit) : SETBIT(fFlags, kUseBPFit);}
-  void SetSkipPDFit(Bool_t b=kTRUE)
-      {b ? CLRBIT(fFlags, kUsePDFit) : SETBIT(fFlags, kUsePDFit);}
+  void SetSkipTimeFits(Bool_t b=kTRUE)
+      {b ? CLRBIT(fFlags, kUseTimeFits) : SETBIT(fFlags, kUseTimeFits);}
+  void SetSkipBlindPixelFit(Bool_t b=kTRUE)
+      {b ? CLRBIT(fFlags, kUseBlindPixelFit) : SETBIT(fFlags, kUseBlindPixelFit);}
+  void SetSkipPinDiodeFit(Bool_t b=kTRUE)
+      {b ? CLRBIT(fFlags, kUsePinDiodeFit) : SETBIT(fFlags, kUsePinDiodeFit);}
 
   void SetPulserColor(PulserColor_t color)    { fColor = color; }

trunk/MagicSoft/Mars/manalysis/MCalibrationCam.cc

@@ -56 +56 @@
 //
 MCalibrationCam::MCalibrationCam(const char *name, const char *title)
-    : fMeanNrPhotAvailable(kFALSE)
+    : fMeanNrPhotAvailable(kFALSE),
+      fMeanNrPhotInnerPix(-1.)
 {
     fName  = name  ? name  : "MCalibrationCam";
@@ -128 +129 @@
     return NULL;
   
-//    return (*this)[idx];
   return (MCalibrationPix*)fPixels->At(idx);
 }
@@ -148 +148 @@
     return kFALSE;
 
-  return (&(*this)[idx]);
+  return kTRUE;
 }
 
 Bool_t MCalibrationCam::IsPixelFitted(Int_t idx) const 
 {
-  return ((*this)[idx].GetRQ() > 0. && (*this)[idx].GetErrRQ() > 0.);
+  return ((*this)[idx].GetRCharge() > 0. && (*this)[idx].GetErrRCharge() > 0.);
 }
 
@@ -170 +170 @@
 // The number of succesful fits is returned
 //
-UShort_t MCalibrationCam::FitQ(Int_t i)
+UShort_t MCalibrationCam::FitCharge(Int_t i)
 {
 
@@ -189 +189 @@
       while ((pix=(MCalibrationPix*)Next()))
         {
-          if (pix->FitQ())
+          if (pix->FitCharge())
             nsuccess++;
         }
@@ -195 +195 @@
   else                  // fit only the pixel with index i
     {
-      if((*this)[i].FitQ())
+      if((*this)[i].FitCharge())
         nsuccess++;
     }
@@ -209 +209 @@
 // The number of succesful fits is returned
 //
-UShort_t MCalibrationCam::FitAllQ()
+UShort_t MCalibrationCam::FitAllCharge()
 {
 
@@ -222 +222 @@
   while ((pix=(MCalibrationPix*)Next()))
     {
-      if (pix->FitQ())
-        nsuccess++;
-    }
-  
-  if (fBlindPixel->FitQ())
-        nsuccess++;
-
-  if (fPINDiode->FitQ())
+      if (pix->FitCharge())
+        nsuccess++;
+    }
+  
+  if (fBlindPixel->FitCharge())
+        nsuccess++;
+
+  if (fPINDiode->FitCharge())
         nsuccess++;
 
@@ -245 +245 @@
 // The number of succesful fits is returned
 //
-UShort_t MCalibrationCam::FitT(Int_t i)
+UShort_t MCalibrationCam::FitTime(Int_t i)
 {
 
@@ -264 +264 @@
       while ((pix=(MCalibrationPix*)Next()))
         {
-         if (pix->FitT())
+         if (pix->FitTime())
             nsuccess++;
         }
@@ -270 +270 @@
   else                     // fit only the pixel with index i
     {
-      if((*this)[i].FitT())
+      if((*this)[i].FitTime())
         nsuccess++;
     }
@@ -285 +285 @@
 // The number of succesful fits is returned
 //
-UShort_t MCalibrationCam::FitAllT()
+UShort_t MCalibrationCam::FitAllTime()
 {
 
@@ -298 +298 @@
   while ((pix=(MCalibrationPix*)Next()))
     {
-      if (pix->FitT())
-        nsuccess++;
-    }
-  
-  if (fBlindPixel->FitT())
-        nsuccess++;
-
-  if (fPINDiode->FitT())
+      if (pix->FitTime())
+        nsuccess++;
+    }
+  
+  if (fBlindPixel->FitTime())
+        nsuccess++;
+
+  if (fPINDiode->FitTime())
        nsuccess++;
 
@@ -364 +364 @@
     {
 
-        *fLog << id << ": " << pix->GetPed() << " " << pix->GetPedRms() << " Charges: " ;
-        *fLog << pix->GetQ() << " " << pix->GetRQ() << endl;
+        *fLog << id << " Pedestals: " << pix->GetPed() << " +- " << pix->GetPedRms() << " Charge: " 
+              << pix->GetCharge() << " Reduced Charge: " << pix->GetRCharge() << " +- " 
+              << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigma() << endl;
 
         id++;
@@ -378 +379 @@
     {
     case 0:
-       val = (*this)[idx].GetQ();
+       val = (*this)[idx].GetCharge();
         break;
     case 1:
-       val = (*this)[idx].GetErrQ();
+       val = (*this)[idx].GetErrCharge();
         break;
     case 2:
-       val = (*this)[idx].GetSigmaQ();
+       val = (*this)[idx].GetSigmaCharge();
         break;
     case 3:
-       val = (*this)[idx].GetErrSigmaQ();
+       val = (*this)[idx].GetErrSigmaCharge();
         break;
     case 4:
-       val = (*this)[idx].GetQProb();
+       val = (*this)[idx].GetChargeProb();
         break;
     case 5:
-       val = (*this)[idx].GetT();
+       val = (*this)[idx].GetTime();
         break;
     case 6:
-       val = (*this)[idx].GetSigmaT();
+       val = (*this)[idx].GetSigmaTime();
         break;
     case 7:
-       val = (*this)[idx].GetTProb();
+       val = (*this)[idx].GetTimeProb();
         break;
     case 8:
@@ -408 +409 @@
         break;
     case 10:
-      val = (*this)[idx].GetRQ();
-        break;
+      val = (*this)[idx].GetRCharge();
+      break;
     case 11:
-      val = (*this)[idx].GetErrRQ();
+      val = (*this)[idx].GetRSigma();
       break;
     case 12:
@@ -419 +420 @@
       val = (*this)[idx].GetConversionFFactorMethod();
       break;
+    case 14:
+      val = (double)fMeanNrPhotInnerPix;
+      break;
+    case 15:
+      if ((fMeanNrPhotInnerPix > 0. ) && ((*this)[idx].GetRCharge() > 100.))
+        val = fMeanNrPhotInnerPix / (*this)[idx].GetRCharge();
+      else 
+        val = -1.;
+      break;
     default:
       return kFALSE;
@@ -443 +453 @@
     {
     case kECGreen:
-      fMeanNrPhotInnerPix = mean / 
-                           (gkCalibrationBlindPixelQEGreen
-                            *TMath::Power(10,gkCalibrationBlindPixelAttGreen)
-                            *gkCalibrationBlindPixelArea);
+      fMeanNrPhotInnerPix = (mean / gkCalibrationBlindPixelQEGreen) // real photons
+                            *TMath::Power(10,gkCalibrationBlindPixelAttGreen) // correct for absorption 
+                            / gkCalibrationBlindPixelArea;          // correct for area
       break;
     case kECBlue:
-      fMeanNrPhotInnerPix = mean / 
-                           (gkCalibrationBlindPixelQEBlue
+      fMeanNrPhotInnerPix = (mean / gkCalibrationBlindPixelQEBlue )
                             *TMath::Power(10,gkCalibrationBlindPixelAttBlue)
-                            *gkCalibrationBlindPixelArea);
+                            / gkCalibrationBlindPixelArea;
       break;
     case kECUV:
-      fMeanNrPhotInnerPix = mean / 
-                           (gkCalibrationBlindPixelQEUV
+      fMeanNrPhotInnerPix = (mean / gkCalibrationBlindPixelQEUV )
                             *TMath::Power(10,gkCalibrationBlindPixelAttUV)
-                            *gkCalibrationBlindPixelArea);
+                            / gkCalibrationBlindPixelArea;
       break;
     }
@@ -478 +485 @@
       return kFALSE;
 
-  mean = fMeanNrPhotInnerPix / (*this)[ipx].GetRQ();
+  mean = fMeanNrPhotInnerPix / (*this)[ipx].GetRCharge();
 
   //

trunk/MagicSoft/Mars/manalysis/MCalibrationCam.h

@@ -33 +33 @@
   
   Int_t fNumPixels;
-  TClonesArray *fPixels;             // FIXME: Change TClonesArray away from a pointer?
+  TClonesArray *fPixels;             //! FIXME: Change TClonesArray away from a pointer?
   
-  MCalibrationBlindPix *fBlindPixel; // containing blind pixel data with fitresults
-  MCalibrationPINDiode *fPINDiode;   // containing PIN Diode data with fit results    
+  MCalibrationBlindPix *fBlindPixel; //! containing blind pixel data with fitresults
+  MCalibrationPINDiode *fPINDiode;   //! containing PIN Diode data with fit results    
 
   Float_t fMeanNrPhotInnerPix;       // The mean number of photons in an inner pixel  
@@ -42 +42 @@
   Bool_t  fMeanNrPhotAvailable;
 
-  Bool_t CalcNrPhotInnerPixel();
-  
 public:
   
@@ -70 +68 @@
   MCalibrationPix &operator[](Int_t i) const;
   
-  UShort_t FitQ(Int_t i=-1);
-  UShort_t FitAllQ();
-  UShort_t FitT(Int_t i=-1);
-  UShort_t FitAllT();
+  UShort_t FitCharge(Int_t i=-1);
+  UShort_t FitAllCharge();
+  UShort_t FitTime(Int_t i=-1);
+  UShort_t FitAllTime();
   
   Bool_t CheckBounds(Int_t i) const;
@@ -81 +79 @@
   void CutEdges();
   
+  Bool_t CalcNrPhotInnerPixel();
   Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
   void DrawPixelContent(Int_t num) const;    

trunk/MagicSoft/Mars/manalysis/MCalibrationConfig.h

@@ -15 +15 @@
 
 // The conversion factor between High Gain and Low Gain
-const UShort_t gkConversionHiLo = 10;
+const UShort_t gkConversionHiLo = 10.;
 
 // The penalty constant to produce overflow in the histogram 
@@ -26 +26 @@
 
 // Average QE of Blind Pixel (three colours)
-const Float_t gkCalibrationBlindPixelQEGreen = 15.4;
-const Float_t gkCalibrationBlindPixelQEBlue  = 22.6;
-const Float_t gkCalibrationBlindPixelQEUV    = 24.7;
+const Float_t gkCalibrationBlindPixelQEGreen = 0.154;
+const Float_t gkCalibrationBlindPixelQEBlue  = 0.226;
+const Float_t gkCalibrationBlindPixelQEUV    = 0.247;
 
 // Attenuation factor Blind Pixel (three colours)

trunk/MagicSoft/Mars/manalysis/MCalibrationPINDiode.cc

@@ -43 +43 @@
 //
 MCalibrationPINDiode::MCalibrationPINDiode(const char *name, const char *title)
-    : fHist(NULL)
+  : fHist(NULL),
+    fCharge(-1.),
+    fErrCharge(-1.),
+    fPed(-1.),
+    fPedRms(-1.),
+    fSigmaCharge(-1.),
+    fErrSigmaCharge(-1.),
+    fTime(-1.),
+    fErrTime(-1.),
+    fRCharge(-1.),
+    fErrRCharge(-1.)
 {
 
@@ -50 +60 @@
 
   fHist = new MHCalibrationPINDiode();
-
-  fQ   = fErrQ     = 0.;
-  fPed = fPedRms   = 0.;
-  fT   = fErrT  = 0.;
-  fRQ  = fErrRQ = 0.;
-  fSigmaQ = fErrSigmaQ = 0.;
 
 }
@@ -73 +77 @@
 }
 
-Bool_t MCalibrationPINDiode::FitQ() 
+Bool_t MCalibrationPINDiode::FitCharge() 
 {
-  if(!fHist->FitQ())
+  if(!fHist->FitCharge())
     return kFALSE;
 
-  fQ         = fHist->GetQMean();
-  fErrQ      = fHist->GetQMeanErr(); 
-  fSigmaQ    = fHist->GetQSigma();
-  fErrSigmaQ = fHist->GetQSigmaErr();
+  fCharge         = fHist->GetChargeMean();
+  fErrCharge      = fHist->GetChargeMeanErr(); 
+  fSigmaCharge    = fHist->GetChargeSigma();
+  fErrSigmaCharge = fHist->GetChargeSigmaErr();
 
   return kTRUE;
@@ -87 +91 @@
 }
 
-Bool_t MCalibrationPINDiode::FitT() 
+Bool_t MCalibrationPINDiode::FitTime() 
 {
 
-  if(!fHist->FitT())
+  if(!fHist->FitTime())
     return kFALSE;
 
-  fT = fHist->GetT();
-  fErrT = fHist->GetErrT();
+  fTime    = fHist->GetTime();
+  fErrTime = fHist->GetErrTime();
   
   return kTRUE;

trunk/MagicSoft/Mars/manalysis/MCalibrationPINDiode.h

@@ -12 +12 @@
 private:
 
-  Float_t fQ;                // The mean charge after the fit
-  Float_t fErrQ;             // The error of mean charge after the fit
+  MHCalibrationPINDiode *fHist; // Pointer to the histograms performing the fits, etc.  
+  
+  Float_t fCharge;                // The mean charge after the fit
+  Float_t fErrCharge;             // The error of mean charge after the fit
   Float_t fPed;              // The mean pedestal (from MPedestalPix)
   Float_t fPedRms;           // The pedestal  RMS (from MPedestalPix)
-  Float_t fSigmaQ;           // The sigma of the mean charge after the fit
-  Float_t fErrSigmaQ;        // The error of the sigma of the mean charge after the fit
-  Float_t fT;                // The mean arrival time after the fit  
-  Float_t fErrT;             // The error of the mean arrival time after the fit
+  Float_t fSigmaCharge;           // The sigma of the mean charge after the fit
+  Float_t fErrSigmaCharge;        // The error of the sigma of the mean charge after the fit
+  Float_t fTime;                // The mean arrival time after the fit  
+  Float_t fErrTime;             // The error of the mean arrival time after the fit
   
-  Float_t fRQ;               // The reduced mean charge after the fit
-  Float_t fErrRQ;            // The error of the reduced mean charge after the fit  
-  
-  MHCalibrationPINDiode *fHist; // Pointer to the histograms performing the fits, etc.  
+  Float_t fRCharge;               // The reduced mean charge after the fit
+  Float_t fErrRCharge;            // The error of the reduced mean charge after the fit  
   
 public:
@@ -36 +36 @@
   void SetPedRms(Float_t pedrms)    { fPedRms   = pedrms; }
 
-  Bool_t IsValid() const { return fRQ >=0 || fErrRQ >= 0; }
+  Bool_t IsValid() const { return fRCharge >=0 || fErrRCharge >= 0; }
 
-  Bool_t FillQ(Int_t q)            { return fHist->FillQ(q); }
-  Bool_t FillT(Int_t t)            { return fHist->FillT(t); }  
-  Bool_t FillRQvsT(Float_t rq, Int_t t) { return fHist->FillQvsN(rq,t); }    
+  Bool_t FillCharge(Int_t q)            { return fHist->FillCharge(q); }
+  Bool_t FillTime(Int_t t)            { return fHist->FillTime(t); }  
+  Bool_t FillRChargevsTime(Float_t rq, Int_t t) { return fHist->FillChargevsN(rq,t); }    
   
-  Bool_t FitQ();
-  Bool_t FitT();
+  Bool_t FitCharge();
+  Bool_t FitTime();
   
   MHCalibrationPINDiode *GetHist()  const  { return fHist;  }

trunk/MagicSoft/Mars/manalysis/MCalibrationPix.cc

@@ -25 +25 @@
 /////////////////////////////////////////////////////////////////////////////
 //                                                                         //
-// MCalibrationPix                                                            //
+// MCalibrationPix                                                         //
 //                                                                         //
 // This is the storage container to hold informations about the pedestal   //
@@ -46 +46 @@
 MCalibrationPix::MCalibrationPix(const char *name, const char *title)
     : fPixId(-1),
-      fQ(-1.),
-      fErrQ(-1.),
-      fSigmaQ(-1.),
-      fErrSigmaQ(-1.),
-      fQProb(-1.),
+      fCharge(-1.),
+      fErrCharge(-1.),
+      fSigmaCharge(-1.),
+      fErrSigmaCharge(-1.),
+      fChargeProb(-1.),
       fPed(-1.),
       fPedRms(-1.),
-      fT(-1.),
-      fSigmaT(-1.),
-      fTProb(-1.),
-      fRQ(-1.),
-      fErrRQ(-1.),
+      fTime(-1.),
+      fSigmaTime(-1.),
+      fTimeProb(-1.),
+      fRCharge(-1.),
+      fErrRCharge(-1.),
+      fRSigma(-1.),
       fFactor(1.3),
       fPheFFactorMethod(-1.),
@@ -66 +67 @@
   fTitle = title ? title : "Container of the MHCalibrationPixels and the fit results";
 
-  fHist = new MHCalibrationPixel("MHCalibrationPixel","Calibration Histograms Pixel");
+  fHist = new MHCalibrationPixel("MHCalibrationPixel","Calibration Histograms Pixel ");
+
 }
 
@@ -75 +77 @@
 
 
-void MCalibrationPix::ChangePixId(Int_t i)
+void MCalibrationPix::DefinePixId(Int_t i)
 {
   
@@ -93 +95 @@
 }
 
-Bool_t MCalibrationPix::FitQ() 
+Bool_t MCalibrationPix::FitCharge() 
 {
 
-  if (fHist->IsFitted())
+  if (fHist->IsFitOK())
     return kTRUE;
 
   if (fPed && fPedRms)
-    fHist->SetLowerFitRange(fPed + 2.0*fPedRms);
+    fHist->SetLowerFitRange(fPed + 1.5*fPedRms);
   else
     *fLog << warn << "Cannot set lower fit range to suppress cosmics: Pedestals not available" << endl;
 
-  if(!fHist->FitQ())
+  if(!fHist->FitCharge())
     {
       *fLog << warn << "Could not fit charges of pixel " << fPixId << endl;
-      fHist->PrintQFitResult();
+      fHist->PrintChargeFitResult();
       return kFALSE;
     }
   
-  fQ         = fHist->GetQMean();
-  fErrQ      = fHist->GetQMeanErr(); 
-  fSigmaQ    = fHist->GetQSigma();
-  fErrSigmaQ = fHist->GetQSigmaErr();
-  fQProb     = fHist->GetQProb();
+  fCharge         = fHist->GetChargeMean();
+  fErrCharge      = fHist->GetChargeMeanErr(); 
+  fSigmaCharge    = fHist->GetChargeSigma();
+  fErrSigmaCharge = fHist->GetChargeSigmaErr();
+  fChargeProb     = fHist->GetChargeProb();
 
   if ((fPed > 0.)  && (fPedRms > 0.))
     {
       
-    fRQ      = fQ - fPed;
-    fErrRQ   = TMath::Sqrt(fErrQ*fErrQ + fPedRms*fPedRms);
+    fRCharge      = fCharge - fPed;
+    fErrRCharge   = TMath::Sqrt(fErrCharge*fErrCharge + fPedRms*fPedRms);
 
-    fPheFFactorMethod = 
-      fFactor 
-      * fRQ * fRQ 
-      / (fSigmaQ * fSigmaQ - fPedRms*fPedRms) ;
+    fRSigma       = (fSigmaCharge*fSigmaCharge) - (fPedRms*fPedRms);
 
-    fConversionFFactorMethod = fPheFFactorMethod / fRQ ;
-    
+    if (fRSigma > 0. )
+      {
+       fPheFFactorMethod =  fFactor * fRCharge*fRCharge / fRSigma;
+       fConversionFFactorMethod = fPheFFactorMethod / fRCharge ;
+      }
+    else
+      {
+        *fLog << warn << "Cannot apply F-Factor method: Reduced Sigmas are smaller than 0 in pixel: " 
+              << fPixId << endl;
+      }
+
     }
 
@@ -142 +150 @@
   fPedRms = pedrms;
   
-  if ((!fRQ) && fQ) 
-    fRQ = fQ - fPed;
-  if ((!fErrRQ) && fErrQ)
-    fErrRQ   = TMath::Sqrt(fErrQ*fErrQ + fPedRms*fPedRms);
+  if ((fRCharge == -1.) && (fCharge > 0.)) 
+    fRCharge = fCharge - fPed;
+  if ((fErrRCharge == -1.) && (fErrCharge > 0.))
+    fErrRCharge   = TMath::Sqrt(fErrCharge*fErrCharge + fPedRms*fPedRms);
 
 }
 
-Bool_t MCalibrationPix::FitT() 
+Bool_t MCalibrationPix::FitTime() 
 {
 
-  if(!fHist->FitT())
+  if(!fHist->FitTime())
     {
       *fLog << warn << "Could not fit times of pixel " << fPixId << endl;
-      fHist->PrintTFitResult();
+      fHist->PrintTimeFitResult();
       return kFALSE;
     }
 
-  fT       = fHist->GetTMean();
-  fSigmaT  = fHist->GetTSigma();
-  fTProb   = fHist->GetTProb();
+  fTime       = fHist->GetTimeMean();
+  fSigmaTime  = fHist->GetTimeSigma();
+  fTimeProb   = fHist->GetTimeProb();
 
   return kTRUE;
-  
 }
 

trunk/MagicSoft/Mars/manalysis/MCalibrationPix.h

@@ -14 +14 @@
   Int_t   fPixId;           // the pixel Id
   
-  Float_t fQ;                // The mean charge after the fit
-  Float_t fErrQ;             // The error of mean charge after the fit
-  Float_t fSigmaQ;           // The sigma of the mean charge after the fit
-  Float_t fErrSigmaQ;        // The error of the sigma of the mean charge after the fit
-  Float_t fQProb;            // The probability of the fit function 
+  Float_t fCharge;              // The mean charge after the fit
+  Float_t fErrCharge;           // The error of mean charge after the fit
+  Float_t fSigmaCharge;         // The sigma of the mean charge after the fit
+  Float_t fErrSigmaCharge;      // The error of the sigma of the mean charge after the fit
+  Float_t fChargeProb;          // The probability of the fit function 
 
-  Float_t fPed;              // The mean pedestal (from MPedestalPix)
-  Float_t fPedRms;           // The pedestal  RMS (from MPedestalPix)
+  Float_t fPed;                 // The mean pedestal (from MPedestalPix)
+  Float_t fPedRms;              // The pedestal  RMS (from MPedestalPix)
 
-  Float_t fT;                // The mean arrival time after the fit  
-  Float_t fSigmaT;           // The error of the mean arrival time after the fit
-  Float_t fTProb;            // The probability of the fit function 
+  Float_t fTime;                // The mean arrival time after the fit  
+  Float_t fSigmaTime;           // The error of the mean arrival time after the fit
+  Float_t fTimeProb;            // The probability of the fit function 
   
-  Float_t fRQ;               // The reduced mean charge after the fit
-  Float_t fErrRQ;            // The error of the reduced mean charge after the fit  
+  Float_t fRCharge;             // The reduced mean charge after the fit
+  Float_t fErrRCharge;          // The error of the reduced mean charge after the fit  
+  Float_t fRSigma;              // The reduced squares of sigmas after the fit
+  
+  Float_t fFactor;                  // The laboratory F-factor
+  Float_t fPheFFactorMethod;        // The number of Phe's calculated after the F-factor method
+  Float_t fConversionFFactorMethod; // The conversion factor to Phe's calculated after the F-factor method
 
-  Float_t fFactor;            // The F-factor
-  Float_t fPheFFactorMethod;  // The number of Phe's calculated after the F-factor method
-  Float_t fConversionFFactorMethod; // The conversion factor to Phe's calculated after the F-factor method
-    
-  MHCalibrationPixel *fHist; // Pointer to the histograms performing the fits, etc.  
+  MHCalibrationPixel *fHist;    //! Pointer to the histograms performing the fits, etc.  
   
 public:
@@ -43 +44 @@
   void Clear(Option_t *o="");
 
-  Float_t GetQ()     const    { return fQ;     }
-  Float_t GetRQ()    const    { return fRQ;    }
+  Float_t GetCharge()         const    { return fCharge;         }
+  Float_t GetRCharge()        const    { return fRCharge;        }
+  Float_t GetRSigma()         const    { return fRSigma;         }
     
-  Float_t GetErrQ()  const    { return fErrQ;  }
-  Float_t GetErrRQ() const    { return fErrRQ; }    
-  Float_t GetQProb() const    { return fQProb;    }    
+  Float_t GetErrCharge()      const    { return fErrCharge;      }
+  Float_t GetErrRCharge()     const    { return fErrRCharge;     }    
+  Float_t GetChargeProb()     const    { return fChargeProb;     }    
   
-  Float_t GetSigmaQ()    const   { return fSigmaQ;    }
-  Float_t GetErrSigmaQ() const   { return fErrSigmaQ; }
-  Float_t GetT()         const   { return fT;         }
-  Float_t GetSigmaT()    const   { return fSigmaT;    }
-  Float_t GetTProb()     const   { return fTProb;    }    
+  Float_t GetSigmaCharge()    const    { return fSigmaCharge;    }
+  Float_t GetErrSigmaCharge() const    { return fErrSigmaCharge; }
+  Float_t GetTime()         const    { return fTime;         }
+  Float_t GetSigmaTime()    const    { return fSigmaTime;    }
+  Float_t GetTimeProb()     const    { return fTimeProb;     }    
   
-  Float_t GetPed()       const    { return fPed;     }
-  Float_t GetPedRms()    const    { return fPedRms;    }    
+  Float_t GetPed()          const    { return fPed;       }
+  Float_t GetPedRms()       const    { return fPedRms;    }    
 
-  void SetPedestal(Float_t ped, Float_t pedrms);       
+  void SetPedestal(Float_t ped, Float_t pedrms);
 
-  Bool_t FillQ(Int_t q)                 { return fHist->FillQ(q); }
-  Bool_t FillT(Int_t t)                 { return fHist->FillT(t); }  
-  Bool_t FillRQvsT(Float_t rq, Int_t t) { return fHist->FillQvsN(rq,t); }    
+  Bool_t FillCharge(Int_t q)           { return fHist->FillCharge(q); }
+  Bool_t FillTime(Int_t t)             { return fHist->FillTime(t); }  
+  Bool_t FillRChargevsTime(Float_t rq, Int_t t) { return fHist->FillChargevsN(rq,t); }    
   
-  Bool_t IsValid()      const           { return fRQ >=0 || fErrRQ >= 0; }
-  Int_t  GetPixId()     const           { return fPixId;   }
-  void ChangePixId(Int_t i);
+  Bool_t IsValid()          const    { return fRCharge >=0 || fErrRCharge >= 0; }
+  Int_t  GetPixId()         const    { return fPixId;   }
+  void   DefinePixId(Int_t i);
   
-  Bool_t FitQ();
-  Bool_t FitT();
+  Bool_t FitCharge();
+  Bool_t FitTime();
   
-  MHCalibrationPixel *GetHist()     const  { return fHist;  }
-  virtual void Draw(Option_t *opt="")     { fHist->Draw(opt); }
+  MHCalibrationPixel *GetHist() const  { return fHist;  }
+  virtual void Draw(Option_t *opt="")   { fHist->Draw(opt); }
   
-  Float_t GetPheFFactorMethod() const        { return fPheFFactorMethod;  }  
-  Float_t GetConversionFFactorMethod() const { return fConversionFFactorMethod;  }
+  Float_t GetPheFFactorMethod()           const { return fPheFFactorMethod;           }  
+  Float_t GetConversionFFactorMethod()    const { return fConversionFFactorMethod;    }
   
   ClassDef(MCalibrationPix, 1)  // Storage Container for Calibration information of one pixel

trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.cc

@@ -69 +69 @@
 
     // Create a large number of bins, later we will rebin
-    fBlindPixelQfirst = 0;
-    fBlindPixelQlast  = gkStartBlindPixelBinNr;
-    fBlindPixelQnbins = gkStartBlindPixelBinNr;
-
-    fHBlindPixelQ = new TH1I("HBlindPixelQ","Distribution of Summed FADC Slices",fBlindPixelQnbins,fBlindPixelQfirst,fBlindPixelQlast);
-    fHBlindPixelQ->SetXTitle("Sum FADC Slices");
-    fHBlindPixelQ->SetYTitle("Nr. of events");
-    fHBlindPixelQ->Sumw2();
-
-    fErrBlindPixelQfirst = 0.;
-    fErrBlindPixelQlast  = gkStartBlindPixelBinNr;
-    fErrBlindPixelQnbins = gkStartBlindPixelBinNr;
-
-    fHBlindPixelErrQ = new TH1F("HBlindPixelErrQ","Distribution of Variances of Summed FADC Slices",
-                        fErrBlindPixelQnbins,fErrBlindPixelQfirst,fErrBlindPixelQlast);
-    fHBlindPixelErrQ->SetXTitle("Variance Summed FADC Slices");
-    fHBlindPixelErrQ->SetYTitle("Nr. of events");
-    fHBlindPixelErrQ->Sumw2();
+    fBlindPixelChargefirst = 0;
+    fBlindPixelChargelast  = gkStartBlindPixelBinNr;
+    fBlindPixelChargenbins = gkStartBlindPixelBinNr;
+
+    fHBlindPixelCharge = new TH1I("HBlindPixelCharge","Distribution of Summed FADC Slices",fBlindPixelChargenbins,fBlindPixelChargefirst,fBlindPixelChargelast);
+    fHBlindPixelCharge->SetXTitle("Sum FADC Slices");
+    fHBlindPixelCharge->SetYTitle("Nr. of events");
+    fHBlindPixelCharge->Sumw2();
+
+    fErrBlindPixelChargefirst = 0.;
+    fErrBlindPixelChargelast  = gkStartBlindPixelBinNr;
+    fErrBlindPixelChargenbins = gkStartBlindPixelBinNr;
+
+    fHBlindPixelErrCharge = new TH1F("HBlindPixelErrCharge","Distribution of Variances of Summed FADC Slices",
+                        fErrBlindPixelChargenbins,fErrBlindPixelChargefirst,fErrBlindPixelChargelast);
+    fHBlindPixelErrCharge->SetXTitle("Variance Summed FADC Slices");
+    fHBlindPixelErrCharge->SetYTitle("Nr. of events");
+    fHBlindPixelErrCharge->Sumw2();
 
     Axis_t tfirst = -0.5;
@@ -92 +92 @@
     Int_t nbins   = 16;
 
-    fHBlindPixelT = new TH1I("HBlindPixelT","Distribution of Mean Arrival Times",nbins,tfirst,tlast);
-    fHBlindPixelT->SetXTitle("Mean Arrival Times [FADC slice nr]");
-    fHBlindPixelT->SetYTitle("Nr. of events");
-    fHBlindPixelT->Sumw2();
+    fHBlindPixelTime = new TH1I("HBlindPixelTime","Distribution of Mean Arrival Times",nbins,tfirst,tlast);
+    fHBlindPixelTime->SetXTitle("Mean Arrival Times [FADC slice nr]");
+    fHBlindPixelTime->SetYTitle("Nr. of events");
+    fHBlindPixelTime->Sumw2();
 
     // We define a reasonable number and later enlarge it if necessary
@@ -102 +102 @@
     Axis_t nlast  = (Axis_t)nbins - 0.5;
 
-    fHBlindPixelQvsN = new TH1I("HBlindPixelQvsN","Sum of Charges vs. Event Number",nbins,nfirst,nlast);
-    fHBlindPixelQvsN->SetXTitle("Event Nr.");
-    fHBlindPixelQvsN->SetYTitle("Sum of FADC slices");
+    fHBlindPixelChargevsN = new TH1I("HBlindPixelChargevsN","Sum of Charges vs. Event Number",nbins,nfirst,nlast);
+    fHBlindPixelChargevsN->SetXTitle("Event Nr.");
+    fHBlindPixelChargevsN->SetYTitle("Sum of FADC slices");
 
     fgSinglePheFitFunc = &gfKto8;
@@ -113 +113 @@
 {
 
-  delete fHBlindPixelQ;
-  delete fHBlindPixelT;
-  delete fHBlindPixelErrQ;
+  delete fHBlindPixelCharge;
+  delete fHBlindPixelTime;
+  delete fHBlindPixelErrCharge;
   
   if (fSinglePheFit)
@@ -127 +127 @@
 void MHCalibrationBlindPixel::ResetBin(Int_t i)
 {
-    fHBlindPixelQ->SetBinContent (i, 1.e-20);
-    fHBlindPixelErrQ->SetBinContent  (i, 1.e-20);
-    fHBlindPixelT->SetBinContent(i, 1.e-20);
+    fHBlindPixelCharge->SetBinContent (i, 1.e-20);
+    fHBlindPixelErrCharge->SetBinContent  (i, 1.e-20);
+    fHBlindPixelTime->SetBinContent(i, 1.e-20);
 }
 
@@ -150 +150 @@
   fFitLegend->SetTextSize(0.05);
 
-  char line1[32];
-  sprintf(line1,"Mean: #lambda = %2.2f #pm %2.2f",GetLambda(),GetLambdaErr());
+  const TString line1 = 
+  Form("Mean: #lambda = %2.2f #pm %2.2f",GetLambda(),GetLambdaErr());
   fFitLegend->AddText(line1);
 
-  char line2[32];
-  sprintf(line2,"Pedestal: #mu_{0} = %2.2f #pm %2.2f",GetMu0(),GetMu0Err());
+  const TString line2 = 
+  Form("Pedestal: #mu_{0} = %2.2f #pm %2.2f",GetMu0(),GetMu0Err());
   fFitLegend->AddText(line2);
 
-  char line3[32];
-  sprintf(line3,"Width Pedestal: #sigma_{0} = %2.2f #pm %2.2f",GetSigma0(),GetSigma0Err());
+  const TString line3 =
+  Form("Width Pedestal: #sigma_{0} = %2.2f #pm %2.2f",GetSigma0(),GetSigma0Err());
   fFitLegend->AddText(line3);
 
-  char line4[32];
-  sprintf(line4,"1^{st} Phe-peak: #mu_{1} = %2.2f #pm %2.2f",GetMu1(),GetMu1Err());
+  const TString line4 =
+  Form("1^{st} Phe-peak: #mu_{1} = %2.2f #pm %2.2f",GetMu1(),GetMu1Err());
   fFitLegend->AddText(line4);
 
-  char line5[32];
-  sprintf(line5,"Width 1^{st} Phe-peak: #sigma_{1} = %2.2f #pm %2.2f",GetSigma1(),GetSigma1Err());
+  const TString line5 =
+  Form("Width 1^{st} Phe-peak: #sigma_{1} = %2.2f #pm %2.2f",GetSigma1(),GetSigma1Err());
   fFitLegend->AddText(line5);
 
-  char line7[32];
-  sprintf(line7,"#chi^{2} / N_{dof}: %4.2f / %3i",GetChiSquare(),GetNdf());
+  const TString line7 =
+  Form("#chi^{2} / N_{dof}: %4.2f / %3i",GetChiSquare(),GetNdf());
   fFitLegend->AddText(line7);
 
-  char line8[32];
-  sprintf(line8,"Probability: %4.2f ",GetProb());
+  const TString line8 =
+  Form("Probability: %4.2f ",GetProb());
   fFitLegend->AddText(line8);
 
@@ -209 +209 @@
     gPad->SetTicks();
 
-    fHBlindPixelQ->DrawCopy(opt);
+    fHBlindPixelCharge->DrawCopy(opt);
     
     if (fSinglePheFit)
@@ -231 +231 @@
     gPad->SetLogy(1);
     gPad->SetBorderMode(0);
-    fHBlindPixelT->DrawCopy(opt);
-
-    if (fHBlindPixelT->GetFunction("GausTime"))
+    fHBlindPixelTime->DrawCopy(opt);
+
+    if (fHBlindPixelTime->GetFunction("GausTime"))
       {
-        TF1 *tfit = fHBlindPixelT->GetFunction("GausTime");
+        TF1 *tfit = fHBlindPixelTime->GetFunction("GausTime");
         if (tfit->GetProb() < 0.01)
           tfit->SetLineColor(kRed);
@@ -248 +248 @@
     c->cd(4);
 
-    fHBlindPixelQvsN->DrawCopy(opt);
+    fHBlindPixelChargevsN->DrawCopy(opt);
 
     c->Modified();
@@ -260 +260 @@
   gRandom->SetSeed();
 
-  if (fHBlindPixelQ->GetEntries() != 0)
+  if (fHBlindPixelCharge->GetEntries() != 0)
     {
-      *fLog << err << "Histogram " << fHBlindPixelQ->GetTitle() << " is already filled. " << endl;
+      *fLog << err << "Histogram " << fHBlindPixelCharge->GetTitle() << " is already filled. " << endl;
       *fLog << err << "Create new class MHCalibrationBlindPixel for simulation! " << endl;
       return kFALSE;
@@ -268 +268 @@
   
   TF1 *simulateSinglePhe = new TF1("simulateSinglePhe",fgSinglePheFitFunc,
-                                   fBlindPixelQfirst,fBlindPixelQlast,fgSinglePheFitNPar);
+                                   fBlindPixelChargefirst,fBlindPixelChargelast,fgSinglePheFitNPar);
   
   simulateSinglePhe->SetParameters(lambda,mu0,mu1,sigma0,sigma1);
   simulateSinglePhe->SetParNames("#lambda","#mu_0","#mu_1","#sigma_0","#sigma_1");
-  simulateSinglePhe->SetNpx(fBlindPixelQnbins);  
+  simulateSinglePhe->SetNpx(fBlindPixelChargenbins);  
 
   for (Int_t i=0;i<10000; i++) 
     {
-      fHBlindPixelQ->Fill(simulateSinglePhe->GetRandom());
+      fHBlindPixelCharge->Fill(simulateSinglePhe->GetRandom());
     }
   
@@ -303 +303 @@
   // Get the fitting ranges
   //
-  rmin = (rmin != 0.) ? rmin : fBlindPixelQfirst;
-  rmax = (rmax != 0.) ? rmax : fBlindPixelQlast;
+  rmin = (rmin != 0.) ? rmin : fBlindPixelChargefirst;
+  rmax = (rmax != 0.) ? rmax : fBlindPixelChargelast;
 
   //
@@ -310 +310 @@
   // otherwise the fit goes gaga because of high number of dimensions ...
   //
-  const Stat_t   entries      = fHBlindPixelQ->GetSumOfWeights();
+  const Stat_t   entries      = fHBlindPixelCharge->GetSumOfWeights();
   const Double_t lambda_guess = 0.2;
-  const Double_t mu_0_guess = fHBlindPixelQ->GetBinCenter(fHBlindPixelQ->GetMaximumBin());
+  const Double_t mu_0_guess = fHBlindPixelCharge->GetBinCenter(fHBlindPixelCharge->GetMaximumBin());
   const Double_t si_0_guess = mu_0_guess/10.;
   const Double_t mu_1_guess = mu_0_guess + 50.;
@@ -333 +333 @@
   // ROOT gives us another nice example of user-unfriendly behavior:
   // Although the normalization of the function fSinglePhe and the 
-  // Histogram fHBlindPixelQ agree (!!), the fit does not normalize correctly INTERNALLY
+  // Histogram fHBlindPixelCharge agree (!!), the fit does not normalize correctly INTERNALLY
   // in the fitting procedure !!!
   // 
@@ -343 +343 @@
   //
   //  const Int_t  npx     = fSinglePheFit->GetNpx();
-  //  const Int_t  bins    = fHBlindPixelQ->GetXaxis()->GetLast()-fHBlindPixelQ->GetXaxis()->GetFirst();
-  //  fHBlindPixelQ->Scale(gkSq2Pi*(float)bins/npx/entries);
+  //  const Int_t  bins    = fHBlindPixelCharge->GetXaxis()->GetLast()-fHBlindPixelCharge->GetXaxis()->GetFirst();
+  //  fHBlindPixelCharge->Scale(gkSq2Pi*(float)bins/npx/entries);
 
   // 
@@ -351 +351 @@
   // mysteries of ROOT which takes you a whole day to find out :-)
   //
-  //  fSinglePheFit->SetNpx(fQnbins);  
-
-  fHBlindPixelQ->Fit(fSinglePheFit,opt);
+  //  fSinglePheFit->SetNpx(fChargenbins);  
+
+  fHBlindPixelCharge->Fit(fSinglePheFit,opt);
 
   fLambda = fSinglePheFit->GetParameter(0);
@@ -405 +405 @@
   Int_t nbins = 50;
 
-  *fLog << "New number of bins in HSinQ: " << CutEdges(fHBlindPixelQ,nbins) << endl;
-
-  fBlindPixelQfirst = fHBlindPixelQ->GetBinLowEdge(fHBlindPixelQ->GetXaxis()->GetFirst());
-  fBlindPixelQlast  = fHBlindPixelQ->GetBinLowEdge(fHBlindPixelQ->GetXaxis()->GetLast())+fHBlindPixelQ->GetBinWidth(0);
-  fBlindPixelQnbins = nbins;
-
-  *fLog << "New number of bins in HErrQ: " << CutEdges(fHBlindPixelErrQ,30) << endl;
-  fErrBlindPixelQfirst = fHBlindPixelErrQ->GetBinLowEdge(fHBlindPixelErrQ->GetXaxis()->GetFirst());
-  fErrBlindPixelQlast  = fHBlindPixelErrQ->GetBinLowEdge(fHBlindPixelErrQ->GetXaxis()->GetLast())+fHBlindPixelErrQ->GetBinWidth(0);
-  fErrBlindPixelQnbins = nbins;
-
-  CutEdges(fHBlindPixelQvsN,0);
-
-}
-
-Bool_t MHCalibrationBlindPixel::FitT(Axis_t rmin, Axis_t rmax, Option_t *opt) 
+  *fLog << "New number of bins in HSinCharge: " << CutEdges(fHBlindPixelCharge,nbins) << endl;
+
+  fBlindPixelChargefirst = fHBlindPixelCharge->GetBinLowEdge(fHBlindPixelCharge->GetXaxis()->GetFirst());
+  fBlindPixelChargelast  = fHBlindPixelCharge->GetBinLowEdge(fHBlindPixelCharge->GetXaxis()->GetLast())+fHBlindPixelCharge->GetBinWidth(0);
+  fBlindPixelChargenbins = nbins;
+
+  *fLog << "New number of bins in HErrCharge: " << CutEdges(fHBlindPixelErrCharge,30) << endl;
+  fErrBlindPixelChargefirst = fHBlindPixelErrCharge->GetBinLowEdge(fHBlindPixelErrCharge->GetXaxis()->GetFirst());
+  fErrBlindPixelChargelast  = fHBlindPixelErrCharge->GetBinLowEdge(fHBlindPixelErrCharge->GetXaxis()->GetLast())+fHBlindPixelErrCharge->GetBinWidth(0);
+  fErrBlindPixelChargenbins = nbins;
+
+  CutEdges(fHBlindPixelChargevsN,0);
+
+}
+
+Bool_t MHCalibrationBlindPixel::FitTime(Axis_t rmin, Axis_t rmax, Option_t *opt) 
 {
   
@@ -429 +429 @@
   rmax = (rmax != 0.) ? rmax : 9.;
 
-  const Stat_t   entries     = fHBlindPixelT->GetEntries();
-  const Double_t mu_guess    = fHBlindPixelT->GetBinCenter(fHBlindPixelT->GetMaximumBin());
+  const Stat_t   entries     = fHBlindPixelTime->GetEntries();
+  const Double_t mu_guess    = fHBlindPixelTime->GetBinCenter(fHBlindPixelTime->GetMaximumBin());
   const Double_t sigma_guess = (rmax - rmin)/2.;
   const Double_t area_guess  = entries/gkSq2Pi;
@@ -441 +441 @@
   fTimeGausFit->SetParLimits(2,0.,rmax-rmin);
 
-  fHBlindPixelT->Fit(fTimeGausFit,opt);
+  fHBlindPixelTime->Fit(fTimeGausFit,opt);
 
   rmin = fTimeGausFit->GetParameter(1) - 2.*fTimeGausFit->GetParameter(2);
@@ -447 +447 @@
   fTimeGausFit->SetRange(rmin,rmax);  
 
-  fHBlindPixelT->Fit(fTimeGausFit,opt);
-
-
-  fMeanT     = fTimeGausFit->GetParameter(2);
-  fSigmaT    = fTimeGausFit->GetParameter(3);
-  fMeanTErr  = fTimeGausFit->GetParError(2);
-  fSigmaTErr = fTimeGausFit->GetParError(3);
+  fHBlindPixelTime->Fit(fTimeGausFit,opt);
+
+
+  fMeanTime     = fTimeGausFit->GetParameter(2);
+  fSigmaTime    = fTimeGausFit->GetParameter(3);
+  fMeanTimeErr  = fTimeGausFit->GetParError(2);
+  fSigmaTimeErr = fTimeGausFit->GetParError(3);
 
   Float_t prob = fTimeGausFit->GetProb();

trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.h

@@ -32 +32 @@
 private:
 
-  TH1I* fHBlindPixelQ;        //-> Histogram with the single Phe spectrum
-  TH1F* fHBlindPixelErrQ;     //-> Variance of summed FADC slices
-  TH1I* fHBlindPixelT;        //-> Variance of summed FADC slices
-  TH1I* fHBlindPixelQvsN;     //-> Summed Charge vs. Event Nr. 
+  TH1I* fHBlindPixelCharge;        //-> Histogram with the single Phe spectrum
+  TH1F* fHBlindPixelErrCharge;     //-> Variance of summed FADC slices
+  TH1I* fHBlindPixelTime;        //-> Variance of summed FADC slices
+  TH1I* fHBlindPixelChargevsN;     //-> Summed Charge vs. Event Nr. 
   
   TF1 *fSinglePheFit;
   TF1 *fTimeGausFit;  
 
-  Axis_t  fBlindPixelQfirst;
-  Axis_t  fBlindPixelQlast;
-  Int_t   fBlindPixelQnbins;
+  Axis_t  fBlindPixelChargefirst;
+  Axis_t  fBlindPixelChargelast;
+  Int_t   fBlindPixelChargenbins;
   
-  Axis_t fErrBlindPixelQfirst;
-  Axis_t fErrBlindPixelQlast;
-  Int_t  fErrBlindPixelQnbins;
+  Axis_t fErrBlindPixelChargefirst;
+  Axis_t fErrBlindPixelChargelast;
+  Int_t  fErrBlindPixelChargenbins;
 
   void ResetBin(Int_t i);
@@ -73 +73 @@
   Int_t     fNdf;       
 
-  Double_t  fMeanT; 
-  Double_t  fMeanTErr; 
-  Double_t  fSigmaT; 
-  Double_t  fSigmaTErr; 
+  Double_t  fMeanTime; 
+  Double_t  fMeanTimeErr; 
+  Double_t  fSigmaTime; 
+  Double_t  fSigmaTimeErr; 
   
 public:
@@ -83 +83 @@
   ~MHCalibrationBlindPixel();
 
-  Bool_t FillBlindPixelQ(Int_t q)         { return fHBlindPixelQ->Fill(q) > -1;  }  
-  Bool_t FillErrBlindPixelQ(Float_t errq) { return fHBlindPixelErrQ->Fill(errq) > -1; }
-  Bool_t FillBlindPixelT(Int_t t)         { return fHBlindPixelT->Fill(t) > -1;  }
-  Bool_t FillBlindPixelQvsN(Stat_t rq, Int_t t) { return fHBlindPixelQvsN->Fill(t,rq) > -1;  }  
+  Bool_t FillBlindPixelCharge(Int_t q)         { return fHBlindPixelCharge->Fill(q) > -1;  }  
+  Bool_t FillErrBlindPixelCharge(Float_t errq) { return fHBlindPixelErrCharge->Fill(errq) > -1; }
+  Bool_t FillBlindPixelTime(Int_t t)         { return fHBlindPixelTime->Fill(t) > -1;  }
+  Bool_t FillBlindPixelChargevsN(Stat_t rq, Int_t t) { return fHBlindPixelChargevsN->Fill(t,rq) > -1;  }  
   
   const Double_t GetLambda()   const { return fLambda; }
@@ -104 +104 @@
   const Int_t    GetNdf()     const { return fNdf;       }   
 
-  const Double_t GetMeanT()      const { return fMeanT; }
-  const Double_t GetMeanTErr()    const { return fMeanTErr; }
-  const Double_t GetSigmaT()      const { return fSigmaT; }
-  const Double_t GetSigmaTErr()    const { return fSigmaTErr; }
+  const Double_t GetMeanTime()      const { return fMeanTime; }
+  const Double_t GetMeanTimeErr()    const { return fMeanTimeErr; }
+  const Double_t GetSigmaTime()      const { return fSigmaTime; }
+  const Double_t GetSigmaTimeErr()    const { return fSigmaTimeErr; }
 
-  const TH1F *GetHErrQ() { return fHBlindPixelErrQ; }
-  const TH1F *GetHErrQ() const { return fHBlindPixelErrQ; }
+  const TH1F *GetHErrCharge() { return fHBlindPixelErrCharge; }
+  const TH1F *GetHErrCharge() const { return fHBlindPixelErrCharge; }
   
   Bool_t SimulateSinglePhe(Double_t lambda,
@@ -119 +119 @@
   
   Bool_t FitSinglePhe(Axis_t rmin=0, Axis_t rmax=0, Option_t *opt="R0+");
-  Bool_t FitT(Axis_t rmin=0., Axis_t rmax=0.,Option_t *opt="R0+");
+  Bool_t FitTime(Axis_t rmin=0., Axis_t rmax=0.,Option_t *opt="R0+");
 
   void ChangeFitFunc(BlindPixelFitFunc fitfunc, Int_t par=5);

trunk/MagicSoft/Mars/mhist/MHCalibrationConfig.h

@@ -20 +20 @@
 const Int_t gkStartPINDiodeBinNr = 4000;
 
-// Starting number of bins for the histo: (maximum possible by hardware = 40800)
-const Int_t gkStartPixelBinNr = 20000;
-
-// Starting number for the highest value of the Q-histo:
-const Axis_t gkStartQlast      = 10000.;
-
 // Square root of 2 pi:
 const Float_t gkSq2Pi = 2.506628274631;

trunk/MagicSoft/Mars/mhist/MHCalibrationPINDiode.cc

@@ -67 +67 @@
 
     // Create a large number of bins, later we will rebin
-    fQfirst = 0;
-    fQlast  = gkStartPINDiodeBinNr;
-    fQnbins = gkStartPINDiodeBinNr;
+    fChargeFirst = 0;
+    fChargeLast  = gkStartPINDiodeBinNr;
+    fChargeNbins = gkStartPINDiodeBinNr;
 
-    fHPQ = new TH1I("HPQ","Distribution of Summed FADC Slices",fQnbins,fQfirst,fQlast);
-    fHPQ->SetXTitle("Sum FADC Slices");
-    fHPQ->SetYTitle("Nr. of events");
-    fHPQ->Sumw2();
+    fHPCharge = new TH1I("HPCharge","Distribution of Summed FADC Slices",fChargeNbins,fChargeFirst,fChargeLast);
+    fHPCharge->SetXTitle("Sum FADC Slices");
+    fHPCharge->SetYTitle("Nr. of events");
+    fHPCharge->Sumw2();
 
-    fErrQfirst = 0.;
-    fErrQlast  = gkStartPINDiodeBinNr;
-    fErrQnbins = gkStartPINDiodeBinNr;
+    fErrChargeFirst = 0.;
+    fErrChargeLast  = gkStartPINDiodeBinNr;
+    fErrChargeNbins = gkStartPINDiodeBinNr;
 
-    fHErrQ = new TH1F("HErrQ","Distribution of Variances of Summed FADC Slices",fErrQnbins,fErrQfirst,fErrQlast);
-    fHErrQ->SetXTitle("Variance Summed FADC Slices");
-    fHErrQ->SetYTitle("Nr. of events");
-    fHErrQ->Sumw2();
+    fHErrCharge = new TH1F("HErrCharge","Distribution of Variances of Summed FADC Slices",fErrChargeNbins,fErrChargeFirst,fErrChargeLast);
+    fHErrCharge->SetXTitle("Variance Summed FADC Slices");
+    fHErrCharge->SetYTitle("Nr. of events");
+    fHErrCharge->Sumw2();
 
     Int_t tfirst = 0;
@@ -89 +89 @@
     Int_t nbins   = 32;
 
-    fHPT = new TH1I("HPT","Distribution of Mean Arrival Times",nbins,tfirst,tlast);
-    fHPT->SetXTitle("Mean Arrival Times [FADC slice nr]");
-    fHPT->SetYTitle("Nr. of events");
-    fHPT->Sumw2();
+    fHPTime = new TH1I("HPTime","Distribution of Mean Arrival Times",nbins,tfirst,tlast);
+    fHPTime->SetXTitle("Mean Arrival Times [FADC slice nr]");
+    fHPTime->SetYTitle("Nr. of events");
+    fHPTime->Sumw2();
 
 }
@@ -99 +99 @@
 {
 
-  delete fHPQ;
-  delete fHErrQ;
+  delete fHPCharge;
+  delete fHErrCharge;
   
   if (fVarGausFit)
     delete fVarGausFit;
   
-  delete fHPT;
+  delete fHPTime;
 
 }

trunk/MagicSoft/Mars/mhist/MHCalibrationPINDiode.h

@@ -26 +26 @@
 private:
 
-  TH1I* fHPQ;             //-> Histogram containing the summed 32 PINDiode slices
-  TH1F* fHErrQ;           //-> Variance of summed FADC slices
-  TH1I* fHPT;             //-> Histogram with time evolution of summed charges
+  TH1I* fHPCharge;             //-> Histogram containing the summed 32 PINDiode slices
+  TH1F* fHErrCharge;           //-> Variance of summed FADC slices
+  TH1I* fHPTime;             //-> Histogram with time evolution of summed charges
   
   
   TF1 *fVarGausFit;
   
-  Float_t  fErrQfirst;
-  Float_t  fErrQlast;
-  UShort_t fErrQnbins;
+  Float_t  fErrChargeFirst;
+  Float_t  fErrChargeLast;
+  UShort_t fErrChargeNbins;
 
 public:
@@ -42 +42 @@
   ~MHCalibrationPINDiode();
 
-  const Double_t GetT()      const { return fVarGausFit->GetParameter(2); }
-  const Double_t GetErrT()    const { return fVarGausFit->GetParameter(3); }
+  const Double_t GetTime()      const { return fVarGausFit->GetParameter(2); }
+  const Double_t GetErrTime()    const { return fVarGausFit->GetParameter(3); }
 
   ClassDef(MHCalibrationPINDiode, 0) 

trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.cc

@@ -62 +62 @@
 MHCalibrationPixel::MHCalibrationPixel(const char *name, const char *title)
       : fPixId(-1),
-        fQGausFit(NULL), 
-        fTGausFit(NULL), 
+        fChargeGausFit(NULL), 
+        fTimeGausFit(NULL), 
         fFitLegend(NULL),
         fLowerFitRange(0.),
         fFitOK(kFALSE),
-        fQChisquare(-1.),
-        fQProb(-1.),
-        fQNdf(-1),
-        fTChisquare(-1.),
-        fTProb(-1.),
-        fTNdf(-1)
+        fChargeChisquare(-1.),
+        fChargeProb(-1.),
+        fChargeNdf(-1),
+        fTimeChisquare(-1.),
+        fTimeProb(-1.),
+        fTimeNdf(-1)
 { 
 
@@ -78 +78 @@
     fTitle = title ? title : "Fill the accumulated charges and times of all events and perform fits";
 
-    TString qtitle = "Distribution of Summed FADC Slices Pixel ";
-
     // Create a large number of bins, later we will rebin
-    fQfirst = -0.5;
-    fQlast  = gkStartQlast - 0.5;
-    fQnbins = gkStartPixelBinNr;
-
-    fHQ = new TH1I("HQ",qtitle.Data(),
-                   fQnbins,fQfirst,fQlast);
-    fHQ->SetXTitle("Sum FADC Slices");
-    fHQ->SetYTitle("Nr. of events");
-    fHQ->Sumw2();
-
-    fHQ->SetDirectory(NULL);
-
-    TString ttitle = "Distribution of Mean Arrival Times Pixel ";
+    fChargeFirst = -0.5;
+    fChargeLast  = 10000. - 0.5;
+    fChargeNbins = 20000;
+
+    fHCharge = new TH1I("HCharge","Distribution of Summed FADC Slices Pixel ",
+                   fChargeNbins,fChargeFirst,fChargeLast);
+    fHCharge->SetXTitle("Sum FADC Slices");
+    fHCharge->SetYTitle("Nr. of events");
+    fHCharge->Sumw2();
+
+    fHCharge->SetDirectory(NULL);
 
     Axis_t tfirst = -0.5;
     Axis_t tlast  = 15.5;
-    Int_t nbins   = 16;
-
-    fHT = new TH1I("HT",ttitle.Data(),
-                  nbins,tfirst,tlast);
-    fHT->SetXTitle("Mean Arrival Times [FADC slice nr]");
-    fHT->SetYTitle("Nr. of events");
-    fHT->Sumw2();
-
-    fHT->SetDirectory(NULL);
+    Int_t  ntbins = 16;
+
+    fHTime = new TH1I("HTime","Distribution of Mean Arrival Times Pixel ",
+                  ntbins,tfirst,tlast);
+    fHTime->SetXTitle("Mean Arrival Times [FADC slice nr]");
+    fHTime->SetYTitle("Nr. of events");
+    fHTime->Sumw2();
+
+    fHTime->SetDirectory(NULL);
 
     TString qvsntitle = "Sum of Charges vs. Event Number Pixel ";
 
     // We define a reasonable number and later enlarge it if necessary
-    nbins = 20000;
+    Int_t  nqbins = 20000;
     Axis_t nfirst = -0.5;
-    Axis_t nlast  = (Axis_t)nbins - 0.5;
-
-    fHQvsN = new TH1I("HQvsN",qvsntitle.Data(),
-                     nbins,nfirst,nlast);
-    fHQvsN->SetXTitle("Event Nr.");
-    fHQvsN->SetYTitle("Sum of FADC slices");
-
-    fHQvsN->SetDirectory(NULL);
+    Axis_t nlast  = (Axis_t)nqbins - 0.5;
+
+    fHChargevsN = new TH1I("HChargevsN",qvsntitle.Data(),
+                     nqbins,nfirst,nlast);
+    fHChargevsN->SetXTitle("Event Nr.");
+    fHChargevsN->SetYTitle("Sum of FADC slices");
+
+    fHChargevsN->SetDirectory(NULL);
 
 }
@@ -126 +122 @@
 {
 
-  delete fHQ;
-  delete fHT;
-  delete fHQvsN;
-
-  if (fQGausFit)
-    delete fQGausFit;
-  if (fTGausFit)
-    delete fTGausFit;
+  delete fHCharge;
+  delete fHTime;
+  delete fHChargevsN;
+
+  if (fChargeGausFit)
+    delete fChargeGausFit;
+  if (fTimeGausFit)
+    delete fTimeGausFit;
   if (fFitLegend)
     delete fFitLegend;
@@ -145 +141 @@
   fPixId = id;
   
-  TString nameQ = TString(fHQ->GetName());
+  TString nameQ = TString(fHCharge->GetName());
   nameQ += id;
-  fHQ->SetName(nameQ.Data());
-
-  TString nameT = TString(fHT->GetName());
+  fHCharge->SetName(nameQ.Data());
+
+  TString nameT = TString(fHTime->GetName());
   nameT += id;
-  fHT->SetName(nameT.Data());
-
-  TString nameQvsN  = TString(fHQvsN->GetName());
+  fHTime->SetName(nameT.Data());
+
+  TString nameQvsN  = TString(fHChargevsN->GetName());
   nameQvsN += id;
-  fHQvsN->SetName(nameQvsN.Data());
+  fHChargevsN->SetName(nameQvsN.Data());
+
+  TString titleQ = TString(fHCharge->GetTitle());
+  titleQ += id;
+  fHCharge->SetTitle(titleQ.Data());
+
+  TString titleT = TString(fHTime->GetTitle());
+  titleT += id;
+  fHTime->SetTitle(titleT.Data());
+
+  TString titleQvsN  = TString(fHChargevsN->GetTitle());
+  titleQvsN += id;
+  fHChargevsN->SetTitle(titleQvsN.Data());
 }
 
@@ -162 +170 @@
 {
   
-  for (Int_t i = fHQ->FindBin(fQfirst); i <= fHQ->FindBin(fQlast); i++)
-      fHQ->SetBinContent(i, 1.e-20);
+  for (Int_t i = fHCharge->FindBin(fChargeFirst); 
+       i <= fHCharge->FindBin(fChargeLast); i++)
+    fHCharge->SetBinContent(i, 1.e-20);
 
   for (Int_t i = 0; i < 16; i++)
-      fHT->SetBinContent(i, 1.e-20);
-  
-  fQlast     = gkStartQlast;
-
-  fHQ->GetXaxis()->SetRangeUser(0.,fQlast);
+      fHTime->SetBinContent(i, 1.e-20);
+  
+  fChargeLast     = 9999.5;
+
+  fHCharge->GetXaxis()->SetRangeUser(0.,fChargeLast);
 
   return;
@@ -183 +192 @@
 {
 
-  fHQ->Reset();
-  fHT->Reset();
+  fHCharge->Reset();
+  fHTime->Reset();
 
   return kTRUE;
@@ -208 +217 @@
   fFitLegend->SetTextSize(0.05);
 
-  char line1[32];
-  sprintf(line1,"Mean: Q_{#mu} = %2.2f #pm %2.2f",fQMean,fQMeanErr);
+  const TString line1 = 
+    Form("Mean: Q_{#mu} = %2.2f #pm %2.2f",fChargeMean,fChargeMeanErr);
+
   fFitLegend->AddText(line1);
 
-  char line4[32];
-  sprintf(line4,"Sigma: #sigma_{Q} = %2.2f #pm %2.2f",fQSigma,fQSigmaErr);
+
+  const TString line4 =
+    Form("Sigma: #sigma_{Q} = %2.2f #pm %2.2f",fChargeSigma,fChargeSigmaErr);
+
   fFitLegend->AddText(line4);
 
-  char line7[32];
-  sprintf(line7,"#chi^{2} / N_{dof}: %4.2f / %3i",fQChisquare,fQNdf);
+
+  const TString line7 =
+    Form("#chi^{2} / N_{dof}: %4.2f / %3i",fChargeChisquare,fChargeNdf);
+
   fFitLegend->AddText(line7);
 
-  char line8[32];
-  sprintf(line8,"Probability: %4.3f ",fQProb);
+
+  const TString line8 =
+    Form("Probability: %4.3f ",fChargeProb);
+
   fFitLegend->AddText(line8);
+
 
   if (fFitOK)
@@ -256 +273 @@
     gPad->SetTicks();
 
-    fHQ->DrawCopy(opt);
+    fHCharge->Draw(opt);
     
-    if (fQGausFit)
+    if (fChargeGausFit)
       {
         if (fFitOK)
-          fQGausFit->SetLineColor(kGreen);          
+          fChargeGausFit->SetLineColor(kGreen);          
         else
-          fQGausFit->SetLineColor(kRed);
-
-        fQGausFit->DrawCopy("same");
+          fChargeGausFit->SetLineColor(kRed);
+
+        fChargeGausFit->Draw("same");
         c->Modified();
         c->Update();
@@ -279 +296 @@
 
     gPad->SetLogy(1);
-    fHT->DrawCopy(opt);
-
-    if (fTGausFit)
+    fHTime->Draw(opt);
+
+    if (fTimeGausFit)
       {
-        if (fTChisquare > 1.)
-          fTGausFit->SetLineColor(kRed);
+        if (fTimeChisquare > 1.)
+          fTimeGausFit->SetLineColor(kRed);
         else
-          fTGausFit->SetLineColor(kGreen);
-
-        fTGausFit->DrawCopy("same");
+          fTimeGausFit->SetLineColor(kGreen);
+
+        fTimeGausFit->Draw("same");
         c->Modified();
         c->Update();
@@ -297 +314 @@
 
     c->cd(4);
-    fHQvsN->DrawCopy(opt);
-}
-
-
-
-Bool_t MHCalibrationPixel::FitT(Axis_t rmin, Axis_t rmax, Option_t *option)
-{
-
-  if (fTGausFit)
+    fHChargevsN->Draw(opt);
+}
+
+
+
+Bool_t MHCalibrationPixel::FitTime(Axis_t rmin, Axis_t rmax, Option_t *option)
+{
+
+  if (fTimeGausFit)
     return kFALSE;
 
@@ -311 +328 @@
   rmax = (rmax != 0.) ? rmax : 9.;
 
-  const Stat_t   entries     = fHT->GetEntries();
-  const Double_t mu_guess    = fHT->GetBinCenter(fHT->GetMaximumBin());
+  const Stat_t   entries     = fHTime->GetEntries();
+  const Double_t mu_guess    = fHTime->GetBinCenter(fHTime->GetMaximumBin());
   const Double_t sigma_guess = (rmax - rmin)/2.;
   const Double_t area_guess  = entries/gkSq2Pi;
@@ -318 +335 @@
   TString name = TString("GausTime");
   name += fPixId;
-  fTGausFit = new TF1(name.Data(),"gaus",rmin,rmax);  
-
-  if (!fTGausFit) 
+  fTimeGausFit = new TF1(name.Data(),"gaus",rmin,rmax);  
+
+  if (!fTimeGausFit) 
     {
     *fLog << err << dbginf << "Could not create fit function for Gauss fit" << endl;
@@ -326 +343 @@
     }
 
-  fTGausFit->SetParameters(area_guess,mu_guess,sigma_guess);
-  fTGausFit->SetParNames("Area","#mu","#sigma");
-  fTGausFit->SetParLimits(0,0.,entries);
-  fTGausFit->SetParLimits(1,rmin,rmax);
-  fTGausFit->SetParLimits(2,0.,(rmax-rmin)/2.);
-  fTGausFit->SetRange(rmin,rmax);
-
-  fHT->Fit(fTGausFit,option);
-
-  rmin = fTGausFit->GetParameter(1) - 3.*fTGausFit->GetParameter(2);
-  rmax = fTGausFit->GetParameter(1) + 3.*fTGausFit->GetParameter(2);
-  fTGausFit->SetRange(rmin,rmax);  
-
-  fHT->Fit(fTGausFit,option);
-
-  fTChisquare = fTGausFit->GetChisquare();
-  fTNdf       = fTGausFit->GetNDF();
-  fTProb      = fTGausFit->GetProb();
-  fTMean      = fTGausFit->GetParameter(1);
-  fTSigma     = fTGausFit->GetParameter(2);
-
-  if (fTChisquare > 1.) 
+  fTimeGausFit->SetParameters(area_guess,mu_guess,sigma_guess);
+  fTimeGausFit->SetParNames("Area","#mu","#sigma");
+  fTimeGausFit->SetParLimits(0,0.,entries);
+  fTimeGausFit->SetParLimits(1,rmin,rmax);
+  fTimeGausFit->SetParLimits(2,0.,(rmax-rmin));
+  fTimeGausFit->SetRange(rmin,rmax);
+
+  fHTime->Fit(fTimeGausFit,option);
+
+  rmin = fTimeGausFit->GetParameter(1) - 3.*fTimeGausFit->GetParameter(2);
+  rmax = fTimeGausFit->GetParameter(1) + 3.*fTimeGausFit->GetParameter(2);
+  fTimeGausFit->SetRange(rmin,rmax);  
+
+  fHTime->Fit(fTimeGausFit,option);
+
+  fTimeChisquare = fTimeGausFit->GetChisquare();
+  fTimeNdf       = fTimeGausFit->GetNDF();
+  fTimeProb      = fTimeGausFit->GetProb();
+
+  fTimeMean      = fTimeGausFit->GetParameter(1);
+  fTimeSigma     = fTimeGausFit->GetParameter(2);
+
+  if (fTimeChisquare > 1.) 
     {
       *fLog << warn << "Fit of the Arrival times failed ! " << endl;
@@ -357 +375 @@
 }
 
-Bool_t MHCalibrationPixel::FitQ(Option_t *option)
-{
-
-  if (fQGausFit)
+Bool_t MHCalibrationPixel::FitCharge(Option_t *option)
+{
+
+  if (fChargeGausFit)
     return kFALSE;
 
@@ -366 +384 @@
   // Get the fitting ranges
   //
-  Axis_t rmin = (fLowerFitRange != 0.) ? fLowerFitRange : fQfirst;
+  Axis_t rmin = (fLowerFitRange != 0.) ? fLowerFitRange : fChargeFirst;
   Axis_t rmax = 0.;
 
@@ -373 +391 @@
   // otherwise the fit goes gaga because of high number of dimensions ...
   //
-  const Stat_t   entries  = fHQ->GetEntries();
-  const Double_t ar_guess = entries/gkSq2Pi;
-  const Double_t mu_guess = fHQ->GetBinCenter(fHQ->GetMaximumBin());
-  const Double_t si_guess = mu_guess/50.;
-
-  TString name = TString("QGausFit");
+  const Stat_t   entries    = fHCharge->GetEntries();
+  const Double_t area_guess = entries/gkSq2Pi;
+  const Double_t mu_guess   = fHCharge->GetBinCenter(fHCharge->GetMaximumBin());
+  const Double_t sigma_guess = mu_guess/15.;
+
+  TString name = TString("ChargeGausFit");
   name += fPixId;
 
-  fQGausFit = new TF1(name.Data(),"gaus",rmin,fQlast);
-
-  if (!fQGausFit) 
+  fChargeGausFit = new TF1(name.Data(),"gaus",rmin,fChargeLast);
+
+  if (!fChargeGausFit) 
     {
     *fLog << err << dbginf << "Could not create fit function for Gauss fit" << endl;
@@ -389 +407 @@
     }
   
-  fQGausFit->SetParameters(ar_guess,mu_guess,si_guess);
-  fQGausFit->SetParNames("Area","#mu","#sigma");
-  fQGausFit->SetParLimits(0,0.,entries);
-  fQGausFit->SetParLimits(1,rmin,fQlast);
-  fQGausFit->SetParLimits(2,0.,fQlast-rmin);
-  fQGausFit->SetRange(rmin,fQlast);
-  fQGausFit->Update();
-
-  fHQ->Fit(fQGausFit,option);
-  
-  rmin = fQGausFit->GetParameter(1) - 3.*fQGausFit->GetParameter(2);
-  rmax = fQGausFit->GetParameter(1) + 3.*fQGausFit->GetParameter(2);
-
-  fQGausFit->SetRange(rmin,rmax);  
-  fHQ->Fit(fQGausFit,option);
-
-  rmin = fQGausFit->GetParameter(1) - 3.5*fQGausFit->GetParameter(2);
-  rmax = fQGausFit->GetParameter(1) + 3.5*fQGausFit->GetParameter(2);
-
-  fQGausFit->SetRange(rmin,rmax);  
-  fHQ->Fit(fQGausFit,option);
-
-  fQChisquare = fQGausFit->GetChisquare();
-  fQNdf       = fQGausFit->GetNDF();
-  fQProb      = fQGausFit->GetProb();
-  fQMean      = fQGausFit->GetParameter(1);
-  fQMeanErr   = fQGausFit->GetParError(1);
-  fQSigma     = fQGausFit->GetParameter(2);
-  fQSigmaErr  = fQGausFit->GetParError(2);
+  fChargeGausFit->SetParameters(area_guess,mu_guess,sigma_guess);
+  fChargeGausFit->SetParNames("Area","#mu","#sigma");
+  fChargeGausFit->SetParLimits(0,0.,entries);
+  fChargeGausFit->SetParLimits(1,rmin,fChargeLast);
+  fChargeGausFit->SetParLimits(2,0.,fChargeLast-rmin);
+  fChargeGausFit->SetRange(rmin,fChargeLast);
+
+  fHCharge->Fit(fChargeGausFit,option);
+  
+  Axis_t rtry = fChargeGausFit->GetParameter(1) - 2.5*fChargeGausFit->GetParameter(2);
+  
+  rmin = (rtry < rmin ? rmin : rtry);
+  rmax = fChargeGausFit->GetParameter(1) + 2.5*fChargeGausFit->GetParameter(2);
+  fChargeGausFit->SetRange(rmin,rmax);  
+
+  fHCharge->Fit(fChargeGausFit,option);
+
+  //  rmin = fChargeGausFit->GetParameter(1) - 2.5*fChargeGausFit->GetParameter(2);
+  //  rmax = fChargeGausFit->GetParameter(1) + 2.5*fChargeGausFit->GetParameter(2);
+  //  fChargeGausFit->SetRange(rmin,rmax);  
+
+  // fHCharge->Fit(fChargeGausFit,option);
+
+  fChargeChisquare = fChargeGausFit->GetChisquare();
+  fChargeNdf       = fChargeGausFit->GetNDF();
+  fChargeProb      = fChargeGausFit->GetProb();
+  fChargeMean      = fChargeGausFit->GetParameter(1);
+  fChargeMeanErr   = fChargeGausFit->GetParError(1);
+  fChargeSigma     = fChargeGausFit->GetParameter(2);
+  fChargeSigmaErr  = fChargeGausFit->GetParError(2);
 
   //
@@ -423 +442 @@
   // The Probability is greater than gkProbLimit (default 0.01 == 99%)
   //
-  if (fQProb < gkProbLimit) 
+  if (fChargeProb < gkProbLimit) 
     {
-      *fLog << warn << "Prob: " << fQProb << " is smaller than the allowed value: " << gkProbLimit << endl;
+      *fLog << warn << "Prob: " << fChargeProb << " is smaller than the allowed value: " << gkProbLimit << endl;
       fFitOK = kFALSE;
       return kFALSE;
@@ -442 +461 @@
   Int_t nbins = 50;
 
-  CutEdges(fHQ,nbins);
-
-  fQfirst = fHQ->GetBinLowEdge(fHQ->GetXaxis()->GetFirst());
-  fQlast  = fHQ->GetBinLowEdge(fHQ->GetXaxis()->GetLast())+fHQ->GetBinWidth(0);
-  fQnbins = nbins;
-
-  CutEdges(fHQvsN,0);
-
-}
-
-void MHCalibrationPixel::PrintQFitResult()
-{
-  
-  *fLog << "Results of the Summed Charges Fit: "                 << endl;
-  *fLog << "Chisquare: "        << fQChisquare                   << endl;
-  *fLog << "DoF: "              << fQNdf                         << endl;
-  *fLog << "Probability: "      << fQProb                        << endl;
-  *fLog                                                          << endl;
-  
-}
-
-void MHCalibrationPixel::PrintTFitResult()
-{
-
-  *fLog << "Results of the Arrival Time Slices Fit: "             << endl;
-  *fLog << "Chisquare: "   << fTChisquare                         << endl;
-  *fLog << "Ndf: "         << fTNdf                               << endl;
-  *fLog << "Probability: " << fTProb                              << endl;
-  *fLog                                                           << endl;
-
-}
+  CutEdges(fHCharge,nbins);
+
+  fChargeFirst = fHCharge->GetBinLowEdge(fHCharge->GetXaxis()->GetFirst());
+  fChargeLast  = fHCharge->GetBinLowEdge(fHCharge->GetXaxis()->GetLast())+fHCharge->GetBinWidth(0);
+  fChargeNbins = nbins;
+
+  CutEdges(fHChargevsN,0);
+
+}
+
+void MHCalibrationPixel::PrintChargeFitResult()
+{
+  
+  *fLog << "Results of the Summed Charges Fit: "                      << endl;
+  *fLog << "Chisquare: "        << fChargeChisquare                   << endl;
+  *fLog << "DoF: "              << fChargeNdf                         << endl;
+  *fLog << "Probability: "      << fChargeProb                        << endl;
+  *fLog                                                               << endl;
+  
+}
+
+void MHCalibrationPixel::PrintTimeFitResult()
+{
+
+  *fLog << "Results of the Time Slices Fit: "                        << endl;
+  *fLog << "Chisquare: "   << fTimeChisquare                         << endl;
+  *fLog << "Ndf: "         << fTimeNdf                               << endl;
+  *fLog << "Probability: " << fTimeProb                              << endl;
+  *fLog                                                              << endl;
+
+}

trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.h

@@ -31 +31 @@
 protected:
 
-  TH1I* fHQ;              //-> Summed FADC slices
-  TH1I* fHT;              //-> Mean arrival time in number of FADC sice
-
-  TH1I* fHQvsN;           //-> Summed Charge vs. Event Nr. 
+  TH1I* fHCharge;              //-> Summed FADC slices
+  TH1I* fHTime;                //-> Mean arrival time in number of FADC sice
+  TH1I* fHChargevsN;           //-> Summed Charge vs. Event Nr. 
   
-  TF1* fQGausFit;
-  TF1* fTGausFit;
+  TF1* fChargeGausFit;
+  TF1* fTimeGausFit;
   
   TPaveText *fFitLegend;  
   
   Axis_t  fLowerFitRange;
-  Axis_t  fQfirst;
-  Axis_t  fQlast;
-  Int_t   fQnbins;
+  Axis_t  fChargeFirst;
+  Axis_t  fChargeLast;
+  Int_t   fChargeNbins;
 
   Bool_t fFitOK;
 
-  Double_t fQChisquare;
-  Double_t fQProb;
-  Int_t    fQNdf;
+  Double_t fChargeChisquare;
+  Double_t fChargeProb;
+  Int_t    fChargeNdf;
 
-  Double_t fQMean;
-  Double_t fQMeanErr;
-  Double_t fQSigma;
-  Double_t fQSigmaErr;
+  Double_t fChargeMean;
+  Double_t fChargeMeanErr;
+  Double_t fChargeSigma;
+  Double_t fChargeSigmaErr;
   
-  Double_t fTChisquare;
-  Double_t fTProb;
-  Int_t    fTNdf;
+  Double_t fTimeChisquare;
+  Double_t fTimeProb;
+  Int_t    fTimeNdf;
 
-  Double_t fTMean;
-  Double_t fTSigma;
+  Double_t fTimeMean;
+  Double_t fTimeSigma;
   
   virtual void DrawLegend();
@@ -76 +75 @@
   Bool_t Fill(const MParContainer *, const Stat_t w=1) { return kTRUE; }
 
-  Bool_t FillQ(Int_t q) {  return fHQ->Fill(q) > -1;  }
-  Bool_t FillT(Int_t t) {  return fHT->Fill(t) > -1;  }
-  Bool_t FillQvsN(Float_t q, Int_t n) { return fHQvsN->Fill(n,q) > -1; }
+  Bool_t FillCharge(Int_t q)               { return fHCharge->Fill(q)      > -1; }
+  Bool_t FillTime(Int_t t)                 { return fHTime->Fill(t)        > -1; }
+  Bool_t FillChargevsN(Float_t q, Int_t n) { return fHChargevsN->Fill(n,q) > -1; }
 
-  const TH1I *GetHQ()       { return fHQ; }
-  const TH1I *GetHQ() const { return fHQ; }
+  const TH1I *GetHCharge()                 { return fHCharge;    }
+  const TH1I *GetHCharge() const           { return fHCharge;    }
 
-  const Double_t GetQMean()    const { return fQMean; }
-  const Double_t GetQMeanErr()  const { return fQMeanErr; }
-  const Double_t GetQSigma()   const { return fQSigma; }
-  const Double_t GetQSigmaErr() const { return fQSigmaErr; }
-  const Double_t GetArea()    const { return fQGausFit->GetParameter(0); }
-  const Double_t GetAreaErr()  const { return fQGausFit->GetParError(0); }
+  const Double_t GetChargeMean()     const { return fChargeMean;    }
+  const Double_t GetChargeMeanErr()  const { return fChargeMeanErr; }
+  const Double_t GetChargeSigma()    const { return fChargeSigma;   }
+  const Double_t GetChargeSigmaErr() const { return fChargeSigmaErr; }
+  const Double_t GetArea()           const { return fChargeGausFit->GetParameter(0); }
+  const Double_t GetAreaErr()        const { return fChargeGausFit->GetParError(0);  }
 
-  const Double_t GetQChiSquare() const { return fQChisquare; }
-  const Double_t GetQProb()    const { return fQProb;      }  
-  const Int_t    GetQNdf()     const { return fQNdf;       }   
+  const Double_t GetChargeChiSquare() const { return fChargeChisquare; }
+  const Double_t GetChargeProb()      const { return fChargeProb;      }  
+  const Int_t    GetChargeNdf()       const { return fChargeNdf;       }   
 
-  const Double_t GetTMean()   const  { return fTMean; }
-  const Double_t GetTSigma()  const  { return fTSigma; }
+  const Double_t GetTimeMean()        const { return fTimeMean;  }
+  const Double_t GetTimeSigma()       const { return fTimeSigma; }
 
-  const Double_t GetTChiSquare() const { return fTChisquare; }
-  const Double_t GetTProb()      const { return fTProb; }
-  const Int_t    GetTNdf()       const { return fTNdf;       }   
+  const Double_t GetTimeChiSquare()   const { return fTimeChisquare; }
+  const Double_t GetTimeProb()        const { return fTimeProb;      }
+  const Int_t    GetTimeNdf()         const { return fTimeNdf;       }   
   
-  const TH1I *GetHT()       { return fHT; }
-  const TH1I *GetHT() const { return fHT; }
+  const TH1I *GetHTime()                    { return fHTime; }
+  const TH1I *GetHTime()              const { return fHTime; }
   
-  const TH1I *GetHQvsN()       { return fHQvsN; }
-  const TH1I *GetHQvsN() const { return fHQvsN; }
+  const TH1I *GetHChargevsN()               { return fHChargevsN; }
+  const TH1I *GetHChargevsN()         const { return fHChargevsN; }
   
-  Bool_t FitQ(Option_t *option="RQ0");  
-  Bool_t FitT(Axis_t rmin=0, Axis_t rmax=0, Option_t *option="RQ0");    
+  Bool_t FitCharge(Option_t *option="RQ0");  
+  Bool_t FitTime(Axis_t rmin=0, Axis_t rmax=0, Option_t *option="RQ0");    
 
   virtual void Draw(Option_t *option="");
@@ -116 +115 @@
   void SetLowerFitRange(Axis_t min)  { fLowerFitRange = min; }
 
-  void PrintQFitResult();
-  void PrintTFitResult();  
+  void PrintChargeFitResult();
+  void PrintTimeFitResult();  
 
-  Bool_t IsFitted()    { return fFitOK; }
+  Bool_t IsFitOK()    { return fFitOK; }
   
   ClassDef(MHCalibrationPixel, 1)