Reorganization of the QA (Rec), by splitting a MTR and MCH parts, so they can be...
authorlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Oct 2009 09:21:50 +0000 (09:21 +0000)
committerlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Oct 2009 09:21:50 +0000 (09:21 +0000)
Also, according to last DAQ meeting discussions (http://indico.cern.ch/conferenceDisplay.py?confId=70835), a few changes in our QAs are implemented :

MCH :

- can now cut on low buspatch occupancies (if the config could be retrieved)

MTR :
- Implementation of raw data checker and update of shifter information (we check trigger algorithm errors, errors in the raw structure, and dead channels/boards).
- General clean-up of QA histograms.
- Improvement of graphical results.

Few more changes still to come...

(Aurelien, Diego, Laurent)

20 files changed:
MUON/AliMUONQAChecker.cxx
MUON/AliMUONQAChecker.h
MUON/AliMUONQADataMakerRec.cxx
MUON/AliMUONQADataMakerRec.h
MUON/AliMUONRecoParam.cxx
MUON/AliMUONRecoParam.h
MUON/AliMUONTrackerQAChecker.cxx [new file with mode: 0644]
MUON/AliMUONTrackerQAChecker.h [new file with mode: 0644]
MUON/AliMUONTrackerQADataMakerRec.cxx [new file with mode: 0644]
MUON/AliMUONTrackerQADataMakerRec.h [new file with mode: 0644]
MUON/AliMUONTriggerQAChecker.cxx [new file with mode: 0644]
MUON/AliMUONTriggerQAChecker.h [new file with mode: 0644]
MUON/AliMUONTriggerQADataMakerRec.cxx [new file with mode: 0644]
MUON/AliMUONTriggerQADataMakerRec.h [new file with mode: 0644]
MUON/AliMUONVQAChecker.cxx [new file with mode: 0644]
MUON/AliMUONVQAChecker.h [new file with mode: 0644]
MUON/AliMUONVQADataMakerRec.cxx [new file with mode: 0644]
MUON/AliMUONVQADataMakerRec.h [new file with mode: 0644]
MUON/MUONrecLinkDef.h
MUON/libMUONrec.pkg

index f87c285..542f87d 100644 (file)
 ///
 /// Implementation of AliQACheckerBase for MCH and MTR
 ///
-/// For the moment we only implement the checking of raw data QA for the tracker
-/// by looking at the occupancy at the manu level.
-/// We count the number of manus above a given occupancy threshold, and
-/// depending on that number, the resulting QA flag is warning, error or fatal.
-/// (there's no "info" type in this case).
-///
 /// \author Laurent Aphecetche, Subatech
 
-#include "AliLog.h"
-#include "AliMUONVTrackerData.h"
-#include "AliMpManuIterator.h"
-#include "AliQAv1.h"
-#include <TDirectory.h>
-#include <TH1.h>
+#include "AliMUONRecoParam.h"
+#include "AliMUONTrackerQAChecker.h"
+#include "AliMUONTriggerQAChecker.h"
+#include "AliCodeTimer.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONQAChecker)
@@ -42,196 +34,86 @@ ClassImp(AliMUONQAChecker)
 
 //__________________________________________________________________
 AliMUONQAChecker::AliMUONQAChecker() : 
-    AliQACheckerBase("MUON","MUON Quality Assurance Data Maker") 
+    AliQACheckerBase("MUON","MUON Quality Assurance Data Maker"),
+fCheckers(new TObjArray)
 {
        /// ctor
+  fCheckers->SetOwner(kTRUE);
+  fCheckers->Add(new AliMUONTrackerQAChecker());
+  fCheckers->Add(new AliMUONTriggerQAChecker());
 }          
 
 //__________________________________________________________________
 AliMUONQAChecker::~AliMUONQAChecker() 
 {
        /// dtor
+  delete fCheckers;
 }
 
-//__________________________________________________________________
-AliMUONQAChecker::AliMUONQAChecker(const AliMUONQAChecker& qac) : 
-    AliQACheckerBase(qac.GetName(), qac.GetTitle()) 
-{
-       /// copy ctor 
-}   
-
 //______________________________________________________________________________
 Double_t *
-AliMUONQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list, AliDetectorRecoParam * /*recoParam*/)
+AliMUONQAChecker::Check(AliQAv1::ALITASK_t index, 
+                        TObjArray** list, 
+                        AliDetectorRecoParam * recoParam)
 {
   /// Check objects in list
   
-  if ( index == AliQAv1::kRAW ) 
-  {
-    return CheckRaws(list);
-  }
+  AliCodeTimerAuto(AliQAv1::GetTaskName(index),0);
   
-  if ( index == AliQAv1::kREC)
+  TIter next(fCheckers);
+  AliMUONVQAChecker* qac;
+  AliMUONRecoParam* muonRecoParam = static_cast<AliMUONRecoParam*>(recoParam);
+  AliMUONVQAChecker::ECheckCode* ecc(0x0);
+  Double_t* rv = new Double_t[AliRecoParam::kNSpecies];
+  for ( Int_t i = 0; i < AliRecoParam::kNSpecies; ++i ) 
   {
-    return CheckRecPoints(list);
+    rv[i] = -1.0;
   }
   
-  if ( index == AliQAv1::kESD )
+  while ( ( qac = static_cast<AliMUONVQAChecker*>(next())) )
   {
-    return CheckESD(list);
-  }
-  
-  AliWarning(Form("Checker for task %d not implement for the moment",index));
-  return NULL;
-}
-
-//______________________________________________________________________________
-TH1* 
-AliMUONQAChecker::GetHisto(TObjArray* list, const char* hname, Int_t specie) const
-{
-  /// Get a given histo from the list
-  TH1* h = static_cast<TH1*>(list->FindObject(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),hname)));
-  if (!h)
-  {
-    AliError(Form("Did not find expected histo %s",hname));
-  }
-  return h;
-}
-
-//______________________________________________________________________________
-Double_t *
-AliMUONQAChecker::CheckRecPoints(TObjArray ** list)
-{
-  /// Check rec points
-  /// Very binary check for the moment. 
-  
-  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    rv[specie] = 1.0 ; 
-  
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    TH1* h = GetHisto(list[specie],"hTrackerNumberOfClustersPerDE",specie);
-  
-    if ( !h ) rv[specie] =  0.75; // only a warning if histo not found, in order not to kill anything because QA failed...
-  
-    else if ( h->GetMean() == 0.0 ) rv[specie] =  MarkHisto(*h,0.0);
-  }
-  return rv;
-}
-
-//______________________________________________________________________________
-Double_t 
-AliMUONQAChecker::MarkHisto(TH1& histo, Double_t value) const
-{
-  /// Mark histo as originator of some QA error/warning
-  
-  if ( value != 1.0 )
-  {
-    histo.SetBit(AliQAv1::GetQABit());
-  }
-  
-  return value;
-}
+    if ( index == AliQAv1::kRAW ) 
+    {    
+      ecc = qac->CheckRaws(list,muonRecoParam);
+    }
 
-//______________________________________________________________________________
-Double_t *
-AliMUONQAChecker::CheckESD(TObjArray ** list)
-{
-  /// Check ESD
-  
-  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    rv[specie] = 1.0 ; 
-  
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+    if ( index == AliQAv1::kREC)
+    {
+      ecc = qac->CheckRecPoints(list,muonRecoParam);
+    }
     
-    TH1* h = GetHisto(list[specie],"hESDnTracks",specie);
-  
-    if (!h) rv[specie] = 0.75;
-  
-    else if ( h->GetMean() == 0.0 ) rv[specie] =  MarkHisto(*h,0.0); // no track -> fatal
-  
-    h = GetHisto(list[specie],"hESDMatchTrig",specie);
-  
-    if (!h) rv[specie] =  0.75;
-  
-    else if (h->GetMean() == 0.0 ) rv[specie] = MarkHisto(*h,0.25); // no trigger matching -> error
-  }
-  return rv;
-}
-
-//______________________________________________________________________________
-Double_t *
-AliMUONQAChecker::CheckRaws(TObjArray ** list)
-{
-  /// Check raws
-
-  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
-    rv[specie] = 1.0 ; 
-  Bool_t IsAnyTrackerDataPresent = kFALSE;
-  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-    TIter next(list[specie]);
-    TObject* object;
-    AliMUONVTrackerData* data(0x0);
-  
-    while ( (object=next()) && !data )
-      {
-        if (object->InheritsFrom("AliMUONVTrackerData"))
-          {
-            data = static_cast<AliMUONVTrackerData*>(object);
-          }
-      }
-
-    if ( !data ) 
-      {
-        AliWarning(Form("Did not find TrackerData for specie %s !",AliRecoParam::GetEventSpecieName(specie)));
-        continue;
-      }
-  
-    IsAnyTrackerDataPresent = kTRUE;
-    AliMpManuIterator it;
-    Int_t detElemId;
-    Int_t manuId;
-    Int_t n50(0); // number of manus with occupancy above 0.5
-    Int_t n75(0); // number of manus with occupancy above 0.75
-    Int_t n(0); // number of manus with some occupancy
-  
-    while ( it.Next(detElemId,manuId) )
-      {
-        Float_t occ = data->Manu(detElemId,manuId,2);
-        if (occ > 0 ) ++n;
-        if (occ >= 0.5 ) ++n50;
-        if (occ >= 0.75 ) ++n75;    
-      }
-
-    AliDebug(1,Form("n %d n50 %d n75 %d",n,n50,n75));
-  
-    if ( n == 0 ) 
-      {
-        AliError("Oups. Got zero occupancy in all manus ?!");
-        rv[specie] =  0.0;
-      }
-
-    if ( n75 ) 
-      {
-        AliError(Form("Got %d manus with occupancy above 0.75",n75));
-        rv[specie] =  0.1;
-      }
+    if ( index == AliQAv1::kESD )
+    {
+      ecc = qac->CheckESD(list,muonRecoParam);
+    }
     
-    if ( n50 ) 
+    if ( ecc ) 
+    {
+      for ( Int_t i = 0; i < AliRecoParam::kNSpecies; ++i ) 
       {
-        AliWarning(Form("Got %d manus with occupancy above 0.5",n50));
-        rv[specie] =  0.9;
+        switch ( ecc[i] ) 
+        {
+          case AliMUONVQAChecker::kInfo:
+            rv[i] = 1.0;
+            break;
+          case AliMUONVQAChecker::kWarning:
+            rv[i] = 0.75;
+            break;
+          case AliMUONVQAChecker::kError:
+            rv[i] = 0.25;
+            break;
+          case AliMUONVQAChecker::kFatal:
+            rv[i] = -1.0;
+            break;
+          default:
+            rv[i] = -1.0;
+            break;
+        }
       }
+    }
   }
   
-  if ( !IsAnyTrackerDataPresent ) 
-    {
-      AliError("Did not find any TrackerData in the list !");
-      return NULL;
-    }
+  delete[] ecc;
   
   return rv;
 }
index 22e713b..63e9edc 100644 (file)
 
 class TH1;
 class TObjArray;
+class AliMUONRecoParam;
+class AliMUONVQAChecker;
 
 class AliMUONQAChecker: public AliQACheckerBase {
 
 public:
   AliMUONQAChecker();
-  AliMUONQAChecker(const AliMUONQAChecker& qac);
   virtual ~AliMUONQAChecker();
 
-  virtual void   Init(const AliQAv1::DETECTORINDEX_t det) 
+  virtual void Init(const AliQAv1::DETECTORINDEX_t det)
 
 protected:
 
-    //using AliQACheckerBase::Check;
-  
-  virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list, AliDetectorRecoParam * recoParam) ;
-  virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const ;       
-       
-  Double_t * CheckRaws(TObjArray** list);
-  Double_t * CheckRecPoints(TObjArray** list);
-  Double_t * CheckESD(TObjArray** list);
-  TH1* GetHisto(TObjArray* list, const char* hname, Int_t specie) const;
-  Double_t MarkHisto(TH1& histo, Double_t value) const;
-  
+  virtual Double_t* Check(AliQAv1::ALITASK_t index, TObjArray ** list, AliDetectorRecoParam * recoParam); 
+
+  virtual void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const;        
+
 private:
+  AliMUONQAChecker(const AliMUONQAChecker& qac);
+  AliMUONQAChecker& operator=(const AliMUONQAChecker& qac);
   
+  TObjArray* fCheckers; ///< internal checkers
+
   ClassDef(AliMUONQAChecker,1)  // MUON quality assurance checker
 
 };
index 921dae2..cff1c67 100644 (file)
 // --- MUON header files ---
 #include "AliMUONQADataMakerRec.h"
 
-#include "AliMUONConstants.h"  
-#include "AliMUONDDLTrigger.h"
-#include "AliMUONDarcHeader.h"
-#include "AliMUONDigitMaker.h"
-#include "AliMUONDigitStoreV2R.h"
-#include "AliMUONQAMappingCheck.h"
-#include "AliMUONGlobalTriggerBoard.h"
-#include "AliMUONGlobalCrateConfig.h"
-#include "AliMUONLocalStruct.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONLocalTriggerBoard.h"
-#include "AliMUONRawStreamTracker.h"
-#include "AliMUONRawStreamTriggerHP.h"
-#include "AliMUONRegHeader.h"
-#include "AliMUONTrackerDataMaker.h"
-#include "AliMUONTriggerDisplay.h"
-#include "AliMUONVCluster.h"
-#include "AliMUONVClusterStore.h"
-#include "AliMUONVDigit.h"
-#include "AliMUONVDigitStore.h"
-#include "AliMUONVTrackerData.h"
-#include "AliMUONVTriggerStore.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackParam.h"
-#include "AliMUONTriggerElectronics.h"
-#include "AliMUONTriggerStoreV1.h"
-#include "AliMUONESDInterface.h"
-#include "AliMUONCalibrationData.h"
-#include "AliMpBusPatch.h"
-#include "AliMpCDB.h"
-#include "AliMpConstants.h"
-#include "AliMpDDLStore.h"
-#include "AliMpDEIterator.h"
-#include "AliMpDEManager.h"
-#include "AliMpDetElement.h"
-#include "AliMpLocalBoard.h"
-#include "AliMpStationType.h"
-#include "AliMpTriggerCrate.h"
-#include "AliMpDCSNamer.h"
-#include "AliRawEventHeaderBase.h"
-
-// --- AliRoot header files ---
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliESDEvent.h"
-#include "AliESDMuonTrack.h"
-#include "AliESDMuonCluster.h"
-#include "AliLog.h"
-#include "AliRawReader.h"
-#include "AliQAChecker.h"
-#include "AliCodeTimer.h"
-#include "AliDCSValue.h"
-#include "AliMUONVDigit.h"
-
-// --- ROOT system ---
-#include <TClonesArray.h>
-#include <TFile.h> 
-#include <TH1F.h> 
-#include <TH1I.h> 
-#include <TH2F.h>
-#include <TLine.h>
-#include <TPaveText.h>
-#include <Riostream.h>
-#include <TMath.h>
-
 //-----------------------------------------------------------------------------
 /// \class AliMUONQADataMakerRec
 ///
 /// MUON base class for quality assurance data (histo) maker
 ///
-/// \author C. Finck, D. Stocco, L. Aphecetche
+/// It is now only a steering class for the two subclasses AliMUONTrackerQADataMakerRec
+/// and AliMUONTriggerQADataMakerRec
+///
+/// \author C. Finck, D. Stocco, L. Aphecetche, A. Blanc
+
+#include "AliMUONTrackerQADataMakerRec.h"
+#include "AliMUONTriggerQADataMakerRec.h"
+#include "AliQAChecker.h"
+#include "AliRawReader.h"
+#include "AliRawEventHeaderBase.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONQADataMakerRec)
 /// \endcond
            
-
-namespace {
-  
-  int trim(Int_t n, 
-           Double_t* x,
-           Double_t alpha,
-           Double_t& tmean,
-           Double_t& tvar,
-           Double_t& min,
-           Double_t& max)
-  {
-    //
-    // Calculates the trimmed (tmean) mean
-    // of a sample (x) and estimates the variance (tvar)
-    // of that mean.
-    //
-    
-    // First check input parameters
-    
-    // number of observations
-    if ( n < 2 )
-    {
-      return -1;
-    }
-    
-    if ( alpha < 0 || alpha >= 0.5 )
-      // proportion of observations
-      // to be trimmed at each end of the sorted sample
-    {
-      return -2;
-    }
-    
-    // Input parameters are good. Let's move on.
-    
-    // Insure we use a sample sorted into ascending order.
-    
-    Int_t* indices = new Int_t[n];
-    
-    TMath::Sort(n,x,indices,kFALSE);
-    
-    Double_t* sx = new Double_t[n];
-    
-    for ( Int_t i = 0; i < n; ++i )
-    {
-      sx[i] = x[indices[i]];
-    }
-    delete[] indices;
-    
-  
-    // Number of observations trimmed at each end.
-    
-    Int_t k = static_cast<Int_t>(floorf(alpha * n));
-    
-    double sum = 0.0;
-    
-    for ( Int_t i = k; i < n - k ; ++i )
-    {
-      sum += sx[i];
-    }
-    
-    tmean = sum / ( n - 2 * k );
-  
-    double t2 = 0.0;
-    
-    for ( Int_t i = k; i < n - k; ++i )
-    {
-      t2 += (sx[i] - tmean) * (sx[i] - tmean);
-    }
-    
-    tvar = (
-            t2 +
-            k * (sx[k] - tmean) * (sx[k] - tmean) +
-            k * (sx[n - k - 1] - tmean) * (sx[n - k - 1] - tmean)
-            ) / (n * n);
-    
-    // get the min and max for the non-rejected values
-    min = DBL_MAX;
-    max = 0.0;
-    
-    for ( Int_t i = k; i < n-k; ++i ) 
-    {
-      min = TMath::Min(min,sx[i]);
-      max = TMath::Max(max,sx[i]);
-    }
-    
-    delete[] sx;
-    
-    return 0;
-  }
-}
-
 //____________________________________________________________________________ 
-AliMUONQADataMakerRec::AliMUONQADataMakerRec() : 
+AliMUONQADataMakerRec::AliMUONQADataMakerRec(Bool_t tracker, Bool_t trigger) : 
 AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kMUON), "MUON Quality Assurance Data Maker"),
-fDigitStore(0x0),
-fDigitMaker(0x0),
-fClusterStore(0x0),
-fTrackerDataMaker(0x0),
-fMappingCheckRecPoints(0x0),
-fCalibrationData(0x0),
-fTriggerProcessor(0x0)
-{
-    /// ctor
-       
-  AliDebug(AliQAv1::GetQADebugLevel(),"");
-
-       Ctor();
-}
-
-//____________________________________________________________________________ 
-void
-AliMUONQADataMakerRec::Ctor()
-{
-       /// Init some members
-  AliCodeTimerAuto("",0);
-       fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV1");
-       fDigitMaker = new AliMUONDigitMaker(kTRUE);
-       fCalibrationData = new AliMUONCalibrationData(AliCDBManager::Instance()->GetRun());
-       fTriggerProcessor = new AliMUONTriggerElectronics(fCalibrationData);
-}
-
-//____________________________________________________________________________ 
-AliMUONQADataMakerRec::AliMUONQADataMakerRec(const AliMUONQADataMakerRec& qadm) :
-AliQADataMakerRec(qadm),
-fDigitStore(0x0),
-fDigitMaker(0x0),
-fClusterStore(0x0),
-fTrackerDataMaker(0x0),
-fMappingCheckRecPoints(0x0),
-fCalibrationData(0x0),
-fTriggerProcessor(0x0)
-{
-    ///copy ctor 
-
-  AliDebug(AliQAv1::GetQADebugLevel(),"");
-
-
-    SetName((const char*)qadm.GetName()) ; 
-    SetTitle((const char*)qadm.GetTitle()); 
-
-       // Do not copy the digit store and digit maker, but create its own ones
-       
-       Ctor();
-       
-}
-
-//__________________________________________________________________
-AliMUONQADataMakerRec& AliMUONQADataMakerRec::operator = (const AliMUONQADataMakerRec& qadm )
+fTracker(tracker ? new AliMUONTrackerQADataMakerRec(this) : 0x0),
+fTrigger(trigger ? new AliMUONTriggerQADataMakerRec(this) : 0x0)
 {
-  /// Assignment operator
-
-  AliDebug(AliQAv1::GetQADebugLevel(),"");
-
-  // check assignment to self
-  if (this == &qadm) return *this;
-
-  this->~AliMUONQADataMakerRec();
-  new(this) AliMUONQADataMakerRec(qadm);
-  return *this;
+  /// ctor
 }
 
 //__________________________________________________________________
 AliMUONQADataMakerRec::~AliMUONQADataMakerRec()
 {
     /// dtor
-  
-  AliDebug(AliQAv1::GetQADebugLevel(),"");
-
-  AliCodeTimerAuto("",0);
-  
-  delete fDigitStore;
-  delete fDigitMaker;
-  delete fClusterStore;
-  delete fTrackerDataMaker;
-  delete fCalibrationData;
-  delete fTriggerProcessor;
-  delete fMappingCheckRecPoints;
+  delete fTracker;
+  delete fTrigger;
 }
 
 //____________________________________________________________________________ 
@@ -278,2069 +60,139 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjAr
 {
   /// Detector specific actions at end of cycle
   
-  AliCodeTimerAuto("",0);
-  
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
   {
     if (! IsValidEventSpecie(specie, list)  ) continue;
     
     SetEventSpecie(AliRecoParam::ConvertIndex(specie));
         
-    if ( task == AliQAv1::kRAWS && fTrackerDataMaker 
+    if ( task == AliQAv1::kRAWS ) 
     {
-      // export trackerdata as is, and also make a summarized version (buspatchoccupancy)
-      EndOfDetectorCycleRaws(specie,list);
+      if (fTracker) fTracker->EndOfDetectorCycleRaws(specie,list);
+      if (fTrigger) fTrigger->EndOfDetectorCycleRaws(specie,list);
     }
     
     if ( task == AliQAv1::kRECPOINTS )
     {
       // normalize recpoints histograms
-      EndOfDetectorCycleRecPoints(specie,list);
+      if (fTracker) fTracker->EndOfDetectorCycleRecPoints(specie,list);
+      if (fTrigger) fTrigger->EndOfDetectorCycleRecPoints(specie,list);
     }
     
     if ( task == AliQAv1::kESDS ) 
     {
       // normalize esds histograms
-      EndOfDetectorCycleESDs();
+      if (fTracker) fTracker->EndOfDetectorCycleESDs(specie,list);
+      if (fTrigger) fTrigger->EndOfDetectorCycleESDs(specie,list);
     }
-    
-    // Display trigger histos in a more user friendly way
-    DisplayTriggerInfo(task);
-    
-  } // loop on specie
+   } // loop on specie
     
   // do the QA checking
-  AliQAChecker::Instance()->Run(AliQAv1::kMUON,task,list);
+  AliQAChecker::Instance()->Run(AliQAv1::kMUON,task,list,const_cast<AliDetectorRecoParam*>(GetRecoParam()));
 }
 
 //____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InsertTrackerData(Int_t specie, TObjArray** list,
-                                              TObject* object, Int_t indexNumber,
-                                              Bool_t replace)
+void AliMUONQADataMakerRec::InitRaws()
 {
-  /// Insert an object to a given list
-  
-  TIter next(list[specie]);
-  TObject* o;
-  TObject* old(0x0);
-  Bool_t alreadyThere(kFALSE);
-  while ( ( o = next() ) && !alreadyThere )
-  {
-    TString classname(o->ClassName());
-    if ( classname.Contains("TrackerData") ) 
-    {
-      alreadyThere = kTRUE;
-      old = o;
-    }
-  }
-  if ( (!alreadyThere && object) || (alreadyThere && replace) )
-  {
-    delete old;
-    AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s to the list of qa objects",object->GetName()));
-    list[specie]->AddAt(object,indexNumber);
-  }
+  /// create Raws histograms in Raws subdir
+       
+  if ( fTracker ) fTracker->InitRaws();
+  if ( fTrigger ) fTrigger->InitRaws();
 }
 
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::EndOfDetectorCycleESDs()
+//__________________________________________________________________
+void AliMUONQADataMakerRec::InitDigits() 
 {
-  /// Normalize ESD histograms
-  
-  if (!GetESDsData(kESDnClustersPerTrack)) return;
-  
-  Double_t nTracks = GetESDsData(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);
-  
-  hESDnClustersPerCh->Reset();
-  hESDnClustersPerDE->Reset();
-  hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks);
-  hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks);
-  
-  // loop over chambers
-  for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
-    
-    TH1* hESDClusterChargeInCh = GetESDsData(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);
-    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);
-    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);
-    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);
-    Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
-    hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
-    hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
-    
-    TH1* hESDLocalChi2YInCh = GetESDsData(kESDLocalChi2YInCh+iCh);
-    Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
-    hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
-    hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
-    
-    TH1* hESDLocalChi2InCh = GetESDsData(kESDLocalChi2InCh+iCh);
-    Double_t sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS();
-    hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean());
-    hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError());
-    
-    // loop over DE into chamber iCh
-    AliMpDEIterator it;
-    it.First(iCh);
-    while ( !it.IsDone()) {
-      
-      Int_t iDE = it.CurrentDEId();
-      
-      Double_t nClusters = hESDnTotClustersPerDE->GetBinContent(iDE+1);
-      if (nClusters > 1) {
-        
-        hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters);
-        hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
-        
-        Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters;
-        hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX);
-        hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters));
-        hESDResidualXPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX));
-        hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters));
-        
-        Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters;
-        hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY);
-        hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters));
-        hESDResidualYPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY));
-        hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters));
-        
-        hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters);
-        hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters));
-        
-        hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters);
-        hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters));
-        
-        hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters);
-        hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters));
-        
-      } else {
-        
-        hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1));
-        hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax());
-        
-        hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1));
-        hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
-        hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.);
-        hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
-        
-        hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1));
-        hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
-        hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.);
-        hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
-        
-        hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1));
-        hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax());
-        
-        hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1));
-        hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax());
-        
-        hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1));
-        hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax());
-        
-      }
-      
-      Double_t nFullClusters = hESDnTotFullClustersPerDE->GetBinContent(iDE+1);
-      if (nFullClusters > 1) {
-        
-        hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters);
-        hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters));
-        
-      } else {
-        
-        hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1));
-        hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax());
-        
-      }
-      
-      it.Next();
-    }
-
-  }
+  /// Initialized Digits spectra 
+  if ( fTracker ) fTracker->InitDigits();
+  if ( fTrigger ) fTrigger->InitDigits();
+} 
 
-}
-  
 //____________________________________________________________________________ 
-void AliMUONQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list)
+void AliMUONQADataMakerRec::InitRecPoints()
 {
-  /// Normalize RecPoints histograms
-  
-  if (!GetRecPointsData(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);
-  
-  // loop over chambers
-  for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
-    
-    TH1* hTrackerClusterChargePerChamber = GetRecPointsData(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);
-    Double_t sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS();
-    hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean());
-    hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError());
-    hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize);
-    hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError());
-    
-    // loop over DE into chamber iCh
-    AliMpDEIterator it;
-    it.First(iCh);
-    while ( !it.IsDone()) {
-      
-      Int_t iDE = it.CurrentDEId();
-      
-      TH1* hTrackerClusterChargePerDE = GetRecPointsData(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);
-      hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean());
-      nClusters = hTrackerClusterMultiplicityPerDE->GetEntries();
-      if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters));
-      else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax());
-      
-      it.Next();
-    }
-  }
-  
-  if ( fMappingCheckRecPoints ) InsertTrackerData(specie,list,fMappingCheckRecPoints->CreateData("RecPoints"),kTrackerRecPoints,kTRUE);
+       /// create Reconstructed Points histograms in RecPoints subdir
+  if ( fTracker ) fTracker->InitRecPoints();
+  if ( fTrigger ) fTrigger->InitRecPoints();
 }
 
 
 //____________________________________________________________________________ 
