Index: trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc	(revision 3644)
@@ -378,6 +378,6 @@
     {
 
-      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
-      MCalibrationQEPix     &pqe = (*fQECam)    [i];
+      MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)  [i];
+      MCalibrationQEPix     &pqe = (MCalibrationQEPix&)    (*fQECam)[i];
       MBadPixelsPix         &bad = (*fBadPixels)[i];
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc	(revision 3644)
@@ -73,4 +73,5 @@
   SetHiGainSaturation  ( kFALSE );
   SetExcluded          ( kFALSE );
+  SetValid             ( kFALSE );
 
 }
@@ -93,4 +94,13 @@
 { 
     b ?  SETBIT(fFlags, kExcluded) : CLRBIT(fFlags, kExcluded); 
+}
+
+// --------------------------------------------------------------------------
+//
+// Set the Valid Bit from outside 
+//
+void MCalibrationPix::SetValid(Bool_t b )
+{ 
+    b ?  SETBIT(fFlags, kValid) : CLRBIT(fFlags, kValid); 
 }
 
@@ -119,4 +129,9 @@
 
 
+Bool_t MCalibrationPix::IsHiGainSaturation()    const
+{ 
+   return TESTBIT(fFlags,kHiGainSaturation);  
+}
+
 Bool_t MCalibrationPix::IsExcluded()     const
 { 
@@ -124,7 +139,7 @@
 }
 
-Bool_t MCalibrationPix::IsHiGainSaturation()    const
+Bool_t MCalibrationPix::IsValid()     const
 { 
-   return TESTBIT(fFlags,kHiGainSaturation);  
+   return TESTBIT(fFlags,kValid);  
 }
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationPix.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationPix.h	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationPix.h	(revision 3644)
@@ -29,5 +29,5 @@
   Float_t fLoGainNumPickup;   // The number of pickup events in the low-gain
 
-  enum  { kHiGainSaturation, kExcluded };
+  enum  { kHiGainSaturation, kExcluded, kValid };
   
 public:
@@ -62,6 +62,7 @@
   void SetNumPickup  ( const Float_t f ) { IsHiGainSaturation() ? fLoGainNumPickup = f  : fHiGainNumPickup = f ; }
   
+  void SetExcluded        ( const Bool_t  b = kTRUE );
   void SetHiGainSaturation( const Bool_t  b = kTRUE );
-  void SetExcluded        ( const Bool_t  b = kTRUE );
+  void SetValid           ( const Bool_t  b = kTRUE );
 
   // Getters
@@ -89,6 +90,7 @@
   Int_t   GetPixId      () const { return fPixId ;  }
 
+  Bool_t  IsHiGainSaturation() const;
   Bool_t  IsExcluded()         const;
-  Bool_t  IsHiGainSaturation() const;
+  Bool_t  IsValid   ()         const;
 
   ClassDef(MCalibrationPix, 1)	// Container for Calibration of one pixel
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.cc	(revision 3644)
@@ -28,8 +28,37 @@
 // MCalibrationQECam                                               
 //                                                               
-// Hold the calibrated QE information of the camera:
-//                                                               
-// 1) MCalibrationQECam initializes a TClonesArray whose elements are 
-//    pointers to MCalibrationQEPix Containers
+// Storage container for the calibrated Quantum Efficiency of the whole camera.
+//
+// Individual pixels have to be cast when retrieved e.g.:
+// MCalibrationQEPix &avpix = (MCalibrationQEPix&)(*fQECam)[i]
+// 
+// The following "calibration" constants can be retrieved from each pixel:
+// - GetQE   ( const PulserColor_t color ): The mean quantum 
+//   efficiency obtained with the calibration pulser color (e.g. kGREEN, kBLUE, kUV)
+// - GetQEErr( const PulserColor_t color ): The uncertainty 
+//   of the mean quantum efficiency.
+//
+// Averaged values over one whole area index (e.g. inner or outer pixels for 
+// the MAGIC camera), can be retrieved via: 
+// MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageArea(i)
+//
+// Averaged values over one whole camera sector can be retrieved via: 
+// MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageSector(i)
+//
+// Note the averageing has been done at the end of the calculation and NOT on an 
+// event-by-event basis (like in other classes deriving from MCalibrationCam). 
+//
+// See also: MHCalibrationChargePix, MHCalibrationChargeCam, MCalibrationChargeCalc
+//                                                                         
+// The calculated values (types of GetPixelContent) are:
+// 
+// 0: Mean Quantum Efficiency of the color: kCT1
+// 1: Error of the Mean Quantum Efficiency of the color: kCT1
+// 2: Mean Quantum Efficiency of the color: kGREEN
+// 3: Error of the Mean Quantum Efficiency of the color: kGreen
+// 4: Mean Quantum Efficiency of the color: kBLUE
+// 5: Error of the Mean Quantum Efficiency of the color: kBlue
+// 6: Mean Quantum Efficiency of the color: kUV
+// 7: Error of the Mean Quantum Efficiency of the color: kUV
 //
 /////////////////////////////////////////////////////////////////////////////
