Index: /trunk/MagicSoft/Mars/Changelog
===================================================================
--- /trunk/MagicSoft/Mars/Changelog	(revision 4907)
+++ /trunk/MagicSoft/Mars/Changelog	(revision 4908)
@@ -72,4 +72,9 @@
    * mcalib/MHCalibrationTestTimeCam.cc
      - able to recognize an *Intensity*Cam if in MParList
+
+   * mcalib/MCalibrationChargeCalc.[h,cc]
+   * mcalib/MCalibrationRelTimeCalc.[h,cc]
+     - able to recognize an *Intensity*Cam if in MParList
+     - set pulser pattern accordingly in Process from MRawEvtHeader     
 
    * msignal/MExtractor.cc
Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 4907)
+++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 4908)
@@ -194,6 +194,5 @@
 #include "MParList.h"
 
-#include "MRawRunHeader.h"
-#include "MRawEvtPixelIter.h"
+#include "MRawEvtHeader.h"
 
 #include "MGeomCam.h"
@@ -203,4 +202,6 @@
 #include "MPedestalCam.h"
 #include "MPedestalPix.h"
+
+#include "MCalibrationIntensityChargeCam.h"
 
 #include "MCalibrationChargeCam.h"
@@ -260,5 +261,5 @@
 //
 MCalibrationChargeCalc::MCalibrationChargeCalc(const char *name, const char *title)
-    : fQECam(NULL), fGeom(NULL)
+    : fQECam(NULL), fGeom(NULL), fSignal(NULL), fHeader(NULL)
 {
         
@@ -307,4 +308,5 @@
     fBadPixels  = NULL;
     fCam        = NULL;
+    fIntensCam  = NULL;
     fBlindPixel = NULL;
     fBlindCam   = NULL;
@@ -312,4 +314,5 @@
     fPedestals  = NULL;
 
+    fPulserPattern = 0;
     SetPulserColor ( MCalibrationCam::kNONE );
     
@@ -333,4 +336,11 @@
 {
   
+  fHeader = (MRawEvtHeader*)pList->FindObject("MRawEvtHeader");
+  if (!fHeader)
+    {
+      *fLog << err << "MRawEvtHeader not found... abort." << endl;
+      return kFALSE;
+    }
+
   // 
   // Containers that have to be there.
@@ -343,4 +353,11 @@
     }
   
+  fSignal = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
+  if (!fSignal)
+    {
+      *fLog << err << "MExtractedSignalCam not found... aborting" << endl;
+      return kFALSE;
+    }
+  
   // 
   // Containers that are created in case that they are not there.
@@ -360,18 +377,12 @@
     }
 
-  
-  //
-  // Check the pulser colour --> FIXME: this solution is only valid until the arrival of the DM's
-  //
-  if (fPulserColor == MCalibrationCam::kNONE)
-    {
-      *fLog << endl;
-      *fLog << err << GetDescriptor()
-            << ": No Pulser colour has been chosen. Since the installation of the IFAE pulser box,"
-            << " you HAVE to provide the LEDs colour, otherwise there is no calibration. " << endl;
-      *fLog << "See e.g. the macro calibration.C " << endl;
+  fHeader = (MRawEvtHeader*)pList->FindObject("MRawEvtHeader");
+  if (!fHeader)
+    {
+      *fLog << err << "MRawEvtHeader not found... abort." << endl;
       return kFALSE;
     }
-  
+
+
   return kTRUE;
 }
@@ -395,4 +406,5 @@
 // It defines the PixId of every pixel in:
 //
+// - MCalibrationIntensityChargeCam 
 // - MCalibrationChargeCam 
 // - MCalibrationQECam
@@ -419,12 +431,18 @@
     }
   
