Moving of the QA checker from rec to base, as it is used also during simulation.
authorlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Nov 2009 17:02:25 +0000 (17:02 +0000)
committerlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Nov 2009 17:02:25 +0000 (17:02 +0000)
Should fix https://savannah.cern.ch/bugs/?59362

A proper fix though would be to allow in the QA framework the usage of two different checkers (one for rec one for sim).

MUON/AliMUONQAIndices.h [new file with mode: 0644]
MUON/AliMUONTrackerQAChecker.cxx
MUON/AliMUONTrackerQADataMakerRec.cxx
MUON/AliMUONTrackerQADataMakerRec.h
MUON/AliMUONTriggerQAChecker.cxx
MUON/AliMUONTriggerQADataMakerRec.cxx
MUON/AliMUONTriggerQADataMakerRec.h
MUON/MUONbaseLinkDef.h
MUON/MUONrecLinkDef.h
MUON/libMUONbase.pkg
MUON/libMUONrec.pkg

diff --git a/MUON/AliMUONQAIndices.h b/MUON/AliMUONQAIndices.h
new file mode 100644 (file)
index 0000000..f7bf908
--- /dev/null
@@ -0,0 +1,181 @@
+#ifndef ALIMUONQAINDICES_H
+#define ALIMUONQAINDICES_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// 
+/// Definition of enums needed by the MUON QA data makers and checkers (both
+/// tracker and trigger)
+///
+/// \author Laurent Aphecetche and Diego Stocco, Subatech
+
+namespace AliMUONQAIndices
+{
+  /// Raw histograms indices
+  enum ERaw { 
+    kTrackerData              = 3,  ///< Accumulated data
+    kTrackerBusPatchOccupancy = 4, ///< Bus patch occupancies
+    kTrackerBusPatchNofPads   = 5, ///< Number of pads per bus patch
+    kTrackerBusPatchNofManus  = 6, ///< Number of manus per bus patch
+    kTrackerBusPatchConfig    = 7, ///< Configuration of the tracker
+    kTriggerScalersTime       = 22, ///< Trigger scalers acquisition time index
+    kTriggerScalers           = 23, ///< Trigger scalers histogram per plane index
+    kTriggerScalersDisplay    = 31, ///< Trigger scalers display histogram per plane index
+    kTriggerCalibSummary      = 40, ///< Number of responding strips/boards and noisy strips 
+    kTriggerCalibSummaryNorm  = 41, ///< Percentage of responding strips/boards and noisy strips
+    kTriggerErrorLocalXPos = 50, ///< Local board: Number of XPos Error vs Local Board Id
+    kTriggerErrorLocalYPos = 51, ///< Local board: Number of YPos Error vs Local Board Id
+    kTriggerErrorLocalDev  = 52, ///< Local board: Number of Deviation Error vs Local Board
+    kTriggerErrorLocalTriggerDec = 53, ///< Local board: Number of Trigger Decision (All Pt) Error vs Local Board Id
+    kTriggerErrorLocalLPtLSB = 54, ///< Local board: Number of LSB Low Pt Error vs Local Board Id
+    kTriggerErrorLocalLPtMSB = 55, ///< Local board: Number of MSB Low Pt Error vs Local Board Id
+    kTriggerErrorLocalHPtLSB = 56, ///< Local board: Number of LSB High Pt Error vs Local Board Id
+    kTriggerErrorLocalHPtMSB = 57, ///< Local board: Number of MSB High Pt Error vs Local Board Id
+    kTriggerErrorLocalTrigY  = 58, ///< Local board: Number of TrigY Error vs Local Board Id
+    kTriggerErrorLocal2RegionalLPtLSB  = 59, ///< Local to Regional: Number of LPt LSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalLPtMSB  = 60, ///< Local to Regional: Number of LPt MSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalHPtLSB  = 61, ///< Local to Regional: Number of HPt LSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalHPtMSB  = 62, ///< Local to Regional: Number of HPt MSB error vs Local Board Id
+    kTriggerErrorOutGlobalFromInGlobal = 63, ///< Global board: Number of error vs output bit 
+    kTriggerErrorSummary      = 64,  ///< Number of errors for each trigger decision level (Local, Reg->Local, Reg, Reg->Glob, Global)
+    kTriggerErrorSummaryNorm  = 65,  ///< Percentage of errors for each trigger decision level
+    kTriggerErrorLocalYCopy     = 67, ///< Local board: Number of Y Copy Error vs Local Board Id
+    kTriggerErrorLocalYCopyTest = 68, ///< Local Board: Number of Y copy error tests (for normalization)
+    kTriggerErrorLocalYCopyNorm = 69, ///< Local Board: Number of Y Copy Error vs Local Board Id Normalized to the number of tests
+    kTriggeredBoards          = 70,  ///< Triggered boards histogram index
+    kTriggerBoardsDisplay     = 71,  ///< Triggered boards display histogram index
+    kTriggerReadOutErrors     = 80,  ///< Number of read-out errors
+    kTriggerReadOutErrorsNorm = 81,  ///< Percentage of read-out errors
+    kTriggerGlobalOutput      = 90,  ///< Number of Global outputs and Global algo errors
+    kTriggerGlobalOutputNorm  = 91,  ///< Percentage of Global outputs and Global algo errors
+    kTriggerRawNAnalyzedEvents= 100  ///< Number of analyzed events per event specie
+    
+  };
+  
+  /// Rec points histograms indices
+  enum ERecPoints { 
+    kTrackerNumberOfClustersPerChamber    = 100, ///< Tracker: number of clusters per chamber
+    kTrackerClusterMultiplicityPerChMean  = 101, ///< cluster size per Ch: mean
+    kTrackerClusterMultiplicityPerChSigma = 102, ///< cluster size per Ch: dispersion
+    kTrackerClusterChargePerChMean        = 103, ///< cluster charge per Ch: mean
+    kTrackerClusterChargePerChSigma       = 104, ///< cluster charge per Ch: dispersion
+    
+    kTrackerRecPoints = 105, ///< Tracker : tracker data of clusters (all and mono-cathode ones)
+    
+    kTrackerClusterMultiplicityPerChamber = 200, ///< Tracker: cluster multiplicity per chamber
+    kTrackerClusterChargePerChamber       = 300, ///< Tracker: cluster charge per chamber
+    kTrackerClusterHitMapPerChamber       = 400, ///< Tracker: cluster position distribution per chamber
+    
+    kTrackerNumberOfClustersPerDE        = 1000, ///< Tracker : number of clusters per DE              
+    kTrackerClusterMultiplicityPerDEMean = 1001, ///< cluster size per DE: mean
+    kTrackerClusterChargePerDEMean       = 1002, ///< cluster charge per DE: mean
+    
+    kTrackerClusterMultiplicityPerDE = 3000, ///< Tracker : cluster multiplicity per DE                
+    kTrackerClusterChargePerDE       = 5000,  ///< Tracker : cluster charge per DE
+    
+    kTriggerNAnalyzedEvents           = 0, ///< Number of analyzed events per event specie
+    kTriggerRPCtrips           = 1, ///< Trips in trigger chambers
+    kTriggerRPChv              = 2  ///< Trigger chamber HV index
+    
+  };
+  
+  /// ESD histograms indices
+  enum EESD { 
+    kESDnTracks                 = 0,  ///< number of tracks
+    kESDMatchTrig               = 1,  ///< number of tracks matched with trigger
+    kESDMomentum                = 2,  ///< P distribution
+    kESDPt                      = 3,  ///< Pt distribution
+    kESDRapidity                = 4,  ///< rapidity distribution
+    kESDChi2                    = 5,  ///< normalized chi2 distribution
+    kESDProbChi2                = 6,  ///< distribution of probability of chi2
+    
+    kESDClusterHitMap           = 7,  ///< cluster position distribution in chamber i
+    kESDnClustersPerTrack       = 17, ///< number of clusters per track
+    kESDnClustersPerCh          = 18, ///< number of clusters per chamber per track
+    kESDnClustersPerDE          = 19, ///< number of clusters per DE per track
+    kESDClusterChargeInCh       = 20, ///< cluster charge distribution in chamber i
+    kESDClusterChargePerChMean  = 30, ///< cluster charge per Ch: mean
+    kESDClusterChargePerChSigma = 31, ///< cluster charge per Ch: dispersion
+    kESDClusterChargePerDE      = 32, ///< cluster charge per DE: mean
+    kESDClusterSizeInCh         = 33, ///< cluster size distribution in chamber i
+    kESDClusterSizePerChMean    = 43, ///< cluster size per Ch: mean
+    kESDClusterSizePerChSigma   = 44, ///< cluster size per Ch: dispersion
+    kESDClusterSizePerDE        = 45, ///< cluster size per DE: mean
+    
+    kESDResidualXInCh           = 46, ///< cluster-track residual-X distribution in chamber i
+    kESDResidualYInCh           = 56, ///< cluster-track residual-Y distribution in chamber i
+    kESDResidualXPerChMean      = 66, ///< cluster-track residual-X per Ch: mean
+    kESDResidualYPerChMean      = 67, ///< cluster-track residual-Y per Ch: mean
+    kESDResidualXPerChSigma     = 68, ///< cluster-track residual-X per Ch: dispersion
+    kESDResidualYPerChSigma     = 69, ///< cluster-track residual-Y per Ch: dispersion
+    kESDResidualXPerDEMean      = 70, ///< cluster-track residual-X per DE: mean
+    kESDResidualYPerDEMean      = 71, ///< cluster-track residual-Y per DE: mean
+    kESDResidualXPerDESigma     = 72, ///< cluster-track residual-X per DE: dispersion
+    kESDResidualYPerDESigma     = 73, ///< cluster-track residual-Y per DE: dispersion
+    kESDLocalChi2XInCh          = 74, ///< local chi2-X distribution in chamber i
+    kESDLocalChi2YInCh          = 84, ///< local chi2-Y distribution in chamber i
+    kESDLocalChi2XPerChMean     = 94, ///< local chi2-X per Ch: mean
+    kESDLocalChi2YPerChMean     = 95, ///< local chi2-Y per Ch: mean
+    kESDLocalChi2XPerDEMean     = 96, ///< local chi2-X per DE: mean
+    kESDLocalChi2YPerDEMean     = 97, ///< local chi2-Y per DE: mean
+    kESDLocalChi2InCh           = 98, ///< local chi2-X distribution in chamber i
+    kESDLocalChi2PerChMean      = 108, ///< local chi2 per Ch: mean
+    kESDLocalChi2PerDEMean      = 109, ///< local chi2 per DE: mean
+    
+    kESDThetaX                  = 110, ///< thetaX distribution
+    kESDThetaY                  = 111, ///< thetaY distribution
+    
+    kESDnTotClustersPerCh       = 1000, ///< total number of associated clusters per chamber
+    kESDnTotClustersPerDE       = 1001, ///< total number of associated clusters per DE
+    kESDnTotFullClustersPerDE   = 1002, ///< total number of associated clusters containing pad info per DE
+    kESDSumClusterChargePerDE   = 1003, ///< sum of cluster charge per DE
+    kESDSumClusterSizePerDE     = 1004, ///< sum of cluster size per DE
+    kESDSumResidualXPerDE       = 1005, ///< sum of cluster-track residual-X per DE
+    kESDSumResidualYPerDE       = 1006, ///< sum of cluster-track residual-Y per DE
+    kESDSumResidualX2PerDE      = 1007, ///< sum of cluster-track residual-X**2 per DE
+    kESDSumResidualY2PerDE      = 1008, ///< sum of cluster-track residual-Y**2 per DE
+    kESDSumLocalChi2XPerDE      = 1009, ///< sum of local chi2-X per DE
+    kESDSumLocalChi2YPerDE      = 1010, ///< sum of local chi2-Y per DE
+    kESDSumLocalChi2PerDE       = 1011  ///< sum of local chi2 per DE
+  };
+  
+  // Bins for summary histos
+  enum {
+    kTriggerRespStrips,    ///< Bin for % of responding trigger strips
+    kTriggerRespLocal,     ///< Bin for % of responding trigger local boards
+    kTriggerRespRegional,  ///< Bin for % of responding trigger regional boards
+    kTriggerRespGlobal,    ///< Bin for % of responding trigger global boards
+    kTriggerNoisyStrips,   ///< Bin for % of noisy trigger strips
+    kNtrigCalibSummaryBins ///< Total number of bins for trigger calibration summary
+  };
+  
+  // Bins for algorithm error histos
+  enum {
+    kAlgoLocalX,             ///< Bin for % of local board X pos errors
+    kAlgoLocalY,             ///< Bin for % of local board Y pos errors
+    kAlgoLocalLUT,           ///< Bin for % of local board deviation errors
+    kAlgoLocalYCopy,         ///< Bin for % of local board Y copy errors
+    kAlgoLocalToRegional,    ///< Bin for % of local to regional errors
+    kAlgoRegional,           ///< Bin for % of regional board errors 
+    kAlgoRegionalToGlobal,   ///< Bin for % of regional to global errors 
+    kAlgoGlobalFromGlobal,   ///< Bin for % of global from global board errors 
+    kAlgoGlobalFromLocal,    ///< Bin for % of global from local board errors 
+    kAlgoGlobalFromRegional, ///< Bin for % of global from regional board errors 
+    kNtrigAlgoErrorBins      ///< Total number of bins for trigger error summary
+  };
+  
+  enum {
+    kLocalStructError,    ///< Bin for % of errors in local struct
+    kRegionalStructError, ///< Bin for % of errors in regional struct
+    kGlobalStructError,   ///< Bin for % of errors in global struct
+    kDarcStructError,     ///< Bin for % of errors in darc struct
+    kNtrigStructErrorBins ///< Total number of bins for struct error summary
+  };
+    
+  
+}
+
+#endif
index 7ee19c0..2d3cfe1 100644 (file)
@@ -29,8 +29,8 @@
 #include "AliCDBManager.h"
 #include "AliCodeTimer.h"
 #include "AliLog.h"
