Index: trunk/MagicSoft/Mars/mcalib/CalibLinkDef.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/CalibLinkDef.h	(revision 4899)
+++ trunk/MagicSoft/Mars/mcalib/CalibLinkDef.h	(revision 4900)
@@ -6,4 +6,5 @@
 
 #pragma link C++ class MCalibColorSet+;
+#pragma link C++ class MCalibColorSteer+;
 
 #pragma link C++ class MCalibrate+;
@@ -11,4 +12,8 @@
 #pragma link C++ class MCalibrateRelTimes+;
 
+#pragma link C++ class MCalibrationIntensityCam+;
+#pragma link C++ class MCalibrationIntensityChargeCam+;
+#pragma link C++ class MCalibrationIntensityQECam+;
+#pragma link C++ class MCalibrationIntensityRelTimeCam+;
 #pragma link C++ class MCalibrationCam+;
 #pragma link C++ class MCalibrationPix+;
@@ -33,4 +38,5 @@
 
 #pragma link C++ class MHCalibrationCam+;
+#pragma link C++ class MHCalibrationPix+;
 #pragma link C++ class MHCalibrationChargeCam+;
 #pragma link C++ class MHCalibrationChargePix+;
Index: trunk/MagicSoft/Mars/mcalib/MCalibColorSteer.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibColorSteer.h	(revision 4900)
+++ trunk/MagicSoft/Mars/mcalib/MCalibColorSteer.h	(revision 4900)
@@ -0,0 +1,43 @@
+#ifndef MARS_MCalibColorSteer
+#define MARS_MCalibColorSteer
+
+#ifndef MARS_MTask
+#include "MTask.h"
+#endif
+
+class MParList;
+class MGeomCam;
+class MRawEvtHeader;
+class MCalibrationIntensityChargeCam;
+class MCalibrationIntensityQECam;
+class MCalibrationIntensityRelTimeCam;
+class MCalibColorSteer : public MTask
+{
+private:
+
+    MRawEvtHeader                   *fHeader;
+    MGeomCam                        *fGeom;
+    MParList                        *fParList;
+    MCalibrationIntensityChargeCam  *fIntensCharge;
+    MCalibrationIntensityQECam      *fIntensQE;
+    MCalibrationIntensityRelTimeCam *fIntensRelTime;
+
+    UInt_t fPattern;
+
+    Int_t  PreProcess(MParList *pList);
+    Int_t  Process();
+
+    Bool_t ReInitialize();
+    Bool_t Finalize(const char* name);
+    const char* GetNamePattern();
+    
+public:
+
+    MCalibColorSteer(const char *name=NULL, const char *title=NULL);
+    ~MCalibColorSteer() {}
+
+    ClassDef(MCalibColorSteer, 1) // Task to steer the processing of multiple calibration colours
+};
+    
+#endif
+
Index: trunk/MagicSoft/Mars/mcalib/MHGausEvents.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MHGausEvents.cc	(revision 4899)
+++ trunk/MagicSoft/Mars/mcalib/MHGausEvents.cc	(revision 4900)
@@ -101,10 +101,7 @@
 using namespace std;
 
-const Int_t    MHGausEvents::fgBinsAfterStripping   = 40;
-const Float_t  MHGausEvents::fgBlackoutLimit        = 5.;
 const Int_t    MHGausEvents::fgNDFLimit             = 2;
-const Float_t  MHGausEvents::fgPickupLimit          = 5.;
 const Float_t  MHGausEvents::fgProbLimit            = 0.001;
-const Int_t    MHGausEvents::fgPowerProbabilityBins = 20;
+const Int_t    MHGausEvents::fgPowerProbabilityBins = 30;
 // --------------------------------------------------------------------------
 //
@@ -114,6 +111,4 @@
 // - the default Probability Limit for fProbLimit  (fgProbLimit)
 // - the default NDF Limit for fNDFLimit           (fgNDFLimit)
-// - the default number for fPickupLimit           (fgPickupLimit)
-// - the default number for fBlackoutLimit         (fgBlackoutLimit)
 // - the default number of bins after stripping for fBinsAfterStipping (fgBinsAfterStipping)
 // - the default name of the fHGausHist            ("HGausHist")
@@ -132,10 +127,10 @@
 //
 MHGausEvents::MHGausEvents(const char *name, const char *title)
