ROOT logo
/**************************************************************************
 * 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 <Riostream.h>

// ROOT includes
#include "TH1F.h"
#include "TH2F.h"
#include "TCanvas.h"
#include "TROOT.h"
#include "TString.h"
#include "TObjArray.h"
#include "TMath.h"
#include "TFile.h"
#include "TRegexp.h"
#include "TMap.h"
#include "TList.h"
#include "TObjString.h"

// STEER includes
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliESDMuonCluster.h"
#include "AliESDInputHandler.h"
#include "AliESDVZERO.h"

// ANALYSIS includes
#include "AliAnalysisDataSlot.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisTaskMuonQA.h"
#include "AliCounterCollection.h"
#include "AliPhysicsSelection.h"
#include "AliTriggerAnalysis.h"

// PWG includes
#include "AliAnalysisMuonUtility.h"
#include "AliMuonTrackCuts.h"

using std::cout;
using std::endl;

ClassImp(AliAnalysisTaskMuonQA)

const Int_t AliAnalysisTaskMuonQA::nCh = 10;

const Int_t AliAnalysisTaskMuonQA::nDE = 1100;

const Float_t AliAnalysisTaskMuonQA::dMax[5] = {176.6, 229.0, 308.84, 418.2,  522.0}; // cm

//________________________________________________________________________
AliAnalysisTaskMuonQA::AliAnalysisTaskMuonQA() :
  AliAnalysisTaskSE(), 
  fList(0x0),
  fListExpert(0x0),
  fListNorm(0x0),
  fTrackCounters(0x0),
  fEventCounters(0x0),
  fSelectCharge(0),
  fSelectPhysics(kFALSE),
  fSelectTrigger(kFALSE),
  fTriggerMask(0),
  fSelectMatched(kFALSE),
  fApplyAccCut(kFALSE),
  fTriggerClass(0x0),
  fSelectTriggerClass(0x0),
  fTrackCuts(0x0),
  fMuonTrigIndex()
{
  // Dummy constructor
}

//________________________________________________________________________
AliAnalysisTaskMuonQA::AliAnalysisTaskMuonQA(const char *name) :
  AliAnalysisTaskSE(name), 
  fList(0x0),
  fListExpert(0x0),
  fListNorm(0x0),
  fTrackCounters(0x0),
  fEventCounters(0x0),
  fSelectCharge(0),
  fSelectPhysics(kFALSE),
  fSelectTrigger(kFALSE),
  fTriggerMask(0),
  fSelectMatched(kFALSE),
  fApplyAccCut(kFALSE),
  fTriggerClass(0x0),
  fSelectTriggerClass(0x0),
  fTrackCuts(new AliMuonTrackCuts("stdMuonCuts","stdMuonCuts")),
  fMuonTrigIndex()
{
  /// Constructor
  
  // Output slot #1 writes into a TObjArray container
  DefineOutput(1,TObjArray::Class());
  // Output slot #2 writes into a TObjArray container
  DefineOutput(2,TObjArray::Class());
  // Output slot #3 writes track counters
  DefineOutput(3,AliCounterCollection::Class());
  // Output slot #4 writes event counters
  DefineOutput(4,AliCounterCollection::Class());
  // Output slot #5 writes normalized histograms
  DefineOutput(5,TObjArray::Class());
  
  fTrackCuts->SetFilterMask(AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs | AliMuonTrackCuts::kMuPdca );
  fTrackCuts->SetAllowDefaultParams(kTRUE);
}

//________________________________________________________________________
AliAnalysisTaskMuonQA::~AliAnalysisTaskMuonQA()
{
  /// Destructor
  if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
    delete fList;
    delete fListExpert;
    delete fTrackCounters;
    delete fEventCounters;
    delete fListNorm;
  }
  delete fTriggerClass;
  delete fSelectTriggerClass;
  delete fTrackCuts;
}


//___________________________________________________________________________
void AliAnalysisTaskMuonQA::NotifyRun()
{
  /// Notify run
  fTrackCuts->SetRun(fInputHandler);
}


//___________________________________________________________________________
void AliAnalysisTaskMuonQA::SetTrackCuts(AliMuonTrackCuts* trackCuts)
{
  /// Set track cuts
  if ( fTrackCuts ) delete fTrackCuts;
  fTrackCuts = new AliMuonTrackCuts(*trackCuts);
}


//___________________________________________________________________________
void AliAnalysisTaskMuonQA::UserCreateOutputObjects()
{
  /// Create histograms and counters
  
  // set the list of trigger classes with corresponding short names
  fTriggerClass = new TMap(20);
  fTriggerClass->SetOwnerKeyValue();
  // p-p trigger classes
  fTriggerClass->Add(new TObjString("CBEAMB"), new TObjString("CBEAMB"));
  fTriggerClass->Add(new TObjString("CINT1B-ABCE-NOPF-ALL"), new TObjString("CINT1B"));
  fTriggerClass->Add(new TObjString("CMUS1B-ABCE-NOPF-MUON"), new TObjString("CMUS1B"));
  fTriggerClass->Add(new TObjString("CINT1[AC]-"), new TObjString("CINT1AC"));
  fTriggerClass->Add(new TObjString("CMUS1[AC]-"), new TObjString("CMUS1AC"));
  fTriggerClass->Add(new TObjString("CINT1-E-"), new TObjString("CINT1E"));
  fTriggerClass->Add(new TObjString("CINT5-E-"), new TObjString("CINT5E"));
  fTriggerClass->Add(new TObjString("CMUS1-E-"), new TObjString("CMUS1E"));
  fTriggerClass->Add(new TObjString("CMUS5-E-"), new TObjString("CMUS5E"));
  fTriggerClass->Add(new TObjString("CINT1-B-"), new TObjString("CINT1B"));
  fTriggerClass->Add(new TObjString("CINT5-B-"), new TObjString("CINT5B"));
  fTriggerClass->Add(new TObjString("CMUS1-B-"), new TObjString("CMUS1B"));
  fTriggerClass->Add(new TObjString("CMUS5-B-"), new TObjString("CMUS5B"));
  fTriggerClass->Add(new TObjString("CINT1-AC-"), new TObjString("CINT1AC"));
  fTriggerClass->Add(new TObjString("CINT5-AC-"), new TObjString("CINT5AC"));
  fTriggerClass->Add(new TObjString("CMUS1-AC-"), new TObjString("CMUS1AC"));
  fTriggerClass->Add(new TObjString("CMUS5-AC-"), new TObjString("CMUS5AC"));
  fTriggerClass->Add(new TObjString("CSH1-B-"), new TObjString("CSH1B"));

  TString side_pp[3] = {"B", "AC", "E"};
  for(Int_t i = 0; i< 3; i++){
    fTriggerClass->Add(new TObjString(Form("CINT7-%s-", side_pp[i].Data())), new TObjString(Form("CINT7%s",side_pp[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMUSH7-%s-",side_pp[i].Data())), new TObjString(Form("CMUSH7%s",side_pp[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMUL7-%s-",side_pp[i].Data())), new TObjString(Form("CMUL7%s",side_pp[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMUU7-%s-",side_pp[i].Data())), new TObjString(Form("CMUU7%s",side_pp[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMUS7-%s-",side_pp[i].Data())), new TObjString(Form("CMUS7%s",side_pp[i].Data())));
  }
  fTriggerClass->Add(new TObjString("CINT7-I-"), new TObjString("CINT7I"));

  // Pb-Pb trigger classes
  TString side[4] = {"B", "A", "C", "E"};
  for (Int_t i = 0; i < 4; i++) {
    fTriggerClass->Add(new TObjString(Form("CMBACS2-%s-", side[i].Data())), new TObjString(Form("CMBACS2-%s", side[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMBS2A-%s-", side[i].Data())), new TObjString(Form("CMBS2A-%s", side[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMBS2C-%s-", side[i].Data())), new TObjString(Form("CMBS2C-%s", side[i].Data())));
    fTriggerClass->Add(new TObjString(Form("CMBAC-%s-", side[i].Data())), new TObjString(Form("CMBAC-%s", side[i].Data())));
    fTriggerClass->Add(new TObjString(Form("C0SMH-%s-", side[i].Data())), new TObjString(Form("C0SMH-%s", side[i].Data())));
  }
  
  // set the list of trigger classes that can be selected to fill histograms (in case the physics selection is not used)
  fSelectTriggerClass = new TList();
  fSelectTriggerClass->SetOwner();
  // p-p trigger classes
  fSelectTriggerClass->AddLast(new TObjString("CINT1B-ABCE-NOPF-ALL")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("CMUS1B-ABCE-NOPF-MUON")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUON);
  fSelectTriggerClass->AddLast(new TObjString("CINT1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("CINT5-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kCINT5);
  fSelectTriggerClass->AddLast(new TObjString("CMUS1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUON);
  fSelectTriggerClass->AddLast(new TObjString("CMUS5-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kCMUS5);
  fSelectTriggerClass->AddLast(new TObjString("CINT7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kINT7);
  fSelectTriggerClass->AddLast(new TObjString("CINT7-I-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kINT7);
  fSelectTriggerClass->AddLast(new TObjString("CMUSH7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUSH7);
  fSelectTriggerClass->AddLast(new TObjString("CMUS7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUS7);
  fSelectTriggerClass->AddLast(new TObjString("CMUU7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUU7);
  fSelectTriggerClass->AddLast(new TObjString("CMUL7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUL7);
  fSelectTriggerClass->AddLast(new TObjString("CSH1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kHighMult);
	
  // Pb-Pb trigger classes
  fSelectTriggerClass->AddLast(new TObjString("CMBACS2-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("CMBS2A-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("CMBS2C-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("CMBAC-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
  fSelectTriggerClass->AddLast(new TObjString("C0SMH-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kHighMult);
  
  // create histograms
  fList = new TObjArray(2000);
  fList->SetOwner();
  fListExpert = new TObjArray(2000);
  fListExpert->SetOwner();
  
  // event info
  TH1F* hNTracks = new TH1F("hNTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
  fList->AddAtAndExpand(hNTracks, kNTracks);
  
  Int_t muonTrigIndex[] = { AliVEvent::kMuonUnlikePB, AliVEvent::kMuonLikePB, AliVEvent::kMUSHPB, AliVEvent::kMuonUnlikePB | AliVEvent::kMuonLikePB,
                            AliVEvent::kMuonUnlikePB | AliVEvent::kMUSHPB, AliVEvent::kMuonLikePB | AliVEvent::kMUSHPB,
                            AliVEvent::kMuonUnlikePB | AliVEvent::kMuonLikePB | AliVEvent::kMUSHPB};
  const Int_t nTrigIndexes = sizeof(muonTrigIndex)/sizeof(muonTrigIndex[0]);
  fMuonTrigIndex.Set(nTrigIndexes, muonTrigIndex);
  TString label[nTrigIndexes] = {"Unlike","Like", "Single Hpt","Like&Unlike","Unlike&Hpt","Like&Hpt","Unlike&Like&Hpt"};
  TH1I* hMuonTriggers = new TH1I("hMuonTriggers", "Muon triggers", nTrigIndexes, -0.5, -0.5+(Double_t)nTrigIndexes);
  for(Int_t ibin=0; ibin<nTrigIndexes; ibin++) hMuonTriggers->GetXaxis()->SetBinLabel(ibin+1,label[ibin].Data());
  fList->AddAtAndExpand(hMuonTriggers, kMuonTrig);

  //track info
  TH1F* hMatchTrig = new TH1F("hMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
  fList->AddAtAndExpand(hMatchTrig, kMatchTrig);
  
  TH1F* hSign = new TH1F("hSign", "track sign;sign", 3, -1.5, 1.5);
  fList->AddAtAndExpand(hSign, kSign);
  
  TH1F* hDCA = new TH1F("hDCA", "DCA distribution;DCA (cm)", 500, 0., 500.);
  fList->AddAtAndExpand(hDCA, kDCA);
  
  TH1F* hP = new TH1F("hP", "momentum distribution;p (GeV/c)", 300, 0., 300.);
  fList->AddAtAndExpand(hP, kP);
  
  TH1F* hPMuPlus = new TH1F("hPMuPlus", "momentum distribution of #mu^{+};p (GeV/c)", 300, 0., 300.);
  fList->AddAtAndExpand(hPMuPlus, kPMuPlus);
  
  TH1F* hPMuMinus = new TH1F("hPMuMinus", "momentum distribution of #mu^{-};p (GeV/c)", 300, 0., 300.);
  fList->AddAtAndExpand(hPMuMinus, kPMuMinus);
  
  Int_t nPtBins = 300;
  Double_t ptMin = 0., ptMax = 30.;
	
  TH1F* hPt = new TH1F("hPt", "transverse momentum distribution;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPt, kPt);
  
  TH1F* hPtMuPlus = new TH1F("hPtMuPlus", "transverse momentum distribution of #mu^{+};p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuPlus, kPtMuPlus);
  
  TH1F* hPtMuMinus = new TH1F("hPtMuMinus", "transverse momentum distribution of #mu^{-};p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuMinus, kPtMuMinus);
  
  TH1F* hRapidity = new TH1F("hRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
  fList->AddAtAndExpand(hRapidity, kRapidity);
  
  TH1F* hThetaX = new TH1F("hThetaX", "#theta_{X} distribution;#theta_{X} (degree)", 360, -180., 180);
  fList->AddAtAndExpand(hThetaX, kThetaX);
  
  TH1F* hThetaY = new TH1F("hThetaY", "#theta_{Y} distribution;#theta_{Y} (degree)", 360, -180., 180);
  fList->AddAtAndExpand(hThetaY, kThetaY);
  
  TH1F* hChi2 = new TH1F("hChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
  fList->AddAtAndExpand(hChi2, kChi2);
  
  TH1F* hProbChi2 = new TH1F("hProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
  fList->AddAtAndExpand(hProbChi2, kProbChi2);
  
  // cluster info
  TH1F* hNClustersPerTrack = new TH1F("hNClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
  fList->AddAtAndExpand(hNClustersPerTrack, kNClustersPerTrack);
  
  TH1F* hNChamberHitPerTrack = new TH1F("hNChamberHitPerTrack", "number of chambers hit per track;n_{chamber hit}", 15, 0., 15.);
  fList->AddAtAndExpand(hNChamberHitPerTrack, kNChamberHitPerTrack);
  
  // Matched tracks info
  TH1F* hPtMatchLpt = new TH1F("hPtMatchLpt", "transverse momentum distribution matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMatchLpt, kPtMatchLpt);
  
  TH1F* hPtMatchHpt = new TH1F("hPtMatchHpt", "transverse momentum distribution matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMatchHpt, kPtMatchHpt);
  
  TH1F* hPtMuPlusMatchLpt = new TH1F("hPtMuPlusMatchLpt", "transverse momentum distribution of #mu^{+} matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuPlusMatchLpt, kPtMuPlusMatchLpt);

  TH1F* hPtMuPlusMatchHpt = new TH1F("hPtMuPlusMatchHpt", "transverse momentum distribution of #mu^{+} matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuPlusMatchHpt, kPtMuPlusMatchHpt);
  
  TH1F* hPtMuMinusMatchLpt = new TH1F("hPtMuMinusMatchLpt", "transverse momentum distribution of #mu^{-} matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuMinusMatchLpt, kPtMuMinusMatchLpt);
  
  TH1F* hPtMuMinusMatchHpt = new TH1F("hPtMuMinusMatchHpt", "transverse momentum distribution of #mu^{-} matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
  fList->AddAtAndExpand(hPtMuMinusMatchHpt, kPtMuMinusMatchHpt);  
	
  TH1F* hNClustersPerCh = new TH1F("hNClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, -0.5, nCh-0.5);
  hNClustersPerCh->Sumw2();
  hNClustersPerCh->SetOption("P");
  hNClustersPerCh->SetMarkerStyle(kFullDotMedium);
  hNClustersPerCh->SetMarkerColor(kBlue);
  fListExpert->AddAtAndExpand(hNClustersPerCh, kNClustersPerCh);
  
  TH1F* hNClustersPerDE = new TH1F("hNClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE+1, -0.5, nDE+0.5);
  hNClustersPerDE->Sumw2();
  hNClustersPerDE->SetOption("P");
  hNClustersPerDE->SetMarkerStyle(kFullDotMedium);
  hNClustersPerDE->SetMarkerColor(kBlue);
  fListExpert->AddAtAndExpand(hNClustersPerDE, kNClustersPerDE);
  
  for (Int_t i = 0; i < nCh; i++) {
    Float_t rMax = 0.5*dMax[i/2];
    TH2F* hClusterHitMapInCh = new TH2F(Form("hClusterHitMapInCh%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
					100, -rMax, rMax, 100, -rMax, rMax);
    fListExpert->AddAtAndExpand(hClusterHitMapInCh, kClusterHitMapInCh+i);
    
    TH1F* hClusterChargeInCh = new TH1F(Form("hClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (fC)",i+1), 100, 0., 1000.);
    fListExpert->AddAtAndExpand(hClusterChargeInCh, kClusterChargeInCh+i);
    
    TH1F* hClusterSizeInCh = new TH1F(Form("hClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
    fListExpert->AddAtAndExpand(hClusterSizeInCh, kClusterSizeInCh+i);
  }
  
  TH2F* hClusterChargePerDE = new TH2F("hClusterChargePerDE", "cluster charge distribution per DE;DetElem ID;charge (fC)", nDE+1, -0.5, nDE+0.5, 100, 0., 1000.);
  fListExpert->AddAtAndExpand(hClusterChargePerDE, kClusterChargePerDE);
  
  TH2F* hClusterSizePerDE = new TH2F("hClusterSizePerDE", "cluster size distribution per DE;DetElem ID;size (n_{pads})", nDE+1, -0.5, nDE+0.5, 200, 0., 200.);
  fListExpert->AddAtAndExpand(hClusterSizePerDE, kClusterSizePerDE);
  
  // initialize track counters
  fTrackCounters = new AliCounterCollection("trackCounters");
  fTrackCounters->AddRubric("track", "trackeronly/triggeronly/matched/notrack");
  fTrackCounters->AddRubric("trigger", 1000000);
  fTrackCounters->AddRubric("run", 1000000);
  fTrackCounters->AddRubric("selected", "yes/no");
  fTrackCounters->AddRubric("triggerRO", "good/bad");
  fTrackCounters->AddRubric("v0mult", "low/int/high/any");
  fTrackCounters->AddRubric("charge", "pos/neg/any");
  fTrackCounters->AddRubric("pt", "low/high/any");
  fTrackCounters->AddRubric("acc", "in/out");
  fTrackCounters->AddRubric("tagTrack", "beamGas/good");
  fTrackCounters->AddRubric("t0pileup", "yes/no");
  fTrackCounters->AddRubric("bgID", "yes/no");
  fTrackCounters->AddRubric("spdpileup", "yes/no");
  fTrackCounters->Init();

  
  // initialize event counters
  fEventCounters = new AliCounterCollection("eventCounters");
  fEventCounters->AddRubric("event", "muon/any");
  fEventCounters->AddRubric("trigger", 1000000);
  fEventCounters->AddRubric("run", 1000000);
  fEventCounters->AddRubric("selected", "yes/no");
  fEventCounters->AddRubric("triggerRO", "good/bad");
  fEventCounters->AddRubric("v0mult", "low/int/high/any");
  fEventCounters->AddRubric("t0pileup", "yes/no");
  fEventCounters->AddRubric("spdpileup", "yes/no");
  fEventCounters->AddRubric("bgID", "yes/no");
  fEventCounters->Init();
  
  // Post data at least once per task to ensure data synchronisation (required for merging)
  PostData(1, fList);
  PostData(2, fListExpert);
  PostData(3, fTrackCounters);
  PostData(4, fEventCounters);
}

//________________________________________________________________________
void AliAnalysisTaskMuonQA::UserExec(Option_t *)
{
  /// Called for each event

  AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(InputEvent());
  if (!fESD) {
    Printf("ERROR: fESD not available");
    return;
  }

  //Flag for T0Pileup, SPDPileup and bgID (SPD cluster vs tracket)
  Bool_t t0PileUp = kFALSE, spdPileUp = kFALSE, bgID = kFALSE;
  spdPileUp = fESD->IsPileupFromSPDInMultBins();
  AliPhysicsSelection *physicsSelection = (AliPhysicsSelection*)((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->GetEventSelection();
  if ( physicsSelection ) {
    AliTriggerAnalysis * triggerAnalysis = (AliTriggerAnalysis*)physicsSelection->GetTriggerAnalysis();
    if ( triggerAnalysis ) {
      t0PileUp = triggerAnalysis->EvaluateTrigger(fESD, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0Pileup));
      bgID = triggerAnalysis->EvaluateTrigger(fESD,  (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kSPDClsVsTrkBG | AliTriggerAnalysis::kOfflineFlag));
    }
  }

  UInt_t geomAccMask = ( AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs );
  
  // check physics selection
  UInt_t triggerWord = (fInputHandler) ? fInputHandler->IsEventSelected() : 0;
  Bool_t isPhysicsSelected = (triggerWord != 0);
  TString selected = isPhysicsSelected ? "selected:yes" : "selected:no";
  selected += t0PileUp ? "/t0pileup:yes" : "/t0pileup:no";
  selected += bgID ? "/bgID:yes" : "/bgID:no";
  selected += spdPileUp ? "/spdpileup:yes" : "/spdpileup:no";

  // fill muon trigger cases
  for ( Int_t idx=0; idx<fMuonTrigIndex.GetSize(); idx++ ) {
    UInt_t currMask = (UInt_t)fMuonTrigIndex[idx];
    if ( ( triggerWord & currMask ) == currMask ) ((TH1I*)fList->UncheckedAt(kMuonTrig))->Fill(idx);
  }
  
  // check trigger selection 
  TString FiredTriggerClasses = fESD->GetFiredTriggerClasses();
  if (!fSelectPhysics) triggerWord = BuildTriggerWord(FiredTriggerClasses);
  Bool_t isTriggerSelected = ((triggerWord & fTriggerMask) != 0);
  
  // get the V0 multiplicity (except for p-p)
  AliESDVZERO* v0Data = fESD->GetVZEROData();
  Float_t v0Mult = 0.;
  const Int_t nV0MultRange = 4;
  const Int_t nCollType = 2;
  //define rough V0 mult. range (~ 80%, 60%, 10%, 0%)
  Int_t v0MultRange[nCollType][nV0MultRange]= {{239,1165,12191,20633},{25,60,200,800}};
  Int_t iCollType = 0;

  if (v0Data) {
    if (!strcmp(fESD->GetBeamType(),"A-A")){
      iCollType = 0;
      for (Int_t i = 0 ; i < 64 ; i++) v0Mult += v0Data->GetMultiplicity(i);
    } 
    else if (!strcmp(fESD->GetBeamType(),"p-A")){
      iCollType = 1;
      for (Int_t i = 0 ; i < 32 ; i++) v0Mult += v0Data->GetMultiplicityV0A(i);
    }
    else if (!strcmp(fESD->GetBeamType(),"A-p")){
      iCollType = 1;
      for (Int_t i = 0 ; i < 32 ; i++) v0Mult += v0Data->GetMultiplicityV0C(i);
    }
  }

  TList listV0MultKey;
  listV0MultKey.SetOwner();
  listV0MultKey.AddLast(new TObjString("v0mult:any"));
  if (v0Mult >= v0MultRange[iCollType][0] && v0Mult < v0MultRange[iCollType][1]) listV0MultKey.AddLast(new TObjString("v0mult:low"));
  else if (v0Mult >= v0MultRange[iCollType][1] && v0Mult < v0MultRange[iCollType][2]) listV0MultKey.AddLast(new TObjString("v0mult:int"));
  else if (v0Mult >= v0MultRange[iCollType][2] && v0Mult < v0MultRange[iCollType][3]) listV0MultKey.AddLast(new TObjString("v0mult:high"));
  
  TIter nextV0MultKey(&listV0MultKey);
  
  // first loop over tracks to check for trigger readout problem
  Int_t maxTriggerRO = (!strcmp(fESD->GetBeamType(),"p-p")) ? 10 : 1000;
  Int_t nTracks = (Int_t) fESD->GetNumberOfMuonTracks();
  Int_t nTriggerTracks = 0;
  for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack)
    if (fESD->GetMuonTrack(iTrack)->ContainTriggerData()) nTriggerTracks++;
  TString triggerRO = (nTriggerTracks < maxTriggerRO) ? "triggerRO:good" : "triggerRO:bad";
  
  // --- fill event counters ---
  
  // build the list of trigger cases
  //TList* triggerCases = BuildListOfTriggerCases(FiredTriggerClasses);
  TList* triggerCases = BuildListOfAllTriggerCases(FiredTriggerClasses);

  // loop over trigger cases
  TObjString* triggerKey = 0x0;
  TIter nextTriggerCase(triggerCases);
  while ((triggerKey = static_cast<TObjString*>(nextTriggerCase()))) {
    
    // loop over V0Mult cases
    TObjString* v0MultKey = 0x0;
    nextV0MultKey.Reset();
    while ((v0MultKey = static_cast<TObjString*>(nextV0MultKey()))) {
      
      // any event
      fEventCounters->Count(Form("event:any/%s/run:%d/%s/%s/%s", triggerKey->GetName(), fCurrentRunNumber, selected.Data(), triggerRO.Data(), v0MultKey->GetName()));
      
      // muon event
      if (nTracks > 0) {
	fEventCounters->Count(Form("event:muon/%s/run:%d/%s/%s/%s", triggerKey->GetName(), fCurrentRunNumber, selected.Data(), triggerRO.Data(), v0MultKey->GetName()));
      }
      else {
	// fill track counter in case of no muon track
	fTrackCounters->Count(Form("%s/%s/run:%d/%s/%s/%s/%s/%s/%s/%s", "track:notrack", triggerKey->GetName(), 
				   fCurrentRunNumber,selected.Data(), "charge:any", "pt:any", "triggerRO:bad", 
				   v0MultKey->GetName(), "acc:out", "tagTrack:good"));
      }

    }
      
  }
  
  // second loop over tracks to fill histograms and track counters
  Int_t nSelectedTrackerTracks = 0;
  Int_t nSelectedTrackMatchTrig = 0;
  Int_t nPVTracks = fESD->GetPrimaryVertex()->GetNContributors();

  for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) {
    
    // get the ESD track
    AliESDMuonTrack* esdTrack = fESD->GetMuonTrack(iTrack);
    
    // --- fill track counters ---
    
    // define the key words
    TString trackKey = "track:";
    TString accKey = "acc:";
    Bool_t isBeamGas = kFALSE;
    TList chargeKeyList;
    chargeKeyList.SetOwner();
    chargeKeyList.Add(new TObjString("charge:any"));
    TList ptKeyList;
    ptKeyList.SetOwner();
    ptKeyList.Add(new TObjString("pt:any"));

    if (esdTrack->ContainTrackerData()) {
      
      if (esdTrack->ContainTriggerData()) trackKey += "matched";
      else  trackKey += "trackeronly";
      
      Short_t trackCharge = esdTrack->Charge();
      TString chargeKey = "charge:";
      chargeKey += ( trackCharge < 0 ) ? "neg" : "pos";
      chargeKeyList.Add(new TObjString(chargeKey));
      
      UInt_t mask = fTrackCuts->GetSelectionMask(esdTrack);
      Bool_t passGeomAccCuts = ( ( mask & geomAccMask ) == geomAccMask );
      accKey += ( passGeomAccCuts ) ? "in" : "out";
      if ( passGeomAccCuts && nPVTracks>0 ) {
        Double_t trackPt = esdTrack->Pt();
        if ( trackPt > 1. ) ptKeyList.Add(new TObjString("pt:low"));
        if ( trackPt > 2. ) ptKeyList.Add(new TObjString("pt:high"));;
      }
      if ( ( mask & AliMuonTrackCuts::kMuPdca ) == 0 ) isBeamGas = kTRUE;
    } else {
      
      trackKey += "triggeronly";
      accKey += "out"; // ghost are labelled out of the acceptance
    
    }
    
    TString tagKey = "tagTrack:";
    tagKey += ( isBeamGas ) ? "beamGas" : "good";
    
    // loop over trigger cases and fill counters
    nextTriggerCase.Reset();
    while ((triggerKey = static_cast<TObjString*>(nextTriggerCase()))) {
      
      // loop over V0Mult cases
      TObjString* v0MultKey = 0x0;
      nextV0MultKey.Reset();
      while ((v0MultKey = static_cast<TObjString*>(nextV0MultKey()))) {
	
        for ( Int_t icharge=0; icharge<chargeKeyList.GetEntries(); icharge++ ) {
          for ( Int_t ipt=0; ipt<ptKeyList.GetEntries(); ipt++ ) {
            fTrackCounters->Count(Form("%s/%s/run:%d/%s/%s/%s/%s/%s/%s/%s", trackKey.Data(), triggerKey->GetName(), fCurrentRunNumber,
                                       selected.Data(), chargeKeyList.At(icharge)->GetName(), ptKeyList.At(ipt)->GetName(),
                                       triggerRO.Data(), v0MultKey->GetName(), accKey.Data(), tagKey.Data()));
          }
        }	
      }
      
    }
    
    // --- apply selections and fill histograms with selected tracks ---
    
    // remove "ghost"
    if (!esdTrack->ContainTrackerData()) continue;
    
    // select on "physics" before filling histograms
    if (fSelectPhysics && !isPhysicsSelected) continue;
    
    // select on trigger before filling histograms
    if (fSelectTrigger && !isTriggerSelected) continue;
    
    // select on track charge
    if (fSelectCharge*esdTrack->Charge() < 0) continue;
    
    // select on track matching
    if (fSelectMatched && !esdTrack->ContainTriggerData()) continue;
    
    // skip tracks that do not pass the acceptance cuts if required
    if (fApplyAccCut && accKey.EndsWith("out")) continue;
    
    nSelectedTrackerTracks++;
    if (esdTrack->ContainTriggerData()) nSelectedTrackMatchTrig++;
    
    Double_t trackP = esdTrack->P();
    Double_t trackPt = esdTrack->Pt();
    Short_t trackCharge = esdTrack->Charge();
    ((TH1F*)fList->UncheckedAt(kP))->Fill(trackP);
    ((TH1F*)fList->UncheckedAt(kPt))->Fill(trackPt);
    Bool_t matchTrigLpt = (esdTrack->GetMatchTrigger()>=2);
    Bool_t matchTrigHpt = (esdTrack->GetMatchTrigger()>=3);
    if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMatchLpt))->Fill(trackPt);
    if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMatchHpt))->Fill(trackPt);
    if (trackCharge < 0) {
      ((TH1F*)fList->UncheckedAt(kPMuMinus))->Fill(trackP);
      ((TH1F*)fList->UncheckedAt(kPtMuMinus))->Fill(trackPt);
      if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMuMinusMatchLpt))->Fill(trackPt);
      if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMuMinusMatchHpt))->Fill(trackPt);
    } else {
      ((TH1F*)fList->UncheckedAt(kPMuPlus))->Fill(trackP);
      ((TH1F*)fList->UncheckedAt(kPtMuPlus))->Fill(trackPt);
      if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMuPlusMatchLpt))->Fill(trackPt);
      if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMuPlusMatchHpt))->Fill(trackPt);
    }
    ((TH1F*)fList->UncheckedAt(kRapidity))->Fill(esdTrack->Y());
    Int_t ndf = 2 * esdTrack->GetNHit() - 5;
    ((TH1F*)fList->UncheckedAt(kChi2))->Fill(esdTrack->GetChi2()/ndf);
    ((TH1F*)fList->UncheckedAt(kProbChi2))->Fill(TMath::Prob(esdTrack->GetChi2(),ndf));
    ((TH1F*)fList->UncheckedAt(kThetaX))->Fill(ChangeThetaRange(esdTrack->GetThetaXUncorrected()));
    ((TH1F*)fList->UncheckedAt(kThetaY))->Fill(ChangeThetaRange(esdTrack->GetThetaYUncorrected()));
    ((TH1F*)fList->UncheckedAt(kNClustersPerTrack))->Fill(esdTrack->GetNHit());
    ((TH1F*)fList->UncheckedAt(kSign))->Fill(trackCharge);
    ((TH1F*)fList->UncheckedAt(kDCA))->Fill(esdTrack->GetDCA());
    
    Int_t nChamberHit = 0;
    for (Int_t ich=0; ich<10; ich++) if (esdTrack->IsInMuonClusterMap(ich)) nChamberHit++;
    ((TH1F*)fList->UncheckedAt(kNChamberHitPerTrack))->Fill(nChamberHit);
    
    // loop over clusters
    for (Int_t icl=0; icl<esdTrack->GetNClusters(); icl++) {
      
      AliESDMuonCluster* esdCluster = esdTrack->GetESDEvent()->FindMuonCluster(esdTrack->GetClusterId(icl));
      
      Int_t chId = esdCluster->GetChamberId();
      Int_t deId = esdCluster->GetDetElemId();
      
      ((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Fill(chId);
      ((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Fill(deId);
      
      ((TH1F*)fListExpert->UncheckedAt(kClusterHitMapInCh+chId))->Fill(esdCluster->GetX(), esdCluster->GetY());
      
      ((TH1F*)fListExpert->UncheckedAt(kClusterChargeInCh+chId))->Fill(esdCluster->GetCharge());
      ((TH1F*)fListExpert->UncheckedAt(kClusterChargePerDE))->Fill(deId, esdCluster->GetCharge());
      
      if (esdCluster->PadsStored()) { // discard clusters with pad not stored in ESD
        ((TH1F*)fListExpert->UncheckedAt(kClusterSizeInCh+chId))->Fill(esdCluster->GetNPads());
	((TH1F*)fListExpert->UncheckedAt(kClusterSizePerDE))->Fill(deId, esdCluster->GetNPads());
      }
      
    }
    
  }
  
  if ((!fSelectPhysics || isPhysicsSelected) && (!fSelectTrigger || isTriggerSelected)) {
    ((TH1F*)fList->UncheckedAt(kNTracks))->Fill(nSelectedTrackerTracks);
    ((TH1F*)fList->UncheckedAt(kMatchTrig))->Fill(nSelectedTrackMatchTrig);
  } 
  
  // clean memory
  delete triggerCases;
  
  // Post final data. It will be written to a file with option "RECREATE"
  PostData(1, fList);
  PostData(2, fListExpert);
  PostData(3, fTrackCounters);
  PostData(4, fEventCounters);
}

//________________________________________________________________________
void AliAnalysisTaskMuonQA::Terminate(Option_t *)
{
  /// Normalize histograms
  /// Draw result to the screen
  /// Print statistics
  
  // global statistic
  fTrackCounters = static_cast<AliCounterCollection*>(GetOutputData(3));
  fEventCounters = static_cast<AliCounterCollection*>(GetOutputData(4));
  if (fTrackCounters && fEventCounters) {
    if (!gROOT->IsBatch()) {
      cout<<"whole statistics without selection:"<<endl;
      fEventCounters->Print("trigger/event");
      fTrackCounters->Print("trigger/track");
      cout<<"whole statistics of selected events:"<<endl;
      fEventCounters->Print("trigger/event","selected:yes");
      fTrackCounters->Print("trigger/track","selected:yes");
      new TCanvas();
      fEventCounters->Draw("event","trigger","");
      new TCanvas();
      fTrackCounters->Draw("track","trigger","");
      new TCanvas();
      fEventCounters->Draw("event","trigger","selected:yes");
      new TCanvas();
      fTrackCounters->Draw("track","trigger","selected:yes");
    }
  }
  
  // recover output histograms
  fList = static_cast<TObjArray*>(GetOutputData(1));
  fListExpert = static_cast<TObjArray*>(GetOutputData(2));
  if (!fList || !fListExpert) return;
  
  // create summary plots
  fListNorm = new TObjArray(1000);
  fListNorm->SetOwner();
  
  // mean/dispersion of cluster charge per chamber/DE
  TH1F* hClusterChargePerChMean = new TH1F("hClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (fC)", nCh, -0.5, nCh-0.5);
  hClusterChargePerChMean->SetOption("P");
  hClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
  hClusterChargePerChMean->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterChargePerChMean, kClusterChargePerChMean);
  
  TH1F* hClusterChargePerChSigma = new TH1F("hClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (fC)", nCh, -0.5, nCh-0.5);
  hClusterChargePerChSigma->SetOption("P");
  hClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
  hClusterChargePerChSigma->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterChargePerChSigma, kClusterChargePerChSigma);
  
  TH1F* hClusterChargePerDEMean = new TH1F("hClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID;<charge> (fC)", nDE+1, -0.5, nDE+0.5);
  hClusterChargePerDEMean->SetOption("P");
  hClusterChargePerDEMean->SetMarkerStyle(kFullDotMedium);
  hClusterChargePerDEMean->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterChargePerDEMean, kClusterChargePerDEMean);
  
  TH1F* hClusterChargePerDESigma = new TH1F("hClusterChargePerDESigma", "cluster charge dispersion per DE;DetElem ID;#sigma_{charge} (fC)", nDE+1, -0.5, nDE+0.5);
  hClusterChargePerDESigma->SetOption("P");
  hClusterChargePerDESigma->SetMarkerStyle(kFullDotMedium);
  hClusterChargePerDESigma->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterChargePerDESigma, kClusterChargePerDESigma);
  
  // mean/dispersion of cluster size per chamber/DE
  TH1F* hClusterSizePerChMean = new TH1F("hClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, -0.5, nCh-0.5);
  hClusterSizePerChMean->SetOption("P");
  hClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
  hClusterSizePerChMean->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterSizePerChMean, kClusterSizePerChMean);
  
  TH1F* hClusterSizePerChSigma = new TH1F("hClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5);
  hClusterSizePerChSigma->SetOption("P");
  hClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
  hClusterSizePerChSigma->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterSizePerChSigma, kClusterSizePerChSigma);
  
  TH1F* hClusterSizePerDEMean = new TH1F("hClusterSizePerDEMean", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE+1, -0.5, nDE+0.5);
  hClusterSizePerDEMean->SetOption("P");
  hClusterSizePerDEMean->SetMarkerStyle(kFullDotMedium);
  hClusterSizePerDEMean->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterSizePerDEMean, kClusterSizePerDEMean);
  
  TH1F* hClusterSizePerDESigma = new TH1F("hClusterSizePerDESigma", "cluster size dispersion per DE;DetElem ID;#sigma_{size} (n_{pads})", nDE+1, -0.5, nDE+0.5);
  hClusterSizePerDESigma->SetOption("P");
  hClusterSizePerDESigma->SetMarkerStyle(kFullDotMedium);
  hClusterSizePerDESigma->SetMarkerColor(kBlue);
  fListNorm->AddAtAndExpand(hClusterSizePerDESigma, kClusterSizePerDESigma);
  
  // normalize histograms
  Float_t nTracks = ((TH1F*)fList->UncheckedAt(kNClustersPerTrack))->GetEntries();
  if (nTracks > 0.) {
    ((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Scale(1./nTracks);
    ((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Scale(1./nTracks);
  }
  fListNorm->AddAtAndExpand(((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Clone(), kNClustersPerChPerTrack);
  fListNorm->AddAtAndExpand(((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Clone(), kNClustersPerDEPerTrack);
  
  // fill summary plots per chamber
  for (Int_t iCh = 0; iCh < nCh; iCh++) {
    
    TH1* hClusterChargeInCh = ((TH1F*)fListExpert->UncheckedAt(kClusterChargeInCh+iCh));
    hClusterChargePerChMean->SetBinContent(iCh+1, hClusterChargeInCh->GetMean());
    hClusterChargePerChMean->SetBinError(iCh+1, hClusterChargeInCh->GetMeanError());
    hClusterChargePerChSigma->SetBinContent(iCh+1, hClusterChargeInCh->GetRMS());
    hClusterChargePerChSigma->SetBinError(iCh+1, hClusterChargeInCh->GetRMSError());
    
    TH1* hClusterSizeInCh = ((TH1F*)fListExpert->UncheckedAt(kClusterSizeInCh+iCh));
    hClusterSizePerChMean->SetBinContent(iCh+1, hClusterSizeInCh->GetMean());
    hClusterSizePerChMean->SetBinError(iCh+1, hClusterSizeInCh->GetMeanError());
    hClusterSizePerChSigma->SetBinContent(iCh+1, hClusterSizeInCh->GetRMS());
    hClusterSizePerChSigma->SetBinError(iCh+1, hClusterSizeInCh->GetRMSError());
    
  }
  
  // fill summary plots per DE
  TH2F* hClusterChargePerDE = ((TH2F*)fListExpert->UncheckedAt(kClusterChargePerDE));
  TH2F* hClusterSizePerDE = ((TH2F*)fListExpert->UncheckedAt(kClusterSizePerDE));
  for (Int_t iDE = 1; iDE < nDE+1; iDE++) {
    
    TH1D *tmp = hClusterChargePerDE->ProjectionY("tmp",iDE,iDE,"e");
    if (tmp->GetEntries() > 10.) {
      hClusterChargePerDEMean->SetBinContent(iDE, tmp->GetMean());
      hClusterChargePerDEMean->SetBinError(iDE, tmp->GetMeanError());
      hClusterChargePerDESigma->SetBinContent(iDE, tmp->GetRMS());
      hClusterChargePerDESigma->SetBinError(iDE, tmp->GetRMSError());
    }
    delete tmp;
    
    tmp = hClusterSizePerDE->ProjectionY("tmp",iDE,iDE,"e");
    if (tmp->GetEntries() > 10.) {
      hClusterSizePerDEMean->SetBinContent(iDE, tmp->GetMean());
      hClusterSizePerDEMean->SetBinError(iDE, tmp->GetMeanError());
      hClusterSizePerDESigma->SetBinContent(iDE, tmp->GetRMS());
      hClusterSizePerDESigma->SetBinError(iDE, tmp->GetRMSError());
    }
    delete tmp;
    
  }
  
  // Post summary data.
  PostData(5, fListNorm);
}

//________________________________________________________________________
Double_t AliAnalysisTaskMuonQA::ChangeThetaRange(Double_t theta)
{
  /// set theta range from -180 to +180 degrees
  if(theta < -2.5) return (theta / TMath::Pi() + 1.) * 180.;
  else if(theta > 2.5) return (theta / TMath::Pi() - 1.) * 180.;
  else return theta / TMath::Pi() * 180.;
}


//________________________________________________________________________
UInt_t AliAnalysisTaskMuonQA::BuildTriggerWord(TString& FiredTriggerClasses)
{
  /// build the trigger word from the fired trigger classes and the list of selectable trigger
  
  UInt_t word = 0;
  
  TObjString* trigClasseName = 0x0;
  TIter nextTrigger(fSelectTriggerClass);
  while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
    
    TRegexp GenericTriggerClasseName(trigClasseName->String());
    if (FiredTriggerClasses.Contains(GenericTriggerClasseName)) word |= trigClasseName->GetUniqueID();
    
  }
  
  return word;
}

//________________________________________________________________________
TList* AliAnalysisTaskMuonQA::BuildListOfAllTriggerCases(TString& FiredTriggerClasses)
{
  /// build the list of trigger for the counters from the fired trigger classes
  /// returned TList must be deleted by user
  
  TList* list = new TList();
  list->SetOwner();
  
  // add case any
  list->AddLast(new TObjString("trigger:any"));
  
  TObjArray *obj = FiredTriggerClasses.Tokenize(" ");
  if ( obj ){
    TIter nextTrigger(obj);
    TObjString* trigClasseName;
    while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
			
      //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
			
      //Add specific trigger
      list->AddLast(new TObjString(Form("trigger:%s",trigClasseName->GetName())));
    }
    delete obj;
  }
  
  // add case other if no specific trigger was found
  if (list->GetSize() == 1) list->AddLast(new TObjString("trigger:other"));
	
  return list;
}


//________________________________________________________________________
TList* AliAnalysisTaskMuonQA::BuildListOfSelectedTriggerCases(TString& FiredTriggerClasses)
{
  /// build the list of trigger for the counters from the fired trigger classes
  /// returned TList must be deleted by user
  
  TList* list = new TList();
  list->SetOwner();
  
  // add case any
  list->AddLast(new TObjString("trigger:any"));
  
  TObjString* trigClasseName = 0x0;
  TObjArray *obj = FiredTriggerClasses.Tokenize(" ");
  if ( obj ){
    TIter nextTrigger(obj);
    while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
			
      //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
      //loop on rejected trigger if (trigClasseName.Contains()
      //Add specific trigger
      list->AddLast(new TObjString(Form("trigger:%s",trigClasseName->GetName())));
    }
    delete obj;
  }
  
  // add case other if no specific trigger was found
  if (list->GetSize() == 1) list->AddLast(new TObjString("trigger:other"));
	
  return list;
}

//________________________________________________________________________
TList* AliAnalysisTaskMuonQA::BuildListOfTriggerCases(TString& FiredTriggerClasses)
{
  /// build the list of trigger for the counters from the fired trigger classes and the list of trigger classes
  /// returned TList must be deleted by user
  
  TList* list = new TList();
  list->SetOwner();
  Bool_t foundCINT1B = kFALSE;
  Bool_t foundCMUS1B = kFALSE;
  
  // add case any
  list->AddLast(new TObjString("trigger:any"));
  
  TObjString* trigClasseName = 0x0;
	
  TIter nextTrigger(fTriggerClass);
  while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
    
    //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
    //  cout<<"trigger name loop on "<<trigClasseName->GetName()<<" to look for "<<FiredTriggerClasses.Data()<<endl;
    TRegexp GenericTriggerClasseName(trigClasseName->String());
    if (FiredTriggerClasses.Contains(GenericTriggerClasseName)) {
      //AliInfo(Form("trigger names match = %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
      //cout<<"trigger names match "<<trigClasseName->GetName()<<" and "<<FiredTriggerClasses.Data()<<endl;
      // add specific trigger case
      TObjString* trigShortName = static_cast<TObjString*>(fTriggerClass->GetValue(trigClasseName));
      list->AddLast(new TObjString(Form("trigger:%s",trigShortName->GetName())));
      
      // check for CINT1B and CMUS1B trigger
      if (trigShortName->String() == "CINT1B") foundCINT1B = kTRUE;
      else if (trigShortName->String() == "CMUS1B") foundCMUS1B = kTRUE;
    }
  }
	
  // add the special case CINT1B+CMUS1B
  if (foundCINT1B && foundCMUS1B) list->AddLast(new TObjString("trigger:CINT1B+CMUS1B"));
	 
  return list;
}

 AliAnalysisTaskMuonQA.cxx:1
 AliAnalysisTaskMuonQA.cxx:2
 AliAnalysisTaskMuonQA.cxx:3
 AliAnalysisTaskMuonQA.cxx:4
 AliAnalysisTaskMuonQA.cxx:5
 AliAnalysisTaskMuonQA.cxx:6
 AliAnalysisTaskMuonQA.cxx:7
 AliAnalysisTaskMuonQA.cxx:8
 AliAnalysisTaskMuonQA.cxx:9
 AliAnalysisTaskMuonQA.cxx:10
 AliAnalysisTaskMuonQA.cxx:11
 AliAnalysisTaskMuonQA.cxx:12
 AliAnalysisTaskMuonQA.cxx:13
 AliAnalysisTaskMuonQA.cxx:14
 AliAnalysisTaskMuonQA.cxx:15
 AliAnalysisTaskMuonQA.cxx:16
 AliAnalysisTaskMuonQA.cxx:17
 AliAnalysisTaskMuonQA.cxx:18
 AliAnalysisTaskMuonQA.cxx:19
 AliAnalysisTaskMuonQA.cxx:20
 AliAnalysisTaskMuonQA.cxx:21
 AliAnalysisTaskMuonQA.cxx:22
 AliAnalysisTaskMuonQA.cxx:23
 AliAnalysisTaskMuonQA.cxx:24
 AliAnalysisTaskMuonQA.cxx:25
 AliAnalysisTaskMuonQA.cxx:26
 AliAnalysisTaskMuonQA.cxx:27
 AliAnalysisTaskMuonQA.cxx:28
 AliAnalysisTaskMuonQA.cxx:29
 AliAnalysisTaskMuonQA.cxx:30
 AliAnalysisTaskMuonQA.cxx:31
 AliAnalysisTaskMuonQA.cxx:32
 AliAnalysisTaskMuonQA.cxx:33
 AliAnalysisTaskMuonQA.cxx:34
 AliAnalysisTaskMuonQA.cxx:35
 AliAnalysisTaskMuonQA.cxx:36
 AliAnalysisTaskMuonQA.cxx:37
 AliAnalysisTaskMuonQA.cxx:38
 AliAnalysisTaskMuonQA.cxx:39
 AliAnalysisTaskMuonQA.cxx:40
 AliAnalysisTaskMuonQA.cxx:41
 AliAnalysisTaskMuonQA.cxx:42
 AliAnalysisTaskMuonQA.cxx:43
 AliAnalysisTaskMuonQA.cxx:44
 AliAnalysisTaskMuonQA.cxx:45
 AliAnalysisTaskMuonQA.cxx:46
 AliAnalysisTaskMuonQA.cxx:47
 AliAnalysisTaskMuonQA.cxx:48
 AliAnalysisTaskMuonQA.cxx:49
 AliAnalysisTaskMuonQA.cxx:50
 AliAnalysisTaskMuonQA.cxx:51
 AliAnalysisTaskMuonQA.cxx:52
 AliAnalysisTaskMuonQA.cxx:53
 AliAnalysisTaskMuonQA.cxx:54
 AliAnalysisTaskMuonQA.cxx:55
 AliAnalysisTaskMuonQA.cxx:56
 AliAnalysisTaskMuonQA.cxx:57
 AliAnalysisTaskMuonQA.cxx:58
 AliAnalysisTaskMuonQA.cxx:59
 AliAnalysisTaskMuonQA.cxx:60
 AliAnalysisTaskMuonQA.cxx:61
 AliAnalysisTaskMuonQA.cxx:62
 AliAnalysisTaskMuonQA.cxx:63
 AliAnalysisTaskMuonQA.cxx:64
 AliAnalysisTaskMuonQA.cxx:65
 AliAnalysisTaskMuonQA.cxx:66
 AliAnalysisTaskMuonQA.cxx:67
 AliAnalysisTaskMuonQA.cxx:68
 AliAnalysisTaskMuonQA.cxx:69
 AliAnalysisTaskMuonQA.cxx:70
 AliAnalysisTaskMuonQA.cxx:71
 AliAnalysisTaskMuonQA.cxx:72
 AliAnalysisTaskMuonQA.cxx:73
 AliAnalysisTaskMuonQA.cxx:74
 AliAnalysisTaskMuonQA.cxx:75
 AliAnalysisTaskMuonQA.cxx:76
 AliAnalysisTaskMuonQA.cxx:77
 AliAnalysisTaskMuonQA.cxx:78
 AliAnalysisTaskMuonQA.cxx:79
 AliAnalysisTaskMuonQA.cxx:80
 AliAnalysisTaskMuonQA.cxx:81
 AliAnalysisTaskMuonQA.cxx:82
 AliAnalysisTaskMuonQA.cxx:83
 AliAnalysisTaskMuonQA.cxx:84
 AliAnalysisTaskMuonQA.cxx:85
 AliAnalysisTaskMuonQA.cxx:86
 AliAnalysisTaskMuonQA.cxx:87
 AliAnalysisTaskMuonQA.cxx:88
 AliAnalysisTaskMuonQA.cxx:89
 AliAnalysisTaskMuonQA.cxx:90
 AliAnalysisTaskMuonQA.cxx:91
 AliAnalysisTaskMuonQA.cxx:92
 AliAnalysisTaskMuonQA.cxx:93
 AliAnalysisTaskMuonQA.cxx:94
 AliAnalysisTaskMuonQA.cxx:95
 AliAnalysisTaskMuonQA.cxx:96
 AliAnalysisTaskMuonQA.cxx:97
 AliAnalysisTaskMuonQA.cxx:98
 AliAnalysisTaskMuonQA.cxx:99
 AliAnalysisTaskMuonQA.cxx:100
 AliAnalysisTaskMuonQA.cxx:101
 AliAnalysisTaskMuonQA.cxx:102
 AliAnalysisTaskMuonQA.cxx:103
 AliAnalysisTaskMuonQA.cxx:104
 AliAnalysisTaskMuonQA.cxx:105
 AliAnalysisTaskMuonQA.cxx:106
 AliAnalysisTaskMuonQA.cxx:107
 AliAnalysisTaskMuonQA.cxx:108
 AliAnalysisTaskMuonQA.cxx:109
 AliAnalysisTaskMuonQA.cxx:110
 AliAnalysisTaskMuonQA.cxx:111
 AliAnalysisTaskMuonQA.cxx:112
 AliAnalysisTaskMuonQA.cxx:113
 AliAnalysisTaskMuonQA.cxx:114
 AliAnalysisTaskMuonQA.cxx:115
 AliAnalysisTaskMuonQA.cxx:116
 AliAnalysisTaskMuonQA.cxx:117
 AliAnalysisTaskMuonQA.cxx:118
 AliAnalysisTaskMuonQA.cxx:119
 AliAnalysisTaskMuonQA.cxx:120
 AliAnalysisTaskMuonQA.cxx:121
 AliAnalysisTaskMuonQA.cxx:122
 AliAnalysisTaskMuonQA.cxx:123
 AliAnalysisTaskMuonQA.cxx:124
 AliAnalysisTaskMuonQA.cxx:125
 AliAnalysisTaskMuonQA.cxx:126
 AliAnalysisTaskMuonQA.cxx:127
 AliAnalysisTaskMuonQA.cxx:128
 AliAnalysisTaskMuonQA.cxx:129
 AliAnalysisTaskMuonQA.cxx:130
 AliAnalysisTaskMuonQA.cxx:131
 AliAnalysisTaskMuonQA.cxx:132
 AliAnalysisTaskMuonQA.cxx:133
 AliAnalysisTaskMuonQA.cxx:134
 AliAnalysisTaskMuonQA.cxx:135
 AliAnalysisTaskMuonQA.cxx:136
 AliAnalysisTaskMuonQA.cxx:137
 AliAnalysisTaskMuonQA.cxx:138
 AliAnalysisTaskMuonQA.cxx:139
 AliAnalysisTaskMuonQA.cxx:140
 AliAnalysisTaskMuonQA.cxx:141
 AliAnalysisTaskMuonQA.cxx:142
 AliAnalysisTaskMuonQA.cxx:143
 AliAnalysisTaskMuonQA.cxx:144
 AliAnalysisTaskMuonQA.cxx:145
 AliAnalysisTaskMuonQA.cxx:146
 AliAnalysisTaskMuonQA.cxx:147
 AliAnalysisTaskMuonQA.cxx:148
 AliAnalysisTaskMuonQA.cxx:149
 AliAnalysisTaskMuonQA.cxx:150
 AliAnalysisTaskMuonQA.cxx:151
 AliAnalysisTaskMuonQA.cxx:152
 AliAnalysisTaskMuonQA.cxx:153
 AliAnalysisTaskMuonQA.cxx:154
 AliAnalysisTaskMuonQA.cxx:155
 AliAnalysisTaskMuonQA.cxx:156
 AliAnalysisTaskMuonQA.cxx:157
 AliAnalysisTaskMuonQA.cxx:158
 AliAnalysisTaskMuonQA.cxx:159
 AliAnalysisTaskMuonQA.cxx:160
 AliAnalysisTaskMuonQA.cxx:161
 AliAnalysisTaskMuonQA.cxx:162
 AliAnalysisTaskMuonQA.cxx:163
 AliAnalysisTaskMuonQA.cxx:164
 AliAnalysisTaskMuonQA.cxx:165
 AliAnalysisTaskMuonQA.cxx:166
 AliAnalysisTaskMuonQA.cxx:167
 AliAnalysisTaskMuonQA.cxx:168
 AliAnalysisTaskMuonQA.cxx:169
 AliAnalysisTaskMuonQA.cxx:170
 AliAnalysisTaskMuonQA.cxx:171
 AliAnalysisTaskMuonQA.cxx:172
 AliAnalysisTaskMuonQA.cxx:173
 AliAnalysisTaskMuonQA.cxx:174
 AliAnalysisTaskMuonQA.cxx:175
 AliAnalysisTaskMuonQA.cxx:176
 AliAnalysisTaskMuonQA.cxx:177
 AliAnalysisTaskMuonQA.cxx:178
 AliAnalysisTaskMuonQA.cxx:179
 AliAnalysisTaskMuonQA.cxx:180
 AliAnalysisTaskMuonQA.cxx:181
 AliAnalysisTaskMuonQA.cxx:182
 AliAnalysisTaskMuonQA.cxx:183
 AliAnalysisTaskMuonQA.cxx:184
 AliAnalysisTaskMuonQA.cxx:185
 AliAnalysisTaskMuonQA.cxx:186
 AliAnalysisTaskMuonQA.cxx:187
 AliAnalysisTaskMuonQA.cxx:188
 AliAnalysisTaskMuonQA.cxx:189
 AliAnalysisTaskMuonQA.cxx:190
 AliAnalysisTaskMuonQA.cxx:191
 AliAnalysisTaskMuonQA.cxx:192
 AliAnalysisTaskMuonQA.cxx:193
 AliAnalysisTaskMuonQA.cxx:194
 AliAnalysisTaskMuonQA.cxx:195
 AliAnalysisTaskMuonQA.cxx:196
 AliAnalysisTaskMuonQA.cxx:197
 AliAnalysisTaskMuonQA.cxx:198
 AliAnalysisTaskMuonQA.cxx:199
 AliAnalysisTaskMuonQA.cxx:200
 AliAnalysisTaskMuonQA.cxx:201
 AliAnalysisTaskMuonQA.cxx:202
 AliAnalysisTaskMuonQA.cxx:203
 AliAnalysisTaskMuonQA.cxx:204
 AliAnalysisTaskMuonQA.cxx:205
 AliAnalysisTaskMuonQA.cxx:206
 AliAnalysisTaskMuonQA.cxx:207
 AliAnalysisTaskMuonQA.cxx:208
 AliAnalysisTaskMuonQA.cxx:209
 AliAnalysisTaskMuonQA.cxx:210
 AliAnalysisTaskMuonQA.cxx:211
 AliAnalysisTaskMuonQA.cxx:212
 AliAnalysisTaskMuonQA.cxx:213
 AliAnalysisTaskMuonQA.cxx:214
 AliAnalysisTaskMuonQA.cxx:215
 AliAnalysisTaskMuonQA.cxx:216
 AliAnalysisTaskMuonQA.cxx:217
 AliAnalysisTaskMuonQA.cxx:218
 AliAnalysisTaskMuonQA.cxx:219
 AliAnalysisTaskMuonQA.cxx:220
 AliAnalysisTaskMuonQA.cxx:221
 AliAnalysisTaskMuonQA.cxx:222
 AliAnalysisTaskMuonQA.cxx:223
 AliAnalysisTaskMuonQA.cxx:224
 AliAnalysisTaskMuonQA.cxx:225
 AliAnalysisTaskMuonQA.cxx:226
 AliAnalysisTaskMuonQA.cxx:227
 AliAnalysisTaskMuonQA.cxx:228
 AliAnalysisTaskMuonQA.cxx:229
 AliAnalysisTaskMuonQA.cxx:230
 AliAnalysisTaskMuonQA.cxx:231
 AliAnalysisTaskMuonQA.cxx:232
 AliAnalysisTaskMuonQA.cxx:233
 AliAnalysisTaskMuonQA.cxx:234
 AliAnalysisTaskMuonQA.cxx:235
 AliAnalysisTaskMuonQA.cxx:236
 AliAnalysisTaskMuonQA.cxx:237
 AliAnalysisTaskMuonQA.cxx:238
 AliAnalysisTaskMuonQA.cxx:239
 AliAnalysisTaskMuonQA.cxx:240
 AliAnalysisTaskMuonQA.cxx:241
 AliAnalysisTaskMuonQA.cxx:242
 AliAnalysisTaskMuonQA.cxx:243
 AliAnalysisTaskMuonQA.cxx:244
 AliAnalysisTaskMuonQA.cxx:245
 AliAnalysisTaskMuonQA.cxx:246
 AliAnalysisTaskMuonQA.cxx:247
 AliAnalysisTaskMuonQA.cxx:248
 AliAnalysisTaskMuonQA.cxx:249
 AliAnalysisTaskMuonQA.cxx:250
 AliAnalysisTaskMuonQA.cxx:251
 AliAnalysisTaskMuonQA.cxx:252
 AliAnalysisTaskMuonQA.cxx:253
 AliAnalysisTaskMuonQA.cxx:254
 AliAnalysisTaskMuonQA.cxx:255
 AliAnalysisTaskMuonQA.cxx:256
 AliAnalysisTaskMuonQA.cxx:257
 AliAnalysisTaskMuonQA.cxx:258
 AliAnalysisTaskMuonQA.cxx:259
 AliAnalysisTaskMuonQA.cxx:260
 AliAnalysisTaskMuonQA.cxx:261
 AliAnalysisTaskMuonQA.cxx:262
 AliAnalysisTaskMuonQA.cxx:263
 AliAnalysisTaskMuonQA.cxx:264
 AliAnalysisTaskMuonQA.cxx:265
 AliAnalysisTaskMuonQA.cxx:266
 AliAnalysisTaskMuonQA.cxx:267
 AliAnalysisTaskMuonQA.cxx:268
 AliAnalysisTaskMuonQA.cxx:269
 AliAnalysisTaskMuonQA.cxx:270
 AliAnalysisTaskMuonQA.cxx:271
 AliAnalysisTaskMuonQA.cxx:272
 AliAnalysisTaskMuonQA.cxx:273
 AliAnalysisTaskMuonQA.cxx:274
 AliAnalysisTaskMuonQA.cxx:275
 AliAnalysisTaskMuonQA.cxx:276
 AliAnalysisTaskMuonQA.cxx:277
 AliAnalysisTaskMuonQA.cxx:278
 AliAnalysisTaskMuonQA.cxx:279
 AliAnalysisTaskMuonQA.cxx:280
 AliAnalysisTaskMuonQA.cxx:281
 AliAnalysisTaskMuonQA.cxx:282
 AliAnalysisTaskMuonQA.cxx:283
 AliAnalysisTaskMuonQA.cxx:284
 AliAnalysisTaskMuonQA.cxx:285
 AliAnalysisTaskMuonQA.cxx:286
 AliAnalysisTaskMuonQA.cxx:287
 AliAnalysisTaskMuonQA.cxx:288
 AliAnalysisTaskMuonQA.cxx:289
 AliAnalysisTaskMuonQA.cxx:290
 AliAnalysisTaskMuonQA.cxx:291
 AliAnalysisTaskMuonQA.cxx:292
 AliAnalysisTaskMuonQA.cxx:293
 AliAnalysisTaskMuonQA.cxx:294
 AliAnalysisTaskMuonQA.cxx:295
 AliAnalysisTaskMuonQA.cxx:296
 AliAnalysisTaskMuonQA.cxx:297
 AliAnalysisTaskMuonQA.cxx:298
 AliAnalysisTaskMuonQA.cxx:299
 AliAnalysisTaskMuonQA.cxx:300
 AliAnalysisTaskMuonQA.cxx:301
 AliAnalysisTaskMuonQA.cxx:302
 AliAnalysisTaskMuonQA.cxx:303
 AliAnalysisTaskMuonQA.cxx:304
 AliAnalysisTaskMuonQA.cxx:305
 AliAnalysisTaskMuonQA.cxx:306
 AliAnalysisTaskMuonQA.cxx:307
 AliAnalysisTaskMuonQA.cxx:308
 AliAnalysisTaskMuonQA.cxx:309
 AliAnalysisTaskMuonQA.cxx:310
 AliAnalysisTaskMuonQA.cxx:311
 AliAnalysisTaskMuonQA.cxx:312
 AliAnalysisTaskMuonQA.cxx:313
 AliAnalysisTaskMuonQA.cxx:314
 AliAnalysisTaskMuonQA.cxx:315
 AliAnalysisTaskMuonQA.cxx:316
 AliAnalysisTaskMuonQA.cxx:317
 AliAnalysisTaskMuonQA.cxx:318
 AliAnalysisTaskMuonQA.cxx:319
 AliAnalysisTaskMuonQA.cxx:320
 AliAnalysisTaskMuonQA.cxx:321
 AliAnalysisTaskMuonQA.cxx:322
 AliAnalysisTaskMuonQA.cxx:323
 AliAnalysisTaskMuonQA.cxx:324
 AliAnalysisTaskMuonQA.cxx:325
 AliAnalysisTaskMuonQA.cxx:326
 AliAnalysisTaskMuonQA.cxx:327
 AliAnalysisTaskMuonQA.cxx:328
 AliAnalysisTaskMuonQA.cxx:329
 AliAnalysisTaskMuonQA.cxx:330
 AliAnalysisTaskMuonQA.cxx:331
 AliAnalysisTaskMuonQA.cxx:332
 AliAnalysisTaskMuonQA.cxx:333
 AliAnalysisTaskMuonQA.cxx:334
 AliAnalysisTaskMuonQA.cxx:335
 AliAnalysisTaskMuonQA.cxx:336
 AliAnalysisTaskMuonQA.cxx:337
 AliAnalysisTaskMuonQA.cxx:338
 AliAnalysisTaskMuonQA.cxx:339
 AliAnalysisTaskMuonQA.cxx:340
 AliAnalysisTaskMuonQA.cxx:341
 AliAnalysisTaskMuonQA.cxx:342
 AliAnalysisTaskMuonQA.cxx:343
 AliAnalysisTaskMuonQA.cxx:344
 AliAnalysisTaskMuonQA.cxx:345
 AliAnalysisTaskMuonQA.cxx:346
 AliAnalysisTaskMuonQA.cxx:347
 AliAnalysisTaskMuonQA.cxx:348
 AliAnalysisTaskMuonQA.cxx:349
 AliAnalysisTaskMuonQA.cxx:350
 AliAnalysisTaskMuonQA.cxx:351
 AliAnalysisTaskMuonQA.cxx:352
 AliAnalysisTaskMuonQA.cxx:353
 AliAnalysisTaskMuonQA.cxx:354
 AliAnalysisTaskMuonQA.cxx:355
 AliAnalysisTaskMuonQA.cxx:356
 AliAnalysisTaskMuonQA.cxx:357
 AliAnalysisTaskMuonQA.cxx:358
 AliAnalysisTaskMuonQA.cxx:359
 AliAnalysisTaskMuonQA.cxx:360
 AliAnalysisTaskMuonQA.cxx:361
 AliAnalysisTaskMuonQA.cxx:362
 AliAnalysisTaskMuonQA.cxx:363
 AliAnalysisTaskMuonQA.cxx:364
 AliAnalysisTaskMuonQA.cxx:365
 AliAnalysisTaskMuonQA.cxx:366
 AliAnalysisTaskMuonQA.cxx:367
 AliAnalysisTaskMuonQA.cxx:368
 AliAnalysisTaskMuonQA.cxx:369
 AliAnalysisTaskMuonQA.cxx:370
 AliAnalysisTaskMuonQA.cxx:371
 AliAnalysisTaskMuonQA.cxx:372
 AliAnalysisTaskMuonQA.cxx:373
 AliAnalysisTaskMuonQA.cxx:374
 AliAnalysisTaskMuonQA.cxx:375
 AliAnalysisTaskMuonQA.cxx:376
 AliAnalysisTaskMuonQA.cxx:377
 AliAnalysisTaskMuonQA.cxx:378
 AliAnalysisTaskMuonQA.cxx:379
 AliAnalysisTaskMuonQA.cxx:380
 AliAnalysisTaskMuonQA.cxx:381
 AliAnalysisTaskMuonQA.cxx:382
 AliAnalysisTaskMuonQA.cxx:383
 AliAnalysisTaskMuonQA.cxx:384
 AliAnalysisTaskMuonQA.cxx:385
 AliAnalysisTaskMuonQA.cxx:386
 AliAnalysisTaskMuonQA.cxx:387
 AliAnalysisTaskMuonQA.cxx:388
 AliAnalysisTaskMuonQA.cxx:389
 AliAnalysisTaskMuonQA.cxx:390
 AliAnalysisTaskMuonQA.cxx:391
 AliAnalysisTaskMuonQA.cxx:392
 AliAnalysisTaskMuonQA.cxx:393
 AliAnalysisTaskMuonQA.cxx:394
 AliAnalysisTaskMuonQA.cxx:395
 AliAnalysisTaskMuonQA.cxx:396
 AliAnalysisTaskMuonQA.cxx:397
 AliAnalysisTaskMuonQA.cxx:398
 AliAnalysisTaskMuonQA.cxx:399
 AliAnalysisTaskMuonQA.cxx:400
 AliAnalysisTaskMuonQA.cxx:401
 AliAnalysisTaskMuonQA.cxx:402
 AliAnalysisTaskMuonQA.cxx:403
 AliAnalysisTaskMuonQA.cxx:404
 AliAnalysisTaskMuonQA.cxx:405
 AliAnalysisTaskMuonQA.cxx:406
 AliAnalysisTaskMuonQA.cxx:407
 AliAnalysisTaskMuonQA.cxx:408
 AliAnalysisTaskMuonQA.cxx:409
 AliAnalysisTaskMuonQA.cxx:410
 AliAnalysisTaskMuonQA.cxx:411
 AliAnalysisTaskMuonQA.cxx:412
 AliAnalysisTaskMuonQA.cxx:413
 AliAnalysisTaskMuonQA.cxx:414
 AliAnalysisTaskMuonQA.cxx:415
 AliAnalysisTaskMuonQA.cxx:416
 AliAnalysisTaskMuonQA.cxx:417
 AliAnalysisTaskMuonQA.cxx:418
 AliAnalysisTaskMuonQA.cxx:419
 AliAnalysisTaskMuonQA.cxx:420
 AliAnalysisTaskMuonQA.cxx:421
 AliAnalysisTaskMuonQA.cxx:422
 AliAnalysisTaskMuonQA.cxx:423
 AliAnalysisTaskMuonQA.cxx:424
 AliAnalysisTaskMuonQA.cxx:425
 AliAnalysisTaskMuonQA.cxx:426
 AliAnalysisTaskMuonQA.cxx:427
 AliAnalysisTaskMuonQA.cxx:428
 AliAnalysisTaskMuonQA.cxx:429
 AliAnalysisTaskMuonQA.cxx:430
 AliAnalysisTaskMuonQA.cxx:431
 AliAnalysisTaskMuonQA.cxx:432
 AliAnalysisTaskMuonQA.cxx:433
 AliAnalysisTaskMuonQA.cxx:434
 AliAnalysisTaskMuonQA.cxx:435
 AliAnalysisTaskMuonQA.cxx:436
 AliAnalysisTaskMuonQA.cxx:437
 AliAnalysisTaskMuonQA.cxx:438
 AliAnalysisTaskMuonQA.cxx:439
 AliAnalysisTaskMuonQA.cxx:440
 AliAnalysisTaskMuonQA.cxx:441
 AliAnalysisTaskMuonQA.cxx:442
 AliAnalysisTaskMuonQA.cxx:443
 AliAnalysisTaskMuonQA.cxx:444
 AliAnalysisTaskMuonQA.cxx:445
 AliAnalysisTaskMuonQA.cxx:446
 AliAnalysisTaskMuonQA.cxx:447
 AliAnalysisTaskMuonQA.cxx:448
 AliAnalysisTaskMuonQA.cxx:449
 AliAnalysisTaskMuonQA.cxx:450
 AliAnalysisTaskMuonQA.cxx:451
 AliAnalysisTaskMuonQA.cxx:452
 AliAnalysisTaskMuonQA.cxx:453
 AliAnalysisTaskMuonQA.cxx:454
 AliAnalysisTaskMuonQA.cxx:455
 AliAnalysisTaskMuonQA.cxx:456
 AliAnalysisTaskMuonQA.cxx:457
 AliAnalysisTaskMuonQA.cxx:458
 AliAnalysisTaskMuonQA.cxx:459
 AliAnalysisTaskMuonQA.cxx:460
 AliAnalysisTaskMuonQA.cxx:461
 AliAnalysisTaskMuonQA.cxx:462
 AliAnalysisTaskMuonQA.cxx:463
 AliAnalysisTaskMuonQA.cxx:464
 AliAnalysisTaskMuonQA.cxx:465
 AliAnalysisTaskMuonQA.cxx:466
 AliAnalysisTaskMuonQA.cxx:467
 AliAnalysisTaskMuonQA.cxx:468
 AliAnalysisTaskMuonQA.cxx:469
 AliAnalysisTaskMuonQA.cxx:470
 AliAnalysisTaskMuonQA.cxx:471
 AliAnalysisTaskMuonQA.cxx:472
 AliAnalysisTaskMuonQA.cxx:473
 AliAnalysisTaskMuonQA.cxx:474
 AliAnalysisTaskMuonQA.cxx:475
 AliAnalysisTaskMuonQA.cxx:476
 AliAnalysisTaskMuonQA.cxx:477
 AliAnalysisTaskMuonQA.cxx:478
 AliAnalysisTaskMuonQA.cxx:479
 AliAnalysisTaskMuonQA.cxx:480
 AliAnalysisTaskMuonQA.cxx:481
 AliAnalysisTaskMuonQA.cxx:482
 AliAnalysisTaskMuonQA.cxx:483
 AliAnalysisTaskMuonQA.cxx:484
 AliAnalysisTaskMuonQA.cxx:485
 AliAnalysisTaskMuonQA.cxx:486
 AliAnalysisTaskMuonQA.cxx:487
 AliAnalysisTaskMuonQA.cxx:488
 AliAnalysisTaskMuonQA.cxx:489
 AliAnalysisTaskMuonQA.cxx:490
 AliAnalysisTaskMuonQA.cxx:491
 AliAnalysisTaskMuonQA.cxx:492
 AliAnalysisTaskMuonQA.cxx:493
 AliAnalysisTaskMuonQA.cxx:494
 AliAnalysisTaskMuonQA.cxx:495
 AliAnalysisTaskMuonQA.cxx:496
 AliAnalysisTaskMuonQA.cxx:497
 AliAnalysisTaskMuonQA.cxx:498
 AliAnalysisTaskMuonQA.cxx:499
 AliAnalysisTaskMuonQA.cxx:500
 AliAnalysisTaskMuonQA.cxx:501
 AliAnalysisTaskMuonQA.cxx:502
 AliAnalysisTaskMuonQA.cxx:503
 AliAnalysisTaskMuonQA.cxx:504
 AliAnalysisTaskMuonQA.cxx:505
 AliAnalysisTaskMuonQA.cxx:506
 AliAnalysisTaskMuonQA.cxx:507
 AliAnalysisTaskMuonQA.cxx:508
 AliAnalysisTaskMuonQA.cxx:509
 AliAnalysisTaskMuonQA.cxx:510
 AliAnalysisTaskMuonQA.cxx:511
 AliAnalysisTaskMuonQA.cxx:512
 AliAnalysisTaskMuonQA.cxx:513
 AliAnalysisTaskMuonQA.cxx:514
 AliAnalysisTaskMuonQA.cxx:515
 AliAnalysisTaskMuonQA.cxx:516
 AliAnalysisTaskMuonQA.cxx:517
 AliAnalysisTaskMuonQA.cxx:518
 AliAnalysisTaskMuonQA.cxx:519
 AliAnalysisTaskMuonQA.cxx:520
 AliAnalysisTaskMuonQA.cxx:521
 AliAnalysisTaskMuonQA.cxx:522
 AliAnalysisTaskMuonQA.cxx:523
 AliAnalysisTaskMuonQA.cxx:524
 AliAnalysisTaskMuonQA.cxx:525
 AliAnalysisTaskMuonQA.cxx:526
 AliAnalysisTaskMuonQA.cxx:527
 AliAnalysisTaskMuonQA.cxx:528
 AliAnalysisTaskMuonQA.cxx:529
 AliAnalysisTaskMuonQA.cxx:530
 AliAnalysisTaskMuonQA.cxx:531
 AliAnalysisTaskMuonQA.cxx:532
 AliAnalysisTaskMuonQA.cxx:533
 AliAnalysisTaskMuonQA.cxx:534
 AliAnalysisTaskMuonQA.cxx:535
 AliAnalysisTaskMuonQA.cxx:536
 AliAnalysisTaskMuonQA.cxx:537
 AliAnalysisTaskMuonQA.cxx:538
 AliAnalysisTaskMuonQA.cxx:539
 AliAnalysisTaskMuonQA.cxx:540
 AliAnalysisTaskMuonQA.cxx:541
 AliAnalysisTaskMuonQA.cxx:542
 AliAnalysisTaskMuonQA.cxx:543
 AliAnalysisTaskMuonQA.cxx:544
 AliAnalysisTaskMuonQA.cxx:545
 AliAnalysisTaskMuonQA.cxx:546
 AliAnalysisTaskMuonQA.cxx:547
 AliAnalysisTaskMuonQA.cxx:548
 AliAnalysisTaskMuonQA.cxx:549
 AliAnalysisTaskMuonQA.cxx:550
 AliAnalysisTaskMuonQA.cxx:551
 AliAnalysisTaskMuonQA.cxx:552
 AliAnalysisTaskMuonQA.cxx:553
 AliAnalysisTaskMuonQA.cxx:554
 AliAnalysisTaskMuonQA.cxx:555
 AliAnalysisTaskMuonQA.cxx:556
 AliAnalysisTaskMuonQA.cxx:557
 AliAnalysisTaskMuonQA.cxx:558
 AliAnalysisTaskMuonQA.cxx:559
 AliAnalysisTaskMuonQA.cxx:560
 AliAnalysisTaskMuonQA.cxx:561
 AliAnalysisTaskMuonQA.cxx:562
 AliAnalysisTaskMuonQA.cxx:563
 AliAnalysisTaskMuonQA.cxx:564
 AliAnalysisTaskMuonQA.cxx:565
 AliAnalysisTaskMuonQA.cxx:566
 AliAnalysisTaskMuonQA.cxx:567
 AliAnalysisTaskMuonQA.cxx:568
 AliAnalysisTaskMuonQA.cxx:569
 AliAnalysisTaskMuonQA.cxx:570
 AliAnalysisTaskMuonQA.cxx:571
 AliAnalysisTaskMuonQA.cxx:572
 AliAnalysisTaskMuonQA.cxx:573
 AliAnalysisTaskMuonQA.cxx:574
 AliAnalysisTaskMuonQA.cxx:575
 AliAnalysisTaskMuonQA.cxx:576
 AliAnalysisTaskMuonQA.cxx:577
 AliAnalysisTaskMuonQA.cxx:578
 AliAnalysisTaskMuonQA.cxx:579
 AliAnalysisTaskMuonQA.cxx:580
 AliAnalysisTaskMuonQA.cxx:581
 AliAnalysisTaskMuonQA.cxx:582
 AliAnalysisTaskMuonQA.cxx:583
 AliAnalysisTaskMuonQA.cxx:584
 AliAnalysisTaskMuonQA.cxx:585
 AliAnalysisTaskMuonQA.cxx:586
 AliAnalysisTaskMuonQA.cxx:587
 AliAnalysisTaskMuonQA.cxx:588
 AliAnalysisTaskMuonQA.cxx:589
 AliAnalysisTaskMuonQA.cxx:590
 AliAnalysisTaskMuonQA.cxx:591
 AliAnalysisTaskMuonQA.cxx:592
 AliAnalysisTaskMuonQA.cxx:593
 AliAnalysisTaskMuonQA.cxx:594
 AliAnalysisTaskMuonQA.cxx:595
 AliAnalysisTaskMuonQA.cxx:596
 AliAnalysisTaskMuonQA.cxx:597
 AliAnalysisTaskMuonQA.cxx:598
 AliAnalysisTaskMuonQA.cxx:599
 AliAnalysisTaskMuonQA.cxx:600
 AliAnalysisTaskMuonQA.cxx:601
 AliAnalysisTaskMuonQA.cxx:602
 AliAnalysisTaskMuonQA.cxx:603
 AliAnalysisTaskMuonQA.cxx:604
 AliAnalysisTaskMuonQA.cxx:605
 AliAnalysisTaskMuonQA.cxx:606
 AliAnalysisTaskMuonQA.cxx:607
 AliAnalysisTaskMuonQA.cxx:608
 AliAnalysisTaskMuonQA.cxx:609
 AliAnalysisTaskMuonQA.cxx:610
 AliAnalysisTaskMuonQA.cxx:611
 AliAnalysisTaskMuonQA.cxx:612
 AliAnalysisTaskMuonQA.cxx:613
 AliAnalysisTaskMuonQA.cxx:614
 AliAnalysisTaskMuonQA.cxx:615
 AliAnalysisTaskMuonQA.cxx:616
 AliAnalysisTaskMuonQA.cxx:617
 AliAnalysisTaskMuonQA.cxx:618
 AliAnalysisTaskMuonQA.cxx:619
 AliAnalysisTaskMuonQA.cxx:620
 AliAnalysisTaskMuonQA.cxx:621
 AliAnalysisTaskMuonQA.cxx:622
 AliAnalysisTaskMuonQA.cxx:623
 AliAnalysisTaskMuonQA.cxx:624
 AliAnalysisTaskMuonQA.cxx:625
 AliAnalysisTaskMuonQA.cxx:626
 AliAnalysisTaskMuonQA.cxx:627
 AliAnalysisTaskMuonQA.cxx:628
 AliAnalysisTaskMuonQA.cxx:629
 AliAnalysisTaskMuonQA.cxx:630
 AliAnalysisTaskMuonQA.cxx:631
 AliAnalysisTaskMuonQA.cxx:632
 AliAnalysisTaskMuonQA.cxx:633
 AliAnalysisTaskMuonQA.cxx:634
 AliAnalysisTaskMuonQA.cxx:635
 AliAnalysisTaskMuonQA.cxx:636
 AliAnalysisTaskMuonQA.cxx:637
 AliAnalysisTaskMuonQA.cxx:638
 AliAnalysisTaskMuonQA.cxx:639
 AliAnalysisTaskMuonQA.cxx:640
 AliAnalysisTaskMuonQA.cxx:641
 AliAnalysisTaskMuonQA.cxx:642
 AliAnalysisTaskMuonQA.cxx:643
 AliAnalysisTaskMuonQA.cxx:644
 AliAnalysisTaskMuonQA.cxx:645
 AliAnalysisTaskMuonQA.cxx:646
 AliAnalysisTaskMuonQA.cxx:647
 AliAnalysisTaskMuonQA.cxx:648
 AliAnalysisTaskMuonQA.cxx:649
 AliAnalysisTaskMuonQA.cxx:650
 AliAnalysisTaskMuonQA.cxx:651
 AliAnalysisTaskMuonQA.cxx:652
 AliAnalysisTaskMuonQA.cxx:653
 AliAnalysisTaskMuonQA.cxx:654
 AliAnalysisTaskMuonQA.cxx:655
 AliAnalysisTaskMuonQA.cxx:656
 AliAnalysisTaskMuonQA.cxx:657
 AliAnalysisTaskMuonQA.cxx:658
 AliAnalysisTaskMuonQA.cxx:659
 AliAnalysisTaskMuonQA.cxx:660
 AliAnalysisTaskMuonQA.cxx:661
 AliAnalysisTaskMuonQA.cxx:662
 AliAnalysisTaskMuonQA.cxx:663
 AliAnalysisTaskMuonQA.cxx:664
 AliAnalysisTaskMuonQA.cxx:665
 AliAnalysisTaskMuonQA.cxx:666
 AliAnalysisTaskMuonQA.cxx:667
 AliAnalysisTaskMuonQA.cxx:668
 AliAnalysisTaskMuonQA.cxx:669
 AliAnalysisTaskMuonQA.cxx:670
 AliAnalysisTaskMuonQA.cxx:671
 AliAnalysisTaskMuonQA.cxx:672
 AliAnalysisTaskMuonQA.cxx:673
 AliAnalysisTaskMuonQA.cxx:674
 AliAnalysisTaskMuonQA.cxx:675
 AliAnalysisTaskMuonQA.cxx:676
 AliAnalysisTaskMuonQA.cxx:677
 AliAnalysisTaskMuonQA.cxx:678
 AliAnalysisTaskMuonQA.cxx:679
 AliAnalysisTaskMuonQA.cxx:680
 AliAnalysisTaskMuonQA.cxx:681
 AliAnalysisTaskMuonQA.cxx:682
 AliAnalysisTaskMuonQA.cxx:683
 AliAnalysisTaskMuonQA.cxx:684
 AliAnalysisTaskMuonQA.cxx:685
 AliAnalysisTaskMuonQA.cxx:686
 AliAnalysisTaskMuonQA.cxx:687
 AliAnalysisTaskMuonQA.cxx:688
 AliAnalysisTaskMuonQA.cxx:689
 AliAnalysisTaskMuonQA.cxx:690
 AliAnalysisTaskMuonQA.cxx:691
 AliAnalysisTaskMuonQA.cxx:692
 AliAnalysisTaskMuonQA.cxx:693
 AliAnalysisTaskMuonQA.cxx:694
 AliAnalysisTaskMuonQA.cxx:695
 AliAnalysisTaskMuonQA.cxx:696
 AliAnalysisTaskMuonQA.cxx:697
 AliAnalysisTaskMuonQA.cxx:698
 AliAnalysisTaskMuonQA.cxx:699
 AliAnalysisTaskMuonQA.cxx:700
 AliAnalysisTaskMuonQA.cxx:701
 AliAnalysisTaskMuonQA.cxx:702
 AliAnalysisTaskMuonQA.cxx:703
 AliAnalysisTaskMuonQA.cxx:704
 AliAnalysisTaskMuonQA.cxx:705
 AliAnalysisTaskMuonQA.cxx:706
 AliAnalysisTaskMuonQA.cxx:707
 AliAnalysisTaskMuonQA.cxx:708
 AliAnalysisTaskMuonQA.cxx:709
 AliAnalysisTaskMuonQA.cxx:710
 AliAnalysisTaskMuonQA.cxx:711
 AliAnalysisTaskMuonQA.cxx:712
 AliAnalysisTaskMuonQA.cxx:713
 AliAnalysisTaskMuonQA.cxx:714
 AliAnalysisTaskMuonQA.cxx:715
 AliAnalysisTaskMuonQA.cxx:716
 AliAnalysisTaskMuonQA.cxx:717
 AliAnalysisTaskMuonQA.cxx:718
 AliAnalysisTaskMuonQA.cxx:719
 AliAnalysisTaskMuonQA.cxx:720
 AliAnalysisTaskMuonQA.cxx:721
 AliAnalysisTaskMuonQA.cxx:722
 AliAnalysisTaskMuonQA.cxx:723
 AliAnalysisTaskMuonQA.cxx:724
 AliAnalysisTaskMuonQA.cxx:725
 AliAnalysisTaskMuonQA.cxx:726
 AliAnalysisTaskMuonQA.cxx:727
 AliAnalysisTaskMuonQA.cxx:728
 AliAnalysisTaskMuonQA.cxx:729
 AliAnalysisTaskMuonQA.cxx:730
 AliAnalysisTaskMuonQA.cxx:731
 AliAnalysisTaskMuonQA.cxx:732
 AliAnalysisTaskMuonQA.cxx:733
 AliAnalysisTaskMuonQA.cxx:734
 AliAnalysisTaskMuonQA.cxx:735
 AliAnalysisTaskMuonQA.cxx:736
 AliAnalysisTaskMuonQA.cxx:737
 AliAnalysisTaskMuonQA.cxx:738
 AliAnalysisTaskMuonQA.cxx:739
 AliAnalysisTaskMuonQA.cxx:740
 AliAnalysisTaskMuonQA.cxx:741
 AliAnalysisTaskMuonQA.cxx:742
 AliAnalysisTaskMuonQA.cxx:743
 AliAnalysisTaskMuonQA.cxx:744
 AliAnalysisTaskMuonQA.cxx:745
 AliAnalysisTaskMuonQA.cxx:746
 AliAnalysisTaskMuonQA.cxx:747
 AliAnalysisTaskMuonQA.cxx:748
 AliAnalysisTaskMuonQA.cxx:749
 AliAnalysisTaskMuonQA.cxx:750
 AliAnalysisTaskMuonQA.cxx:751
 AliAnalysisTaskMuonQA.cxx:752
 AliAnalysisTaskMuonQA.cxx:753
 AliAnalysisTaskMuonQA.cxx:754
 AliAnalysisTaskMuonQA.cxx:755
 AliAnalysisTaskMuonQA.cxx:756
 AliAnalysisTaskMuonQA.cxx:757
 AliAnalysisTaskMuonQA.cxx:758
 AliAnalysisTaskMuonQA.cxx:759
 AliAnalysisTaskMuonQA.cxx:760
 AliAnalysisTaskMuonQA.cxx:761
 AliAnalysisTaskMuonQA.cxx:762
 AliAnalysisTaskMuonQA.cxx:763
 AliAnalysisTaskMuonQA.cxx:764
 AliAnalysisTaskMuonQA.cxx:765
 AliAnalysisTaskMuonQA.cxx:766
 AliAnalysisTaskMuonQA.cxx:767
 AliAnalysisTaskMuonQA.cxx:768
 AliAnalysisTaskMuonQA.cxx:769
 AliAnalysisTaskMuonQA.cxx:770
 AliAnalysisTaskMuonQA.cxx:771
 AliAnalysisTaskMuonQA.cxx:772
 AliAnalysisTaskMuonQA.cxx:773
 AliAnalysisTaskMuonQA.cxx:774
 AliAnalysisTaskMuonQA.cxx:775
 AliAnalysisTaskMuonQA.cxx:776
 AliAnalysisTaskMuonQA.cxx:777
 AliAnalysisTaskMuonQA.cxx:778
 AliAnalysisTaskMuonQA.cxx:779
 AliAnalysisTaskMuonQA.cxx:780
 AliAnalysisTaskMuonQA.cxx:781
 AliAnalysisTaskMuonQA.cxx:782
 AliAnalysisTaskMuonQA.cxx:783
 AliAnalysisTaskMuonQA.cxx:784
 AliAnalysisTaskMuonQA.cxx:785
 AliAnalysisTaskMuonQA.cxx:786
 AliAnalysisTaskMuonQA.cxx:787
 AliAnalysisTaskMuonQA.cxx:788
 AliAnalysisTaskMuonQA.cxx:789
 AliAnalysisTaskMuonQA.cxx:790
 AliAnalysisTaskMuonQA.cxx:791
 AliAnalysisTaskMuonQA.cxx:792
 AliAnalysisTaskMuonQA.cxx:793
 AliAnalysisTaskMuonQA.cxx:794
 AliAnalysisTaskMuonQA.cxx:795
 AliAnalysisTaskMuonQA.cxx:796
 AliAnalysisTaskMuonQA.cxx:797
 AliAnalysisTaskMuonQA.cxx:798
 AliAnalysisTaskMuonQA.cxx:799
 AliAnalysisTaskMuonQA.cxx:800
 AliAnalysisTaskMuonQA.cxx:801
 AliAnalysisTaskMuonQA.cxx:802
 AliAnalysisTaskMuonQA.cxx:803
 AliAnalysisTaskMuonQA.cxx:804
 AliAnalysisTaskMuonQA.cxx:805
 AliAnalysisTaskMuonQA.cxx:806
 AliAnalysisTaskMuonQA.cxx:807
 AliAnalysisTaskMuonQA.cxx:808
 AliAnalysisTaskMuonQA.cxx:809
 AliAnalysisTaskMuonQA.cxx:810
 AliAnalysisTaskMuonQA.cxx:811
 AliAnalysisTaskMuonQA.cxx:812
 AliAnalysisTaskMuonQA.cxx:813
 AliAnalysisTaskMuonQA.cxx:814
 AliAnalysisTaskMuonQA.cxx:815
 AliAnalysisTaskMuonQA.cxx:816
 AliAnalysisTaskMuonQA.cxx:817
 AliAnalysisTaskMuonQA.cxx:818
 AliAnalysisTaskMuonQA.cxx:819
 AliAnalysisTaskMuonQA.cxx:820
 AliAnalysisTaskMuonQA.cxx:821
 AliAnalysisTaskMuonQA.cxx:822
 AliAnalysisTaskMuonQA.cxx:823
 AliAnalysisTaskMuonQA.cxx:824
 AliAnalysisTaskMuonQA.cxx:825
 AliAnalysisTaskMuonQA.cxx:826
 AliAnalysisTaskMuonQA.cxx:827
 AliAnalysisTaskMuonQA.cxx:828
 AliAnalysisTaskMuonQA.cxx:829
 AliAnalysisTaskMuonQA.cxx:830
 AliAnalysisTaskMuonQA.cxx:831
 AliAnalysisTaskMuonQA.cxx:832
 AliAnalysisTaskMuonQA.cxx:833
 AliAnalysisTaskMuonQA.cxx:834
 AliAnalysisTaskMuonQA.cxx:835
 AliAnalysisTaskMuonQA.cxx:836
 AliAnalysisTaskMuonQA.cxx:837
 AliAnalysisTaskMuonQA.cxx:838
 AliAnalysisTaskMuonQA.cxx:839
 AliAnalysisTaskMuonQA.cxx:840
 AliAnalysisTaskMuonQA.cxx:841
 AliAnalysisTaskMuonQA.cxx:842
 AliAnalysisTaskMuonQA.cxx:843
 AliAnalysisTaskMuonQA.cxx:844
 AliAnalysisTaskMuonQA.cxx:845
 AliAnalysisTaskMuonQA.cxx:846
 AliAnalysisTaskMuonQA.cxx:847
 AliAnalysisTaskMuonQA.cxx:848
 AliAnalysisTaskMuonQA.cxx:849
 AliAnalysisTaskMuonQA.cxx:850
 AliAnalysisTaskMuonQA.cxx:851
 AliAnalysisTaskMuonQA.cxx:852
 AliAnalysisTaskMuonQA.cxx:853
 AliAnalysisTaskMuonQA.cxx:854
 AliAnalysisTaskMuonQA.cxx:855
 AliAnalysisTaskMuonQA.cxx:856
 AliAnalysisTaskMuonQA.cxx:857
 AliAnalysisTaskMuonQA.cxx:858
 AliAnalysisTaskMuonQA.cxx:859
 AliAnalysisTaskMuonQA.cxx:860
 AliAnalysisTaskMuonQA.cxx:861
 AliAnalysisTaskMuonQA.cxx:862
 AliAnalysisTaskMuonQA.cxx:863
 AliAnalysisTaskMuonQA.cxx:864
 AliAnalysisTaskMuonQA.cxx:865
 AliAnalysisTaskMuonQA.cxx:866
 AliAnalysisTaskMuonQA.cxx:867
 AliAnalysisTaskMuonQA.cxx:868
 AliAnalysisTaskMuonQA.cxx:869
 AliAnalysisTaskMuonQA.cxx:870
 AliAnalysisTaskMuonQA.cxx:871
 AliAnalysisTaskMuonQA.cxx:872
 AliAnalysisTaskMuonQA.cxx:873
 AliAnalysisTaskMuonQA.cxx:874
 AliAnalysisTaskMuonQA.cxx:875
 AliAnalysisTaskMuonQA.cxx:876
 AliAnalysisTaskMuonQA.cxx:877
 AliAnalysisTaskMuonQA.cxx:878
 AliAnalysisTaskMuonQA.cxx:879
 AliAnalysisTaskMuonQA.cxx:880
 AliAnalysisTaskMuonQA.cxx:881
 AliAnalysisTaskMuonQA.cxx:882
 AliAnalysisTaskMuonQA.cxx:883
 AliAnalysisTaskMuonQA.cxx:884
 AliAnalysisTaskMuonQA.cxx:885
 AliAnalysisTaskMuonQA.cxx:886
 AliAnalysisTaskMuonQA.cxx:887
 AliAnalysisTaskMuonQA.cxx:888
 AliAnalysisTaskMuonQA.cxx:889
 AliAnalysisTaskMuonQA.cxx:890
 AliAnalysisTaskMuonQA.cxx:891
 AliAnalysisTaskMuonQA.cxx:892
 AliAnalysisTaskMuonQA.cxx:893
 AliAnalysisTaskMuonQA.cxx:894
 AliAnalysisTaskMuonQA.cxx:895
 AliAnalysisTaskMuonQA.cxx:896
 AliAnalysisTaskMuonQA.cxx:897
 AliAnalysisTaskMuonQA.cxx:898
 AliAnalysisTaskMuonQA.cxx:899
 AliAnalysisTaskMuonQA.cxx:900
 AliAnalysisTaskMuonQA.cxx:901
 AliAnalysisTaskMuonQA.cxx:902
 AliAnalysisTaskMuonQA.cxx:903
 AliAnalysisTaskMuonQA.cxx:904
 AliAnalysisTaskMuonQA.cxx:905
 AliAnalysisTaskMuonQA.cxx:906
 AliAnalysisTaskMuonQA.cxx:907
 AliAnalysisTaskMuonQA.cxx:908
 AliAnalysisTaskMuonQA.cxx:909
 AliAnalysisTaskMuonQA.cxx:910
 AliAnalysisTaskMuonQA.cxx:911
 AliAnalysisTaskMuonQA.cxx:912
 AliAnalysisTaskMuonQA.cxx:913
 AliAnalysisTaskMuonQA.cxx:914
 AliAnalysisTaskMuonQA.cxx:915
 AliAnalysisTaskMuonQA.cxx:916
 AliAnalysisTaskMuonQA.cxx:917
 AliAnalysisTaskMuonQA.cxx:918
 AliAnalysisTaskMuonQA.cxx:919
 AliAnalysisTaskMuonQA.cxx:920
 AliAnalysisTaskMuonQA.cxx:921
 AliAnalysisTaskMuonQA.cxx:922
 AliAnalysisTaskMuonQA.cxx:923
 AliAnalysisTaskMuonQA.cxx:924
 AliAnalysisTaskMuonQA.cxx:925
 AliAnalysisTaskMuonQA.cxx:926
 AliAnalysisTaskMuonQA.cxx:927
 AliAnalysisTaskMuonQA.cxx:928
 AliAnalysisTaskMuonQA.cxx:929
 AliAnalysisTaskMuonQA.cxx:930
 AliAnalysisTaskMuonQA.cxx:931
 AliAnalysisTaskMuonQA.cxx:932
 AliAnalysisTaskMuonQA.cxx:933
 AliAnalysisTaskMuonQA.cxx:934
 AliAnalysisTaskMuonQA.cxx:935
 AliAnalysisTaskMuonQA.cxx:936
 AliAnalysisTaskMuonQA.cxx:937
 AliAnalysisTaskMuonQA.cxx:938
 AliAnalysisTaskMuonQA.cxx:939
 AliAnalysisTaskMuonQA.cxx:940
 AliAnalysisTaskMuonQA.cxx:941
 AliAnalysisTaskMuonQA.cxx:942
 AliAnalysisTaskMuonQA.cxx:943
 AliAnalysisTaskMuonQA.cxx:944
 AliAnalysisTaskMuonQA.cxx:945
 AliAnalysisTaskMuonQA.cxx:946
 AliAnalysisTaskMuonQA.cxx:947
 AliAnalysisTaskMuonQA.cxx:948
 AliAnalysisTaskMuonQA.cxx:949
 AliAnalysisTaskMuonQA.cxx:950
 AliAnalysisTaskMuonQA.cxx:951
 AliAnalysisTaskMuonQA.cxx:952
 AliAnalysisTaskMuonQA.cxx:953
 AliAnalysisTaskMuonQA.cxx:954
 AliAnalysisTaskMuonQA.cxx:955
 AliAnalysisTaskMuonQA.cxx:956
 AliAnalysisTaskMuonQA.cxx:957