+#include "AliMUONQAIndices.h"
 #include "AliMUONRecoParam.h"
-#include "AliMUONTrackerQADataMakerRec.h"
 #include "AliMpBusPatch.h"
 #include "AliMpDDLStore.h"
 #include "AliQAv1.h"
@@ -170,9 +170,10 @@ AliMUONTrackerQAChecker::CheckRecPoints(TObjArray ** list, AliMUONRecoParam* /*r
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
     rv[specie] =  AliMUONVQAChecker::kInfo; 
   
+  
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
   {
-    TH1* h = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerNumberOfClustersPerDE,AliRecoParam::ConvertIndex(specie));
+    TH1* h = AliQAv1::GetData(list,AliMUONQAIndices::kTrackerNumberOfClustersPerDE,AliRecoParam::ConvertIndex(specie));
 
     if ( !h ) rv[specie] = AliMUONVQAChecker::kWarning; // only a warning if histo not found, in order not to kill anything because QA failed...
   
@@ -209,13 +210,13 @@ AliMUONTrackerQAChecker::CheckESD(TObjArray ** list, AliMUONRecoParam* /*recoPar
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     
-    TH1* h = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kESDnTracks,AliRecoParam::ConvertIndex(specie));
+    TH1* h = AliQAv1::GetData(list,AliMUONQAIndices::kESDnTracks,AliRecoParam::ConvertIndex(specie));
   
     if (!h) rv[specie] = AliMUONVQAChecker::kWarning;
   
     else if ( h->GetMean() == 0.0 ) rv[specie] =  MarkHisto(*h,AliMUONVQAChecker::kFatal); // no track -> fatal
   
-    h = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kESDMatchTrig,AliRecoParam::ConvertIndex(specie));
+    h = AliQAv1::GetData(list,AliMUONQAIndices::kESDMatchTrig,AliRecoParam::ConvertIndex(specie));
   
     if (!h) rv[specie] = AliMUONVQAChecker::kWarning;
   
@@ -243,11 +244,11 @@ AliMUONTrackerQAChecker::CheckRaws(TObjArray ** list, AliMUONRecoParam* recoPara
   
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
   {
-    TH1* hbp = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchOccupancy,AliRecoParam::ConvertIndex(specie));    
+    TH1* hbp = AliQAv1::GetData(list,AliMUONQAIndices::kTrackerBusPatchOccupancy,AliRecoParam::ConvertIndex(specie));    
 
-    TH1* hnpads = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchNofPads,AliRecoParam::ConvertIndex(specie));
+    TH1* hnpads = AliQAv1::GetData(list,AliMUONQAIndices::kTrackerBusPatchNofPads,AliRecoParam::ConvertIndex(specie));
 
-    TH1* hbpconfig = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchConfig,AliRecoParam::ConvertIndex(specie));
+    TH1* hbpconfig = AliQAv1::GetData(list,AliMUONQAIndices::kTrackerBusPatchConfig,AliRecoParam::ConvertIndex(specie));
 
     if (!hbp || !hnpads ) 
     {
index 0b0411a..b330c0b 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliQAv1.h"
 #include "AliMUONConstants.h"  
 #include "AliMUONDigitMaker.h"
+#include "AliMUONQAIndices.h"
 #include "AliMUONQAMappingCheck.h"
 #include "AliMUONTrackerDataMaker.h"
 #include "AliMUONVCluster.h"
@@ -127,45 +128,45 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**)
 {
   /// Normalize ESD histograms
   
-  if (!GetESDsData(kESDnClustersPerTrack)) return;
+  if (!GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)) return;
   
-  Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries();
+  Double_t nTracks = GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->GetEntries();
   if (nTracks <= 0) return;
   
-  TH1* hESDnClustersPerCh = GetESDsData(kESDnClustersPerCh);
-  TH1* hESDnClustersPerDE = GetESDsData(kESDnClustersPerDE);
-  TH1* hESDClusterChargePerChMean = GetESDsData(kESDClusterChargePerChMean);
-  TH1* hESDClusterChargePerChSigma = GetESDsData(kESDClusterChargePerChSigma);
-  TH1* hESDClusterSizePerChMean = GetESDsData(kESDClusterSizePerChMean);
-  TH1* hESDClusterSizePerChSigma = GetESDsData(kESDClusterSizePerChSigma);
-  TH1* hESDResidualXPerChMean = GetESDsData(kESDResidualXPerChMean);
-  TH1* hESDResidualXPerChSigma = GetESDsData(kESDResidualXPerChSigma);
-  TH1* hESDResidualYPerChMean = GetESDsData(kESDResidualYPerChMean);
-  TH1* hESDResidualYPerChSigma = GetESDsData(kESDResidualYPerChSigma);
-  TH1* hESDLocalChi2XPerChMean = GetESDsData(kESDLocalChi2XPerChMean);
-  TH1* hESDLocalChi2YPerChMean = GetESDsData(kESDLocalChi2YPerChMean);
-  TH1* hESDLocalChi2PerChMean = GetESDsData(kESDLocalChi2PerChMean);
-  TH1* hESDClusterChargePerDE = GetESDsData(kESDClusterChargePerDE);
-  TH1* hESDClusterSizePerDE = GetESDsData(kESDClusterSizePerDE);
-  TH1* hESDResidualXPerDEMean = GetESDsData(kESDResidualXPerDEMean);
-  TH1* hESDResidualXPerDESigma = GetESDsData(kESDResidualXPerDESigma);
-  TH1* hESDResidualYPerDEMean = GetESDsData(kESDResidualYPerDEMean);
-  TH1* hESDResidualYPerDESigma = GetESDsData(kESDResidualYPerDESigma);
-  TH1* hESDLocalChi2XPerDEMean = GetESDsData(kESDLocalChi2XPerDEMean);
-  TH1* hESDLocalChi2YPerDEMean = GetESDsData(kESDLocalChi2YPerDEMean);
-  TH1* hESDLocalChi2PerDEMean = GetESDsData(kESDLocalChi2PerDEMean);
-  TH1* hESDnTotClustersPerCh = GetESDsData(kESDnTotClustersPerCh);
-  TH1* hESDnTotClustersPerDE = GetESDsData(kESDnTotClustersPerDE);
-  TH1* hESDnTotFullClustersPerDE = GetESDsData(kESDnTotFullClustersPerDE);
-  TH1* hESDSumClusterChargePerDE = GetESDsData(kESDSumClusterChargePerDE);
-  TH1* hESDSumClusterSizePerDE = GetESDsData(kESDSumClusterSizePerDE);
-  TH1* hESDSumResidualXPerDE = GetESDsData(kESDSumResidualXPerDE);
-  TH1* hESDSumResidualYPerDE = GetESDsData(kESDSumResidualYPerDE);
-  TH1* hESDSumResidualX2PerDE = GetESDsData(kESDSumResidualX2PerDE);
-  TH1* hESDSumResidualY2PerDE = GetESDsData(kESDSumResidualY2PerDE);
-  TH1* hESDSumLocalChi2XPerDE = GetESDsData(kESDSumLocalChi2XPerDE);
-  TH1* hESDSumLocalChi2YPerDE = GetESDsData(kESDSumLocalChi2YPerDE);
-  TH1* hESDSumLocalChi2PerDE = GetESDsData(kESDSumLocalChi2PerDE);
+  TH1* hESDnClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnClustersPerCh);
+  TH1* hESDnClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnClustersPerDE);
+  TH1* hESDClusterChargePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChMean);
+  TH1* hESDClusterChargePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChSigma);
+  TH1* hESDClusterSizePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChMean);
+  TH1* hESDClusterSizePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChSigma);
+  TH1* hESDResidualXPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerChMean);
+  TH1* hESDResidualXPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerChSigma);
+  TH1* hESDResidualYPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerChMean);
+  TH1* hESDResidualYPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerChSigma);
+  TH1* hESDLocalChi2XPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerChMean);
+  TH1* hESDLocalChi2YPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerChMean);
+  TH1* hESDLocalChi2PerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerChMean);
+  TH1* hESDClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDClusterChargePerDE);
+  TH1* hESDClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDClusterSizePerDE);
+  TH1* hESDResidualXPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerDEMean);
+  TH1* hESDResidualXPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerDESigma);
+  TH1* hESDResidualYPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerDEMean);
+  TH1* hESDResidualYPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerDESigma);
+  TH1* hESDLocalChi2XPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerDEMean);
+  TH1* hESDLocalChi2YPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerDEMean);
+  TH1* hESDLocalChi2PerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerDEMean);
+  TH1* hESDnTotClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh);
+  TH1* hESDnTotClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE);
+  TH1* hESDnTotFullClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE);
+  TH1* hESDSumClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE);
+  TH1* hESDSumClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE);
+  TH1* hESDSumResidualXPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE);
+  TH1* hESDSumResidualYPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE);
+  TH1* hESDSumResidualX2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE);
+  TH1* hESDSumResidualY2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE);
+  TH1* hESDSumLocalChi2XPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE);
+  TH1* hESDSumLocalChi2YPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE);
+  TH1* hESDSumLocalChi2PerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE);
   
   hESDnClustersPerCh->Reset();
   hESDnClustersPerDE->Reset();
@@ -175,45 +176,45 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**)
   // loop over chambers
   for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
     
-    TH1* hESDClusterChargeInCh = GetESDsData(kESDClusterChargeInCh+iCh);
+    TH1* hESDClusterChargeInCh = GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+iCh);
     Double_t sigmaCharge = hESDClusterChargeInCh->GetRMS();
     hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean());
     hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError());
     hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
     hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError());
     
-    TH1* hESDClusterSizeInCh = GetESDsData(kESDClusterSizeInCh+iCh);
+    TH1* hESDClusterSizeInCh = GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+iCh);
     Double_t sigmaSize = hESDClusterSizeInCh->GetRMS();
     hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean());
     hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError());
     hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize);
     hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError());
     
-    TH1* hESDResidualXInCh = GetESDsData(kESDResidualXInCh+iCh);
+    TH1* hESDResidualXInCh = GetESDsData(AliMUONQAIndices::kESDResidualXInCh+iCh);
     Double_t sigmaResidualX = hESDResidualXInCh->GetRMS();
     hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean());
     hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError());
     hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX);
     hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError());
     
-    TH1* hESDResidualYInCh = GetESDsData(kESDResidualYInCh+iCh);
+    TH1* hESDResidualYInCh = GetESDsData(AliMUONQAIndices::kESDResidualYInCh+iCh);
     Double_t sigmaResidualY = hESDResidualYInCh->GetRMS();
     hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean());
     hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError());
     hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY);
     hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError());
     
-    TH1* hESDLocalChi2XInCh = GetESDsData(kESDLocalChi2XInCh+iCh);
+    TH1* hESDLocalChi2XInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+iCh);
     Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
     hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
     hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
     
-    TH1* hESDLocalChi2YInCh = GetESDsData(kESDLocalChi2YInCh+iCh);
+    TH1* hESDLocalChi2YInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+iCh);
     Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
     hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
     hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
     
-    TH1* hESDLocalChi2InCh = GetESDsData(kESDLocalChi2InCh+iCh);
+    TH1* hESDLocalChi2InCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+iCh);
     Double_t sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS();
     hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean());
     hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError());
@@ -303,26 +304,26 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TOb
 {
   /// Normalize RecPoints histograms
   
-  if (!GetRecPointsData(kTrackerClusterChargePerChMean)) return;
+  if (!GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean)) return;
   
-  TH1* hTrackerClusterChargePerChMean = GetRecPointsData(kTrackerClusterChargePerChMean);
-  TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(kTrackerClusterChargePerChSigma);
-  TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(kTrackerClusterMultiplicityPerChMean);
-  TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(kTrackerClusterMultiplicityPerChSigma);
-  TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(kTrackerClusterChargePerDEMean);
-  TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(kTrackerClusterMultiplicityPerDEMean);
+  TH1* hTrackerClusterChargePerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean);
+  TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChSigma);
+  TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean);
+  TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma);
+  TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDEMean);
+  TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean);
   
   // loop over chambers
   for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
     
-    TH1* hTrackerClusterChargePerChamber = GetRecPointsData(kTrackerClusterChargePerChamber+iCh);
+    TH1* hTrackerClusterChargePerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+iCh);
     Double_t sigmaCharge = hTrackerClusterChargePerChamber->GetRMS();
     hTrackerClusterChargePerChMean->SetBinContent(iCh+1, hTrackerClusterChargePerChamber->GetMean());
     hTrackerClusterChargePerChMean->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetMeanError());
     hTrackerClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
     hTrackerClusterChargePerChSigma->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetRMSError());
     
-    TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(kTrackerClusterMultiplicityPerChamber+iCh);
+    TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+iCh);
     Double_t sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS();
     hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean());
     hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError());
@@ -336,13 +337,13 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TOb
       
       Int_t iDE = it.CurrentDEId();
       
-      TH1* hTrackerClusterChargePerDE = GetRecPointsData(kTrackerClusterChargePerDE+iDE);
+      TH1* hTrackerClusterChargePerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+iDE);
       hTrackerClusterChargePerDEMean->SetBinContent(iDE+1, hTrackerClusterChargePerDE->GetMean());
       Double_t nClusters = hTrackerClusterChargePerDE->GetEntries();
       if (nClusters > 1) hTrackerClusterChargePerDEMean->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
       else hTrackerClusterChargePerDEMean->SetBinError(iDE+1, hTrackerClusterChargePerChamber->GetXaxis()->GetXmax());
       
-      TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(kTrackerClusterMultiplicityPerDE+iDE);
+      TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+iDE);
       hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean());
       nClusters = hTrackerClusterMultiplicityPerDE->GetEntries();
       if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters));
@@ -352,7 +353,7 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TOb
     }
   }
   
-  if ( fMappingCheckRecPoints ) InsertTrackerData(specie,list,fMappingCheckRecPoints->CreateData("RecPoints"),kTrackerRecPoints,kTRUE);
+  if ( fMappingCheckRecPoints ) InsertTrackerData(specie,list,fMappingCheckRecPoints->CreateData("RecPoints"),AliMUONQAIndices::kTrackerRecPoints,kTRUE);
 }
 
 
@@ -361,13 +362,13 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRaws(Int_t specie, TObjArra
 {
   /// create Raws histograms in Raws subdir
   
-  if ( !GetRawsData(kTrackerBusPatchOccupancy) ) return;
+  if ( !GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy) ) return;
 
   if ( fTrackerDataMaker ) 
   {
-    InsertTrackerData(specie,list,fTrackerDataMaker->Data(),kTrackerData);
+    InsertTrackerData(specie,list,fTrackerDataMaker->Data(),AliMUONQAIndices::kTrackerData);
 
-    TH1* hbp = GetRawsData(kTrackerBusPatchOccupancy);
+    TH1* hbp = GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy);
     hbp->Reset();
     TIter nextBP(AliMpDDLStore::Instance()->CreateBusPatchIterator());
     AliMpBusPatch* bp(0x0);
@@ -416,9 +417,9 @@ void AliMUONTrackerQADataMakerRec::InitRaws()
 
   TH1* hbpnmanus = new TH1F("hTrackerBusPatchNofManus","Number of manus per bus patch",nbins,xmin,xmax);
 
-  Add2RawsList(hbp,kTrackerBusPatchOccupancy, !expert, image, !saveCorr);
-  Add2RawsList(hbpnpads,kTrackerBusPatchNofPads, expert, !image, !saveCorr);
-  Add2RawsList(hbpnmanus,kTrackerBusPatchNofManus, expert, !image, !saveCorr);
+  Add2RawsList(hbp,AliMUONQAIndices::kTrackerBusPatchOccupancy, !expert, image, !saveCorr);
+  Add2RawsList(hbpnpads,AliMUONQAIndices::kTrackerBusPatchNofPads, expert, !image, !saveCorr);
+  Add2RawsList(hbpnmanus,AliMUONQAIndices::kTrackerBusPatchNofManus, expert, !image, !saveCorr);
 
   const Bool_t histogram(kFALSE);
 
@@ -446,7 +447,7 @@ void AliMUONTrackerQADataMakerRec::InitRaws()
   if (config)
   {
     hbpconfig = new TH1F("hTrackerBusPatchConfig","Configuration of bus patches",nbins,xmin,xmax);
-    Add2RawsList(hbpconfig,kTrackerBusPatchConfig, expert, !image, !saveCorr);
+    Add2RawsList(hbpconfig,AliMUONQAIndices::kTrackerBusPatchConfig, expert, !image, !saveCorr);
   }
   else
   {
@@ -507,43 +508,43 @@ void AliMUONTrackerQADataMakerRec::InitRecPoints()
   for ( Int_t i = 0; i < nCh; ++i ) 
   {
     h1I = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads};Counts)",i+1), 100,0,100);
-    Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i, expert, !image);
+    Add2RecPointsList(h1I,AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+i, expert, !image);
     
     h1I = new TH1I(Form("hTrackerClusterChargeForChamber%d",i+1), Form("cluster charge distribution in chamber %d;charge (fC);Counts",i+1), 100,0,1000);
-    Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i, expert, !image);
+    Add2RecPointsList(h1I,AliMUONQAIndices::kTrackerClusterChargePerChamber+i, expert, !image);
     
     Float_t rMax = AliMUONConstants::Rmax(i/2);
     h2F = new TH2F(Form("hTrackerClusterHitMapForChamber%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1), 100, -rMax, rMax, 100, -rMax, rMax);
-    Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i, expert, !image);
+    Add2RecPointsList(h2F, AliMUONQAIndices::kTrackerClusterHitMapPerChamber+i, expert, !image);
   }
   
   // summary histograms per chamber
   h1I = new TH1I("hTrackerNumberOfClustersPerChamber", "Number of clusters per chamber;chamber ID;n_{clusters}", nCh,-0.5,nCh-0.5);
-  Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber, !expert, image);
+  Add2RecPointsList(h1I,AliMUONQAIndices::kTrackerNumberOfClustersPerChamber, !expert, image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean, !expert, image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma, !expert, image);
   
   h1F = new TH1F("hTrackerClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (fC)", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerChMean, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterChargePerChMean, !expert, image);
   
   h1F = new TH1F("hTrackerClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (fC)", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterChargePerChSigma, !expert, image);
   
   // histograms per DE
   Int_t ndes(0);
@@ -558,10 +559,10 @@ void AliMUONTrackerQADataMakerRec::InitRecPoints()
       ndes = TMath::Max(ndes,detElemId);
       
       h1I = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId), Form("cluster size distribution in detection element %d;size (n_{pads})",detElemId), 100,0,100);
-      Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId, expert, !image);
+      Add2RecPointsList(h1I,AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId, expert, !image);
       
       h1I = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId), Form("cluster charge distribution in detection element %d;charge (fC)",detElemId), 100,0,1000);
-      Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId, expert, !image);
+      Add2RecPointsList(h1I,AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId, expert, !image);
     }
     
     it.Next();
@@ -569,19 +570,19 @@ void AliMUONTrackerQADataMakerRec::InitRecPoints()
   
   // summary histograms per DE
   h1I = new TH1I("hTrackerNumberOfClustersPerDE", "Number of clusters per detection element;DetElem ID;n_{clusters}", ndes+1,-0.5,ndes+0.5);
-  Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE, !expert, image);
+  Add2RecPointsList(h1I, AliMUONQAIndices::kTrackerNumberOfClustersPerDE, !expert, image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerDEMean", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", ndes+1,-0.5,ndes+0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean, !expert, image);
   
   h1F = new TH1F("hTrackerClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID;<charge> (fC)", ndes+1,-0.5,ndes+0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean, !expert, image);
+  Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterChargePerDEMean, !expert, image);
   
   if (!fMappingCheckRecPoints) fMappingCheckRecPoints = new AliMUONQAMappingCheck(RunNumber());  
 }
@@ -599,224 +600,224 @@ void AliMUONTrackerQADataMakerRec::InitESDs()
   
   // track info
   TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDnTracks, kESDnTracks, !expert, image);
+  Add2ESDsList(hESDnTracks, AliMUONQAIndices::kESDnTracks, !expert, image);
 
   TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDMatchTrig, kESDMatchTrig, !expert, image);
+  Add2ESDsList(hESDMatchTrig, AliMUONQAIndices::kESDMatchTrig, !expert, image);
   
   TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
-  Add2ESDsList(hESDMomentum, kESDMomentum, !expert, image);
+  Add2ESDsList(hESDMomentum, AliMUONQAIndices::kESDMomentum, !expert, image);
 
   TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
-  Add2ESDsList(hESDPt, kESDPt, !expert, image);
+  Add2ESDsList(hESDPt, AliMUONQAIndices::kESDPt, !expert, image);
 
   TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
-  Add2ESDsList(hESDRapidity, kESDRapidity, !expert, image);
+  Add2ESDsList(hESDRapidity, AliMUONQAIndices::kESDRapidity, !expert, image);
 
   TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
-  Add2ESDsList(hESDChi2, kESDChi2, !expert, image);
+  Add2ESDsList(hESDChi2, AliMUONQAIndices::kESDChi2, !expert, image);
   
   TH1F* hESDProbChi2 = new TH1F("hESDProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
-  Add2ESDsList(hESDProbChi2, kESDProbChi2, !expert, image);
+  Add2ESDsList(hESDProbChi2, AliMUONQAIndices::kESDProbChi2, !expert, image);
   
   TH1F* hESDThetaX = new TH1F("hESDThetaX", "#theta_{X} distribution;#theta_{X} (degree)", 360, -180., 180);
-  Add2ESDsList(hESDThetaX, kESDThetaX, !expert, image);
+  Add2ESDsList(hESDThetaX, AliMUONQAIndices::kESDThetaX, !expert, image);
   
   TH1F* hESDThetaY = new TH1F("hESDThetaY", "#theta_{Y} distribution;#theta_{Y} (degree)", 360, -180., 180);
-  Add2ESDsList(hESDThetaY, kESDThetaY, !expert, image);
+  Add2ESDsList(hESDThetaY, AliMUONQAIndices::kESDThetaY, !expert, image);
   
   // cluster info
   for (Int_t i = 0; i < nCh; i++) {
     Float_t rMax = AliMUONConstants::Rmax(i/2);
     TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
                                       100, -rMax, rMax, 100, -rMax, rMax);
-    Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i, expert, !image);
+    Add2ESDsList(hESDClusterHitMap, AliMUONQAIndices::kESDClusterHitMap+i, expert, !image);
   }
   
   TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
-  Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack, !expert, image);
+  Add2ESDsList(hESDnClustersPerTrack, AliMUONQAIndices::kESDnClustersPerTrack, !expert, image);
   
   TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, -0.5, nCh-0.5);
   hESDnClustersPerCh->SetFillColor(kRed);
-  Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh, !expert, image);
+  Add2ESDsList(hESDnClustersPerCh, AliMUONQAIndices::kESDnClustersPerCh, !expert, image);
   
   TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE+1, -0.5, nDE+0.5);
   hESDnClustersPerDE->SetFillColor(kRed);
-  Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE, !expert, image);
+  Add2ESDsList(hESDnClustersPerDE, AliMUONQAIndices::kESDnClustersPerDE, !expert, image);
   
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (fC)",i+1), 100, 0., 1000.);
-    Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i, expert, !image);
+    Add2ESDsList(hESDClusterChargeInCh, AliMUONQAIndices::kESDClusterChargeInCh+i, expert, !image);
   }
   
   TH1F* hESDClusterChargePerChMean = new TH1F("hESDClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (fC)", nCh, -0.5, nCh-0.5);
   hESDClusterChargePerChMean->SetOption("P");
   hESDClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean, !expert, image);
+  Add2ESDsList(hESDClusterChargePerChMean, AliMUONQAIndices::kESDClusterChargePerChMean, !expert, image);
   
   TH1F* hESDClusterChargePerChSigma = new TH1F("hESDClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (fC)", nCh, -0.5, nCh-0.5);
   hESDClusterChargePerChSigma->SetOption("P");
   hESDClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma, !expert, image);
+  Add2ESDsList(hESDClusterChargePerChSigma, AliMUONQAIndices::kESDClusterChargePerChSigma, !expert, image);
   
   TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID;<charge> (fC)", nDE+1, -0.5, nDE+0.5);
   hESDClusterChargePerDE->SetOption("P");
   hESDClusterChargePerDE->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerDE->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE, !expert, image);
+  Add2ESDsList(hESDClusterChargePerDE, AliMUONQAIndices::kESDClusterChargePerDE, !expert, image);
   
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDClusterSizeInCh = new TH1F(Form("hESDClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
-    Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i, expert, !image);
+    Add2ESDsList(hESDClusterSizeInCh, AliMUONQAIndices::kESDClusterSizeInCh+i, expert, !image);
   }
   
   TH1F* hESDClusterSizePerChMean = new TH1F("hESDClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, -0.5, nCh-0.5);
   hESDClusterSizePerChMean->SetOption("P");
   hESDClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean, !expert, image);
+  Add2ESDsList(hESDClusterSizePerChMean, AliMUONQAIndices::kESDClusterSizePerChMean, !expert, image);
   
   TH1F* hESDClusterSizePerChSigma = new TH1F("hESDClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5);
   hESDClusterSizePerChSigma->SetOption("P");
   hESDClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma, !expert, image);
+  Add2ESDsList(hESDClusterSizePerChSigma, AliMUONQAIndices::kESDClusterSizePerChSigma, !expert, image);
   
   TH1F* hESDClusterSizePerDE = new TH1F("hESDClusterSizePerDE", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE+1, -0.5, nDE+0.5);
   hESDClusterSizePerDE->SetOption("P");
   hESDClusterSizePerDE->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerDE->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE, !expert, image);
+  Add2ESDsList(hESDClusterSizePerDE, AliMUONQAIndices::kESDClusterSizePerDE, !expert, image);
   
   // cluster - track info
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d;#Delta_{X} (cm)",i+1), 1000, -5., 5.);
-    Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i, expert, !image);
+    Add2ESDsList(hESDResidualXInCh, AliMUONQAIndices::kESDResidualXInCh+i, expert, !image);
     
     TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d;#Delta_{Y} (cm)",i+1), 1000, -1., 1.);
-    Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i, expert, !image);
+    Add2ESDsList(hESDResidualYInCh, AliMUONQAIndices::kESDResidualYInCh+i, expert, !image);
     
     TH1F* hESDLocalChi2XInCh = new TH1F(Form("hESDLocalChi2XInCh%d",i+1), Form("local chi2-X distribution in chamber %d;local #chi^{2}_{X}",i+1), 1000, 0., 25);
-    Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i, expert, !image);
+    Add2ESDsList(hESDLocalChi2XInCh, AliMUONQAIndices::kESDLocalChi2XInCh+i, expert, !image);
     
     TH1F* hESDLocalChi2YInCh = new TH1F(Form("hESDLocalChi2YInCh%d",i+1), Form("local chi2-Y distribution in chamber %d;local #chi^{2}_{Y}",i+1), 1000, 0., 25);
-    Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i, expert, !image);
+    Add2ESDsList(hESDLocalChi2YInCh, AliMUONQAIndices::kESDLocalChi2YInCh+i, expert, !image);
     
     TH1F* hESDLocalChi2InCh = new TH1F(Form("hESDLocalChi2InCh%d",i+1), Form("local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) distribution in chamber %d;local #chi^{2}",i+1), 1000, 0., 25);
-    Add2ESDsList(hESDLocalChi2InCh, kESDLocalChi2InCh+i, expert, !image);
+    Add2ESDsList(hESDLocalChi2InCh, AliMUONQAIndices::kESDLocalChi2InCh+i, expert, !image);
   }
   
   TH1F* hESDResidualXPerChMean = new TH1F("hESDResidualXPerChMean", "cluster-track residual-X per Ch: mean;chamber ID;<#Delta_{X}> (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualXPerChMean->SetOption("P");
   hESDResidualXPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean, !expert, image);
+  Add2ESDsList(hESDResidualXPerChMean, AliMUONQAIndices::kESDResidualXPerChMean, !expert, image);
   
   TH1F* hESDResidualYPerChMean = new TH1F("hESDResidualYPerChMean", "cluster-track residual-Y per Ch: mean;chamber ID;<#Delta_{Y}> (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualYPerChMean->SetOption("P");
   hESDResidualYPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean, !expert, image);
+  Add2ESDsList(hESDResidualYPerChMean, AliMUONQAIndices::kESDResidualYPerChMean, !expert, image);
   
   TH1F* hESDResidualXPerChSigma = new TH1F("hESDResidualXPerChSigma", "cluster-track residual-X per Ch: sigma;chamber ID;#sigma_{X} (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualXPerChSigma->SetOption("P");
   hESDResidualXPerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma, !expert, image);
+  Add2ESDsList(hESDResidualXPerChSigma, AliMUONQAIndices::kESDResidualXPerChSigma, !expert, image);
   
   TH1F* hESDResidualYPerChSigma = new TH1F("hESDResidualYPerChSigma", "cluster-track residual-Y per Ch: sigma;chamber ID;#sigma_{Y} (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualYPerChSigma->SetOption("P");
   hESDResidualYPerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma, !expert, image);
+  Add2ESDsList(hESDResidualYPerChSigma, AliMUONQAIndices::kESDResidualYPerChSigma, !expert, image);
   
   TH1F* hESDLocalChi2XPerChMean = new TH1F("hESDLocalChi2XPerCh", "local chi2-X per Ch: mean;chamber ID;<local #chi^{2}_{X}>", nCh, -0.5, nCh-0.5);
   hESDLocalChi2XPerChMean->SetOption("P");
   hESDLocalChi2XPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2XPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2XPerChMean, AliMUONQAIndices::kESDLocalChi2XPerChMean, !expert, image);
   
   TH1F* hESDLocalChi2YPerChMean = new TH1F("hESDLocalChi2YPerCh", "local chi2-Y per Ch: mean;chamber ID;<local #chi^{2}_{Y}>", nCh, -0.5, nCh-0.5);
   hESDLocalChi2YPerChMean->SetOption("P");
   hESDLocalChi2YPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2YPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2YPerChMean, AliMUONQAIndices::kESDLocalChi2YPerChMean, !expert, image);
   
   TH1F* hESDLocalChi2PerChMean = new TH1F("hESDLocalChi2PerCh", "local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) per Ch: mean;chamber ID;<local #chi^{2}>", nCh, -0.5, nCh-0.5);
   hESDLocalChi2PerChMean->SetOption("P");
   hESDLocalChi2PerChMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2PerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2PerChMean, kESDLocalChi2PerChMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2PerChMean, AliMUONQAIndices::kESDLocalChi2PerChMean, !expert, image);
   
   TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID;<#Delta_{X}> (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualXPerDEMean->SetOption("P");
   hESDResidualXPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean, !expert, image);
+  Add2ESDsList(hESDResidualXPerDEMean, AliMUONQAIndices::kESDResidualXPerDEMean, !expert, image);
   
   TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID;<#Delta_{Y}> (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualYPerDEMean->SetOption("P");
   hESDResidualYPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean, !expert, image);
+  Add2ESDsList(hESDResidualYPerDEMean, AliMUONQAIndices::kESDResidualYPerDEMean, !expert, image);
   
   TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID;#sigma_{X} (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualXPerDESigma->SetOption("P");
   hESDResidualXPerDESigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerDESigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma, !expert, image);
+  Add2ESDsList(hESDResidualXPerDESigma, AliMUONQAIndices::kESDResidualXPerDESigma, !expert, image);
   
   TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID;#sigma_{Y} (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualYPerDESigma->SetOption("P");
   hESDResidualYPerDESigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerDESigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma, !expert, image);
+  Add2ESDsList(hESDResidualYPerDESigma, AliMUONQAIndices::kESDResidualYPerDESigma, !expert, image);
   
   TH1F* hESDLocalChi2XPerDEMean = new TH1F("hESDLocalChi2XPerDE", "local chi2-X per DE: mean;DetElem ID;<local #chi^{2}_{X}>", nDE+1, -0.5, nDE+0.5);
   hESDLocalChi2XPerDEMean->SetOption("P");
   hESDLocalChi2XPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2XPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2XPerDEMean, AliMUONQAIndices::kESDLocalChi2XPerDEMean, !expert, image);
   
   TH1F* hESDLocalChi2YPerDEMean = new TH1F("hESDLocalChi2YPerDE", "local chi2-Y per DE: mean;DetElem ID;<local #chi^{2}_{Y}>", nDE+1, -0.5, nDE+0.5);
   hESDLocalChi2YPerDEMean->SetOption("P");
   hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2YPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2YPerDEMean, AliMUONQAIndices::kESDLocalChi2YPerDEMean, !expert, image);
   
   TH1F* hESDLocalChi2PerDEMean = new TH1F("hESDLocalChi2PerDE", "local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) per DE: mean;DetElem ID;<local #chi^{2}>", nDE+1, -0.5, nDE+0.5);
   hESDLocalChi2PerDEMean->SetOption("P");
   hESDLocalChi2PerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2PerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2PerDEMean, kESDLocalChi2PerDEMean, !expert, image);
+  Add2ESDsList(hESDLocalChi2PerDEMean, AliMUONQAIndices::kESDLocalChi2PerDEMean, !expert, image);
   
   // intermediate histograms
   TH1F* hESDnTotClustersPerCh = new TH1F("hESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID;#Sigma(n_{clusters})", nCh, -0.5, nCh-0.5);
-  Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, expert, !image);
+  Add2ESDsList(hESDnTotClustersPerCh, AliMUONQAIndices::kESDnTotClustersPerCh, expert, !image);
   TH1F* hESDnTotClustersPerDE = new TH1F("hESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID;#Sigma(n_{clusters})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, expert, !image);
+  Add2ESDsList(hESDnTotClustersPerDE, AliMUONQAIndices::kESDnTotClustersPerDE, expert, !image);
   TH1F* hESDnTotFullClustersPerDE = new TH1F("hESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID;#Sigma(n_{full clusters})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, expert, !image);
+  Add2ESDsList(hESDnTotFullClustersPerDE, AliMUONQAIndices::kESDnTotFullClustersPerDE, expert, !image);
   TH1F* hESDSumClusterChargePerDE = new TH1F("hESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;#Sigma(charge) (fC)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, expert, !image);
+  Add2ESDsList(hESDSumClusterChargePerDE, AliMUONQAIndices::kESDSumClusterChargePerDE, expert, !image);
   TH1F* hESDSumClusterSizePerDE = new TH1F("hESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;#Sigma(size) (n_{pads})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, expert, !image);
+  Add2ESDsList(hESDSumClusterSizePerDE, AliMUONQAIndices::kESDSumClusterSizePerDE, expert, !image);
   TH1F* hESDSumResidualXPerDE = new TH1F("hESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID;#Sigma(#Delta_{X}) (cm)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, expert, !image);
+  Add2ESDsList(hESDSumResidualXPerDE, AliMUONQAIndices::kESDSumResidualXPerDE, expert, !image);
   TH1F* hESDSumResidualYPerDE = new TH1F("hESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID;#Sigma(#Delta_{Y}) (cm)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, expert, !image);
+  Add2ESDsList(hESDSumResidualYPerDE, AliMUONQAIndices::kESDSumResidualYPerDE, expert, !image);
   TH1F* hESDSumResidualX2PerDE = new TH1F("hESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID;#Sigma(#Delta_{X}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, expert, !image);
+  Add2ESDsList(hESDSumResidualX2PerDE, AliMUONQAIndices::kESDSumResidualX2PerDE, expert, !image);
   TH1F* hESDSumResidualY2PerDE = new TH1F("hESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID;#Sigma(#Delta_{Y}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, expert, !image);
+  Add2ESDsList(hESDSumResidualY2PerDE, AliMUONQAIndices::kESDSumResidualY2PerDE, expert, !image);
   TH1F* hESDSumLocalChi2XPerDE = new TH1F("hESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID;#Sigma(local #chi^{2}_{X})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, expert, !image);
+  Add2ESDsList(hESDSumLocalChi2XPerDE, AliMUONQAIndices::kESDSumLocalChi2XPerDE, expert, !image);
   TH1F* hESDSumLocalChi2YPerDE = new TH1F("hESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID;#Sigma(local #chi^{2}_{Y})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, expert, !image);
+  Add2ESDsList(hESDSumLocalChi2YPerDE, AliMUONQAIndices::kESDSumLocalChi2YPerDE, expert, !image);
   TH1F* hESDSumLocalChi2PerDE = new TH1F("hESDSumLocalChi2PerDE", "sum of local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) per DE;DetElem ID;#Sigma(local #chi^{2})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumLocalChi2PerDE, kESDSumLocalChi2PerDE, expert, !image);
+  Add2ESDsList(hESDSumLocalChi2PerDE, AliMUONQAIndices::kESDSumLocalChi2PerDE, expert, !image);
 }
 
 //____________________________________________________________________________
@@ -827,7 +828,7 @@ void AliMUONTrackerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
   AliCodeTimerAuto("",0);
 
   /// forces init
-  GetRawsData(kTrackerBusPatchOccupancy);
+  GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy);
   
        ((AliMUONTrackerDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader);
        
@@ -901,14 +902,14 @@ void AliMUONTrackerQADataMakerRec::MakeRecPoints(TTree* clustersTree)
                Int_t detElemId = cluster->GetDetElemId();
                Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
                
-               GetRecPointsData(kTrackerNumberOfClustersPerDE)->Fill(detElemId);
-               GetRecPointsData(kTrackerClusterChargePerDE+detElemId)->Fill(cluster->GetCharge());
-               GetRecPointsData(kTrackerClusterMultiplicityPerDE+detElemId)->Fill(cluster->GetNDigits());
-
-               GetRecPointsData(kTrackerNumberOfClustersPerChamber)->Fill(chamberId);
-               GetRecPointsData(kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge());
-               GetRecPointsData(kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits());
-               GetRecPointsData(kTrackerClusterHitMapPerChamber+chamberId)->Fill(cluster->GetX(),cluster->GetY());
+               GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerDE)->Fill(detElemId);
+               GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId)->Fill(cluster->GetCharge());
+               GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId)->Fill(cluster->GetNDigits());
+
+               GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerChamber)->Fill(chamberId);
+               GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge());
+               GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits());
+               GetRecPointsData(AliMUONQAIndices::kTrackerClusterHitMapPerChamber+chamberId)->Fill(cluster->GetX(),cluster->GetY());
                
     if ( fMappingCheckRecPoints ) fMappingCheckRecPoints->Store(*cluster);
     
@@ -933,7 +934,7 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd)
   else AliError("Unable to get recoParam: use default ones for residual calculation");
   esdInterface.LoadEvent(*esd);
   
-  GetESDsData(kESDnTracks)->Fill(esdInterface.GetNTracks());
+  GetESDsData(AliMUONQAIndices::kESDnTracks)->Fill(esdInterface.GetNTracks());
   
   Int_t nTrackMatchTrig = 0;
   
@@ -950,14 +951,14 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd)
     
     if (esdTrack->ContainTriggerData()) nTrackMatchTrig++;
     
-    GetESDsData(kESDMomentum)->Fill(esdTrack->P());
-    GetESDsData(kESDPt)->Fill(esdTrack->Pt());
-    GetESDsData(kESDRapidity)->Fill(esdTrack->Y());
-    GetESDsData(kESDChi2)->Fill(track->GetNormalizedChi2());
-    GetESDsData(kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF()));
-    GetESDsData(kESDThetaX)->Fill(esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.);
-    GetESDsData(kESDThetaY)->Fill(esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.);
-    GetESDsData(kESDnClustersPerTrack)->Fill(track->GetNClusters());
+    GetESDsData(AliMUONQAIndices::kESDMomentum)->Fill(esdTrack->P());
+    GetESDsData(AliMUONQAIndices::kESDPt)->Fill(esdTrack->Pt());
+    GetESDsData(AliMUONQAIndices::kESDRapidity)->Fill(esdTrack->Y());
+    GetESDsData(AliMUONQAIndices::kESDChi2)->Fill(track->GetNormalizedChi2());
+    GetESDsData(AliMUONQAIndices::kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF()));
+    GetESDsData(AliMUONQAIndices::kESDThetaX)->Fill(esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.);
+    GetESDsData(AliMUONQAIndices::kESDThetaY)->Fill(esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.);
+    GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->Fill(track->GetNClusters());
     
     // loop over clusters
     AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
@@ -974,33 +975,33 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd)
       Double_t localChi2Y = (sigmaResidualY2 > 0.) ? residualY*residualY/sigmaResidualY2 : 0.;
       Double_t localChi2 = 0.5 * trackParam->GetLocalChi2();
       
-      GetESDsData(kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY());
+      GetESDsData(AliMUONQAIndices::kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY());
       
-      GetESDsData(kESDnTotClustersPerCh)->Fill(chId);
-      GetESDsData(kESDnTotClustersPerDE)->Fill(deID);
+      GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh)->Fill(chId);
+      GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE)->Fill(deID);
       
-      GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
-      GetESDsData(kESDSumClusterChargePerDE)->Fill(deID, cluster->GetCharge());
+      GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
+      GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE)->Fill(deID, cluster->GetCharge());
       
       if (cluster->GetNDigits() > 0) { // discard clusters with pad not stored in ESD
-       GetESDsData(kESDnTotFullClustersPerDE)->Fill(deID);
-        GetESDsData(kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits());
-       GetESDsData(kESDSumClusterSizePerDE)->Fill(deID, cluster->GetNDigits());
+       GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE)->Fill(deID);
+        GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits());
+       GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE)->Fill(deID, cluster->GetNDigits());
       }
       
-      GetESDsData(kESDResidualXInCh+chId)->Fill(residualX);
-      GetESDsData(kESDResidualYInCh+chId)->Fill(residualY);
-      GetESDsData(kESDSumResidualXPerDE)->Fill(deID, residualX);
-      GetESDsData(kESDSumResidualYPerDE)->Fill(deID, residualY);
-      GetESDsData(kESDSumResidualX2PerDE)->Fill(deID, residualX*residualX);
-      GetESDsData(kESDSumResidualY2PerDE)->Fill(deID, residualY*residualY);
+      GetESDsData(AliMUONQAIndices::kESDResidualXInCh+chId)->Fill(residualX);
+      GetESDsData(AliMUONQAIndices::kESDResidualYInCh+chId)->Fill(residualY);
+      GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE)->Fill(deID, residualX);
+      GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE)->Fill(deID, residualY);
+      GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE)->Fill(deID, residualX*residualX);
+      GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE)->Fill(deID, residualY*residualY);
       
-      GetESDsData(kESDLocalChi2XInCh+chId)->Fill(localChi2X);
-      GetESDsData(kESDLocalChi2YInCh+chId)->Fill(localChi2Y);
-      GetESDsData(kESDLocalChi2InCh+chId)->Fill(localChi2);
-      GetESDsData(kESDSumLocalChi2XPerDE)->Fill(deID, localChi2X);
-      GetESDsData(kESDSumLocalChi2YPerDE)->Fill(deID, localChi2Y);
-      GetESDsData(kESDSumLocalChi2PerDE)->Fill(deID, localChi2);
+      GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+chId)->Fill(localChi2X);
+      GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+chId)->Fill(localChi2Y);
+      GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+chId)->Fill(localChi2);
+      GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE)->Fill(deID, localChi2X);
+      GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE)->Fill(deID, localChi2Y);
+      GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE)->Fill(deID, localChi2);
       
       trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
       
@@ -1008,7 +1009,7 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd)
     
   }
 
-  GetESDsData(kESDMatchTrig)->Fill(nTrackMatchTrig);
+  GetESDsData(AliMUONQAIndices::kESDMatchTrig)->Fill(nTrackMatchTrig);
   
 }
 
index 60e699a..9d163de 100644 (file)
@@ -48,100 +48,6 @@ public:
   virtual void MakeRaws(AliRawReader* rawReader); 
   virtual void MakeRecPoints(TTree* recpo); 
   
-public:
-
-  /// Raw histograms indices
-  enum ERaw { 
-    kTrackerData              = 3,  ///< Accumulated data
-    kTrackerBusPatchOccupancy = 4, ///< Bus patch occupancies
-    kTrackerBusPatchNofPads   = 5, ///< Number of pads per bus patch
-    kTrackerBusPatchNofManus  = 6, ///< Number of manus per bus patch
-    kTrackerBusPatchConfig    = 7 ///< Configuration of the tracker
-  };
-         
-  /// Rec points histograms indices
-  enum ERecPoints { 
-    kTrackerNumberOfClustersPerChamber    = 100, ///< Tracker: number of clusters per chamber
-    kTrackerClusterMultiplicityPerChMean  = 101, ///< cluster size per Ch: mean
-    kTrackerClusterMultiplicityPerChSigma = 102, ///< cluster size per Ch: dispersion
-    kTrackerClusterChargePerChMean        = 103, ///< cluster charge per Ch: mean
-    kTrackerClusterChargePerChSigma       = 104, ///< cluster charge per Ch: dispersion
-
-    kTrackerRecPoints = 105, ///< Tracker : tracker data of clusters (all and mono-cathode ones)
-
-    kTrackerClusterMultiplicityPerChamber = 200, ///< Tracker: cluster multiplicity per chamber
-    kTrackerClusterChargePerChamber       = 300, ///< Tracker: cluster charge per chamber
-    kTrackerClusterHitMapPerChamber       = 400, ///< Tracker: cluster position distribution per chamber
-    
-    kTrackerNumberOfClustersPerDE        = 1000, ///< Tracker : number of clusters per DE              
-    kTrackerClusterMultiplicityPerDEMean = 1001, ///< cluster size per DE: mean
-    kTrackerClusterChargePerDEMean       = 1002, ///< cluster charge per DE: mean
-    
-    kTrackerClusterMultiplicityPerDE = 3000, ///< Tracker : cluster multiplicity per DE                
-    kTrackerClusterChargePerDE       = 5000  ///< Tracker : cluster charge per DE
-    
-  };
-  
-  /// ESD histograms indices
-  enum EESD { 
-    kESDnTracks                 = 0,  ///< number of tracks
-    kESDMatchTrig               = 1,  ///< number of tracks matched with trigger
-    kESDMomentum                = 2,  ///< P distribution
-    kESDPt                      = 3,  ///< Pt distribution
-    kESDRapidity                = 4,  ///< rapidity distribution
-    kESDChi2                    = 5,  ///< normalized chi2 distribution
-    kESDProbChi2                = 6,  ///< distribution of probability of chi2
-    
-    kESDClusterHitMap           = 7,  ///< cluster position distribution in chamber i
-    kESDnClustersPerTrack       = 17, ///< number of clusters per track
-    kESDnClustersPerCh          = 18, ///< number of clusters per chamber per track
-    kESDnClustersPerDE          = 19, ///< number of clusters per DE per track
-    kESDClusterChargeInCh       = 20, ///< cluster charge distribution in chamber i
-    kESDClusterChargePerChMean  = 30, ///< cluster charge per Ch: mean
-    kESDClusterChargePerChSigma = 31, ///< cluster charge per Ch: dispersion
-    kESDClusterChargePerDE      = 32, ///< cluster charge per DE: mean
-    kESDClusterSizeInCh         = 33, ///< cluster size distribution in chamber i
-    kESDClusterSizePerChMean    = 43, ///< cluster size per Ch: mean
-    kESDClusterSizePerChSigma   = 44, ///< cluster size per Ch: dispersion
-    kESDClusterSizePerDE        = 45, ///< cluster size per DE: mean
-    
-    kESDResidualXInCh           = 46, ///< cluster-track residual-X distribution in chamber i
-    kESDResidualYInCh           = 56, ///< cluster-track residual-Y distribution in chamber i
-    kESDResidualXPerChMean      = 66, ///< cluster-track residual-X per Ch: mean
-    kESDResidualYPerChMean      = 67, ///< cluster-track residual-Y per Ch: mean
-    kESDResidualXPerChSigma     = 68, ///< cluster-track residual-X per Ch: dispersion
-    kESDResidualYPerChSigma     = 69, ///< cluster-track residual-Y per Ch: dispersion
-    kESDResidualXPerDEMean      = 70, ///< cluster-track residual-X per DE: mean
-    kESDResidualYPerDEMean      = 71, ///< cluster-track residual-Y per DE: mean
-    kESDResidualXPerDESigma     = 72, ///< cluster-track residual-X per DE: dispersion
-    kESDResidualYPerDESigma     = 73, ///< cluster-track residual-Y per DE: dispersion
-    kESDLocalChi2XInCh          = 74, ///< local chi2-X distribution in chamber i
-    kESDLocalChi2YInCh          = 84, ///< local chi2-Y distribution in chamber i
-    kESDLocalChi2XPerChMean     = 94, ///< local chi2-X per Ch: mean
-    kESDLocalChi2YPerChMean     = 95, ///< local chi2-Y per Ch: mean
-    kESDLocalChi2XPerDEMean     = 96, ///< local chi2-X per DE: mean
-    kESDLocalChi2YPerDEMean     = 97, ///< local chi2-Y per DE: mean
-    kESDLocalChi2InCh           = 98, ///< local chi2-X distribution in chamber i
-    kESDLocalChi2PerChMean      = 108, ///< local chi2 per Ch: mean
-    kESDLocalChi2PerDEMean      = 109, ///< local chi2 per DE: mean
-    
-    kESDThetaX                  = 110, ///< thetaX distribution
-    kESDThetaY                  = 111, ///< thetaY distribution
-    
-    kESDnTotClustersPerCh       = 1000, ///< total number of associated clusters per chamber
-    kESDnTotClustersPerDE       = 1001, ///< total number of associated clusters per DE
-    kESDnTotFullClustersPerDE   = 1002, ///< total number of associated clusters containing pad info per DE
-    kESDSumClusterChargePerDE   = 1003, ///< sum of cluster charge per DE
-    kESDSumClusterSizePerDE     = 1004, ///< sum of cluster size per DE
-    kESDSumResidualXPerDE       = 1005, ///< sum of cluster-track residual-X per DE
-    kESDSumResidualYPerDE       = 1006, ///< sum of cluster-track residual-Y per DE
-    kESDSumResidualX2PerDE      = 1007, ///< sum of cluster-track residual-X**2 per DE
-    kESDSumResidualY2PerDE      = 1008, ///< sum of cluster-track residual-Y**2 per DE
-    kESDSumLocalChi2XPerDE      = 1009, ///< sum of local chi2-X per DE
-    kESDSumLocalChi2YPerDE      = 1010, ///< sum of local chi2-Y per DE
-    kESDSumLocalChi2PerDE       = 1011  ///< sum of local chi2 per DE
-  };
-  
 private:
   
   void InsertTrackerData(Int_t specie, TObjArray** list, TObject* object, 
index 8711ca4..0d54d6b 100644 (file)
@@ -28,7 +28,7 @@
 
 
 #include "AliRecoParam.h"
-#include "AliMUONTriggerQADataMakerRec.h"
+#include "AliMUONQAIndices.h"
 #include "AliQAv1.h"
 #include "TH1.h"
 #include "TPaveText.h"
@@ -79,9 +79,9 @@ AliMUONTriggerQAChecker::CheckRaws(TObjArray** list, AliMUONRecoParam* )
   }
 
   Int_t histoRawsPercentIndex[] = {
-    AliMUONTriggerQADataMakerRec::kTriggerErrorSummaryNorm, 
-    AliMUONTriggerQADataMakerRec::kTriggerCalibSummaryNorm,
-    AliMUONTriggerQADataMakerRec::kTriggerReadOutErrorsNorm
+    AliMUONQAIndices::kTriggerErrorSummaryNorm, 
+    AliMUONQAIndices::kTriggerCalibSummaryNorm,
+    AliMUONQAIndices::kTriggerReadOutErrorsNorm
   };
   const Int_t kNrawsHistos = sizeof(histoRawsPercentIndex)/sizeof(histoRawsPercentIndex[0]);
 
index 96f2020..54df752 100644 (file)
@@ -59,6 +59,7 @@ ClassImp(AliMUONTriggerQADataMakerRec)
 #include "AliMUONGlobalTriggerBoard.h"
 #include "AliMUONGlobalTrigger.h"
 #include "AliMUONGlobalCrateConfig.h"
+#include "AliMUONQAIndices.h"
 
 //____________________________________________________________________________ 
 AliMUONTriggerQADataMakerRec::AliMUONTriggerQADataMakerRec(AliQADataMakerRec* master) : 
@@ -104,18 +105,18 @@ void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleRaws(Int_t /*specie*/, TObj
   DisplayTriggerInfo();
 
   // Normalize RawData histos
-  Float_t nbevent = GetRawsData(kRawNAnalyzedEvents)->GetBinContent(1);
+  Float_t nbevent = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->GetBinContent(1);
   Int_t histoRawsIndex[] = {
-    kTriggerErrorSummary,
-    kTriggerCalibSummary,
-    kTriggerReadOutErrors,
-    kTriggerGlobalOutput
+    AliMUONQAIndices::kTriggerErrorSummary,
+    AliMUONQAIndices::kTriggerCalibSummary,
+    AliMUONQAIndices::kTriggerReadOutErrors,
+    AliMUONQAIndices::kTriggerGlobalOutput
   };
   Int_t histoRawsScaledIndex[] = {
-    kTriggerErrorSummaryNorm,
-    kTriggerCalibSummaryNorm,
-    kTriggerReadOutErrorsNorm,
-    kTriggerGlobalOutputNorm
+    AliMUONQAIndices::kTriggerErrorSummaryNorm,
+    AliMUONQAIndices::kTriggerCalibSummaryNorm,
+    AliMUONQAIndices::kTriggerReadOutErrorsNorm,
+    AliMUONQAIndices::kTriggerGlobalOutputNorm
   };
   const Int_t kNrawsHistos = sizeof(histoRawsIndex)/sizeof(histoRawsIndex[0]);
   Float_t scaleFactor[kNrawsHistos] = {100., 100., 100., 1.};
@@ -129,16 +130,16 @@ void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleRaws(Int_t /*specie*/, TObj
     }
   } // loop on histos
 