-    : fEventFrequency(0), fHPowerProbability(NULL), 
+    : fHPowerProbability(NULL), 
       fPowerSpectrum(NULL),
+      fFGausFit(NULL), fFExpFit(NULL),
+      fFirst(0.), 
       fGraphEvents(NULL), fGraphPowerSpectrum(NULL),
-      fFGausFit(NULL), fFExpFit(NULL),
-      fFirst(0.), fLast(100.), 
-      fNbins(100), fPixId(-1)
+      fLast(100.), fNbins(100)
 { 
 
@@ -146,7 +141,5 @@
   
   SetBinsAfterStripping();
-  SetBlackoutLimit();
   SetNDFLimit();
-  SetPickupLimit();
   SetPowerProbabilityBins();
   SetProbLimit();
@@ -206,5 +199,5 @@
 // Sets:
 // - all other pointers to NULL
-// - all variables to 0., except fPixId to -1 and keep fEventFrequency
+// - all variables to 0.
 // - all flags to kFALSE
 // 
@@ -226,5 +219,4 @@
   fProb              = 0.;
 
-  fSaturated         = 0;
   fCurrentSize       = 0;
 
@@ -271,51 +263,4 @@
 
 
-// -----------------------------------------------------------------------------
-// 
-// Bypasses the Gauss fit by taking mean and RMS from the histogram
-//
-// Errors are determined in the following way:
-// MeanErr  = RMS / Sqrt(entries)
-// SigmaErr = RMS / (2.*Sqrt(entries) )
-//
-void MHGausEvents::BypassFit()
-{
-
-  const Stat_t entries = fHGausHist.GetEntries();
-  
-  if (entries <= 0.)
-    {
-      *fLog << warn << GetDescriptor() 
-            << ": Cannot bypass fit. Number of entries smaller or equal 0 in pixel: " << fPixId << endl;
-      return;
-    }
-  
-  fMean     = fHGausHist.GetMean();
-  fMeanErr  = fHGausHist.GetRMS() / TMath::Sqrt(entries);
-  fSigma    = fHGausHist.GetRMS() ;
-  fSigmaErr = fHGausHist.GetRMS() / TMath::Sqrt(entries) / 2.;
-}
-
-
-
-// --------------------------------------------------------------------------
-//
-// - Set fPixId to id
-//
-// Add id to names and titles of:
-// - fHGausHist
-//
-void MHGausEvents::ChangeHistId(const Int_t id)
-{
-
-  fPixId = id;
-
-  fHGausHist.SetName(  Form("%s%d", fHGausHist.GetName(),  id));
-  fHGausHist.SetTitle( Form("%s%d", fHGausHist.GetTitle(), id));
-
-  fName  = Form("%s%d", fName.Data(),  id);
-  fTitle = Form("%s%d", fTitle.Data(), id);
-
-}
 
 // -----------------------------------------------------------------------------
@@ -328,11 +273,7 @@
   Float_t *xaxis = new Float_t[n];  
 
-  if (fEventFrequency)
-    for (Int_t i=0;i<n;i++)
-      xaxis[i] = (Float_t)i/fEventFrequency;
-  else
-    for (Int_t i=0;i<n;i++)
-      xaxis[i] = (Float_t)i;
-
+  for (Int_t i=0;i<n;i++)
+    xaxis[i] = (Float_t)i;
+  
   return xaxis;
                  
@@ -344,5 +285,5 @@
 // Create the fourier spectrum using the class MFFT.
 // The result is projected into a histogram and fitted by an exponential
-//   fHPowerProbability->SetDirectory(NULL);
+//
 void MHGausEvents::CreateFourierSpectrum()
 {
@@ -353,10 +294,9 @@
   if (fEvents.GetSize() < 8)
     {
-      *fLog << warn << "Cannot create Fourier spectrum in pixel: " << fPixId 
+      *fLog << warn << "Cannot create Fourier spectrum in: " << fName 
             << ". Number of events smaller than 8 " << endl;
       return;
     }
   
-
   //
   // The number of entries HAS to be a potence of 2, 
@@ -436,7 +376,9 @@
   const Int_t n = fEvents.GetSize();
 
+  if (n==0)
+    return;
+
   fGraphEvents = new TGraph(n,CreateEventXaxis(n),fEvents.GetArray());  
   fGraphEvents->SetTitle("Evolution of Events with time");
-  fGraphEvents->GetXaxis()->SetTitle((fEventFrequency) ? "Time [s]" : "Event Nr.");
   fGraphEvents->GetYaxis()->SetTitle(fHGausHist.GetXaxis()->GetTitle());
   fGraphEvents->GetYaxis()->CenterTitle();
@@ -457,5 +399,4 @@
   fGraphPowerSpectrum = new TGraph(n,CreatePSDXaxis(n),fPowerSpectrum->GetArray());  
   fGraphPowerSpectrum->SetTitle("Power Spectrum Density");
-  fGraphPowerSpectrum->GetXaxis()->SetTitle((fEventFrequency) ? "Frequency [Hz]" : "Frequency");
   fGraphPowerSpectrum->GetYaxis()->SetTitle("P(f)");
   fGraphPowerSpectrum->GetYaxis()->CenterTitle();
@@ -473,11 +414,7 @@
   Float_t *xaxis = new Float_t[n];
 
-  if (fEventFrequency)
-    for (Int_t i=0;i<n;i++)
-      xaxis[i] = 0.5*(Float_t)i*fEventFrequency/n;
-  else
-    for (Int_t i=0;i<n;i++)
-      xaxis[i] = 0.5*(Float_t)i/n;
-
+  for (Int_t i=0;i<n;i++)
+    xaxis[i] = 0.5*(Float_t)i/n;
+  
   return xaxis;
                  
@@ -534,5 +471,5 @@
   pad->cd(1);
 
-  if (!IsEmpty())
+  if (!IsEmpty() && !IsOnlyOverflow() && !IsOnlyUnderflow())
     gPad->SetLogy();
 
@@ -571,4 +508,7 @@
     CreateGraphEvents();
 
+  if (!fGraphEvents)
+    return;
+
   fGraphEvents->SetBit(kCanDelete);
   fGraphEvents->SetTitle("Events with time");
@@ -666,10 +606,13 @@
   //
   // First, strip the zeros from the edges which contain only zeros and rebin 
-  // to about fBinsAfterStripping bins. 
+  // to fBinsAfterStripping bins. If fBinsAfterStripping is 0, reduce bins only by 
+  // a factor 10.
   //
   // (ATTENTION: The Chisquare method is more sensitive, 
   // the _less_ bins, you have!)
   //
-  StripZeros(&fHGausHist,fBinsAfterStripping);
+  StripZeros(&fHGausHist,
+             fBinsAfterStripping ? fBinsAfterStripping 
+             : (fNbins > 1000 ? fNbins/10 : 0));
   
   TAxis *axe = fHGausHist.GetXaxis();
@@ -693,5 +636,5 @@
     {
     *fLog << warn << dbginf << "WARNING: Could not create fit function for Gauss fit " 
-          << "in pixel: " << fPixId << endl;
+          << "in: " << fName << endl;
     return kFALSE;
     }
@@ -731,24 +674,4 @@
 }
 
-// -------------------------------------------------------------------------------
-//
-// Return the number of "blackout" events, which are events with values higher 
-// than fBlackoutLimit sigmas from the mean
-//
-//
-const Double_t MHGausEvents::GetBlackout() const 
-{
-  
-  if ((fMean == 0.) && (fSigma == 0.))
-    return -1.;
-
-  const Int_t first = fHGausHist.GetXaxis()->GetFirst();
-  const Int_t last  = fHGausHist.GetXaxis()->FindBin(fMean-fBlackoutLimit*fSigma);
-
-  if (first >= last)
-    return 0.;
-  
-  return fHGausHist.Integral(first, last, "width");
-}
 
 const Double_t MHGausEvents::GetChiSquare()  const 
@@ -786,25 +709,4 @@
 }
 