-  fCam = (MCalibrationChargeCam*)pList->FindObject("MCalibrationChargeCam");
-  if (!fCam)
-    {
-      *fLog << err << "Cannot find MCalibrationChargeCam... aborting" << endl;
-      *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
-      return kFALSE;
-    }
-
+  fIntensCam = (MCalibrationIntensityChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationIntensityChargeCam"));
+  if (fIntensCam)
+    *fLog << inf << "Found MCalibrationIntensityChargeCam ... " << endl;
+  else
+    {
+      fCam = (MCalibrationChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationChargeCam"));
+      if (!fCam)
+        {
+          *fLog << err << "Cannot find MCalibrationChargeCam ... abort." << endl;
+          *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
+          return kFALSE;
+        }
+    }
+  
   // 
   // Optional Containers 
@@ -451,60 +469,6 @@
     }
   
-
-  //
-  // Initialize the pulser colours
-  //
-  if (fCam->GetPulserColor() == MCalibrationCam::kNONE)
-    {
-      fCam->SetPulserColor( fPulserColor );
-      
-      if (fBlindPixel)
-        fBlindPixel->SetColor( fPulserColor );
-      
-      if (fBlindCam)
-        fBlindCam->SetColor( fPulserColor );
-      
-      if (fPINDiode)
-        fPINDiode->SetColor( fPulserColor );
-    }
-
-  if (fPulserColor != fCam->GetPulserColor())
-    {
-      *fLog << err << GetDescriptor() 
-            << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeCam" << endl;
-      *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
-      return kFALSE;
-    }
-
-  if (fBlindPixel)
-    if (fPulserColor != fBlindPixel->GetColor())
-      {
-        *fLog << err << GetDescriptor() 
-              << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeBlindPix." << endl;
-        *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
-        return kFALSE;
-      }
-
-  if (fBlindCam)
-    if (fPulserColor != fBlindCam->GetColor())
-      {
-        *fLog << err << GetDescriptor() 
-              << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeBlindCam." << endl;
-        *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
-        return kFALSE;
-      }
-  
-  if (fPINDiode)
-    if (fPulserColor != fPINDiode->GetColor())
-      {
-        *fLog << err << GetDescriptor() 
-              << ": Pulser colour has changed w.r.t. last file in MCalibrationChargePINDiode." << endl;
-        *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
-        return kFALSE;
-      }
-  
-
-  fNumHiGainSamples  =  fCam->GetNumHiGainFADCSlices();
-  fNumLoGainSamples  =  fCam->GetNumLoGainFADCSlices();
+  fNumHiGainSamples  =  fSignal->GetNumUsedHiGainFADCSlices();
+  fNumLoGainSamples  =  fSignal->GetNumUsedLoGainFADCSlices();
 
   fSqrtHiGainSamples =  TMath::Sqrt(fNumHiGainSamples);
@@ -516,5 +480,7 @@
     {
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)  [i];
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)      [i];
       MCalibrationQEPix     &pqe = (MCalibrationQEPix&)    (*fQECam)[i];
       MBadPixelsPix         &bad = (*fBadPixels)[i];
@@ -539,8 +505,114 @@
 // ----------------------------------------------------------------------------------
 //  