-  TH1* hYCopy = GetRawsData(kTriggerErrorLocalYCopy); //number of YCopy error per board
-  TH1* hYCopyTests = GetRawsData(kTriggerErrorLocalYCopyTest); //contains the number of YCopy test per board
-  TH1* hYCopyNorm = GetRawsData(kTriggerErrorLocalYCopyNorm); 
+  TH1* hYCopy = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy); //number of YCopy error per board
+  TH1* hYCopyTests = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest); //contains the number of YCopy test per board
+  TH1* hYCopyNorm = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyNorm); 
   hYCopyNorm->Reset();
   hYCopyNorm->Divide(hYCopy, hYCopyTests, 100., 1.);
      
   Float_t mean = hYCopyNorm->Integral();
       
-  TH1* hSummary = GetRawsData(kTriggerErrorSummary);
-  hSummary->SetBinContent(kAlgoLocalYCopy+1,mean/192.); //put the mean of the % of YCopy error in the kTriggerError's corresponding bin
+  TH1* hSummary = GetRawsData(AliMUONQAIndices::kTriggerErrorSummary);
+  hSummary->SetBinContent(AliMUONQAIndices::kAlgoLocalYCopy+1,mean/192.); //put the mean of the % of YCopy error in the kTriggerError's corresponding bin
 }
 
 //____________________________________________________________________________ 