@@ -51,8 +80,7 @@
 // Default constructor. 
 //
-// Creates a TClonesArray of MCalibrationPix containers, initialized to 1 entry
-// Later, a call to MCalibrationQECam::InitSize(Int_t size) has to be performed
-//
-// Creates an MCalibrationBlindPix container 
+// Creates a TClonesArray of MCalibrationQEPix containers, initialized to 1 entry, destinated 
+// to hold one container per pixel. Later, a call to MCalibrationQECam::InitSize() 
+// has to be performed (in MGeomApply). 
 //
 MCalibrationQECam::MCalibrationQECam(const char *name, const char *title)
@@ -61,68 +89,8 @@
     fTitle = title ? title : "Storage container for the calibrated Quantrum Efficiency of the camera";
 
-    fPixels     = new TClonesArray("MCalibrationQEPix",1);
-
-    Clear();
-}
-
-// --------------------------------------------------------------------------
-//
-MCalibrationQECam::~MCalibrationQECam()
-{
-
-  //
-  // delete fPixels should delete all Objects stored inside
-  // 
-  delete fPixels;
-
-}
-
-// -------------------------------------------------------------------
-//
-void MCalibrationQECam::InitSize(const UInt_t i)
-{
-  fPixels->ExpandCreate(i);
-}
-
-// --------------------------------------------------------------------------
-//
-// This function returns the current size of the TClonesArray 
-// independently if the MCalibrationPix is filled with values or not.
-//
-// It is the size of the array fPixels.
-//
-Int_t MCalibrationQECam::GetSize() const
-{
-  return fPixels->GetEntriesFast();
-}
-
-
-// --------------------------------------------------------------------------
-//
-// Get i-th pixel (pixel number)
-//
-MCalibrationQEPix &MCalibrationQECam::operator[](UInt_t i)
-{
-  return *static_cast<MCalibrationQEPix*>(fPixels->UncheckedAt(i));
-}
-
-// --------------------------------------------------------------------------
-//
-// Get i-th pixel (pixel number)
-//
-const MCalibrationQEPix &MCalibrationQECam::operator[](UInt_t i) const
-{
-  return *static_cast<MCalibrationQEPix*>(fPixels->UncheckedAt(i));
-}
-
-
-// --------------------------------------
-//
-void MCalibrationQECam::Clear(Option_t *o)
-{
-
-  fPixels->ForEach(TObject, Clear)();
-
-  return;
+    fPixels           = new TClonesArray("MCalibrationQEPix",1);
+    fAverageAreas     = new TClonesArray("MCalibrationQEPix",1);
+    fAverageSectors   = new TClonesArray("MCalibrationQEPix",1);
+
 }
 
