Index: /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.cc
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.cc	(revision 4812)
+++ /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.cc	(revision 4813)
@@ -469,4 +469,18 @@
   }
 
+  fSumhiarea  .Set(nareas); 
+  fSumloarea  .Set(nareas); 
+  fTimehiarea .Set(nareas); 
+  fTimeloarea .Set(nareas);
+  fSumhisector.Set(nsectors); 
+  fSumlosector.Set(nsectors); 
+  fTimehisector.Set(nsectors); 
+  fTimelosector.Set(nsectors);
+
+  fSathiarea  .Set(nareas); 
+  fSatloarea  .Set(nareas);
+  fSathisector.Set(nsectors); 
+  fSatlosector.Set(nsectors);
+
   return kTRUE;
 }
@@ -512,21 +526,17 @@
   const UInt_t lofirst  = signal->GetFirstUsedSliceLoGain();
 
-  Float_t sumhiarea  [nareas],   sumloarea  [nareas],   timehiarea  [nareas],   timeloarea  [nareas];
-  Float_t sumhisector[nsectors], sumlosector[nsectors], timehisector[nsectors], timelosector[nsectors];
-  Int_t   sathiarea  [nareas],   satloarea  [nareas];
-  Int_t   sathisector[nsectors], satlosector[nsectors];
-
-  memset(sumhiarea,   0, nareas * sizeof(Float_t));
-  memset(sumloarea,   0, nareas * sizeof(Float_t));
-  memset(timehiarea,  0, nareas * sizeof(Float_t));
-  memset(timeloarea,  0, nareas * sizeof(Float_t));
-  memset(sathiarea,   0, nareas * sizeof(Int_t  ));
-  memset(satloarea,   0, nareas * sizeof(Int_t  ));
-  memset(sumhisector, 0, nsectors*sizeof(Float_t));
-  memset(sumlosector, 0, nsectors*sizeof(Float_t));
-  memset(timehisector,0, nsectors*sizeof(Float_t));
-  memset(timelosector,0, nsectors*sizeof(Float_t));
-  memset(sathisector, 0, nsectors*sizeof(Int_t  ));
-  memset(satlosector, 0, nsectors*sizeof(Int_t  ));
+  fSumhiarea  .Reset(); 
+  fSumloarea  .Reset(); 
+  fTimehiarea .Reset(); 
+  fTimeloarea  .Reset();
+  fSumhisector.Reset(); 
+  fSumlosector.Reset(); 
+  fTimehisector.Reset(); 
+  fTimelosector.Reset();
+
+  fSathiarea  .Reset(); 
+  fSatloarea  .Reset();
+  fSathisector.Reset(); 
+  fSatlosector.Reset();
 
   for (UInt_t i=0; i<npixels; i++)
@@ -559,13 +569,13 @@
       const Int_t sector = (*fGeom)[i].GetSector();
 
-      sumhiarea[aidx]  += sumhi;
-      sumloarea[aidx]  += sumlo;
-      sathiarea[aidx]  += sathi;
-      satloarea[aidx]  += satlo;
-
-      sumhisector[sector]  += sumhi;
-      sumlosector[sector]  += sumlo;
-      sathisector[sector]  += sathi;
-      satlosector[sector]  += satlo;
+      fSumhiarea[aidx]  += sumhi;
+      fSumloarea[aidx]  += sumlo;
+      fSathiarea[aidx]  += sathi;
+      fSatloarea[aidx]  += satlo;
+
+      fSumhisector[sector]  += sumhi;
+      fSumlosector[sector]  += sumlo;
+      fSathisector[sector]  += sathi;
+      fSatlosector[sector]  += satlo;
     }
 
@@ -591,9 +601,9 @@
       const Int_t sector = (*fGeom)[pixid].GetSector();
 
-      timehiarea[aidx] += timehi;
-      timeloarea[aidx] += timelo;
-
-      timehisector[sector] += timehi;
-      timelosector[sector] += timelo;
+      fTimehiarea[aidx] += timehi;
+      fTimeloarea[aidx] += timelo;
+
+      fTimehisector[sector] += timehi;
+      fTimelosector[sector] += timelo;
     }
   
@@ -609,12 +619,12 @@
       MHCalibrationChargePix &lopix = (MHCalibrationChargePix&)GetAverageLoGainArea(j);
 