-// Nothing to be done in Process, but have a look at MHCalibrationChargeCam, instead
+// Set the correct colour to the charge containers
 // 
 Int_t MCalibrationChargeCalc::Process()
 {
+
+  const UInt_t pattern = fHeader->GetCalibrationPattern();
+
+  if (pattern == fPulserPattern)
+    return kTRUE;
+
+  enum ColorCode_t 
+    {
+      kSlot1Green     = BIT(0),
+      kSlot2Green     = BIT(1),
+      kSlot3Blue      = BIT(2),
+      kSlot4UV        = BIT(3),
+      kSlot5UV        = BIT(4),
+      kSlot6Blue      = BIT(5),
+      kSlot7Blue      = BIT(6),
+      kSlot8Blue      = BIT(7),
+      kSlot9AttBlue   = BIT(8),
+      kSlot10Blue     = BIT(9),
+      kSlot11Blue     = BIT(10),
+      kSlot12UV       = BIT(11),
+      kSlot13UV       = BIT(12),
+      kSlot14Blue     = BIT(13),
+      kSlot15Green    = BIT(14),
+      kSlot16AttGreen = BIT(15),
+      kCT1Pulser      = BIT(16),
+      kAnyGreen       = kSlot1Green  | kSlot2Green | kSlot15Green | kSlot16AttGreen,
+      kAnyUV          = kSlot4UV     | kSlot5UV    | kSlot12UV    | kSlot13UV,
+      kAnyBlue        = kSlot3Blue   | kSlot6Blue  | kSlot7Blue   | kSlot8Blue 
+                      | kSlot9AttBlue| kSlot10Blue | kSlot11Blue  | kSlot14Blue 
+    };
+
+  //
+  // The pattern has changed, we have to initialize everything new!!!
+  //
+  *fLog << inf << " New pulser pattern: " ;
+  for (Int_t i=16; i>= 0; i--)
+    *fLog << (pattern >> i & 1);
+  *fLog  << endl;
+  fPulserPattern = pattern;
+  
+  //
+  // Now retrieve the colour and check if not various colours have been used
+  //
+  fPulserColor = MCalibrationCam::kNONE;
+  
+  if (fPulserPattern & kAnyGreen )
+    fPulserColor = MCalibrationCam::kGREEN;
+  
+  if (fPulserPattern & kAnyBlue )
+    if (fPulserColor != MCalibrationCam::kNONE)
+      {
+        *fLog << err << GetDescriptor() 
+              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
+        return kCONTINUE;
+      }
+    else
+      fPulserColor = MCalibrationCam::kBLUE;
+  
+  if (fPulserPattern & kAnyUV )
+    if (fPulserColor != MCalibrationCam::kNONE)
+      {
+        *fLog << err << GetDescriptor() 
+              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
+        return kCONTINUE;
+      }
+    else
+      fPulserColor = MCalibrationCam::kUV;
+  
+  if (fPulserPattern & kCT1Pulser )
+    if (fPulserColor != MCalibrationCam::kNONE)
+      {
+        *fLog << err << GetDescriptor() 
+              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
+        return kCONTINUE;
+      }
+    else
+      fPulserColor = MCalibrationCam::kCT1;
+  
+  *fLog << inf << GetDescriptor() << ": Found new colour ... " << endl;
+  
+  switch (fPulserColor)
+    {
+    case MCalibrationCam::kGREEN: *fLog << "Green.";  break;
+    case MCalibrationCam::kBLUE:  *fLog << "Blue.";   break;
+    case MCalibrationCam::kUV:    *fLog << "UV.";     break;
+    case MCalibrationCam::kCT1:   *fLog << "CT1.";    break;
+    }
+  *fLog << endl;
+  
+  //
+  // Initialize the pulser colours
+  //
+  if (fIntensCam)
+    fIntensCam->SetPulserColor( fPulserColor );
+  else
+    fCam->SetPulserColor( fPulserColor );
+  
+  if (fBlindPixel)
+    fBlindPixel->SetColor( fPulserColor );
+  
+  if (fBlindCam)
+    fBlindCam->SetColor( fPulserColor );
+  
+  if (fPINDiode)
+    fPINDiode->SetColor( fPulserColor );
+
   return kTRUE;
 }
@@ -570,5 +642,5 @@
 // Call  FinalizeUnsuitablePixels()
 //  
-// Call MParContainer::SetReadyToSave() for fCam, fQECam, fBadPixels and 
+// Call MParContainer::SetReadyToSave() for fIntensCam, fCam, fQECam, fBadPixels and 
 //                                          fBlindPixel and fPINDiode if they exist
 //
@@ -608,5 +680,7 @@
     {
 
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[pixid];
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[pixid]
+        : (MCalibrationChargePix&)(*fCam)[pixid];
       //
       // Check if the pixel has been excluded from the fits
@@ -643,8 +717,12 @@
 
       const MPedestalPix     &ped = fPedestals->GetAverageArea(aidx);
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+      MCalibrationChargePix &pix = fIntensCam
+        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
+        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
 
       FinalizePedestals(ped,pix,aidx);
-      FinalizeCharges(pix, fCam->GetAverageBadArea(aidx),"area id");
+      FinalizeCharges(pix, 
+                      fIntensCam ? fIntensCam->GetAverageBadArea(aidx) : fCam->GetAverageBadArea(aidx),
+                      "area id");
     }
   
@@ -656,5 +734,7 @@
       const MPedestalPix     &ped = fPedestals->GetAverageSector(sector);
 
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
+        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
       FinalizePedestals(ped,pix, 0);
     }
@@ -673,9 +753,15 @@
     {
       *fLog << warn << "Could not calculate the photons flux from the F-Factor method " << endl;
-      fCam->SetFFactorMethodValid(kFALSE); 
+      if (fIntensCam)
+        fIntensCam->SetFFactorMethodValid(kFALSE); 
+      else
+        fCam->SetFFactorMethodValid(kFALSE); 
       return kFALSE;
     }
   else
-    fCam->SetFFactorMethodValid(kTRUE);
+    if (fIntensCam)
+      fIntensCam->SetFFactorMethodValid(kTRUE);
+    else
+      fCam->SetFFactorMethodValid(kTRUE);
   
   *fLog << endl;
