Changeset 2627 for trunk/MagicSoft/Mars/manalysis

Timestamp:

12/09/03 18:25:21 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/manalysis

Files:

• AnalysisLinkDef.h (modified) (1 diff)
• MCalibrationBlindPix.h (modified) (1 diff)
• MCalibrationCalc.cc (modified) (12 diffs)
• MCalibrationCalc.h (modified) (1 diff)
• MCalibrationCam.cc (modified) (8 diffs)
• MCalibrationCam.h (modified) (2 diffs)
• MCalibrationConfig.h (modified) (3 diffs)
• MCalibrationPINDiode.cc (modified) (2 diffs)
• MCalibrationPINDiode.h (modified) (1 diff)
• MCalibrationPix.cc (modified) (7 diffs)
• MCalibrationPix.h (modified) (4 diffs)
• MExtractSignal.cc (added)
• MExtractSignal.h (added)
• MExtractedSignalCam.cc (added)
• MExtractedSignalCam.h (added)
• MExtractedSignalPix.cc (added)
• MExtractedSignalPix.h (added)
• Makefile (modified) (1 diff)

trunk/MagicSoft/Mars/manalysis/AnalysisLinkDef.h

@@ -69 +69 @@
 #pragma link C++ class MCalibrationCalc+;
 
+#pragma link C++ class MExtractedSignalCam+;
+#pragma link C++ class MExtractedSignalPix+;
+#pragma link C++ class MExtractSignal+;
+
 
 #endif

trunk/MagicSoft/Mars/manalysis/MCalibrationBlindPix.h

@@ -48 +48 @@
   Float_t GetErrSigma1() const    { return fErrSigma1;  }
 
-  Float_t GetTime()         const    { return fTime;         }
-  Float_t GetErrTime()      const    { return fErrTime;      }
+  Float_t GetTime()      const    { return fTime;         }
+  Float_t GetErrTime()   const    { return fErrTime;      }
   
-  Bool_t FillCharge(Int_t q)            { return fHist->FillBlindPixelCharge(q); }
-  Bool_t FillTime(Int_t t)            { return fHist->FillBlindPixelTime(t); }  
+  Bool_t FillCharge(Float_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 IsValid()                { return fLambda > 0. || fErrLambda > 0.; }
   
   Bool_t FitCharge();

trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.cc

@@ -53 +53 @@
 //               Every MCalibrationPix holds a histogram class,             //
 //               MHCalibrationPixel which itself hold histograms of type:   //
-//               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 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::SetSkipTimeFits()   (skip all time fits)      //
-//               MalibrationCam::SetSkipBlindPixelFits()  (skip all blind pixel fits) //
-//               MalibrationCam::SetSkipPinDiodeFits()  (skip all PIN Diode fits) //
-//                                                                          //
+//               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 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::SetSkipTimeFits()   (skip all time fits)   
+//               MalibrationCam::SetSkipBlindPixelFits()  (skip all blind pixel fits) 
+//               MalibrationCam::SetSkipPinDiodeFits()  (skip all PIN Diode fits) 
+//                                                                          
 //////////////////////////////////////////////////////////////////////////////
 
@@ -169 +169 @@
       case kEBlue:
         fCalibrations->SetColor(MCalibrationCam::kECBlue);
-      break;        
+        break;        
       case kEGreen:
         fCalibrations->SetColor(MCalibrationCam::kECGreen);      
-      break;
+        break;
       case kEUV:
         fCalibrations->SetColor(MCalibrationCam::kECUV);            
+        break;
+      case kECT1:
+        fCalibrations->SetColor(MCalibrationCam::kECCT1);            
+        break;
+      default:
+        fCalibrations->SetColor(MCalibrationCam::kECCT1); 
       }
-
-
 
     fPedestals = (MPedestalCam*)pList->FindObject("MPedestalCam");
@@ -185 +189 @@
         return kFALSE;
       }
-    
     
     return kTRUE;
@@ -245 +248 @@
     MRawEvtPixelIter pixel(fRawEvt);
 
+    //
     // Create a first loop to sort out the cosmics ...
     // 
@@ -266 +270 @@
         Float_t pedrms = ped.GetPedestalRms();
         
-        if ((float)sum < (pedes*fNumHiGainSamples)+(1.5*pedrms) )
+        if ((float)sum < ((pedes*fNumHiGainSamples)+(30.*pedrms)) )
            cosmicpix++;
      }