-      hipix.FillHistAndArray(sumhiarea[j]/npix);
-      lopix.FillHistAndArray(sumloarea[j]/npix);
-
-      hipix.SetSaturated(sathiarea[j]/npix); 
-      lopix.SetSaturated(satloarea[j]/npix); 
-
-      hipix.FillAbsTime(timehiarea[j]/npix);
-      lopix.FillAbsTime(timeloarea[j]/npix);
+      hipix.FillHistAndArray(fSumhiarea[j]/npix);
+      lopix.FillHistAndArray(fSumloarea[j]/npix);
+
+      hipix.SetSaturated(fSathiarea[j]/npix); 
+      lopix.SetSaturated(fSatloarea[j]/npix); 
+
+      hipix.FillAbsTime(fTimehiarea[j]/npix);
+      lopix.FillAbsTime(fTimeloarea[j]/npix);
 
     }
@@ -631,12 +641,12 @@
       MHCalibrationChargePix &lopix = (MHCalibrationChargePix&)GetAverageLoGainSector(j);
 
-      hipix.FillHistAndArray(sumhisector[j]/npix);
-      lopix.FillHistAndArray(sumlosector[j]/npix);
-
-      hipix.SetSaturated(sathisector[j]/npix); 
-      lopix.SetSaturated(satlosector[j]/npix); 
-
-      hipix.FillAbsTime(timehisector[j]/npix);
-      lopix.FillAbsTime(timelosector[j]/npix);
+      hipix.FillHistAndArray(fSumhisector[j]/npix);
+      lopix.FillHistAndArray(fSumlosector[j]/npix);
+
+      hipix.SetSaturated(fSathisector[j]/npix); 
+      lopix.SetSaturated(fSatlosector[j]/npix); 
+
+      hipix.FillAbsTime(fTimehisector[j]/npix);
+      lopix.FillAbsTime(fTimelosector[j]/npix);
 
     }
Index: /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.h
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.h	(revision 4812)
+++ /trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeCam.h	(revision 4813)
@@ -4,8 +4,4 @@
 #ifndef MARS_MHCalibrationCam
 #include "MHCalibrationCam.h"
-#endif
-
-#ifndef ROOT_TArrayF
-#include "TArrayF.h"
 #endif
 
@@ -27,9 +23,23 @@
   static const Float_t fgTimeUpperLimit;             //! Default for fTimeUpperLimit    (now set to: 2.)
   
-  static const Float_t gkHiGainInnerRefLines[7];
-  static const Float_t gkHiGainOuterRefLines[7];
-  static const Float_t gkLoGainInnerRefLines[7];
-  static const Float_t gkLoGainOuterRefLines[7];
-  
+  static const Float_t gkHiGainInnerRefLines[7];     //!
+  static const Float_t gkHiGainOuterRefLines[7];     //!
+  static const Float_t gkLoGainInnerRefLines[7];     //!
+  static const Float_t gkLoGainOuterRefLines[7];     //!
+
+  TArrayF fSumhiarea  ;                             //!
+  TArrayF fSumloarea  ;                             //!
+  TArrayF fTimehiarea ;                             //!
+  TArrayF fTimeloarea ;                             //!
+  TArrayF fSumhisector;                             //!
+  TArrayF fSumlosector;                             //!
+  TArrayF fTimehisector;                            //!
+  TArrayF fTimelosector;                            //!
+
+  TArrayI fSathiarea  ;                             //!
+  TArrayI fSatloarea  ;                             //!
+  TArrayI fSathisector;                             //!
+  TArrayI fSatlosector;                             //!
+
   Float_t fTimeLowerLimit;            // Limit dist. to first signal slice (in units of FADC slices) 
   Float_t fTimeUpperLimit;            // Limit dist. to last signal slice  (in units of FADC slices) 
Index: /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.cc
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.cc	(revision 4812)
+++ /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.cc	(revision 4813)
@@ -281,4 +281,13 @@
     }
 
+  fSumareahi  .Set(nareas); 
+  fSumarealo  .Set(nareas);
+  fSumsectorhi.Set(nsectors); 
+  fSumsectorlo.Set(nsectors);
+  fNumareahi  .Set(nareas); 
+  fNumarealo  .Set(nareas);
+  fNumsectorhi.Set(nsectors); 
+  fNumsectorlo.Set(nsectors);
+
   return kTRUE;
 }
@@ -313,18 +322,13 @@
   const Int_t nsectors = fGeom->GetNumSectors();
 
