diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
index a5db8a9b0d9a8fdf7fffd53a879b3a9c0fb37999..d6552cf73d9137cbe772f0796410c2cd030d4b40 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
@@ -20,6 +20,7 @@
 #include "StoreGate/ReadHandleKey.h"
 #include "TileEvent/TileRawChannelContainer.h"
 #include "TileEvent/TileDigitsContainer.h"
+#include "TileCalibBlobObjs/TileCalibUtils.h"
 
 
 #include "TString.h"
@@ -27,6 +28,9 @@
 #include <string> 
 #include <map>
 
+#define NBITS 10
+#define NBSTATUS 4
+
 // Forward declaration
 class TileHWID;
 class TileCablingSvc;
@@ -123,28 +127,29 @@ class TileCisDefaultCalibTool: public AthAlgTool
 
     bool m_doSampleChecking;
 
+    using Tile = TileCalibUtils;
     // Results
-    float (*m_calib)[64][48][2];
-    int (*m_qflag)[64][48][2];
-    int (*m_nDAC)[64][48][2]; // This is now deprecated since you can get this form the TGraph
-    int (*m_nDigitalErrors)[64][48][2];
-    float (*m_chi2)[64][48][2];
+    float (*m_calib)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    int (*m_qflag)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    int (*m_nDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]; // This is now deprecated since you can get this form the TGraph
+    int (*m_nDigitalErrors)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_chi2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     // These will not be saved to the ntuple
     // They are for the sample check that gets written to qflag
     // Mike Miller - 4 June 2009
-    int (*m_edgeSample)[64][48][2];
-    int (*m_nextToEdgeSample)[64][48][2];
+    int (*m_edgeSample)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    int (*m_nextToEdgeSample)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     // these arrays are used to contain information about stuck bits in adc's
     // this array pertains to the "stuck bit" quality flag; it is not written to
     // the ntuple
-    int (*m_sampleBit)[64][48][2][10];
+    int (*m_sampleBit)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NBITS];
     // This array contains information about each bit in the adc
     // it IS written into the ntuple
-    unsigned short (*m_bitStatus)[64][48][2][4];
+    unsigned short (*m_bitStatus)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NBSTATUS];
     // used to count the number of injection samples analyzed for odd bit behavior
-    int (*m_numSamp)[64][48][2];
+    int (*m_numSamp)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     //  TList *scanList;  // This is now deprecated and replaced by the map for speed -CT March 09
     TMap* m_scanMap;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
index 2d3d1ba46e98713247e0297b88a660fbc77ab8d8..578c8e39092fa679a727fb03c8a4aa0ae898d862 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
@@ -27,6 +27,7 @@
 #include "TileConditions/TileCablingService.h"
 #include "TileEvent/TileDQstatus.h"
 #include "TileEvent/TileDigitsContainer.h"
+#include "TileCalibBlobObjs/TileCalibUtils.h"
 
 #include <cmath>
 #include <vector>
@@ -34,6 +35,8 @@
 #include <map>
 #include <stdint.h>
 
+#define NVALS 36
+
 // Forward declaration
 class TileHWID;
 class TileBeamElemContByteStreamCnv;
@@ -117,14 +120,16 @@ class TileDigiNoiseCalibAlg: public AthAlgorithm {
      std::string m_optRawChannelContainer;*/
     std::string m_dspRawChannelContainer;
 
-    double (*m_sumPed2)[64][48][2];
-    double (*m_sumRms2)[64][48][2];
-    double (*m_meanAmp)[64][48][2];
-    double (*m_meanAmp_ij)[64][48][48][2];
+    using Tile = TileCalibUtils;
+
+    double (*m_sumPed2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    double (*m_sumRms2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    double (*m_meanAmp)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    double (*m_meanAmp_ij)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     // event number
     int m_evtNr;
-    int (*m_evt)[64][48][2];
+    int (*m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     // Trigger items
     int m_time;
@@ -136,15 +141,15 @@ class TileDigiNoiseCalibAlg: public AthAlgorithm {
     int m_min;
     int m_run;
     int m_trigType;
-    uint8_t (*m_ros)[64][48][2];
-    uint8_t (*m_drawer)[64][48][2];
-    uint8_t (*m_channel)[64][48][2];
-    bool (*m_gain)[64][48][2];
-    float (*m_ped)[64][48][2];
-    float (*m_lfn)[64][48][2];
-    float (*m_hfn)[64][48][2];
-    float (*m_noise_cov)[64][2];
-    float (*m_auto_corr)[64][48][2][36];
+    uint8_t (*m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    uint8_t (*m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    uint8_t (*m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    bool (*m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_ped)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_lfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_hfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_noise_cov)[Tile::MAX_DRAWER][Tile::MAX_GAIN];
+    float (*m_auto_corr)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS];
 };
 
 #endif // TILENOISECALIBALG_H
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
index d13dd702fec2c3920cc5193b2efbfeaea6682929..90407429da322ed637fd349d5b5d672de760e6cb 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
@@ -19,6 +19,20 @@
 #include "TileEvent/TileLaserObject.h"
 #include "StoreGate/ReadHandleKey.h"
 
+#define NFILTERS 10
+#define NDIODES 10
+#define NDIODES_LASER1 4
+#define NMONITORS 4
+#define NPMTS 2
+
+#define NGAINS 2
+#define NPARTITIONS 4 
+#define NDRAWERS 64
+#define NCOUPLES 22 
+#define NCHANNELS 48
+#define NSLICES 100
+#define NFIBERS 2
+
 class TileRawChannelContainer;
 class TileLaserObject;
 class TileHWID;
@@ -73,25 +87,25 @@ class TileLaserLinearityCalibTool : public AthAlgTool, virtual public ITileCalib
   double m_flow;                     // Gas flow in diodes box (in L/h)
   double m_head_temp;                // Temperature of the LASER head
   double m_las_time;                 // Event time
-  double (*m_LG_PMT)[2];                // Mean value for box PMTs
-  double (*m_LG_PMT_S)[2];              // Corresponding RMS
-  double (*m_LG_diode)[10];              // Mean value for box Photodiodes
-  double (*m_LG_diode_S)[10];            // Corresponding RMS
-  double (*m_HG_PMT)[2];                // Mean value for box PMTs
-  double (*m_HG_PMT_S)[2];              // Corresponding RMS
-  double (*m_HG_diode)[10];              // Mean value for box Photodiodes
-  double (*m_HG_diode_S)[10];            // Corresponding RMS
-  double (*m_mean)[4][64][48][2];       // Mean signal computed for this run
-  double (*m_mean_S)[4][64][48][2];     // Corresponding RMS
-  double (*m_LG_ratio)[4][64][48][2];      // Calib coefficients computed for this run (for all diodes)
-  double (*m_LG_ratio_S)[4][64][48][2];    // Corresponding RMS
-  double (*m_LG_ratio2)[4][64][48][2];      // Calib coefficients computed for this run (for all diodes)
-  double (*m_LG_ratio2_S)[4][64][48][2];    // Corresponding RMS
-  double (*m_HG_ratio)[4][64][48][2];      // Calib coefficients computed for this run (for all diodes)
-  double (*m_HG_ratio_S)[4][64][48][2];    // Corresponding RMS
-  double (*m_HG_ratio2)[4][64][48][2];      // Calib coefficients computed for this run (for all diodes)
-  double (*m_HG_ratio2_S)[4][64][48][2];    // Corresponding RMS
-  int    (*m_entries)[4][64][48][2];    // Number of LASER events collected for one channel (and a particular gain)
+  double (*m_LG_PMT)[NPMTS];                // Mean value for box PMTs
+  double (*m_LG_PMT_S)[NPMTS];              // Corresponding RMS
+  double (*m_LG_diode)[NDIODES];              // Mean value for box Photodiodes
+  double (*m_LG_diode_S)[NDIODES];            // Corresponding RMS
+  double (*m_HG_PMT)[NPMTS];                // Mean value for box PMTs
+  double (*m_HG_PMT_S)[NPMTS];              // Corresponding RMS
+  double (*m_HG_diode)[NDIODES];              // Mean value for box Photodiodes
+  double (*m_HG_diode_S)[NDIODES];            // Corresponding RMS
+  double (*m_mean)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];       // Mean signal computed for this run
+  double (*m_mean_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];     // Corresponding RMS
+  double (*m_LG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];      // Calib coefficients computed for this run (for all diodes)
+  double (*m_LG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];    // Corresponding RMS
+  double (*m_LG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];      // Calib coefficients computed for this run (for all diodes)
+  double (*m_LG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];    // Corresponding RMS
+  double (*m_HG_ratio)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];      // Calib coefficients computed for this run (for all diodes)
+  double (*m_HG_ratio_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];    // Corresponding RMS
+  double (*m_HG_ratio2)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];      // Calib coefficients computed for this run (for all diodes)
+  double (*m_HG_ratio2_S)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];    // Corresponding RMS
+  int    (*m_entries)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];    // Number of LASER events collected for one channel (and a particular gain)
 
  
   // Local results - not sent to ROOTuple