@@ -166,7 +167,7 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
     histo1D = new TH1F("hTriggerScalersTime", "Acquisition time from trigger scalers", 1, 0.5, 1.5);
     histo1D->GetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event.");
     histo1D->GetYaxis()->SetTitle("Cumulated scaler time (s)");
-    Add2RawsList(histo1D, kTriggerScalersTime, expert, !image, !saveCorr);
+    Add2RawsList(histo1D, AliMUONQAIndices::kTriggerScalersTime, expert, !image, !saveCorr);
 
     for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
       TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
@@ -179,7 +180,7 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
        histo2D->GetXaxis()->SetTitle(boardName.Data());
        histo2D->GetYaxis()->SetTitle("Strip"); 
        histo2D->SetOption("COLZ");     
-       Add2RawsList(histo2D, kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+       Add2RawsList(histo2D, AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
       } // loop on chambers
     } // loop on cathodes
        
@@ -191,14 +192,14 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
        histo2D = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
                                                             iCath, iChamber, histoTitle);
        histo2D->SetOption("COLZ");
-       Add2RawsList(histo2D, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+       Add2RawsList(histo2D, AliMUONQAIndices::kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
       } // loop on chambers
     } // loop on cathodes    
 
-    TString axisLabel[kNtrigCalibSummaryBins] = {"#splitline{Dead}{Channels}", "#splitline{Dead}{Local Boards}", "#splitline{Dead}{Regional Boards}", "#splitline{Dead}{Global Board}", "#splitline{Noisy}{Strips}"};
+    TString axisLabel[AliMUONQAIndices::kNtrigCalibSummaryBins] = {"#splitline{Dead}{Channels}", "#splitline{Dead}{Local Boards}", "#splitline{Dead}{Regional Boards}", "#splitline{Dead}{Global Board}", "#splitline{Noisy}{Strips}"};
 