@@ -721,5 +807,9 @@
   FinalizeUnsuitablePixels();
 
-  fCam      ->SetReadyToSave();
+  if (fIntensCam)
+    fIntensCam->SetReadyToSave();
+  else
+    fCam      ->SetReadyToSave();
+
   fQECam    ->SetReadyToSave();
   fBadPixels->SetReadyToSave();
@@ -923,5 +1013,5 @@
       
       MBadPixelsPix    &bad    = (*fBadPixels)[i];
-      MCalibrationPix  &pix    = (*fCam)[i];
+      MCalibrationPix  &pix    = fIntensCam ? (*fIntensCam)[i] : (*fCam)[i];
 
       if (bad.IsUncalibrated( MBadPixelsPix::kChargeIsPedestal))
@@ -990,7 +1080,7 @@
 {
 
-  const UInt_t npixels  = fGeom->GetNumPixels();
-  const UInt_t nareas   = fGeom->GetNumAreas();
-  const UInt_t nsectors = fGeom->GetNumSectors();
+  const Int_t npixels  = fGeom->GetNumPixels();
+  const Int_t nareas   = fGeom->GetNumAreas();
+  const Int_t nsectors = fGeom->GetNumSectors();
 
   TArrayF lowlim        (nareas);
@@ -1010,8 +1100,10 @@
   MHCamera camphes(*fGeom,"Camphes","Phes in Camera");
 
-  for (UInt_t i=0; i<npixels; i++)
-    {
-      
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)  [i];
+  for (Int_t i=0; i<npixels; i++)
+    {
+      
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)  [i];
       MBadPixelsPix         &bad = (*fBadPixels)[i];
       
@@ -1039,5 +1131,5 @@
     } 
 
-  for (UInt_t i=0; i<nareas; i++)
+  for (Int_t i=0; i<nareas; i++)
     {
       if (numareavalid[i] == 0)
@@ -1071,8 +1163,5 @@
       upplim  [i] = areaphes[i] + fPheErrLimit*TMath::Sqrt(areavars[i]);
 
-      TArrayI area(1);
-      area[0] = i;
-
-      TH1D *hist = camphes.ProjectionS(TArrayI(),area,"_py",100);
+      TH1D *hist = camphes.ProjectionS(TArrayI(),TArrayI(1,&i),"_py",100);
       hist->Fit("gaus","Q");
       const Float_t mean  = hist->GetFunction("gaus")->GetParameter(1);
@@ -1081,5 +1170,5 @@
 
       if (IsDebug())
-        camphes.DrawClone();
+        hist->DrawClone();
 
       if (ndf < 2)
@@ -1126,8 +1215,10 @@
   //              Set the conversion factor FADC counts to photo-electrons
   // 
-  for (UInt_t i=0; i<npixels; i++)
-    {
-      
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+  for (Int_t i=0; i<npixels; i++)
+    {
+      
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];
 
       if (!pix.IsFFactorMethodValid())
@@ -1177,8 +1268,10 @@
   *fLog << endl;
 
-  for (UInt_t aidx=0; aidx<nareas; aidx++)
-    {
-
-      MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+  for (Int_t aidx=0; aidx<nareas; aidx++)
+    {
+
+      MCalibrationChargePix &apix = fIntensCam 
+        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
+        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
 
       if (numareavalid[aidx] == 1)
@@ -1218,5 +1311,5 @@
   *fLog << endl;
 
-  for (UInt_t sector=0; sector<nsectors; sector++)
+  for (Int_t sector=0; sector<nsectors; sector++)
     {
 
@@ -1237,5 +1330,7 @@
         }
       
-      MCalibrationChargePix &spix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
+      MCalibrationChargePix &spix = fIntensCam 
+        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
+        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
 
       if (sectorweights[sector] < 0. || sectorphes[sector] <= 0.)
@@ -1264,8 +1359,10 @@
   //             only excluded as: MBadPixelsPix::kChargeSigmaNotValid 
   // 
-  for (UInt_t i=0; i<npixels; i++)
-    {
-      
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+  for (Int_t i=0; i<npixels; i++)
+    {
+      
+      MCalibrationChargePix &pix = fIntensCam
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];
       MBadPixelsPix         &bad = (*fBadPixels)[i];
 
@@ -1276,5 +1373,7 @@
         {
           const Int_t            aidx = (*fGeom)[i].GetAidx();
-          MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
+          MCalibrationChargePix &apix = fIntensCam
+            ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
+            : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
           pix.SetPheFFactorMethod   ( apix.GetPheFFactorMethod()    );
           pix.SetPheFFactorMethodVar( apix.GetPheFFactorMethodVar() );
@@ -1417,9 +1516,15 @@
 
   const Float_t photons = flux * (*fGeom)[0].GetA() / fQECam->GetPlexiglassQE();
-  fCam->SetNumPhotonsBlindPixelMethod(photons);
+  if (fIntensCam)
+    fIntensCam->SetNumPhotonsBlindPixelMethod(photons);
+  else
+    fCam->SetNumPhotonsBlindPixelMethod(photons);
   
   const Float_t photrelvar = fluxvar / flux / flux + fQECam->GetPlexiglassQERelVar();
   if (photrelvar > 0.)
-    fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
+    if (fIntensCam)
+      fIntensCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
+    else
+      fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
 
   return kTRUE;
@@ -1529,5 +1634,7 @@
     }
   
-  MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCam->GetAverageArea(0);
+  MCalibrationChargePix &avpix = fIntensCam 
+    ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(0)
+    : (MCalibrationChargePix&)fCam->GetAverageArea(0);
   MCalibrationQEPix     &qepix = (MCalibrationQEPix&)  fQECam->GetAverageArea(0);  
 
@@ -1549,7 +1656,14 @@
   // Set the results in the MCalibrationChargeCam
   //
-  fCam->SetNumPhotonsFFactorMethod   (avphotons);
+  if (fIntensCam)
+    fIntensCam->SetNumPhotonsFFactorMethod   (avphotons);
+  else
+    fCam->SetNumPhotonsFFactorMethod   (avphotons);
+
   if (avphotrelvar > 0.)
-    fCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));  
+    if (fIntensCam)
+      fIntensCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));  
+    else
+      fCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));  
 
   TArrayF lowlim           (nareas);