@@ -106,15 +120,15 @@ class TileLaserLinearityCalibTool : public AthAlgTool, virtual public ITileCalib
 
   bool m_complete_turn;
 
-  RunningStat* (*m_HG_diode_signal)[10];
-  RunningStat* (*m_HG_PMT_signal)[2];
-  RunningStat* (*m_LG_diode_signal)[10];
-  RunningStat* (*m_LG_PMT_signal)[2];
-  RunningStat* (*m_signal)[4][64][48][2];
-  RunningStat* (*m_LG_ratio_stat)[4][64][48][2];
-  RunningStat* (*m_LG_ratio2_stat)[4][64][48][2];
-  RunningStat* (*m_HG_ratio_stat)[4][64][48][2];
-  RunningStat* (*m_HG_ratio2_stat)[4][64][48][2];
+  RunningStat* (*m_HG_diode_signal)[NDIODES];
+  RunningStat* (*m_HG_PMT_signal)[NPMTS];
+  RunningStat* (*m_LG_diode_signal)[NDIODES];
+  RunningStat* (*m_LG_PMT_signal)[NPMTS];
+  RunningStat* (*m_signal)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];
+  RunningStat* (*m_LG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];
+  RunningStat* (*m_LG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];
+  RunningStat* (*m_HG_ratio_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];
+  RunningStat* (*m_HG_ratio2_stat)[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS];
 
   // Functions
   inline int chanIsConnected(int ros, int chan) {
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
index d590cae48e50ebb5717e11056f54834b77588011..f5dfff9eeb44ef33534b8cb892feb4b310ccf99c 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
@@ -55,6 +55,17 @@
 #include <map>
 #include <sstream>
 
+#define NDIODES 10
+#define NDIODES_LASER1 4
+#define NMONITORS 4
+#define NPMTS 2
+
+#define NGAINS 2
+#define NPARTITIONS 4 
+#define NDRAWERS 64
+#define NCHANNELS 48
+#define NDIGI 8
+
 class TileHWID;
 class TileRawChannelContainer;
 
@@ -143,7 +154,7 @@ class TileLaserTimingTool: public AthAlgTool, virtual public ITileCalibTool {
 
     struct DrawerData {
         DrawerData(const std::string &id);
-        PMTData* pmtd[48];
+        PMTData* pmtd[NCHANNELS];
         DigitizerData digid[8];
 
         // Time difference for Inter module timing
@@ -160,69 +171,69 @@ class TileLaserTimingTool: public AthAlgTool, virtual public ITileCalibTool {
         float FarDigitizerMeanTime;
     };
 
-    DrawerData* (*m_drawerData)[64];
+    DrawerData* (*m_drawerData)[NDRAWERS];
 
     static const int NROS = 5;
 
     // ---- Ntuple data ----
 
     // mean of Gaussian fit to DrawerData.Digi0TimeDiffHisto
-    float (*m_DrawerOffset)[64];
-    float (*m_DrawerOffsetError)[64];
+    float (*m_DrawerOffset)[NDRAWERS];
+    float (*m_DrawerOffsetError)[NDRAWERS];
 
     // time diff wrt Digi0
-    float (*m_ChannelOffset)[64][48];
-    float (*m_ChannelOffsetError)[64][48];
+    float (*m_ChannelOffset)[NDRAWERS][NCHANNELS];
+    float (*m_ChannelOffsetError)[NDRAWERS][NCHANNELS];
     // Maximum ADC amplitude
-    float (*m_ADCAmplitude)[64][48];
+    float (*m_ADCAmplitude)[NDRAWERS][NCHANNELS];
 
-    float (*m_PedestalMean)[64][48];
-    float (*m_PedestalSigma)[64][48];
+    float (*m_PedestalMean)[NDRAWERS][NCHANNELS];
+    float (*m_PedestalSigma)[NDRAWERS][NCHANNELS];
 
     // time diff wrt PMT0
-    float (*m_TimeDiffMean)[64][48];
-    float (*m_TimeDiffMeanError)[64][48];
-    float (*m_TimeDiffSigma)[64][48];
+    float (*m_TimeDiffMean)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffMeanError)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffSigma)[NDRAWERS][NCHANNELS];
 
     // mon-->
-    float (*m_MeanOddPmtTdiffPMT0)[64];
-    int (*m_OddPmtCounterPMT0)[64];
-    float (*m_MeanEvenPmtTdiffPMT0)[64];
-    int (*m_EvenPmtCounterPMT0)[64];
-    float (*m_EvenOddTimeDiffPMT0)[64];
+    float (*m_MeanOddPmtTdiffPMT0)[NDRAWERS];
+    int (*m_OddPmtCounterPMT0)[NDRAWERS];
+    float (*m_MeanEvenPmtTdiffPMT0)[NDRAWERS];
+    int (*m_EvenPmtCounterPMT0)[NDRAWERS];
+    float (*m_EvenOddTimeDiffPMT0)[NDRAWERS];
     // <-- mon
 
 #ifdef TileLaserTimingPMT0Mon
-    float (*m_TimeDiffHighMean)[64][48];
-    float (*m_TimeDiffHighMeanError)[64][48];
-    float (*m_TimeDiffHighSigma)[64][48];
+    float (*m_TimeDiffHighMean)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffHighMeanError)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffHighSigma)[NDRAWERS][NCHANNELS];
 
-    float (*m_TimeDiffLowMean)[64][48];
-    float (*m_TimeDiffLowMeanError)[64][48];
-    float (*m_TimeDiffLowSigma)[64][48];
+    float (*m_TimeDiffLowMean)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffLowMeanError)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffLowSigma)[NDRAWERS][NCHANNELS];
 