-
-// -------------------------------------------------------------------------------
-//
-// Return the number of "pickup" events, which are events with values higher 
-// than fPickupLimit sigmas from the mean
-//
-//
-const Double_t MHGausEvents::GetPickup() const 
-{
-  
-  if ((fMean == 0.) && (fSigma == 0.))
-    return -1.;
-
-  const Int_t first = fHGausHist.GetXaxis()->FindBin(fMean+fPickupLimit*fSigma);
-  const Int_t last  = fHGausHist.GetXaxis()->GetLast();
-
-  if (first >= last)
-    return 0.;
-  
-  return fHGausHist.Integral(first, last, "width");
-}
 
 
@@ -890,5 +792,5 @@
   
   *fLog << all                                                        << endl;
-  *fLog << all << "Results of the Gauss Fit in pixel: " << fPixId     << endl;
+  *fLog << all << "Results of the Gauss Fit in: " << fName            << endl;
   *fLog << all << "Mean: "             << GetMean()                   << endl;
   *fLog << all << "Sigma: "            << GetSigma()                  << endl;
@@ -900,77 +802,4 @@
 }
 
-// --------------------------------------------------------------------------
-//
-// Re-normalize the results, has to be overloaded
-//
-void  MHGausEvents::Renorm()
-{
-}
-
-// -----------------------------------------------------------------------------
-//
-// If flag IsGausFitOK() is set (histogram already successfully fitted), 
-// returns kTRUE
-// 
-// If both fMean and fSigma are still zero, call FitGaus() 
-// 
-// Repeats the Gauss fit in a smaller range, defined by: 
-// 
-// min = GetMean() - fBlackoutLimit * GetSigma();
-// max = GetMean() + fPickupLimit   * GetSigma();
-//
-// The fit results are retrieved and stored in class-own variables.  
-//
-// A flag IsGausFitOK() is set according to whether the fit probability 
-// is smaller or bigger than fProbLimit, whether the NDF is bigger than 
-// fNDFLimit and whether results are NaNs.
-//
-Bool_t MHGausEvents::RepeatFit(const Option_t *option)
-{
-
-  if (IsGausFitOK())
-    return kTRUE;
-
-  if ((fMean == 0.) && (fSigma == 0.))
-    return FitGaus();
-
-  //
-  // Get new fitting ranges
-  //
-  Axis_t rmin = fMean - fBlackoutLimit * fSigma;
-  Axis_t rmax = fMean + fPickupLimit   * fSigma;
-
-  Axis_t hmin = fHGausHist.GetBinCenter(fHGausHist.GetXaxis()->GetFirst());
-  Axis_t hmax = fHGausHist.GetBinCenter(fHGausHist.GetXaxis()->GetLast()) ;
-
-  fFGausFit->SetRange(hmin < rmin ? rmin : hmin , hmax > rmax ? rmax : hmax);
-
-  fHGausHist.Fit(fFGausFit,option);
-
-  fMean     = fFGausFit->GetParameter(1);
-  fSigma    = fFGausFit->GetParameter(2);
-  fMeanErr  = fFGausFit->GetParError(1) ; 
-  fSigmaErr = fFGausFit->GetParError(2) ; 
-  fProb     = fFGausFit->GetProb()      ;      
-
-  //
-  // The fit result is accepted under condition:
-  // 1) The results are not nan's
-  // 2) The NDF is not smaller than fNDFLimit (default: fgNDFLimit)
-  // 3) The Probability is greater than fProbLimit (default: fgProbLimit)
-  //
-  if (   TMath::IsNaN ( fMean     ) 
-      || TMath::IsNaN ( fMeanErr  )
-      || TMath::IsNaN ( fProb     )    
-      || TMath::IsNaN ( fSigma    )
-      || TMath::IsNaN ( fSigmaErr ) 
-      || fFGausFit->GetNDF() < fNDFLimit 
-      || fProb < fProbLimit )
-    return kFALSE;
-  
-  SetGausFitOK(kTRUE);
-  return kTRUE;
-
-}
 
 // --------------------------------------------------------------------------