-    TH1F* histoCalib = new TH1F("hTriggerCalibSummaryAll", "MTR calibration summary counts", kNtrigCalibSummaryBins, -0.5, (Float_t)kNtrigCalibSummaryBins - 0.5);
-    for (Int_t ibin=1; ibin<=kNtrigCalibSummaryBins; ibin++){
+    TH1F* histoCalib = new TH1F("hTriggerCalibSummaryAll", "MTR calibration summary counts", AliMUONQAIndices::kNtrigCalibSummaryBins, -0.5, (Float_t)AliMUONQAIndices::kNtrigCalibSummaryBins - 0.5);
+    for (Int_t ibin=1; ibin<=AliMUONQAIndices::kNtrigCalibSummaryBins; ibin++){
       histoCalib->GetXaxis()->SetBinLabel(ibin, axisLabel[ibin-1].Data());
     }
     histoCalib->SetFillColor(kBlue);
@@ -209,91 +210,91 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
     histoCalibNorm->SetOption("bar2");
     histoCalibNorm->GetYaxis()->SetTitle("Percentage per event (%)");
     // Adding both histos after cloning to avoid problems with the expert bit
-    Add2RawsList(histoCalib,     kTriggerCalibSummary,      expert, !image, !saveCorr);
-    Add2RawsList(histoCalibNorm, kTriggerCalibSummaryNorm, !expert,  image, !saveCorr);
+    Add2RawsList(histoCalib,     AliMUONQAIndices::kTriggerCalibSummary,      expert, !image, !saveCorr);
+    Add2RawsList(histoCalibNorm, AliMUONQAIndices::kTriggerCalibSummaryNorm, !expert,  image, !saveCorr);
   } // Calibration reco param
        
   const char *globalXaxisName[6] = {"US HPt", "US LPt", "LS HPt", "LS LPt", "SGL HPt", "SGL LPt"};