-    float (*m_TimeDiffNoCFCorrMean)[64][48];
-    float (*m_TimeDiffNoCFCorrMeanError)[64][48];
-    float (*m_TimeDiffNoCFCorrSigma)[64][48];
+    float (*m_TimeDiffNoCFCorrMean)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffNoCFCorrMeanError)[NDRAWERS][NCHANNELS];
+    float (*m_TimeDiffNoCFCorrSigma)[NDRAWERS][NCHANNELS];
 #endif
 
-    float (*m_FiberLength)[64][48]; // Not needed
+    float (*m_FiberLength)[NDRAWERS][NCHANNELS]; // Not needed
 
 #ifdef TileLaserTimingMon
-    float (*m_TimeDiffPMTDigi0)[64][48]; // Not needed
-    float (*m_FiberCorrection)[64][48]; // Not needed
-    int (*m_IsConnected)[64][48]; // Not needed
+    float (*m_TimeDiffPMTDigi0)[NDRAWERS][NCHANNELS]; // Not needed
+    float (*m_FiberCorrection)[NDRAWERS][NCHANNELS]; // Not needed
+    int (*m_IsConnected)[NDRAWERS][NCHANNELS]; // Not needed
 
-    float (*m_MeanOddPmtTdiff)[64];
-    int (*m_OddPmtCounter)[64];
-    float (*m_MeanEvenPmtTdiff)[64];
-    int (*m_EvenPmtCounter)[64];
+    float (*m_MeanOddPmtTdiff)[NDRAWERS];
+    int (*m_OddPmtCounter)[NDRAWERS];
+    float (*m_MeanEvenPmtTdiff)[NDRAWERS];
+    int (*m_EvenPmtCounter)[NDRAWERS];
 
-    float (*m_EvenOddTimeDiff)[64];
+    float (*m_EvenOddTimeDiff)[NDRAWERS];
 #endif
 