-  Float_t sumareahi  [nareas],   sumarealo  [nareas];
-  Float_t sumsectorhi[nsectors], sumsectorlo[nsectors];
-  Int_t   numareahi  [nareas],   numarealo  [nareas];
-  Int_t   numsectorhi[nsectors], numsectorlo[nsectors];
-
-  memset(sumareahi,   0, nareas * sizeof(Float_t));
-  memset(sumarealo,   0, nareas * sizeof(Float_t));
-  memset(sumsectorhi, 0, nsectors*sizeof(Float_t));
-  memset(sumsectorlo, 0, nsectors*sizeof(Float_t));
-  memset(numareahi,   0, nareas * sizeof(Float_t));
-  memset(numarealo,   0, nareas * sizeof(Float_t));
-  memset(numsectorhi, 0, nsectors*sizeof(Float_t));
-  memset(numsectorlo, 0, nsectors*sizeof(Float_t));
-  
+  fSumareahi  .Reset();
+  fSumarealo  .Reset();
+  fSumsectorhi.Reset(); 
+  fSumsectorlo.Reset();
+  fNumareahi  .Reset(); 
+  fNumarealo  .Reset();
+  fNumsectorhi.Reset(); 
+  fNumsectorlo.Reset();
+
   const MArrivalTimePix &refpix = (*arrtime)[fReferencePixel];
   const Float_t reftime = refpix.IsLoGainUsed() 
@@ -349,8 +353,8 @@
           histhi.SetSaturated(1); 
           histlo.FillHistAndArray(reltime);
-          sumarealo  [aidx]   += reltime;
-          numarealo  [aidx]   ++;
-          sumsectorlo[sector] += reltime;
-          numsectorlo[sector] ++;
+          fSumarealo  [aidx]   += reltime;
+          fNumarealo  [aidx]   ++;
+          fSumsectorlo[sector] += reltime;
+          fNumsectorlo[sector] ++;
         }
       else
@@ -358,8 +362,8 @@
           const Float_t reltime = pix.GetArrivalTimeHiGain() - reftime;
           histhi.FillHistAndArray(reltime) ;
-          sumareahi  [aidx]   += reltime;
-          numareahi  [aidx]   ++;
-          sumsectorhi[sector] += reltime;
-          numsectorhi[sector] ++;
+          fSumareahi  [aidx]   += reltime;
+          fNumareahi  [aidx]   ++;
+          fSumsectorhi[sector] += reltime;
+          fNumsectorhi[sector] ++;
         }
     }
@@ -368,8 +372,8 @@
     {
       MHGausEvents &histhi = GetAverageHiGainArea(j);
-      histhi.FillHistAndArray(numareahi[j] == 0 ? 0. : sumareahi[j]/numareahi[j]);
+      histhi.FillHistAndArray(fNumareahi[j] == 0 ? 0. : fSumareahi[j]/fNumareahi[j]);
 
       MHGausEvents &histlo = GetAverageLoGainArea(j);
-      histlo.FillHistAndArray(numarealo[j] == 0 ? 0. : sumarealo[j]/numarealo[j]);
+      histlo.FillHistAndArray(fNumarealo[j] == 0 ? 0. : fSumarealo[j]/fNumarealo[j]);
     }
   
@@ -377,8 +381,8 @@
     {
       MHGausEvents &histhi = GetAverageHiGainSector(j);
-      histhi.FillHistAndArray(numsectorhi[j] == 0 ? 0. : sumsectorhi[j]/numsectorhi[j]);
+      histhi.FillHistAndArray(fNumsectorhi[j] == 0 ? 0. : fSumsectorhi[j]/fNumsectorhi[j]);
 
       MHGausEvents &histlo = GetAverageLoGainSector(j);
-      histlo.FillHistAndArray(numsectorlo[j] == 0 ? 0. : sumsectorlo[j]/numsectorlo[j]);
+      histlo.FillHistAndArray(fNumsectorlo[j] == 0 ? 0. : fSumsectorlo[j]/fNumsectorlo[j]);
     }
 
Index: /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.h
===================================================================
--- /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.h	(revision 4812)
+++ /trunk/MagicSoft/Mars/mcalib/MHCalibrationRelTimeCam.h	(revision 4813)
@@ -14,4 +14,14 @@
   static const Float_t fgNumHiGainSaturationLimit;   //! The default for fNumHiGainSaturationLimit (now at: 0.25)
   static const UInt_t  fgReferencePixel;             //! Default for fReferencePixel (now set to: 1)
+
+  TArrayF fSumareahi  ;                             //!
+  TArrayF fSumarealo  ;                             //!
+  TArrayF fSumsectorhi;                             //!
+  TArrayF fSumsectorlo;                             //!
+  TArrayI fNumareahi  ;                             //!
+  TArrayI fNumarealo  ;                             //!
+  TArrayI fNumsectorhi;                             //!
+  TArrayI fNumsectorlo;                             //!
+
   UInt_t fReferencePixel;                           //  The reference pixel for rel. times