-void AliMUONQADataMakerRec::EndOfDetectorCycleRaws(Int_t specie, TObjArray** list)
+void AliMUONQADataMakerRec::InitESDs()
 {
-  /// create Raws histograms in Raws subdir
-  
-  if ( !GetRawsData(kTrackerBusPatchOccupancy) ) return;
-
-  if ( fTrackerDataMaker ) 
-  {
-    InsertTrackerData(specie,list,fTrackerDataMaker->Data(),kTrackerData);
-
-    TH1* hbp = GetRawsData(kTrackerBusPatchOccupancy);
-    hbp->Reset();
-    TIter nextBP(AliMpDDLStore::Instance()->CreateBusPatchIterator());
-    AliMpBusPatch* bp(0x0);
-    AliMUONVTrackerData* data = fTrackerDataMaker->Data();
-    Int_t occDim = 2;
-    
-    while ( ( bp = static_cast<AliMpBusPatch*>(nextBP())) )
-    {
-      Int_t busPatchId = bp->GetId();
-      Int_t bin = hbp->FindBin(busPatchId);
-      hbp->SetBinContent(bin,data->BusPatch(busPatchId,occDim)*100.0); // occupancy, in percent
-    }
-    
-    BeautifyTrackerBusPatchOccupancy(*hbp);
-  }
-
-  // Normalize RawData histos
-      Float_t nbevent = GetRawsData(kRawNAnalyzedEvents)->GetBinContent(1);
-      TH1* htemp = GetRawsData(kTriggerError);
-      Float_t temp=htemp->GetBinContent(4);
-      htemp->SetBinContent(4, temp/192.);
-      if (nbevent>0) htemp->Scale(100./nbevent);
+  ///create ESDs histograms in ESDs subdir
+  if ( fTracker ) fTracker->InitESDs();
+  if ( fTrigger ) fTrigger->InitESDs();
 }
 
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InitRaws()
+//____________________________________________________________________________
+void AliMUONQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 {
-    /// create Raws histograms in Raws subdir
-       
-  AliCodeTimerAuto("",0);
-  
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t saveCorr = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  TString boardName = "Local board Id";
-
-  Int_t nbLocalBoard = AliMUONConstants::NTriggerCircuit();
-  
-  TString histoName, histoTitle;
-  for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
-    TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
-    for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
-      histoName = Form("hTriggerScalers%sChamber%i", cathName.Data(), 11+iChamber);
-      histoTitle = Form("Chamber %i - %s: trigger scaler counts", 11+iChamber, cathName.Data());
-      TH2F* h3 = new TH2F(histoName.Data(), histoTitle.Data(),
-                         234, 0.5, 234.5,
-                         16, -0.5, 15.5);
-      h3->GetXaxis()->SetTitle(boardName.Data());
-      h3->GetYaxis()->SetTitle("Strip");       
-      h3->SetOption("COLZ");   
-      Add2RawsList(h3, kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
-    }
-  }
-       
-       AliMUONTriggerDisplay triggerDisplay;
-       for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
-               TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
-               for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
-                       histoName = Form("hScalersDisplay%sChamber%i", cathName.Data(), 11+iChamber);
-                       histoTitle = Form("Chamber %i - %s: Hit rate from scalers (Hz/cm^{2})", 11+iChamber, cathName.Data());
-                       TH2F* h5 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
-                                                                             iCath, iChamber, histoTitle);
-                       h5->SetOption("COLZ");
-                       Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image, !saveCorr);
-               }
-       }
-
-       FillTriggerDCSHistos();
-
-       TH1F* h10 = new TH1F("hTriggerScalersTime", "Acquisition time from trigger scalers", 1, 0.5, 1.5);
-       h10->GetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event.");
-       h10->GetYaxis()->SetTitle("Cumulated scaler time (s)");
-       Add2RawsList(h10, kTriggerScalersTime, !expert, !image, !saveCorr);
-       
-       Char_t *globalXaxisName[6] = {"US HPt", "US LPt", "LS HPt", "LS LPt", "SGL HPt", "SGL LPt"};
-       Char_t *allLevelXaxisName[10] = {"Local algo X", "Local algo Y", "Local LUT","Local Y Copy" , "Local2Regional", "Regional", "Regional2Global", "GlobalFromInGlobal", "GlobalFromInLocal", "GlobalFromOutLocal"};
-
-       TString errorAxisTitle = "Number of errors";
-
-       TH1F* h11 = new TH1F("ErrorLocalXPos", "ErrorLocalXPos",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h11->GetXaxis()->SetTitle(boardName.Data());
-       h11->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h11, kTriggerErrorLocalXPos, expert, !image, !saveCorr);
-
-       TH1F* h12 = new TH1F("ErrorLocalYPos", "ErrorLocalYPos",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h12->GetXaxis()->SetTitle(boardName.Data());
-       h12->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h12, kTriggerErrorLocalYPos, expert, !image, !saveCorr);
-
-       TH1F* h13 = new TH1F("ErrorLocalDev", "ErrorLocalDev",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h13->GetXaxis()->SetTitle(boardName.Data());
-       h13->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h13, kTriggerErrorLocalDev, expert, !image, !saveCorr);
-
-       TH1F* h14 = new TH1F("ErrorLocalTriggerDec", "ErrorLocalTriggerDec",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h14->GetXaxis()->SetTitle(boardName.Data());
-       h14->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h14, kTriggerErrorLocalTriggerDec, expert, !image, !saveCorr);
-
-       TH1F* h15 = new TH1F("ErrorLocalLPtLSB", "ErrorLocalLPtLSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h15->GetXaxis()->SetTitle(boardName.Data());
-       h15->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h15, kTriggerErrorLocalLPtLSB, expert, !image, !saveCorr);
-
-       TH1F* h16 = new TH1F("ErrorLocalLPtMSB", "ErrorLocalLPtMSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h16->GetXaxis()->SetTitle(boardName.Data());
-       h16->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h16, kTriggerErrorLocalLPtMSB, expert, !image, !saveCorr);
+  /// make QA for rawdata
 
-       TH1F* h17 = new TH1F("ErrorLocalHPtLSB", "ErrorLocalHPtLSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h17->GetXaxis()->SetTitle(boardName.Data());
-       h17->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h17, kTriggerErrorLocalHPtLSB, expert, !image, !saveCorr);
+  // Check id histograms already created for this Event Specie
 
-       TH1F* h18 = new TH1F("ErrorLocalHPtMSB", "ErrorLocalHPtMSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h18->GetXaxis()->SetTitle(boardName.Data());
-       h18->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h18, kTriggerErrorLocalHPtMSB, expert, !image, !saveCorr);
-
-       TH1F* h19 = new TH1F("ErrorLocal2RegionalLPtLSB", "ErrorLocal2RegionalLPtLSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h19->GetXaxis()->SetTitle(boardName.Data());
-       h19->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h19, kTriggerErrorLocal2RegionalLPtLSB, expert, !image, !saveCorr);
-
-       TH1F* h20 = new TH1F("ErrorLocal2RegionalLPtMSB", "ErrorLocal2RegionalLPtMSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h20->GetXaxis()->SetTitle(boardName.Data());
-       h20->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h20, kTriggerErrorLocal2RegionalLPtMSB, expert, !image, !saveCorr);
-
-       TH1F* h21 = new TH1F("ErrorLocal2RegionalHPtLSB", "ErrorLocal2RegionalHPtLSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h21->GetXaxis()->SetTitle(boardName.Data());
-       h21->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h21, kTriggerErrorLocal2RegionalHPtLSB, expert, !image, !saveCorr);
-
-       TH1F* h22 = new TH1F("ErrorLocal2RegionalHPtMSB", "ErrorLocal2RegionalHPtMSB",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h22->GetXaxis()->SetTitle(boardName.Data());
-       h22->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h22, kTriggerErrorLocal2RegionalHPtMSB, expert, !image, !saveCorr);
-
-       TH1F* h23 = new TH1F("ErrorOutGlobalFromInGlobal", "ErrorOutGlobalFromInGlobal",6,0,6);
-       h23->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       for (int i=0;i<6;i++){
-           h23->GetXaxis()->SetBinLabel(i+1,globalXaxisName[i]);
-       }
-       Add2RawsList(h23, kTriggerErrorOutGlobalFromInGlobal, expert, !image, !saveCorr);
-
-       TH1F* h24 = new TH1F("ErrorTrigger", "ErrorTrigger",11,0,11);
-       h24->GetYaxis()->SetTitle("Percentage of error");
-       for (int i=0;i<10;i++){
-           h24->GetXaxis()->SetBinLabel(i+1,allLevelXaxisName[i]);
-       }
-       Add2RawsList(h24, kTriggerError, !expert, !image, !saveCorr);
-
-       TH1F* h25 = new TH1F("ErrorLocalTrigY", "ErrorLocalTrigY",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h25->GetXaxis()->SetTitle(boardName.Data());
-       h25->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h25, kTriggerErrorLocalTrigY, expert, !image, !saveCorr);
-
-       TH1F* h26 = new TH1F("ErrorLocalYCopy", "ErrorLocalYCopy",nbLocalBoard+1,-0.5,(Float_t)nbLocalBoard+0.5);
-       h26->GetXaxis()->SetTitle(boardName.Data());
-       h26->GetYaxis()->SetTitle(errorAxisTitle.Data());
-       Add2RawsList(h26, kTriggerErrorLocalYCopy, expert, !image, !saveCorr);
-       
-       TH1F* h27 = new TH1F("hRawNAnalyzedEvents", "Number of analyzed events per specie", 1, 0.5, 1.5);
-       Int_t esindex = AliRecoParam::AConvert(fEventSpecie);
-       h27->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
-       h27->GetYaxis()->SetTitle("Number of analyzed events");
-       Add2RawsList(h27, kRawNAnalyzedEvents, expert, !image, !saveCorr);
-
-  Int_t bpmin(999999);
-  Int_t bpmax(0);
-  
-  TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
-  AliMpBusPatch* bp(0x0);
-  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
+  if ( fTracker && rawReader->GetType() == AliRawEventHeaderBase::kPhysicsEvent ) 
   {
-    bpmin = TMath::Min(bpmin,bp->GetId());
-    bpmax = TMath::Max(bpmax,bp->GetId());
+    rawReader->Reset();
+    fTracker->MakeRaws(rawReader);
   }
   
-  Double_t xmin = bpmin-0.5;
-  Double_t xmax = bpmax+0.5;
-  Int_t nbins = bpmax-bpmin+1;
-  
-  TH1* hbp = new TH1F("hTrackerBusPatchOccupancy","Occupancy of bus patches",nbins,xmin,xmax);
-
-  TH1* hbpnpads = new TH1F("hTrackerBusPatchNofPads","Number of pads per bus patch",nbins,xmin,xmax);
-
-  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);
-
-  const Bool_t histogram(kFALSE);
-
-  if(!fTrackerDataMaker) 
+  if ( fTrigger && (rawReader->GetType() == AliRawEventHeaderBase::kPhysicsEvent ||
+                    rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent ) )
   {
-    fTrackerDataMaker = new AliMUONTrackerDataMaker(GetMUONRecoParam(),
-                                                    AliCDBManager::Instance()->GetRun(),
-                                                    0x0,
-                                                    "",
-                                                    "NOGAIN",
-                                                    histogram,
-                                                    0.0,0.0);
+    rawReader->Reset();    
+    fTrigger->MakeRaws(rawReader);
   }
-  
-  fTrackerDataMaker->Data()->DisableChannelLevel(); // to save up disk space, we only store starting at the manu level
-
-  fTrackerDataMaker->SetRunning(kTRUE);
 }
 
 //__________________________________________________________________