@@ -1566,5 +1680,7 @@
     {
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = fIntensCam
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];
       MCalibrationQEPix   &qepix = (MCalibrationQEPix&)  (*fQECam)[i];
       MBadPixelsPix         &bad =                   (*fBadPixels)[i];
@@ -1681,5 +1797,7 @@
     {
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];
       MBadPixelsPix         &bad =                   (*fBadPixels)[i];
 
@@ -1704,5 +1822,7 @@
     {
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = fIntensCam 
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];
       MCalibrationQEPix   &qepix = (MCalibrationQEPix&)  (*fQECam)[i];
       MBadPixelsPix         &bad =                   (*fBadPixels)[i];
@@ -1752,10 +1872,16 @@
           const Float_t photons = fBlindPixel->GetFluxInsidePlexiglass() * (*fGeom)[0].GetA()
                                / fQECam->GetPlexiglassQE();
-          fCam->SetNumPhotonsBlindPixelMethod(photons);
+          if (fIntensCam)
+            fCam->SetNumPhotonsBlindPixelMethod(photons);
+          else
+            fCam->SetNumPhotonsBlindPixelMethod(photons);
 
           const Float_t photrelvar = fBlindPixel->GetFluxInsidePlexiglassRelVar() 
                                    + fQECam->GetPlexiglassQERelVar();
           if (photrelvar > 0.)
-            fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
+            if (fIntensCam)
+              fIntensCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
+            else
+              fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));  
         }
     }
@@ -1788,5 +1914,7 @@
         }
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = fIntensCam
+        ? (MCalibrationChargePix&)(*fIntensCam)[i]
+        : (MCalibrationChargePix&)(*fCam)[i];        
       MGeomPix              &geo =                        (*fGeom)[i];
       
@@ -1861,5 +1989,7 @@
         }
       
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
+      MCalibrationChargePix &pix = fIntensCam 
+        ?  (MCalibrationChargePix&)(*fIntensCam)[i]      
+        :  (MCalibrationChargePix&)(*fCam)[i];
       MGeomPix              &geo =                        (*fGeom)[i];
       
@@ -1910,5 +2040,5 @@
 //
 // - Print out statistics about BadPixels of type UnsuitableType_t 
-// - store numbers of bad pixels of each type in fCam
+// - store numbers of bad pixels of each type in fCam or fIntensCam
 //
 void MCalibrationChargeCalc::FinalizeUnsuitablePixels()