Index: trunk/MagicSoft/Mars/mcalib/MHGausEvents.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MHGausEvents.h	(revision 4899)
+++ trunk/MagicSoft/Mars/mcalib/MHGausEvents.h	(revision 4900)
@@ -21,14 +21,10 @@
 private:
 
-  const static Int_t    fgBinsAfterStripping;   //! Default for fBinsAfterStripping   (now set to: 40)
-  const static Float_t  fgBlackoutLimit;        //! Default for fBlackoutLimit        (now set to: 5. )
   const static Int_t    fgNDFLimit;             //! Default for fNDFLimit             (now set to: 2)
   const static Float_t  fgProbLimit;            //! Default for fProbLimit            (now set to: 0.001)
-  const static Float_t  fgPickupLimit;          //! Default for fPickupLimit          (now set to: 5. )
   const static Int_t    fgPowerProbabilityBins; //! Default for fPowerProbabilityBins (now set to: 20)
   
   Int_t    fBinsAfterStripping;        // Bins for the Gauss Histogram after stripping off the zeros at both ends
   Int_t    fCurrentSize;               // Current size of the array fEvents
-  Float_t  fEventFrequency;            // Event frequency in Hertz (to be set)
   Byte_t   fFlags;                     // Bit field for the fit result bits
   Int_t    fPowerProbabilityBins;      // Bins for the projected power spectrum