-  const char *allLevelXaxisName[kNtrigAlgoErrorBins] = {"Local algo X", "Local algo Y", "Local LUT","Local Y Copy" , "Local2Regional", "Regional", "Regional2Global", "GlobalFromInGlobal", "GlobalFromInLocal", "GlobalFromOutLocal"};
-  const char *readoutErrNames[kNtrigStructErrorBins]={"Local","Regional","Global","DARC"};
+  const char *allLevelXaxisName[AliMUONQAIndices::kNtrigAlgoErrorBins] = {"Local algo X", "Local algo Y", "Local LUT","Local Y Copy" , "Local2Regional", "Regional", "Regional2Global", "GlobalFromInGlobal", "GlobalFromInLocal", "GlobalFromOutLocal"};
+  const char *readoutErrNames[AliMUONQAIndices::kNtrigStructErrorBins]={"Local","Regional","Global","DARC"};
 
   TString errorAxisTitle = "Number of errors";
 
   histo1D = new TH1F("ErrorLocalXPos", "ErrorLocalXPos",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalXPos, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalXPos, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalYPos", "ErrorLocalYPos",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalYPos, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalYPos, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalDev", "ErrorLocalDev",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalDev, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalDev, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalTriggerDec", "ErrorLocalTriggerDec",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalTriggerDec, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalTriggerDec, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalLPtLSB", "ErrorLocalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalLPtLSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalLPtLSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalLPtMSB", "ErrorLocalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalLPtMSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalLPtMSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalHPtLSB", "ErrorLocalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalHPtLSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalHPtLSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalHPtMSB", "ErrorLocalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalHPtMSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalHPtMSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocalTrigY", "ErrorLocalTrigY",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocalTrigY, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalTrigY, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocal2RegionalLPtLSB", "ErrorLocal2RegionalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocal2RegionalLPtLSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalLPtLSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocal2RegionalLPtMSB", "ErrorLocal2RegionalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocal2RegionalLPtMSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalLPtMSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocal2RegionalHPtLSB", "ErrorLocal2RegionalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocal2RegionalHPtLSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalHPtLSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorLocal2RegionalHPtMSB", "ErrorLocal2RegionalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histo1D->GetXaxis()->SetTitle(boardName.Data());
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
-  Add2RawsList(histo1D, kTriggerErrorLocal2RegionalHPtMSB, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalHPtMSB, expert, !image, !saveCorr);
 
   histo1D = new TH1F("ErrorOutGlobalFromInGlobal", "ErrorOutGlobalFromInGlobal",6,-0.5,6-0.5);
   histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
   for (int ibin=0;ibin<6;ibin++){
     histo1D->GetXaxis()->SetBinLabel(ibin+1,globalXaxisName[ibin]);
   }
-  Add2RawsList(histo1D, kTriggerErrorOutGlobalFromInGlobal, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorOutGlobalFromInGlobal, expert, !image, !saveCorr);
 
-  TH1F* histoAlgoErr = new TH1F("hTriggerAlgoNumOfErrors", "Trigger Algorithm total errors",kNtrigAlgoErrorBins,-0.5,(Float_t)kNtrigAlgoErrorBins-0.5);
+  TH1F* histoAlgoErr = new TH1F("hTriggerAlgoNumOfErrors", "Trigger Algorithm total errors",AliMUONQAIndices::kNtrigAlgoErrorBins,-0.5,(Float_t)AliMUONQAIndices::kNtrigAlgoErrorBins-0.5);
   histoAlgoErr->GetYaxis()->SetTitle("Number of events with errors");
-  for (int ibin=0;ibin<kNtrigAlgoErrorBins;ibin++){
+  for (int ibin=0;ibin<AliMUONQAIndices::kNtrigAlgoErrorBins;ibin++){
     histoAlgoErr->GetXaxis()->SetBinLabel(ibin+1,allLevelXaxisName[ibin]);
   }
   histoAlgoErr->SetFillColor(kBlue);
@@ -303,16 +304,16 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
   histoAlgoErrNorm->SetTitle("Trigger algorithm errors");
   histoAlgoErrNorm->GetYaxis()->SetTitle("% of events with errors");
   // Adding both histos after cloning to avoid problems with the expert bit
-  Add2RawsList(histoAlgoErr,     kTriggerErrorSummary,      expert, !image, !saveCorr);
-  Add2RawsList(histoAlgoErrNorm, kTriggerErrorSummaryNorm, !expert,  image, !saveCorr);  
+  Add2RawsList(histoAlgoErr,     AliMUONQAIndices::kTriggerErrorSummary,      expert, !image, !saveCorr);
+  Add2RawsList(histoAlgoErrNorm, AliMUONQAIndices::kTriggerErrorSummaryNorm, !expert,  image, !saveCorr);  
 
   histo1D = new TH1F("hTriggeredBoards", "Triggered boards", nbLocalBoard, 0.5, (Float_t)nbLocalBoard + 0.5);
-  Add2RawsList(histo1D, kTriggeredBoards, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggeredBoards, expert, !image, !saveCorr);
 
   histo2D = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
                                                       0, 0, "Local board triggers / event");
   histo2D->SetOption("COLZ");
-  Add2RawsList(histo2D, kTriggerBoardsDisplay, expert, !image, !saveCorr);
+  Add2RawsList(histo2D, AliMUONQAIndices::kTriggerBoardsDisplay, expert, !image, !saveCorr);
 
   TH1F* histoYCopyErr = new TH1F("ErrorLocalYCopy", "Number of YCopy errors",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
   histoYCopyErr->GetXaxis()->SetTitle(boardName.Data());
@@ -324,14 +325,14 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
   TH1F* histoYCopyErrNorm = (TH1F*)histoYCopyErr->Clone("ErrorLocalYCopyNorm");
   histoYCopyErrNorm->SetTitle("% of YCopy errors");
   // Adding both histos after cloning to avoid problems with the expert bit
-  Add2RawsList(histoYCopyErr,     kTriggerErrorLocalYCopy,     expert, !image, !saveCorr);
-  Add2RawsList(histoYCopyErrTest, kTriggerErrorLocalYCopyTest, expert, !image, !saveCorr);
-  Add2RawsList(histoYCopyErrNorm, kTriggerErrorLocalYCopyNorm, expert, !image, !saveCorr);
+  Add2RawsList(histoYCopyErr,     AliMUONQAIndices::kTriggerErrorLocalYCopy,     expert, !image, !saveCorr);
+  Add2RawsList(histoYCopyErrTest, AliMUONQAIndices::kTriggerErrorLocalYCopyTest, expert, !image, !saveCorr);
+  Add2RawsList(histoYCopyErrNorm, AliMUONQAIndices::kTriggerErrorLocalYCopyNorm, expert, !image, !saveCorr);
 
-  TH1F* histoROerr = new TH1F("hTriggerReadoutNumOfErrors","Trigger Read-Out total errors", kNtrigStructErrorBins, -0.5, (Float_t)kNtrigStructErrorBins-0.5);
+  TH1F* histoROerr = new TH1F("hTriggerReadoutNumOfErrors","Trigger Read-Out total errors", AliMUONQAIndices::kNtrigStructErrorBins, -0.5, (Float_t)AliMUONQAIndices::kNtrigStructErrorBins-0.5);
   histoROerr->GetYaxis()->SetTitle("Fraction of errors");
   histoROerr->SetFillColor(kBlue);
-  for (int ibin=0;ibin<kNtrigStructErrorBins;ibin++){
+  for (int ibin=0;ibin<AliMUONQAIndices::kNtrigStructErrorBins;ibin++){
     histoROerr->GetXaxis()->SetBinLabel(ibin+1,readoutErrNames[ibin]);
   }
   // Copy of previous histo for scaling purposes
@@ -340,8 +341,8 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
   histoROerrNorm->SetOption("bar2");
   histoROerrNorm->GetYaxis()->SetTitle("% of errors per event");
   // Adding both histos after cloning to avoid problems with the expert bit
-  Add2RawsList(histoROerr,     kTriggerReadOutErrors,      expert, !image, !saveCorr);
-  Add2RawsList(histoROerrNorm, kTriggerReadOutErrorsNorm, !expert,  image, !saveCorr);
+  Add2RawsList(histoROerr,     AliMUONQAIndices::kTriggerReadOutErrors,      expert, !image, !saveCorr);
+  Add2RawsList(histoROerrNorm, AliMUONQAIndices::kTriggerReadOutErrorsNorm, !expert,  image, !saveCorr);
 
   TH1F* histoGlobalMult = new TH1F("hTriggerGlobalOutMultiplicity","Trigger global outputs multiplicity", 6, -0.5, 6.-0.5);
   histoGlobalMult->GetYaxis()->SetTitle("Number of triggers"); 
@@ -358,14 +359,14 @@ void AliMUONTriggerQADataMakerRec::InitRaws()
   histoGlobalMultNorm->SetBarOffset(0.25);
   histoGlobalMultNorm->GetYaxis()->SetTitle("Triggers per event");
   // Adding both histos after cloning to avoid problems with the expert bit
-  Add2RawsList(histoGlobalMult,     kTriggerGlobalOutput,     expert, !image, !saveCorr);
-  Add2RawsList(histoGlobalMultNorm, kTriggerGlobalOutputNorm, expert, !image, !saveCorr);
+  Add2RawsList(histoGlobalMult,     AliMUONQAIndices::kTriggerGlobalOutput,     expert, !image, !saveCorr);
+  Add2RawsList(histoGlobalMultNorm, AliMUONQAIndices::kTriggerGlobalOutputNorm, expert, !image, !saveCorr);
 
   histo1D = new TH1F("hRawNAnalyzedEvents", "Number of analyzed events per specie", 1, 0.5, 1.5);
   Int_t esindex = AliRecoParam::AConvert(CurrentEventSpecie());
   histo1D->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
   histo1D->GetYaxis()->SetTitle("Number of analyzed events");
-  Add2RawsList(histo1D, kRawNAnalyzedEvents, expert, !image, !saveCorr);
+  Add2RawsList(histo1D, AliMUONQAIndices::kTriggerRawNAnalyzedEvents, expert, !image, !saveCorr);
 }
 
 //__________________________________________________________________
@@ -394,14 +395,14 @@ void AliMUONTriggerQADataMakerRec::InitRecPoints()
   Int_t esindex = AliRecoParam::AConvert(CurrentEventSpecie());
   histo1D->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
   histo1D->GetYaxis()->SetTitle("Number of analyzed events");
-  Add2RecPointsList(histo1D, kNAnalyzedEvents, expert, !image);
+  Add2RecPointsList(histo1D, AliMUONQAIndices::kTriggerNAnalyzedEvents, expert, !image);
 
   histo1D = new TH1F("hTriggerTrippedChambers", "Trigger RPCs in trip", 418, 1100-0.5, 1417+0.5);
   histo1D->GetXaxis()->SetTitle("DetElemId");
   histo1D->GetYaxis()->SetTitle("# of trips");
   histo1D->SetFillColor(kRed);
   histo1D->SetLineColor(kRed);
-  Add2RecPointsList(histo1D, kTriggerRPCtrips, !expert, image);
+  Add2RecPointsList(histo1D, AliMUONQAIndices::kTriggerRPCtrips, !expert, image);
 
   FillTriggerDCSHistos();      
 }
@@ -420,7 +421,7 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 
     AliCodeTimerAuto("",0);
        
-    GetRawsData(kRawNAnalyzedEvents)->Fill(1.);
+    GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->Fill(1.);
 
     // Init Local/Regional/Global decision with fake values
 
@@ -488,7 +489,7 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
        if ( fillScalerHistos ) {
          UInt_t nOfClocks = darcHeader->GetGlobalClock();
          Double_t nOfSeconds = ((Double_t) nOfClocks) / 40e6; // 1 clock each 25 ns
-         ((TH1F*)GetRawsData(kTriggerScalersTime))->Fill(1., nOfSeconds);
+         ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime))->Fill(1., nOfSeconds);
        }
 
        //Get Global datas