@@ -274 +278 @@
       {
         fCosmics++;
-        return kTRUE;
+        return kCONTINUE;
       }
 
     pixel.Reset();
 
+    //
+    // Create a second loop to do fill the calibration histograms
+    // 
+
     while (pixel.Next())
       {
 
         UShort_t sat = 0;
-        UShort_t lowgainoverflow = 0;
 
         const Int_t pixid = pixel.GetPixelId();
 
-        Byte_t *ptr = pixel.GetHiGainSamples();
         Byte_t mid  = pixel.GetIdxMaxHiGainSample();
         UInt_t max  = pixel.GetMaxHiGainSample();
 
-        Int_t sum = (max > gkSaturationLimit              // overflow ?
-                     ? sat++, pixel.GetSumLoGainSamples() // take Low Gain
-                     : pixel.GetSumHiGainSamples());      // no overflow
-
-        if (sat)
-          {
-
-            ptr = pixel.GetLoGainSamples();
-            max = pixel.GetMaxLoGainSample();
-            mid = pixel.GetIdxMaxLoGainSample();
-
-            // 
-            //  FIXME: It seems the conversion HiGain LoGain is already
-            //         performed in the data?!?
-            //
-            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++;
-                }
-          }
-
-        MPedestalPix    &ped = (*fPedestals)[pixid];
-        MCalibrationPix &pix = (*fCalibrations)[pixid];
-        
+        MPedestalPix    &ped = (*fPedestals)[pixid]; 
+        MCalibrationPix &pix = (*fCalibrations)[pixid];
+
         Float_t pedes  = ped.GetPedestal();
-        Float_t pedrms = ped.GetPedestalRms();
-        
+        Float_t sum;
+
         //
         // FIXME: This is preliminary, we will change to pedestals per slice!!!
         // Assume pedestals per time slice ==> multiply with number of slices
         //
-        pedes  *= (sat ? fNumLoGainSamples : fNumHiGainSamples );
-        pedrms *= (sat ? fNumLoGainSamples : fNumHiGainSamples );
-
-        Float_t rsum      = (float)sum - pedes;
-        
+
+        if (max < gkSaturationLimit)  // take Hi Gain
+          {
+            sum = (float)pixel.GetSumHiGainSamples() - pedes*fNumHiGainSamples;  
+          }
+        else                          // Lo Gain
+          {
+
+            sat++;
+            pix.SetHiGainSaturation();
+
+            sum = (float)pixel.GetSumLoGainSamples() - pedes*fNumLoGainSamples ;
+            sum *= gkConversionHiLo; 
+
+            max = pixel.GetMaxLoGainSample();
+            mid = pixel.GetIdxMaxLoGainSample();
+
+            if (max > gkSaturationLimit)
+              {
+                *fLog << err << dbginf 
+                      << "Warning: Saturation of Lo Gain reached in pixel: " 
+                      << pixid << " " << "   sum = " << sum << endl;
+                fHistOverFlow++;
+              }
+
+          }
+
         switch(pixid)
           {
@@ -339 +339 @@
           case gkCalibrationBlindPixelId:
 
-            // 
-            // FIXME: This works only when the blind pixel ID is much larger than 
-            //        the rest of the pixels (which is the case right now)
-            //
             if (!blindpixel.FillCharge(sum)) 
               *fLog << warn << 
@@ -351 +347 @@
                 "Overflow or Underflow occurred filling Blind Pixel time = " << (int)mid << endl;
             
-            if (!blindpixel.FillRChargevsTime(rsum,fEvents))
+            if (!blindpixel.FillRChargevsTime(sum,fEvents))
               *fLog << warn << 
                 "Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
@@ -362 +358 @@
               *fLog << warn << 
                 "Overflow or Underflow occurred filling HTime: time = " << (int)mid << endl;
-            if (!pindiode.FillRChargevsTime(rsum,fEvents))
+            if (!pindiode.FillRChargevsTime(sum,fEvents))
               *fLog << warn << 
                 "Overflow or Underflow occurred filling HChargevsN: eventnr = " << fEvents << endl;
@@ -368 +364 @@
           default:
 
-            if (!pix.FillCharge(sum))
-              *fLog << warn << "Could not fill Charge of pixel: " << pixid 
-                    << " signal = " << sum << endl;
-
-            //
-            // Fill the reduced charge into the control histo for better visibility
-            //
-            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.FillTime((int)mid)) 
-            *fLog << warn << "Could not fill Time of pixel: " << pixid << " time = " << (int)mid << endl;
-
-
+            if (sat)
+              {
+                
+                if (!pix.FillChargeLoGain(sum))
+                  *fLog << warn << "Could not fill Lo Gain Charge of pixel: " << pixid 
+                        << " signal = " << sum << endl;
+
+                if (!pix.FillTimeLoGain((int)mid)) 
+                  *fLog << warn << "Could not fill Lo Gain Time of pixel: " 
+                        << pixid << " time = " << (int)mid << endl;
+                
+                //
+                // Fill the reduced charge into the control histo for better visibility
+                //
+                if (!pix.FillRChargevsTimeLoGain(sum,fEvents))
+                  *fLog << warn << "Could not fill Lo Gain Charge vs. EvtNr of pixel: " 
+                        << pixid << " signal = " << sum  << " event Nr: " << fEvents << endl;
+                
+              }
+            else
+              {
+                if (!pix.FillChargeHiGain(sum))
+                  *fLog << warn << "Could not fill Hi Gain Charge of pixel: " << pixid 
+                        << " signal = " << sum << endl;
+                
+                if (!pix.FillTimeHiGain((int)mid)) 
+                  *fLog << warn << "Could not fill Hi Gain Time of pixel: " 
+                        << pixid << " time = " << (int)mid << endl;
+                
+                if (!pix.FillRChargevsTimeHiGain(sum,fEvents))
+                  *fLog << warn << "Could not fill Hi Gain Charge vs. EvtNr of pixel: " 
+                        << pixid << " signal = " << sum  << " event Nr: " << fEvents << endl;
+              }
+            
           } /* switch(pixid) */
 