@@ -36,16 +32,18 @@
   TH1I    *fHPowerProbability;         // Fourier transform of fEvents projected on y-axis
   TArrayF *fPowerSpectrum;             // Fourier transform of fEvents
-  TGraph  *fGraphEvents;               //! TGraph to display the event array (will not be cloned!!)
-  TGraph  *fGraphPowerSpectrum;        //! TGraph to display the power spectrum array (will not be cloned!!)
 
-  enum { kGausFitOK, kExpFitOK, kFourierSpectrumOK, kExcluded }; // Bits for information about fit results 
+  enum  { kGausFitOK,
+          kExpFitOK,
+          kFourierSpectrumOK,
+          kExcluded };                 // Bits for information about fit results 
   
 protected:
 
-  Float_t  fBlackoutLimit;             // Lower number sigmas from mean until event is considered blackout
   TArrayF  fEvents;                    // Array which holds the entries of GausHist
   TF1     *fFGausFit;                  // Gauss fit for fHGausHist
   TF1     *fFExpFit;                   // Exponential fit for FHPowerProbability
   Axis_t   fFirst;                     // Lower histogram edge  for fHGausHist (used by InitBins()) 
+  TGraph  *fGraphEvents;               //! TGraph to display the event array (will not be cloned!!)
+  TGraph  *fGraphPowerSpectrum;        //! TGraph to display the power spectrum array (will not be cloned!!)
   TH1F     fHGausHist;                 // Histogram to hold the Gaussian distribution
   Axis_t   fLast;                      // Upper histogram edge  for fHGausHist (used by InitBins()) 
@@ -54,22 +52,21 @@
   Int_t    fNbins;                     // Number histogram bins for fHGausHist (used by InitBins())
   Int_t    fNDFLimit;                  // NDF limit for judgement if fit is OK
-  Int_t    fSaturated;                 // Number of events classified as saturated
   Double_t fSigma;                     // Sigma of the Gauss fit
   Double_t fSigmaErr;                  // Error of the sigma of the Gauss fit
-  Float_t  fPickupLimit;               // Upper number sigmas from mean until event is considered pickup
-  Int_t    fPixId;                     // Pixel ID 
   Double_t fProb;                      // Probability of the Gauss fit 
   Float_t  fProbLimit;                 // Probability limit for judgement if fit is OK 
 
-  Float_t *CreateEventXaxis(Int_t n);  // Create an x-axis for the Event TGraphs
-  Float_t *CreatePSDXaxis(Int_t n);    // Create an x-axis for the PSD TGraphs
+  virtual Float_t *CreateEventXaxis(Int_t n);  // Create an x-axis for the Event TGraphs
+  virtual Float_t *CreatePSDXaxis(Int_t n);    // Create an x-axis for the PSD TGraphs
+  virtual void     CreateGraphEvents();        // Create the TGraph fGraphEvents of fEvents 
+  virtual void     CreateGraphPowerSpectrum(); // Create the TGraph fGraphPowerSpectrum out of fPowerSpectrum
 
   void DrawPowerSpectrum(TVirtualPad &pad, Int_t i);  // Draw graph of fPowerSpectrum and fHPowerProbability
 
   // Setters
-  void  SetBinsAfterStripping   ( const Int_t nbins=fgBinsAfterStripping   ) { fBinsAfterStripping  =nbins; }
+  void  SetBinsAfterStripping   ( const Int_t nbins=0   )                    { fBinsAfterStripping  =nbins; }
   void  SetPowerProbabilityBins ( const Int_t nbins=fgPowerProbabilityBins ) { fPowerProbabilityBins=nbins; }
 
- public:
+public:
 
   MHGausEvents(const char* name=NULL, const char* title=NULL);