@@ -502,7 +503,7 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
              nDeadGlobal++;
          }
          else
-           ((TH1F*)GetRawsData(kTriggerGlobalOutput))->Fill(bit);
+           ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerGlobalOutput))->Fill(bit);
        }
 
        //for (Int_t Bit=0; Bit<32; Bit++){
@@ -580,7 +581,7 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 
          //Get local in/outputs
          if (Int_t(localStruct->GetDec())!=0){
-             ((TH1F*)GetRawsData(kTriggeredBoards))->Fill(loCircuit);
+             ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggeredBoards))->Fill(loCircuit);
          }
          else if ( fillScalerHistos ){
            nDeadLocal++;
@@ -603,7 +604,7 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 
              for(Int_t ich=0; ich<AliMpConstants::NofTriggerChambers(); ich++){
                if ( scalerVal[ich] > 0 )
-                 ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + ich))
+                 ((TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + ich))
                    ->Fill(loCircuit, ibitxy, 2*(Float_t)scalerVal[ich]);
 
                if ( scalerVal[ich] >= maxNcounts )
@@ -616,23 +617,23 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
          nDeadRegional++; // Not necessary when regional output will work
       } // iReg
 
-      Float_t readoutErrors[kNtrigStructErrorBins] = {
+      Float_t readoutErrors[AliMUONQAIndices::kNtrigStructErrorBins] = {
        ((Float_t)rawStreamTrig.GetLocalEoWErrors())/((Float_t)countAllBoards),
        ((Float_t)rawStreamTrig.GetRegEoWErrors())/16.,
        ((Float_t)rawStreamTrig.GetGlobalEoWErrors())/6.,
        ((Float_t)rawStreamTrig.GetDarcEoWErrors())/2.
       };
     
-      for (Int_t ibin=0; ibin<kNtrigStructErrorBins; ibin++){
+      for (Int_t ibin=0; ibin<AliMUONQAIndices::kNtrigStructErrorBins; ibin++){
        if ( readoutErrors[ibin] > 0 )
-         ((TH1F*)GetRawsData(kTriggerReadOutErrors))->Fill(ibin, readoutErrors[ibin]);
+         ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerReadOutErrors))->Fill(ibin, readoutErrors[ibin]);
       }
     } // NextDDL
 
     nDeadLocal += AliMUONConstants::NTriggerCircuit() - countNotifiedBoards;
     Int_t nStripsTot = digitStoreAll.GetSize();
     if ( nStripsTot > 0 ) { // The value is != 0 only for scaler events
-      Float_t fraction[kNtrigCalibSummaryBins] = {
+      Float_t fraction[AliMUONQAIndices::kNtrigCalibSummaryBins] = {
        ((Float_t)(nStripsTot - digitStore.GetSize())) / ((Float_t)nStripsTot),
        //(Float_t)nDeadLocal / ((Float_t)countNotifiedBoards),
        (Float_t)nDeadLocal / ((Float_t)AliMUONConstants::NTriggerCircuit()),
@@ -641,9 +642,9 @@ void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
        (Float_t)nNoisyStrips / ((Float_t)nStripsTot),
       };
 
-      for(Int_t ibin = 0; ibin < kNtrigCalibSummaryBins; ibin++){
+      for(Int_t ibin = 0; ibin < AliMUONQAIndices::kNtrigCalibSummaryBins; ibin++){
        if ( fraction[ibin] > 0. )
-         ((TH1F*)GetRawsData(kTriggerCalibSummary))->Fill(ibin, fraction[ibin]);
+         ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerCalibSummary))->Fill(ibin, fraction[ibin]);
       }
     }
 
@@ -693,7 +694,7 @@ void AliMUONTriggerQADataMakerRec::MakeRecPoints(TTree* /*clustersTree*/)
   // Do nothing in case of calibration event
   if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
        
-  GetRecPointsData(kNAnalyzedEvents)->Fill(1.);
+  GetRecPointsData(AliMUONQAIndices::kTriggerNAnalyzedEvents)->Fill(1.);
 }
 
 //____________________________________________________________________________
@@ -715,32 +716,32 @@ void AliMUONTriggerQADataMakerRec::DisplayTriggerInfo()
   
   TH2F* histoStrips=0x0;
   TH2F* histoDisplayStrips=0x0;
-  if ( GetRawsData(kTriggerScalers) ) {
+  if ( GetRawsData(AliMUONQAIndices::kTriggerScalers) ) {
     AliMUONTriggerDisplay::EDisplayOption displayOption = AliMUONTriggerDisplay::kNormalizeToArea;
     for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
       {    
        for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
          {
-           histoStrips = (TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
+           histoStrips = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
 
            if(histoStrips->GetEntries()==0) continue; // No events found => No need to display
 
-           histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
+           histoDisplayStrips = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
 
            triggerDisplay.FillDisplayHistogram(histoStrips, histoDisplayStrips,
                                                AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, displayOption);
 
-           Float_t scaleValue = ((TH1F*)GetRawsData(kTriggerScalersTime))->GetBinContent(1);
+           Float_t scaleValue = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime))->GetBinContent(1);
            if(scaleValue>0.) histoDisplayStrips->Scale(1./scaleValue);
          } // iChamber
       } // iCath
   }
 
-  if ( GetRawsData(kTriggeredBoards) ){
-    TH1F* histoBoards = (TH1F*)GetRawsData(kTriggeredBoards);
-    TH2F* histoDisplayBoards = (TH2F*)GetRawsData(kTriggerBoardsDisplay);
+  if ( GetRawsData(AliMUONQAIndices::kTriggeredBoards) ){
+    TH1F* histoBoards = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggeredBoards);
+    TH2F* histoDisplayBoards = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerBoardsDisplay);
     triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
-    Float_t scaleValue = GetRawsData(kRawNAnalyzedEvents)->GetBinContent(1);
+    Float_t scaleValue = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->GetBinContent(1);
     if(scaleValue>0.) histoDisplayBoards->Scale(1./scaleValue);
   }
 }
@@ -885,7 +886,7 @@ AliMUONTriggerQADataMakerRec::FillTriggerDCSHistos()
       Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
       Int_t ich = iChamber - AliMpConstants::NofTrackingChambers();
 
-      histoIndex = kTriggerRPChv + ich;
+      histoIndex = AliMUONQAIndices::kTriggerRPChv + ich;
       histoName = Form("hRPCHVChamber%i", 11+ich);
       histoTitle = Form("Chamber %i: RPC HV (kV)", 11+ich);
 
@@ -961,7 +962,7 @@ AliMUONTriggerQADataMakerRec::FillTriggerDCSHistos()
        previousVal = currVal;
       } // loop on values
       currHisto->SetBinContent(previousBin, slatBin, scaleFactor*sumValuesPerBin/((Double_t)nValuesPerBin)); // Fill last value
-      if ( isTrip ) ((TH1F*)GetRecPointsData(kTriggerRPCtrips))->Fill(detElemId);
+      if ( isTrip ) ((TH1F*)GetRecPointsData(AliMUONQAIndices::kTriggerRPCtrips))->Fill(detElemId);
     } // if ( values ) 
     deIt.Next();
   } // loop on detElem
@@ -1049,7 +1050,7 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal(AliMUONVTriggerStore&
     loCircuit = recoLocalTrigger->LoCircuit();
     Int_t iboard = loCircuit - 1;
 
-    ((TH1F*)GetRawsData(kTriggerErrorLocalYCopyTest))->Fill(loCircuit);
+    ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest))->Fill(loCircuit);
   
     inputLocalTrigger = inputTriggerStore.FindLocal(loCircuit);
 
@@ -1073,11 +1074,11 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal(AliMUONVTriggerStore&
       }
     } // loop on chambers
     if ( errorInCopyBoard )
-      ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);    
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy))->Fill(loCircuit);    
   } // loop on local boards
 
   if (errorInYCopy)
-    ((TH1F*)GetRawsData(kTriggerErrorSummary))->Fill(kAlgoLocalYCopy);
+    ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalYCopy);
   
   Bool_t errorInXPosDev = kFALSE;
   Bool_t errorInYPosTrigY = kFALSE;
@@ -1092,12 +1093,12 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal(AliMUONVTriggerStore&
     inputLocalTrigger = inputTriggerStore.FindLocal(loCircuit);
 
     if ( recoLocalTrigger->LoStripX() != inputLocalTrigger->LoStripX() ) {
-      ((TH1F*)GetRawsData(kTriggerErrorLocalXPos))->Fill(loCircuit);
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalXPos))->Fill(loCircuit);
       errorInXPosDev = kTRUE;
     }
 
     if ( recoLocalTrigger->GetDeviation() != inputLocalTrigger->GetDeviation() ) {
-      ((TH1F*)GetRawsData(kTriggerErrorLocalDev))->Fill(loCircuit);
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalDev))->Fill(loCircuit);
       errorInXPosDev = kTRUE;
     }
 
@@ -1105,14 +1106,14 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal(AliMUONVTriggerStore&
     if ( (!skipBoard[iboard]) || ( (recoLocalTrigger->LoStripY() == inputLocalTrigger->LoStripY()) && (recoLocalTrigger->LoTrigY() == inputLocalTrigger->LoTrigY())) ) {
        
        if ( recoLocalTrigger->GetLoDecision() != inputLocalTrigger->GetLoDecision() ) {
-           ((TH1F*)GetRawsData(kTriggerErrorLocalTriggerDec))->Fill(loCircuit);
+           ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalTriggerDec))->Fill(loCircuit);
        }
        
        // Test Hpt and LPT
        Int_t recoLut[2]  = { recoLocalTrigger->LoLpt(),  recoLocalTrigger->LoHpt() };
        Int_t inputLut[2] = {inputLocalTrigger->LoLpt(), inputLocalTrigger->LoHpt() };