-void AliMUONQADataMakerRec::InitDigits() 
+void AliMUONQADataMakerRec::MakeDigits()         
 {
-  /// Initialized Digits spectra 
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
-  TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts",  1400, 100, 1500); 
-  Add2DigitsList(h0, 0, !expert, image);
+  /// makes data from Digits
   
-  TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits;ACD value;Counts", 4096, 0, 4095); 
-  Add2DigitsList(h1, 1, !expert, image);    
-} 
+  AliError("Not implemented");
+}
 
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InitRecPoints()
+//__________________________________________________________________
+void AliMUONQADataMakerRec::MakeDigits(TTree* digitsTree)         
 {
-       /// create Reconstructed Points histograms in RecPoints subdir
-  
-  AliCodeTimerAuto("",0);
-  
-       InitRecPointsTrigger();
-       InitRecPointsTracker();
+  /// makes data from Digits
+
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+
+  if ( fTracker ) fTracker->MakeDigits(digitsTree);
+  if ( fTrigger ) fTrigger->MakeDigits(digitsTree);  
 }
 
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InitRecPointsTracker()
+//____________________________________________________________________________
+void AliMUONQADataMakerRec::MakeRecPoints(TTree* clustersTree)
 {
-  /// create Reconstructed Points histograms in RecPoints subdir for the
-  /// MUON tracker subsystem.
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
-  AliCodeTimerAuto("",0);
-  
-  TH1I *h1I;
-  TH1F *h1F;
-  TH2F *h2F;
-  
-  // histograms per chamber
-  Int_t nCh = AliMpConstants::NofTrackingChambers();
-  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);
-    
-    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);
-    
-    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);
-  }
-  
-  // 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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  // histograms per DE
-  Int_t ndes(0);
-  AliMpDEIterator it;
-  it.First();
-  while ( !it.IsDone())
-  {
-    Int_t detElemId = it.CurrentDEId();
-    
-    if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger )
-    {
-      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);
-      
-      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);
-    }
-    
-    it.Next();
-  }
-  
-  // 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);
-  
-  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);
-  
-  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);
-  
-  if (!fMappingCheckRecPoints) fMappingCheckRecPoints = new AliMUONQAMappingCheck(fRun);  
+       /// Fill histograms from treeR
+
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+       
+  if ( fTracker ) fTracker->MakeRecPoints(clustersTree);
+  if ( fTrigger ) fTrigger->MakeRecPoints(clustersTree);  
 }
 
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InitRecPointsTrigger()
+//____________________________________________________________________________
+void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd)
 {
-       /// create Reconstructed Points histograms in RecPoints subdir for the
-       /// MUON Trigger subsystem.
-       
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
+  /// make QA data from ESDs
 
-  TString boardName = "Local board Id";
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+  
+  if ( fTracker ) fTracker->MakeESDs(esd);
+  if ( fTrigger ) fTrigger->MakeESDs(esd);  
 
-  TString histoName, histoTitle;
-  for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
-    TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
-    for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
-      histoName = Form("hTriggerDigits%sChamber%i", cathName.Data(), 11+iChamber);
-      histoTitle = Form("Chamber %i - %s: counts per strip", 11+iChamber, cathName.Data());
-      TH2F* h0 = new TH2F(histoName.Data(), histoTitle.Data(),
-                         234, 0.5, 234.5,
-                         16, -0.5, 15.5);
-      h0->GetXaxis()->SetTitle(boardName.Data());
-      h0->GetYaxis()->SetTitle("Strip");
-      h0->SetOption("COLZ");
-      Add2RecPointsList(h0, kTriggerDigits + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image);
-    }
-  }
-
-    TH1F* h2 = new TH1F("hTriggeredBoards", "Triggered boards", 234, 0.5, 234.5);
-    Add2RecPointsList(h2, kTriggeredBoards, expert, !image);
-
-    AliMUONTriggerDisplay triggerDisplay;
-    for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
-      TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
-      for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
-       histoName = Form("hTriggerDigitsDisplay%sChamber%i", cathName.Data(), 11+iChamber);
-       histoTitle = Form("Chamber %i - %s: Occupancy per strip (counts/event)", 11+iChamber, cathName.Data());
-       TH2F* h3 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
-                                                             iCath, iChamber, histoTitle);
-       h3->SetOption("COLZ");
-       Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image);
-      }
-    }
-
-    TH2F* h4 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
-                                                         0, 0, "Local board triggers / event");
-    h4->SetOption("COLZ");
-    Add2RecPointsList(h4, kTriggerBoardsDisplay, !expert, image);
-
-    TH1F* h5 = new TH1F("hNAnalyzedEvents", "Number of analyzed events per specie", 1, 0.5, 1.5);
-    Int_t esindex = AliRecoParam::AConvert(fEventSpecie);
-    h5->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
-    h5->GetYaxis()->SetTitle("Number of analyzed events");
-    Add2RecPointsList(h5, kNAnalyzedEvents, !expert, image);
-}
-
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::InitESDs()
-{
-  ///create ESDs histograms in ESDs subdir
-  
-  const Bool_t expert   = kTRUE ; 
-  const Bool_t image    = kTRUE ; 
-  
-  Int_t nCh = AliMUONConstants::NTrackingCh();
-  Int_t nDE = 1100;
-  
-  // track info
-  TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDnTracks, kESDnTracks, !expert, image);
-
-  TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDMatchTrig, kESDMatchTrig, !expert, image);
-  
-  TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
-  Add2ESDsList(hESDMomentum, kESDMomentum, !expert, image);
-
-  TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
-  Add2ESDsList(hESDPt, kESDPt, !expert, image);
-
-  TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
-  Add2ESDsList(hESDRapidity, kESDRapidity, !expert, image);
-
-  TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
-  Add2ESDsList(hESDChi2, 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);
-  
-  TH1F* hESDThetaX = new TH1F("hESDThetaX", "#theta_{X} distribution;#theta_{X} (degree)", 360, -180., 180);
-  Add2ESDsList(hESDThetaX, kESDThetaX, !expert, image);
-  
-  TH1F* hESDThetaY = new TH1F("hESDThetaY", "#theta_{Y} distribution;#theta_{Y} (degree)", 360, -180., 180);
-  Add2ESDsList(hESDThetaY, 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);
-  }
-  
-  TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
-  Add2ESDsList(hESDnClustersPerTrack, 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);
-  
-  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);
-  
-  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);
-  }
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  }
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  // 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);
-    
-    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);
-    
-    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);
-    
-    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);
-    
-    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);
-  }
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  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);
-  
-  // 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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-  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);
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRaws(AliRawReader* rawReader)
-{
-    /// make QA for rawdata
-
-    // Check id histograms already created for this Event Specie
-
-  AliDebug(AliQAv1::GetQADebugLevel(),
-          Form("RAW event type %s", AliRawEventHeaderBase::GetTypeName(rawReader->GetType())));
-  
-  if ( rawReader->GetType() == AliRawEventHeaderBase::kPhysicsEvent ) 
-  {
-    rawReader->Reset();
-    MakeRawsTracker(rawReader);
-  }
-  
-  if ( rawReader->GetType() == AliRawEventHeaderBase::kPhysicsEvent ||
-       rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent ) 
-  {
-    rawReader->Reset();    
-    MakeRawsTrigger(rawReader);
-  }
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRawsTracker(AliRawReader* rawReader)
-{
-       /// make QA for rawdata tracker
-       
-  /// forces init
-  GetRawsData(kTrackerBusPatchOccupancy);
-  
-       ((AliMUONTrackerDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader);
-       
-       fTrackerDataMaker->ProcessEvent();
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRawsTrigger(AliRawReader* rawReader)
-{
-       /// make QA for rawdata trigger
-       
-
-    GetRawsData(kRawNAnalyzedEvents)->Fill(1.);
-
-    // Init Local/Regional/Global decision with fake values
-    Int_t globaltemp[4];
-    for (Int_t bit=0; bit<4; bit++){
-       globaltemp[bit]=0;
-       fgitmp[bit]=0;
-    }
-
-    for (Int_t loc=0;loc<235;loc++){
-       fTriggerErrorLocalYCopy[loc]=kFALSE;
-
-       fTriggerOutputLocalRecTriggerDec[loc]=0;
-       fTriggerOutputLocalRecLPtDec[0][loc]=0;
-       fTriggerOutputLocalRecLPtDec[1][loc]=0;
-       fTriggerOutputLocalRecHPtDec[0][loc]=0;
-       fTriggerOutputLocalRecHPtDec[1][loc]=0;
-       fTriggerOutputLocalRecXPos[loc]=0;
-       fTriggerOutputLocalRecYPos[loc]=15;
-       fTriggerOutputLocalRecDev[loc]=0;
-       fTriggerOutputLocalRecTrigY[loc]=1;
-
-       fTriggerOutputLocalDataTriggerDec[loc]=0;
-       fTriggerOutputLocalDataLPtDec[0][loc]=0;
-       fTriggerOutputLocalDataLPtDec[1][loc]=0;
-       fTriggerOutputLocalDataHPtDec[0][loc]=0;
-       fTriggerOutputLocalDataHPtDec[1][loc]=0;
-       fTriggerOutputLocalDataXPos[loc]=0;
-       fTriggerOutputLocalDataYPos[loc]=15;
-       fTriggerOutputLocalDataDev[loc]=0;
-       fTriggerOutputLocalDataTrigY[loc]=1;
-       fTriggerInputRegionalDataLPt[0][loc]=0;
-       fTriggerInputRegionalDataLPt[1][loc]=0;
-       fTriggerInputRegionalDataHPt[0][loc]=0;
-       fTriggerInputRegionalDataHPt[1][loc]=0; 
-    }
-
-    for (Int_t reg=0;reg<16;reg++){
-       fTriggerOutputRegionalData[reg]=0;
-       for (Int_t bit=0;bit<4;bit++){
-           fTriggerInputGlobalDataLPt[reg][bit]=0;
-           fTriggerInputGlobalDataHPt[reg][bit]=0;
-       }
-    }
-
-    for (Int_t bit=0;bit<6;bit++){
-       fgotmp[bit]=0;
-       fTriggerOutputGlobalData[bit]=0;
-       fTriggerOutputGlobalRecFromGlobalInput[bit]=0;
-    }
-
-    for (Int_t loc=0;loc<243;loc++){
-       for (Int_t bit=0;bit<16;bit++){
-           fTriggerPatternX1[loc][bit]=0;
-           fTriggerPatternX2[loc][bit]=0;
-           fTriggerPatternX3[loc][bit]=0;
-           fTriggerPatternX4[loc][bit]=0;
-
-           fTriggerPatternY1[loc][bit]=0;
-           fTriggerPatternY2[loc][bit]=0;
-           fTriggerPatternY3[loc][bit]=0;
-           fTriggerPatternY4[loc][bit]=0;
-       }
-    }
-
-    AliMUONDigitStoreV2R digitStore;
-    digitStore.Create();
-    digitStore.Clear();
-
-    
-    AliMUONTriggerStoreV1 triggerStore;
-    triggerStore.Create();
-    triggerStore.Clear();
-    
-    // Get trigger Local, Regional, Global in/outputs and scalers
-
-    Int_t loCircuit=0;
-    AliMpCDB::LoadDDLStore();
-
-    const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
-    const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
-    const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
-
-    AliMUONRawStreamTriggerHP rawStreamTrig(rawReader);
-    
-    while (rawStreamTrig.NextDDL()) 
-    {
-      Bool_t scalerEvent =  rawReader->GetDataHeader()->GetL1TriggerMessage() & 0x1;
-
-      darcHeader = rawStreamTrig.GetHeaders();
-
-      if (darcHeader->GetGlobalFlag()){
-        UInt_t nOfClocks = darcHeader->GetGlobalClock();
-        Double_t nOfSeconds = ((Double_t) nOfClocks) / 40e6; // 1 clock each 25 ns
-        ((TH1F*)GetRawsData(kTriggerScalersTime))->Fill(1., nOfSeconds);
-
-       //Get Global datas
-       for (Int_t bit=1; bit<7; bit++){
-         fTriggerOutputGlobalData[bit-1]=Int_t(((darcHeader->GetGlobalOutput())>>bit)&1);
-       }
-       for (Int_t Bit=0; Bit<32; Bit++){
-         fTriggerInputGlobalDataLPt[Bit/4][Bit%4]=((darcHeader->GetGlobalInput(0)>>Bit)&1);
-         fTriggerInputGlobalDataLPt[Bit/4+8][Bit%4]=((darcHeader->GetGlobalInput(1)>>Bit)&1);
-         fTriggerInputGlobalDataHPt[Bit/4][Bit%4]=((darcHeader->GetGlobalInput(2)>>Bit)&1);
-         fTriggerInputGlobalDataHPt[Bit/4+8][Bit%4]=((darcHeader->GetGlobalInput(3)>>Bit)&1);
-       }
-
-       globaltemp[0]=darcHeader->GetGlobalInput(0);
-       globaltemp[1]=darcHeader->GetGlobalInput(1);
-       globaltemp[2]=darcHeader->GetGlobalInput(2);
-       globaltemp[3]=darcHeader->GetGlobalInput(3);
-      }
-    
-      Int_t nReg = rawStreamTrig.GetRegionalHeaderCount();
-
-      for(Int_t iReg = 0; iReg < nReg ;iReg++)
-      {   //reg loop
-
-         Int_t regId=rawStreamTrig.GetDDL()*8+iReg;
-
-       // crate info  
-         AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->GetTriggerCrate(rawStreamTrig.GetDDL(), iReg);
-
-         regHeader =  rawStreamTrig.GetRegionalHeader(iReg);
-
-       //Get regional outputs -> not checked, hardware read-out doesn't work
-       fTriggerOutputRegionalData[regId]=Int_t(regHeader->GetOutput());
-
-       // loop over local structures
-       Int_t nLocal = regHeader->GetLocalStructCount();
-
-       for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) 
-       {
-           
-           localStruct = regHeader->GetLocalStruct(iLocal);
-
-         // if card exist
-         if (!localStruct) continue;
-          
-         loCircuit = crate->GetLocalBoardId(localStruct->GetId());
-
-         if ( !loCircuit ) continue; // empty slot
-
-         AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
-
-         // skip copy cards
-         if( !localBoard->IsNotified()) 
-           continue;
-
-         TArrayS xyPattern[2];
-         
-         localStruct->GetXPattern(xyPattern[0]);
-         localStruct->GetYPattern(xyPattern[1]);
-
-         fDigitMaker->TriggerDigits(loCircuit, xyPattern, digitStore);
-
-         Int_t cathode = localStruct->GetComptXY()%2;
-
-         //Get electronic Decisions from data
-
-         //Get regional inputs -> not checked, hardware read-out doesn't work
-         fTriggerInputRegionalDataLPt[0][loCircuit]=Int_t(((regHeader->GetInput(0))>>(2*iLocal))&1);
-         fTriggerInputRegionalDataLPt[1][loCircuit]=Int_t(((regHeader->GetInput(1))>>((2*iLocal)+1))&1);
-         
-         //Get local in/outputs
-         if (Int_t(localStruct->GetDec())!=0){
-             fTriggerOutputLocalDataTriggerDec[loCircuit]++;
-         }
-         
-         fTriggerOutputLocalDataLPtDec[0][loCircuit]=((localStruct->GetLpt())&1);
-         fTriggerOutputLocalDataLPtDec[1][loCircuit]=((localStruct->GetLpt()>>1)&1);
-         fTriggerOutputLocalDataHPtDec[0][loCircuit]=((localStruct->GetHpt())&1);
-         fTriggerOutputLocalDataHPtDec[1][loCircuit]=((localStruct->GetHpt()>>1)&1);
-         fTriggerOutputLocalDataXPos[loCircuit]=Int_t(localStruct->GetXPos());
-         fTriggerOutputLocalDataYPos[loCircuit]=Int_t(localStruct->GetYPos());
-         fTriggerOutputLocalDataDev[loCircuit]=Int_t((localStruct->GetXDev())*(pow(-1.0,(localStruct->GetSXDev()))));
-         fTriggerOutputLocalDataTrigY[loCircuit]=Int_t(localStruct->GetTrigY());
-         
-         UShort_t x1  = (Int_t)localStruct->GetX1();
-         UShort_t x2  = (Int_t)localStruct->GetX2();
-         UShort_t x3  = (Int_t)localStruct->GetX3();
-         UShort_t x4  = (Int_t)localStruct->GetX4();
-
-         UShort_t y1  = (Int_t)localStruct->GetY1();
-         UShort_t y2  = (Int_t)localStruct->GetY2();
-         UShort_t y3  = (Int_t)localStruct->GetY3();
-         UShort_t y4  = (Int_t)localStruct->GetY4();
-
-         // loop over strips
-         for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
-
-             fTriggerPatternX1[loCircuit][ibitxy]=Int_t((x1>>ibitxy)&1);
-             fTriggerPatternX2[loCircuit][ibitxy]=Int_t((x2>>ibitxy)&1);
-             fTriggerPatternX3[loCircuit][ibitxy]=Int_t((x3>>ibitxy)&1);
-             fTriggerPatternX4[loCircuit][ibitxy]=Int_t((x4>>ibitxy)&1);
-             
-             fTriggerPatternY1[loCircuit][ibitxy]=Int_t((y1>>ibitxy)&1);
-             fTriggerPatternY2[loCircuit][ibitxy]=Int_t((y2>>ibitxy)&1);
-             fTriggerPatternY3[loCircuit][ibitxy]=Int_t((y3>>ibitxy)&1);
-             fTriggerPatternY4[loCircuit][ibitxy]=Int_t((y4>>ibitxy)&1);
-             
-             if (scalerEvent){
-                 if (ibitxy==0){
-                     AliDebug(AliQAv1::GetQADebugLevel(),"Filling trigger scalers");
-                 }
-                 
-                 if(localStruct->GetXY1(ibitxy) > 0)
-                     ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + 0))
-                         ->Fill(loCircuit, ibitxy, 2*localStruct->GetXY1(ibitxy));
-                 if(localStruct->GetXY2(ibitxy) > 0)
-                     ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + 1))
-                         ->Fill(loCircuit, ibitxy, 2*localStruct->GetXY2(ibitxy));
-                 if(localStruct->GetXY3(ibitxy) > 0)
-                     ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + 2))
-                         ->Fill(loCircuit, ibitxy, 2*localStruct->GetXY3(ibitxy));
-                 if(localStruct->GetXY4(ibitxy) > 0)
-                     ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + 3))
-                         ->Fill(loCircuit, ibitxy, 2*localStruct->GetXY4(ibitxy));
-             }
-         } // loop on strips
-       } // iLocal
-      } // iReg
-    } // NextDDL
-
-  fTriggerProcessor->Digits2Trigger(digitStore,triggerStore);
-
-  TIter next(triggerStore.CreateLocalIterator());
-  AliMUONLocalTrigger *localTrigger;
-
-  while ( ( localTrigger = static_cast<AliMUONLocalTrigger*>(next()) ) )
-  {
-    
-      //... extract information
-      loCircuit = localTrigger->LoCircuit();
-
-      AliMpLocalBoard* localBoardMp = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit);  // get local board objectfor switch value
-      if (localTrigger->GetLoDecision() != 0){
-         fTriggerOutputLocalRecTriggerDec[loCircuit]++;
-      }
-      
-      fTriggerOutputLocalRecLPtDec[0][loCircuit]=Int_t(localTrigger->LoLpt() & 1);
-      fTriggerOutputLocalRecLPtDec[1][loCircuit]=Int_t((localTrigger->LoLpt()>>1) & 1);
-      fTriggerOutputLocalRecHPtDec[0][loCircuit]=Int_t(localTrigger->LoHpt() & 1);
-      fTriggerOutputLocalRecHPtDec[1][loCircuit]=Int_t((localTrigger->LoHpt()>>1) & 1);
-      fTriggerOutputLocalRecXPos[loCircuit]=localTrigger->LoStripX();
-      fTriggerOutputLocalRecYPos[loCircuit]=localTrigger->LoStripY();
-      fTriggerOutputLocalRecTrigY[loCircuit]=localTrigger->LoTrigY();
-      fTriggerOutputLocalRecDev[loCircuit]=Int_t(localTrigger->LoDev()*(pow(-1.,localTrigger->LoSdev())));
-
-      Bool_t firstFillYCopy=kTRUE;
-
-      for (int bit=0; bit<16; bit++){
-         if (fTriggerPatternY1[loCircuit][bit]!=((localTrigger->GetY1Pattern()>>bit) & 1))
-         {
-             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
-             if (firstFillYCopy){
-                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
-                 ((TH1F*)GetRawsData(kTriggerError))->Fill(3);
-                 firstFillYCopy=kFALSE;
-             }
-         }
-         if (fTriggerPatternY2[loCircuit][bit]!=((localTrigger->GetY2Pattern()>>bit) & 1))
-         {
-             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
-             if (firstFillYCopy){
-                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
-                 ((TH1F*)GetRawsData(kTriggerError))->Fill(3);
-                 firstFillYCopy=kFALSE;
-             }
-         }
-         if (fTriggerPatternY3[loCircuit][bit]!=((localTrigger->GetY3Pattern()>>bit) & 1))
-         {
-             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
-             if (localBoardMp->GetSwitch(4)) fTriggerErrorLocalYCopy[loCircuit-1]=kTRUE;
-             if (localBoardMp->GetSwitch(3)) fTriggerErrorLocalYCopy[loCircuit+1]=kTRUE;
-             if (firstFillYCopy){
-                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
-                 ((TH1F*)GetRawsData(kTriggerError))->Fill(3);
-                 firstFillYCopy=kFALSE;
-             }
-         }
-         if (fTriggerPatternY4[loCircuit][bit]!=((localTrigger->GetY4Pattern()>>bit) & 1))
-         {
-             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
-             if (localBoardMp->GetSwitch(4)) fTriggerErrorLocalYCopy[loCircuit-1]=kTRUE;
-             if (localBoardMp->GetSwitch(3)) fTriggerErrorLocalYCopy[loCircuit+1]=kTRUE;
-             if (firstFillYCopy){
-                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
-                 ((TH1F*)GetRawsData(kTriggerError))->Fill(3);
-                 firstFillYCopy=kFALSE;
-             }
-         }
-      }
-  }
-
-    //Reconstruct Global decision from Global inputs
-    for (Int_t bit=0; bit<4; bit++){
-       for (Int_t i=0; i<32; i=i+4){
-           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>i)&1)*pow(2.0,i+1));
-           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+1))&1)*pow(2.0,i));
-           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+2))&1)*pow(2.0,i+2));
-           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+3))&1)*pow(2.0,i+3));
-           }
-    }
-    RawTriggerInGlobal2OutGlobal();
-    for (Int_t bit=0; bit<6; bit++){
-       fTriggerOutputGlobalRecFromGlobalInput[bit]=fgotmp[bit];
-    }
-
-    // Compare data and reconstructed decisions and fill histos
-    RawTriggerMatchOutLocal();
-    RawTriggerMatchOutLocalInRegional(); // Not tested, hardware read-out doesn't work
-    RawTriggerMatchOutGlobalFromInGlobal();
-}
-
-//__________________________________________________________________
-void AliMUONQADataMakerRec::MakeDigits(TTree* digitsTree)         
-{
-  /// makes data from Digits
-
-  // Do nothing in case of calibration event
-  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
-
-  if (!fDigitStore)
-    fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
-  fDigitStore->Connect(*digitsTree, false);
-  digitsTree->GetEvent(0);
-  
-  TIter next(fDigitStore->CreateIterator());
-  
-  AliMUONVDigit* dig = 0x0;
-  
-  while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
-    {
-    GetDigitsData(0)->Fill(dig->DetElemId());
-    GetDigitsData(1)->Fill(dig->ADC());
-    }
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRecPoints(TTree* clustersTree)
-{
-       /// Fill histograms from treeR
-
-  // Do nothing in case of calibration event
-  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
-       
-  GetRecPointsData(kNAnalyzedEvents)->Fill(1.);
-
-  MakeRecPointsTracker(clustersTree);
-       MakeRecPointsTrigger(clustersTree);
-}
-
-
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRecPointsTracker(TTree* clustersTree)
-{
-       /// Fill histograms related to tracker clusters 
-       
-       // First things first : do we have clusters in the TreeR ?
-       // In "normal" production mode, it should be perfectly normal
-       // *not* to have them.
-       // But if for some reason we de-activated the combined tracking,
-       // then we have clusters in TreeR, so let's take that opportunity
-       // to QA them...
-       
-  AliCodeTimerAuto("",0);
-
-  // Do nothing in case of calibration event
-  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
-
-       if (!fClusterStore)
-       {
-         AliCodeTimerAuto("ClusterStore creation",1);
-               fClusterStore = AliMUONVClusterStore::Create(*clustersTree);
-               if (!fClusterStore) 
-               {
-                       return;
-               }
-       }
-       
-       fClusterStore->Connect(*clustersTree,kFALSE);
-       clustersTree->GetEvent(0);
-
-       TIter next(fClusterStore->CreateIterator());
-       AliMUONVCluster* cluster;
-       
-  if ( fMappingCheckRecPoints ) fMappingCheckRecPoints->NewEvent();
-  
-       while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) )
-       {
-               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());
-               
-    if ( fMappingCheckRecPoints ) fMappingCheckRecPoints->Store(*cluster);
-    
-       }
-       
-       fClusterStore->Clear();
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeRecPointsTrigger(TTree* clustersTree)
-{
-       /// makes data from trigger response
-
-  AliCodeTimerAuto("",0);
-
-    // Fired pads info
-    fDigitStore->Clear();
-
-    AliMUONVTriggerStore *triggerStore = AliMUONVTriggerStore::Create(*clustersTree);
-    triggerStore->Clear();
-    triggerStore->Connect(*clustersTree, false);
-    clustersTree->GetEvent(0);
-
-    AliMUONLocalTrigger* locTrg;
-    TIter nextLoc(triggerStore->CreateLocalIterator());
-
-    while ( ( locTrg = static_cast<AliMUONLocalTrigger*>(nextLoc()) ) ) 
-    {
-      if (locTrg->IsNull()) continue;
-   
-      TArrayS xyPattern[2];
-      locTrg->GetXPattern(xyPattern[0]);
-      locTrg->GetYPattern(xyPattern[1]);
-
-      Int_t nBoard = locTrg->LoCircuit();
-
-      Bool_t xTrig=locTrg->IsTrigX();
-      Bool_t yTrig=locTrg->IsTrigY();
-    
-      if (xTrig && yTrig)
-       ((TH1F*)GetRecPointsData(kTriggeredBoards))->Fill(nBoard);
-
-      fDigitMaker->TriggerDigits(nBoard, xyPattern, *fDigitStore);
-    }
-
-    TIter nextDigit(fDigitStore->CreateIterator());
-    AliMUONVDigit* mDigit;
-    while ( ( mDigit = static_cast<AliMUONVDigit*>(nextDigit()) ) )
-    {
-      Int_t detElemId = mDigit->DetElemId();
-      Int_t ch = detElemId/100;
-      Int_t localBoard = mDigit->ManuId();
-      Int_t channel = mDigit->ManuChannel();
-      Int_t cathode = mDigit->Cathode();
-      Int_t iChamber = ch - 11;
-      
-      ((TH2F*)GetRecPointsData(kTriggerDigits + AliMpConstants::NofTriggerChambers()*cathode + iChamber))
-       ->Fill(localBoard, channel);
-    }
-
-    delete triggerStore;
-}
-
-//____________________________________________________________________________
-void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd)
-{
-  /// make QA data from ESDs
-
-  AliCodeTimerAuto("",0);
-  
-  // Do nothing in case of calibration event
-  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
-  
-  // load ESD event in the interface
-  AliMUONESDInterface esdInterface;
-  if (GetMUONRecoParam()) AliMUONESDInterface::ResetTracker(GetMUONRecoParam());
-  else AliError("Unable to get recoParam: use default ones for residual calculation");
-  esdInterface.LoadEvent(*esd);
-  
-  GetESDsData(kESDnTracks)->Fill(esdInterface.GetNTracks());
-  
-  Int_t nTrackMatchTrig = 0;
-  
-  // loop over tracks
-  Int_t nTracks = (Int_t) esd->GetNumberOfMuonTracks(); 
-  for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) {
-    
-    // get the ESD track and skip "ghosts"
-    AliESDMuonTrack* esdTrack = esd->GetMuonTrack(iTrack);
-    if (!esdTrack->ContainTrackerData()) continue;
-    
-    // get corresponding MUON track
-    AliMUONTrack* track = esdInterface.FindTrack(esdTrack->GetUniqueID());
-    
-    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());
-    
-    // loop over clusters
-    AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
-    while (trackParam) {
-      
-      AliMUONVCluster* cluster = trackParam->GetClusterPtr();
-      Int_t chId = cluster->GetChamberId();
-      Int_t deID = cluster->GetDetElemId();
-      Double_t residualX = cluster->GetX() - trackParam->GetNonBendingCoor();
-      Double_t residualY = cluster->GetY() - trackParam->GetBendingCoor();
-      Double_t sigmaResidualX2 = cluster->GetErrX2() - trackParam->GetCovariances()(0,0);
-      Double_t sigmaResidualY2 = cluster->GetErrY2() - trackParam->GetCovariances()(2,2);
-      Double_t localChi2X = (sigmaResidualX2 > 0.) ? residualX*residualX/sigmaResidualX2 : 0.;
-      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(kESDnTotClustersPerCh)->Fill(chId);
-      GetESDsData(kESDnTotClustersPerDE)->Fill(deID);
-      
-      GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
-      GetESDsData(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(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(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);
-      
-      trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
-      
-    }
-    
-  }
-
-  GetESDsData(kESDMatchTrig)->Fill(nTrackMatchTrig);
-  
-}
+ }
 
 //____________________________________________________________________________ 
 void AliMUONQADataMakerRec::StartOfDetectorCycle()
 {
-    /// Detector specific actions at start of cycle
-  
-}
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQAv1::TASKINDEX_t task)
-{
-  //
-  /// Display trigger information in a user-friendly way:
-  /// from local board and strip numbers to their position on chambers
-  //
-  
-
-  if(task!=AliQAv1::kRECPOINTS && task!=AliQAv1::kRAWS) return;
-
-  // check we get histograms, otherwise return right now
-  if ( task == AliQAv1::kRECPOINTS )
-  {
-    if ( !GetRecPointsData(kTriggerDigits) ) return;
-  }
-  
-  if ( task == AliQAv1::kRAWS ) 
-  {
-    if ( !GetRawsData(kTriggerScalers) ) return;
-  }
-  
-  AliMUONTriggerDisplay triggerDisplay;
-  
-  TH2F* histoStrips=0x0;
-  TH2F* histoDisplayStrips=0x0;
-  AliMUONTriggerDisplay::EDisplayOption displayOption = AliMUONTriggerDisplay::kDefaultDisplay;
-  if(task == AliQAv1::kRAWS) displayOption = AliMUONTriggerDisplay::kNormalizeToArea;
-
-  for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
-  {    
-    for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
-    {
-      if(task==AliQAv1::kRECPOINTS){
-       histoStrips = (TH2F*)GetRecPointsData(kTriggerDigits + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
-      }
-      else if(task==AliQAv1::kRAWS){
-       histoStrips = (TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
-      }
-
-      if(histoStrips->GetEntries()==0) continue; // No events found => No need to display
-
-      if(task==AliQAv1::kRECPOINTS){
-       histoDisplayStrips = (TH2F*)GetRecPointsData(kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
-      }
-      else if(task==AliQAv1::kRAWS){
-       histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
-      }
-
-      triggerDisplay.FillDisplayHistogram(histoStrips, histoDisplayStrips,
-                                         AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, displayOption);
-
-      Float_t scaleValue = 0.;
-      if(task==AliQAv1::kRAWS) {
-        scaleValue = ((TH1F*)GetRawsData(kTriggerScalersTime))->GetBinContent(1);
-      }
-      else if ( task == AliQAv1::kRECPOINTS ) {
-       scaleValue = GetRecPointsData(kNAnalyzedEvents)->GetBinContent(1);
-      }
-      if(scaleValue>0.) histoDisplayStrips->Scale(1./scaleValue);
-    } // iChamber
-  } // iCath
-
-  if(task==AliQAv1::kRECPOINTS){
-    TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards);
-    TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay);
-    triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
-    Float_t scaleValue = GetRecPointsData(kNAnalyzedEvents)->GetBinContent(1);
-    if(scaleValue>0.) histoDisplayBoards->Scale(1./scaleValue);
-  }
-}
-
-
-//_____________________________________________________________________________
-Bool_t 
-AliMUONQADataMakerRec::FillTriggerDCSHistos()
-{
-  /// Get HV and currents values for one trigger chamber
-  
-  AliCodeTimerAuto("",0);
-
-  TMap* triggerDcsMap = fCalibrationData->TriggerDCS();
-
-  if ( !triggerDcsMap ) 
-  {
-    AliError("Cannot fill DCS histos, as triggerDcsMap is NULL");
-    return kFALSE;
-  }
-
-  AliMpDEIterator deIt;
-  
-  deIt.First();
-    
-  AliMpDCSNamer triggerDcsNamer("TRIGGER");
-
-  TH2* currHisto = 0x0;
-  Int_t histoIndex = 0;
-  TString histoName, histoTitle;
-
-  Bool_t error = kFALSE;
-  Bool_t expert   = kTRUE;
-  Bool_t saveCorr = kTRUE;
-  Bool_t image    = kTRUE;
-  
-  while ( !deIt.IsDone() )
-  {
-    Int_t detElemId = deIt.CurrentDEId();
-    
-    if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStationTrigger) {
-
-      Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
-      Int_t slat = detElemId%100;
-
-      for(Int_t iMeas=0; iMeas<AliMpDCSNamer::kNDCSMeas; iMeas++){
-       TString currAlias = triggerDcsNamer.DCSChannelName(detElemId, 0, iMeas);
-
-        AliDebug(AliQAv1::GetQADebugLevel(), Form("\nDetElemId %i   dcsAlias %s", detElemId, currAlias.Data()));
-
-       TPair* triggerDcsPair = static_cast<TPair*>(triggerDcsMap->FindObject(currAlias.Data()));
-
-       if (!triggerDcsPair)
-       {
-         AliError(Form("Did not find expected alias (%s) for DE %d",
-                       currAlias.Data(),detElemId));  
-         error = kTRUE;
-       }
-       else
-       {
-         TObjArray* values = static_cast<TObjArray*>(triggerDcsPair->Value());
-         if (!values)
-         {
-           AliError(Form("Could not get values for alias %s",currAlias.Data()));
-           error = kTRUE;
-         }
-         else
-         {
-           TIter next(values);
-           AliDCSValue* val = 0x0;
-
-           Int_t ich = iChamber - AliMpConstants::NofTrackingChambers();
-
-           switch(iMeas){
-           case AliMpDCSNamer::kDCSI:
-             histoIndex = kTriggerRPCi + ich;
-             histoName = Form("hRPCIChamber%i", 11+ich);
-             histoTitle = Form("Chamber %i: RPC Currents (#muA)", 11+ich);
-             break;
-           case AliMpDCSNamer::kDCSHV:
-             histoIndex = kTriggerRPChv + ich;
-             histoName = Form("hRPCHVChamber%i", 11+ich);
-             histoTitle = Form("Chamber %i: RPC HV (V)", 11+ich);
-             break;
-           }
-
-           currHisto = (TH2F*) GetRawsData(histoIndex);
-
-           if(!currHisto){
-             Int_t npoints = values->GetEntries();
-             TArrayF axisSlat(18+1), axisTime(npoints+1);
-             for(Int_t islat=0; islat<=18; islat++){
-               axisSlat[islat] = -0.5 + (Float_t)islat;
-             }
-             for(Int_t ientry=0; ientry<npoints; ientry++){
-               val = static_cast<AliDCSValue*>(values->At(ientry));
-               axisTime[ientry] = val->GetTimeStamp();
-             }
-             axisTime[npoints] = val->GetTimeStamp() + 100;
-
-             currHisto  = new TH2F(histoName.Data(), histoTitle.Data(),
-                                   npoints, axisTime.GetArray(),
-                                   18, axisSlat.GetArray());
-             currHisto->GetXaxis()->SetTitle("Time");
-             currHisto->GetXaxis()->SetTimeDisplay(1);
-             //currHisto->GetXaxis()->SetTimeFormat("%d%b%y %H:%M:%S");
-             currHisto->GetYaxis()->SetTitle("RPC");
-             currHisto->SetOption("COLZ");
-             Add2RawsList(currHisto, histoIndex, !expert, image, !saveCorr);
-           }
-
-           while ( ( val = static_cast<AliDCSValue*>(next()) ) )
-           {
-             Float_t hvi = val->GetFloat();
-
-             AliDebug(AliQAv1::GetQADebugLevel(), Form("Value %f", hvi));
-             currHisto->Fill(1.0001 * val->GetTimeStamp(), slat, hvi);
-           } // loop on values
-         } // if (!values)
-       } // if (!triggerDcsPair)
-      } // loop on measured types (HV and currents)
-    } // if (stationType == kStationTrigger)
-
-    deIt.Next();
-  }
-  return error;
-}
-
-//____________________________________________________________________________ 
-AliMUONVTrackerData* AliMUONQADataMakerRec::GetTrackerData() const
-{ 
-/// Return tracker data
-  
-  return fTrackerDataMaker->Data(); 
-  
-}
-
-//____________________________________________________________________________ 
-void
-AliMUONQADataMakerRec::BeautifyTrackerBusPatchOccupancy(TH1& hbp)
-{
-  /// Put labels, limits and so on on the TrackerBusPatchOccupancy histogram
-  
-  hbp.SetXTitle("Absolute Bus Patch Id");
-  hbp.SetYTitle("Occupancy (percent)");
-  hbp.SetStats(kFALSE);
-  
-  Double_t xmin = hbp.GetXaxis()->GetXmin();
-  Double_t xmax = hbp.GetXaxis()->GetXmax();
-  
-  Double_t occMax(0.1); // 0.1% y-limit for the plot
-  Double_t occError(1.0); // 1.0% y-limit to count the "errors"
-  
-  TLine* line = new TLine(xmin,occError,xmax,occError);
-  line->SetLineColor(2);
-  line->SetLineWidth(3);
-  
-  hbp.GetListOfFunctions()->Add(line);
-  
-  TH1* hnpads = GetRawsData(kTrackerBusPatchNofPads);
-  hnpads->SetStats(kFALSE);
-  TH1* hnmanus = GetRawsData(kTrackerBusPatchNofManus);
-  hnmanus->SetStats(kFALSE);
-  
-  TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
-  AliMpBusPatch* bp(0x0);
-  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
-  {
-    Int_t n(0);
-    for ( Int_t imanu = 0; imanu < bp->GetNofManus(); ++imanu )
-    {
-      Int_t manuId = bp->GetManuId(imanu);
-      AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(bp->GetDEId());      
-      n += de->NofChannelsInManu(manuId);
-    }
-    hnpads->Fill(bp->GetId(),n*1.0);
-    hnmanus->Fill(bp->GetId(),bp->GetNofManus()*1.0);
-  }
-  
-  next.Reset();
-  
-  Int_t nMissingPads(0);
-  Int_t nPads(0);
-  Int_t nBusPatches(0);
-  Int_t nMissingBusPatches(0);
-
-  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
-  {
-    Int_t bin = hbp.FindBin(bp->GetId());
-    Int_t n = hnpads->GetBinContent(bin);
-    
-    ++nBusPatches;
-
-    nPads += n;
-    
-    if ( hbp.GetBinContent(bin) <= 0 ) 
-    {
-      nMissingPads += n;
-      ++nMissingBusPatches;
-    }
-  }
-
-  next.Reset();
-  
-  Int_t ok(-1);
-  Int_t n(0);
-  Int_t nBusPatchesAboveLimit(0);
-  Double_t alpha(0.1); // trim 10% of data
-  Double_t tmean(0.0),tvar(0.0);
-  Double_t ymin(0.0),ymax(0.0);
-  
-  
-  if ( nBusPatches ) 
-  {
-    Double_t* x = new Double_t[nBusPatches];
-  
-    while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
-    {
-      Int_t bin = hbp.FindBin(bp->GetId());
-      if ( hbp.GetBinContent(bin) > 0 )
-      {
-        x[n] = hbp.GetBinContent(bin);
-        ++n;
-      }
-      if ( hbp.GetBinContent(bin) > occError )
-      {
-        ++nBusPatchesAboveLimit;
-      }
-    }
-  
-    // computed the truncated mean of the occupancy values, in order to get a 
-    // reasonable y-range for the histogram (without giant peaks to the roof 
-    // for misbehaving buspatches).
-    ok = trim(n,x,alpha,tmean,tvar,ymin,ymax);
-    
-    delete[] x;
-  }
-  
-  if ( ok < 0 ) 
-  {
-    ymax = occMax;
-  }
-  else
-  {
-    ymax = TMath::Max(ymax,occMax);
-  }
-  
-  hbp.SetMaximum(ymax*1.4);
-  
-  TPaveText* text = new TPaveText(0.55,0.85,0.99,0.99,"NDC");
-  
-  if (ok < 0 ) 
-  {
-    text->AddText("Could not compute truncated mean. Not enough events ?");
-    text->SetFillColor(2);
-  }
-  else if (!nPads || !nBusPatches)
-  {
-    text->AddText("Could not get the total number of pads. ERROR !!!");
-    text->SetFillColor(2);
-  }
-  else
-  {
-    Float_t missingPadFraction = nMissingPads*100.0/nPads;
-    Float_t missingBusPatchFraction = nMissingBusPatches*100.0/nBusPatches;
-    Float_t aboveLimitFraction = nBusPatchesAboveLimit*100.0/nBusPatches;
-    
-    text->AddText(Form("%5.2f %% of missing buspatches (%d out of %d)",missingBusPatchFraction,nMissingBusPatches,nBusPatches));
-    text->AddText(Form("%5.2f %% of missing pads (%d out of %d)",missingPadFraction,nMissingPads,nPads));
-    text->AddText(Form("%5.2f %% bus patches above the %5.2f %% limit",aboveLimitFraction,occError));
-    text->AddText(Form("Truncated mean at %2d %% is %7.2f %%",(Int_t)(alpha*100),tmean));
-    
-    if ( missingPadFraction > 10.0 || aboveLimitFraction > 5.0 ) 
-    {
-      text->SetFillColor(2);
-    }
-    else
-    {
-      text->SetFillColor(3);
-    }
-  }
-  
-  hbp.GetListOfFunctions()->Add(text);
-}
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::RawTriggerInGlobal2OutGlobal()
-{
-  //
-  /// Reconstruct Global Trigger decision using Global Inputs
-  //
-
-    AliMUONGlobalCrateConfig* globalConfig = fCalibrationData->GlobalTriggerCrateConfig();
-
-    AliMUONGlobalTriggerBoard globalTriggerBoard;
-    globalTriggerBoard.Reset();
-    for (Int_t i = 0; i < 4; i++) {
-       globalTriggerBoard.Mask(i,globalConfig->GetGlobalMask(i));
-    }
-
-
-    UShort_t regional[16];
-
-    for (Int_t iReg = 0; iReg < 16; iReg++) {
-      regional[iReg] = 0;
-      if (iReg < 8) {    // right
-       // Lpt
-       regional[iReg] |=  (fgitmp[0] >> (4*iReg))     & 0xF;
-       // Hpt
-       regional[iReg] |= ((fgitmp[2] >> (4*iReg))     & 0xF) << 4;
-      } else {           // left
-       // Lpt
-       regional[iReg] |=  (fgitmp[1] >> (4*(iReg-8))) & 0xF;
-       // Hpt
-       regional[iReg] |= ((fgitmp[3] >> (4*(iReg-8))) & 0xF) << 4;
-      }
-    }
-    globalTriggerBoard.SetRegionalResponse(regional);
-    globalTriggerBoard.Response();
-
-    for (Int_t bit=1; bit<7; bit++){
-       fgotmp[bit-1]=Int_t((globalTriggerBoard.GetResponse())>>bit&1);
-    }
-}
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::RawTriggerMatchOutLocal()
-{
-  //
-  /// Match data and reconstructed Local Trigger decision
-  //
-
-    Bool_t firstFillXPosDev=kTRUE;
-    Bool_t firstFillYPosTrigY=kTRUE;
-    Bool_t firstFillLUT=kTRUE;
-
-    for (int localId=1;localId<235;localId++){
-       if(fTriggerOutputLocalDataTriggerDec[localId]!=fTriggerOutputLocalRecTriggerDec[localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalTriggerDec))->Fill(localId);
-       }
-       if(fTriggerOutputLocalDataTrigY[localId]!=fTriggerOutputLocalRecTrigY[localId]){
-           if(fTriggerErrorLocalYCopy[localId]) continue;
-           ((TH1F*)GetRawsData(kTriggerErrorLocalTrigY))->Fill(localId);
-            if (firstFillYPosTrigY){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(1);
-                firstFillYPosTrigY=kFALSE;
-            }
-       }
-
-       if(fTriggerOutputLocalDataYPos[localId]!=fTriggerOutputLocalRecYPos[localId]){
-           if(fTriggerErrorLocalYCopy[localId]) continue;
-           ((TH1F*)GetRawsData(kTriggerErrorLocalYPos))->Fill(localId);
-           if (firstFillYPosTrigY){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(1);
-                firstFillYPosTrigY=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataXPos[localId]!=fTriggerOutputLocalRecXPos[localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalXPos))->Fill(localId);
-            if (firstFillXPosDev){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(0);
-                firstFillXPosDev=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataDev[localId]!=fTriggerOutputLocalRecDev[localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalDev))->Fill(localId);
-            if (firstFillXPosDev){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(0);
-                firstFillXPosDev=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataLPtDec[0][localId]!=fTriggerOutputLocalRecLPtDec[0][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalLPtLSB))->Fill(localId);
-            if (firstFillLUT){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(2);
-                firstFillLUT=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataLPtDec[1][localId]!=fTriggerOutputLocalRecLPtDec[1][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalLPtMSB))->Fill(localId);
-            if (firstFillLUT){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(2);
-                firstFillLUT=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataHPtDec[0][localId]!=fTriggerOutputLocalRecHPtDec[0][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalHPtLSB))->Fill(localId);
-            if (firstFillLUT){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(2);
-                firstFillLUT=kFALSE;
-            }
-       }
-       if(fTriggerOutputLocalDataHPtDec[1][localId]!=fTriggerOutputLocalRecHPtDec[1][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocalHPtMSB))->Fill(localId);
-            if (firstFillLUT){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(2);
-                firstFillLUT=kFALSE;
-            }
-       }
-    } // loop over Local Boards
-}
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::RawTriggerMatchOutLocalInRegional()
-{
-  //
-  /// Match Local outputs and Regional inputs
-  /// Not tested, hardware read-out doesn't work
-  //
-
-    for (int localId=1;localId<235;localId++){
-       if(fTriggerOutputLocalDataLPtDec[0][localId]!=fTriggerInputRegionalDataLPt[0][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalLPtLSB))->Fill(localId);
-       }
-       if(fTriggerOutputLocalDataLPtDec[1][localId]!=fTriggerInputRegionalDataLPt[1][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalLPtMSB))->Fill(localId);
-       }
-       if(fTriggerOutputLocalDataHPtDec[0][localId]!=fTriggerInputRegionalDataHPt[0][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalHPtLSB))->Fill(localId);
-       }
-       if(fTriggerOutputLocalDataHPtDec[1][localId]!=fTriggerInputRegionalDataHPt[1][localId]){
-           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalHPtMSB))->Fill(localId);
-       }
-    }
-
-}
-
-//____________________________________________________________________________ 
-void AliMUONQADataMakerRec::RawTriggerMatchOutGlobalFromInGlobal()
-{
-  //
-  /// Match data and reconstructed Global Trigger decision for a reconstruction from Global inputs
-  //
-
-    Bool_t firstFill=kTRUE;
-
-    for (int bit=0;bit<6;bit++){
-        if(fTriggerOutputGlobalData[bit]!=fTriggerOutputGlobalRecFromGlobalInput[bit]){
-            ((TH1F*)GetRawsData(kTriggerErrorOutGlobalFromInGlobal))->Fill(5-bit);
-            if (firstFill){
-                ((TH1F*)GetRawsData(kTriggerError))->Fill(7);
-                firstFill=kFALSE;
-            }
-        }
-    } 
+    /// Detector specific actions at start of cycle  
 }