@@ -396 +410 @@
   *fLog << inf << endl;
   *fLog << GetDescriptor() << " Cut Histogram Edges" << endl;
+
   //
   // Cut edges to make fits and viewing of the hists easier  
@@ -414 +429 @@
     {
       if (blindpixel.FitCharge())
-        if (!fCalibrations->CalcNrPhotInnerPixel())
-          *fLog << err << dbginf << "Could not calculate Number of photons from the blind pixel " << endl;
+        {
+          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;
-      
+        {
+          *fLog << err << dbginf << "Could not fit the blind pixel " << endl;
+        }
+
       if (!blindpixel.FitTime())
         *fLog << warn << "Could not the Times of the blind pixel " << endl;

trunk/MagicSoft/Mars/manalysis/MCalibrationCalc.h

@@ -54 +54 @@
 public:
   
-  enum PulserColor_t  { kEGreen, kEBlue, kEUV };
+  enum PulserColor_t  { kEGreen, kEBlue, kEUV, kECT1 };
 
 private:

trunk/MagicSoft/Mars/manalysis/MCalibrationCam.cc

@@ -57 +57 @@
 MCalibrationCam::MCalibrationCam(const char *name, const char *title)
     : fMeanNrPhotAvailable(kFALSE),
-      fMeanNrPhotInnerPix(-1.)
+      fMeanNrPhotInnerPix(-1.),
+      fMeanNrPhotInnerPixErr(-1.)
 {
     fName  = name  ? name  : "MCalibrationCam";
@@ -153 +154 @@
 Bool_t MCalibrationCam::IsPixelFitted(Int_t idx) const 
 {
-  return ((*this)[idx].GetRCharge() > 0. && (*this)[idx].GetErrRCharge() > 0.);
+  return ((*this)[idx].GetCharge() > 0. && (*this)[idx].GetErrCharge() > 0.);
 }
 
@@ -359 +360 @@
     int id = 0;
 
+    *fLog << "Succesfully calibrated pixels:" << endl;
+    *fLog << endl;
+
     TIter Next(fPixels);
     MCalibrationPix *pix;
@@ -364 +368 @@
     {
 
-        *fLog << id << " Pedestals: " << pix->GetPed() << " +- " << pix->GetPedRms() << " Charge: " 
-              << pix->GetCharge() << " Reduced Charge: " << pix->GetRCharge() << " +- " 
-              << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigma() << endl;
-
-        id++;
-    }
+      if (pix->GetCharge() >= 0.)
+        {
+          *fLog << pix->GetPixId() << " Pedestals: " << pix->GetPed() << " +- " << pix->GetPedRms() 
+                << " Reduced Charge: " << pix->GetCharge() << " +- " 
+                << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigma() << endl;
+          id++;
+        }
+    }
+
+    *fLog << id << " succesful pixels :-))" << endl;
+    id = 0;
+
+    *fLog << endl;
+    *fLog << "Pixels with errors:" << endl;
+    *fLog << endl;
+
+    TIter Next2(fPixels);
+    while ((pix=(MCalibrationPix*)Next2()))
+    {
+
+      if (pix->GetCharge() == -1.)
+        {
+          *fLog << pix->GetPixId() << " Pedestals: " << pix->GetPed() << " +- " << pix->GetPedRms() 
+                << " Reduced Charge: " << pix->GetCharge() << " +- " 
+                << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigma() << endl;
+          id++;
+        }
+    }
+    *fLog << id << " pixels with errors :-((" << endl;
+
 }
 
@@ -379 +407 @@
     {
     case 0:
-       val = (*this)[idx].GetCharge();
-        break;
+      val = (*this)[idx].GetCharge();
+      break;
     case 1:
-       val = (*this)[idx].GetErrCharge();
-        break;
+      val = (*this)[idx].GetErrCharge();
+      break;
     case 2:
-       val = (*this)[idx].GetSigmaCharge();
-        break;
+      val = (*this)[idx].GetSigmaCharge();
+      break;
     case 3:
-       val = (*this)[idx].GetErrSigmaCharge();
-        break;
+      val = (*this)[idx].GetErrSigmaCharge();
+      break;
     case 4:
-       val = (*this)[idx].GetChargeProb();
-        break;
+      val = (*this)[idx].GetChargeProb();
+      break;
     case 5:
-       val = (*this)[idx].GetTime();
-        break;
+      val = (*this)[idx].GetTime();
+      break;
     case 6:
-       val = (*this)[idx].GetSigmaTime();
-        break;
+      val = (*this)[idx].GetSigmaTime();
+      break;
     case 7:
-       val = (*this)[idx].GetTimeProb();
-        break;
+      val = (*this)[idx].GetTimeProb();
+      break;
     case 8:
-       val = (*this)[idx].GetPed();
-        break;
+      val = (*this)[idx].GetPed();
+      break;
     case 9:
-       val = (*this)[idx].GetPedRms();
-        break;
+      val = (*this)[idx].GetPedRms();
+      break;
     case 10:
-      val = (*this)[idx].GetRCharge();
+      val = (*this)[idx].GetRSigma();
       break;
     case 11:
-      val = (*this)[idx].GetRSigma();
+      val = (*this)[idx].GetPheFFactorMethod();
       break;
     case 12:
-      val = (*this)[idx].GetPheFFactorMethod();
+      val = (*this)[idx].GetConversionFFactorMethod();
       break;
     case 13:
-      val = (*this)[idx].GetConversionFFactorMethod();
+      if (idx < 397)
+        val = (double)fMeanNrPhotInnerPix;
+      else
+        val = (double)fMeanNrPhotInnerPix*gkCalibrationOuterPixelArea;
       break;
     case 14:
-      val = (double)fMeanNrPhotInnerPix;
-      break;
-    case 15:
-      if ((fMeanNrPhotInnerPix > 0. ) && ((*this)[idx].GetRCharge() > 100.))
-        val = fMeanNrPhotInnerPix / (*this)[idx].GetRCharge();
-      else 
-        val = -1.;
+      if ((fMeanNrPhotInnerPix > 0. ) && ((*this)[idx].GetCharge() != -1.))
+        {
+          if (idx < 397)
+            val = fMeanNrPhotInnerPix / (*this)[idx].GetCharge();
+          else 
+            val = fMeanNrPhotInnerPix*gkCalibrationOuterPixelArea / (*this)[idx].GetCharge();
+        } 
+      else
+        {
+          val = -1.;
+        }
       break;
     default:
@@ -467 +502 @@
                             / gkCalibrationBlindPixelArea;
       break;
+    case kECCT1:
+    default:
+      fMeanNrPhotInnerPix = (mean / gkCalibrationBlindPixelQECT1 )
+                            *TMath::Power(10,gkCalibrationBlindPixelAttCT1)
+                            / gkCalibrationBlindPixelArea;
+      break;
     }
 
@@ -474 +515 @@
 
 
-
-Bool_t MCalibrationCam::GetConversionFactor(Int_t ipx, Float_t &mean, Float_t &err)
+Bool_t MCalibrationCam::GetConversionFactorBlindPixel(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma)
 {
   
@@ -485 +525 @@
       return kFALSE;
 
-  mean = fMeanNrPhotInnerPix / (*this)[ipx].GetRCharge();
+  mean = fMeanNrPhotInnerPix / (*this)[ipx].GetCharge();
 
   //
   // Not yet ready , sorry 
   //
-  err  = 100000000000.;
+  err  = -1.;
+  sigma = -1.;
 
   return kTRUE;
 }
+
+
+Bool_t MCalibrationCam::GetConversionFactorFFactor(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma)
+{
+  
+  if (ipx < 0 || !IsPixelFitted(ipx))
+    return kFALSE;
+
+  Float_t conv = (*this)[ipx].GetConversionFFactorMethod();
+
+  if (conv < 0.)
+    return kFALSE;
+
+  mean = conv;
+
+  //
+  // Not yet ready , sorry 
+  //
+  err  = -1.;
+  sigma = -1.;
+
+  return kTRUE;
+}

trunk/MagicSoft/Mars/manalysis/MCalibrationCam.h

@@ -38 +38 @@
   MCalibrationPINDiode *fPINDiode;   //! containing PIN Diode data with fit results    
 
+  Bool_t  fMeanNrPhotAvailable;
   Float_t fMeanNrPhotInnerPix;       // The mean number of photons in an inner pixel  
   Float_t fMeanNrPhotInnerPixErr;    // The uncertainty about the number of photons in an inner pixel  
-  Bool_t  fMeanNrPhotAvailable;
 
 public:
   
-  enum CalibrationColor_t { kECGreen, kECBlue, kECUV };
+  enum CalibrationColor_t { kECGreen, kECBlue, kECUV, kECCT1 };
 
 private:
@@ -89 +89 @@
   void SetColor(CalibrationColor_t color)    { fColor = color; }
 
-  Bool_t GetConversionFactor(Int_t ipx, Float_t &mean, Float_t &err);
+  Bool_t GetConversionFactorFFactor(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma);
+  Bool_t GetConversionFactorBlindPixel(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma);
   
   ClassDef(MCalibrationCam, 1)  // Storage Container for all calibration information of the camera

trunk/MagicSoft/Mars/manalysis/MCalibrationConfig.h

@@ -15 +15 @@
 
 // The conversion factor between High Gain and Low Gain
-const UShort_t gkConversionHiLo = 10.;
+const Float_t gkConversionHiLo = 10.;
 
 // The penalty constant to produce overflow in the histogram 
@@ -29 +29 @@
 const Float_t gkCalibrationBlindPixelQEBlue  = 0.226;
 const Float_t gkCalibrationBlindPixelQEUV    = 0.247;
+const Float_t gkCalibrationBlindPixelQECT1   = 0.247;
 
 // Attenuation factor Blind Pixel (three colours)
@@ -34 +35 @@
 const Float_t gkCalibrationBlindPixelAttBlue  = 1.96;
 const Float_t gkCalibrationBlindPixelAttUV    = 1.95;
+const Float_t gkCalibrationBlindPixelAttCT1   = 1.95;
 
 // Area of Blind Pixel w.r.t. Inner Pixel
 const Float_t gkCalibrationBlindPixelArea     = 0.25;
+
+// Area of Outer Pixel w.r.t. Inner Pixel
+const Float_t gkCalibrationOuterPixelArea     = 4.00;
 
 // ----- PIN DIODE ------------------------//

trunk/MagicSoft/Mars/manalysis/MCalibrationPINDiode.cc

@@ -79 +79 @@
 Bool_t MCalibrationPINDiode::FitCharge() 
 {
-  if(!fHist->FitCharge())
+  if(!fHist->FitChargeHiGain())
     return kFALSE;
 
@@ -94 +94 @@
 {
 
-  if(!fHist->FitTime())
+  if(!fHist->FitTimeHiGain())
     return kFALSE;
 

trunk/MagicSoft/Mars/manalysis/MCalibrationPINDiode.h

@@ -33 +33 @@
   void Clear(Option_t *o="");
   
-  void SetPed(Float_t ped)         { fPed      = ped;      } 
+  void SetPed(Float_t ped)          { fPed      = ped;      } 
   void SetPedRms(Float_t pedrms)    { fPedRms   = pedrms; }
 
   Bool_t IsValid() const { return fRCharge >=0 || fErrRCharge >= 0; }
 
-  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 FillCharge(Float_t q)      { return fHist->FillChargeHiGain(q); }
+  Bool_t FillTime(Int_t t)          { return fHist->FillTimeHiGain(t); }  
+  Bool_t FillRChargevsTime(Float_t rq, Int_t t) { return fHist->FillChargevsNHiGain(rq,t); }    
   
   Bool_t FitCharge();

trunk/MagicSoft/Mars/manalysis/MCalibrationPix.cc

@@ -50 +50 @@
       fSigmaCharge(-1.),
       fErrSigmaCharge(-1.),
+      fRSigma(-1.),
       fChargeProb(-1.),
       fPed(-1.),
@@ -56 +57 @@
       fSigmaTime(-1.),
       fTimeProb(-1.),
-      fRCharge(-1.),
-      fErrRCharge(-1.),
-      fRSigma(-1.),
       fFactor(1.3),
       fPheFFactorMethod(-1.),
-      fConversionFFactorMethod(-1.)
+      fConversionFFactorMethod(-1.),
+      fHiGainSaturation(kFALSE)
 {
 
@@ -102 +101 @@
 
   if (fPed && fPedRms)
-    fHist->SetLowerFitRange(fPed + 1.5*fPedRms);
+    fHist->SetLowerFitRange(3.5*fPedRms);
+  //    fHist->SetLowerFitRange(fPed + 3.5*fPedRms);
   else
     *fLog << warn << "Cannot set lower fit range to suppress cosmics: Pedestals not available" << endl;
 
-  if(!fHist->FitCharge())
+
+  if (fHiGainSaturation)
     {
-      *fLog << warn << "Could not fit charges of pixel " << fPixId << endl;
-      fHist->PrintChargeFitResult();
-      return kFALSE;
+      if(!fHist->FitChargeLoGain())
+        {
+          *fLog << warn << "Could not fit Lo Gain charges of pixel " << fPixId << endl;
+          fHist->PrintChargeFitResult();
+          return kFALSE;
+        }
+    }
+  else 
+    {
+      if(!fHist->FitChargeHiGain())
+        {
+          *fLog << warn << "Could not fit Hi Gain charges of pixel " << fPixId << endl;
+          fHist->PrintChargeFitResult();
+          return kFALSE;
+        }
     }
   
+
   fCharge         = fHist->GetChargeMean();
   fErrCharge      = fHist->GetChargeMeanErr(); 
@@ -122 +136 @@
     {
       
-    fRCharge      = fCharge - fPed;
-    fErrRCharge   = TMath::Sqrt(fErrCharge*fErrCharge + fPedRms*fPedRms);
-
     fRSigma       = (fSigmaCharge*fSigmaCharge) - (fPedRms*fPedRms);
 
     if (fRSigma > 0. )
       {
-       fPheFFactorMethod =  fFactor * fRCharge*fRCharge / fRSigma;
-       fConversionFFactorMethod = fPheFFactorMethod / fRCharge ;
+       fPheFFactorMethod =  fFactor * fCharge*fCharge / fRSigma;
+       fConversionFFactorMethod = fPheFFactorMethod /   fCharge ;
       }
     else
@@ -144 +155 @@
 }
 
+
 void MCalibrationPix::SetPedestal(Float_t ped, Float_t pedrms)
 {
@@ -150 +162 @@
   fPedRms = pedrms;
   
-  if ((fRCharge == -1.) && (fCharge > 0.)) 
-    fRCharge = fCharge - fPed;
-  if ((fErrRCharge == -1.) && (fErrCharge > 0.))
-    fErrRCharge   = TMath::Sqrt(fErrCharge*fErrCharge + fPedRms*fPedRms);
-
 }
 
@@ -160 +167 @@
 {
 
-  if(!fHist->FitTime())
+  if (fHiGainSaturation)
     {
-      *fLog << warn << "Could not fit times of pixel " << fPixId << endl;
-      fHist->PrintTimeFitResult();
-      return kFALSE;
+      if(!fHist->FitTimeLoGain())
+        {
+          *fLog << warn << "Could not fit Lo Gain times of pixel " << fPixId << endl;
+          fHist->PrintTimeFitResult();
+          return kFALSE;
+        }
     }
-
+  else
+    {
+      if(!fHist->FitTimeHiGain())
+        {
+          *fLog << warn << "Could not fit Hi Gain times of pixel " << fPixId << endl;
+          fHist->PrintTimeFitResult();
+          return kFALSE;
+        }
+    }
+    
   fTime       = fHist->GetTimeMean();
   fSigmaTime  = fHist->GetTimeSigma();

trunk/MagicSoft/Mars/manalysis/MCalibrationPix.h

@@ -14 +14 @@
   Int_t   fPixId;           // the pixel Id
   
-  Float_t fCharge;              // The mean charge after the fit
-  Float_t fErrCharge;           // The error of mean charge after the fit
+  Float_t fCharge;              // The mean reduced charge after the fit
+  Float_t fErrCharge;           // The error of reduced 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 fRSigma;              // The reduced squares of sigmas after the fit
   Float_t fChargeProb;          // The probability of the fit function 
 
@@ -27 +28 @@
   Float_t fTimeProb;            // The probability of the fit function 
   
-  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
+
+  Bool_t fHiGainSaturation;     // Is Lo-Gain used at all?
 
   MHCalibrationPixel *fHist;    //! Pointer to the histograms performing the fits, etc.  
@@ -45 +44 @@
 
   Float_t GetCharge()         const    { return fCharge;         }
-  Float_t GetRCharge()        const    { return fRCharge;        }
   Float_t GetRSigma()         const    { return fRSigma;         }
     
   Float_t GetErrCharge()      const    { return fErrCharge;      }
-  Float_t GetErrRCharge()     const    { return fErrRCharge;     }    
   Float_t GetChargeProb()     const    { return fChargeProb;     }    
   
   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 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 SetHiGainSaturation()                 { fHiGainSaturation = kTRUE; fHist->SetUseLoGain(); } 
 
-  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 FillChargeHiGain(Float_t q)   { return fHist->FillChargeHiGain(q); }
+  Bool_t FillTimeHiGain(Int_t t)       { return fHist->FillTimeHiGain(t); }  
+  Bool_t FillRChargevsTimeHiGain(Float_t rq, Int_t t) { return fHist->FillChargevsNHiGain(rq,t); }    
+
+  Bool_t FillChargeLoGain(Float_t q)   { return fHist->FillChargeLoGain(q); }
+  Bool_t FillTimeLoGain(Int_t t)       { return fHist->FillTimeLoGain(t); }  
+  Bool_t FillRChargevsTimeLoGain(Float_t rq, Int_t t) { return fHist->FillChargevsNLoGain(rq,t); }    
   
-  Bool_t IsValid()          const    { return fRCharge >=0 || fErrRCharge >= 0; }
-  Int_t  GetPixId()         const    { return fPixId;   }
+  Bool_t IsValid()            const    { return fCharge >=0 || fErrCharge >= 0; }
+  Int_t  GetPixId()           const    { return fPixId;   }
   void   DefinePixId(Int_t i);
   
@@ -74 +76 @@
   Bool_t FitTime();
   
-  MHCalibrationPixel *GetHist() const  { return fHist;  }
-  virtual void Draw(Option_t *opt="")   { fHist->Draw(opt); }
+  MHCalibrationPixel *GetHist() const   { return fHist;     }
+  void Draw(Option_t *opt="")           { fHist->Draw(opt); }
   
   Float_t GetPheFFactorMethod()           const { return fPheFFactorMethod;           }  

trunk/MagicSoft/Mars/manalysis/Makefile

@@ -75 +75 @@
            MCalibrationBlindPix.cc  \
            MCalibrationPINDiode.cc  \
-           MCalibrationCam.cc
+           MCalibrationCam.cc \
+           MExtractedSignalCam.cc \
+           MExtractedSignalPix.cc \
+           MExtractSignal.cc
 
 SRCS    = $(SRCFILES)