-       Int_t currIndex[2][2] = {{kTriggerErrorLocalLPtLSB, kTriggerErrorLocalLPtMSB},
-                                {kTriggerErrorLocalHPtMSB, kTriggerErrorLocalHPtMSB}};
+       Int_t currIndex[2][2] = {{AliMUONQAIndices::kTriggerErrorLocalLPtLSB, AliMUONQAIndices::kTriggerErrorLocalLPtMSB},
+                                {AliMUONQAIndices::kTriggerErrorLocalHPtMSB, AliMUONQAIndices::kTriggerErrorLocalHPtMSB}};
        for (Int_t ilut=0; ilut<2; ilut++){
            Int_t bitDiff = recoLut[ilut]^inputLut[ilut];
            if ( bitDiff == 0 ) continue;
@@ -1131,24 +1132,24 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal(AliMUONVTriggerStore&
     if ( skipBoard[iboard] ) continue;
 
     if ( recoLocalTrigger->LoStripY() != inputLocalTrigger->LoStripY() ) {
-      ((TH1F*)GetRawsData(kTriggerErrorLocalYPos))->Fill(loCircuit);
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYPos))->Fill(loCircuit);
       errorInYPosTrigY = kTRUE;
     }
 
     if ( recoLocalTrigger->LoTrigY() != inputLocalTrigger->LoTrigY()  ) {
-      ((TH1F*)GetRawsData(kTriggerErrorLocalTrigY))->Fill(loCircuit);  
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalTrigY))->Fill(loCircuit);        
       errorInYPosTrigY = kTRUE;
     }
   } // loop on local boards
 
   if (errorInXPosDev)
-    ((TH1F*)GetRawsData(kTriggerErrorSummary))->Fill(kAlgoLocalX);
+    ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalX);
 
   if (errorInLUT)
-    ((TH1F*)GetRawsData(kTriggerErrorSummary))->Fill(kAlgoLocalLUT);
+    ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalLUT);
 
   if (errorInYPosTrigY)
-    ((TH1F*)GetRawsData(kTriggerErrorSummary))->Fill(kAlgoLocalY);
+    ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalY);
 
 }
 /*
@@ -1189,7 +1190,7 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutGlobalFromInGlobal(AliMUONG
   if ( recoGlobalTrigger.GetGlobalResponse() == inputGlobalTrigger.GetGlobalResponse() )
     return;
 
-  ((TH1F*)GetRawsData(kTriggerErrorSummary))->Fill(kAlgoGlobalFromGlobal);
+  ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoGlobalFromGlobal);
 
   Bool_t inputResp[6] = {inputGlobalTrigger.PairUnlikeHpt(), inputGlobalTrigger.PairUnlikeLpt(),
                         inputGlobalTrigger.PairLikeHpt(), inputGlobalTrigger.PairLikeLpt(),
@@ -1201,6 +1202,6 @@ void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutGlobalFromInGlobal(AliMUONG
 
   for (int bit=0;bit<6;bit++){
     if ( recoResp[bit] != inputResp[bit] )
-      ((TH1F*)GetRawsData(kTriggerErrorOutGlobalFromInGlobal))->Fill(bit);
+      ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorOutGlobalFromInGlobal))->Fill(bit);
   }
 }
index 7da9ec1..4824c53 100644 (file)
@@ -48,88 +48,6 @@ public:
   virtual void MakeRecPoints(TTree* recpo); 
   virtual void MakeESDs(AliESDEvent* esd) ;
   
-public:
-
-  /// Raw histograms indices
-  
-  enum ERaw {
-    kTriggerScalersTime       = 22, ///< Trigger scalers acquisition time index
-    kTriggerScalers           = 23, ///< Trigger scalers histogram per plane index
-    kTriggerScalersDisplay    = 31, ///< Trigger scalers display histogram per plane index
-    kTriggerCalibSummary      = 40, ///< Number of responding strips/boards and noisy strips 
-    kTriggerCalibSummaryNorm  = 41, ///< Percentage of responding strips/boards and noisy strips
-    kTriggerErrorLocalXPos = 50, ///< Local board: Number of XPos Error vs Local Board Id
-    kTriggerErrorLocalYPos = 51, ///< Local board: Number of YPos Error vs Local Board Id
-    kTriggerErrorLocalDev  = 52, ///< Local board: Number of Deviation Error vs Local Board
-    kTriggerErrorLocalTriggerDec = 53, ///< Local board: Number of Trigger Decision (All Pt) Error vs Local Board Id
-    kTriggerErrorLocalLPtLSB = 54, ///< Local board: Number of LSB Low Pt Error vs Local Board Id
-    kTriggerErrorLocalLPtMSB = 55, ///< Local board: Number of MSB Low Pt Error vs Local Board Id
-    kTriggerErrorLocalHPtLSB = 56, ///< Local board: Number of LSB High Pt Error vs Local Board Id
-    kTriggerErrorLocalHPtMSB = 57, ///< Local board: Number of MSB High Pt Error vs Local Board Id
-    kTriggerErrorLocalTrigY  = 58, ///< Local board: Number of TrigY Error vs Local Board Id
-    kTriggerErrorLocal2RegionalLPtLSB  = 59, ///< Local to Regional: Number of LPt LSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalLPtMSB  = 60, ///< Local to Regional: Number of LPt MSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalHPtLSB  = 61, ///< Local to Regional: Number of HPt LSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalHPtMSB  = 62, ///< Local to Regional: Number of HPt MSB error vs Local Board Id
-    kTriggerErrorOutGlobalFromInGlobal = 63, ///< Global board: Number of error vs output bit 
-    kTriggerErrorSummary      = 64,  ///< Number of errors for each trigger decision level (Local, Reg->Local, Reg, Reg->Glob, Global)
-    kTriggerErrorSummaryNorm  = 65,  ///< Percentage of errors for each trigger decision level
-    kTriggerErrorLocalYCopy     = 67, ///< Local board: Number of Y Copy Error vs Local Board Id
-    kTriggerErrorLocalYCopyTest = 68, ///< Local Board: Number of Y copy error tests (for normalization)
-    kTriggerErrorLocalYCopyNorm = 69, ///< Local Board: Number of Y Copy Error vs Local Board Id Normalized to the number of tests
-    kTriggeredBoards          = 70,  ///< Triggered boards histogram index
-    kTriggerBoardsDisplay     = 71,  ///< Triggered boards display histogram index
-    kTriggerReadOutErrors     = 80,  ///< Number of read-out errors
-    kTriggerReadOutErrorsNorm = 81,  ///< Percentage of read-out errors
-    kTriggerGlobalOutput      = 90,  ///< Number of Global outputs and Global algo errors
-    kTriggerGlobalOutputNorm  = 91,  ///< Percentage of Global outputs and Global algo errors
-    kRawNAnalyzedEvents       = 100  ///< Number of analyzed events per event specie
-  };
-         
-  /// Rec points histograms indices
-  enum ERecPoints { 
-    kNAnalyzedEvents           = 0, ///< Number of analyzed events per event specie
-    kTriggerRPCtrips           = 1, ///< Trips in trigger chambers
-    kTriggerRPChv              = 2  ///< Trigger chamber HV index
-  };
-  
-//  /// ESD histograms indices
-//  enum EESD { 
-//  };
-
-  // Bins for summary histos
-  enum {
-    kTriggerRespStrips,    ///< Bin for % of responding trigger strips
-    kTriggerRespLocal,     ///< Bin for % of responding trigger local boards
-    kTriggerRespRegional,  ///< Bin for % of responding trigger regional boards
-    kTriggerRespGlobal,    ///< Bin for % of responding trigger global boards
-    kTriggerNoisyStrips,   ///< Bin for % of noisy trigger strips
-    kNtrigCalibSummaryBins ///< Total number of bins for trigger calibration summary
-  };
-
-  // Bins for algorithm error histos
-  enum {
-    kAlgoLocalX,             ///< Bin for % of local board X pos errors
-    kAlgoLocalY,             ///< Bin for % of local board Y pos errors
-    kAlgoLocalLUT,           ///< Bin for % of local board deviation errors
-    kAlgoLocalYCopy,         ///< Bin for % of local board Y copy errors
-    kAlgoLocalToRegional,    ///< Bin for % of local to regional errors
-    kAlgoRegional,           ///< Bin for % of regional board errors 
-    kAlgoRegionalToGlobal,   ///< Bin for % of regional to global errors 
-    kAlgoGlobalFromGlobal,   ///< Bin for % of global from global board errors 
-    kAlgoGlobalFromLocal,    ///< Bin for % of global from local board errors 
-    kAlgoGlobalFromRegional, ///< Bin for % of global from regional board errors 
-    kNtrigAlgoErrorBins      ///< Total number of bins for trigger error summary
-  };
-
-  enum {
-    kLocalStructError,    ///< Bin for % of errors in local struct
-    kRegionalStructError, ///< Bin for % of errors in regional struct
-    kGlobalStructError,   ///< Bin for % of errors in global struct
-    kDarcStructError,     ///< Bin for % of errors in darc struct
-    kNtrigStructErrorBins ///< Total number of bins for struct error summary
-  };
-  
 private:
   /// Not implemented
   AliMUONTriggerQADataMakerRec(const AliMUONTriggerQADataMakerRec& qadm);   
index ab8378d..3880818 100644 (file)
 #pragma link C++ class AliMUONDigitMaker+;
 #pragma link C++ class AliMUONRawWriter+;
 
+// needed by qa (sim and rec)
+#pragma link C++ class AliMUONRecoParam+;
+#pragma link C++ class AliMUONPadStatusMaker+;
+#pragma link C++ class AliMUONVQAChecker+;
+#pragma link C++ class AliMUONQAChecker+;
+#pragma link C++ class AliMUONTrackerQAChecker+;
+#pragma link C++ class AliMUONTriggerQAChecker+;
+
 #endif
 
 
index 5176164..cdf80f6 100644 (file)
@@ -46,7 +46,6 @@
 #pragma link C++ class AliMUONVTriggerTrackStore+;
 #pragma link C++ class AliMUONTriggerTrackStoreV1+;
 
-#pragma link C++ class AliMUONRecoParam+;
 
 #pragma link C++ class AliMUONVClusterServer+;
 #pragma link C++ class AliMUONSimpleClusterServer+;
 
 // calibration
 #pragma link C++ class AliMUONDigitCalibrator+;
-#pragma link C++ class AliMUONPadStatusMaker+;
 #pragma link C++ class AliMUONPadStatusMapMaker+;
 
 // QA
-#pragma link C++ class AliMUONVQADataMakerRec+;
-#pragma link C++ class AliMUONVQAChecker+;
 #pragma link C++ class AliMUONQADataMakerRec+;
-#pragma link C++ class AliMUONQAChecker+;
 #pragma link C++ class AliMUONTrackerQADataMakerRec+;
-#pragma link C++ class AliMUONTrackerQAChecker+;
 #pragma link C++ class AliMUONTriggerQADataMakerRec+;
-#pragma link C++ class AliMUONTriggerQAChecker+;
-
+#pragma link C++ class AliMUONVQADataMakerRec+;
 #pragma link C++ class AliMUONVTrackerDataMaker+;
 #pragma link C++ class AliMUONTrackerDataMaker+;
 #pragma link C++ class AliMUONTrackerConditionDataMaker+;
index 3d2d586..409c219 100644 (file)
@@ -22,7 +22,13 @@ SRCS:=  AliMUONConstants.cxx \
         AliMUONTriggerCircuit.cxx \
         AliMUONVTriggerStore.cxx \
         AliMUONTriggerStoreV1.cxx \
-        AliMUONTriggerElectronics.cxx
+        AliMUONTriggerElectronics.cxx \
+        AliMUONQAChecker.cxx \
+        AliMUONVQAChecker.cxx \
+        AliMUONTrackerQAChecker.cxx \
+        AliMUONTriggerQAChecker.cxx \
+        AliMUONRecoParam.cxx \
+        AliMUONPadStatusMaker.cxx
 
 HDRS:= $(SRCS:.cxx=.h)
 
index 0d59724..9011b3c 100644 (file)
@@ -24,7 +24,6 @@ SRCS:= AliMUONReconstructor.cxx \
        AliMUONClusterFinderCOG.cxx \
        AliMUONPad.cxx \
        AliMUONCluster.cxx \
-       AliMUONPadStatusMaker.cxx \
        AliMUONPadStatusMapMaker.cxx \
        AliMUONTrackHitPattern.cxx \
        AliMUONVClusterStore.cxx \
@@ -33,17 +32,12 @@ SRCS:= AliMUONReconstructor.cxx \
        AliMUONClusterStoreV2Iterator.cxx \
        AliMUONVTrackStore.cxx \
        AliMUONTrackStoreV1.cxx \
-       AliMUONRecoParam.cxx \
        AliMUONVClusterServer.cxx \
        AliMUONSimpleClusterServer.cxx \
        AliMUONVQADataMakerRec.cxx \
        AliMUONQADataMakerRec.cxx \
        AliMUONTrackerQADataMakerRec.cxx \
        AliMUONTriggerQADataMakerRec.cxx \
-       AliMUONQAChecker.cxx \
-       AliMUONVQAChecker.cxx \
-       AliMUONTrackerQAChecker.cxx \
-       AliMUONTriggerQAChecker.cxx \
        AliMUONClusterFinderPeakCOG.cxx \
        AliMUONClusterFinderPeakFit.cxx \
        AliMUONRefitter.cxx \