-
-
-
-
-
index 48e25c1..23ef2a1 100644 (file)
 
 // --- AliRoot header files ---
 #include "AliQADataMakerRec.h"
-#include "AliMUONRecoParam.h"
 
-class AliMUONDigitMaker;
-class AliMUONVClusterStore;
-class AliMUONVDigitStore;
-class AliMUONVStore;
-class AliMUONVTrackerData;
-class AliMUONVTrackerDataMaker;
-class AliMUONCalibrationData;
-class AliMUONTriggerElectronics;
-
-class AliMUONQAMappingCheck;
+class AliMUONVQADataMakerRec;
 
 class AliMUONQADataMakerRec: public AliQADataMakerRec {
 
 public:
-  AliMUONQADataMakerRec();         
-  AliMUONQADataMakerRec(const AliMUONQADataMakerRec& qadm);   
-  AliMUONQADataMakerRec& operator=(const AliMUONQADataMakerRec& qadm);
+  AliMUONQADataMakerRec(Bool_t tracker=kTRUE, Bool_t trigger=kTRUE);         
   virtual ~AliMUONQADataMakerRec();
-  
-  AliMUONVTrackerData* GetTrackerData() const;
 
+  AliMUONVQADataMakerRec* Tracker() const { return fTracker; }
+  AliMUONVQADataMakerRec* Trigger() const { return fTrigger; }
+  
+  virtual void InitDigits(); 
+  virtual void InitESDs(); 
   virtual void InitRaws(); 
   virtual void InitRecPoints(); 
 
-protected:
-       
   virtual void StartOfDetectorCycle(); 
-
-  virtual void InitDigits(); 
-  virtual void InitESDs(); 
   
-  virtual void MakeRaws(AliRawReader* rawReader); 
+  void MakeDigits();
+  
   virtual void MakeDigits(TTree* dig); 
-  virtual void MakeDigits()  {return;}
-  virtual void MakeRecPoints(TTree* recpo); 
   virtual void MakeESDs(AliESDEvent* esd) ;
+  virtual void MakeRaws(AliRawReader* rawReader); 
+  virtual void MakeRecPoints(TTree* recpo); 
   
-  virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t) {}
-
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list);
 
 private:
-  /// 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
-    kTriggerScalers           = 22, ///< Trigger scalers histogram per plane index
-    kTriggerScalersDisplay    = 30, ///< Trigger scalers display histogram per plane index
-    kTriggerScalersTime       = 38, ///< Trigger scalers acquisition time index
-    kTriggerRPCi              = 39, ///< Trigger chamber currents index
-    kTriggerRPChv             = 43,  ///< Trigger chamber HV index
-    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
-    kTriggerErrorLocal2RegionalLPtLSB = 58,  ///< Local to Regional: Number of LPt LSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalLPtMSB = 59,  ///< Local to Regional: Number of LPt MSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalHPtLSB = 60,  ///< Local to Regional: Number of HPt LSB error vs Local Board Id
-    kTriggerErrorLocal2RegionalHPtMSB = 61,  ///< Local to Regional: Number of HPt MSB error vs Local Board Id
-    kTriggerErrorOutGlobalFromInGlobal = 62,  ///< Global board: Number of error vs output bit 
-    kTriggerError = 63,  ///< percentage of error for each trigger decision level (Local, Reg->Local, Reg, Reg->Glob, Global)
-    kTriggerErrorLocalTrigY = 64,  ///< Local board: Number of TrigY Error vs Local Board Id
-    kTriggerErrorLocalYCopy = 65,  ///< Local board: Number of Y Copy Error vs Local Board Id
-
-    kRawNAnalyzedEvents = 66 ///< Number of analyzed events per event specie
-  };
-         
-  /// Rec points histograms indices
-  enum ERecPoints { 
-    kTriggerDigits             = 0,  ///< Trigger digits histogram per plane index
-    kTriggeredBoards           = 8,  ///< Triggered boards histogram index
-    kTriggerDigitsDisplay      = 9,  ///< Trigger digits display histogram per plane index
-    kTriggerBoardsDisplay      = 17, ///< Triggered boards display histogram index
-
-    kNAnalyzedEvents           = 90, ///< Number of analyzed events per event specie
-    
-    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 BeautifyTrackerBusPatchOccupancy(TH1& hbp);
-  
-  void EndOfDetectorCycleRaws(Int_t specie, TObjArray** list);
-  void EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list);
-  void EndOfDetectorCycleESDs();
-  void InsertTrackerData(Int_t specie, TObjArray** list, TObject* object, 
-                         Int_t indexNumber, Bool_t replace=kFALSE);
-
-private:
-       
-  void Ctor();
-  void DisplayTriggerInfo(AliQAv1::TASKINDEX_t task);
-  Bool_t FillTriggerDCSHistos();
-  void InitRecPointsTracker();
-  void InitRecPointsTrigger();
-  void MakeRawsTracker(AliRawReader* rawReader);
-  void MakeRawsTrigger(AliRawReader* rawReader);
-  void MakeRecPointsTracker(TTree* treeR);
-  void MakeRecPointsTrigger(TTree* treeR);
-  void RawTriggerInRegional2OutRegional();
-  void RawTriggerInGlobal2OutGlobal();
-  void RawTriggerMatchOutLocal();
-  void RawTriggerMatchOutLocalInRegional();
-  void RawTriggerMatchOutGlobalFromInGlobal();
-       
-  /// Return reco parameters
-  const AliMUONRecoParam* GetMUONRecoParam() const { return dynamic_cast<const AliMUONRecoParam *>(fRecoParam); }
-  
-  Int_t fTriggerOutputLocalDataTriggerDec[235]; ///< Data Local Trigger decision for each active Local Board
-  Int_t fTriggerOutputLocalDataTrigY[235]; ///< Data Local Trigger Y decision for each active Local Board
-  Int_t fTriggerOutputLocalDataLPtDec[2][235]; ///< Data Local decision Low Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
-  Int_t fTriggerOutputLocalDataHPtDec[2][235]; ///< Data Local decision High Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
-  Int_t fTriggerOutputLocalDataXPos[235]; ///< Data Local XPos for each active Local Board
-  Int_t fTriggerOutputLocalDataYPos[235]; ///< Data Local YPos for each active Local Board
-  Int_t fTriggerOutputLocalDataDev[235]; ///< Data Local deviation for each active Local Board
-
-  Int_t fTriggerOutputLocalRecTriggerDec[235]; ///< Reconstructed Local Trigger decision for each active Local Board
-  Int_t fTriggerOutputLocalRecTrigY[235]; ///< Reconstructed Local Trigger Y decision for each active Local Board
-  Int_t fTriggerOutputLocalRecLPtDec[2][235]; ///< Reconstructed Local decision Low Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
-  Int_t fTriggerOutputLocalRecHPtDec[2][235]; ///< Reconstructed Local decision High Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
-  Int_t fTriggerOutputLocalRecXPos[235]; ///< Reconstructed Local XPos for each active Local Board
-  Int_t fTriggerOutputLocalRecYPos[235]; ///< Reconstructed Local YPos for each active Local Board
-  Int_t fTriggerOutputLocalRecDev[235]; ///< Reconstructed Local deviation for each active Local Board
-
-  Int_t fTriggerInputRegionalDataLPt[2][235]; ///< Data Regional Input LPt for each Local board
-  Int_t fTriggerInputRegionalDataHPt[2][235]; ///< Data Regional Input HPt for each Local board
-  Int_t fTriggerOutputRegionalData[16]; ///< Data Regional Trigger decision for each Regional Board (1R:0, 2R:1, ... , 1L:8, ...) -> 4 bits LPt, 4 bits HPt
-  Int_t fTriggerInputRegionalRecLPt[2][16][16]; ///< Reconstructed Regional Input LPt for each Regional Board ([bit][reg][loc]) (reg -> 1R:0, 2R:1, ... , 1L:8, ...)
-  Int_t fTriggerInputRegionalRecHPt[2][16][16]; ///< Reconstructed Regional Input HPt for each Regional Board ([bit][reg][loc]) (reg -> 1R:0, 2R:1, ... , 1L:8, ...)
-  Int_t fTriggerOutputRegionalRec[16]; ///< Reconstructed Regional Trigger decision for each Regional Board (8 Bits)
-
-  Int_t fTriggerInputGlobalDataLPt[16][4]; ///< Data Global inputs LPt (1R:0, 2R:1, ... , 1L:8, ...)
-  Int_t fTriggerInputGlobalDataHPt[16][4]; ///< Data Global inputs HPt (1R:0, 2R:1, ... , 1L:8, ...)
-  Int_t fTriggerOutputGlobalData[6]; ///< Data Global outputs
-  Int_t fTriggerOutputGlobalRecFromGlobalInput[6]; //< Reconstructed Global outputs from Global inputs
-  Int_t fTriggerOutputGlobalRecFromLocalInput[6]; //< Reconstructed Global outputs from Local inputs
-  Int_t fTriggerOutputGlobalRecFromLocalOutput[6]; //< Reconstructed Global outputs from Local outputs
-  Int_t fgitmp[4]; //< Tempory used to store Global inputs
-  Int_t fgotmp[6]; //< Tempory used to store Global outputs
-
-  Int_t fTriggerPatternX1[243][16]; ///< Local pattern X1
-  Int_t fTriggerPatternX2[243][16]; ///< Local pattern X2
-  Int_t fTriggerPatternX3[243][16]; ///< Local pattern X3
-  Int_t fTriggerPatternX4[243][16]; ///< Local pattern X4
-  Int_t fTriggerPatternY1[243][16]; ///< Local pattern Y1
-  Int_t fTriggerPatternY2[243][16]; ///< Local pattern Y2
-  Int_t fTriggerPatternY3[243][16]; ///< Local pattern Y3
-  Int_t fTriggerPatternY4[243][16]; ///< Local pattern Y4
-
-  Bool_t fTriggerErrorLocalYCopy[235]; ///< True if Y copy error for Local Board i
   
-  AliMUONVDigitStore*   fDigitStore; //!< pointer to digits store
-  AliMUONDigitMaker*    fDigitMaker;  //!< pointer to digit maker
-  AliMUONVClusterStore* fClusterStore; //!< pointer to cluster store
-       
-  AliMUONVTrackerDataMaker* fTrackerDataMaker; //!< tracker data accumulation (Raw)
-  
-  AliMUONQAMappingCheck* fMappingCheckRecPoints; //!< mapping cross-checker (RecPoints)
-  
-  AliMUONCalibrationData* fCalibrationData; //!< Used to load Local, Regional and Global masks
+  AliMUONQADataMakerRec(const AliMUONQADataMakerRec& qadm);   
+  AliMUONQADataMakerRec& operator=(const AliMUONQADataMakerRec& qadm);
 
-  AliMUONTriggerElectronics* fTriggerProcessor; //!< trigger processore to re-compute response
+  AliMUONVQADataMakerRec* fTracker; ///< tracker sub-qadatamaker
+  AliMUONVQADataMakerRec* fTrigger; ///< trigger sub-qadatamaker
   
-  ClassDef(AliMUONQADataMakerRec,9)  // MUON Quality assurance data maker
+  ClassDef(AliMUONQADataMakerRec,10)  // MUON Quality assurance data maker
 
 };
 #endif
index a6f88bb..5780d4f 100644 (file)
@@ -72,7 +72,9 @@ AliMUONRecoParam::AliMUONRecoParam()
   fRemoveConnectedTracksInSt12(kFALSE),
   fMaxTriggerTracks(0),
   fMaxTrackCandidates(0),
-  fSelectTrackOnSlope(kFALSE)
+  fSelectTrackOnSlope(kFALSE),
+  fMissingPadFractionLimit(0),
+  fFractionOfBuspatchOutsideOccupancyLimit(0)
 {
   /// Constructor
   
@@ -202,8 +204,7 @@ void AliMUONRecoParam::SetLowFluxParam()
   for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
   fBypassSt45 = 0;
   fMaxTriggerTracks = 100;
-  fMaxTrackCandidates = 10000;
-  
+  fMaxTrackCandidates = 10000;  
 }
 
 //_____________________________________________________________________________
@@ -298,7 +299,10 @@ void AliMUONRecoParam::SetCosmicParam()
   fMaxTrackCandidates = 10000;
   SetPedMeanLimits(20, 700);
   SetManuOccupancyLimits(-1.,0.01); // reject manu above occ=1%
-  
+
+  SetBuspatchOccupancyLimits(-1,0.01);  
+  SetMissingPadFractionLimit(0.1); // 10 %   
+  SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %   
 }
 
 
@@ -483,9 +487,13 @@ void AliMUONRecoParam::Print(Option_t *option) const
   
   cout << "Occupancy limits are :" << endl;
   