@@ -144,5 +112,5 @@
     {
       
-      if (!pix->IsExcluded() && pix->IsQEValid()) 
+      if (!pix->IsExcluded() && pix->IsValid()) 
 	{
 	    *fLog << all << "Pix " << pix->GetPixId() 
@@ -164,5 +132,5 @@
       {
         
-        if (!pix->IsExcluded() && !pix->IsQEValid())
+        if (!pix->IsExcluded() && !pix->IsValid())
           {
 	    *fLog << all << "Pix " << pix->GetPixId() 
@@ -193,4 +161,16 @@
 }
 
+// --------------------------------------------------------------------
+//                                                                         
+// The calculated values (types) are:
+// 
+// 0: Mean Quantum Efficiency of the color: kCT1
+// 1: Error of the Mean Quantum Efficiency of the color: kCT1
+// 2: Mean Quantum Efficiency of the color: kGREEN
+// 3: Error of the Mean Quantum Efficiency of the color: kGreen
+// 4: Mean Quantum Efficiency of the color: kBLUE
+// 5: Error of the Mean Quantum Efficiency of the color: kBlue
+// 6: Mean Quantum Efficiency of the color: kUV
+// 7: Error of the Mean Quantum Efficiency of the color: kUV
 //
 Bool_t MCalibrationQECam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const
@@ -198,4 +178,9 @@
 
   if (idx > GetSize())
+    return kFALSE;
+
+  MCalibrationQEPix &pix = (MCalibrationQEPix&)(*this)[idx];
+
+  if (pix.IsExcluded())
     return kFALSE;
 
@@ -203,12 +188,26 @@
     {
     case 0:
-      if ((*this)[idx].IsExcluded())
-        return kFALSE;
-      val = (*this)[idx].GetQE(kCT1);
+      val = pix.GetQE(kCT1);
       break;
     case 1:
-      if ((*this)[idx].IsExcluded())
-        return kFALSE;
-      val = (*this)[idx].GetQEErr(kCT1);
+      val = pix.GetQEErr(kCT1);
+      break;
+    case 2:
+      val = pix.GetQE(kGREEN);
+      break;
+    case 3:
+      val = pix.GetQEErr(kGREEN);
+      break;
+    case 4:
+      val = pix.GetQE(kBLUE);
+      break;
+    case 5:
+      val = pix.GetQEErr(kBLUE);
+      break;
+    case 6:
+      val = pix.GetQE(kUV);
+      break;
+    case 7:
+      val = pix.GetQEErr(kUV);
       break;
     default:
@@ -220,17 +219,17 @@
 // --------------------------------------------------------------------------
 //
-// What MHCamera needs in order to draw an individual pixel in the camera
+// Not yet implemented
 //
 void MCalibrationQECam::DrawPixelContent(Int_t idx) const
 {
-    return;
-}
-
-
-
-
-
-
-
-
-
+  return;
+}
+
+
+
+
+
+
+
+
+
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.h	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationQECam.h	(revision 3644)
@@ -2,36 +2,16 @@
 #define MARS_MCalibrationQECam
 
-#ifndef MARS_MParContainer
-#include "MParContainer.h"
-#endif
-#ifndef MARS_MCamEvent
-#include "MCamEvent.h"
+#ifndef MARS_MCalibrationCam
+#include "MCalibrationCam.h"
 #endif
 
-class TClonesArray;
-
-class MCalibrationQEPix;
-class MCalibrationQECam : public MParContainer, public MCamEvent
+class MCalibrationQECam : public MCalibrationCam
 {
 private:
-  
-  Int_t fNumPixels;
-  TClonesArray *fPixels;                                        //-> Array of MCalibrationPix with fit results
   
 public:
 
   MCalibrationQECam(const char *name=NULL, const char *title=NULL);
-  ~MCalibrationQECam();
-  
-  void Clear(    Option_t *o="" );
-  void InitSize( const UInt_t i );
-
-  // Getters
-  Int_t  GetSize()               const;
-  UInt_t GetNumPixels()          const { return fNumPixels; }
-
-  // Others
-  MCalibrationQEPix &operator[](UInt_t i);
-  const MCalibrationQEPix &operator[](UInt_t i) const;
+  ~MCalibrationQECam() {}
   
   // Prints
@@ -42,5 +22,5 @@
   void DrawPixelContent(Int_t num) const;    
 
-  ClassDef(MCalibrationQECam, 1)	// Container for calibration information of the camera
+  ClassDef(MCalibrationQECam, 1)	// Container for Quantum Efficieny Calibration Results Camera
 };
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.cc	(revision 3644)
@@ -25,5 +25,5 @@
 /////////////////////////////////////////////////////////////////////////////
 //                                                                         //
-// MCalibrationChargePix                                                         //
+// MCalibrationQEPix                                                       //
 //                                                                         //
 // Storage container of the calibrated Quantrum Efficiency of one pixel 
@@ -89,5 +89,4 @@
 //
 MCalibrationQEPix::MCalibrationQEPix(const char *name, const char *title)
-    : fPixId(-1)
 {
 
@@ -105,7 +104,4 @@
 void MCalibrationQEPix::Clear(Option_t *o)
 {
-
-  SetExcluded               ( kFALSE );
-  SetQEValid                ( kFALSE );
 
   fQEGreen      =  -1.;
@@ -119,4 +115,6 @@
   fQECT1Err     =  -1.;
  
+  MCalibrationPix::Clear();
+
 }
 
@@ -169,29 +167,4 @@
 
 
-
-// --------------------------------------------------------------------------
-//
-// Set the Excluded Bit from outside 
-//
-void MCalibrationQEPix::SetExcluded(Bool_t b )
-{ 
-    b ?  SETBIT(fFlags, kExcluded) : CLRBIT(fFlags, kExcluded); 
-}
-
-// --------------------------------------------------------------------------
-//
-// Set the Excluded Bit from outside 
-//
-void MCalibrationQEPix::SetQEValid(Bool_t b )    
-{ 
-  b ?  SETBIT(fFlags, kQEValid) : CLRBIT(fFlags, kQEValid); 
-}
-
-
-Int_t MCalibrationQEPix::GetPixId()  const
-{
-    return fPixId;
-}
-
 Float_t MCalibrationQEPix::GetQE(const PulserColor_t col )  const
 {
@@ -240,29 +213,14 @@
 }
 
-
-Bool_t MCalibrationQEPix::IsExcluded()            const
-{ 
-   return TESTBIT(fFlags,kExcluded);  
-}
-
-
-Bool_t MCalibrationQEPix::IsQEValid()         const 
-{
-  return TESTBIT(fFlags, kQEValid);  
-}
-
-
+// --------------------------------------------------------------
 //
 // The check return kTRUE if:
 //
-// 1) Pixel has a fitted charge greater than fQELimit*PedRMS
-// 2) Pixel has a fit error greater than fQEErrLimit
-// 3) Pixel has a fitted charge greater its fQERelErrLimit times its charge error
-// 4) Pixel has a charge sigma bigger than its Pedestal RMS
-// 
+// Not yet implemented! 
+//
 Bool_t MCalibrationQEPix::CheckQEValidity()
 {
  
-  SetQEValid();
+  SetValid();
   return kTRUE;
 }
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.h	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationQEPix.h	(revision 3644)
@@ -2,28 +2,22 @@
 #define MARS_MCalibrationQEPix
 
-#ifndef MARS_MParContainer
-#include "MParContainer.h"
+#ifndef MARS_MCalibrationPix
+#include "MCalibrationPix.h"
 #endif
 
-class MCalibrationQEPix : public MParContainer
+class MCalibrationQEPix : public MCalibrationPix
 {
 private:
 
-  Int_t fPixId;
-
-  Float_t fQEGreen;
-  Float_t fQEBlue;
-  Float_t fQEUV;
-  Float_t fQECT1;
+  Float_t fQEGreen;          // The calibrated quantum efficiency at 520 nm
+  Float_t fQEBlue;           // The calibrated quantum efficiency at 460 nm
+  Float_t fQEUV;             // The calibrated quantum efficiency at 370 nm
+  Float_t fQECT1;            // The calibrated quantum efficiency at 370 nm
   
-  Float_t fQEGreenErr;
-  Float_t fQEBlueErr;
-  Float_t fQEUVErr;
-  Float_t fQECT1Err;   
+  Float_t fQEGreenErr;       // The uncertainty about the calibrated QE at 520 nm
+  Float_t fQEBlueErr;        // The uncertainty about the calibrated QE at 460 nm
+  Float_t fQEUVErr;          // The uncertainty about the calibrated QE at 370 nm
+  Float_t fQECT1Err;         // The uncertainty about the calibrated QE at 370 nm
   
-  Byte_t fFlags;
-
-  enum { kExcluded, kQEValid };
-
 public:
 
@@ -37,21 +31,12 @@
   void SetQEErr( const Float_t qeerr, const PulserColor_t col );
 
-  void SetExcluded            (  const Bool_t b = kTRUE );
-  void SetQEValid             (  const Bool_t b = kTRUE );
-
   // Getters
   Float_t GetQE   ( const PulserColor_t col )  const;
   Float_t GetQEErr( const PulserColor_t col )  const;
-  Int_t   GetPixId()          const;
-
-  Bool_t IsExcluded()         const;
-  Bool_t IsQEValid()          const;
-
-  void SetPixId(const Int_t i)     { fPixId = i; }
 
   // Miscellaneous
   Bool_t CheckQEValidity();
 
-  ClassDef(MCalibrationQEPix, 1)	// Container for calibrated Quantrum Efficieny of one pixel
+  ClassDef(MCalibrationQEPix, 1)	// Container for Quantum Efficieny Calibration Results Pixel
 };
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.cc	(revision 3644)
@@ -27,9 +27,34 @@
 // MCalibrationRelTimeCam                                               
 //                                                               
-// Hold the whole Calibration results of the camera:
-//                                                               
-// 1) MCalibrationRelTimeCam initializes a TClonesArray whose elements are 
-//    pointers to MCalibrationRelTimePix Containers
-//
+// Storage container for relative arrival time calibration results         
+// of the whole camera.
+//
+// Individual pixels have to be cast when retrieved e.g.:
+// MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)(*fRelCam)[i]
+// 
+// The following "calibration" constants can be retrieved from each pixel:
+// - GetTimeOffset(): The mean offset in relative times, 
+//   has to be added to any calculated relative time in the camera. 
+// - GetTimePrecision(): The Gauss sigma of histogrammed relative arrival 
+//   times for the calibration run. Gives an estimate about the timing 
+//   resolution.
+//
+// ALL RELATIVE TIMES HAVE TO BE CALCULATED W.R.T. PIXEL IDX 1 
+// (HARDWARE NUMBER: 2) !!
+//
+// Averaged values over one whole area index (e.g. inner or outer pixels for 
+// the MAGIC camera), can be retrieved via: 
+// MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageArea(i)
+//
+// Averaged values over one whole camera sector can be retrieved via: 
+// MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageSector(i)
+//
+// Note the averageing has been done on an event-by-event basis. Resulting 
+// Sigma's of the Gauss fit have been multiplied with the square root of the number 
+// of involved pixels in order to make a direct comparison possible with the mean of 
+// sigmas. 
+//
+// See also: MHCalibrationRelTimePix, MHCalibrationRelTimeCam              
+//                                                                         
 // The calculated values (types of GetPixelContent) are:
 // 
@@ -37,13 +62,13 @@
 // ============== 
 //
-// 0: Fitted RelTime
-// 1: Error of fitted RelTime
-// 2: Sigma of fitted RelTime
-// 3: Error of Sigma of fitted RelTime
+// 0: Mean Time Offset
+// 1: Error of Mean Time Offset
+// 2: Sigma of Time Offset == Time Resolution 
+// 3: Error of Sigma of Time Offset
 //
 // Useful variables derived from the fit results:
 // =============================================
 //
-// 4: Returned probability of Gauss fit to RelTime distribution
+// 4: Returned probability of Gauss fit to Rel. Arrival Time distribution
 //
 /////////////////////////////////////////////////////////////////////////////
@@ -69,8 +94,15 @@
 // Default constructor. 
 //
-// Creates a TClonesArray of MCalibrationPix containers, initialized to 1 entry
-// Later, a call to MCalibrationRelTimeCam::InitSize(Int_t size) has to be performed
-//
-// Creates an MCalibrationBlindPix container 
+// Creates a TClonesArray of MCalibrationPix containers, initialized to 1 entry, destinated 
+// to hold one container per pixel. Later, a call to MCalibrationRelTimeCam::InitSize() 
+// has to be performed (in MGeomApply). 
+//
+// Creates a TClonesArray of MCalibrationPix containers, initialized to 1 entry, destinated 
+// to hold one container per pixel AREA. Later, a call to MCalibrationRelTimeCam::InitAreas() 
+// has to be performed (in MGeomApply). 
+//
+// Creates a TClonesArray of MCalibrationPix containers, initialized to 1 entry, destinated
+// to hold one container per camera SECTOR. Later, a call to MCalibrationRelTimeCam::InitSectors() 
+// has to be performed (in MGeomApply). 
 //
 MCalibrationRelTimeCam::MCalibrationRelTimeCam(const char *name, const char *title)
@@ -83,31 +115,4 @@
     fAverageSectors   = new TClonesArray("MCalibrationRelTimePix",1);
 
-    Clear();
-
-}
-
-
-
-// --------------------------------------
-//
-void MCalibrationRelTimeCam::Clear(Option_t *o)
-{
-
-  MCalibrationCam::Clear();
-
-  CLRBIT(fFlags,kValid);
-
-  return;
-}
-
-void MCalibrationRelTimeCam::SetValid(const Bool_t b)
-{
-    b ? SETBIT(fFlags, kValid) : CLRBIT(fFlags, kValid); 
-}
-
-
-Bool_t  MCalibrationRelTimeCam::IsValid()   const
-{
-  return TESTBIT(fFlags,kValid);
 }
 
@@ -115,5 +120,5 @@
 //
 // Print first the well fitted pixels 
-// and then the ones which are not FitValid
+// and then the ones which are not Valid
 //
 void MCalibrationRelTimeCam::Print(Option_t *o) const
@@ -254,5 +259,5 @@
 // --------------------------------------------------------------------------
 //
-// What MHCamera needs in order to draw an individual pixel in the camera
+// Calls MCalibrationPix::DrawClone()
 //
 void MCalibrationRelTimeCam::DrawPixelContent(Int_t idx) const
@@ -261,17 +266,2 @@
 }
 
-
-
-Bool_t MCalibrationRelTimeCam::GetConversion(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma)
-{
-
-  MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*this)[ipx];
-
-  mean  = pix.GetMeanConversion();
-  err   = pix.GetConversionErr();
-  sigma = pix.GetSigmaConversion();
-
-  return kTRUE;
-}
-
-
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.h	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimeCam.h	(revision 3644)
@@ -6,38 +6,21 @@
 #endif
 
-class MCalibrationRelTimePix;
-class MBadPixelsPix;
-class MBadPixelsCam;
 class MCalibrationRelTimeCam : public MCalibrationCam
 {
 private:
   
-  enum  { kValid };
-
 public:
 
   MCalibrationRelTimeCam(const char *name=NULL, const char *title=NULL);
   ~MCalibrationRelTimeCam() {}
-  
-  
-  void Clear(    Option_t *o="" );
-
-  // Setters   
-  void SetValid(    const Bool_t b = kTRUE );
-
-  Bool_t  GetConversion(    Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma );
-
-  Bool_t IsValid()   const;
 
   // Prints
   void Print(Option_t *o="") const;
   
-  // Draws
+  // Others
+  Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
   void DrawPixelContent(Int_t num) const;    
   
-  // Others
-  Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
-
-  ClassDef(MCalibrationRelTimeCam, 1)	// Container for calibration of the camera
+  ClassDef(MCalibrationRelTimeCam, 1)	// Container Rel. Arrival Time Calibration Results Camera
 };
 
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.cc
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.cc	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.cc	(revision 3644)
@@ -25,6 +25,17 @@
 // MCalibrationRelTimePix                                                  //
 //                                                                         //
-// Storage container to hold informations about the calibrated arrival time// 
-// value of one Pixel (PMT).                                               //
+// Storage container for relative arrival time calibration results         // 
+// of one Pixel (PMT).                                                     //
+// The following "calibration" constants can be retrieved:                 //
+// - GetTimeOffset(): The mean offset in relative times, 
+//   has to be added to any calculated relative time in the camera. 
+// - GetTimePrecision(): The Gauss sigma of histogrammed relative arrival 
+//   times for the calibration run. Gives an estimate about the timing 
+//   resolution.
+//
+// ALL RELATIVE TIMES HAVE TO BE CALCULATED W.R.T. PIXEL IDX 1 
+// (HARDWARE NUMBER: 2) !!
+//
+// See also: MHCalibrationRelTimePix, MHCalibrationRelTimeCam              //
 //                                                                         //
 /////////////////////////////////////////////////////////////////////////////
@@ -36,66 +47,12 @@
 // --------------------------------------------------------------------------
 //
-// Default Constructor: 
+// Default Constructor
 //
 MCalibrationRelTimePix::MCalibrationRelTimePix(const char *name, const char *title)
-    : fRelTimeFlags(0)
 {
 
   fName  = name  ? name  : "MCalibrationRelTimePix";
-  fTitle = title ? title : "Container of the fit results of MHCalibrationRelTimePixs ";
-
-  Clear();
+  fTitle = title ? title : "Results of MHCalibrationRelTimePix ";
 
 }
 
-// ------------------------------------------------------------------------
-//
-// Invalidate values
-//
-void MCalibrationRelTimePix::Clear(Option_t *o)
-{
-
-  SetValid     ( kFALSE );
-
-  fMeanConversion   =  -1.;
-  fConversionVar    =  -1.;
-  fSigmaConversion  =  -1.;
-
-  MCalibrationPix::Clear();
-}
-
-
-// --------------------------------------------------------------------------
-//
-// Set the conversion factors from outside (only for MC)
-//
-void MCalibrationRelTimePix::SetConversion(Float_t c, Float_t err, Float_t sig)
-{
-  fMeanConversion  = c;
-  fConversionVar   = err*err;
-  fSigmaConversion = sig;
-}
-
-
-// --------------------------------------------------------------------------
-//
-// Set the Excluded Bit from outside 
-//
-void MCalibrationRelTimePix::SetValid(const Bool_t b )
-{ 
-  b ?  SETBIT(fRelTimeFlags, kValid) : CLRBIT(fRelTimeFlags, kValid); 
-}    
-
-
-Float_t MCalibrationRelTimePix::GetConversionErr()  const
-{
-  if (fConversionVar < 0.)
-    return -1.;
-  return TMath::Sqrt(fConversionVar);
-}
-
-
-Bool_t MCalibrationRelTimePix::IsValid() const 
-{ 
-  return TESTBIT(fRelTimeFlags, kValid); 
-}
Index: trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.h
===================================================================
--- trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.h	(revision 3642)
+++ trunk/MagicSoft/Mars/mcalib/MCalibrationRelTimePix.h	(revision 3644)
@@ -10,12 +10,4 @@
 private:
 
-  Float_t fMeanConversion;     // The conversion factor to Phe's (F-factor method)
-  Float_t fConversionVar;      // The error of the conversion factor to Phe's (F-factor method)
-  Float_t fSigmaConversion;    // The sigma of conversion factor to Phe's (F-factor method)
-
-  Byte_t fRelTimeFlags;        // The bit-field for the class-own bits
-
-  enum  { kValid };             // The possible bits to be set
-
 public:
 
@@ -23,16 +15,4 @@
   ~MCalibrationRelTimePix() {}
   
-  void Clear(Option_t *o="");
-
-  // Conversion Factors
-  void SetConversion   ( Float_t c, Float_t err, Float_t sig );
-  
-  // Setters
-  void SetValid( const Bool_t b = kTRUE );
-
-  Float_t GetMeanConversion()  const  { return fMeanConversion;  }
-  Float_t GetConversionErr()   const;
-  Float_t GetSigmaConversion() const  { return fSigmaConversion; }
-
   Float_t GetTimeOffset()       const { return GetMean();        }
   Float_t GetTimeOffsetErr()    const { return GetMeanErr();     }
@@ -40,7 +20,5 @@
   Float_t GetTimePrecisionErr() const { return GetSigmaErr();    }
 
-  Bool_t IsValid()              const;
-
-  ClassDef(MCalibrationRelTimePix, 1)	// Container for Calibration of one pixel
+  ClassDef(MCalibrationRelTimePix, 1)	// Container Rel. Arrival Time Calibration Results Pixel
 };
 
