Changeset 4909 for trunk/MagicSoft/Mars/mjobs

Timestamp:

09/09/04 18:03:23 (20 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/mjobs

Files:

• MJCalibration.cc (modified) (36 diffs)
• MJCalibration.h (modified) (7 diffs)

trunk/MagicSoft/Mars/mjobs/MJCalibration.cc

@@ -111 +111 @@
 
 #include "MPedestalCam.h"
+#include "MCalibColorSteer.h"
+
+#include "MCalibrationIntensityChargeCam.h"
+#include "MCalibrationIntensityRelTimeCam.h"
+#include "MCalibrationIntensityQECam.h"
+
 #include "MCalibrationCam.h"
 #include "MCalibrationQECam.h"
@@ -122 +128 @@
 #include "MCalibrationChargeBlindCamTwoNewStyle.h"
 #include "MCalibrationChargeCalc.h"
+#include "MCalibColorSet.h"
 
 #include "MHGausEvents.h"
@@ -170 +177 @@
 
 const Float_t  MJCalibration::fgRefConvFADC2PheInner      = 0.14;       
-const Float_t  MJCalibration::fgRefConvFADC2PheOuter      = 0.45;       
+const Float_t  MJCalibration::fgRefConvFADC2PheOuter      = 0.4;       
 const Float_t  MJCalibration::fgRefConvFADC2PhotInner     = 0.8; 
 const Float_t  MJCalibration::fgRefConvFADC2PhotOuter     = 3.8; 
@@ -184 +191 @@
 //
 // - Sets fRuns to 0, fExtractor to NULL, fTimeExtractor to NULL, fColor to kNONE, 
-//   fDisplay to kNormalDisplay, fRelTime to kFALSE, fDataCheck to kFALSE, 
+//   fDisplay to kNormalDisplay, kRelTimes to kFALSE, kataCheck to kFALSE, kDebug to kFALSE,
+//   kIntensity to kFALSE
 // - SetUseBlindPixel()
 // - SetUsePINDiode()
@@ -191 +199 @@
     : fRuns(0), fExtractor(NULL), fTimeExtractor(NULL),
       fColor(MCalibrationCam::kNONE), fDisplayType(kNormalDisplay),
-      fRelTimes(kFALSE), fDataCheck(kFALSE), fDebug(kFALSE), fGeometry("MGeomCamMagic")
+      fGeometry("MGeomCamMagic")
 {
-    fName  = name  ? name  : "MJCalibration";
-    fTitle = title ? title : "Tool to create the calibration constants for one calibration run";
-
-    SetUseBlindPixel();
-    SetUsePINDiode();
+
+  fName  = name  ? name  : "MJCalibration";
+  fTitle = title ? title : "Tool to create the calibration constants for one calibration run";
+  
+  SetUseBlindPixel();
+  SetUsePINDiode();
+  
+  SetRelTimeCalibration( kFALSE );
+  SetDataCheck         ( kFALSE );
+  SetDebug             ( kFALSE );
+  SetIntensity         ( kFALSE );
 }
 
@@ -297 +311 @@
     MHCamera disp34(geomcam, "TimeOscillating",   "Oscillating Pixels");
     MHCamera disp35(geomcam, "TotalConv",         "Conversion Factor to photons");
-
+    
+    MCalibrationChargeCam  *cam    = NULL;
+    MCalibrationQECam      *qecam  = NULL;
+    MCalibrationRelTimeCam *relcam = NULL;
+
+    if (IsIntensity())
+      {
+        cam    = (MCalibrationChargeCam*) fIntensCalibCam.GetCam();
+        qecam  = (MCalibrationQECam*)     fIntensQECam.GetCam();
+        relcam = (MCalibrationRelTimeCam*)fIntensRelTimeCam.GetCam();
+      }
+    else
+      {
+        cam    = &fCalibrationCam;
+        qecam  = &fQECam;
+        relcam = &fRelTimeCam;
+      }
+    
     // Fitted charge means and sigmas
-    disp1.SetCamContent(fCalibrationCam,  0);
-    disp1.SetCamError(  fCalibrationCam,  1);
-    disp2.SetCamContent(fCalibrationCam,  2);
-    disp2.SetCamError(  fCalibrationCam,  3);
+    disp1.SetCamContent(*cam,  0);
+    disp1.SetCamError(  *cam,  1);
+    disp2.SetCamContent(*cam,  2);
+    disp2.SetCamError(  *cam,  3);
 
     // Reduced Sigmas and reduced sigmas per charge
-    disp3.SetCamContent(fCalibrationCam,  5);
-    disp3.SetCamError(  fCalibrationCam,  6);
-    disp4.SetCamContent(fCalibrationCam,  7);
-    disp4.SetCamError(  fCalibrationCam,  8);
+    disp3.SetCamContent(*cam,  5);
+    disp3.SetCamError(  *cam,  6);
+    disp4.SetCamContent(*cam,  7);
+    disp4.SetCamError(  *cam,  8);
 
     // F-Factor Method
-    disp5.SetCamContent(fCalibrationCam,  9);
-    disp5.SetCamError(  fCalibrationCam, 10);
-    disp6.SetCamContent(fCalibrationCam, 11);
-    disp6.SetCamError(  fCalibrationCam, 12);
-    disp7.SetCamContent(fCalibrationCam, 13);
-    disp7.SetCamError(  fCalibrationCam, 14);
+    disp5.SetCamContent(*cam,  9);
+    disp5.SetCamError(  *cam, 10);
+    disp6.SetCamContent(*cam, 11);
+    disp6.SetCamError(  *cam, 12);
+    disp7.SetCamContent(*cam, 13);
+    disp7.SetCamError(  *cam, 14);
 
     // Quantum Efficiencies
-    disp8.SetCamContent (fQECam, 0 );
-    disp8.SetCamError   (fQECam, 1 );
-    disp9.SetCamContent (fQECam, 2 );
-    disp9.SetCamError   (fQECam, 3 );
-    disp10.SetCamContent(fQECam, 4 );
-    disp10.SetCamError  (fQECam, 5 );
-    disp11.SetCamContent(fQECam, 6 );
-    disp11.SetCamError  (fQECam, 7 );
+    disp8.SetCamContent (*qecam, 0 );
+    disp8.SetCamError   (*qecam, 1 );
+    disp9.SetCamContent (*qecam, 2 );
+    disp9.SetCamError   (*qecam, 3 );
+    disp10.SetCamContent(*qecam, 4 );
+    disp10.SetCamError  (*qecam, 5 );
+    disp11.SetCamContent(*qecam, 6 );
+    disp11.SetCamError  (*qecam, 7 );
 
     // Valid flags
-    disp12.SetCamContent(fQECam, 8 );
-    disp13.SetCamContent(fQECam, 9 );
-    disp14.SetCamContent(fQECam, 10);
-    disp15.SetCamContent(fQECam, 11);
+    disp12.SetCamContent(*qecam, 8 );
+    disp13.SetCamContent(*qecam, 9 );
+    disp14.SetCamContent(*qecam, 10);
+    disp15.SetCamContent(*qecam, 11);
 
     // Conversion Hi-Lo
-    disp16.SetCamContent(fCalibrationCam, 25);
-    disp17.SetCamContent(fCalibrationCam, 16);
-    disp17.SetCamError  (fCalibrationCam, 17);
-    disp18.SetCamContent(fCalibrationCam, 18);
-    disp18.SetCamError  (fCalibrationCam, 19);
+    disp16.SetCamContent(*cam, 25);
+    disp17.SetCamContent(*cam, 16);
+    disp17.SetCamError  (*cam, 17);
+    disp18.SetCamContent(*cam, 18);
+    disp18.SetCamError  (*cam, 19);
 
     // Pickup and Blackout
-    disp19.SetCamContent(fCalibrationCam, 21);
-    disp20.SetCamContent(fCalibrationCam, 22);
-    disp21.SetCamContent(fCalibrationCam, 23);
-    disp22.SetCamContent(fCalibrationCam, 24);
+    disp19.SetCamContent(*cam, 21);
+    disp20.SetCamContent(*cam, 22);
+    disp21.SetCamContent(*cam, 23);
+    disp22.SetCamContent(*cam, 24);
 
     // Pixels with defects
-    disp23.SetCamContent(fCalibrationCam, 20);
+    disp23.SetCamContent(*cam, 20);
     disp24.SetCamContent(fBadPixels, 6);
     disp25.SetCamContent(fBadPixels, 7);
@@ -357 +388 @@
 
     // Arrival Times
-    disp28.SetCamContent(fCalibrationCam, 26);
-    disp28.SetCamError(  fCalibrationCam, 27);
-    disp29.SetCamContent(fCalibrationCam, 27);
+    disp28.SetCamContent(*cam, 26);
+    disp28.SetCamError(  *cam, 27);
+    disp29.SetCamContent(*cam, 27);
 
     disp1.SetYTitle("Q [FADC counts]");
@@ -403 +434 @@
       {
 
-        MCalibrationChargePix &pix = (MCalibrationChargePix&)fCalibrationCam[i];
-        MCalibrationQEPix     &qe  = (MCalibrationQEPix&)    fQECam         [i];
+        MCalibrationChargePix &pix = (MCalibrationChargePix&)(*cam)  [i];
+        MCalibrationQEPix     &qe  = (MCalibrationQEPix&)    (*qecam)[i];
 
         if (!pix.IsFFactorMethodValid())
@@ -417 +448 @@
     
 
-    if (fRelTimes)
-    {
-        disp30.SetCamContent(fRelTimeCam,0);
-        disp30.SetCamError(  fRelTimeCam,1);
-        disp31.SetCamContent(fRelTimeCam,2);
-        disp31.SetCamError(  fRelTimeCam,3);
-        disp32.SetCamContent(fRelTimeCam,4);
+    if (IsRelTimes())
+    {
+        disp30.SetCamContent(*relcam,0);
+        disp30.SetCamError(  *relcam,1);
+        disp31.SetCamContent(*relcam,2);
+        disp31.SetCamError(  *relcam,3);
+        disp32.SetCamContent(*relcam,4);
         disp33.SetCamContent(fBadPixels,20);
         disp34.SetCamContent(fBadPixels,21);
@@ -434 +465 @@
     }
 
-
-    
     if (fDisplayType == kDataCheckDisplay)
     {
@@ -739 +768 @@
       if (geomcam.InheritsFrom("MGeomCamMagic"))
         DisplayDoubleProject(&disp29, "", "jittering");
-
 
       //
@@ -884 +912 @@
       obj9->Draw();
 
-      if (fRelTimes)
+      if (IsRelTimes())
         {
           // Rel. Times
@@ -955 +983 @@
         disp29.CamDraw(c16, 2, 2, 5);
 
-        if (fRelTimes)
+        if (IsRelTimes())
         {
             // Rel. Times
@@ -1052 +1080 @@
         disp29.CamDraw(c30, 2, 2, 1);
 
-        if (fRelTimes)
+        if (IsRelTimes())
         {
             // Rel. Times
@@ -1142 +1170 @@
 {
 
-  const Float_t mean  = hist->GetFunction("gaus")->GetParameter(1);
-  const Float_t lolim = mean - 4.0*hist->GetFunction("gaus")->GetParameter(2);
-  const Float_t uplim = mean + 4.0*hist->GetFunction("gaus")->GetParameter(2);
+  const Int_t kNotDraw = 1<<9;
+  TF1 *f = hist->GetFunction("gaus");
+  f->ResetBit(kNotDraw);
+
+  const Float_t mean  = f->GetParameter(1);
+  const Float_t lolim = mean - 4.0*f->GetParameter(2);
+  const Float_t uplim = mean + 4.0*f->GetParameter(2);
   const Stat_t  dead  = hist->Integral(0,hist->FindBin(lolim)-1);
   const Stat_t  noisy = hist->Integral(hist->FindBin(uplim)+1,hist->GetNbinsX()+1);
@@ -1356 +1388 @@
         SetNormalDisplay();
 
-    SetRelTimeCalibration(GetEnv("RelTimeCalibration", fRelTimes));
-    SetDataCheck(GetEnv("Datacheck", fDataCheck));
-    SetDebug(GetEnv("Debug", fDebug));
+    SetRelTimeCalibration(GetEnv("RelTimeCalibration", IsRelTimes()));
+    SetDataCheck(GetEnv("Datacheck", IsDataCheck()));
+    SetDebug(GetEnv("Debug", IsDebug()));
+    SetIntensity(GetEnv("Intensity", IsIntensity()));
+
     SetUseBlindPixel(GetEnv("UseBlindPixel", IsUseBlindPixel()));
     SetUsePINDiode(GetEnv("UsePINDiode", IsUsePINDiode()));
@@ -1438 +1472 @@
 //   2) MCalibrationQECam     (fQECam)
 //   3) MCalibrationChargeCam (fCalibrationCam)
-//   4) MCalibrationRelTimeCam (fRelTimeCam)   (only if flag fRelTimes is chosen)
+//   4) MCalibrationRelTimeCam (fRelTimeCam)   (only if flag IsRelTimes() is chosen)
 //   5) MBadPixelsCam         (fBadPixels)
 //   6) MCalibrationChargePINDiode
@@ -1449 +1483 @@
 //   5)  MExtractPINDiode
 //   6)  MExtractBlindPixel
-//   7)  MExtractTime (only if flag fRelTimes is chosen)
+//   7)  MExtractTime (only if flag IsRelTimes() is chosen)
 //   8)  MContinue(MFCosmics)
-//   9)  MFillH("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode")
-//   10) MFillH("MHCalibrationChargeBlindCam", "MExtractedSignalBlindPixel")
-//   11) MFillH("MHCalibrationChargeCam",      "MExtractedSignalCam")
-//   12) MFillH("MHCalibrationChargeCam",      "MExtractedSignalCam")
+//   9)  MFillH("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode",   "FillPINDiode")
+//   10) MFillH("MHCalibrationChargeBlindCam", "MExtractedSignalBlindPixel", "FillBlindCam")
+//   11) MFillH("MHCalibrationChargeCam",      "MExtractedSignalCam",        "FillChargeCam")
+//   12) MFillH("MHCalibrationChargeCam",      "MExtractedSignalCam",        "FillRelTime")
 //   13) MCalibrationChargeCalc
-//   14) MFillH("MHCalibrationRelTimeCam",     "MArrivalTimeCam") (only if flag fRelTimes is chosen)
+//   14) MFillH("MHCalibrationRelTimeCam",     "MArrivalTimeCam") (only if flag IsRelTimes() is chosen)
 //   15) MCalibrationRelTimeCalc
 // - Execute MEvtLoop
@@ -1507 +1541 @@
     plist.AddToList(&tlist);
     plist.AddToList(this); // take care of fDisplay!
-
-    MReadMarsFile read("Events");
-    MRawFileRead rawread(NULL);
 
     MDirIter iter;
@@ -1528 +1559 @@
     }
 
-    if (fDataCheck)
+    //
+    // Input containers
+    //
+    plist.AddToList(&pedcam);
+    plist.AddToList(&fBadPixels);
+
+    //
+    // Calibration Results containers
+    //
+    if (IsIntensity())
+      {
+        plist.AddToList(&fIntensQECam);
+        plist.AddToList(&fIntensCalibCam);
+        //        plist.AddToList(&fIntensCalibrationBlindCam);
+        //        plist.AddToList(&fIntensCalibrationPINDiode);
+        plist.AddToList(&fIntensRelTimeCam);
+      }
+    else
+      {
+        plist.AddToList(&fQECam);
+        plist.AddToList(&fCalibrationCam);
+        plist.AddToList(&fCalibrationBlindCam);
+        plist.AddToList(&fCalibrationPINDiode);
+        plist.AddToList(&fRelTimeCam);
+      }
+
+    //
+    // Initialize two histogram containers which could be modified in this class
+    //
+    MHCalibrationChargeCam      chargecam;
+    MHCalibrationChargeBlindCam blindcam;
+    plist.AddToList(&chargecam);
+    plist.AddToList(&blindcam);
+
+    //
+    // Data Reading tasks
+    //
+    MReadMarsFile read("Events");
+    MRawFileRead rawread(NULL);
+
+    if (IsDataCheck())
     {
         rawread.AddFiles(fSequence.IsValid() ? iter : *fRuns);
@@ -1540 +1611 @@
     }
 
-    MHCalibrationChargeCam      chargecam;
-    MHCalibrationChargeBlindCam blindcam;
-
-    plist.AddToList(&pedcam);
-    plist.AddToList(&chargecam);
-    plist.AddToList(&blindcam);
-    plist.AddToList(&fBadPixels);
-    plist.AddToList(&fQECam);
-    plist.AddToList(&fCalibrationCam);
-    plist.AddToList(&fCalibrationBlindCam);
-    plist.AddToList(&fCalibrationPINDiode);
-    plist.AddToList(&fRelTimeCam);
-
+    //
+    // Other Tasks
+    //
     MGeomApply               apply;
     apply.SetGeometry(fGeometry);
@@ -1572 +1633 @@
     }
 
-    if (fDebug)
+    if (IsDebug())
     {
         chargecam.SetDebug();
@@ -1579 +1640 @@
 
     //
-    // As long as there are no DM's, have to colour by hand
-    //
-    chargecam.SetColor    (fColor);
-    calcalc.SetPulserColor(fColor);
-
+    // Calibration histogramming
+    //
     MFillH fillpin("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode",   "FillPINDiode");
     MFillH fillbnd("MHCalibrationChargeBlindCam", "MExtractedSignalBlindPixel", "FillBlindCam");
@@ -1613 +1671 @@
     MContinue cont(&cosmics);
 
+    MTaskEnv taskenv("ExtractSignal");
+    taskenv.SetDefault(fExtractor ? fExtractor : &extract2);
+
     tlist.AddToList(&merge);
     tlist.AddToList(&apply);
-
-    MTaskEnv taskenv("ExtractSignal");
-    taskenv.SetDefault(fExtractor ? fExtractor : &extract2);
-
     tlist.AddToList(&taskenv);
     tlist.AddToList(&pinext);
@@ -1626 +1683 @@
     taskenv2.SetDefault(fTimeExtractor ? fTimeExtractor : &timespline);
 
-    if (fRelTimes)
+    if (IsRelTimes())
         tlist.AddToList(&taskenv2);
 
+    //
+    // FIXME: This is not yet implemented in the classes!!!
+    // 
     if (fColor == MCalibrationCam::kCT1)
         tlist.AddToList(&cont);
 
+    MCalibColorSet colorset;
+    tlist.AddToList(&colorset);
+
+    MCalibColorSteer steer;
+    if (IsIntensity())
+      tlist.AddToList(&steer);
+
     tlist.AddToList(&fillcam);
 
-    if (fRelTimes)
+    if (IsRelTimes())
     {
         tlist.AddToList(&filltme);
@@ -1662 +1729 @@
 
     if (!WriteTasks(taskenv.GetTask(), taskenv2.GetTask()))
-        return kFALSE;
+      return kFALSE;
 
     // Execute first analysis
@@ -1693 +1760 @@
     if (fDisplay)
     {
-        /*
       if (IsUsePINDiode())
         {
@@ -1706 +1772 @@
           cam->DrawClone(Form("nonew %s",drawoption.Data()));
         }
-      else if (fRelTimes)
+      else if (IsRelTimes())
         {
           MHCalibrationRelTimeCam *cam =
@@ -1713 +1779 @@
         }
       else
-        {
-          MHCalibrationChargeCam *cam =
-            (MHCalibrationChargeCam*)plist.FindObject("MHCalibrationChargeCam");
-          cam->DrawClone(Form("nonew %s",drawoption.Data()));
-        } */
+        chargecam.DrawClone(Form("nonew %s",drawoption.Data()));
     }
 
@@ -1896 +1958 @@
     *fLog << inf << "ok." << endl;
 
-    *fLog << inf << " - MCalibrationChargeCam..." << flush;
-    if (fCalibrationCam.Write()<=0)
-    {
-        *fLog << err << "Unable to write MCalibrationChargeCam to " << oname << endl;
-        return kFALSE;
-    }
-    *fLog << inf << "ok." << endl;
-
+    if (IsIntensity())
+      {
+        *fLog << inf << " - MCalibrationIntensityChargeCam..." << flush;
+        if (fIntensCalibCam.Write()<=0)
+          {
+            *fLog << err << "Unable to write MCalibrationIntensityChargeCam to " << oname << endl;
+            return kFALSE;
+          }
+        *fLog << inf << "ok." << endl;
+
+        *fLog << inf << " - MCalibrationIntensityQECam..." << flush;
+        if (fIntensQECam.Write()<=0)
+          {
+            *fLog << err << "Unable to write MCalibrationIntensityQECam to " << oname << endl;
+            return kFALSE;
+          }
+        *fLog << inf << "ok." << endl;
+      }
+    else
+      {
+        *fLog << inf << " - MCalibrationChargeCam..." << flush;
+        if (fCalibrationCam.Write()<=0)
+          {
+            *fLog << err << "Unable to write MCalibrationChargeCam to " << oname << endl;
+            return kFALSE;
+          }
+        *fLog << inf << "ok." << endl;
+
+        *fLog << inf << " - MCalibrationQECam..." << flush;
+        if (fQECam.Write()<=0)
+          {
+            *fLog << err << "Unable to write MCalibrationQECam to " << oname << endl;
+            return kFALSE;
+          }
+        *fLog << inf << "ok." << endl;
+      }
+    
     *fLog << inf << " - MCalibrationChargeBlindCam..." << flush;
     if (fCalibrationBlindCam.Write()<=0)
-    {
+      {
         *fLog << err << "Unable to write MCalibrationChargeBlindCam to " << oname << endl;
         return kFALSE;
-    }
+      }
     *fLog << inf << "ok." << endl;
-
+    
     *fLog << inf << " - MCalibrationChargePINDiode..." << flush;
     if (fCalibrationPINDiode.Write()<=0)
-    {
+      {
         *fLog << err << "Unable to write MCalibrationChargePINDiode to " << oname << endl;
-        return kFALSE;
-    }
-    *fLog << inf << "ok." << endl;
-
-    *fLog << inf << " - MCalibrationQECam..." << flush;
-    if (fQECam.Write()<=0)
-    {
-        *fLog << err << "Unable to write MCalibrationQECam to " << oname << endl;
         return kFALSE;
     }
@@ -1948 +2031 @@
     }
 
-    if (fRelTimes)
-    {
-        *fLog << inf << " - MCalibrationRelTimeCam..." << flush;
-        if (fRelTimeCam.Write()<=0)
-        {
-            *fLog << err << "Unable to write MCalibrationRelTimeCam to " << oname << endl;
-            return kFALSE;
-        }
-        *fLog << inf << "ok." << endl;
+    if (IsRelTimes())
+    {
+      if (IsIntensity())
+        {
+          *fLog << inf << " - MCalibrationIntensityRelTimeCam..." << flush;
+          if (fIntensRelTimeCam.Write()<=0)
+            {
+              *fLog << err << "Unable to write MCalibrationIntensityRelTimeCam to " << oname << endl;
+              return kFALSE;
+            }
+          *fLog << inf << "ok." << endl;
+        }
+      else
+        {
+          *fLog << inf << " - MCalibrationRelTimeCam..." << flush;
+          if (fRelTimeCam.Write()<=0)
+            {
+              *fLog << err << "Unable to write MCalibrationRelTimeCam to " << oname << endl;
+              return kFALSE;
+            }
+          *fLog << inf << "ok." << endl;
+        }
+      
     }
 
@@ -1972 +2069 @@
   outer[0] = 1;
           
-  TArrayI s0(6);
-  s0[0] = 6;
-  s0[1] = 1;
-  s0[2] = 2;
-  s0[3] = 3;
-  s0[4] = 4;
-  s0[5] = 5;
-  
   TArrayI s1(3);
   s1[0] = 6;
@@ -1994 +2083 @@
   
   TH1D *inout[2];
-  inout[0] = cam->ProjectionS(s0, inner, "Inner");
-  inout[1] = cam->ProjectionS(s0, outer, "Outer");
-  FixDataCheckHist(inout[0]);
-  FixDataCheckHist(inout[1]);
-  
-  inout[0]->SetTitle(Form("%s %s",cam->GetTitle(),"Inner"));
-  inout[1]->SetTitle(Form("%s %s",cam->GetTitle(),"Outer"));
-  
+
   for (int i=0; i<2; i++)
     {
@@ -2008 +2090 @@
       gPad->SetTicks();
       
+      inout[i] = cam->ProjectionS(TArrayI(), TArrayI(1,&i), i==0 ? "Inner" : "Outer");
+      FixDataCheckHist(inout[i]);
+      inout[i]->SetTitle(Form("%s %s",cam->GetTitle(),i==0 ? "Inner" : "Outer"));
       inout[i]->SetDirectory(NULL);
       inout[i]->SetLineColor(kRed+i);
       inout[i]->SetBit(kCanDelete);
       inout[i]->Draw();
-      inout[i]->Fit("gaus", "Q");
+      //
+      // Display the outliers as dead and noisy pixels
+      //
+      if (!inout[i]->Fit("gaus","0Q"))
+        DisplayOutliers(inout[i],whatsmall,whatbig);
+
       gPad->Modified();
       gPad->Update();      
@@ -2024 +2114 @@
 
       TLegend *leg2 = new TLegend(0.55,0.4,0.99,0.6);
-      //
-      // Display the outliers as dead and noisy pixels
-      //
-      DisplayOutliers(inout[i],whatsmall,whatbig);
       
       //
@@ -2033 +2119 @@
       //
       TH1D *half[2];
-      half[0] = cam->ProjectionS(s1, i==0 ? inner : outer , "Sector 6-1-2");
-      half[1] = cam->ProjectionS(s2, i==0 ? inner : outer , "Sector 3-4-5");
+      half[0] = cam->ProjectionS(s1, TArrayI(1,&i), "Sector 6-1-2");
+      half[1] = cam->ProjectionS(s2, TArrayI(1,&i), "Sector 3-4-5");
       
       for (int j=0; j<2; j++)

trunk/MagicSoft/Mars/mjobs/MJCalibration.h

@@ -4 +4 @@
 #ifndef MARS_MJob
 #include "MJob.h"
+#endif
+#ifndef MARS_MCalibrationIntensityChargeCam
+#include "MCalibrationIntensityChargeCam.h"
 #endif
 #ifndef MARS_MCalibrationChargeCam
@@ -14 +17 @@
 #include "MCalibrationChargePINDiode.h"
 #endif
+#ifndef MARS_MCalibrationIntensityRelTimeCam
+#include "MCalibrationIntensityRelTimeCam.h"
+#endif
 #ifndef MARS_MCalibrationRelTimeCam
 #include "MCalibrationRelTimeCam.h"
+#endif
+#ifndef MARS_MCalibrationIntensityQECam
+#include "MCalibrationIntensityQECam.h"
 #endif
 #ifndef MARS_MCalibrationQECam
@@ -41 +50 @@
 private:
 
-  static const Int_t gkIFAEBoxInaugurationRun;         //! Run number of first IFAE box calibration
-  static const Int_t gkSecondBlindPixelInstallation;   //! Run number upon which second blind pixel was installed
-  static const Int_t gkThirdBlindPixelInstallation;    //! Run number upon which third blind pixel was installed
+  static const Int_t gkIFAEBoxInaugurationRun;          //! Run number of first IFAE box calibration
+  static const Int_t gkSecondBlindPixelInstallation;    //! Run number upon which second blind pixel was installed
+  static const Int_t gkThirdBlindPixelInstallation;     //! Run number upon which third blind pixel was installed
 
-  static const Double_t fgConvFADC2PheMin;             //! Histogram minimum for conversion factor to phes
-  static const Double_t fgConvFADC2PheMax;             //! Histogram maximum for conversion factor to phes
-  static const Double_t fgConvFADC2PhotMin;            //! Histogram minimum for conversion factor to phs
-  static const Double_t fgConvFADC2PhotMax;            //! Histogram maixmum for conversion factor to phs
-  static const Double_t fgQEMin;                       //! Histogram minimum for quantum efficiency
-  static const Double_t fgQEMax;                       //! Histogram maximum for quantum efficiency
-  static const Double_t fgArrivalTimeMin;              //! Histogram minimum for arrival times 
-  static const Double_t fgArrivalTimeMax;              //! Histogram maximum for arrival times
+  static const Double_t fgConvFADC2PheMin;              //! Histogram minimum for conversion factor to phes
+  static const Double_t fgConvFADC2PheMax;              //! Histogram maximum for conversion factor to phes
+  static const Double_t fgConvFADC2PhotMin;             //! Histogram minimum for conversion factor to phs
+  static const Double_t fgConvFADC2PhotMax;             //! Histogram maixmum for conversion factor to phs
+  static const Double_t fgQEMin;                        //! Histogram minimum for quantum efficiency
+  static const Double_t fgQEMax;                        //! Histogram maximum for quantum efficiency
+  static const Double_t fgArrivalTimeMin;               //! Histogram minimum for arrival times 
+  static const Double_t fgArrivalTimeMax;               //! Histogram maximum for arrival times
   
-  static const Float_t  fgRefConvFADC2PheInner;        //! Reference value for the conversion factor to phes - inner
-  static const Float_t  fgRefConvFADC2PheOuter;        //! Reference value for the conversion factor to phes - outer
-  static const Float_t  fgRefConvFADC2PhotInner;       //! Reference value for the conversion factor to phs - inner
-  static const Float_t  fgRefConvFADC2PhotOuter;       //! Reference value for the conversion factor to phs - outer
-  static const Float_t  fgRefQEInner;                  //! Reference value for the quantum eff. cascades - inner
-  static const Float_t  fgRefQEOuter;                  //! Reference value for the quantum eff. cascades - outer
-  static const Float_t  fgRefArrivalTimeInner;         //! Reference value for the arrival time - inner
-  static const Float_t  fgRefArrivalTimeOuter;         //! Reference value for the arrival time - outer
-  static const Float_t  fgRefArrivalTimeRmsInner;      //! Reference value for the arrival time - inner
-  static const Float_t  fgRefArrivalTimeRmsOuter;      //! Reference value for the arrival time - outer
+  static const Float_t  fgRefConvFADC2PheInner;         //! Reference value for the conversion factor to phes - inner
+  static const Float_t  fgRefConvFADC2PheOuter;         //! Reference value for the conversion factor to phes - outer
+  static const Float_t  fgRefConvFADC2PhotInner;        //! Reference value for the conversion factor to phs - inner
+  static const Float_t  fgRefConvFADC2PhotOuter;        //! Reference value for the conversion factor to phs - outer
+  static const Float_t  fgRefQEInner;                   //! Reference value for the quantum eff. cascades - inner
+  static const Float_t  fgRefQEOuter;                   //! Reference value for the quantum eff. cascades - outer
+  static const Float_t  fgRefArrivalTimeInner;          //! Reference value for the arrival time - inner
+  static const Float_t  fgRefArrivalTimeOuter;          //! Reference value for the arrival time - outer
+  static const Float_t  fgRefArrivalTimeRmsInner;       //! Reference value for the arrival time - inner
+  static const Float_t  fgRefArrivalTimeRmsOuter;       //! Reference value for the arrival time - outer
 
-  MRunIter       *fRuns;                               // Calibration files
+  MRunIter       *fRuns;                                // Calibration files
   
-  MExtractor     *fExtractor;                          // Signal extractor
-  MExtractTime   *fTimeExtractor;                      // Arrival Time extractor
+  MExtractor     *fExtractor;                           // Signal extractor
+  MExtractTime   *fTimeExtractor;                       // Arrival Time extractor
   
-  MBadPixelsCam              fBadPixels;               // Bad Pixels cam, can be set from previous runs
-  MCalibrationChargeCam      fCalibrationCam;          // Calibration conversion factors FADC2Phe
-  MCalibrationChargeBlindCam fCalibrationBlindCam;     // Calibration from Blind Pixel(s)
-  MCalibrationChargePINDiode fCalibrationPINDiode;     // Calibration from PIN Diode
-  MCalibrationQECam          fQECam;                   // Quantum efficiency, can be set from previous runs
-  MCalibrationRelTimeCam     fRelTimeCam;              // Calibration constants rel. times
+  MBadPixelsCam                   fBadPixels;           // Bad Pixels cam, can be set from previous runs
+  MCalibrationIntensityChargeCam  fIntensCalibCam;      // Calibration conversion factors FADC2Phe for diff. intens.
+  MCalibrationChargeCam           fCalibrationCam;      // Calibration conversion factors FADC2Phe  
+  MCalibrationChargeBlindCam      fCalibrationBlindCam; // Calibration from Blind Pixel(s)
+  MCalibrationChargePINDiode      fCalibrationPINDiode; // Calibration from PIN Diode
+  MCalibrationIntensityQECam      fIntensQECam;         // Quantum efficiency for diff. intensities, 
+  MCalibrationQECam               fQECam;               // Quantum efficiency, can be set from previous runs
+  MCalibrationIntensityRelTimeCam fIntensRelTimeCam;    // Calibration constants rel. times for diff. intensities
+  MCalibrationRelTimeCam          fRelTimeCam;          // Calibration constants rel. times
   
-  MCalibrationCam::PulserColor_t fColor;               // Colour of the pulsed LEDs
+  MCalibrationCam::PulserColor_t fColor;                // Colour of the pulsed LEDs
   
-  enum  Display_t                                      // Possible Display types
+  enum  Display_t                                       // Possible Display types
     {
       kFullDisplay,
@@ -96 +108 @@
   Byte_t fDevices;                                     // Bit-field for used devices for calibration
 
-  // Combine these options into a single bit-files (TestBit/SetBit, etc)
-  Bool_t fRelTimes;                                    // Flag if relative times have to be calibrated
-  Bool_t fDataCheck;                                   // Flag if the data check is run on raw data
-  Bool_t fDebug;                                       // Flag if debug option is passed onto cal. classes
+  enum { kRelTimes, kDataCheck, kDebug, kIntensity };  // Possible flags
 
-  TString fGeometry;
+  Byte_t fFlags;                                       // Bit-field for the flags
+  
+  TString fGeometry;                                   // Class name geometry
   
   void   DisplayResult        ( MParList &plist );
@@ -110 +121 @@
   void   FixDataCheckHist     ( TH1D     *hist  ) const;
   
-  Bool_t WriteResult(TObject *geom);
-  Bool_t WriteEventloop(MEvtLoop &evtloop) const;
-  Bool_t WriteTasks(MTask *t1, MTask *t2) const;
-  Bool_t CheckEnvLocal();
+  Bool_t WriteResult   ( TObject *geom );
+  Bool_t WriteEventloop( MEvtLoop &evtloop   ) const;
+  Bool_t WriteTasks    ( MTask *t1, MTask *t2) const;
+  Bool_t CheckEnvLocal ();
   
   // WORKAROUNDS!!!
@@ -125 +136 @@
   const char* GetOutputFile() const;
   
-  MCalibrationChargeCam  &GetCalibrationCam() { return fCalibrationCam; }
-  MCalibrationRelTimeCam &GetRelTimeCam()     { return fRelTimeCam;     }
-  MCalibrationQECam      &GetQECam()          { return fQECam;          }
-  MBadPixelsCam          &GetBadPixels()      { return fBadPixels;      }
+  MCalibrationIntensityChargeCam  &GetIntensCalibrationCam() { return fIntensCalibCam;   }
+  MCalibrationIntensityRelTimeCam &GetIntensRelTimeCam()     { return fIntensRelTimeCam; }
+  MCalibrationIntensityQECam      &GetIntensQECam()          { return fIntensQECam;      }
+
+  MCalibrationChargeCam           &GetCalibrationCam()       { return fCalibrationCam;   }
+  MCalibrationRelTimeCam          &GetRelTimeCam()           { return fRelTimeCam;       }
+  MCalibrationQECam               &GetQECam()                { return fQECam;            }
+  MBadPixelsCam                   &GetBadPixels()            { return fBadPixels;        }
   
   Bool_t IsUseBlindPixel() const;
-  Bool_t IsUsePINDiode()   const;
+  Bool_t IsUsePINDiode  () const;
+
+  Bool_t IsRelTimes     () const { return TESTBIT(fFlags,kRelTimes);  }
+  Bool_t IsDataCheck    () const { return TESTBIT(fFlags,kDataCheck); }
+  Bool_t IsDebug        () const { return TESTBIT(fFlags,kDebug);     }
+  Bool_t IsIntensity    () const { return TESTBIT(fFlags,kIntensity); }
   
-  void SetBadPixels(const MBadPixelsCam &bad)    { bad.Copy(fBadPixels);   }
-  void SetExtractor(MExtractor* ext)             { fExtractor = ext; }
-  void SetTimeExtractor(MExtractTime* ext)       { fTimeExtractor = ext; }
-  void SetQECam(const MCalibrationQECam &qe)     { qe.Copy(fQECam);        }
-  void SetColor(const MCalibrationCam::PulserColor_t color) { fColor = color; }
-  void SetInput(MRunIter *iter) { fRuns = iter; }
+  void SetBadPixels(const MBadPixelsCam &bad)               { bad.Copy(fBadPixels); }
+  void SetExtractor(MExtractor* ext)                        { fExtractor = ext;     }
+  void SetTimeExtractor(MExtractTime* ext)                  { fTimeExtractor = ext; }
+  void SetQECam(const MCalibrationQECam &qe)                { qe.Copy(fQECam);      }
+  void SetColor(const MCalibrationCam::PulserColor_t color) { fColor = color;       }
+  void SetInput(MRunIter *iter)                             { fRuns = iter;         }
     
   // Displays
@@ -148 +168 @@
   void SetGeometry(const char *geom) { fGeometry = geom; }
   
-  // Rel. Time
-  void SetRelTimeCalibration(const Bool_t b=kTRUE) { fRelTimes = b; }
-  
-  // Data Check
-  void SetDataCheck(const Bool_t b=kTRUE) { fDataCheck = b; SetDataCheckDisplay(); }
-  
-  // Debug
-  void SetDebug(const Bool_t b=kTRUE) { fDebug = b; }
+  // Flags
+  void SetRelTimeCalibration( const Bool_t b=kTRUE ) { b ? SETBIT(fFlags,kRelTimes)  : CLRBIT(fFlags,kRelTimes); }
+  void SetDataCheck         ( const Bool_t b=kTRUE ) { b ? SetDataCheckDisplay(), SETBIT(fFlags,kDataCheck)
+                                                                                     : CLRBIT(fFlags,kDataCheck); }
+  void SetDebug             ( const Bool_t b=kTRUE ) { b ? SETBIT(fFlags,kDebug)     : CLRBIT(fFlags,kDebug); }
+  void SetIntensity         ( const Bool_t b=kTRUE ) { b ? SETBIT(fFlags,kIntensity) : CLRBIT(fFlags,kIntensity); }
   
   // Devices