@@ -1950,5 +2080,8 @@
 
   for (Int_t aidx=0; aidx<nareas; aidx++)
-    fCam->SetNumUnsuitable(counts[aidx], aidx);
+    if (fIntensCam)
+      fIntensCam->SetNumUnsuitable(counts[aidx], aidx);
+    else
+      fCam->SetNumUnsuitable(counts[aidx], aidx);
 
   if (fGeom->InheritsFrom("MGeomCamMagic"))
@@ -1969,5 +2102,8 @@
 
   for (Int_t aidx=0; aidx<nareas; aidx++)
-    fCam->SetNumUnreliable(counts[aidx], aidx);
+    if (fIntensCam)
+      fIntensCam->SetNumUnreliable(counts[aidx], aidx);
+    else
+      fCam->SetNumUnreliable(counts[aidx], aidx);
 
   *fLog << " " << setw(7) << "Unreliable Pixels:              "
Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.h
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.h	(revision 4907)
+++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.h	(revision 4908)
@@ -27,6 +27,5 @@
 #endif
 
-class MRawEvtData;
-class MRawRunHeader;
+class MRawEvtHeader;
 class MPedestalCam;
 class MPedestalPix;
@@ -36,9 +35,8 @@
 class MCalibrationChargePix;
 class MCalibrationChargeCam;
+class MCalibrationIntensityChargeCam;
 class MCalibrationQECam;
 class MGeomCam;
 class MExtractedSignalCam;
-class MExtractedSignalBlindPixel;
-class MExtractedSignalPINDiode;
 class MBadPixelsCam;
 class MTime;
@@ -68,5 +66,8 @@
   Float_t fSqrtHiGainSamples;                  // Square root nr. High-Gain FADC slices used by extractor
   Float_t fSqrtLoGainSamples;                  // Square root nr. Low -Gain FADC slices used by extractor 
+
   MCalibrationCam::PulserColor_t fPulserColor; // Calibration LEDs colour 
+  UInt_t  fPulserPattern;                      // Calibration LEDs Pulser Pattern
+
   Int_t   fNumInnerFFactorMethodUsed;          // Number of inner pixels used for F-Factor Method calibration
 
@@ -80,5 +81,6 @@
   
   // Pointers
-  MBadPixelsCam              *fBadPixels;      //  Bad Pixels 
+  MBadPixelsCam              *fBadPixels;      //  Bad Pixels
+  MCalibrationIntensityChargeCam *fIntensCam;  //  Calibrated Charges of all pixels   
   MCalibrationChargeCam      *fCam;            //  Calibrated Charges of all pixels 
   MCalibrationChargeBlindPix *fBlindPixel;     //  Calibrated Charges of the Blind Pixel 
@@ -87,4 +89,6 @@
   MCalibrationQECam          *fQECam;          //  Calibrated Quantum Efficiencies of all pixels 
   MGeomCam                   *fGeom;           //! Camera geometry
+  MExtractedSignalCam        *fSignal;         //! Extracted Signal
+  MRawEvtHeader              *fHeader;         //! Event header
   MPedestalCam               *fPedestals;      //! Pedestals all pixels (calculated previously from ped.file)
 
Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.cc
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.cc	(revision 4907)
+++ /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.cc	(revision 4908)
@@ -61,4 +61,6 @@
 #include "MGeomPix.h"
 
+#include "MCalibrationIntensityRelTimeCam.h"
+
 #include "MCalibrationRelTimeCam.h"
 #include "MCalibrationRelTimePix.h"
@@ -72,5 +74,5 @@
 using namespace std;
 
-const Float_t MCalibrationRelTimeCalc::fgRelTimeResolutionLimit = 0.75;
+const Float_t MCalibrationRelTimeCalc::fgRelTimeResolutionLimit = 1.0;
 // --------------------------------------------------------------------------
 //
@@ -88,5 +90,5 @@
 //
 MCalibrationRelTimeCalc::MCalibrationRelTimeCalc(const char *name, const char *title)
-    : fBadPixels(NULL), fCam(NULL), fGeom(NULL)
+    : fGeom(NULL)
 {
         
@@ -106,8 +108,13 @@
 // Sets:
 // - all flags to kFALSE
+// - all pointers to NULL
 //
 void MCalibrationRelTimeCalc::Clear(const Option_t *o)
 {
-    SkipHiLoGainCalibration( kFALSE );    
+
+  fBadPixels  = NULL;
+  fCam        = NULL;
+  fIntensCam  = NULL;
+
 }
 
@@ -160,12 +167,17 @@
     }
   