-    float (*m_DSkewSet)[64][8];
-    float (*m_DigiMean)[64][8];
+    float (*m_DSkewSet)[NDRAWERS][NDIGI];
+    float (*m_DigiMean)[NDRAWERS][NDIGI];
 
     /** @return drawer data */
     inline DrawerData* drawerData(int ros, int drawer) {
@@ -339,9 +350,9 @@ class TileLaserTimingTool: public AthAlgTool, virtual public ITileCalibTool {
      */
     void fitGauss2(TH1F &hi, float &p1, float &p2, float &chi2, float &p1_err, float w1, float w2);
 
-    typedef float (*TPMTArray)[64][48];
-    typedef float (*TDrawerArrayF)[64];
-    typedef int (*TDrawerArrayI)[64];
+    typedef float (*TPMTArray)[NDRAWERS][NCHANNELS];
+    typedef float (*TDrawerArrayF)[NDRAWERS];
+    typedef int (*TDrawerArrayI)[NDRAWERS];
 
     /**
      * Correct for differences between even and odd PMTs
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileOFCorrelation.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileOFCorrelation.h
index 78752e6c74ba85253e9c14aa84ef0a95f02705cd..b80bca874f67f9a6c6f0d21ebfecd9ae481d505a 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileOFCorrelation.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileOFCorrelation.h
@@ -18,10 +18,14 @@
 #define TILECALIBALGS_TILELOFCORRELATION_H
 
 #include "GaudiKernel/MsgStream.h"
+#include "TileCalibBlobObjs/TileCalibUtils.h"
 
 #include <vector>
 #include <string>
 
+#define NPARTITIONS 4
+#define NDIG 9
+
 class TileHWID;
 
 class TileOFCorrelation
@@ -88,18 +92,28 @@ class TileOFCorrelation
   
  private:
 
+  using Tile = TileCalibUtils;
   //double SS(9,9);
-  double m_SS[4][64][48][2][9][9];
-  double m_S[4][64][48][2][9];
-  double m_R[4][64][48][2][9][9];
+  double (*m_SS)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG][NDIG];
+  double (*m_S)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double (*m_R)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG][NDIG];
   //int N_events[4][64][48][2]; 
-  std::vector< std::vector <float> > m_DataVector[4][64][48][2]; 
+  std::vector< std::vector <float> > m_DataVector[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]; 
 
-  double m_corr2[9], m_corr_sum[4][64][48][2][9], m_corr_sum_sq[4][64][48][2][9], m_ncorr;
+  double m_corr2[NDIG];
+  double  (*m_corr_sum)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double  (*m_corr_sum_sq)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double  m_ncorr;
   float  m_corr[8];
-  int m_N[4][64][48][2], m_jentry, m_lag, m_N_pairs[4][64][48][2][9];
+  int (*m_N)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+  int  m_jentry, m_lag;
+  int (*m_N_pairs)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
   double m_N_d;
-  double m_S1[4][64][48][2][9], m_S2[4][64][48][2][9], m_S11[4][64][48][2][9], m_S12[4][64][48][2][9], m_S22[4][64][48][2][9];
+  double (*m_S1)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double (*m_S2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double (*m_S11)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double (*m_S12)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
+  double  (*m_S22)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG];
 
 };
 
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
index becc765f58aa711161a1e8a8483c741e66e97183..963fbea9e4dbbd51f2e7080633379f800f13b8ab 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
@@ -30,6 +30,7 @@
 #include "TileConditions/ITileBadChanTool.h"
 #include "TileEvent/TileDQstatus.h"
 #include "TileEvent/TileRawChannelContainer.h"
+#include "TileCalibBlobObjs/TileCalibUtils.h"
 
 #include <cmath>
 #include <vector>
@@ -37,6 +38,12 @@
 #include <map>
 #include <stdint.h>
 
+#define NSIDES 2
+#define NSAMPLES 4
+#define NTOWERS 17
+#define NCELLGAINS 6
+#define NPARS 8
+
 class TileHWID;
 class TileBeamElemContByteStreamCnv;
 class TileDQstatus;
@@ -155,16 +162,18 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
     std::string m_OF1RawChannelContainer;
     std::string m_MFRawChannelContainer;
 
-    TH1F* (*m_histAmp)[5][64][48][2];
-    TH1F* (*m_histCellAmp)[64][4][17][6];
+    using Tile = TileCalibUtils;
+
+    TH1F* (*m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    TH1F* (*m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
 
     // event number
     int m_evtNr;
-    int (*m_evt)[64][48][2];
-    uint8_t (*m_ros)[64][48][2];
-    uint8_t (*m_drawer)[64][48][2];
-    uint8_t (*m_channel)[64][48][2];
-    bool (*m_gain)[64][48][2];
+    int (*m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    uint8_t (*m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    uint8_t (*m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    uint8_t (*m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    bool (*m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
     // Trigger items
     int m_time;
     int m_year;
@@ -178,27 +187,27 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
     //int m_nsamples;
 
     // RawCh items
-    float (*m_rc_mean)[5][64][48][2];
-    float (*m_rc_sigma)[5][64][48][2];
-    float (*m_rc_av)[5][64][48][2];
-    float (*m_rc_rms)[5][64][48][2];
-    float (*m_rc_skewness)[5][64][48][2];
-    float (*m_rc_kurtosis)[5][64][48][2];
-    float (*m_rc_mean_err)[5][64][48][2];
-    float (*m_rc_sigma_err)[5][64][48][2];
-    float (*m_rc_chi2)[5][64][48][2];
-    float (*m_rc_ndf)[5][64][48][2];
-    float (*m_rc_probC2)[5][64][48][2];
-
-    float (*m_rc_ggpar)[5][64][48][2][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
-    float (*m_rc_gsigma1)[5][64][48][2];
-    float (*m_rc_gsigma2)[5][64][48][2];
-    float (*m_rc_gnorm)[5][64][48][2];
-    float (*m_rc_gchi2)[5][64][48][2];
-    float (*m_rc_gerrsigma1)[5][64][48][2];
-    float (*m_rc_gerrsigma2)[5][64][48][2];
-    float (*m_rc_gerrnorm)[5][64][48][2];
-    float (*m_rc_gcorrsigma1sigma2)[5][64][48][2];
+    float (*m_rc_mean)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_av)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_rms)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_kurtosis)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_mean_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_sigma_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_chi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_ndf)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_probC2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+
+    float (*m_rc_ggpar)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
+    float (*m_rc_gsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gchi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gerrsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
+    float (*m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN];
 
     //Cell items
     //structure is side:             A=0 C=1,
@@ -206,27 +215,27 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
     //		 sample:           A=0, BC=1, D=2, E=3
     //             tower:            0-16,
     //             gain combination: LGLG, LG-, -LG, HGHG, HG-, -HG
-    bool (*m_side)[64][4][17][6];
-    uint8_t (*m_phi)[64][4][17][6];
-    uint8_t (*m_sample)[64][4][17][6];
-    uint8_t (*m_tower)[64][4][17][6];
-    uint8_t (*m_gg)[64][4][17][6];
-
-    float (*m_ecell_av)[64][4][17][6];
-    float (*m_ecell_rms)[64][4][17][6];
-    uint32_t (*m_ecell_hash)[64][4][17];
-
-    int (*m_cell_nch)[64][4][17][2]; // number of good channels in given cell in given event - 0 or 1 or 2
-    float (*m_ecell_ene)[64][4][17][2];
-    float (*m_ggpar)[64][4][17][6][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
-    float (*m_gsigma1)[64][4][17][6];
-    float (*m_gsigma2)[64][4][17][6];
-    float (*m_gnorm)[64][4][17][6];
-    float (*m_gchi2)[64][4][17][6];
-    float (*m_gerrsigma1)[64][4][17][6];
-    float (*m_gerrsigma2)[64][4][17][6];
-    float (*m_gerrnorm)[64][4][17][6];
-    float (*m_gcorrsigma1sigma2)[64][4][17][6];
+    bool (*m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    uint8_t (*m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    uint8_t (*m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    uint8_t (*m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    uint8_t (*m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+
+    float (*m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    uint32_t (*m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS];
+
+    int (*m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]; // number of good channels in given cell in given event - 0 or 1 or 2
+    float (*m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN];
+    float (*m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
+    float (*m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
+    float (*m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS];
 
     enum CELL_CHANNEL {OUTER_MBTS_CHANNEL = 4, SPECIAL_C10_CHANNEL = 5, E1_CHANNEL = 12};
 };
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
index 212c96f0844411f964433aef09c735fda6792446..475336635140e1e4453f14a29bef1f9692a060cc 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
@@ -14,6 +14,7 @@
 //#include "TrigT1CaloToolInterfaces/IL1TriggerTowerTool.h"
 #include "TileEvent/TileDQstatus.h"
 #include "TileEvent/TileRawChannelContainer.h"
+#include "TileCalibBlobObjs/TileCalibUtils.h"
 #include "StoreGate/ReadHandleKey.h"
 
 #include <string> 
@@ -65,28 +66,30 @@ class TileTriggerDefaultCalibTool : public AthAlgTool, virtual public ITileCalib
   SG::ReadHandleKey<xAOD::TriggerTowerContainer> m_triggerTowerContainerKey{this,
       "TriggerTowerContainer", "xAODTriggerTowers", "Trigger Tower container"};
  
+  using Tile = TileCalibUtils;
+
   // Results Tile
-  float (*m_meanTile)[64][48];
-  float (*m_rmsTile)[64][48];
-  float (*m_meanTileDAC)[64][48];
-  float (*m_rmsTileDAC)[64][48];
-  int   (*m_ietaTile)[64][48];
-  int   (*m_iphiTile)[64][48];
-  int   (*m_ipmtTile)[64][48];
-  int   (*m_nEvtTile)[64][48];
+  float (*m_meanTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_rmsTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_meanTileDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_rmsTileDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_ietaTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_iphiTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_ipmtTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_nEvtTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
 
   // Results L1Calo
-  float (*m_meanL1Calo)[64][48];
-  float (*m_rmsL1Calo)[64][48];
-  float (*m_meanL1CaloDAC)[64][48];
-  float (*m_rmsL1CaloDAC)[64][48];
-  int   (*m_ietaL1Calo)[64][48];
-  int   (*m_iphiL1Calo)[64][48];
-  int   (*m_ipmtL1Calo)[64][48];
-  int   (*m_nEvtL1Calo)[64][48];
-
-  float (*m_meanTileL1Calo)[64][48];
-  float (*m_rmsTileL1Calo)[64][48];
+  float (*m_meanL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_rmsL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_meanL1CaloDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_rmsL1CaloDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_ietaL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_iphiL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_ipmtL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  int   (*m_nEvtL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+
+  float (*m_meanTileL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
+  float (*m_rmsTileL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN];
 
   float m_DACvalue;
 
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
index f4c0f0908603595e026a9b53446111f73df22471..79e5888c4c21448525940be4ebd38d78091dad39 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
@@ -68,19 +68,19 @@ TileCisDefaultCalibTool::TileCisDefaultCalibTool(const std::string& type, const
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 
   // Initialize arrays for results
-  m_calib = new float[5][64][48][2]();
-  m_qflag = new int[5][64][48][2]();
-  m_nDAC = new int[5][64][48][2]();
-  m_nDigitalErrors = new int[5][64][48][2]();
-  m_chi2 = new float[5][64][48][2]();
+  m_calib = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_qflag = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_nDAC = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_nDigitalErrors = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_chi2 = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
 
   // Initialize sample check arrays
-  m_edgeSample = new int[5][64][48][2]();
-  m_nextToEdgeSample = new int[5][64][48][2]();
+  m_edgeSample = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_nextToEdgeSample = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
 
-  m_sampleBit = new int[5][64][48][2][10]();
-  m_bitStatus = new unsigned short[5][64][48][2][4]();
-  m_numSamp = new int[5][64][48][2]();
+  m_sampleBit = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NBITS]();
+  m_bitStatus = new unsigned short[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NBSTATUS]();
+  m_numSamp = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
 }
 
 TileCisDefaultCalibTool::~TileCisDefaultCalibTool() {
@@ -567,7 +567,7 @@ StatusCode TileCisDefaultCalibTool::finalizeCalculations() {
       // And store information about bits in an array
       // which will be written to the ntuple
       int NoStuckBit = 1; 
-      for(int i = 0; i < 10; i++) {
+      for(int i = 0; i < NBITS; i++) {
         // If a bit is stuck at zero...
         if(m_sampleBit[ros][drawer][chan][gain][i] == 0  && (m_numSamp[ros][drawer][chan][gain] != 0)) {
           // write information to m_bitStatus array of shorts
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
index 70b63a5dbdb8b49d8a9c3f94bb2aaeafc991cd67..1a0b457416356309e71c76cf6948fdfd896e89b4 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
@@ -42,10 +42,6 @@
 #include <cmath>
 #include <ctime>
 
-#define MAX_DRAWERS 256
-#define N_CHANS 48
-#define N_DMUS 16
-
 TileDigiNoiseCalibAlg::TileDigiNoiseCalibAlg(const std::string& name, ISvcLocator* pSvcLocator)
     : AthAlgorithm(name, pSvcLocator)
   , m_adderFilterAlgTool("TileRawChannelBuilderFlatFilter/TileAdderFlatFilter", this)
@@ -85,20 +81,20 @@ TileDigiNoiseCalibAlg::TileDigiNoiseCalibAlg(const std::string& name, ISvcLocato
   m_run = 0;
   m_evtNr = -1;
 
-  m_sumPed2 = new double[5][64][48][2]();
-  m_sumRms2 = new double[5][64][48][2]();
-  m_meanAmp = new double[5][64][48][2]();
-  m_meanAmp_ij = new double[5][64][48][48][2]();
-  m_evt = new int[5][64][48][2]();
-  m_ros = new uint8_t[5][64][48][2]();
-  m_drawer = new uint8_t[5][64][48][2]();
-  m_channel = new uint8_t[5][64][48][2]();
-  m_gain = new bool[5][64][48][2]();
-  m_ped = new float[5][64][48][2]();
-  m_lfn = new float[5][64][48][2]();
-  m_hfn = new float[5][64][48][2]();
-  m_noise_cov = new float[5][64][2]();
-  m_auto_corr = new float[5][64][48][2][36]();
+  m_sumPed2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_sumRms2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_meanAmp = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_meanAmp_ij = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_ped = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_lfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_hfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_noise_cov = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_GAIN]();
+  m_auto_corr = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]();
 }
 
 TileDigiNoiseCalibAlg::~TileDigiNoiseCalibAlg() {
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
index a08a62f05e962ba822bd788e6aecbabe7f3c1553..c0967227e1aeb0f46ed1242d8fe6c30980b47712 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
@@ -56,34 +56,34 @@ TileLaserLinearityCalibTool::TileLaserLinearityCalibTool(const std::string& type
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 
 // creating multi-dim arrays on the heap and initialize all elements to zeros
-  m_LG_PMT = new double[8][2]();
-  m_LG_PMT_S = new double[8][2]();
-  m_LG_diode = new double[8][10]();
-  m_LG_diode_S = new double[8][10]();
-  m_HG_PMT = new double[8][2]();
-  m_HG_PMT_S = new double[8][2]();
-  m_HG_diode = new double[8][10]();
-  m_HG_diode_S = new double[8][10]();
-  m_mean = new double[8][4][64][48][2]();
-  m_mean_S = new double[8][4][64][48][2]();
-  m_LG_ratio = new double[8][4][64][48][2]();
-  m_LG_ratio_S = new double[8][4][64][48][2]();
-  m_LG_ratio2 = new double[8][4][64][48][2]();
-  m_LG_ratio2_S = new double[8][4][64][48][2]();
-  m_HG_ratio = new double[8][4][64][48][2]();
-  m_HG_ratio_S = new double[8][4][64][48][2]();
-  m_HG_ratio2 = new double[8][4][64][48][2]();
-  m_HG_ratio2_S = new double[8][4][64][48][2]();
-  m_entries = new int[8][4][64][48][2]();
-  m_HG_diode_signal = new RunningStat*[8][10]();
-  m_HG_PMT_signal = new RunningStat*[8][2]();
-  m_LG_diode_signal = new RunningStat*[8][10]();
-  m_LG_PMT_signal = new RunningStat*[8][2]();
-  m_signal = new RunningStat*[8][4][64][48][2]();
-  m_LG_ratio_stat = new RunningStat*[8][4][64][48][2]();
-  m_LG_ratio2_stat = new RunningStat*[8][4][64][48][2]();
-  m_HG_ratio_stat = new RunningStat*[8][4][64][48][2]();
-  m_HG_ratio2_stat = new RunningStat*[8][4][64][48][2]();
+  m_LG_PMT = new double[NFILTERS][NPMTS]();
+  m_LG_PMT_S = new double[NFILTERS][NPMTS]();
+  m_LG_diode = new double[NFILTERS][NDIODES]();
+  m_LG_diode_S = new double[NFILTERS][NDIODES]();
+  m_HG_PMT = new double[NFILTERS][NPMTS]();
+  m_HG_PMT_S = new double[NFILTERS][NPMTS]();
+  m_HG_diode = new double[NFILTERS][NDIODES]();
+  m_HG_diode_S = new double[NFILTERS][NDIODES]();
+  m_mean = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_mean_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_entries = new int[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
+  m_HG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
+  m_LG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
+  m_LG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
+  m_signal = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_LG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
+  m_HG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
 }
 
 TileLaserLinearityCalibTool::~TileLaserLinearityCalibTool()
@@ -156,33 +156,33 @@ StatusCode TileLaserLinearityCalibTool::initialize()
   m_last_evt_filter  = 0; 
   m_n_same_filt_evts = 0; 
 
-  for(int f=0; f<8; ++f) 
+  for(int f=0; f<NFILTERS; ++f) 
   {
-    for(int d=0; d<2; ++d) 
+    for(int d=0; d<NPMTS; ++d) 
     {
       m_LG_PMT_signal[f][d] = new RunningStat();
       m_HG_PMT_signal[f][d] = new RunningStat();
     }
   }
 
-  for(int f=0; f<8; ++f) 
+  for(int f=0; f<NFILTERS; ++f) 
   {
-    for(int d=0; d<4; ++d) 
+    for(int d=0; d<NPARTITIONS; ++d) 
     {
       m_LG_diode_signal[f][d]  = new RunningStat();
       m_HG_diode_signal[f][d]  = new RunningStat();
     }
   }
 
-  for(int f=0; f<8; ++f)        // Filter 
+  for(int f=0; f<NFILTERS; ++f)        // Filter 
   {
-    for(int i=0; i<4; ++i)      // Partition
+    for(int i=0; i<NPARTITIONS; ++i)      // Partition
     {
-      for(int j=0; j<64; ++j)   // Module
+      for(int j=0; j<NDRAWERS; ++j)   // Module
       {
-	for(int k=0; k<48; ++k) // Channel
+	for(int k=0; k<NCHANNELS; ++k) // Channel
 	{ 
-	  for(int l=0; l<2; ++l) // Gain
+	  for(int l=0; l<NGAINS; ++l) // Gain
 	  { 
 	    m_signal[f][i][j][k][l]    = new RunningStat();
 	    m_HG_ratio_stat[f][i][j][k][l]     = new RunningStat();
@@ -486,9 +486,9 @@ StatusCode TileLaserLinearityCalibTool::finalizeCalculations()
 {
   ATH_MSG_INFO ( "execute()" );
 
-  for(int f=0; f<8; ++f) 
+  for(int f=0; f<NFILTERS; ++f) 
   {
-    for(int d=0; d<2; ++d) 
+    for(int d=0; d<NPMTS; ++d) 
     {
       m_LG_PMT[f][d]      = m_LG_PMT_signal[f][d]->Mean();    
       m_LG_PMT_S[f][d]    = m_LG_PMT_signal[f][d]->StandardDeviation();  
@@ -498,9 +498,9 @@ StatusCode TileLaserLinearityCalibTool::finalizeCalculations()
     }
   }
 
-  for(int f=0; f<8; ++f) 
+  for(int f=0; f<NFILTERS; ++f) 
   {
-    for(int d=0; d<4; ++d) 
+    for(int d=0; d<NPARTITIONS; ++d) 
     {
       m_LG_diode[f][d]       = m_LG_diode_signal[f][d]->Mean();    
       m_LG_diode_S[f][d]     = m_LG_diode_signal[f][d]->StandardDeviation();    
@@ -510,15 +510,15 @@ StatusCode TileLaserLinearityCalibTool::finalizeCalculations()
     }
   }
 
-  for(int f=0; f<8; ++f) 
+  for(int f=0; f<NFILTERS; ++f) 
   {
-    for(int i=0; i<4; ++i) 
+    for(int i=0; i<NPARTITIONS; ++i) 
     {
-      for(int j=0; j<64; ++j) 
+      for(int j=0; j<NDRAWERS; ++j) 
       {
-	for(int k=0; k<48; ++k) 
+	for(int k=0; k<NCHANNELS; ++k) 
 	{ 
-	  for(int l=0; l<2; ++l) 
+	  for(int l=0; l<NGAINS; ++l) 
 	  { 
 	    m_mean[f][i][j][k][l]    = m_signal[f][i][j][k][l]->Mean();
 	    m_mean_S[f][i][j][k][l]  = m_signal[f][i][j][k][l]->StandardDeviation();
@@ -540,33 +540,33 @@ StatusCode TileLaserLinearityCalibTool::finalizeCalculations()
 
   // remove all RunningStat objects from memory
 
-  for(int f=0; f<8; ++f)
+  for(int f=0; f<NFILTERS; ++f)
   {
-    for(int d=0; d<2; ++d)
+    for(int d=0; d<NPMTS; ++d)
     {
       delete m_LG_PMT_signal[f][d];
       delete m_HG_PMT_signal[f][d];
     }
   }
 
-  for(int f=0; f<8; ++f)
+  for(int f=0; f<NFILTERS; ++f)
   {
-    for(int d=0; d<4; ++d)
+    for(int d=0; d<NPARTITIONS; ++d)
     {
       delete m_LG_diode_signal[f][d];
       delete m_HG_diode_signal[f][d];
     }
   }
 
-  for(int f=0; f<8; ++f)        // Filter
+  for(int f=0; f<NFILTERS; ++f)        // Filter
   {
-    for(int i=0; i<4; ++i)      // Partition
+    for(int i=0; i<NPARTITIONS; ++i)      // Partition
     {
-      for(int j=0; j<64; ++j)   // Module
+      for(int j=0; j<NDRAWERS; ++j)   // Module
       {
-	for(int k=0; k<48; ++k) // Channel
+	for(int k=0; k<NCHANNELS; ++k) // Channel
 	{
-	  for(int l=0; l<2; ++l) // Gain
+	  for(int l=0; l<NGAINS; ++l) // Gain
 	  {
 	    delete m_signal[f][i][j][k][l];
 	    delete m_HG_ratio_stat[f][i][j][k][l];
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
index 326bdcfb9f954259f180386ad3faaaffa12b628a..56619532dd2f1a2d548d4e256f938c550204f00a 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
@@ -151,60 +151,60 @@ TileLaserTimingTool::TileLaserTimingTool(const std::string& type, const std::str
 #endif
 
   // creating multi-dim arrays on the heap and initialize all elements to zeros
-  m_drawerData = new DrawerData*[4][64]();
+  m_drawerData = new DrawerData*[NPARTITIONS][NDRAWERS]();
 
-  m_DrawerOffset = new float[NROS][64]();
-  m_DrawerOffsetError = new float[NROS][64]();
+  m_DrawerOffset = new float[NROS][NDRAWERS]();
+  m_DrawerOffsetError = new float[NROS][NDRAWERS]();
 
-  m_ChannelOffset = new float[NROS][64][48]();
-  m_ChannelOffsetError = new float[NROS][64][48]();
+  m_ChannelOffset = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_ChannelOffsetError = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_ADCAmplitude = new float[NROS][64][48]();
+  m_ADCAmplitude = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_PedestalMean = new float[NROS][64][48]();
-  m_PedestalSigma = new float[NROS][64][48]();
+  m_PedestalMean = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_PedestalSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_TimeDiffMean = new float[NROS][64][48]();
-  m_TimeDiffMeanError = new float[NROS][64][48]();
-  m_TimeDiffSigma = new float[NROS][64][48]();
+  m_TimeDiffMean = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_MeanOddPmtTdiffPMT0 = new float[NROS][64]();
-  m_OddPmtCounterPMT0 = new int[NROS][64]();
-  m_MeanEvenPmtTdiffPMT0 = new float[NROS][64]();
-  m_EvenPmtCounterPMT0 = new int[NROS][64]();
-  m_EvenOddTimeDiffPMT0 = new float[NROS][64]();
+  m_MeanOddPmtTdiffPMT0 = new float[NROS][NDRAWERS]();
+  m_OddPmtCounterPMT0 = new int[NROS][NDRAWERS]();
+  m_MeanEvenPmtTdiffPMT0 = new float[NROS][NDRAWERS]();
+  m_EvenPmtCounterPMT0 = new int[NROS][NDRAWERS]();
+  m_EvenOddTimeDiffPMT0 = new float[NROS][NDRAWERS]();
 
 #ifdef TileLaserTimingPMT0Mon
-  m_TimeDiffHighMean = new float[NROS][64][48]();
-  m_TimeDiffHighMeanError = new float[NROS][64][48]();
-  m_TimeDiffHighSigma = new float[NROS][64][48]();
+  m_TimeDiffHighMean = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffHighMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffHighSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_TimeDiffLowMean = new float[NROS][64][48]();
-  m_TimeDiffLowMeanError = new float[NROS][64][48]();
-  m_TimeDiffLowSigma = new float[NROS][64][48]();
+  m_TimeDiffLowMean = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffLowMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffLowSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 
-  m_TimeDiffNoCFCorrMean = new float[NROS][64][48]();
-  m_TimeDiffNoCFCorrMeanError = new float[NROS][64][48]();
-  m_TimeDiffNoCFCorrSigma = new float[NROS][64][48]();
+  m_TimeDiffNoCFCorrMean = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffNoCFCorrMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_TimeDiffNoCFCorrSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 #endif
 
-  m_FiberLength = new float[NROS][64][48]();
+  m_FiberLength = new float[NROS][NDRAWERS][NCHANNELS]();
 
 #ifdef TileLaserTimingMon
-  m_TimeDiffPMTDigi0 = new float[NROS][64][48]();
-  m_FiberCorrection = new float[NROS][64][48]();
-  m_IsConnected = new int[NROS][64][48]();
+  m_TimeDiffPMTDigi0 = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_FiberCorrection = new float[NROS][NDRAWERS][NCHANNELS]();
+  m_IsConnected = new int[NROS][NDRAWERS][NCHANNELS]();
 
-  m_MeanOddPmtTdiff = new float[NROS][64]();
-  m_OddPmtCounter = new int[NROS][64]();
-  m_MeanEvenPmtTdiff = new float[NROS][64]();
-  m_EvenPmtCounter = new int[NROS][64]();
+  m_MeanOddPmtTdiff = new float[NROS][NDRAWERS]();
+  m_OddPmtCounter = new int[NROS][NDRAWERS]();
+  m_MeanEvenPmtTdiff = new float[NROS][NDRAWERS]();
+  m_EvenPmtCounter = new int[NROS][NDRAWERS]();
 
-  m_EvenOddTimeDiff = new float[NROS][64]();
+  m_EvenOddTimeDiff = new float[NROS][NDRAWERS]();
 #endif
 
-  m_DSkewSet = new float[NROS][64][8]();
-  m_DigiMean = new float[NROS][64][8]();
+  m_DSkewSet = new float[NROS][NDRAWERS][NDIGI]();
+  m_DigiMean = new float[NROS][NDRAWERS][NDIGI]();
 }
 
 TileLaserTimingTool::~TileLaserTimingTool() {
@@ -520,7 +520,7 @@ StatusCode TileLaserTimingTool::execute() {
           //============================================================================
           //=== Calculate residuals. Fill histos with time diff b/w PMT i and digi 1 ===
           //============================================================================
-          for (int ipmt = 0; ipmt < 48; ipmt++) {
+          for (int ipmt = 0; ipmt < NCHANNELS; ipmt++) {
             if (isConnectedPMT(ros, ipmt)) {
               ChannelOffset = -(ddata->pmtd[ipmt]->time - fiberCorrection(ros, ipmt) - ddata->FarDigitizerMeanTime);
               ddata->pmtd[ipmt]->TimeDiffResHis.Fill(ChannelOffset);
@@ -569,7 +569,7 @@ StatusCode TileLaserTimingTool::finalizeCalculations() {
     for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
       DrawerData &drawerd = *drawerData(ros, drawer);
 
-      for (int ipmt = 0; ipmt < 48; ++ipmt) {
+      for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
         PMTData &pmtd = *drawerd.pmtd[ipmt];
         // to simplify the root analysis, store the fiber length, not really neccessary
         m_FiberLength[ros][drawer][ipmt] = fiberLength(ros, ipmt);
@@ -718,7 +718,7 @@ StatusCode TileLaserTimingTool::finalizeCalculations() {
       //==================================================================
       //=== Calculate Dskews                                           ===
       //==================================================================
-      for (int ipmt = 0; ipmt < 48; ++ipmt) {
+      for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
         // LBA and LBC
         if (isBarrel(ros)) {
           if (isConnectedPMT(ros, ipmt) && (timeDiffs[ros][drawer][ipmt] < 300)) {
@@ -758,7 +758,7 @@ StatusCode TileLaserTimingTool::finalizeCalculations() {
         } // end isExtBarrel
       } // end PMT loop
 
-      for (int digi = 0; digi < 8; ++digi) {
+      for (int digi = 0; digi < NDIGI; ++digi) {
         m_DigiMean[ros][drawer][digi] = drawerd.digid[digi].GetDigiTime();
         m_DSkewSet[ros][drawer][digi] = (m_DigiMean[ros][drawer][digi] - m_DigiMean[ros][drawer][0]) * 240. / 25.;
 
@@ -854,7 +854,7 @@ StatusCode TileLaserTimingTool::writeNtuple(int runNumber, int runType, TFile* r
 #ifdef TileLaserTimingMon
         dd->Digi0Time.Write();
 #endif
-        for (int ipmt = 0; ipmt < 48; ++ipmt) {
+        for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
           if (isConnectedPMT(ros, ipmt)) {
             /*dd->pmtd[ipmt]->TimeDiffHisto.Write();
              dd->pmtd[ipmt]->TimeDiffNoCFCorrHisto.Write();*/
@@ -967,7 +967,7 @@ void TileLaserTimingTool::correctEvenOddPMT(int ros, int drawer, TPMTArray& Chan
   //=== determine overall shift between odd and even fibers ===
   //=== for this take only into account channels with connected PMT
   //=== don't take into the mean the value of tdiff when it is too far from zero
-  for (int ipmt = 0; ipmt < 48; ++ipmt) {
+  for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
     if (isConnectedPMT(ros, ipmt)) {
       if (ipmt % 2 == 1) {
         // odd PMTs
@@ -1016,7 +1016,7 @@ void TileLaserTimingTool::correctEvenOddPMT(int ros, int drawer, TPMTArray& Chan
   //==================================================================
   //=== Correct for overall shift b/w odd and even fibers          ===
   //==================================================================
-  for (int ipmt = 0; ipmt < 48; ++ipmt) {
+  for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
     if (isConnectedPMT(ros, ipmt)) {
       if (ipmt % 2 == 1)
         ChannelOffset[ros][drawer][ipmt] -= DeltaParity;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileOFCorrelation.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileOFCorrelation.cxx
index 1e9b784db116a41b0d885a0a8bf67910fc5044f9..76541ec5f22f4993a7070c75793bdcef7e834074 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileOFCorrelation.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileOFCorrelation.cxx
@@ -39,12 +39,38 @@ TileOFCorrelation::TileOFCorrelation()
 {
   memset(m_corr2,0,sizeof(m_corr2));
   memset(m_corr,0,sizeof(m_corr));
+
+  m_SS = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG][NDIG]();
+  m_S = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_R = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG][NDIG]();
+
+  m_corr_sum = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_corr_sum_sq = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_N = new int[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_N_pairs = new int[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_S1 = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_S2 = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_S11 = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_S12 = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
+  m_S22 = new double[NPARTITIONS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NDIG]();
 }
 
 
 ////////////////////////////////////////
 TileOFCorrelation::~TileOFCorrelation()
 {
+  delete[] m_SS;
+  delete[] m_S;
+  delete[] m_R;
+  delete[] m_corr_sum;
+  delete[] m_corr_sum_sq;
+  delete[] m_N;
+  delete[] m_N_pairs;
+  delete[] m_S1;
+  delete[] m_S2;
+  delete[] m_S11;
+  delete[] m_S12;
+  delete[] m_S22;
 }
 
 
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
index e7b596ae539d58b79d8fb9aacee2d3e2f45991c5..6fd10bdffeca85bcfef2a81943b5966ef0a9b803 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
@@ -54,10 +54,6 @@
 #   define CAN_REBIN(hist)  hist->SetBit(TH1::kCanRebin)
 #endif
 
-#define MAX_DRAWERS 256
-#define N_CHANS 48
-#define N_DMUS 16
-
 
 TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg(const std::string& name, ISvcLocator* pSvcLocator)
  : AthAlgorithm(name,pSvcLocator)
@@ -107,54 +103,54 @@ TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg(const std::string& name, ISvcLoca
 
   m_fillidx=false;
 
-  m_histAmp = new TH1F*[RCnum][5][64][48][2]();
-  m_histCellAmp = new TH1F*[2][64][4][17][6]();
-  m_evt = new int[5][64][48][2]();
-  m_ros = new uint8_t[5][64][48][2]();
-  m_drawer = new uint8_t[5][64][48][2]();
-  m_channel = new uint8_t[5][64][48][2]();
-  m_gain = new bool[5][64][48][2]();
-  m_rc_mean = new float[RCnum][5][64][48][2]();
-  m_rc_sigma = new float[RCnum][5][64][48][2]();
-  m_rc_av = new float[RCnum][5][64][48][2]();
-  m_rc_rms = new float[RCnum][5][64][48][2]();
-  m_rc_skewness = new float[RCnum][5][64][48][2]();
-  m_rc_kurtosis = new float[RCnum][5][64][48][2]();
-  m_rc_mean_err = new float[RCnum][5][64][48][2]();
-  m_rc_sigma_err = new float[RCnum][5][64][48][2]();
-  m_rc_chi2 = new float[RCnum][5][64][48][2]();
-  m_rc_ndf = new float[RCnum][5][64][48][2]();
-  m_rc_probC2 = new float[RCnum][5][64][48][2]();
-  m_rc_ggpar = new float[RCnum][5][64][48][2][8]();
-  m_rc_gsigma1 = new float[RCnum][5][64][48][2]();
-  m_rc_gsigma2 = new float[RCnum][5][64][48][2]();
-  m_rc_gnorm = new float[RCnum][5][64][48][2]();
-  m_rc_gchi2 = new float[RCnum][5][64][48][2]();
-  m_rc_gerrsigma1= new float[RCnum][5][64][48][2]();
-  m_rc_gerrsigma2 = new float[RCnum][5][64][48][2]();
-  m_rc_gerrnorm = new float[RCnum][5][64][48][2]();
-  m_rc_gcorrsigma1sigma2 = new float[RCnum][5][64][48][2]();
-
-  m_side = new bool[2][64][4][17][6]();
-  m_phi = new uint8_t[2][64][4][17][6]();
-  m_sample = new uint8_t[2][64][4][17][6]();
-  m_tower = new uint8_t[2][64][4][17][6]();
-  m_gg = new uint8_t[2][64][4][17][6]();
-  m_ecell_av = new float[2][64][4][17][6]();
-  m_ecell_rms= new float[2][64][4][17][6]();
-  m_ecell_hash= new uint32_t[2][64][4][17]();
+  m_histAmp = new TH1F*[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_histCellAmp = new TH1F*[2][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_mean = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_sigma = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_av = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_rms = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_skewness = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_kurtosis = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_mean_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_sigma_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_chi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_ndf = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_probC2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_ggpar = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]();
+  m_rc_gsigma1 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gchi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gerrsigma1= new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gerrsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gerrnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+  m_rc_gcorrsigma1sigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
+
+  m_side = new bool[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_phi = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_sample = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_tower = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gg = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_ecell_av = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_ecell_rms= new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_ecell_hash= new uint32_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS]();
   
-  m_cell_nch = new int[2][64][4][17][2]();
-  m_ecell_ene = new float[2][64][4][17][2]();
-  m_ggpar = new float[2][64][4][17][6][8]();
-  m_gsigma1 = new float[2][64][4][17][6]();
-  m_gsigma2 = new float[2][64][4][17][6]();
-  m_gnorm = new float[2][64][4][17][6]();
-  m_gchi2 = new float[2][64][4][17][6]();
-  m_gerrsigma1 = new float[2][64][4][17][6]();
-  m_gerrsigma2 = new float[2][64][4][17][6]();
-  m_gerrnorm = new float[2][64][4][17][6]();
-  m_gcorrsigma1sigma2 = new float[2][64][4][17][6]();
+  m_cell_nch = new int[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
+  m_ecell_ene = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
+  m_ggpar = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]();
+  m_gsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gchi2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gerrsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gerrsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gerrnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
+  m_gcorrsigma1sigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
 }
 
 TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg()
@@ -241,11 +237,11 @@ StatusCode TileRawChNoiseCalibAlg::initialize() {
   float cellbin[2] = { 80., 2.5 }; //in MeV
   float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
 
-  for (int side = 0; side < 2; side++) {
+  for (int side = 0; side < NSIDES; side++) {
     for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
-      for (int sample = 0; sample < 4; sample++) {
-        for (int tower = 0; tower < 17; tower++) {
-          for (int gg = 0; gg < 6; gg++) {
+      for (int sample = 0; sample < NSAMPLES; sample++) {
+        for (int tower = 0; tower < NTOWERS; tower++) {
+          for (int gg = 0; gg < NCELLGAINS; gg++) {
             sStr.str("");
             sStr << "CellAmplitude_Side_" << side << "_Drawer_" << drawer << "_Sample_" << sample << "_Tower_" << tower << "_Gains_" << gg;
             nam = sStr.str();
@@ -622,11 +618,11 @@ StatusCode TileRawChNoiseCalibAlg::finalize() {
       }
     }
     
-    for (int side = 0; side < 2; side++) {
+    for (int side = 0; side < NSIDES; side++) {
       for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
-        for (int sample = 0; sample < 4; ++sample) {
-          for (int tower = 0; tower < 17; ++tower) {
-            for (int gg = 0; gg < 6; ++gg) {
+        for (int sample = 0; sample < NSAMPLES; ++sample) {
+          for (int tower = 0; tower < NTOWERS; ++tower) {
+            for (int gg = 0; gg < NCELLGAINS; ++gg) {
               m_histCellAmp[side][drawer][sample][tower][gg]->Write();
             }
           }
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
index 972bce12b633d4c83b6af5ed5341885f97cbc1ca..7ae6fc6565c58c0358b57a696d91a4f25a389fde 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
@@ -78,26 +78,26 @@ TileTriggerDefaultCalibTool::TileTriggerDefaultCalibTool(const std::string& type
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
   //  declareProperty("L1TriggerTowerTool", m_ttTool);
   
-  m_meanTile = new float[5][64][48]();
-  m_rmsTile = new float[5][64][48]();
-  m_meanTileDAC = new float[5][64][48]();
-  m_rmsTileDAC = new float[5][64][48]();
-  m_ietaTile = new int[5][64][48]();
-  m_iphiTile = new int[5][64][48]();
-  m_ipmtTile = new int[5][64][48]();
-  m_nEvtTile = new int[5][64][48]();
-
-  m_meanL1Calo = new float[5][64][48]();
-  m_rmsL1Calo = new float[5][64][48]();
-  m_meanL1CaloDAC = new float[5][64][48]();
-  m_rmsL1CaloDAC = new float[5][64][48]();
-  m_ietaL1Calo = new int[5][64][48]();
-  m_iphiL1Calo = new int[5][64][48]();
-  m_ipmtL1Calo = new int[5][64][48]();
-  m_nEvtL1Calo = new int[5][64][48]();
-
-  m_meanTileL1Calo = new float[5][64][48]();
-  m_rmsTileL1Calo = new float[5][64][48]();
+  m_meanTile = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_rmsTile = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_meanTileDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_rmsTileDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_ietaTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_iphiTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_ipmtTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_nEvtTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+
+  m_meanL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_rmsL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_meanL1CaloDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_rmsL1CaloDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_ietaL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_iphiL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_ipmtL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_nEvtL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+
+  m_meanTileL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
+  m_rmsTileL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
 }
 
 TileTriggerDefaultCalibTool::~TileTriggerDefaultCalibTool()