-  cout << Form("%7.2f <= Manu occupancy < %7.2f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl;
-  cout << Form("%7.2f <= Buspatch occupancy < %7.2f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl;
-  cout << Form("%7.2f <= DE occupancy < %7.2f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl;
+  cout << Form("%e <= Manu occupancy < %7.2f",ManuOccupancyLowLimit(),ManuOccupancyHighLimit()) << endl;
+  cout << Form("%e <= Buspatch occupancy < %7.2f",BuspatchOccupancyLowLimit(),BuspatchOccupancyHighLimit()) << endl;
+  cout << Form("%e <= DE occupancy < %7.2f",DEOccupancyLowLimit(),DEOccupancyHighLimit()) << endl;
+  
+  cout << "'QAChecker' limits" << endl;  
+  cout << Form("MissingPadFractionLimit = %5.2f %%",MissingPadFractionLimit()*100.0) << endl;  
+  cout << Form("FractionOfBuspatchOutsideOccupancyLimit = %5.2f %%",FractionOfBuspatchOutsideOccupancyLimit()*100.0) << endl;
   
   cout << "chamber non bending resolution = |";
   for (Int_t iCh = 0; iCh < 10; iCh++) cout << Form(" %6.3f |",fDefaultNonBendingReso[iCh]);
@@ -532,12 +540,16 @@ AliMUONRecoParam::SetDefaultLimits()
   fManuOccupancyLimits[0] = -1.0; 
   fManuOccupancyLimits[1] = 1.0;
 
-  fBuspatchOccupancyLimits[0] = -1.0
+  fBuspatchOccupancyLimits[0] = 1E-6
   fBuspatchOccupancyLimits[1] = 1.0;
 
   fDEOccupancyLimits[0] = -1.0; 
   fDEOccupancyLimits[1] = 1.0;
 
   fChargeSigmaCut = 4.0;
+  
+  fMissingPadFractionLimit = 0.1; // 10 % 
+  fFractionOfBuspatchOutsideOccupancyLimit = 0.05; // 5 % 
+
 }
 
index 2152f91..7271dd7 100644 (file)
@@ -286,6 +286,16 @@ class AliMUONRecoParam : public AliDetectorRecoParam
   /// Retrieve high value of DE occupancy limit
   Float_t DEOccupancyHighLimit() const { return fDEOccupancyLimits[1]; }
   
+  /// Set the missing pad fraction limit
+  void SetMissingPadFractionLimit(float v) { fMissingPadFractionLimit = v; }
+  /// Get the missing pad fraction limit
+  Float_t MissingPadFractionLimit() const { return fMissingPadFractionLimit; }
+  
+  /// Set the fraction of buspatches outside the occupancy limits
+  void SetFractionOfBuspatchOutsideOccupancyLimit(float v) { fFractionOfBuspatchOutsideOccupancyLimit = v; }
+  /// Get the fraction of buspatches outside the occupancy limits
+  Float_t FractionOfBuspatchOutsideOccupancyLimit() const { return fFractionOfBuspatchOutsideOccupancyLimit; }
+
   virtual void Print(Option_t *option = "") const;
   
  private:
@@ -378,14 +388,17 @@ class AliMUONRecoParam : public AliDetectorRecoParam
   Double32_t fManuOccupancyLimits[2]; ///< low and high thresholds for manu occupancy cut
   Double32_t fBuspatchOccupancyLimits[2]; ///< low and high thresholds for bus patch occupancy cut
   Double32_t fDEOccupancyLimits[2]; ///< low and high thresholds for DE occupancy cut
-  
+
+  Double32_t fMissingPadFractionLimit; ///< above this fraction, we consider we have too few pads alive...
+  Double32_t fFractionOfBuspatchOutsideOccupancyLimit; ///< above this limit, we consider we have too many buspatches out of the allowed occupancy range
+
   // functions
   void SetLowFluxParam();
   void SetHighFluxParam();
   void SetCosmicParam();
   void SetCalibrationParam();
   
-  ClassDef(AliMUONRecoParam,14) // MUON reco parameters
+  ClassDef(AliMUONRecoParam,15) // MUON reco parameters
 };
 
 #endif
diff --git a/MUON/AliMUONTrackerQAChecker.cxx b/MUON/AliMUONTrackerQAChecker.cxx
new file mode 100644 (file)
index 0000000..d3c3fca
--- /dev/null
@@ -0,0 +1,449 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// $Id$
+
+#include "AliMUONTrackerQAChecker.h"
+
+/// \class AliMUONTrackerQAChecker
+///
+/// Implementation of AliQACheckerBase for MCH and MTR
+///
+/// For the moment we only implement the checking of raw data QA for the tracker
+/// by looking at the occupancy at the bus patch level.
+///
+/// \author Laurent Aphecetche, Subatech
+
+#include "AliCDBManager.h"
+#include "AliCodeTimer.h"
+#include "AliLog.h"
+#include "AliMUONRecoParam.h"
+#include "AliMUONTrackerQADataMakerRec.h"
+#include "AliMpBusPatch.h"
+#include "AliMpDDLStore.h"
+#include "AliQAv1.h"
+#include "AliQAv1.h"
+#include "Riostream.h"
+#include "TAxis.h"
+#include "TDirectory.h"
+#include "TH1.h"
+#include "TLine.h"
+#include "TMath.h"
+#include "TPaveText.h"
+
+/// \cond CLASSIMP
+ClassImp(AliMUONTrackerQAChecker)
+/// \endcond
+
+namespace {
+  
+  //___________________________________________________________________________  
+  int trim(Int_t n, 
+           Double_t* x,
+           Double_t alpha,
+           Double_t& tmean,
+           Double_t& tvar,
+           Double_t& min,
+           Double_t& max)
+  {
+    //
+    // Calculates the trimmed (tmean) mean
+    // of a sample (x) and estimates the variance (tvar)
+    // of that mean.
+    //
+    
+    // First check input parameters
+    
+    // number of observations
+    if ( n < 2 )
+    {
+      return -1;
+    }
+    
+    if ( alpha < 0 || alpha >= 0.5 )
+      // proportion of observations
+      // to be trimmed at each end of the sorted sample
+    {
+      return -2;
+    }
+    
+    // Input parameters are good. Let's move on.
+    
+    // Insure we use a sample sorted into ascending order.
+    
+    Int_t* indices = new Int_t[n];
+    
+    TMath::Sort(n,x,indices,kFALSE);
+    
+    Double_t* sx = new Double_t[n];
+    
+    for ( Int_t i = 0; i < n; ++i )
+    {
+      sx[i] = x[indices[i]];
+    }
+    delete[] indices;
+    
+    
+    // Number of observations trimmed at each end.
+    
+    Int_t k = TMath::FloorNint(alpha * n);
+    
+    double sum = 0.0;
+    
+    for ( Int_t i = k; i < n - k ; ++i )
+    {
+      sum += sx[i];
+    }
+    
+    tmean = sum / ( n - 2 * k );
+    
+    double t2 = 0.0;
+    
+    for ( Int_t i = k; i < n - k; ++i )
+    {
+      t2 += (sx[i] - tmean) * (sx[i] - tmean);
+    }
+    
+    tvar = (
+            t2 +
+            k * (sx[k] - tmean) * (sx[k] - tmean) +
+            k * (sx[n - k - 1] - tmean) * (sx[n - k - 1] - tmean)
+            ) / (n * n);
+    
+    // get the min and max for the non-rejected values
+    min = DBL_MAX;
+    max = 0.0;
+    
+    for ( Int_t i = k; i < n-k; ++i ) 
+    {
+      min = TMath::Min(min,sx[i]);
+      max = TMath::Max(max,sx[i]);
+    }
+    
+    delete[] sx;
+    
+    return 0;
+  }
+}
+
+//__________________________________________________________________
+AliMUONTrackerQAChecker::AliMUONTrackerQAChecker() : AliMUONVQAChecker()
+{
+       /// ctor
+}          
+
+//__________________________________________________________________
+AliMUONTrackerQAChecker::~AliMUONTrackerQAChecker() 
+{
+       /// dtor
+}
+
+//__________________________________________________________________
+AliMUONTrackerQAChecker::AliMUONTrackerQAChecker(const AliMUONTrackerQAChecker& qac) : 
+    AliMUONVQAChecker(qac) 
+{
+       /// copy ctor 
+}   
+
+//______________________________________________________________________________
+AliMUONVQAChecker::ECheckCode*
+AliMUONTrackerQAChecker::CheckRecPoints(TObjArray ** list, AliMUONRecoParam* /*recoParam*/)
+{
+  /// Check rec points
+  /// Very binary check for the moment. 
+  
+  AliCodeTimerAuto("",0);
+  
+  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies] ; 
+  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));
+
+    if ( !h ) rv[specie] = AliMUONVQAChecker::kWarning; // only a warning if histo not found, in order not to kill anything because QA failed...
+  
+    else if ( h->GetMean() == 0.0 ) rv[specie] =  MarkHisto(*h,AliMUONVQAChecker::kFatal);
+  }
+  return rv;
+}
+
+//______________________________________________________________________________
+AliMUONVQAChecker::ECheckCode 
+AliMUONTrackerQAChecker::MarkHisto(TH1& histo, AliMUONVQAChecker::ECheckCode value) const
+{
+  /// Mark histo as originator of some QA error/warning
+  
+  if ( value != AliMUONVQAChecker::kInfo )
+  {
+    histo.SetBit(AliQAv1::GetQABit());
+  }
+  
+  return value;
+}
+
+//______________________________________________________________________________
+AliMUONVQAChecker::ECheckCode*
+AliMUONTrackerQAChecker::CheckESD(TObjArray ** list, AliMUONRecoParam* /*recoParam*/)
+{
+  /// Check ESD
+  
+  AliCodeTimerAuto("",0);
+  
+  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies] ; 
+  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::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));
+  
+    if (!h) rv[specie] = AliMUONVQAChecker::kWarning;
+  
+    else if (h->GetMean() == 0.0 ) rv[specie] = MarkHisto(*h,AliMUONVQAChecker::kError); // no trigger matching -> error
+  }
+  return rv;
+}
+
+//______________________________________________________________________________
+AliMUONVQAChecker::ECheckCode*
+AliMUONTrackerQAChecker::CheckRaws(TObjArray ** list, AliMUONRecoParam* recoParam)
+{
+  /// Check raws
+
+  AliCodeTimerAuto("",0);
+  
+  if (!recoParam) return 0x0;
+  
+  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies] ; 
+
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
+  {
+    rv[specie] = AliMUONVQAChecker::kInfo; 
+  }
+  
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
+  {
+    TH1* hbp = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchOccupancy,AliRecoParam::ConvertIndex(specie));    
+
+    TH1* hnpads = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchNofPads,AliRecoParam::ConvertIndex(specie));
+
+    TH1* hbpconfig = AliQAv1::GetData(list,AliMUONTrackerQADataMakerRec::kTrackerBusPatchConfig,AliRecoParam::ConvertIndex(specie));
+
+    if (!hbp || !hnpads ) 
+    {
+      continue;
+    }
+
+    rv[specie] = BeautifyTrackerBusPatchOccupancy(*hbp,hbpconfig,*hnpads,*recoParam);    
+  }
+  
+  return rv;
+}
+
+//____________________________________________________________________________ 
+AliMUONVQAChecker::ECheckCode
+AliMUONTrackerQAChecker::BeautifyTrackerBusPatchOccupancy(TH1& hbp, 
+                                                          const TH1* hbuspatchconfig, 
+                                                          const TH1& hnpads, 
+                                                          AliMUONRecoParam& recoParam)
+{
+  /// Put labels, limits and so on on the TrackerBusPatchOccupancy histogram
+  /// hbuspatchconfig and hbp must have the same bin definitions
+  
+  if ( hbuspatchconfig )
+  {
+    if ( hbp.GetNbinsX() != hbuspatchconfig->GetNbinsX() ||
+        hbp.GetXaxis()->GetXmin() != hbuspatchconfig->GetXaxis()->GetXmin() ||
+        hbp.GetXaxis()->GetXmax() != hbuspatchconfig->GetXaxis()->GetXmax() )
+    {
+      AliError("hbp and hbuspatchconfig histograms are not compatible !");
+      return AliMUONVQAChecker::kFatal;
+    }
+  }
+  
+  hbp.SetXTitle("Absolute Bus Patch Id");
+  hbp.SetYTitle("Occupancy (percent)");
+  hbp.SetStats(kFALSE);
+  
+  Double_t xmin = hbp.GetXaxis()->GetXmin();
+  Double_t xmax = hbp.GetXaxis()->GetXmax();
+  
+  Double_t occMax(0.1); // 0.1% y-limit for the plot
+  Double_t maxToleratedOccupancy(recoParam.BuspatchOccupancyHighLimit()*100.0); 
+  Double_t minToleratedOccupancy(recoParam.BuspatchOccupancyLowLimit()*100.0);   
+  TLine* line1 = new TLine(xmin,maxToleratedOccupancy,xmax,maxToleratedOccupancy);
+  line1->SetLineColor(1);
+  line1->SetLineWidth(1);
+
+  TLine* line2 = new TLine(xmin,minToleratedOccupancy,xmax,minToleratedOccupancy);
+  line2->SetLineColor(1);
+  line2->SetLineWidth(1);
+  
+  hbp.GetListOfFunctions()->Add(line1);
+  hbp.GetListOfFunctions()->Add(line2);
+    
+  TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+  AliMpBusPatch* bp(0x0);
+
+  Int_t nMissingPads(0);
+  Int_t nPads(0);
+  Int_t nBusPatches(0);
+  Int_t nMissingBusPatches(0);
+  
+  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
+  {
+    Int_t bin = hbp.FindBin(bp->GetId());
+    Int_t n = hnpads.GetBinContent(bin);
+    
+    ++nBusPatches;
+    
+    nPads += n;
+    
+    if ( hbp.GetBinContent(bin) <= 0 ) 
+    {
+      nMissingPads += n;
+      ++nMissingBusPatches;
+    }
+  }
+  
+  next.Reset();
+  
+  Int_t ok(-1);
+  Int_t n(0);
+  Int_t nBusPatchesAboveLimit(0);
+  Int_t nBusPatchesBelowLimit(0);
+  Double_t alpha(0.1); // trim 10% of data
+  Double_t tmean(0.0),tvar(0.0);
+  Double_t ymin(0.0),ymax(0.0);
+  AliMUONVQAChecker::ECheckCode rv(AliMUONVQAChecker::kFatal); // default value = serious problem
+  
+  if ( nBusPatches ) 
+  {
+    Double_t* x = new Double_t[nBusPatches];
+    
+    while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
+    {
+      Int_t bin = hbp.FindBin(bp->GetId());
+      if ( hbp.GetBinContent(bin) > 0 )
+      {
+        x[n] = hbp.GetBinContent(bin);
+        ++n;
+      }
+      if ( hbp.GetBinContent(bin) > maxToleratedOccupancy )
+      {
+        ++nBusPatchesAboveLimit;
+      }
+      if ( hbp.GetBinContent(bin) < minToleratedOccupancy )
+      {
+        // check whether this buspatch has a reason to be absent (only valid
+        // if we got the config, otherwise we cannot do the test)
+        if ( hbuspatchconfig && hbuspatchconfig->GetBinContent(bin) > 0 )
+        {
+          // should be there, so it's an error
+          ++nBusPatchesBelowLimit;
+        }
+      }
+    }
+    
+    // computed the truncated mean of the occupancy values, in order to get a 
+    // reasonable y-range for the histogram (without giant peaks to the roof 
+    // for misbehaving buspatches).
+    ok = trim(n,x,alpha,tmean,tvar,ymin,ymax);
+    
+    delete[] x;
+  }
+  
+  if ( ok < 0 ) 
+  {
+    ymax = occMax;
+  }
+  else
+  {
+    ymax = TMath::Max(ymax,occMax);
+  }
+  
+  hbp.SetMaximum(ymax*1.4);
+  
+  TPaveText* text = new TPaveText(0.50,0.80,0.99,0.99,"NDC");
+  
+  if (ok < 0 ) 
+  {
+    text->AddText("Could not compute truncated mean. Not enough events ?");
+  }
+  else if (!nPads || !nBusPatches)
+  {
+    text->AddText("Could not get the total number of pads. ERROR !!!");
+  }
+  else
+  {
+    Float_t missingPadFraction = nMissingPads*100.0/nPads;
+    Float_t missingBusPatchFraction = nMissingBusPatches*100.0/nBusPatches;
+    Float_t aboveLimitFraction = nBusPatchesAboveLimit*100.0/nBusPatches;
+    Float_t belowLimitFraction = nBusPatchesBelowLimit*100.0/nBusPatches;
+    
+    text->AddText(Form("MCH RUN %d",AliCDBManager::Instance()->GetRun()));
+    text->AddText(Form("%5.2f %% of missing buspatches (%d out of %d)",missingBusPatchFraction,nMissingBusPatches,nBusPatches));
+    text->AddText(Form("%5.2f %% of missing pads (%d out of %d)",missingPadFraction,nMissingPads,nPads));
+    text->AddText(Form("%5.2f %% bus patches above the %5.2f %% limit",aboveLimitFraction,maxToleratedOccupancy));
+    text->AddText(Form("%5.2f %% bus patches below the %e %% limit",belowLimitFraction,minToleratedOccupancy));
+    text->AddText(Form("Truncated mean at %2d %% is %7.2f %%",(Int_t)(alpha*100),tmean));
+    
+    if ( missingPadFraction >= 100.0 ) 
+    {
+      rv = AliMUONVQAChecker::kFatal;       
+    }
+    
+    else if ( missingPadFraction > recoParam.MissingPadFractionLimit()*100.0 || 
+             aboveLimitFraction > recoParam.FractionOfBuspatchOutsideOccupancyLimit()*100.0 || 
+             belowLimitFraction > recoParam.FractionOfBuspatchOutsideOccupancyLimit()*100.0 ) 
+    {
+      rv = AliMUONVQAChecker::kError;
+    }
+    else
+    {
+      rv = AliMUONVQAChecker::kInfo;
+    }
+  }
+  
+  hbp.GetListOfFunctions()->Add(text);
+  
+  if ( rv == AliMUONVQAChecker::kInfo ) 
+  {
+    text->SetFillColor(3); // green = INFO
+  }
+  else if ( rv == AliMUONVQAChecker::kWarning ) 
+  {
+    text->SetFillColor(5); // yellow = WARNING
+  }
+  else if ( rv ==  AliMUONVQAChecker::kFatal) 
+  {
+    text->SetFillColor(2); // red = FATAL
+  }
+  else 
+  {
+    text->SetFillColor(6); // pink = ERROR
+  }
+  
+  return rv;
+}
+
diff --git a/MUON/AliMUONTrackerQAChecker.h b/MUON/AliMUONTrackerQAChecker.h
new file mode 100644 (file)
index 0000000..6560774
--- /dev/null
@@ -0,0 +1,41 @@
+#ifndef ALIMUONTRACKERQACHECKER_H
+#define ALIMUONTRACKERQACHECKER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec 
+/// \class AliMUONTrackerQAChecker
+/// \brief Implementation of QAChecker for MCH
+///
+//  Author: Laurent Aphecetche
+
+#include "AliMUONVQAChecker.h"
+
+class TH1;
+
+class AliMUONTrackerQAChecker: public AliMUONVQAChecker {
+
+public:
+  AliMUONTrackerQAChecker();
+  AliMUONTrackerQAChecker(const AliMUONTrackerQAChecker& qac);
+  virtual ~AliMUONTrackerQAChecker();
+
+  virtual AliMUONVQAChecker::ECheckCode* CheckRaws(TObjArray** list, AliMUONRecoParam* recoParam);
+  virtual AliMUONVQAChecker::ECheckCode* CheckRecPoints(TObjArray** list, AliMUONRecoParam* recoParam);
+  virtual AliMUONVQAChecker::ECheckCode* CheckESD(TObjArray** list, AliMUONRecoParam* recoParam);
+
+private:
+  
+  AliMUONVQAChecker::ECheckCode MarkHisto(TH1& histo, AliMUONVQAChecker::ECheckCode value) const;
+  
+  AliMUONVQAChecker::ECheckCode BeautifyTrackerBusPatchOccupancy(TH1& hbp, 
+                                                                 const TH1* hbuspatchconfig, 
+                                                                 const TH1& hnpads, AliMUONRecoParam& recoParam);
+
+  ClassDef(AliMUONTrackerQAChecker,1)  // MUON quality assurance checker
+
+};
+
+#endif 
diff --git a/MUON/AliMUONTrackerQADataMakerRec.cxx b/MUON/AliMUONTrackerQADataMakerRec.cxx
new file mode 100644 (file)
index 0000000..89ad415
--- /dev/null
@@ -0,0 +1,1022 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// $Id: AliMUONTrackerQADataMakerRec.cxx 35760 2009-10-21 21:45:42Z ivana $
+
+// --- MUON header files ---
+#include "AliMUONTrackerQADataMakerRec.h"
+
+#include "AliQAv1.h"
+#include "AliMUONConstants.h"  
+#include "AliMUONDigitMaker.h"
+#include "AliMUONQAMappingCheck.h"
+#include "AliMUONTrackerDataMaker.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
+#include "AliMUONVDigit.h"
+#include "AliMUONVDigitStore.h"
+#include "AliMUONVTrackerData.h"
+#include "AliMUONTrack.h"
+#include "AliMUONTrackParam.h"
+#include "AliMUONESDInterface.h"
+#include "AliMUONCalibrationData.h"
+#include "AliMpBusPatch.h"
+#include "AliMpConstants.h"
+#include "AliMpDDLStore.h"
+#include "AliMpDEIterator.h"
+#include "AliMpDEManager.h"
+#include "AliMpDetElement.h"
+
+// --- AliRoot header files ---
+#include "AliCDBManager.h"
+#include "AliESDEvent.h"
+#include "AliESDMuonTrack.h"
+#include "AliLog.h"
+#include "AliRawReader.h"
+#include "AliCodeTimer.h"
+#include "AliMUONVDigit.h"
+
+// --- ROOT system ---
+#include <TH1F.h> 
+#include <TH1I.h> 
+#include <TH2F.h>
+#include <Riostream.h>
+#include <TMath.h>
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONTrackerQADataMakerRec
+///
+/// MUON base class for quality assurance data (histo) maker
+///
+/// \author C. Finck, D. Stocco, L. Aphecetche
+
+/// \cond CLASSIMP
+ClassImp(AliMUONTrackerQADataMakerRec)
+/// \endcond
+           
+//____________________________________________________________________________ 
+AliMUONTrackerQADataMakerRec::AliMUONTrackerQADataMakerRec(AliQADataMakerRec* master) : 
+AliMUONVQADataMakerRec(master),
+fDigitStore(AliMUONVDigitStore::Create("AliMUONDigitStoreV1")),
+fDigitMaker(new AliMUONDigitMaker(kTRUE)),
+fClusterStore(0x0),
+fTrackerDataMaker(0x0),
+fMappingCheckRecPoints(0x0),
+fCalibrationData(new AliMUONCalibrationData(AliCDBManager::Instance()->GetRun()))
+{
+  /// ctor
+}
+
+//__________________________________________________________________
+AliMUONTrackerQADataMakerRec::~AliMUONTrackerQADataMakerRec()
+{
+  /// dtor
+  delete fDigitStore;
+  delete fDigitMaker;
+  delete fClusterStore;
+  delete fTrackerDataMaker;
+  delete fCalibrationData;
+  delete fMappingCheckRecPoints;
+}
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::InsertTrackerData(Int_t specie, TObjArray** list,
+                                                     TObject* object, Int_t indexNumber,
+                                                     Bool_t replace)
+{
+  /// Insert an object to a given list
+  
+  TIter next(list[specie]);
+  TObject* o;
+  TObject* old(0x0);
+  Bool_t alreadyThere(kFALSE);
+  while ( ( o = next() ) && !alreadyThere )
+  {
+    TString classname(o->ClassName());
+    if ( classname.Contains("TrackerData") ) 
+    {
+      alreadyThere = kTRUE;
+      old = o;
+    }
+  }
+  if ( (!alreadyThere && object) || (alreadyThere && replace) )
+  {
+    delete old;
+    AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s to the list of qa objects",object->GetName()));
+    TNamed* named = static_cast<TNamed*>(object);
+    named->SetName(Form("%s_%s",AliRecoParam::GetEventSpecieName(specie),object->GetName()));
+    object->SetBit(AliQAv1::GetExpertBit());
+    list[specie]->AddAt(object,indexNumber);
+  }
+}
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**)
+{
+  /// Normalize ESD histograms
+  
+  if (!GetESDsData(kESDnClustersPerTrack)) return;
+  
+  Double_t nTracks = GetESDsData(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);
+  
+  hESDnClustersPerCh->Reset();
+  hESDnClustersPerDE->Reset();
+  hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks);
+  hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks);
+  
+  // loop over chambers
+  for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
+    
+    TH1* hESDClusterChargeInCh = GetESDsData(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);
+    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);
+    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);
+    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);
+    Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
+    hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
+    hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
+    
+    TH1* hESDLocalChi2YInCh = GetESDsData(kESDLocalChi2YInCh+iCh);
+    Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
+    hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
+    hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
+    
+    TH1* hESDLocalChi2InCh = GetESDsData(kESDLocalChi2InCh+iCh);
+    Double_t sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS();
+    hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean());
+    hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError());
+    
+    // loop over DE into chamber iCh
+    AliMpDEIterator it;
+    it.First(iCh);
+    while ( !it.IsDone()) {
+      
+      Int_t iDE = it.CurrentDEId();
+      
+      Double_t nClusters = hESDnTotClustersPerDE->GetBinContent(iDE+1);
+      if (nClusters > 1) {
+        
+        hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters);
+        hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
+        
+        Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters;
+        hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX);
+        hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters));
+        hESDResidualXPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX));
+        hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters));
+        
+        Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters;
+        hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY);
+        hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters));
+        hESDResidualYPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY));
+        hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters));
+        
+        hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters);
+        hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters));
+        
+        hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters);
+        hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters));
+        
+        hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters);
+        hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters));
+        
+      } else {
+        
+        hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1));
+        hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax());
+        
+        hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1));
+        hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
+        hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.);
+        hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
+        
+        hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1));
+        hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
+        hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.);
+        hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
+        
+        hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1));
+        hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax());
+        
+        hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1));
+        hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax());
+        
+        hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1));
+        hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax());
+        
+      }
+      
+      Double_t nFullClusters = hESDnTotFullClustersPerDE->GetBinContent(iDE+1);
+      if (nFullClusters > 1) {
+        
+        hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters);
+        hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters));
+        
+      } else {
+        
+        hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1));
+        hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax());
+        
+      }
+      
+      it.Next();
+    }
+
+  }
+
+}
+  
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list)
+{
+  /// Normalize RecPoints histograms
+  
+  if (!GetRecPointsData(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);
+  
+  // loop over chambers
+  for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
+    
+    TH1* hTrackerClusterChargePerChamber = GetRecPointsData(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);
+    Double_t sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS();
+    hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean());
+    hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError());
+    hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize);
+    hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError());
+    
+    // loop over DE into chamber iCh
+    AliMpDEIterator it;
+    it.First(iCh);
+    while ( !it.IsDone()) {
+      
+      Int_t iDE = it.CurrentDEId();
+      
+      TH1* hTrackerClusterChargePerDE = GetRecPointsData(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);
+      hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean());
+      nClusters = hTrackerClusterMultiplicityPerDE->GetEntries();
+      if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters));
+      else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax());
+      
+      it.Next();
+    }
+  }
+  
+  if ( fMappingCheckRecPoints ) InsertTrackerData(specie,list,fMappingCheckRecPoints->CreateData("RecPoints"),kTrackerRecPoints,kTRUE);
+}
+
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRaws(Int_t specie, TObjArray** list)
+{
+  /// create Raws histograms in Raws subdir
+  
+  if ( !GetRawsData(kTrackerBusPatchOccupancy) ) return;
+
+  if ( fTrackerDataMaker ) 
+  {
+    InsertTrackerData(specie,list,fTrackerDataMaker->Data(),kTrackerData);
+
+    TH1* hbp = GetRawsData(kTrackerBusPatchOccupancy);
+    hbp->Reset();
+    TIter nextBP(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+    AliMpBusPatch* bp(0x0);
+    AliMUONVTrackerData* data = fTrackerDataMaker->Data();
+    Int_t occDim = 2;
+    
+    while ( ( bp = static_cast<AliMpBusPatch*>(nextBP())) )
+    {
+      Int_t busPatchId = bp->GetId();
+      Int_t bin = hbp->FindBin(busPatchId);
+      hbp->SetBinContent(bin,data->BusPatch(busPatchId,occDim)*100.0); // occupancy, in percent
+    }
+  }
+}
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::InitRaws()
+{
+    /// create Raws histograms in Raws subdir
+       
+  AliCodeTimerAuto("",0);
+  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+   Int_t bpmin(999999);
+  Int_t bpmax(0);
+  
+  TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+  AliMpBusPatch* bp(0x0);
+  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
+  {
+    bpmin = TMath::Min(bpmin,bp->GetId());
+    bpmax = TMath::Max(bpmax,bp->GetId());
+  }
+  
+  Double_t xmin = bpmin-0.5;
+  Double_t xmax = bpmax+0.5;
+  Int_t nbins = bpmax-bpmin+1;
+  
+  TH1* hbp = new TH1F("hTrackerBusPatchOccupancy","Occupancy of bus patches",nbins,xmin,xmax);
+
+
+  TH1* hbpnpads = new TH1F("hTrackerBusPatchNofPads","Number of pads per bus patch",nbins,xmin,xmax);
+
+  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);
+
+  const Bool_t histogram(kFALSE);
+
+  if(!fTrackerDataMaker) 
+  {
+    fTrackerDataMaker = new AliMUONTrackerDataMaker(GetRecoParam(),
+                                                    AliCDBManager::Instance()->GetRun(),
+                                                    0x0,
+                                                    "",
+                                                    "NOGAIN",
+                                                    histogram,
+                                                    0.0,0.0);
+  }
+  
+  fTrackerDataMaker->Data()->DisableChannelLevel(); // to save up disk space, we only store starting at the manu level
+
+  fTrackerDataMaker->SetRunning(kTRUE);
+  
+  next.Reset();
+
+  AliMUONVStore* config = fCalibrationData->Config();
+
+  TH1* hbpconfig(0x0);
+  
+  if (config)
+  {
+    hbpconfig = new TH1F("hTrackerBusPatchConfig","Configuration of bus patches",nbins,xmin,xmax);
+    Add2RawsList(hbpconfig,kTrackerBusPatchConfig, expert, !image, !saveCorr);
+  }
+  else
+  {
+    AliWarning("Tracker configuration not found. Will not be able to cut on low occupancies");
+  }
+  
+  while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
+  {
+    Int_t n(0);
+    Bool_t inConfig(kTRUE);
+    
+    for ( Int_t imanu = 0; imanu < bp->GetNofManus(); ++imanu )
+    {
+      Int_t manuId = bp->GetManuId(imanu);
+      AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(bp->GetDEId());      
+      n += de->NofChannelsInManu(manuId);
+      if ( config && !config->FindObject(de->GetId(),manuId)) inConfig=kFALSE;
+    }
+    hbpnpads->Fill(bp->GetId(),n*1.0);
+    hbpnmanus->Fill(bp->GetId(),bp->GetNofManus()*1.0);
+    if ( hbpconfig && inConfig ) 
+    {
+      hbpconfig->Fill(bp->GetId());
+    }
+  }
+}
+
+//__________________________________________________________________
+void AliMUONTrackerQADataMakerRec::InitDigits() 
+{
+  /// Initialized Digits spectra 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts",  1400, 100, 1500); 
+  Add2DigitsList(h0, 0, !expert, image);
+  
+  TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits;ACD value;Counts", 4096, 0, 4095); 
+  Add2DigitsList(h1, 1, !expert, image);    
+} 
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::InitRecPoints()
+{
+  /// create Reconstructed Points histograms in RecPoints subdir for the
+  /// MUON tracker subsystem.
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  AliCodeTimerAuto("",0);
+  
+  TH1I *h1I;
+  TH1F *h1F;
+  TH2F *h2F;
+  
+  // histograms per chamber
+  Int_t nCh = AliMpConstants::NofTrackingChambers();
+  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);
+    
+    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);
+    
+    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);
+  }
+  
+  // 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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  // histograms per DE
+  Int_t ndes(0);
+  AliMpDEIterator it;
+  it.First();
+  while ( !it.IsDone())
+  {
+    Int_t detElemId = it.CurrentDEId();
+    
+    if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger )
+    {
+      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);
+      
+      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);
+    }
+    
+    it.Next();
+  }
+  
+  // 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);
+  
+  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);
+  
+  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);
+  
+  if (!fMappingCheckRecPoints) fMappingCheckRecPoints = new AliMUONQAMappingCheck(RunNumber());  
+}
+
+//____________________________________________________________________________ 
+void AliMUONTrackerQADataMakerRec::InitESDs()
+{
+  ///create ESDs histograms in ESDs subdir
+  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  Int_t nCh = AliMUONConstants::NTrackingCh();
+  Int_t nDE = 1100;
+  
+  // track info
+  TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
+  Add2ESDsList(hESDnTracks, kESDnTracks, !expert, image);
+
+  TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
+  Add2ESDsList(hESDMatchTrig, kESDMatchTrig, !expert, image);
+  
+  TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
+  Add2ESDsList(hESDMomentum, kESDMomentum, !expert, image);
+
+  TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
+  Add2ESDsList(hESDPt, kESDPt, !expert, image);
+
+  TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
+  Add2ESDsList(hESDRapidity, kESDRapidity, !expert, image);
+
+  TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
+  Add2ESDsList(hESDChi2, 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);
+  
+  TH1F* hESDThetaX = new TH1F("hESDThetaX", "#theta_{X} distribution;#theta_{X} (degree)", 360, -180., 180);
+  Add2ESDsList(hESDThetaX, kESDThetaX, !expert, image);
+  
+  TH1F* hESDThetaY = new TH1F("hESDThetaY", "#theta_{Y} distribution;#theta_{Y} (degree)", 360, -180., 180);
+  Add2ESDsList(hESDThetaY, 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);
+  }
+  
+  TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
+  Add2ESDsList(hESDnClustersPerTrack, 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);
+  
+  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);
+  
+  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);
+  }
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  }
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  // 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);
+    
+    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);
+    
+    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);
+    
+    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);
+    
+    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);
+  }
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  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);
+  
+  // 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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+}
+
+//____________________________________________________________________________
+void AliMUONTrackerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
+{
+       /// make QA for rawdata tracker
+       
+  AliCodeTimerAuto("",0);
+
+  /// forces init
+  GetRawsData(kTrackerBusPatchOccupancy);
+  
+       ((AliMUONTrackerDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader);
+       
+       fTrackerDataMaker->ProcessEvent();
+}
+
+//__________________________________________________________________
+void AliMUONTrackerQADataMakerRec::MakeDigits(TTree* digitsTree)         
+{
+  /// makes data from Digits
+
+  AliCodeTimerAuto("",0);
+  
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+
+  if (!fDigitStore)
+    fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
+  fDigitStore->Connect(*digitsTree, false);
+  digitsTree->GetEvent(0);
+  
+  TIter next(fDigitStore->CreateIterator());
+  
+  AliMUONVDigit* dig = 0x0;
+  
+  while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
+    {
+    GetDigitsData(0)->Fill(dig->DetElemId());
+    GetDigitsData(1)->Fill(dig->ADC());
+    }
+}
+
+
+//____________________________________________________________________________
+void AliMUONTrackerQADataMakerRec::MakeRecPoints(TTree* clustersTree)
+{
+       /// Fill histograms related to tracker clusters 
+       
+       // First things first : do we have clusters in the TreeR ?
+       // In "normal" production mode, it should be perfectly normal
+       // *not* to have them.
+       // But if for some reason we de-activated the combined tracking,
+       // then we have clusters in TreeR, so let's take that opportunity
+       // to QA them...
+       
+  AliCodeTimerAuto("",0);
+
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+
+       if (!fClusterStore)
+       {
+         AliCodeTimerAuto("ClusterStore creation",1);
+               fClusterStore = AliMUONVClusterStore::Create(*clustersTree);
+               if (!fClusterStore) 
+               {
+                       return;
+               }
+       }
+       
+       fClusterStore->Connect(*clustersTree,kFALSE);
+       clustersTree->GetEvent(0);
+
+       TIter next(fClusterStore->CreateIterator());
+       AliMUONVCluster* cluster;
+       
+  if ( fMappingCheckRecPoints ) fMappingCheckRecPoints->NewEvent();
+  
+       while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) )
+       {
+               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());
+               
+    if ( fMappingCheckRecPoints ) fMappingCheckRecPoints->Store(*cluster);
+    
+       }
+       
+       fClusterStore->Clear();
+}
+
+//____________________________________________________________________________
+void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd)
+{
+  /// make QA data from ESDs
+
+  AliCodeTimerAuto("",0);
+  
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+  
+  // load ESD event in the interface
+  AliMUONESDInterface esdInterface;
+  if (GetRecoParam()) AliMUONESDInterface::ResetTracker(GetRecoParam());
+  else AliError("Unable to get recoParam: use default ones for residual calculation");
+  esdInterface.LoadEvent(*esd);
+  
+  GetESDsData(kESDnTracks)->Fill(esdInterface.GetNTracks());
+  
+  Int_t nTrackMatchTrig = 0;
+  
+  // loop over tracks
+  Int_t nTracks = (Int_t) esd->GetNumberOfMuonTracks(); 
+  for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) {
+    
+    // get the ESD track and skip "ghosts"
+    AliESDMuonTrack* esdTrack = esd->GetMuonTrack(iTrack);
+    if (!esdTrack->ContainTrackerData()) continue;
+    
+    // get corresponding MUON track
+    AliMUONTrack* track = esdInterface.FindTrack(esdTrack->GetUniqueID());
+    
+    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());
+    
+    // loop over clusters
+    AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
+    while (trackParam) {
+      
+      AliMUONVCluster* cluster = trackParam->GetClusterPtr();
+      Int_t chId = cluster->GetChamberId();
+      Int_t deID = cluster->GetDetElemId();
+      Double_t residualX = cluster->GetX() - trackParam->GetNonBendingCoor();
+      Double_t residualY = cluster->GetY() - trackParam->GetBendingCoor();
+      Double_t sigmaResidualX2 = cluster->GetErrX2() - trackParam->GetCovariances()(0,0);
+      Double_t sigmaResidualY2 = cluster->GetErrY2() - trackParam->GetCovariances()(2,2);
+      Double_t localChi2X = (sigmaResidualX2 > 0.) ? residualX*residualX/sigmaResidualX2 : 0.;
+      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(kESDnTotClustersPerCh)->Fill(chId);
+      GetESDsData(kESDnTotClustersPerDE)->Fill(deID);
+      
+      GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
+      GetESDsData(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(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(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);
+      
+      trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
+      
+    }
+    
+  }
+
+  GetESDsData(kESDMatchTrig)->Fill(nTrackMatchTrig);
+  
+}
+
+//____________________________________________________________________________ 
+AliMUONVTrackerData* AliMUONTrackerQADataMakerRec::GetTrackerData() const
+{ 
+/// Return tracker data
+  
+  return fTrackerDataMaker->Data(); 
+  
+}
diff --git a/MUON/AliMUONTrackerQADataMakerRec.h b/MUON/AliMUONTrackerQADataMakerRec.h
new file mode 100644 (file)
index 0000000..0d1529e
--- /dev/null
@@ -0,0 +1,165 @@
+#ifndef ALIMUONTRACKERQADATAMAKERREC_H
+#define ALIMUONTRACKERQADATAMAKERREC_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// $Id: AliMUONTrackerQADataMakerRec.h 35760 2009-10-21 21:45:42Z ivana $
+
+/// \ingroup rec
+/// \class AliMUONTrackerQADataMakerRec
+/// \brief MUON Quality assurance data maker
+///
+
+// --- AliRoot header files ---
+#include "AliMUONVQADataMakerRec.h"
+#include "AliMUONRecoParam.h"
+
+class AliMUONDigitMaker;
+class AliMUONVClusterStore;
+class AliMUONVDigitStore;
+class AliMUONVStore;
+class AliMUONVTrackerData;
+class AliMUONVTrackerDataMaker;
+class AliMUONCalibrationData;
+class AliMUONQAMappingCheck;
+
+class AliMUONTrackerQADataMakerRec: public AliMUONVQADataMakerRec {
+
+public:
+  AliMUONTrackerQADataMakerRec(AliQADataMakerRec* master);         
+  virtual ~AliMUONTrackerQADataMakerRec();
+  
+  AliMUONVTrackerData* GetTrackerData() const;
+
+  virtual void InitDigits(); 
+  virtual void InitESDs(); 
+  virtual void InitRaws(); 
+  virtual void InitRecPoints(); 
+  
+  void EndOfDetectorCycleRaws(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleESDs(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleDigits(Int_t, TObjArray**) {}
+    
+  virtual void MakeDigits(TTree* dig); 
+  virtual void MakeESDs(AliESDEvent* esd) ;
+  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, 
+                         Int_t indexNumber, Bool_t replace=kFALSE);
+
+private:
+       AliMUONTrackerQADataMakerRec(const AliMUONTrackerQADataMakerRec& rhs);
+       AliMUONTrackerQADataMakerRec& operator=(const AliMUONTrackerQADataMakerRec& rhs);
+  
+  AliMUONVDigitStore*   fDigitStore; //!< pointer to digits store
+  AliMUONDigitMaker*    fDigitMaker;  //!< pointer to digit maker
+  AliMUONVClusterStore* fClusterStore; //!< pointer to cluster store
+       
+  AliMUONVTrackerDataMaker* fTrackerDataMaker; //!< tracker data accumulation (Raw)
+  
+  AliMUONQAMappingCheck* fMappingCheckRecPoints; //!< mapping cross-checker (RecPoints)
+  
+  AliMUONCalibrationData* fCalibrationData; //!< Used to load Local, Regional and Global masks
+  
+  ClassDef(AliMUONTrackerQADataMakerRec,1)  // MUON Quality assurance data maker
+
+};
+#endif
diff --git a/MUON/AliMUONTriggerQAChecker.cxx b/MUON/AliMUONTriggerQAChecker.cxx
new file mode 100644 (file)
index 0000000..4b4cc21
--- /dev/null
@@ -0,0 +1,146 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// $Id$
+
+#include "AliMUONTriggerQAChecker.h"
+
+/// \class AliMUONTriggerQAChecker
+///
+/// Implementation of QAChecker for MTR
+///
+/// For the moment we only implement the checking of raw data QA for the trigger
+/// by looking at the local structure and trigger response errors.
+///
+/// \author Diego Stocc, Subatech
+
+
+#include "AliRecoParam.h"
+#include "AliMUONTriggerQADataMakerRec.h"
+#include "AliQAV1.h"
+#include "TH1.h"
+#include "TPaveText.h"
+#include "TString.h"
+#include "TObjArray.h"
+#include "TList.h"
+
+/// \cond CLASSIMP
+ClassImp(AliMUONTriggerQAChecker)
+/// \endcond
+
+//__________________________________________________________________
+AliMUONTriggerQAChecker::AliMUONTriggerQAChecker() : AliMUONVQAChecker()
+{
+       /// ctor
+}          
+
+//__________________________________________________________________
+AliMUONTriggerQAChecker::~AliMUONTriggerQAChecker() 
+{
+       /// dtor
+}
+
+//______________________________________________________________________________
+AliMUONVQAChecker::ECheckCode 
+AliMUONTriggerQAChecker::MarkHisto(TH1& histo, AliMUONVQAChecker::ECheckCode value) const
+{
+  /// Mark histo as originator of some QA error/warning
+  
+  if ( value != AliMUONVQAChecker::kInfo )
+  {
+    histo.SetBit(AliQAv1::GetQABit());
+  }
+  
+  return value;
+}
+
+//__________________________________________________________________
+AliMUONVQAChecker::ECheckCode* 
+AliMUONTriggerQAChecker::CheckRaws(TObjArray** list, AliMUONRecoParam* )
+{
+  /// Check raw data
+
+  AliMUONVQAChecker::ECheckCode * rv = new AliMUONVQAChecker::ECheckCode[AliRecoParam::kNSpecies] ; 
+
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+    rv[specie] = AliMUONVQAChecker::kInfo; 
+  }
+
+  Int_t histoRawsPercentIndex[] = {
+    AliMUONTriggerQADataMakerRec::kTriggerError, 
+    AliMUONTriggerQADataMakerRec::kTriggerCalibSummary,
+    AliMUONTriggerQADataMakerRec::kTriggerReadOutErrors
+  };
+  const Int_t kNrawsHistos = sizeof(histoRawsPercentIndex)/sizeof(histoRawsPercentIndex[0]);
+
+  // MOVE THESE TO REFERENCE HISTOS
+  Float_t safeFactor = 5.;
+  Float_t alarmPercentTrigAlgo[AliMUONTriggerQADataMakerRec::kNtrigAlgoErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., 100., 100., 100., 100., safeFactor*1., safeFactor*1., safeFactor*1.};
+  Float_t alarmPercentCalib[AliMUONTriggerQADataMakerRec::kNtrigCalibSummaryBins] = {safeFactor*0.4, safeFactor*1., 6.2, 0.0001, safeFactor*0.4};
+  Float_t alarmPercentReadout[AliMUONTriggerQADataMakerRec::kNtrigStructErrorBins] = {safeFactor*1., safeFactor*1., safeFactor*1., safeFactor*1.};
+
+  Float_t* alarmPercent[kNrawsHistos] = {alarmPercentTrigAlgo, alarmPercentCalib, alarmPercentReadout};
+
+  TH1* currHisto = 0x0;
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+    for(Int_t ihisto = 0; ihisto<kNrawsHistos; ihisto++){
+      currHisto = AliQAv1::GetData(list,histoRawsPercentIndex[ihisto],AliRecoParam::ConvertIndex(specie));
+      if ( currHisto ){
+       currHisto->SetBarWidth(0.5);
+       currHisto->SetBarOffset(0.25);
+       TPaveText* text = new TPaveText(0.65,0.65,0.99,0.99,"NDC");
+       TString binName;
+       Bool_t isOk = kTRUE;
+       Int_t nbins = currHisto->GetXaxis()->GetNbins();
+       for (Int_t ibin = 1; ibin<=nbins; ibin++){
+         binName = currHisto->GetXaxis()->GetBinLabel(ibin);
+         binName.ReplaceAll("#splitline","");
+         binName.ReplaceAll("{","");
+         binName.ReplaceAll("}","");
+         Float_t binContent = currHisto->GetBinContent(ibin);
+//       if (binContent > alarmPercent[ihisto][ibin-1]) isOk = kFALSE;
+         text->AddText(Form("%5.2f %% in %s", binContent, binName.Data()));
+         //text->AddText(Form("%5.2f %% in %s (limit %5.2f %%)", binContent, binName.Data(), alarmPercent[ihisto][ibin-1]));
+       }
+       if ( ! isOk ) {
+         text->SetFillColor(kRed);
+         rv[specie] = MarkHisto(*currHisto, AliMUONVQAChecker::kError);
+       }
+       else text->SetFillColor(kGreen);
+       currHisto->GetListOfFunctions()->Add(text);
+       currHisto->SetStats(kFALSE);
+       currHisto->GetYaxis()->SetRangeUser(0., 110.);
+      }
+    } // loop on histos
+  } // loop on species
+
+  return rv;
+}
+
+//__________________________________________________________________
+AliMUONVQAChecker::ECheckCode* 
+AliMUONTriggerQAChecker::CheckRecPoints(TObjArray** , AliMUONRecoParam* )
+{
+  /// Check rec points
+  return 0x0;
+}
+
+//__________________________________________________________________
+AliMUONVQAChecker::ECheckCode* 
+AliMUONTriggerQAChecker::CheckESD(TObjArray** , AliMUONRecoParam* )
+{
+  /// Check esd
+  return 0x0;
+}
diff --git a/MUON/AliMUONTriggerQAChecker.h b/MUON/AliMUONTriggerQAChecker.h
new file mode 100644 (file)
index 0000000..e591663
--- /dev/null
@@ -0,0 +1,35 @@
+#ifndef ALIMUONTRIGGERQACHECKER_H
+#define ALIMUONTRIGGERQACHECKER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// $Id: AliMUONTriggerQAChecker.h 34140 2009-08-06 13:02:16Z hristov $
+
+/// \ingroup rec 
+/// \class AliMUONTriggerQAChecker
+/// \brief Implementation of QAChecker for MTR
+///
+//  Author: Laurent Aphecetche
+
+#include "AliMUONVQAChecker.h"
+
+class TObjArray;
+class TH1;
+
+class AliMUONTriggerQAChecker: public AliMUONVQAChecker {
+public:
+  AliMUONTriggerQAChecker();
+  virtual ~AliMUONTriggerQAChecker();
+
+  virtual ECheckCode * CheckRaws(TObjArray** list, AliMUONRecoParam* recoParam);
+  virtual ECheckCode * CheckRecPoints(TObjArray** list, AliMUONRecoParam* recoParam);
+  virtual ECheckCode * CheckESD(TObjArray** list, AliMUONRecoParam* recoParam);
+  
+private:
+
+  AliMUONVQAChecker::ECheckCode MarkHisto(TH1& histo, AliMUONVQAChecker::ECheckCode value) const;
+
+  ClassDef(AliMUONTriggerQAChecker,1)  // MUON quality assurance checker
+
+};
+#endif 
diff --git a/MUON/AliMUONTriggerQADataMakerRec.cxx b/MUON/AliMUONTriggerQADataMakerRec.cxx
new file mode 100644 (file)
index 0000000..a0ebefa
--- /dev/null
@@ -0,0 +1,1253 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// $Id: AliMUONTriggerQADataMakerRec.cxx 35760 2009-10-21 21:45:42Z ivana $
+
+// --- MUON header files ---
+#include "AliMUONTriggerQADataMakerRec.h"
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONTriggerQADataMakerRec
+///
+/// MUON class for quality assurance data (histo) maker
+///
+/// \author C. Finck, D. Stocco, L. Aphecetche
+
+/// \cond CLASSIMP
+ClassImp(AliMUONTriggerQADataMakerRec)
+/// \endcond
+           
+#include "AliCodeTimer.h"
+#include "AliMUONConstants.h"
+#include "AliMpConstants.h"
+#include "AliMUONTriggerDisplay.h"
+#include "TH2.h"
+#include "TString.h"
+#include "AliRecoParam.h"
+#include "AliMUONDigitStoreV2R.h"
+#include "AliMUONTriggerStoreV1.h"
+#include "AliMpCDB.h"
+#include "AliMUONRawStreamTriggerHP.h"
+#include "AliMpDDLStore.h"
+#include "AliMpTriggerCrate.h"
+#include "AliMpLocalBoard.h"
+#include "AliQAv1.h"
+#include "AliRawReader.h"
+#include "AliMUONDigitMaker.h"
+#include "AliMUONLocalTrigger.h"
+#include "AliMUONRecoParam.h"
+#include "AliMUONTriggerElectronics.h"
+#include "AliMUONCalibrationData.h"
+#include "AliDCSValue.h"
+#include "AliMpDCSNamer.h"
+#include "AliMpDEManager.h"
+#include "AliMpDEIterator.h"
+#include "AliCDBManager.h"
+#include "TTree.h"
+#include "AliMUONGlobalTriggerBoard.h"
+#include "AliMUONGlobalCrateConfig.h"
+
+//____________________________________________________________________________ 
+AliMUONTriggerQADataMakerRec::AliMUONTriggerQADataMakerRec(AliQADataMakerRec* master) : 
+AliMUONVQADataMakerRec(master),
+fDigitMaker(new AliMUONDigitMaker(kFALSE)),
+fCalibrationData(new AliMUONCalibrationData(AliCDBManager::Instance()->GetRun())),
+fTriggerProcessor(new AliMUONTriggerElectronics(fCalibrationData)),
+fDigitStore(0x0)
+{
+    /// ctor
+}
+
+
+//__________________________________________________________________
+AliMUONTriggerQADataMakerRec::~AliMUONTriggerQADataMakerRec()
+{
+    /// dtor
+  delete fDigitMaker;
+  delete fDigitStore;
+  delete fTriggerProcessor;
+  delete fCalibrationData;
+}
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleESDs(Int_t /*specie*/, TObjArray** /*list*/)
+{
+  /// Normalize ESD histograms
+}
+  
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t /*specie*/, TObjArray** /*list*/)
+{
+  /// Normalize RecPoints histograms
+  
+}
+
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleRaws(Int_t /*specie*/, TObjArray** /*list*/)
+{
+  /// create Raws histograms in Raws subdir
+
+  // Normalize RawData histos
+  Float_t nbevent = GetRawsData(kRawNAnalyzedEvents)->GetBinContent(1);
+  Int_t histoRawsIndex[] = {
+    kTriggerError,
+    kTriggerCalibSummary,
+    kTriggerReadOutErrors,
+    kTriggerGlobalOutput
+  };
+  const Int_t kNrawsHistos = sizeof(histoRawsIndex)/sizeof(histoRawsIndex[0]);
+  Float_t scaleFactor[kNrawsHistos] = {100., 100., 100., 1.};
+  for(Int_t ihisto=0; ihisto<kNrawsHistos; ihisto++){
+    TH1* currHisto = GetRawsData(histoRawsIndex[ihisto]);
+    if ( currHisto && nbevent > 0 ){
+      currHisto->Scale(scaleFactor[ihisto]/nbevent);
+    }
+  }
+}
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::InitRaws()
+{
+    /// create Raws histograms in Raws subdir
+       
+  AliCodeTimerAuto("",0);
+  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  TString boardName = "Local board Id";
+
+  Int_t nbLocalBoard = AliMUONConstants::NTriggerCircuit();
+
+  TH1F* histo1D = 0x0;
+  TH2F* histo2D = 0x0;
+
+  AliMUONTriggerDisplay triggerDisplay;
+
+  TString histoName, histoTitle;
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) {
+    for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
+      TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
+      for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
+       histoName = Form("hTriggerScalers%sChamber%i", cathName.Data(), 11+iChamber);
+       histoTitle = Form("Chamber %i - %s: trigger scaler counts", 11+iChamber, cathName.Data());
+       histo2D = new TH2F(histoName.Data(), histoTitle.Data(),
+                          nbLocalBoard, 0.5, (Float_t)nbLocalBoard + 0.5,
+                          16, -0.5, 15.5);
+       histo2D->GetXaxis()->SetTitle(boardName.Data());
+       histo2D->GetYaxis()->SetTitle("Strip"); 
+       histo2D->SetOption("COLZ");     
+       Add2RawsList(histo2D, kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+      } // loop on chambers
+    } // loop on cathodes
+       
+    for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
+      TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
+      for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
+       histoName = Form("hTriggerScalersDisplay%sChamber%i", cathName.Data(), 11+iChamber);
+       histoTitle = Form("Chamber %i - %s: Hit rate from scalers (Hz/cm^{2})", 11+iChamber, cathName.Data());
+       histo2D = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
+                                                            iCath, iChamber, histoTitle);
+       histo2D->SetOption("COLZ");
+       Add2RawsList(histo2D, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+      } // loop on chambers
+    } // loop on cathodes
+    
+    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);
+
+    TString axisLabel[kNtrigCalibSummaryBins] = {"#splitline{Dead}{Channels}", "#splitline{Dead}{Local Boards}", "#splitline{Dead}{Regional Boards}", "#splitline{Dead}{Global Board}", "#splitline{Noisy}{Strips}"};
+
+    histo1D = new TH1F("hTriggerCalibSummary", "MTR calibration sumamry", kNtrigCalibSummaryBins, -0.5, (Float_t)kNtrigCalibSummaryBins - 0.5);
+    for (Int_t ibin=1; ibin<=kNtrigCalibSummaryBins; ibin++){
+      histo1D->GetXaxis()->SetBinLabel(ibin, axisLabel[ibin-1].Data());
+    }
+    histo1D->GetYaxis()->SetTitle("Percentage per event (%)");
+    histo1D->SetOption("bar2");
+    histo1D->SetStats(kFALSE);
+    histo1D->SetFillColor(kRed);
+    Add2RawsList(histo1D, kTriggerCalibSummary, !expert, image, !saveCorr);
+  } // Calibration reco param
+
+  histo1D = new TH1F("hTriggeredBoards", "Triggered boards", nbLocalBoard, 0.5, (Float_t)nbLocalBoard + 0.5);
+  Add2RawsList(histo1D, 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);
+       
+  Char_t *globalXaxisName[6] = {"US HPt", "US LPt", "LS HPt", "LS LPt", "SGL HPt", "SGL LPt"};
+  Char_t *allLevelXaxisName[kNtrigAlgoErrorBins] = {"Local algo X", "Local algo Y", "Local LUT","Local Y Copy" , "Local2Regional", "Regional", "Regional2Global", "GlobalFromInGlobal", "GlobalFromInLocal", "GlobalFromOutLocal"};
+  Char_t *readoutErrNames[kNtrigStructErrorBins]={"Local","Regional","Global","DARC"};
+
+  TString errorAxisTitle = "Number of errors";
+
+  TH1F* h11 = new TH1F("ErrorLocalXPos", "ErrorLocalXPos",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h11->GetXaxis()->SetTitle(boardName.Data());
+  h11->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h11, kTriggerErrorLocalXPos, expert, !image, !saveCorr);
+
+  TH1F* h12 = new TH1F("ErrorLocalYPos", "ErrorLocalYPos",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h12->GetXaxis()->SetTitle(boardName.Data());
+  h12->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h12, kTriggerErrorLocalYPos, expert, !image, !saveCorr);
+
+  TH1F* h13 = new TH1F("ErrorLocalDev", "ErrorLocalDev",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h13->GetXaxis()->SetTitle(boardName.Data());
+  h13->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h13, kTriggerErrorLocalDev, expert, !image, !saveCorr);
+
+  TH1F* h14 = new TH1F("ErrorLocalTriggerDec", "ErrorLocalTriggerDec",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h14->GetXaxis()->SetTitle(boardName.Data());
+  h14->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h14, kTriggerErrorLocalTriggerDec, expert, !image, !saveCorr);
+
+  TH1F* h15 = new TH1F("ErrorLocalLPtLSB", "ErrorLocalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h15->GetXaxis()->SetTitle(boardName.Data());
+  h15->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h15, kTriggerErrorLocalLPtLSB, expert, !image, !saveCorr);
+
+  TH1F* h16 = new TH1F("ErrorLocalLPtMSB", "ErrorLocalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h16->GetXaxis()->SetTitle(boardName.Data());
+  h16->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h16, kTriggerErrorLocalLPtMSB, expert, !image, !saveCorr);
+
+  TH1F* h17 = new TH1F("ErrorLocalHPtLSB", "ErrorLocalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h17->GetXaxis()->SetTitle(boardName.Data());
+  h17->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h17, kTriggerErrorLocalHPtLSB, expert, !image, !saveCorr);
+
+  TH1F* h18 = new TH1F("ErrorLocalHPtMSB", "ErrorLocalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h18->GetXaxis()->SetTitle(boardName.Data());
+  h18->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h18, kTriggerErrorLocalHPtMSB, expert, !image, !saveCorr);
+
+  TH1F* h19 = new TH1F("ErrorLocal2RegionalLPtLSB", "ErrorLocal2RegionalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h19->GetXaxis()->SetTitle(boardName.Data());
+  h19->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h19, kTriggerErrorLocal2RegionalLPtLSB, expert, !image, !saveCorr);
+
+  TH1F* h20 = new TH1F("ErrorLocal2RegionalLPtMSB", "ErrorLocal2RegionalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h20->GetXaxis()->SetTitle(boardName.Data());
+  h20->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h20, kTriggerErrorLocal2RegionalLPtMSB, expert, !image, !saveCorr);
+
+  TH1F* h21 = new TH1F("ErrorLocal2RegionalHPtLSB", "ErrorLocal2RegionalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h21->GetXaxis()->SetTitle(boardName.Data());
+  h21->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h21, kTriggerErrorLocal2RegionalHPtLSB, expert, !image, !saveCorr);
+
+  TH1F* h22 = new TH1F("ErrorLocal2RegionalHPtMSB", "ErrorLocal2RegionalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h22->GetXaxis()->SetTitle(boardName.Data());
+  h22->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h22, kTriggerErrorLocal2RegionalHPtMSB, expert, !image, !saveCorr);
+
+  TH1F* h23 = new TH1F("ErrorOutGlobalFromInGlobal", "ErrorOutGlobalFromInGlobal",6,-0.5,6-0.5);
+  h23->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  for (int ibin=0;ibin<6;ibin++){
+    h23->GetXaxis()->SetBinLabel(ibin+1,globalXaxisName[ibin]);
+  }
+  Add2RawsList(h23, kTriggerErrorOutGlobalFromInGlobal, expert, !image, !saveCorr);
+
+  TH1F* h24 = new TH1F("hTriggerAlgoErrors", "Trigger Algorithm errors",kNtrigAlgoErrorBins,-0.5,(Float_t)kNtrigAlgoErrorBins-0.5);
+  h24->GetYaxis()->SetTitle("% of error");
+  h24->SetOption("bar2");
+  for (int ibin=0;ibin<kNtrigAlgoErrorBins;ibin++){
+    h24->GetXaxis()->SetBinLabel(ibin+1,allLevelXaxisName[ibin]);
+  }
+  h24->SetFillColor(2);
+  Add2RawsList(h24, kTriggerError, !expert, image, !saveCorr);
+
+  TH1F* h25 = new TH1F("ErrorLocalTrigY", "ErrorLocalTrigY",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h25->GetXaxis()->SetTitle(boardName.Data());
+  h25->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h25, kTriggerErrorLocalTrigY, expert, !image, !saveCorr);
+
+  TH1F* h26 = new TH1F("ErrorLocalYCopy", "ErrorLocalYCopy",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
+  h26->GetXaxis()->SetTitle(boardName.Data());
+  h26->GetYaxis()->SetTitle(errorAxisTitle.Data());
+  Add2RawsList(h26, kTriggerErrorLocalYCopy, expert, !image, !saveCorr);
+       
+  TH1F* h27 = new TH1F("hRawNAnalyzedEvents", "Number of analyzed events per specie", 1, 0.5, 1.5);
+  Int_t esindex = AliRecoParam::AConvert(CurrentEventSpecie());
+  h27->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
+  h27->GetYaxis()->SetTitle("Number of analyzed events");
+  Add2RawsList(h27, kRawNAnalyzedEvents, expert, !image, !saveCorr);
+
+  TH1F* h28 = new TH1F("hTriggerReadoutErrors","Trigger Read-Out errors", kNtrigStructErrorBins, -0.5, (Float_t)kNtrigStructErrorBins-0.5);
+  h28->SetOption("bar2");
+  h28->GetYaxis()->SetTitle("% of errors");
+  for (int ibin=0;ibin<kNtrigStructErrorBins;ibin++){
+    h28->GetXaxis()->SetBinLabel(ibin+1,readoutErrNames[ibin]);
+  }
+  h28->SetFillColor(2);
+  Add2RawsList(h28, kTriggerReadOutErrors, !expert, image, !saveCorr);
+
+  TH1F* h29 = new TH1F("hTriggerGlobalOutMultiplicity","Trigger global outputs multiplicity", 6, -0.5, 6.-0.5);
+  h29->SetOption("bar2");
+  h29->GetYaxis()->SetTitle("Number of triggers per event"); 
+  h29->GetXaxis()->SetTitle("Global output");
+  for (int ibin=0;ibin<6;ibin++){
+    h29->GetXaxis()->SetBinLabel(ibin+1,globalXaxisName[ibin]);
+  }        
+  h29->SetFillColor(3);
+  Add2RawsList(h29, kTriggerGlobalOutput, expert, !image, !saveCorr);
+}
+
+//__________________________________________________________________
+void AliMUONTriggerQADataMakerRec::InitDigits() 
+{
+  /// Initialized Digits spectra 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts",  400, 1100, 1500); 
+  Add2DigitsList(h0, 0, !expert, image);
+} 
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::InitRecPoints()
+{
+       /// create Reconstructed Points histograms in RecPoints subdir for the
+       /// MUON Trigger subsystem.
+
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
+  TH1F* histo1D = 0x0;
+
+  histo1D = new TH1F("hNAnalyzedEvents", "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");
+  Add2RecPointsList(histo1D, kNAnalyzedEvents, 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);
+
+  FillTriggerDCSHistos();      
+}
+
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::InitESDs()
+{
+}
+
+//____________________________________________________________________________
+void AliMUONTriggerQADataMakerRec::MakeRaws(AliRawReader* rawReader)
+{
+       /// make QA for rawdata trigger
+       
+    GetRawsData(kRawNAnalyzedEvents)->Fill(1.);
+
+    // Init Local/Regional/Global decision with fake values
+    Int_t globaltemp[4];
+    for (Int_t bit=0; bit<4; bit++){
+       globaltemp[bit]=0;
+       fgitmp[bit]=0;
+    }
+
+    for (Int_t loc=0;loc<235;loc++){
+       fTriggerErrorLocalYCopy[loc]=kFALSE;
+
+       fTriggerOutputLocalRecTriggerDec[loc]=0;
+       fTriggerOutputLocalRecLPtDec[0][loc]=0;
+       fTriggerOutputLocalRecLPtDec[1][loc]=0;
+       fTriggerOutputLocalRecHPtDec[0][loc]=0;
+       fTriggerOutputLocalRecHPtDec[1][loc]=0;
+       fTriggerOutputLocalRecXPos[loc]=0;
+       fTriggerOutputLocalRecYPos[loc]=15;
+       fTriggerOutputLocalRecDev[loc]=0;
+       fTriggerOutputLocalRecTrigY[loc]=1;
+
+       fTriggerOutputLocalDataTriggerDec[loc]=0;
+       fTriggerOutputLocalDataLPtDec[0][loc]=0;
+       fTriggerOutputLocalDataLPtDec[1][loc]=0;
+       fTriggerOutputLocalDataHPtDec[0][loc]=0;
+       fTriggerOutputLocalDataHPtDec[1][loc]=0;
+       fTriggerOutputLocalDataXPos[loc]=0;
+       fTriggerOutputLocalDataYPos[loc]=15;
+       fTriggerOutputLocalDataDev[loc]=0;
+       fTriggerOutputLocalDataTrigY[loc]=1;
+       fTriggerInputRegionalDataLPt[0][loc]=0;
+       fTriggerInputRegionalDataLPt[1][loc]=0;
+       fTriggerInputRegionalDataHPt[0][loc]=0;
+       fTriggerInputRegionalDataHPt[1][loc]=0; 
+    }
+
+    for (Int_t reg=0;reg<16;reg++){
+       fTriggerOutputRegionalData[reg]=0;
+       for (Int_t bit=0;bit<4;bit++){
+           fTriggerInputGlobalDataLPt[reg][bit]=0;
+           fTriggerInputGlobalDataHPt[reg][bit]=0;
+       }
+    }
+
+    for (Int_t bit=0;bit<6;bit++){
+       fgotmp[bit]=0;
+       fTriggerOutputGlobalData[bit]=0;
+       fTriggerOutputGlobalRecFromGlobalInput[bit]=0;
+    }
+
+    for (Int_t loc=0;loc<243;loc++){
+       for (Int_t bit=0;bit<16;bit++){
+           fTriggerPatternX1[loc][bit]=0;
+           fTriggerPatternX2[loc][bit]=0;
+           fTriggerPatternX3[loc][bit]=0;
+           fTriggerPatternX4[loc][bit]=0;
+
+           fTriggerPatternY1[loc][bit]=0;
+           fTriggerPatternY2[loc][bit]=0;
+           fTriggerPatternY3[loc][bit]=0;
+           fTriggerPatternY4[loc][bit]=0;
+       }
+    }
+
+    AliMUONDigitStoreV2R digitStore;
+    digitStore.Create();
+    digitStore.Clear();
+
+    AliMUONDigitStoreV2R digitStoreAll;
+    digitStoreAll.Create();
+    digitStoreAll.Clear();
+    TArrayS xyPatternAll[2];
+    for(Int_t icath=0; icath<AliMpConstants::NofCathodes(); icath++){
+      xyPatternAll[icath].Set(AliMpConstants::NofTriggerChambers());
+      xyPatternAll[icath].Reset(1);
+    }
+    
+    AliMUONTriggerStoreV1 triggerStore;
+    triggerStore.Create();
+    triggerStore.Clear();
+
+
+    UShort_t maxNcounts = 0xFFFF;
+    
+    // Get trigger Local, Regional, Global in/outputs and scalers
+
+    Int_t loCircuit=0;
+    AliMpCDB::LoadDDLStore();
+
+    const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
+    const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
+    const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
+
+    Int_t nDeadLocal = 0, nDeadRegional = 0, nDeadGlobal = 0, nNoisyStrips = 0;
+
+    // When a crate is not present, the loop on boards is not performed
+    // This should allow to correctly count the local boards
+    Int_t countNotifiedBoards = 0, countAllBoards = 0;
+
+    AliMUONRawStreamTriggerHP rawStreamTrig(rawReader);
+    while (rawStreamTrig.NextDDL()) 
+    {
+      Bool_t scalerEvent =  rawReader->GetDataHeader()->GetL1TriggerMessage() & 0x1;
+
+      Bool_t fillScalerHistos = ( scalerEvent && 
+                                 ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) );
+
+      if ( scalerEvent != fillScalerHistos ) {
+       Int_t esindex = AliRecoParam::AConvert(CurrentEventSpecie());
+       AliWarning(Form("Scaler event found but event specie is %s. Scaler histos will not be filled", AliRecoParam::GetEventSpecieName(esindex)));
+      }
+
+      darcHeader = rawStreamTrig.GetHeaders();
+
+      if (darcHeader->GetGlobalFlag()){
+       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);
+       }
+
+       //Get Global datas
+       for (Int_t bit=1; bit<7; bit++){
+         fTriggerOutputGlobalData[bit-1]=Int_t(((darcHeader->GetGlobalOutput())>>bit)&1);
+         if ( fillScalerHistos && !fTriggerOutputGlobalData[bit-1] )
+           nDeadGlobal++;
+       }
+       for (Int_t Bit=0; Bit<32; Bit++){
+         fTriggerInputGlobalDataLPt[Bit/4][Bit%4]=((darcHeader->GetGlobalInput(0)>>Bit)&1);
+         fTriggerInputGlobalDataLPt[Bit/4+8][Bit%4]=((darcHeader->GetGlobalInput(1)>>Bit)&1);
+         fTriggerInputGlobalDataHPt[Bit/4][Bit%4]=((darcHeader->GetGlobalInput(2)>>Bit)&1);
+         fTriggerInputGlobalDataHPt[Bit/4+8][Bit%4]=((darcHeader->GetGlobalInput(3)>>Bit)&1);
+       }
+
+       globaltemp[0]=darcHeader->GetGlobalInput(0);
+       globaltemp[1]=darcHeader->GetGlobalInput(1);
+       globaltemp[2]=darcHeader->GetGlobalInput(2);
+       globaltemp[3]=darcHeader->GetGlobalInput(3);
+      }
+
+      Int_t nReg = rawStreamTrig.GetRegionalHeaderCount();
+
+      for(Int_t iReg = 0; iReg < nReg ;iReg++)
+      {   //reg loop
+
+         Int_t regId=rawStreamTrig.GetDDL()*8+iReg;
+
+       // crate info  
+         AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->GetTriggerCrate(rawStreamTrig.GetDDL(), iReg);
+
+         regHeader =  rawStreamTrig.GetRegionalHeader(iReg);
+
+       //Get regional outputs -> not checked, hardware read-out doesn't work
+       fTriggerOutputRegionalData[regId]=Int_t(regHeader->GetOutput());
+       // if ( ! fTriggerOutputRegionalData[regId] )
+       // nDeadRegional++;
+       Int_t nBoardsInReg = 0; // Not necessary when regional output will work
+
+       // loop over local structures
+       Int_t nLocal = regHeader->GetLocalStructCount();
+
+       for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) 
+       {
+           
+           localStruct = regHeader->GetLocalStruct(iLocal);
+
+         // if card exist
+         if (!localStruct) continue;
+          
+         loCircuit = crate->GetLocalBoardId(localStruct->GetId());
+
+         if ( !loCircuit ) continue; // empty slot
+
+         AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
+
+         nBoardsInReg++; // Not necessary when regional output will work
+         countAllBoards++;
+
+         // skip copy cards
+         if( !localBoard->IsNotified()) 
+           continue;
+
+         countNotifiedBoards++;  
+
+         TArrayS xyPattern[2];   
+         localStruct->GetXPattern(xyPattern[0]);
+         localStruct->GetYPattern(xyPattern[1]);
+         fDigitMaker->TriggerDigits(loCircuit, xyPattern, digitStore);
+         if ( fillScalerHistos ) // Compute total number of strips
+           fDigitMaker->TriggerDigits(loCircuit, xyPatternAll, digitStoreAll);
+
+         Int_t cathode = localStruct->GetComptXY()%2;
+
+         //Get electronic Decisions from data
+
+         //Get regional inputs -> not checked, hardware read-out doesn't work
+         fTriggerInputRegionalDataLPt[0][loCircuit]=Int_t(((regHeader->GetInput(0))>>(2*iLocal))&1);
+         fTriggerInputRegionalDataLPt[1][loCircuit]=Int_t(((regHeader->GetInput(1))>>((2*iLocal)+1))&1);
+
+         //Get local in/outputs
+         if (Int_t(localStruct->GetDec())!=0){
+             fTriggerOutputLocalDataTriggerDec[loCircuit]++;
+             ((TH1F*)GetRawsData(kTriggeredBoards))->Fill(loCircuit);
+         }
+         else if ( fillScalerHistos ){
+           nDeadLocal++;
+         }
+         
+         fTriggerOutputLocalDataLPtDec[0][loCircuit]=((localStruct->GetLpt())&1);
+         fTriggerOutputLocalDataLPtDec[1][loCircuit]=((localStruct->GetLpt()>>1)&1);
+         fTriggerOutputLocalDataHPtDec[0][loCircuit]=((localStruct->GetHpt())&1);
+         fTriggerOutputLocalDataHPtDec[1][loCircuit]=((localStruct->GetHpt()>>1)&1);
+         fTriggerOutputLocalDataXPos[loCircuit]=Int_t(localStruct->GetXPos());
+         fTriggerOutputLocalDataYPos[loCircuit]=Int_t(localStruct->GetYPos());
+         fTriggerOutputLocalDataDev[loCircuit]=Int_t((localStruct->GetXDev())*(pow(-1.0,(localStruct->GetSXDev()))));
+         fTriggerOutputLocalDataTrigY[loCircuit]=Int_t(localStruct->GetTrigY());
+         
+         UShort_t x1  = (Int_t)localStruct->GetX1();
+         UShort_t x2  = (Int_t)localStruct->GetX2();
+         UShort_t x3  = (Int_t)localStruct->GetX3();
+         UShort_t x4  = (Int_t)localStruct->GetX4();
+
+         UShort_t y1  = (Int_t)localStruct->GetY1();
+         UShort_t y2  = (Int_t)localStruct->GetY2();
+         UShort_t y3  = (Int_t)localStruct->GetY3();
+         UShort_t y4  = (Int_t)localStruct->GetY4();
+
+         // loop over strips
+         for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
+
+             fTriggerPatternX1[loCircuit][ibitxy]=Int_t((x1>>ibitxy)&1);
+             fTriggerPatternX2[loCircuit][ibitxy]=Int_t((x2>>ibitxy)&1);
+             fTriggerPatternX3[loCircuit][ibitxy]=Int_t((x3>>ibitxy)&1);
+             fTriggerPatternX4[loCircuit][ibitxy]=Int_t((x4>>ibitxy)&1);
+             
+             fTriggerPatternY1[loCircuit][ibitxy]=Int_t((y1>>ibitxy)&1);
+             fTriggerPatternY2[loCircuit][ibitxy]=Int_t((y2>>ibitxy)&1);
+             fTriggerPatternY3[loCircuit][ibitxy]=Int_t((y3>>ibitxy)&1);
+             fTriggerPatternY4[loCircuit][ibitxy]=Int_t((y4>>ibitxy)&1);
+             
+             if ( fillScalerHistos ) {
+                 if (ibitxy==0){
+                     AliDebug(AliQAv1::GetQADebugLevel(),"Filling trigger scalers");
+                 }
+
+                 UShort_t scalerVal[4] = {
+                   localStruct->GetXY1(ibitxy),
+                   localStruct->GetXY2(ibitxy),
+                   localStruct->GetXY3(ibitxy),
+                   localStruct->GetXY4(ibitxy)
+                 };
+
+                 for(Int_t ich=0; ich<AliMpConstants::NofTriggerChambers(); ich++){
+                   if ( scalerVal[ich] > 0 )
+                     ((TH2F*)GetRawsData(kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + ich))
+                       ->Fill(loCircuit, ibitxy, 2*(Float_t)scalerVal[ich]);
+
+                   if ( scalerVal[ich] >= maxNcounts )
+                     nNoisyStrips++;
+                 } // loop on chamber
+             } // scaler event
+         } // loop on strips
+       } // iLocal
+       if ( nBoardsInReg == 0 )
+         nDeadRegional++; // Not necessary when regional output will work
+      } // iReg
+
+      Float_t readoutErrors[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++){
+       if ( readoutErrors[ibin] > 0 )
+         ((TH1F*)GetRawsData(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)(nStripsTot - digitStore.GetSize())) / ((Float_t)nStripsTot),
+       //(Float_t)nDeadLocal / ((Float_t)countNotifiedBoards),
+       (Float_t)nDeadLocal / ((Float_t)AliMUONConstants::NTriggerCircuit()),
+       (Float_t)nDeadRegional / 16.,
+       (Float_t)nDeadGlobal / 6., // Number of bits of global response
+       (Float_t)nNoisyStrips / ((Float_t)nStripsTot),
+      };
+
+      for(Int_t ibin = 0; ibin < kNtrigCalibSummaryBins; ibin++){
+       if ( fraction[ibin] > 0. )
+         ((TH1F*)GetRawsData(kTriggerCalibSummary))->Fill(ibin, fraction[ibin]);
+      }
+    }
+
+  fTriggerProcessor->Digits2Trigger(digitStore,triggerStore);
+
+  TIter next(triggerStore.CreateLocalIterator());
+  AliMUONLocalTrigger *localTrigger;
+
+  while ( ( localTrigger = static_cast<AliMUONLocalTrigger*>(next()) ) )
+  {
+    
+      //... extract information
+      loCircuit = localTrigger->LoCircuit();
+
+      AliMpLocalBoard* localBoardMp = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit);  // get local board objectfor switch value
+      if (localTrigger->GetLoDecision() != 0){
+         fTriggerOutputLocalRecTriggerDec[loCircuit]++;
+      }
+      
+      fTriggerOutputLocalRecLPtDec[0][loCircuit]=Int_t(localTrigger->LoLpt() & 1);
+      fTriggerOutputLocalRecLPtDec[1][loCircuit]=Int_t((localTrigger->LoLpt()>>1) & 1);
+      fTriggerOutputLocalRecHPtDec[0][loCircuit]=Int_t(localTrigger->LoHpt() & 1);
+      fTriggerOutputLocalRecHPtDec[1][loCircuit]=Int_t((localTrigger->LoHpt()>>1) & 1);
+      fTriggerOutputLocalRecXPos[loCircuit]=localTrigger->LoStripX();
+      fTriggerOutputLocalRecYPos[loCircuit]=localTrigger->LoStripY();
+      fTriggerOutputLocalRecTrigY[loCircuit]=localTrigger->LoTrigY();
+      fTriggerOutputLocalRecDev[loCircuit]=Int_t(localTrigger->LoDev()*(pow(-1.,localTrigger->LoSdev())));
+
+      Bool_t firstFillYCopy=kTRUE;
+
+      for (int bit=0; bit<16; bit++){
+         if (fTriggerPatternY1[loCircuit][bit]!=((localTrigger->GetY1Pattern()>>bit) & 1))
+         {
+             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
+             if (firstFillYCopy){
+                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
+                 ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalYCopy, 1./192.);
+                 firstFillYCopy=kFALSE;
+             }
+         }
+         if (fTriggerPatternY2[loCircuit][bit]!=((localTrigger->GetY2Pattern()>>bit) & 1))
+         {
+             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
+             if (firstFillYCopy){
+                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
+                 ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalYCopy, 1./192.);
+                 firstFillYCopy=kFALSE;
+             }
+         }
+         if (fTriggerPatternY3[loCircuit][bit]!=((localTrigger->GetY3Pattern()>>bit) & 1))
+         {
+             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
+             if (localBoardMp->GetSwitch(4)) fTriggerErrorLocalYCopy[loCircuit-1]=kTRUE;
+             if (localBoardMp->GetSwitch(3)) fTriggerErrorLocalYCopy[loCircuit+1]=kTRUE;
+             if (firstFillYCopy){
+                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
+                 ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalYCopy, 1./192.);
+                 firstFillYCopy=kFALSE;
+             }
+         }
+         if (fTriggerPatternY4[loCircuit][bit]!=((localTrigger->GetY4Pattern()>>bit) & 1))
+         {
+             fTriggerErrorLocalYCopy[loCircuit]=kTRUE;
+             if (localBoardMp->GetSwitch(4)) fTriggerErrorLocalYCopy[loCircuit-1]=kTRUE;
+             if (localBoardMp->GetSwitch(3)) fTriggerErrorLocalYCopy[loCircuit+1]=kTRUE;
+             if (firstFillYCopy){
+                 ((TH1F*)GetRawsData(kTriggerErrorLocalYCopy))->Fill(loCircuit);
+                 ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalYCopy, 1./192.);
+                 firstFillYCopy=kFALSE;
+             }
+         }
+      }
+  }
+
+    //Reconstruct Global decision from Global inputs
+    for (Int_t bit=0; bit<4; bit++){
+       for (Int_t i=0; i<32; i=i+4){
+           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>i)&1)*pow(2.0,i+1));
+           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+1))&1)*pow(2.0,i));
+           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+2))&1)*pow(2.0,i+2));
+           fgitmp[bit]+=UInt_t(((globaltemp[bit]>>(i+3))&1)*pow(2.0,i+3));
+           }
+    }
+    RawTriggerInGlobal2OutGlobal();
+    for (Int_t bit=0; bit<6; bit++){
+       fTriggerOutputGlobalRecFromGlobalInput[bit]=fgotmp[bit];
+    }
+
+    // Compare data and reconstructed decisions and fill histos
+    RawTriggerMatchOutLocal();
+    RawTriggerMatchOutLocalInRegional(); // Not tested, hardware read-out doesn't work
+    RawTriggerMatchOutGlobalFromInGlobal();
+}
+
+//__________________________________________________________________
+void AliMUONTriggerQADataMakerRec::MakeDigits(TTree* digitsTree)         
+{
+  /// makes data from Digits
+
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+
+  if (!fDigitStore)
+    fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
+
+  fDigitStore->Clear();
+  fDigitStore->Connect(*digitsTree, false);
+  digitsTree->GetEvent(0);
+  
+  TIter next(fDigitStore->CreateIterator());
+  
+  AliMUONVDigit* dig = 0x0;
+  
+  while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
+    {
+    GetDigitsData(0)->Fill(dig->DetElemId());
+    GetDigitsData(1)->Fill(dig->ADC());
+    }
+}
+
+//____________________________________________________________________________
+void AliMUONTriggerQADataMakerRec::MakeRecPoints(TTree* /*clustersTree*/)
+{
+  // Do nothing in case of calibration event
+  if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
+       
+  GetRecPointsData(kNAnalyzedEvents)->Fill(1.);
+}
+
+//____________________________________________________________________________
+void AliMUONTriggerQADataMakerRec::MakeESDs(AliESDEvent* /*esd*/)
+{  
+}
+
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::DisplayTriggerInfo()
+{
+  //
+  /// Display trigger information in a user-friendly way:
+  /// from local board and strip numbers to their position on chambers
+  //
+
+  AliMUONTriggerDisplay triggerDisplay;
+  
+  TH2F* histoStrips=0x0;
+  TH2F* histoDisplayStrips=0x0;
+  if ( GetRawsData(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);
+
+           if(histoStrips->GetEntries()==0) continue; // No events found => No need to display
+
+           histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
+
+           triggerDisplay.FillDisplayHistogram(histoStrips, histoDisplayStrips,
+                                               AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, displayOption);
+
+           Float_t scaleValue = ((TH1F*)GetRawsData(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);
+    triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
+    Float_t scaleValue = GetRawsData(kRawNAnalyzedEvents)->GetBinContent(1);
+    if(scaleValue>0.) histoDisplayBoards->Scale(1./scaleValue);
+  }
+}
+
+
+//_____________________________________________________________________________
+Bool_t 
+AliMUONTriggerQADataMakerRec::FillTriggerDCSHistos()
+{
+  /// Get HV and currents values for one trigger chamber
+  
+  AliCodeTimerAuto("",0);
+
+  TMap* triggerDcsMap = fCalibrationData->TriggerDCS();
+
+  if ( !triggerDcsMap ) 
+  {
+    AliError("Cannot fill DCS histos, as triggerDcsMap is NULL");
+    return kFALSE;
+  }
+
+  const Double_t kMaxDelay = 3.;
+  const Double_t kMaxVariation = 25.; // Volts
+  const Int_t kDefaultNpoints = 200;
+  Double_t scaleFactor = 1./1000.;
+
+  Bool_t error = kFALSE;
+  Bool_t expert   = kTRUE;
+  Bool_t image    = kTRUE;
+
+  AliMpDEIterator deIt;
+  
+  AliMpDCSNamer triggerDcsNamer("TRIGGER");
+
+  TH2F* currHisto = 0x0;
+  Int_t histoIndex = 0;
+  TString histoName, histoTitle;
+
+  TArrayD axisSlat(18+1);
+  for(Int_t islat=0; islat<=18; islat++){
+    axisSlat[islat] = -0.5 + (Float_t)islat;
+  }
+
+  TArrayD axisTimeAux[4], axisTime[4], axisTimeDE(kDefaultNpoints);
+  TArrayI index[4], npoints(4);
+
+  // Build axis of times
+  npoints.Reset();
+  for(Int_t ich=0; ich<4; ich++){
+    axisTimeAux[ich].Set(kDefaultNpoints);
+    axisTimeAux[ich].Reset(-1.);
+  }
+
+  deIt.First();
+  while ( !deIt.IsDone() )
+  {
+    Int_t detElemId = deIt.CurrentDEId();
+    TObjArray* values = GetDCSValues(AliMpDCSNamer::kDCSHV, detElemId, triggerDcsMap, triggerDcsNamer);
+
+    if ( values ) {
+
+      AliDebug(AliQAv1::GetQADebugLevel(), Form("DetElemId %i", detElemId));
+
+      axisTimeDE.Reset(-1.);
+
+      TIter next(values);
+      AliDCSValue* val = 0x0;
+      Double_t previousVal = -999.;
+      Int_t npointsde = 0;
+      while ( ( val = static_cast<AliDCSValue*>(next()) ) )
+      {
+       if ( npointsde + 1 > kDefaultNpoints ) {
+         axisTimeDE.Set(npointsde + 1);
+       }
+
+       Double_t currVal = val->GetFloat();
+       Double_t currTime = (Double_t)val->GetTimeStamp();
+       if (npointsde > 0 ){
+         if ( TMath::Abs( currVal - previousVal ) < kMaxVariation && 
+              TMath::Abs( currTime - axisTimeDE[npointsde-1] ) < 40 ) continue;
+       }
+
+       axisTimeDE[npointsde] = currTime;
+       previousVal = currVal;
+       npointsde++;
+      } // loop on values
+
+      //      AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding DE point %2i  (%2i)  %.2f  (%i)\n", previousBin, npointsde, axisTimeDE[previousBin], nTimesPerBin));
+
+      Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
+      Int_t ich = iChamber - AliMpConstants::NofTrackingChambers();
+
+      for(Int_t ipde=0; ipde<npointsde; ipde++){
+
+       if ( npoints[ich] + 1 > kDefaultNpoints ) {
+         axisTimeAux[ich].Set(npoints[ich] + 1);
+       }
+
+       for(Int_t ipoint = 0; ipoint < axisTimeAux[ich].GetSize(); ipoint++){
+         if (axisTimeAux[ich][ipoint] < 0.) {
+           axisTimeAux[ich][ipoint] = axisTimeDE[ipde];
+           npoints[ich]++;
+           AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding point %2i  %.0f\n", ipoint, axisTimeAux[ich][ipoint]));
+           break;
+         }
+         if ( TMath::Abs( axisTimeDE[ipde] - axisTimeAux[ich][ipoint]) < kMaxDelay ) {
+           axisTimeAux[ich][ipoint] = TMath::Min(axisTimeAux[ich][ipoint], axisTimeDE[ipde]);
+           break;
+         }
+       } // loop on points
+      } // loop on reorganized values
+
+    } // if ( values ) 
+    deIt.Next();
+  } // loop on DetElemId
+
+  for(Int_t ich=0; ich<4; ich++){
+    axisTimeAux[ich].Set(npoints[ich]);
+    index[ich].Set(npoints[ich]);
+    TMath::Sort(npoints[ich], axisTimeAux[ich].GetArray(), index[ich].GetArray(), kFALSE);
+
+    axisTime[ich].Set(npoints[ich]+1);
+    for(Int_t ipoint = 0; ipoint < axisTimeAux[ich].GetSize(); ipoint++){
+      axisTime[ich][ipoint] = axisTimeAux[ich][index[ich][ipoint]];
+    }
+    Double_t minStartEndWidth = 0.1 * (axisTime[ich][npoints[ich]-1] - axisTime[ich][0]);
+    axisTime[ich][npoints[ich]] = axisTime[ich][npoints[ich]-1] + minStartEndWidth;
+    if ( npoints[ich] >= 1)
+      if ( axisTime[ich][1] - axisTime[ich][0] < minStartEndWidth )
+       axisTime[ich][0] = axisTime[ich][1] - minStartEndWidth;
+  }
+
+
+  // Loop again on detection elements: create and fill histos
+  deIt.First();
+  while ( !deIt.IsDone() )
+  {
+    Int_t detElemId = deIt.CurrentDEId();
+    TObjArray* values = GetDCSValues(AliMpDCSNamer::kDCSHV, detElemId, triggerDcsMap, triggerDcsNamer);
+
+    if ( values ) {
+      Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
+      Int_t ich = iChamber - AliMpConstants::NofTrackingChambers();
+
+      histoIndex = kTriggerRPChv + ich;
+      histoName = Form("hRPCHVChamber%i", 11+ich);
+      histoTitle = Form("Chamber %i: RPC HV (kV)", 11+ich);
+
+      currHisto = (TH2F*)GetRecPointsData(histoIndex);
+
+      if(!currHisto){
+       currHisto  = new TH2F(histoName.Data(), histoTitle.Data(),
+                             npoints[ich], axisTime[ich].GetArray(),
+                             18, axisSlat.GetArray());
+       currHisto->GetXaxis()->SetTitle("Time");
+       currHisto->GetXaxis()->SetTimeDisplay(1);
+       //currHisto->GetXaxis()->SetTimeFormat("%d%b%y %H:%M:%S");
+       currHisto->GetXaxis()->SetLabelSize(0.03);
+       currHisto->GetYaxis()->SetTitle("RPC");
+       currHisto->SetOption("TEXT45COLZ");
+       Add2RecPointsList(currHisto, histoIndex, expert, !image);
+      }
+
+      Int_t slat = detElemId%100;
+      Int_t slatBin = currHisto->GetYaxis()->FindBin(slat);
+
+      TIter next(values);
+      AliDCSValue* val = 0x0;
+      Double_t sumValuesPerBin = 0.;
+      Int_t nValuesPerBin = 0;
+      Int_t previousBin = -1;
+      Double_t previousTime = -1., previousVal = -999., sumVal = 0., sumTime = 0.;
+      Bool_t isTrip = kFALSE;
+      Int_t nPointsForSlope = 0;
+      while ( ( val = static_cast<AliDCSValue*>(next()) ) )
+      {
+       Double_t currTime = (Double_t)val->GetTimeStamp();
+       Int_t currentBin = currHisto->GetXaxis()->FindBin(currTime+0.5);
+       Double_t currVal = val->GetFloat();
+       Double_t deltaVal = currVal - previousVal;
+       Bool_t isRepeated = kFALSE;
+       if ( previousTime > 0 ){
+         isRepeated = ( TMath::Abs( currVal - previousVal ) < kMaxVariation && 
+                        TMath::Abs( currTime - previousTime ) < 40 );
+
+         // Check for trips
+         sumTime += currTime - previousTime;
+         sumVal += deltaVal;
+         nPointsForSlope++;
+
+         if ( sumTime > 0. && nPointsForSlope >= 3 ){
+           Double_t slope = sumVal / sumTime;
+           if ( slope < -10. ) // going down of more than 10V/s
+             isTrip = kTRUE;
+         }
+
+         if ( deltaVal * sumVal < 0. ) {
+           sumTime = 0.;
+           sumVal = 0.;
+           nPointsForSlope = 0;
+         }
+       }
+
+       if ( ! isRepeated ) {
+         if ( currentBin != previousBin ) {
+           if ( previousBin >= 0 ) {
+             currHisto->SetBinContent(previousBin, slatBin, scaleFactor*sumValuesPerBin/((Double_t)nValuesPerBin));
+             sumValuesPerBin = 0.;
+             nValuesPerBin = 0;
+           }
+           previousBin = currentBin;
+         }
+       }
+         
+       sumValuesPerBin += currVal;
+       nValuesPerBin++;
+       previousTime = currTime;
+       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 ( values ) 
+    deIt.Next();
+  } // loop on detElem
+  return error;
+}
+
+
+//____________________________________________________________________________ 
+TObjArray* 
+AliMUONTriggerQADataMakerRec::GetDCSValues(Int_t iMeas, Int_t detElemId,
+                                          TMap* triggerDcsMap, AliMpDCSNamer& triggerDcsNamer)
+{
+  if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger) return 0x0;
+
+  TString currAlias = triggerDcsNamer.DCSChannelName(detElemId, 0, iMeas);
+
+  TPair* triggerDcsPair = static_cast<TPair*>(triggerDcsMap->FindObject(currAlias.Data()));
+
+  if (!triggerDcsPair)
+  {
+    printf(Form("Did not find expected alias (%s) for DE %d\n",
+               currAlias.Data(),detElemId));
+    return 0x0;
+  }
+
+  TObjArray* values = static_cast<TObjArray*>(triggerDcsPair->Value());
+  if (!values)
+  {
+    printf(Form("Could not get values for alias %s\n",currAlias.Data()));
+    return 0x0;
+  }
+
+  return values;
+}
+
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::RawTriggerInGlobal2OutGlobal()
+{
+  //
+  /// Reconstruct Global Trigger decision using Global Inputs
+  //
+
+    AliMUONGlobalCrateConfig* globalConfig = fCalibrationData->GlobalTriggerCrateConfig();
+
+    AliMUONGlobalTriggerBoard globalTriggerBoard;
+    globalTriggerBoard.Reset();
+    for (Int_t i = 0; i < 4; i++) {
+       globalTriggerBoard.Mask(i,globalConfig->GetGlobalMask(i));
+    }
+
+
+    UShort_t regional[16];
+
+    for (Int_t iReg = 0; iReg < 16; iReg++) {
+      regional[iReg] = 0;
+      if (iReg < 8) {    // right
+       // Lpt
+       regional[iReg] |=  (fgitmp[0] >> (4*iReg))     & 0xF;
+       // Hpt
+       regional[iReg] |= ((fgitmp[2] >> (4*iReg))     & 0xF) << 4;
+      } else {           // left
+       // Lpt
+       regional[iReg] |=  (fgitmp[1] >> (4*(iReg-8))) & 0xF;
+       // Hpt
+       regional[iReg] |= ((fgitmp[3] >> (4*(iReg-8))) & 0xF) << 4;
+      }
+    }
+    globalTriggerBoard.SetRegionalResponse(regional);
+    globalTriggerBoard.Response();
+
+    for (Int_t bit=1; bit<7; bit++){
+       fgotmp[bit-1]=Int_t((globalTriggerBoard.GetResponse())>>bit&1);
+    }
+}
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocal()
+{
+  //
+  /// Match data and reconstructed Local Trigger decision
+  //
+
+    Bool_t firstFillXPosDev=kTRUE;
+    Bool_t firstFillYPosTrigY=kTRUE;
+    Bool_t firstFillLUT=kTRUE;
+
+    for (int localId=1;localId<235;localId++){
+       if(fTriggerOutputLocalDataTriggerDec[localId]!=fTriggerOutputLocalRecTriggerDec[localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalTriggerDec))->Fill(localId);
+       }
+       if(fTriggerOutputLocalDataTrigY[localId]!=fTriggerOutputLocalRecTrigY[localId]){
+           if(fTriggerErrorLocalYCopy[localId]) continue;
+           ((TH1F*)GetRawsData(kTriggerErrorLocalTrigY))->Fill(localId);
+            if (firstFillYPosTrigY){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalY);
+                firstFillYPosTrigY=kFALSE;
+            }
+       }
+
+       if(fTriggerOutputLocalDataYPos[localId]!=fTriggerOutputLocalRecYPos[localId]){
+           if(fTriggerErrorLocalYCopy[localId]) continue;
+           ((TH1F*)GetRawsData(kTriggerErrorLocalYPos))->Fill(localId);
+           if (firstFillYPosTrigY){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalY);
+                firstFillYPosTrigY=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataXPos[localId]!=fTriggerOutputLocalRecXPos[localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalXPos))->Fill(localId);
+            if (firstFillXPosDev){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalX);
+                firstFillXPosDev=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataDev[localId]!=fTriggerOutputLocalRecDev[localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalDev))->Fill(localId);
+            if (firstFillXPosDev){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalX);
+                firstFillXPosDev=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataLPtDec[0][localId]!=fTriggerOutputLocalRecLPtDec[0][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalLPtLSB))->Fill(localId);
+            if (firstFillLUT){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalLUT);
+                firstFillLUT=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataLPtDec[1][localId]!=fTriggerOutputLocalRecLPtDec[1][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalLPtMSB))->Fill(localId);
+            if (firstFillLUT){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalLUT);
+                firstFillLUT=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataHPtDec[0][localId]!=fTriggerOutputLocalRecHPtDec[0][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalHPtLSB))->Fill(localId);
+            if (firstFillLUT){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalLUT);
+                firstFillLUT=kFALSE;
+            }
+       }
+       if(fTriggerOutputLocalDataHPtDec[1][localId]!=fTriggerOutputLocalRecHPtDec[1][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocalHPtMSB))->Fill(localId);
+            if (firstFillLUT){
+                ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoLocalLUT);
+                firstFillLUT=kFALSE;
+            }
+       }
+    } // loop over Local Boards
+}
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutLocalInRegional()
+{
+  //
+  /// Match Local outputs and Regional inputs
+  /// Not tested, hardware read-out doesn't work
+  //
+
+    for (int localId=1;localId<235;localId++){
+       if(fTriggerOutputLocalDataLPtDec[0][localId]!=fTriggerInputRegionalDataLPt[0][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalLPtLSB))->Fill(localId);
+       }
+       if(fTriggerOutputLocalDataLPtDec[1][localId]!=fTriggerInputRegionalDataLPt[1][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalLPtMSB))->Fill(localId);
+       }
+       if(fTriggerOutputLocalDataHPtDec[0][localId]!=fTriggerInputRegionalDataHPt[0][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalHPtLSB))->Fill(localId);
+       }
+       if(fTriggerOutputLocalDataHPtDec[1][localId]!=fTriggerInputRegionalDataHPt[1][localId]){
+           ((TH1F*)GetRawsData(kTriggerErrorLocal2RegionalHPtMSB))->Fill(localId);
+       }
+    }
+
+}
+
+//____________________________________________________________________________ 
+void AliMUONTriggerQADataMakerRec::RawTriggerMatchOutGlobalFromInGlobal()
+{
+  //
+  /// Match data and reconstructed Global Trigger decision for a reconstruction from Global inputs
+  //
+
+  Bool_t firstFill=kTRUE;
+
+  for (int bit=0;bit<6;bit++){
+    if(fTriggerOutputGlobalData[bit]!=0){
+      ((TH1F*)GetRawsData(kTriggerGlobalOutput))->Fill(5-bit);
+    }
+    if(fTriggerOutputGlobalData[bit]!=fTriggerOutputGlobalRecFromGlobalInput[bit]){
+      ((TH1F*)GetRawsData(kTriggerErrorOutGlobalFromInGlobal))->Fill(5-bit);
+      if (firstFill){
+       ((TH1F*)GetRawsData(kTriggerError))->Fill(kAlgoGlobalFromGlobal);
+       firstFill=kFALSE;
+      }
+    }
+  }
+}
diff --git a/MUON/AliMUONTriggerQADataMakerRec.h b/MUON/AliMUONTriggerQADataMakerRec.h
new file mode 100644 (file)
index 0000000..9637450
--- /dev/null
@@ -0,0 +1,191 @@
+#ifndef ALIMUONTRIGGERQADATAMAKERREC_H
+#define ALIMUONTRIGGERQADATAMAKERREC_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec
+/// \class AliMUONTriggerQADataMakerRec
+/// \brief MUON Quality assurance data maker for MTR
+///
+
+// --- AliRoot header files ---
+#include "AliMUONVQADataMakerRec.h"
+
+class AliMUONCalibrationData;
+class AliMUONDigitMaker;
+class AliMUONVClusterStore;
+class AliMUONTriggerElectronics;
+class AliMUONVDigitStore;
+class TObjectArray;
+class TMap;
+class AliMpDCSNamer;
+
+class AliMUONTriggerQADataMakerRec: public AliMUONVQADataMakerRec {
+
+public:
+  AliMUONTriggerQADataMakerRec(AliQADataMakerRec* master);         
+  virtual ~AliMUONTriggerQADataMakerRec();
+  
+  virtual void InitRaws(); 
+  virtual void InitRecPoints(); 
+  virtual void InitDigits(); 
+  virtual void InitESDs(); 
+  
+  void EndOfDetectorCycleRaws(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleESDs(Int_t specie, TObjArray** list);
+  void EndOfDetectorCycleDigits(Int_t , TObjArray** ) {}
+    
+  virtual void MakeRaws(AliRawReader* rawReader); 
+  
+  virtual void MakeDigits(TTree* dig); 
+  virtual void MakeRecPoints(TTree* recpo); 
+  virtual void MakeESDs(AliESDEvent* esd) ;
+  
+public:
+
+  /// Raw histograms indices
+  
+  enum ERaw { 
+    kTriggerScalers           = 22, ///< Trigger scalers histogram per plane index
+    kTriggerScalersDisplay    = 30, ///< Trigger scalers display histogram per plane index
+    kTriggerScalersTime       = 38, ///< Trigger scalers acquisition time index
+    kTriggerCalibSummary      = 39, ///< Summary of responding strips/boards and noisy strips 
+    kTriggeredBoards          = 40,  ///< Triggered boards histogram index
+    kTriggerBoardsDisplay     = 41, ///< Triggered boards display histogram index
+    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
+    kTriggerErrorLocal2RegionalLPtLSB = 58,  ///< Local to Regional: Number of LPt LSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalLPtMSB = 59,  ///< Local to Regional: Number of LPt MSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalHPtLSB = 60,  ///< Local to Regional: Number of HPt LSB error vs Local Board Id
+    kTriggerErrorLocal2RegionalHPtMSB = 61,  ///< Local to Regional: Number of HPt MSB error vs Local Board Id
+    kTriggerErrorOutGlobalFromInGlobal = 62,  ///< Global board: Number of error vs output bit 
+    kTriggerError = 63,  ///< percentage of error for each trigger decision level (Local, Reg->Local, Reg, Reg->Glob, Global)
+    kTriggerErrorLocalTrigY = 64,  ///< Local board: Number of TrigY Error vs Local Board Id
+    kTriggerErrorLocalYCopy = 65,  ///< Local board: Number of Y Copy Error vs Local Board Id
+
+    kRawNAnalyzedEvents = 66, ///< Number of analyzed events per event specie
+    kTriggerReadOutErrors = 67, ///< Number of read-out errors
+    kTriggerGlobalOutput = 68 //< Histo including Global outputs and Global algo errors
+  };
+         
+  /// 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:
+
+  AliMUONTriggerQADataMakerRec(const AliMUONTriggerQADataMakerRec& qadm);   
+  AliMUONTriggerQADataMakerRec& operator=(const AliMUONTriggerQADataMakerRec& qadm);
+
+  void DisplayTriggerInfo();
+  Bool_t FillTriggerDCSHistos();
+  TObjArray* GetDCSValues(Int_t iMeas, Int_t detElemId,
+                         TMap* triggerDcsMap, AliMpDCSNamer& triggerDcsNamer);
+  void RawTriggerInRegional2OutRegional();
+  void RawTriggerInGlobal2OutGlobal();
+  void RawTriggerMatchOutLocal();
+  void RawTriggerMatchOutLocalInRegional();
+  void RawTriggerMatchOutGlobalFromInGlobal();
+       
+  Int_t fTriggerOutputLocalDataTriggerDec[235]; ///< Data Local Trigger decision for each active Local Board
+  Int_t fTriggerOutputLocalDataTrigY[235]; ///< Data Local Trigger Y decision for each active Local Board
+  Int_t fTriggerOutputLocalDataLPtDec[2][235]; ///< Data Local decision Low Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
+  Int_t fTriggerOutputLocalDataHPtDec[2][235]; ///< Data Local decision High Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
+  Int_t fTriggerOutputLocalDataXPos[235]; ///< Data Local XPos for each active Local Board
+  Int_t fTriggerOutputLocalDataYPos[235]; ///< Data Local YPos for each active Local Board
+  Int_t fTriggerOutputLocalDataDev[235]; ///< Data Local deviation for each active Local Board
+
+  Int_t fTriggerOutputLocalRecTriggerDec[235]; ///< Reconstructed Local Trigger decision for each active Local Board
+  Int_t fTriggerOutputLocalRecTrigY[235]; ///< Reconstructed Local Trigger Y decision for each active Local Board
+  Int_t fTriggerOutputLocalRecLPtDec[2][235]; ///< Reconstructed Local decision Low Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
+  Int_t fTriggerOutputLocalRecHPtDec[2][235]; ///< Reconstructed Local decision High Pt for each active Local Board (2 Bits -> 0:LSB, 1:MSB)
+  Int_t fTriggerOutputLocalRecXPos[235]; ///< Reconstructed Local XPos for each active Local Board
+  Int_t fTriggerOutputLocalRecYPos[235]; ///< Reconstructed Local YPos for each active Local Board
+  Int_t fTriggerOutputLocalRecDev[235]; ///< Reconstructed Local deviation for each active Local Board
+
+  Int_t fTriggerInputRegionalDataLPt[2][235]; ///< Data Regional Input LPt for each Local board
+  Int_t fTriggerInputRegionalDataHPt[2][235]; ///< Data Regional Input HPt for each Local board
+  Int_t fTriggerOutputRegionalData[16]; ///< Data Regional Trigger decision for each Regional Board (1R:0, 2R:1, ... , 1L:8, ...) -> 4 bits LPt, 4 bits HPt
+  Int_t fTriggerInputRegionalRecLPt[2][16][16]; ///< Reconstructed Regional Input LPt for each Regional Board ([bit][reg][loc]) (reg -> 1R:0, 2R:1, ... , 1L:8, ...)
+  Int_t fTriggerInputRegionalRecHPt[2][16][16]; ///< Reconstructed Regional Input HPt for each Regional Board ([bit][reg][loc]) (reg -> 1R:0, 2R:1, ... , 1L:8, ...)
+  Int_t fTriggerOutputRegionalRec[16]; ///< Reconstructed Regional Trigger decision for each Regional Board (8 Bits)
+
+  Int_t fTriggerInputGlobalDataLPt[16][4]; ///< Data Global inputs LPt (1R:0, 2R:1, ... , 1L:8, ...)
+  Int_t fTriggerInputGlobalDataHPt[16][4]; ///< Data Global inputs HPt (1R:0, 2R:1, ... , 1L:8, ...)
+  Int_t fTriggerOutputGlobalData[6]; ///< Data Global outputs
+  Int_t fTriggerOutputGlobalRecFromGlobalInput[6]; //< Reconstructed Global outputs from Global inputs
+  Int_t fTriggerOutputGlobalRecFromLocalInput[6]; //< Reconstructed Global outputs from Local inputs
+  Int_t fTriggerOutputGlobalRecFromLocalOutput[6]; //< Reconstructed Global outputs from Local outputs
+  Int_t fgitmp[4]; //< Tempory used to store Global inputs
+  Int_t fgotmp[6]; //< Tempory used to store Global outputs
+
+  Int_t fTriggerPatternX1[243][16]; ///< Local pattern X1
+  Int_t fTriggerPatternX2[243][16]; ///< Local pattern X2
+  Int_t fTriggerPatternX3[243][16]; ///< Local pattern X3
+  Int_t fTriggerPatternX4[243][16]; ///< Local pattern X4
+  Int_t fTriggerPatternY1[243][16]; ///< Local pattern Y1
+  Int_t fTriggerPatternY2[243][16]; ///< Local pattern Y2
+  Int_t fTriggerPatternY3[243][16]; ///< Local pattern Y3
+  Int_t fTriggerPatternY4[243][16]; ///< Local pattern Y4
+
+  Bool_t fTriggerErrorLocalYCopy[235]; ///< True if Y copy error for Local Board i
+  
+  AliMUONDigitMaker* fDigitMaker; //!< pointer to digit maker
+  AliMUONCalibrationData* fCalibrationData; //!< Used to load Local, Regional and Global masks
+  AliMUONTriggerElectronics* fTriggerProcessor; //!< trigger processore to re-compute response
+  AliMUONVDigitStore* fDigitStore; //!< pointer to digits store
+  
+  ClassDef(AliMUONTriggerQADataMakerRec,1)  // MUON Quality assurance data maker
+
+};
+
+#endif
diff --git a/MUON/AliMUONVQAChecker.cxx b/MUON/AliMUONVQAChecker.cxx
new file mode 100644 (file)
index 0000000..33808ef
--- /dev/null
@@ -0,0 +1,41 @@
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+
+// $Id$
+
+/// \class AliMUONVQAChecker
+/// 
+/// Interface for a MUON QA Checker, that both MCH and MTR will use
+///
+/// \author Laurent Aphecetche
+
+#include "AliMUONVQAChecker.h"
+
+/// \cond CLASSIMP
+ClassImp(AliMUONVQAChecker)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONVQAChecker::AliMUONVQAChecker() :  TObject()
+{
+  /// ctor
+}
+
+//_____________________________________________________________________________
+AliMUONVQAChecker::~AliMUONVQAChecker()
+{
+  /// Dtor
+}
+
diff --git a/MUON/AliMUONVQAChecker.h b/MUON/AliMUONVQAChecker.h
new file mode 100644 (file)
index 0000000..821ee29
--- /dev/null
@@ -0,0 +1,42 @@
+#ifndef ALIMUONVQACHECKER_H
+#define ALIMUONVQACHECKER_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec
+/// \class AliMUONVQAChecker
+/// \brief Base class for a MUON QA checker
+/// 
+/// \author Laurent Aphecetche
+
+#ifndef ROOT_TObject
+#  include "TObject.h"
+#endif
+
+class TObjArray;
+class AliMUONRecoParam;
+
+class AliMUONVQAChecker : public TObject
+{
+public:
+  enum ECheckCode {
+    kFatal=-1,
+    kError=0,
+    kWarning=1,
+    kInfo=2
+  };
+  
+  AliMUONVQAChecker();
+  virtual ~AliMUONVQAChecker();
+  
+  virtual ECheckCode * CheckRaws(TObjArray** list, AliMUONRecoParam* recoParam) = 0;
+  virtual ECheckCode * CheckRecPoints(TObjArray** list, AliMUONRecoParam* recoParam) = 0;
+  virtual ECheckCode * CheckESD(TObjArray** list, AliMUONRecoParam* recoParam) = 0;
+  
+  ClassDef(AliMUONVQAChecker,1) // Interface for a MUON QA checker
+};
+
+#endif
diff --git a/MUON/AliMUONVQADataMakerRec.cxx b/MUON/AliMUONVQADataMakerRec.cxx
new file mode 100644 (file)
index 0000000..e864736
--- /dev/null
@@ -0,0 +1,134 @@
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+
+// $Id$
+
+#include "AliMUONVQADataMakerRec.h"
+
+///
+/// \class AliMUONVQADataMakerRec
+/// 
+/// Interface for a MUON QADataMakerRec, common to MCH and MTR
+/// 
+/// \author Laurent Aphecetche
+
+/// \cond CLASSIMP
+ClassImp(AliMUONVQADataMakerRec)
+/// \endcond
+
+#include "AliQADataMakerRec.h"
+#include "AliMUONRecoParam.h"
+#include "AliCDBManager.h"
+
+//_____________________________________________________________________________
+AliMUONVQADataMakerRec::AliMUONVQADataMakerRec(AliQADataMakerRec* master)
+: fMaster(master)
+{
+  /// ctor
+}
+
+//_____________________________________________________________________________
+AliMUONVQADataMakerRec::~AliMUONVQADataMakerRec()
+{
+  /// dtor
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONVQADataMakerRec::Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert , const Bool_t image )
+{
+  /// fwd
+  return fMaster ? fMaster->Add2DigitsList(hist,index,expert,image) : -1;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONVQADataMakerRec::Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert , const Bool_t image )
+{
+  /// fwd
+  return fMaster ? fMaster->Add2ESDsList(hist,index,expert,image) : -1;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONVQADataMakerRec::Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert , const Bool_t image )
+{
+  /// fwd
+  return fMaster ? fMaster->Add2RecPointsList(hist,index,expert,image) : -1;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONVQADataMakerRec::Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert , const Bool_t image , const Bool_t saveForCorr )
+{
+  /// fwd
+  return fMaster ? fMaster->Add2RawsList(hist,index,expert,image,saveForCorr) : -1;
+}
+
+//_____________________________________________________________________________
+AliRecoParam::EventSpecie_t 
+AliMUONVQADataMakerRec::CurrentEventSpecie() const
+{
+  /// fwd
+  return fMaster ? fMaster->GetEventSpecie() : AliRecoParam::kDefault;
+}
+
+//_____________________________________________________________________________
+const AliMUONRecoParam* 
+AliMUONVQADataMakerRec::GetRecoParam() const
+{
+  /// fwd
+  return fMaster ? dynamic_cast<const AliMUONRecoParam*>(fMaster->GetRecoParam()) : 0x0;
+}
+
+//_____________________________________________________________________________
+TH1* 
+AliMUONVQADataMakerRec::GetDigitsData(Int_t index) const
+{
+  /// fwd
+  return fMaster ? fMaster->GetDigitsData(index) : 0x0;
+}
+
+//_____________________________________________________________________________
+TH1* 
+AliMUONVQADataMakerRec::GetESDsData(Int_t index) const
+{
+  /// fwd
+  return fMaster ? fMaster->GetESDsData(index) : 0x0;
+}
+
+//_____________________________________________________________________________
+TH1* 
+AliMUONVQADataMakerRec::GetRecPointsData(Int_t index) const
+{
+  /// fwd
+  return fMaster ? fMaster->GetRecPointsData(index) : 0x0;
+}
+
+//_____________________________________________________________________________
+TH1* 
+AliMUONVQADataMakerRec::GetRawsData(Int_t index) const
+{
+  /// fwd
+  return fMaster ? fMaster->GetRawsData(index) : 0x0;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONVQADataMakerRec::RunNumber() const
+{
+  /// fwd
+  return fMaster ? fMaster->GetRun() : -1;
+}
diff --git a/MUON/AliMUONVQADataMakerRec.h b/MUON/AliMUONVQADataMakerRec.h
new file mode 100644 (file)
index 0000000..fdd65f7
--- /dev/null
@@ -0,0 +1,79 @@
+#ifndef ALIMUONVQADATAMAKERREC_H
+#define ALIMUONVQADATAMAKERREC_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec
+/// \class AliMUONVQADataMakerRec
+/// \brief Interface for a MUON QADataMakerRec
+/// 
+/// author Laurent Aphecetche
+
+#ifndef ROOT_TObject
+#  include "TObject.h"
+#endif
+
+#ifndef ALIRECOPARAM_H
+#  include "AliRecoParam.h"
+#endif
+
+class AliESDEvent;
+class AliQADataMakerRec;
+class AliMUONRecoParam;
+class AliRawReader;
+class TH1;
+class TObjArray;
+class TTree;
+
+class AliMUONVQADataMakerRec : public TObject
+{
+public:
+  AliMUONVQADataMakerRec(AliQADataMakerRec* master);
+  virtual ~AliMUONVQADataMakerRec();
+  
+  virtual void InitDigits() = 0; 
+  virtual void InitESDs() = 0; 
+  virtual void InitRaws() = 0; 
+  virtual void InitRecPoints() = 0; 
+  
+  virtual void MakeRaws(AliRawReader* rawReader) = 0; 
+  virtual void MakeDigits(TTree* dig) = 0; 
+  virtual void MakeRecPoints(TTree* recpo) = 0;
+  virtual void MakeESDs(AliESDEvent* esd) = 0;
+  
+  virtual void EndOfDetectorCycleRaws(Int_t specie, TObjArray** list) = 0;
+  virtual void EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list) = 0;
+  virtual void EndOfDetectorCycleESDs(Int_t specie, TObjArray** list) = 0;
+  virtual void EndOfDetectorCycleDigits(Int_t specie, TObjArray** list) = 0;
+
+protected:
+
+  Int_t RunNumber() const;
+  
+  AliRecoParam::EventSpecie_t CurrentEventSpecie() const;
+  
+  const AliMUONRecoParam* GetRecoParam() const;
+  
+  TH1* GetDigitsData(Int_t index) const;
+  TH1* GetESDsData(Int_t index) const;
+  TH1* GetRecPointsData(Int_t index) const;
+  TH1* GetRawsData(Int_t index) const;
+                    
+  Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);  
+  Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);                      
+  Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);                 
+  Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE);  
+  
+private:
+  AliMUONVQADataMakerRec(const AliMUONVQADataMakerRec& rhs);
+  AliMUONVQADataMakerRec& operator=(const AliMUONVQADataMakerRec& rhs);
+  
+  AliQADataMakerRec* fMaster; ///< master to get access to its methods
+  
+  ClassDef(AliMUONVQADataMakerRec,1) // Interface for a MUON QADataMakerRec
+};
+
+#endif
index c73bc23..6ffbb79 100644 (file)
 #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 AliMUONVTrackerDataMaker+;
 #pragma link C++ class AliMUONTrackerDataMaker+;
index 83fff4a..8b3e065 100644 (file)
@@ -36,8 +36,14 @@ SRCS:= AliMUONReconstructor.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 \