-  fCam = (MCalibrationRelTimeCam*)pList->FindObject("MCalibrationRelTimeCam");
-  if (!fCam)
-    {
-      *fLog << err << "Cannot find MCalibrationRelTimeCam... aborting" << endl;
-      *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationRelTimeCam before..." << endl;
-      return kFALSE;
-    }
-
+  fIntensCam = (MCalibrationIntensityRelTimeCam*)pList->FindObject(AddSerialNumber("MCalibrationIntensityRelTimeCam"));
+  if (fIntensCam)
+    *fLog << inf << "Found MCalibrationIntensityRelTimeCam ... " << endl;
+  else
+    {
+      fCam = (MCalibrationRelTimeCam*)pList->FindObject(AddSerialNumber("MCalibrationRelTimeCam"));
+      if (!fCam)
+        {
+          *fLog << err << "Cannot find MCalibrationRelTimeCam ... abort." << endl;
+          *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationRelTimeCam before..." << endl;
+          return kFALSE;
+        }
+    }
   
   UInt_t npixels     = fGeom->GetNumPixels();
@@ -174,6 +186,8 @@
     {
       
-      MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*fCam)  [i];
-      MBadPixelsPix         &bad = (*fBadPixels)[i];
+      MCalibrationRelTimePix &pix = fIntensCam 
+        ? (MCalibrationRelTimePix&)(*fIntensCam)[i]
+        : (MCalibrationRelTimePix&)(*fCam)      [i];
+      MBadPixelsPix          &bad = (*fBadPixels)[i];
       
       pix.SetPixId(i);
@@ -184,5 +198,7 @@
           continue;
         }
-      
+
+      if (IsDebug())
+        pix.SetDebug();
     }
 
@@ -245,5 +261,8 @@
   FinalizeUnsuitablePixels();
 
-  fCam      ->SetReadyToSave();
+  if (fIntensCam)
+    fIntensCam->SetReadyToSave();
+  else
+    fCam      ->SetReadyToSave();
   fBadPixels->SetReadyToSave();
 
@@ -321,5 +340,7 @@
     {
       
-      MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*fCam)[i];
+      MCalibrationRelTimePix &pix = fIntensCam 
+        ? (MCalibrationRelTimePix&)(*fIntensCam)[i]
+        : (MCalibrationRelTimePix&)(*fCam)      [i];
       MBadPixelsPix          &bad = (*fBadPixels)[i];
       
@@ -369,5 +390,7 @@
     {
       
-      MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*fCam)[i];
+      MCalibrationRelTimePix &pix = fIntensCam 
+        ? (MCalibrationRelTimePix&)(*fIntensCam)[i]
+        : (MCalibrationRelTimePix&)(*fCam)      [i];
       MBadPixelsPix          &bad = (*fBadPixels)[i];
       
@@ -378,5 +401,5 @@
         continue;
       
-      const Float_t res  = pix.GetTimePrecision();
+      const Float_t res    = pix.GetTimePrecision();
       const Int_t   aidx   = (*fGeom)[i].GetAidx();
       