@@ -85,5 +82,4 @@
   
   // Getters
-  const Double_t GetBlackout()           const;  
   const Double_t GetChiSquare()          const;
   const Double_t GetExpChiSquare()       const;
@@ -110,10 +106,7 @@
   const Int_t    GetNdf()                const;
   const Double_t GetOffset()             const;
-  const Double_t GetPickup()             const;
-  const Int_t    GetPixId()              const { return fPixId;              }
         TArrayF *GetPowerSpectrum()            { return fPowerSpectrum;      }  
   const TArrayF *GetPowerSpectrum()      const { return fPowerSpectrum;      }
   const Double_t GetProb()               const { return fProb;               }
-  const Float_t  GetSaturated()          const { return fSaturated;          }
   const Double_t GetSigma()              const { return fSigma;              }
   const Double_t GetSigmaErr()           const { return fSigmaErr;           }
@@ -137,6 +130,4 @@
                    const Double_t xmin=0., 
 	           const Double_t xmax=0.);       // Fit the histogram HGausHist with a Gaussian
-  Bool_t RepeatFit(const Option_t *option="RQ0"); // Repeat fit within limits defined by fPickupLimit
-  void   BypassFit();                             // Take mean and RMS from the histogram
   
   // Prints
@@ -144,6 +135,4 @@
   
   // Setters
-  void  SetBlackoutLimit    ( const Float_t  lim=fgBlackoutLimit ) { fBlackoutLimit  = lim; }
-  void  SetEventFrequency   ( const Float_t  f                   ) { fEventFrequency = f;   }
   void  SetExcluded         ( const Bool_t   b=kTRUE             );  
   void  SetExpFitOK         ( const Bool_t   b=kTRUE             );
@@ -156,19 +145,10 @@
   void  SetNbins            ( const Int_t    i                   ) { fNbins          = i;   }  
   void  SetNDFLimit         ( const Int_t    lim=fgNDFLimit      ) { fNDFLimit       = lim; }  
-  void  SetPickupLimit      ( const Float_t  lim=fgPickupLimit   ) { fPickupLimit    = lim; }
-  void  SetPixId            ( const Int_t    i                   ) { fPixId          = i;   }
   void  SetProb             ( const Double_t d                   ) { fProb           = d;   }
   void  SetProbLimit        ( const Float_t  lim=fgProbLimit     ) { fProbLimit      = lim; }
-  void  SetSaturated        ( const Int_t    i                   ) { fSaturated     += i;   }
   void  SetSigma            ( const Double_t d                   ) { fSigma          = d;   }
   void  SetSigmaErr         ( const Double_t d                   ) { fSigmaErr       = d;   }
 
-  // Miscelleaneous
-  virtual void ChangeHistId(const Int_t id);      // Changes names and titles of the histogram
-  virtual void Renorm();                          // Re-normalize the results 
-  
   void CreateFourierSpectrum();                   // Create the fourier spectrum out of fEvents
-  void CreateGraphEvents();                       // Create the TGraph fGraphEvents of fEvents 
-  void CreateGraphPowerSpectrum();                // Create the TGraph fGraphPowerSpectrum out of fPowerSpectrum
   
   ClassDef(MHGausEvents, 1) // Base class for events with Gaussian distributed values
Index: trunk/MagicSoft/Mars/mcalib/Makefile
===================================================================
--- trunk/MagicSoft/Mars/mcalib/Makefile	(revision 4899)
+++ trunk/MagicSoft/Mars/mcalib/Makefile	(revision 4900)
@@ -33,6 +33,11 @@
 SRCFILES = MCalibrate.cc \
 	   MCalibColorSet.cc \
+	   MCalibColorSteer.cc \
 	   MCalibrateData.cc \
 	   MCalibrateRelTimes.cc \
+           MCalibrationIntensityCam.cc \
+           MCalibrationIntensityChargeCam.cc \
+           MCalibrationIntensityQECam.cc \
+           MCalibrationIntensityRelTimeCam.cc \
            MCalibrationCam.cc \
            MCalibrationPix.cc  \
@@ -59,4 +64,5 @@
            MHCalibrationChargePix.cc \
            MHCalibrationCam.cc \
+           MHCalibrationPix.cc \
            MHCalibrationChargeCam.cc \
            MHCalibrationChargeHiGainPix.cc \