@@ -408,6 +431,8 @@
     {
       
-      MBadPixelsPix    &bad    = (*fBadPixels)[i];
-      MCalibrationPix  &pix    = (*fCam)[i];
+      MBadPixelsPix          &bad = (*fBadPixels)[i];
+      MCalibrationRelTimePix &pix = fIntensCam 
+        ? (MCalibrationRelTimePix&)(*fIntensCam)[i]
+        : (MCalibrationRelTimePix&)(*fCam)      [i];
 
       if (bad.IsUncalibrated( MBadPixelsPix::kDeviatingTimeResolution))
@@ -430,5 +455,5 @@
 //
 // - Print out statistics about BadPixels of type UnsuitableType_t 
-// - store numbers of bad pixels of each type in fCam
+// - store numbers of bad pixels of each type in fIntensCam or fCam
 //
 void MCalibrationRelTimeCalc::FinalizeUnsuitablePixels()
@@ -454,5 +479,8 @@
 
   for (Int_t aidx=0; aidx<nareas; aidx++)
-    fCam->SetNumUnsuitable(counts[aidx], aidx);
+    if (fIntensCam)
+      fIntensCam->SetNumUnsuitable(counts[aidx], aidx);
+    else
+      fCam->SetNumUnsuitable(counts[aidx], aidx);
 
   if (fGeom->InheritsFrom("MGeomCamMagic"))
@@ -473,5 +501,8 @@
 
   for (Int_t aidx=0; aidx<nareas; aidx++)
-    fCam->SetNumUnreliable(counts[aidx], aidx);
+    if (fIntensCam)
+      fIntensCam->SetNumUnreliable(counts[aidx], aidx);
+    else
+      fCam->SetNumUnreliable(counts[aidx], aidx);
 
   *fLog << " " << setw(7) << "Unreliable Pixels:              "
Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.h
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.h	(revision 4907)
+++ /trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCalc.h	(revision 4908)
@@ -19,4 +19,5 @@
 #endif
 
+class MCalibrationIntensityRelTimeCam;
 class MCalibrationRelTimeCam;
 class MGeomCam;
@@ -30,24 +31,24 @@
  
   // Variables
-  Float_t fRelTimeResolutionLimit;              // Limit acceptance rel. time resolution (in FADC slices)
-  Byte_t  fFlags;                               // Bit-field for the flags
-  
-  TString fOutputPath;                          // Path to the output file
-  TString fOutputFile;                          // Name of the output file  
+  Float_t fRelTimeResolutionLimit;               //  Limit acceptance rel. time resolution (in FADC slices)
+  TString fOutputPath;                           //  Path to the output file
+  TString fOutputFile;                           //  Name of the output file  
   
   // Pointers
-  MBadPixelsCam              *fBadPixels;      //  Bad Pixels 
-  MCalibrationRelTimeCam     *fCam;            //  Calibrated RelTimes of all pixels 
-  MGeomCam                   *fGeom;           //! Camera geometry
+  MBadPixelsCam              *fBadPixels;        //  Bad Pixels 
+  MCalibrationIntensityRelTimeCam *fIntensCam;   //  Calibrated RelTimes for different intensities
+  MCalibrationRelTimeCam     *fCam;              //  Calibrated RelTimes of all pixels 
+  MGeomCam                   *fGeom;             //! Camera geometry
 
-  // enums
-  enum  { kHiLoGainCalibration };
+  enum  { kDebug };                              //  Possible flags
 
+  Byte_t  fFlags;                                //  Bit-field for the general flags
+  
   // functions
-  const char* GetOutputFile();
+  const char* GetOutputFile       ();
   void   FinalizeAverageResolution();
-  void   FinalizeRelTimes     ();
-  void   FinalizeBadPixels      ();
-  void   FinalizeUnsuitablePixels();
+  void   FinalizeRelTimes         ();
+  void   FinalizeBadPixels        ();
+  void   FinalizeUnsuitablePixels ();
 
   void   PrintUncalibrated( MBadPixelsPix::UncalibratedType_t typ, const char *text) const;
@@ -64,10 +65,10 @@
   void Clear(const Option_t *o="");
   
-  void SetOutputPath        ( TString path="."                   );
-  void SetOutputFile        ( TString file="TimeCalibStat.txt"   ) { fOutputFile        = file; }
-  void SetRelTimeResolutionLimit ( const Float_t f=fgRelTimeResolutionLimit    ) { fRelTimeResolutionLimit = f;   }
+  Bool_t IsDebug() const  {  return TESTBIT(fFlags,kDebug); }
 
-  void SkipHiLoGainCalibration ( const Bool_t b=kTRUE )
-      { b ? CLRBIT(fFlags, kHiLoGainCalibration) : SETBIT(fFlags, kHiLoGainCalibration); }
+  void SetDebug                 ( const Bool_t  b=kTRUE ) { b ? SETBIT(fFlags,kDebug) : CLRBIT(fFlags,kDebug); }   
+  void SetOutputPath            ( TString path="."                         );
+  void SetOutputFile            ( TString file="TimeCalibStat.txt"         ) { fOutputFile          = file; }
+  void SetRelTimeResolutionLimit( const Float_t f=fgRelTimeResolutionLimit ) { fRelTimeResolutionLimit = f; }
 
   ClassDef(MCalibrationRelTimeCalc, 1)   // Task finalizing the relative time Calibration