PWGPP/MUON/lite/AliAnalysisTaskMuonQA.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 #include <Riostream.h>
  19
  20 // ROOT includes
  21 #include "TH1F.h"
  22 #include "TH2F.h"
  23 #include "TCanvas.h"
  24 #include "TROOT.h"
  25 #include "TString.h"
  26 #include "TObjArray.h"
  27 #include "TMath.h"
  28 #include "TFile.h"
  29 #include "TRegexp.h"
  30 #include "TMap.h"
  31 #include "TList.h"
  32 #include "TObjString.h"
  33
  34 // STEER includes
  35 #include "AliESDEvent.h"
  36 #include "AliESDMuonTrack.h"
  37 #include "AliESDMuonCluster.h"
  38 #include "AliESDInputHandler.h"
  39 #include "AliESDVZERO.h"
  40
  41 // ANALYSIS includes
  42 #include "AliAnalysisDataSlot.h"
  43 #include "AliAnalysisManager.h"
  44 #include "AliAnalysisTaskMuonQA.h"
  45 #include "AliCounterCollection.h"
  46 #include "AliPhysicsSelection.h"
  47 #include "AliTriggerAnalysis.h"
  48
  49 // PWG includes
  50 #include "AliAnalysisMuonUtility.h"
  51 #include "AliMuonTrackCuts.h"
  52
  53 using std::cout;
  54 using std::endl;
  55
  56 ClassImp(AliAnalysisTaskMuonQA)
  57
  58 const Int_t AliAnalysisTaskMuonQA::nCh = 10;
  59
  60 const Int_t AliAnalysisTaskMuonQA::nDE = 1100;
  61
  62 const Float_t AliAnalysisTaskMuonQA::dMax[5] = {176.6, 229.0, 308.84, 418.2,  522.0}; // cm
  63
  64 //________________________________________________________________________
  65 AliAnalysisTaskMuonQA::AliAnalysisTaskMuonQA() :
  66   AliAnalysisTaskSE(),
  67   fList(0x0),
  68   fListExpert(0x0),
  69   fListNorm(0x0),
  70   fTrackCounters(0x0),
  71   fEventCounters(0x0),
  72   fSelectCharge(0),
  73   fSelectPhysics(kFALSE),
  74   fSelectTrigger(kFALSE),
  75   fTriggerMask(0),
  76   fSelectMatched(kFALSE),
  77   fApplyAccCut(kFALSE),
  78   fTriggerClass(0x0),
  79   fSelectTriggerClass(0x0),
  80   fTrackCuts(0x0),
  81   fMuonTrigIndex()
  82 {
  83   // Dummy constructor
  84 }
  85
  86 //________________________________________________________________________
  87 AliAnalysisTaskMuonQA::AliAnalysisTaskMuonQA(const char *name) :
  88   AliAnalysisTaskSE(name),
  89   fList(0x0),
  90   fListExpert(0x0),
  91   fListNorm(0x0),
  92   fTrackCounters(0x0),
  93   fEventCounters(0x0),
  94   fSelectCharge(0),
  95   fSelectPhysics(kFALSE),
  96   fSelectTrigger(kFALSE),
  97   fTriggerMask(0),
  98   fSelectMatched(kFALSE),
  99   fApplyAccCut(kFALSE),
 100   fTriggerClass(0x0),
 101   fSelectTriggerClass(0x0),
 102   fTrackCuts(new AliMuonTrackCuts("stdMuonCuts","stdMuonCuts")),
 103   fMuonTrigIndex()
 104 {
 105   /// Constructor
 106
 107   // Output slot #1 writes into a TObjArray container
 108   DefineOutput(1,TObjArray::Class());
 109   // Output slot #2 writes into a TObjArray container
 110   DefineOutput(2,TObjArray::Class());
 111   // Output slot #3 writes track counters
 112   DefineOutput(3,AliCounterCollection::Class());
 113   // Output slot #4 writes event counters
 114   DefineOutput(4,AliCounterCollection::Class());
 115   // Output slot #5 writes normalized histograms
 116   DefineOutput(5,TObjArray::Class());
 117
 118   fTrackCuts->SetFilterMask(AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs | AliMuonTrackCuts::kMuPdca );
 119   fTrackCuts->SetAllowDefaultParams(kTRUE);
 120 }
 121
 122 //________________________________________________________________________
 123 AliAnalysisTaskMuonQA::~AliAnalysisTaskMuonQA()
 124 {
 125   /// Destructor
 126   if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 127     delete fList;
 128     delete fListExpert;
 129     delete fTrackCounters;
 130     delete fEventCounters;
 131     delete fListNorm;
 132   }
 133   delete fTriggerClass;
 134   delete fSelectTriggerClass;
 135   delete fTrackCuts;
 136 }
 137
 138
 139 //___________________________________________________________________________
 140 void AliAnalysisTaskMuonQA::NotifyRun()
 141 {
 142   /// Notify run
 143   fTrackCuts->SetRun(fInputHandler);
 144 }
 145
 146
 147 //___________________________________________________________________________
 148 void AliAnalysisTaskMuonQA::SetTrackCuts(AliMuonTrackCuts* trackCuts)
 149 {
 150   /// Set track cuts
 151   if ( fTrackCuts ) delete fTrackCuts;
 152   fTrackCuts = new AliMuonTrackCuts(*trackCuts);
 153 }
 154
 155
 156 //___________________________________________________________________________
 157 void AliAnalysisTaskMuonQA::UserCreateOutputObjects()
 158 {
 159   /// Create histograms and counters
 160
 161   // set the list of trigger classes with corresponding short names
 162   fTriggerClass = new TMap(20);
 163   fTriggerClass->SetOwnerKeyValue();
 164   // p-p trigger classes
 165   fTriggerClass->Add(new TObjString("CBEAMB"), new TObjString("CBEAMB"));
 166   fTriggerClass->Add(new TObjString("CINT1B-ABCE-NOPF-ALL"), new TObjString("CINT1B"));
 167   fTriggerClass->Add(new TObjString("CMUS1B-ABCE-NOPF-MUON"), new TObjString("CMUS1B"));
 168   fTriggerClass->Add(new TObjString("CINT1[AC]-"), new TObjString("CINT1AC"));
 169   fTriggerClass->Add(new TObjString("CMUS1[AC]-"), new TObjString("CMUS1AC"));
 170   fTriggerClass->Add(new TObjString("CINT1-E-"), new TObjString("CINT1E"));
 171   fTriggerClass->Add(new TObjString("CINT5-E-"), new TObjString("CINT5E"));
 172   fTriggerClass->Add(new TObjString("CMUS1-E-"), new TObjString("CMUS1E"));
 173   fTriggerClass->Add(new TObjString("CMUS5-E-"), new TObjString("CMUS5E"));
 174   fTriggerClass->Add(new TObjString("CINT1-B-"), new TObjString("CINT1B"));
 175   fTriggerClass->Add(new TObjString("CINT5-B-"), new TObjString("CINT5B"));
 176   fTriggerClass->Add(new TObjString("CMUS1-B-"), new TObjString("CMUS1B"));
 177   fTriggerClass->Add(new TObjString("CMUS5-B-"), new TObjString("CMUS5B"));
 178   fTriggerClass->Add(new TObjString("CINT1-AC-"), new TObjString("CINT1AC"));
 179   fTriggerClass->Add(new TObjString("CINT5-AC-"), new TObjString("CINT5AC"));
 180   fTriggerClass->Add(new TObjString("CMUS1-AC-"), new TObjString("CMUS1AC"));
 181   fTriggerClass->Add(new TObjString("CMUS5-AC-"), new TObjString("CMUS5AC"));
 182   fTriggerClass->Add(new TObjString("CSH1-B-"), new TObjString("CSH1B"));
 183
 184   TString side_pp[3] = {"B", "AC", "E"};
 185   for(Int_t i = 0; i< 3; i++){
 186     fTriggerClass->Add(new TObjString(Form("CINT7-%s-", side_pp[i].Data())), new TObjString(Form("CINT7%s",side_pp[i].Data())));
 187     fTriggerClass->Add(new TObjString(Form("CMUSH7-%s-",side_pp[i].Data())), new TObjString(Form("CMUSH7%s",side_pp[i].Data())));
 188     fTriggerClass->Add(new TObjString(Form("CMUL7-%s-",side_pp[i].Data())), new TObjString(Form("CMUL7%s",side_pp[i].Data())));
 189     fTriggerClass->Add(new TObjString(Form("CMUU7-%s-",side_pp[i].Data())), new TObjString(Form("CMUU7%s",side_pp[i].Data())));
 190     fTriggerClass->Add(new TObjString(Form("CMUS7-%s-",side_pp[i].Data())), new TObjString(Form("CMUS7%s",side_pp[i].Data())));
 191   }
 192   fTriggerClass->Add(new TObjString("CINT7-I-"), new TObjString("CINT7I"));
 193
 194   // Pb-Pb trigger classes
 195   TString side[4] = {"B", "A", "C", "E"};
 196   for (Int_t i = 0; i < 4; i++) {
 197     fTriggerClass->Add(new TObjString(Form("CMBACS2-%s-", side[i].Data())), new TObjString(Form("CMBACS2-%s", side[i].Data())));
 198     fTriggerClass->Add(new TObjString(Form("CMBS2A-%s-", side[i].Data())), new TObjString(Form("CMBS2A-%s", side[i].Data())));
 199     fTriggerClass->Add(new TObjString(Form("CMBS2C-%s-", side[i].Data())), new TObjString(Form("CMBS2C-%s", side[i].Data())));
 200     fTriggerClass->Add(new TObjString(Form("CMBAC-%s-", side[i].Data())), new TObjString(Form("CMBAC-%s", side[i].Data())));
 201     fTriggerClass->Add(new TObjString(Form("C0SMH-%s-", side[i].Data())), new TObjString(Form("C0SMH-%s", side[i].Data())));
 202   }
 203
 204   // set the list of trigger classes that can be selected to fill histograms (in case the physics selection is not used)
 205   fSelectTriggerClass = new TList();
 206   fSelectTriggerClass->SetOwner();
 207   // p-p trigger classes
 208   fSelectTriggerClass->AddLast(new TObjString("CINT1B-ABCE-NOPF-ALL")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 209   fSelectTriggerClass->AddLast(new TObjString("CMUS1B-ABCE-NOPF-MUON")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUON);
 210   fSelectTriggerClass->AddLast(new TObjString("CINT1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 211   fSelectTriggerClass->AddLast(new TObjString("CINT5-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kCINT5);
 212   fSelectTriggerClass->AddLast(new TObjString("CMUS1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUON);
 213   fSelectTriggerClass->AddLast(new TObjString("CMUS5-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kCMUS5);
 214   fSelectTriggerClass->AddLast(new TObjString("CINT7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kINT7);
 215   fSelectTriggerClass->AddLast(new TObjString("CINT7-I-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kINT7);
 216   fSelectTriggerClass->AddLast(new TObjString("CMUSH7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUSH7);
 217   fSelectTriggerClass->AddLast(new TObjString("CMUS7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUS7);
 218   fSelectTriggerClass->AddLast(new TObjString("CMUU7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUU7);
 219   fSelectTriggerClass->AddLast(new TObjString("CMUL7-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMUL7);
 220   fSelectTriggerClass->AddLast(new TObjString("CSH1-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kHighMult);
 221
 222   // Pb-Pb trigger classes
 223   fSelectTriggerClass->AddLast(new TObjString("CMBACS2-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 224   fSelectTriggerClass->AddLast(new TObjString("CMBS2A-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 225   fSelectTriggerClass->AddLast(new TObjString("CMBS2C-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 226   fSelectTriggerClass->AddLast(new TObjString("CMBAC-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kMB);
 227   fSelectTriggerClass->AddLast(new TObjString("C0SMH-B-")); fSelectTriggerClass->Last()->SetUniqueID(AliVEvent::kHighMult);
 228
 229   // create histograms
 230   fList = new TObjArray(2000);
 231   fList->SetOwner();
 232   fListExpert = new TObjArray(2000);
 233   fListExpert->SetOwner();
 234
 235   // event info
 236   TH1F* hNTracks = new TH1F("hNTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
 237   fList->AddAtAndExpand(hNTracks, kNTracks);
 238
 239   Int_t muonTrigIndex[] = { AliVEvent::kMuonUnlikePB, AliVEvent::kMuonLikePB, AliVEvent::kMUSHPB, AliVEvent::kMuonUnlikePB | AliVEvent::kMuonLikePB,
 240                             AliVEvent::kMuonUnlikePB | AliVEvent::kMUSHPB, AliVEvent::kMuonLikePB | AliVEvent::kMUSHPB,
 241                             AliVEvent::kMuonUnlikePB | AliVEvent::kMuonLikePB | AliVEvent::kMUSHPB};
 242   const Int_t nTrigIndexes = sizeof(muonTrigIndex)/sizeof(muonTrigIndex[0]);
 243   fMuonTrigIndex.Set(nTrigIndexes, muonTrigIndex);
 244   TString label[nTrigIndexes] = {"Unlike","Like", "Single Hpt","Like&Unlike","Unlike&Hpt","Like&Hpt","Unlike&Like&Hpt"};
 245   TH1I* hMuonTriggers = new TH1I("hMuonTriggers", "Muon triggers", nTrigIndexes, -0.5, -0.5+(Double_t)nTrigIndexes);
 246   for(Int_t ibin=0; ibin<nTrigIndexes; ibin++) hMuonTriggers->GetXaxis()->SetBinLabel(ibin+1,label[ibin].Data());
 247   fList->AddAtAndExpand(hMuonTriggers, kMuonTrig);
 248
 249   //track info
 250   TH1F* hMatchTrig = new TH1F("hMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
 251   fList->AddAtAndExpand(hMatchTrig, kMatchTrig);
 252
 253   TH1F* hSign = new TH1F("hSign", "track sign;sign", 3, -1.5, 1.5);
 254   fList->AddAtAndExpand(hSign, kSign);
 255
 256   TH1F* hDCA = new TH1F("hDCA", "DCA distribution;DCA (cm)", 500, 0., 500.);
 257   fList->AddAtAndExpand(hDCA, kDCA);
 258
 259   TH1F* hP = new TH1F("hP", "momentum distribution;p (GeV/c)", 300, 0., 300.);
 260   fList->AddAtAndExpand(hP, kP);
 261
 262   TH1F* hPMuPlus = new TH1F("hPMuPlus", "momentum distribution of #mu^{+};p (GeV/c)", 300, 0., 300.);
 263   fList->AddAtAndExpand(hPMuPlus, kPMuPlus);
 264
 265   TH1F* hPMuMinus = new TH1F("hPMuMinus", "momentum distribution of #mu^{-};p (GeV/c)", 300, 0., 300.);
 266   fList->AddAtAndExpand(hPMuMinus, kPMuMinus);
 267
 268   Int_t nPtBins = 300;
 269   Double_t ptMin = 0., ptMax = 30.;
 270
 271   TH1F* hPt = new TH1F("hPt", "transverse momentum distribution;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 272   fList->AddAtAndExpand(hPt, kPt);
 273
 274   TH1F* hPtMuPlus = new TH1F("hPtMuPlus", "transverse momentum distribution of #mu^{+};p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 275   fList->AddAtAndExpand(hPtMuPlus, kPtMuPlus);
 276
 277   TH1F* hPtMuMinus = new TH1F("hPtMuMinus", "transverse momentum distribution of #mu^{-};p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 278   fList->AddAtAndExpand(hPtMuMinus, kPtMuMinus);
 279
 280   TH1F* hRapidity = new TH1F("hRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
 281   fList->AddAtAndExpand(hRapidity, kRapidity);
 282
 283   TH1F* hThetaX = new TH1F("hThetaX", "#theta_{X} distribution;#theta_{X} (degree)", 360, -180., 180);
 284   fList->AddAtAndExpand(hThetaX, kThetaX);
 285
 286   TH1F* hThetaY = new TH1F("hThetaY", "#theta_{Y} distribution;#theta_{Y} (degree)", 360, -180., 180);
 287   fList->AddAtAndExpand(hThetaY, kThetaY);
 288
 289   TH1F* hChi2 = new TH1F("hChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
 290   fList->AddAtAndExpand(hChi2, kChi2);
 291
 292   TH1F* hProbChi2 = new TH1F("hProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
 293   fList->AddAtAndExpand(hProbChi2, kProbChi2);
 294
 295   // cluster info
 296   TH1F* hNClustersPerTrack = new TH1F("hNClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
 297   fList->AddAtAndExpand(hNClustersPerTrack, kNClustersPerTrack);
 298
 299   TH1F* hNChamberHitPerTrack = new TH1F("hNChamberHitPerTrack", "number of chambers hit per track;n_{chamber hit}", 15, 0., 15.);
 300   fList->AddAtAndExpand(hNChamberHitPerTrack, kNChamberHitPerTrack);
 301
 302   // Matched tracks info
 303   TH1F* hPtMatchLpt = new TH1F("hPtMatchLpt", "transverse momentum distribution matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 304   fList->AddAtAndExpand(hPtMatchLpt, kPtMatchLpt);
 305
 306   TH1F* hPtMatchHpt = new TH1F("hPtMatchHpt", "transverse momentum distribution matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 307   fList->AddAtAndExpand(hPtMatchHpt, kPtMatchHpt);
 308
 309   TH1F* hPtMuPlusMatchLpt = new TH1F("hPtMuPlusMatchLpt", "transverse momentum distribution of #mu^{+} matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 310   fList->AddAtAndExpand(hPtMuPlusMatchLpt, kPtMuPlusMatchLpt);
 311
 312   TH1F* hPtMuPlusMatchHpt = new TH1F("hPtMuPlusMatchHpt", "transverse momentum distribution of #mu^{+} matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 313   fList->AddAtAndExpand(hPtMuPlusMatchHpt, kPtMuPlusMatchHpt);
 314
 315   TH1F* hPtMuMinusMatchLpt = new TH1F("hPtMuMinusMatchLpt", "transverse momentum distribution of #mu^{-} matching Lpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 316   fList->AddAtAndExpand(hPtMuMinusMatchLpt, kPtMuMinusMatchLpt);
 317
 318   TH1F* hPtMuMinusMatchHpt = new TH1F("hPtMuMinusMatchHpt", "transverse momentum distribution of #mu^{-} matching Hpt;p_{t} (GeV/c)", nPtBins, ptMin, ptMax);
 319   fList->AddAtAndExpand(hPtMuMinusMatchHpt, kPtMuMinusMatchHpt);
 320
 321   TH1F* hNClustersPerCh = new TH1F("hNClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, -0.5, nCh-0.5);
 322   hNClustersPerCh->Sumw2();
 323   hNClustersPerCh->SetOption("P");
 324   hNClustersPerCh->SetMarkerStyle(kFullDotMedium);
 325   hNClustersPerCh->SetMarkerColor(kBlue);
 326   fListExpert->AddAtAndExpand(hNClustersPerCh, kNClustersPerCh);
 327
 328   TH1F* hNClustersPerDE = new TH1F("hNClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE+1, -0.5, nDE+0.5);
 329   hNClustersPerDE->Sumw2();
 330   hNClustersPerDE->SetOption("P");
 331   hNClustersPerDE->SetMarkerStyle(kFullDotMedium);
 332   hNClustersPerDE->SetMarkerColor(kBlue);
 333   fListExpert->AddAtAndExpand(hNClustersPerDE, kNClustersPerDE);
 334
 335   for (Int_t i = 0; i < nCh; i++) {
 336     Float_t rMax = 0.5*dMax[i/2];
 337     TH2F* hClusterHitMapInCh = new TH2F(Form("hClusterHitMapInCh%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
 338                                         100, -rMax, rMax, 100, -rMax, rMax);
 339     fListExpert->AddAtAndExpand(hClusterHitMapInCh, kClusterHitMapInCh+i);
 340
 341     TH1F* hClusterChargeInCh = new TH1F(Form("hClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (fC)",i+1), 100, 0., 1000.);
 342     fListExpert->AddAtAndExpand(hClusterChargeInCh, kClusterChargeInCh+i);
 343
 344     TH1F* hClusterSizeInCh = new TH1F(Form("hClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
 345     fListExpert->AddAtAndExpand(hClusterSizeInCh, kClusterSizeInCh+i);
 346   }
 347
 348   TH2F* hClusterChargePerDE = new TH2F("hClusterChargePerDE", "cluster charge distribution per DE;DetElem ID;charge (fC)", nDE+1, -0.5, nDE+0.5, 100, 0., 1000.);
 349   fListExpert->AddAtAndExpand(hClusterChargePerDE, kClusterChargePerDE);
 350
 351   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.);
 352   fListExpert->AddAtAndExpand(hClusterSizePerDE, kClusterSizePerDE);
 353
 354   // initialize track counters
 355   fTrackCounters = new AliCounterCollection("trackCounters");
 356   fTrackCounters->AddRubric("track", "trackeronly/triggeronly/matched");
 357   fTrackCounters->AddRubric("trigger", 1000000);
 358   fTrackCounters->AddRubric("run", 1000000);
 359   fTrackCounters->AddRubric("selected", "yes/no");
 360   fTrackCounters->AddRubric("triggerRO", "good/bad");
 361   fTrackCounters->AddRubric("v0mult", "low/int/high/any");
 362   fTrackCounters->AddRubric("charge", "pos/neg/any");
 363   fTrackCounters->AddRubric("pt", "low/high/any");
 364   fTrackCounters->AddRubric("acc", "in/out");
 365   fTrackCounters->AddRubric("tagTrack", "beamGas/good");
 366   fTrackCounters->AddRubric("t0pileup", "yes/no");
 367   fTrackCounters->AddRubric("bgID", "yes/no");
 368   fTrackCounters->AddRubric("spdpileup", "yes/no");
 369   fTrackCounters->Init();
 370
 371
 372   // initialize event counters
 373   fEventCounters = new AliCounterCollection("eventCounters");
 374   fEventCounters->AddRubric("event", "muon/any");
 375   fEventCounters->AddRubric("trigger", 1000000);
 376   fEventCounters->AddRubric("run", 1000000);
 377   fEventCounters->AddRubric("selected", "yes/no");
 378   fEventCounters->AddRubric("triggerRO", "good/bad");
 379   fEventCounters->AddRubric("v0mult", "low/int/high/any");
 380   fEventCounters->AddRubric("t0pileup", "yes/no");
 381   fEventCounters->AddRubric("spdpileup", "yes/no");
 382   fEventCounters->AddRubric("bgID", "yes/no");
 383   fEventCounters->Init();
 384
 385   // Post data at least once per task to ensure data synchronisation (required for merging)
 386   PostData(1, fList);
 387   PostData(2, fListExpert);
 388   PostData(3, fTrackCounters);
 389   PostData(4, fEventCounters);
 390 }
 391
 392 //________________________________________________________________________
 393 void AliAnalysisTaskMuonQA::UserExec(Option_t *)
 394 {
 395   /// Called for each event
 396
 397   AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 398   if (!fESD) {
 399     Printf("ERROR: fESD not available");
 400     return;
 401   }
 402
 403   //Flag for T0Pileup, SPDPileup and bgID (SPD cluster vs tracket)
 404   Bool_t t0PileUp = kFALSE, spdPileUp = kFALSE, bgID = kFALSE;
 405   spdPileUp = fESD->IsPileupFromSPDInMultBins();
 406   AliPhysicsSelection *physicsSelection = (AliPhysicsSelection*)((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->GetEventSelection();
 407   AliTriggerAnalysis * triggerAnalysis = (AliTriggerAnalysis*)physicsSelection->GetTriggerAnalysis();
 408   if ( physicsSelection && triggerAnalysis ) {
 409     t0PileUp = triggerAnalysis->EvaluateTrigger(fESD, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0Pileup));
 410     bgID = triggerAnalysis->EvaluateTrigger(fESD,  (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kSPDClsVsTrkBG | AliTriggerAnalysis::kOfflineFlag));
 411   }
 412
 413   UInt_t geomAccMask = ( AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs );
 414
 415   // check physics selection
 416   UInt_t triggerWord = (fInputHandler) ? fInputHandler->IsEventSelected() : 0;
 417   Bool_t isPhysicsSelected = (triggerWord != 0);
 418   TString selected = isPhysicsSelected ? "selected:yes" : "selected:no";
 419   selected += t0PileUp ? "/t0pileup:yes" : "/t0pileup:no";
 420   selected += bgID ? "/bgID:yes" : "/bgID:no";
 421   selected += spdPileUp ? "/spdpileup:yes" : "/spdpileup:no";
 422
 423   // fill muon trigger cases
 424   for ( Int_t idx=0; idx<fMuonTrigIndex.GetSize(); idx++ ) {
 425     UInt_t currMask = (UInt_t)fMuonTrigIndex[idx];
 426     if ( ( triggerWord & currMask ) == currMask ) ((TH1I*)fList->UncheckedAt(kMuonTrig))->Fill(idx);
 427   }
 428
 429   // check trigger selection
 430   TString FiredTriggerClasses = fESD->GetFiredTriggerClasses();
 431   if (!fSelectPhysics) triggerWord = BuildTriggerWord(FiredTriggerClasses);
 432   Bool_t isTriggerSelected = ((triggerWord & fTriggerMask) != 0);
 433
 434   // get the V0 multiplicity (except for p-p)
 435   AliESDVZERO* v0Data = fESD->GetVZEROData();
 436   Float_t v0Mult = 0.;
 437   const Int_t nV0MultRange = 4;
 438   const Int_t nCollType = 2;
 439   //define rough V0 mult. range (~ 80%, 60%, 10%, 0%)
 440   Int_t v0MultRange[nCollType][nV0MultRange]= {{239,1165,12191,20633},{25,60,200,800}};
 441   Int_t iCollType = 0;
 442
 443   if (v0Data) {
 444     if (!strcmp(fESD->GetBeamType(),"A-A")){
 445       iCollType = 0;
 446       for (Int_t i = 0 ; i < 64 ; i++) v0Mult += v0Data->GetMultiplicity(i);
 447     }
 448     else if (!strcmp(fESD->GetBeamType(),"p-A")){
 449       iCollType = 1;
 450       for (Int_t i = 0 ; i < 32 ; i++) v0Mult += v0Data->GetMultiplicityV0A(i);
 451     }
 452     else if (!strcmp(fESD->GetBeamType(),"A-p")){
 453       iCollType = 1;
 454       for (Int_t i = 0 ; i < 32 ; i++) v0Mult += v0Data->GetMultiplicityV0C(i);
 455     }
 456   }
 457
 458   TList listV0MultKey;
 459   listV0MultKey.SetOwner();
 460   listV0MultKey.AddLast(new TObjString("v0mult:any"));
 461   if (v0Mult >= v0MultRange[iCollType][0] && v0Mult < v0MultRange[iCollType][1]) listV0MultKey.AddLast(new TObjString("v0mult:low"));
 462   else if (v0Mult >= v0MultRange[iCollType][1] && v0Mult < v0MultRange[iCollType][2]) listV0MultKey.AddLast(new TObjString("v0mult:int"));
 463   else if (v0Mult >= v0MultRange[iCollType][2] && v0Mult < v0MultRange[iCollType][3]) listV0MultKey.AddLast(new TObjString("v0mult:high"));
 464
 465   TIter nextV0MultKey(&listV0MultKey);
 466
 467   // first loop over tracks to check for trigger readout problem
 468   Int_t maxTriggerRO = (!strcmp(fESD->GetBeamType(),"p-p")) ? 10 : 1000;
 469   Int_t nTracks = (Int_t) fESD->GetNumberOfMuonTracks();
 470   Int_t nTriggerTracks = 0;
 471   for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack)
 472     if (fESD->GetMuonTrack(iTrack)->ContainTriggerData()) nTriggerTracks++;
 473   TString triggerRO = (nTriggerTracks < maxTriggerRO) ? "triggerRO:good" : "triggerRO:bad";
 474
 475   // --- fill event counters ---
 476
 477   // build the list of trigger cases
 478   //TList* triggerCases = BuildListOfTriggerCases(FiredTriggerClasses);
 479   TList* triggerCases = BuildListOfAllTriggerCases(FiredTriggerClasses);
 480
 481   // loop over trigger cases
 482   TObjString* triggerKey = 0x0;
 483   TIter nextTriggerCase(triggerCases);
 484   while ((triggerKey = static_cast<TObjString*>(nextTriggerCase()))) {
 485
 486     // loop over V0Mult cases
 487     TObjString* v0MultKey = 0x0;
 488     nextV0MultKey.Reset();
 489     while ((v0MultKey = static_cast<TObjString*>(nextV0MultKey()))) {
 490
 491       // any event
 492       fEventCounters->Count(Form("event:any/%s/run:%d/%s/%s/%s", triggerKey->GetName(), fCurrentRunNumber, selected.Data(), triggerRO.Data(), v0MultKey->GetName()));
 493
 494       // muon event
 495       if (nTracks > 0) fEventCounters->Count(Form("event:muon/%s/run:%d/%s/%s/%s", triggerKey->GetName(), fCurrentRunNumber, selected.Data(), triggerRO.Data(), v0MultKey->GetName()));
 496
 497     }
 498
 499   }
 500
 501   // second loop over tracks to fill histograms and track counters
 502   Int_t nSelectedTrackerTracks = 0;
 503   Int_t nSelectedTrackMatchTrig = 0;
 504   Int_t nPVTracks = fESD->GetPrimaryVertex()->GetNContributors();
 505   for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) {
 506
 507     // get the ESD track
 508     AliESDMuonTrack* esdTrack = fESD->GetMuonTrack(iTrack);
 509
 510     // --- fill track counters ---
 511
 512     // define the key words
 513     TString trackKey = "track:";
 514     TString accKey = "acc:";
 515     Bool_t isBeamGas = kFALSE;
 516     TList chargeKeyList;
 517     chargeKeyList.SetOwner();
 518     chargeKeyList.Add(new TObjString("charge:any"));
 519     TList ptKeyList;
 520     ptKeyList.SetOwner();
 521     ptKeyList.Add(new TObjString("pt:any"));
 522     if (esdTrack->ContainTrackerData()) {
 523
 524       if (esdTrack->ContainTriggerData()) trackKey += "matched";
 525       else  trackKey += "trackeronly";
 526
 527       Short_t trackCharge = esdTrack->Charge();
 528       TString chargeKey = "charge:";
 529       chargeKey += ( trackCharge < 0 ) ? "neg" : "pos";
 530       chargeKeyList.Add(new TObjString(chargeKey));
 531
 532       UInt_t mask = fTrackCuts->GetSelectionMask(esdTrack);
 533       Bool_t passGeomAccCuts = ( ( mask & geomAccMask ) == geomAccMask );
 534       accKey += ( passGeomAccCuts ) ? "in" : "out";
 535       if ( passGeomAccCuts && nPVTracks>0 ) {
 536         Double_t trackPt = esdTrack->Pt();
 537         if ( trackPt > 1. ) ptKeyList.Add(new TObjString("pt:low"));
 538         if ( trackPt > 2. ) ptKeyList.Add(new TObjString("pt:high"));;
 539       }
 540       if ( ( mask & AliMuonTrackCuts::kMuPdca ) == 0 ) isBeamGas = kTRUE;
 541     } else {
 542
 543       trackKey += "triggeronly";
 544       accKey += "out"; // ghost are labelled out of the acceptance
 545
 546     }
 547
 548     TString tagKey = "tagTrack:";
 549     tagKey += ( isBeamGas ) ? "beamGas" : "good";
 550
 551     // loop over trigger cases and fill counters
 552     nextTriggerCase.Reset();
 553     while ((triggerKey = static_cast<TObjString*>(nextTriggerCase()))) {
 554
 555       // loop over V0Mult cases
 556       TObjString* v0MultKey = 0x0;
 557       nextV0MultKey.Reset();
 558       while ((v0MultKey = static_cast<TObjString*>(nextV0MultKey()))) {
 559
 560         for ( Int_t icharge=0; icharge<chargeKeyList.GetEntries(); icharge++ ) {
 561           for ( Int_t ipt=0; ipt<ptKeyList.GetEntries(); ipt++ ) {
 562             fTrackCounters->Count(Form("%s/%s/run:%d/%s/%s/%s/%s/%s/%s/%s", trackKey.Data(), triggerKey->GetName(), fCurrentRunNumber,
 563                                        selected.Data(), chargeKeyList.At(icharge)->GetName(), ptKeyList.At(ipt)->GetName(),
 564                                        triggerRO.Data(), v0MultKey->GetName(), accKey.Data(), tagKey.Data()));
 565           }
 566         }
 567       }
 568
 569     }
 570
 571     // --- apply selections and fill histograms with selected tracks ---
 572
 573     // remove "ghost"
 574     if (!esdTrack->ContainTrackerData()) continue;
 575
 576     // select on "physics" before filling histograms
 577     if (fSelectPhysics && !isPhysicsSelected) continue;
 578
 579     // select on trigger before filling histograms
 580     if (fSelectTrigger && !isTriggerSelected) continue;
 581
 582     // select on track charge
 583     if (fSelectCharge*esdTrack->Charge() < 0) continue;
 584
 585     // select on track matching
 586     if (fSelectMatched && !esdTrack->ContainTriggerData()) continue;
 587
 588     // skip tracks that do not pass the acceptance cuts if required
 589     if (fApplyAccCut && accKey.EndsWith("out")) continue;
 590
 591     nSelectedTrackerTracks++;
 592     if (esdTrack->ContainTriggerData()) nSelectedTrackMatchTrig++;
 593
 594     Double_t trackP = esdTrack->P();
 595     Double_t trackPt = esdTrack->Pt();
 596     Short_t trackCharge = esdTrack->Charge();
 597     ((TH1F*)fList->UncheckedAt(kP))->Fill(trackP);
 598     ((TH1F*)fList->UncheckedAt(kPt))->Fill(trackPt);
 599     Bool_t matchTrigLpt = (esdTrack->GetMatchTrigger()>=2);
 600     Bool_t matchTrigHpt = (esdTrack->GetMatchTrigger()>=3);
 601     if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMatchLpt))->Fill(trackPt);
 602     if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMatchHpt))->Fill(trackPt);
 603     if (trackCharge < 0) {
 604       ((TH1F*)fList->UncheckedAt(kPMuMinus))->Fill(trackP);
 605       ((TH1F*)fList->UncheckedAt(kPtMuMinus))->Fill(trackPt);
 606       if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMuMinusMatchLpt))->Fill(trackPt);
 607       if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMuMinusMatchHpt))->Fill(trackPt);
 608     } else {
 609       ((TH1F*)fList->UncheckedAt(kPMuPlus))->Fill(trackP);
 610       ((TH1F*)fList->UncheckedAt(kPtMuPlus))->Fill(trackPt);
 611       if ( matchTrigLpt ) ((TH1F*)fList->UncheckedAt(kPtMuPlusMatchLpt))->Fill(trackPt);
 612       if ( matchTrigHpt ) ((TH1F*)fList->UncheckedAt(kPtMuPlusMatchHpt))->Fill(trackPt);
 613     }
 614     ((TH1F*)fList->UncheckedAt(kRapidity))->Fill(esdTrack->Y());
 615     Int_t ndf = 2 * esdTrack->GetNHit() - 5;
 616     ((TH1F*)fList->UncheckedAt(kChi2))->Fill(esdTrack->GetChi2()/ndf);
 617     ((TH1F*)fList->UncheckedAt(kProbChi2))->Fill(TMath::Prob(esdTrack->GetChi2(),ndf));
 618     ((TH1F*)fList->UncheckedAt(kThetaX))->Fill(ChangeThetaRange(esdTrack->GetThetaXUncorrected()));
 619     ((TH1F*)fList->UncheckedAt(kThetaY))->Fill(ChangeThetaRange(esdTrack->GetThetaYUncorrected()));
 620     ((TH1F*)fList->UncheckedAt(kNClustersPerTrack))->Fill(esdTrack->GetNHit());
 621     ((TH1F*)fList->UncheckedAt(kSign))->Fill(trackCharge);
 622     ((TH1F*)fList->UncheckedAt(kDCA))->Fill(esdTrack->GetDCA());
 623
 624     Int_t nChamberHit = 0;
 625     for (Int_t ich=0; ich<10; ich++) if (esdTrack->IsInMuonClusterMap(ich)) nChamberHit++;
 626     ((TH1F*)fList->UncheckedAt(kNChamberHitPerTrack))->Fill(nChamberHit);
 627
 628     // loop over clusters
 629     for (Int_t icl=0; icl<esdTrack->GetNClusters(); icl++) {
 630
 631       AliESDMuonCluster* esdCluster = esdTrack->GetESDEvent()->FindMuonCluster(esdTrack->GetClusterId(icl));
 632
 633       Int_t chId = esdCluster->GetChamberId();
 634       Int_t deId = esdCluster->GetDetElemId();
 635
 636       ((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Fill(chId);
 637       ((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Fill(deId);
 638
 639       ((TH1F*)fListExpert->UncheckedAt(kClusterHitMapInCh+chId))->Fill(esdCluster->GetX(), esdCluster->GetY());
 640
 641       ((TH1F*)fListExpert->UncheckedAt(kClusterChargeInCh+chId))->Fill(esdCluster->GetCharge());
 642       ((TH1F*)fListExpert->UncheckedAt(kClusterChargePerDE))->Fill(deId, esdCluster->GetCharge());
 643
 644       if (esdCluster->PadsStored()) { // discard clusters with pad not stored in ESD
 645         ((TH1F*)fListExpert->UncheckedAt(kClusterSizeInCh+chId))->Fill(esdCluster->GetNPads());
 646         ((TH1F*)fListExpert->UncheckedAt(kClusterSizePerDE))->Fill(deId, esdCluster->GetNPads());
 647       }
 648
 649     }
 650
 651   }
 652
 653   if ((!fSelectPhysics || isPhysicsSelected) && (!fSelectTrigger || isTriggerSelected)) {
 654     ((TH1F*)fList->UncheckedAt(kNTracks))->Fill(nSelectedTrackerTracks);
 655     ((TH1F*)fList->UncheckedAt(kMatchTrig))->Fill(nSelectedTrackMatchTrig);
 656   }
 657
 658   // clean memory
 659   delete triggerCases;
 660
 661   // Post final data. It will be written to a file with option "RECREATE"
 662   PostData(1, fList);
 663   PostData(2, fListExpert);
 664   PostData(3, fTrackCounters);
 665   PostData(4, fEventCounters);
 666 }
 667
 668 //________________________________________________________________________
 669 void AliAnalysisTaskMuonQA::Terminate(Option_t *)
 670 {
 671   /// Normalize histograms
 672   /// Draw result to the screen
 673   /// Print statistics
 674
 675   // global statistic
 676   fTrackCounters = static_cast<AliCounterCollection*>(GetOutputData(3));
 677   fEventCounters = static_cast<AliCounterCollection*>(GetOutputData(4));
 678   if (fTrackCounters && fEventCounters) {
 679     if (!gROOT->IsBatch()) {
 680       cout<<"whole statistics without selection:"<<endl;
 681       fEventCounters->Print("trigger/event");
 682       fTrackCounters->Print("trigger/track");
 683       cout<<"whole statistics of selected events:"<<endl;
 684       fEventCounters->Print("trigger/event","selected:yes");
 685       fTrackCounters->Print("trigger/track","selected:yes");
 686       new TCanvas();
 687       fEventCounters->Draw("event","trigger","");
 688       new TCanvas();
 689       fTrackCounters->Draw("track","trigger","");
 690       new TCanvas();
 691       fEventCounters->Draw("event","trigger","selected:yes");
 692       new TCanvas();
 693       fTrackCounters->Draw("track","trigger","selected:yes");
 694     }
 695   }
 696
 697   // recover output histograms
 698   fList = static_cast<TObjArray*>(GetOutputData(1));
 699   fListExpert = static_cast<TObjArray*>(GetOutputData(2));
 700   if (!fList || !fListExpert) return;
 701
 702   // create summary plots
 703   fListNorm = new TObjArray(1000);
 704   fListNorm->SetOwner();
 705
 706   // mean/dispersion of cluster charge per chamber/DE
 707   TH1F* hClusterChargePerChMean = new TH1F("hClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (fC)", nCh, -0.5, nCh-0.5);
 708   hClusterChargePerChMean->SetOption("P");
 709   hClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
 710   hClusterChargePerChMean->SetMarkerColor(kBlue);
 711   fListNorm->AddAtAndExpand(hClusterChargePerChMean, kClusterChargePerChMean);
 712
 713   TH1F* hClusterChargePerChSigma = new TH1F("hClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (fC)", nCh, -0.5, nCh-0.5);
 714   hClusterChargePerChSigma->SetOption("P");
 715   hClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
 716   hClusterChargePerChSigma->SetMarkerColor(kBlue);
 717   fListNorm->AddAtAndExpand(hClusterChargePerChSigma, kClusterChargePerChSigma);
 718
 719   TH1F* hClusterChargePerDEMean = new TH1F("hClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID;<charge> (fC)", nDE+1, -0.5, nDE+0.5);
 720   hClusterChargePerDEMean->SetOption("P");
 721   hClusterChargePerDEMean->SetMarkerStyle(kFullDotMedium);
 722   hClusterChargePerDEMean->SetMarkerColor(kBlue);
 723   fListNorm->AddAtAndExpand(hClusterChargePerDEMean, kClusterChargePerDEMean);
 724
 725   TH1F* hClusterChargePerDESigma = new TH1F("hClusterChargePerDESigma", "cluster charge dispersion per DE;DetElem ID;#sigma_{charge} (fC)", nDE+1, -0.5, nDE+0.5);
 726   hClusterChargePerDESigma->SetOption("P");
 727   hClusterChargePerDESigma->SetMarkerStyle(kFullDotMedium);
 728   hClusterChargePerDESigma->SetMarkerColor(kBlue);
 729   fListNorm->AddAtAndExpand(hClusterChargePerDESigma, kClusterChargePerDESigma);
 730
 731   // mean/dispersion of cluster size per chamber/DE
 732   TH1F* hClusterSizePerChMean = new TH1F("hClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, -0.5, nCh-0.5);
 733   hClusterSizePerChMean->SetOption("P");
 734   hClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
 735   hClusterSizePerChMean->SetMarkerColor(kBlue);
 736   fListNorm->AddAtAndExpand(hClusterSizePerChMean, kClusterSizePerChMean);
 737
 738   TH1F* hClusterSizePerChSigma = new TH1F("hClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5);
 739   hClusterSizePerChSigma->SetOption("P");
 740   hClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
 741   hClusterSizePerChSigma->SetMarkerColor(kBlue);
 742   fListNorm->AddAtAndExpand(hClusterSizePerChSigma, kClusterSizePerChSigma);
 743
 744   TH1F* hClusterSizePerDEMean = new TH1F("hClusterSizePerDEMean", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE+1, -0.5, nDE+0.5);
 745   hClusterSizePerDEMean->SetOption("P");
 746   hClusterSizePerDEMean->SetMarkerStyle(kFullDotMedium);
 747   hClusterSizePerDEMean->SetMarkerColor(kBlue);
 748   fListNorm->AddAtAndExpand(hClusterSizePerDEMean, kClusterSizePerDEMean);
 749
 750   TH1F* hClusterSizePerDESigma = new TH1F("hClusterSizePerDESigma", "cluster size dispersion per DE;DetElem ID;#sigma_{size} (n_{pads})", nDE+1, -0.5, nDE+0.5);
 751   hClusterSizePerDESigma->SetOption("P");
 752   hClusterSizePerDESigma->SetMarkerStyle(kFullDotMedium);
 753   hClusterSizePerDESigma->SetMarkerColor(kBlue);
 754   fListNorm->AddAtAndExpand(hClusterSizePerDESigma, kClusterSizePerDESigma);
 755
 756   // normalize histograms
 757   Float_t nTracks = ((TH1F*)fList->UncheckedAt(kNClustersPerTrack))->GetEntries();
 758   if (nTracks > 0.) {
 759     ((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Scale(1./nTracks);
 760     ((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Scale(1./nTracks);
 761   }
 762   fListNorm->AddAtAndExpand(((TH1F*)fListExpert->UncheckedAt(kNClustersPerCh))->Clone(), kNClustersPerChPerTrack);
 763   fListNorm->AddAtAndExpand(((TH1F*)fListExpert->UncheckedAt(kNClustersPerDE))->Clone(), kNClustersPerDEPerTrack);
 764
 765   // fill summary plots per chamber
 766   for (Int_t iCh = 0; iCh < nCh; iCh++) {
 767
 768     TH1* hClusterChargeInCh = ((TH1F*)fListExpert->UncheckedAt(kClusterChargeInCh+iCh));
 769     hClusterChargePerChMean->SetBinContent(iCh+1, hClusterChargeInCh->GetMean());
 770     hClusterChargePerChMean->SetBinError(iCh+1, hClusterChargeInCh->GetMeanError());
 771     hClusterChargePerChSigma->SetBinContent(iCh+1, hClusterChargeInCh->GetRMS());
 772     hClusterChargePerChSigma->SetBinError(iCh+1, hClusterChargeInCh->GetRMSError());
 773
 774     TH1* hClusterSizeInCh = ((TH1F*)fListExpert->UncheckedAt(kClusterSizeInCh+iCh));
 775     hClusterSizePerChMean->SetBinContent(iCh+1, hClusterSizeInCh->GetMean());
 776     hClusterSizePerChMean->SetBinError(iCh+1, hClusterSizeInCh->GetMeanError());
 777     hClusterSizePerChSigma->SetBinContent(iCh+1, hClusterSizeInCh->GetRMS());
 778     hClusterSizePerChSigma->SetBinError(iCh+1, hClusterSizeInCh->GetRMSError());
 779
 780   }
 781
 782   // fill summary plots per DE
 783   TH2F* hClusterChargePerDE = ((TH2F*)fListExpert->UncheckedAt(kClusterChargePerDE));
 784   TH2F* hClusterSizePerDE = ((TH2F*)fListExpert->UncheckedAt(kClusterSizePerDE));
 785   for (Int_t iDE = 1; iDE < nDE+1; iDE++) {
 786
 787     TH1D *tmp = hClusterChargePerDE->ProjectionY("tmp",iDE,iDE,"e");
 788     if (tmp->GetEntries() > 10.) {
 789       hClusterChargePerDEMean->SetBinContent(iDE, tmp->GetMean());
 790       hClusterChargePerDEMean->SetBinError(iDE, tmp->GetMeanError());
 791       hClusterChargePerDESigma->SetBinContent(iDE, tmp->GetRMS());
 792       hClusterChargePerDESigma->SetBinError(iDE, tmp->GetRMSError());
 793     }
 794     delete tmp;
 795
 796     tmp = hClusterSizePerDE->ProjectionY("tmp",iDE,iDE,"e");
 797     if (tmp->GetEntries() > 10.) {
 798       hClusterSizePerDEMean->SetBinContent(iDE, tmp->GetMean());
 799       hClusterSizePerDEMean->SetBinError(iDE, tmp->GetMeanError());
 800       hClusterSizePerDESigma->SetBinContent(iDE, tmp->GetRMS());
 801       hClusterSizePerDESigma->SetBinError(iDE, tmp->GetRMSError());
 802     }
 803     delete tmp;
 804
 805   }
 806
 807   // Post summary data.
 808   PostData(5, fListNorm);
 809 }
 810
 811 //________________________________________________________________________
 812 Double_t AliAnalysisTaskMuonQA::ChangeThetaRange(Double_t theta)
 813 {
 814   /// set theta range from -180 to +180 degrees
 815   if(theta < -2.5) return (theta / TMath::Pi() + 1.) * 180.;
 816   else if(theta > 2.5) return (theta / TMath::Pi() - 1.) * 180.;
 817   else return theta / TMath::Pi() * 180.;
 818 }
 819
 820
 821 //________________________________________________________________________
 822 UInt_t AliAnalysisTaskMuonQA::BuildTriggerWord(TString& FiredTriggerClasses)
 823 {
 824   /// build the trigger word from the fired trigger classes and the list of selectable trigger
 825
 826   UInt_t word = 0;
 827
 828   TObjString* trigClasseName = 0x0;
 829   TIter nextTrigger(fSelectTriggerClass);
 830   while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
 831
 832     TRegexp GenericTriggerClasseName(trigClasseName->String());
 833     if (FiredTriggerClasses.Contains(GenericTriggerClasseName)) word |= trigClasseName->GetUniqueID();
 834
 835   }
 836
 837   return word;
 838 }
 839
 840 //________________________________________________________________________
 841 TList* AliAnalysisTaskMuonQA::BuildListOfAllTriggerCases(TString& FiredTriggerClasses)
 842 {
 843   /// build the list of trigger for the counters from the fired trigger classes
 844   /// returned TList must be deleted by user
 845
 846   TList* list = new TList();
 847   list->SetOwner();
 848
 849   // add case any
 850   list->AddLast(new TObjString("trigger:any"));
 851
 852   TObjArray *obj = FiredTriggerClasses.Tokenize(" ");
 853   if ( obj ){
 854     TIter nextTrigger(obj);
 855     TObjString* trigClasseName;
 856     while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
 857
 858       //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
 859
 860       //Add specific trigger
 861       list->AddLast(new TObjString(Form("trigger:%s",trigClasseName->GetName())));
 862     }
 863     delete obj;
 864   }
 865
 866   // add case other if no specific trigger was found
 867   if (list->GetSize() == 1) list->AddLast(new TObjString("trigger:other"));
 868
 869   return list;
 870 }
 871
 872
 873 //________________________________________________________________________
 874 TList* AliAnalysisTaskMuonQA::BuildListOfSelectedTriggerCases(TString& FiredTriggerClasses)
 875 {
 876   /// build the list of trigger for the counters from the fired trigger classes
 877   /// returned TList must be deleted by user
 878
 879   TList* list = new TList();
 880   list->SetOwner();
 881
 882   // add case any
 883   list->AddLast(new TObjString("trigger:any"));
 884
 885   TObjString* trigClasseName = 0x0;
 886   TObjArray *obj = FiredTriggerClasses.Tokenize(" ");
 887   if ( obj ){
 888     TIter nextTrigger(obj);
 889     while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
 890
 891       //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
 892       //loop on rejected trigger if (trigClasseName.Contains()
 893       //Add specific trigger
 894       list->AddLast(new TObjString(Form("trigger:%s",trigClasseName->GetName())));
 895     }
 896     delete obj;
 897   }
 898
 899   // add case other if no specific trigger was found
 900   if (list->GetSize() == 1) list->AddLast(new TObjString("trigger:other"));
 901
 902   return list;
 903 }
 904
 905 //________________________________________________________________________
 906 TList* AliAnalysisTaskMuonQA::BuildListOfTriggerCases(TString& FiredTriggerClasses)
 907 {
 908   /// build the list of trigger for the counters from the fired trigger classes and the list of trigger classes
 909   /// returned TList must be deleted by user
 910
 911   TList* list = new TList();
 912   list->SetOwner();
 913   Bool_t foundCINT1B = kFALSE;
 914   Bool_t foundCMUS1B = kFALSE;
 915
 916   // add case any
 917   list->AddLast(new TObjString("trigger:any"));
 918
 919   TObjString* trigClasseName = 0x0;
 920
 921   TIter nextTrigger(fTriggerClass);
 922   while ((trigClasseName = static_cast<TObjString*>(nextTrigger()))) {
 923
 924     //AliInfo(Form("trigger name %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
 925     //  cout<<"trigger name loop on "<<trigClasseName->GetName()<<" to look for "<<FiredTriggerClasses.Data()<<endl;
 926     TRegexp GenericTriggerClasseName(trigClasseName->String());
 927     if (FiredTriggerClasses.Contains(GenericTriggerClasseName)) {
 928       //AliInfo(Form("trigger names match = %s %s",trigClasseName->GetName(),FiredTriggerClasses.Data()));
 929       //cout<<"trigger names match "<<trigClasseName->GetName()<<" and "<<FiredTriggerClasses.Data()<<endl;
 930       // add specific trigger case
 931       TObjString* trigShortName = static_cast<TObjString*>(fTriggerClass->GetValue(trigClasseName));
 932       list->AddLast(new TObjString(Form("trigger:%s",trigShortName->GetName())));
 933
 934       // check for CINT1B and CMUS1B trigger
 935       if (trigShortName->String() == "CINT1B") foundCINT1B = kTRUE;
 936       else if (trigShortName->String() == "CMUS1B") foundCMUS1B = kTRUE;
 937     }
 938   }
 939
 940   // add the special case CINT1B+CMUS1B
 941   if (foundCINT1B && foundCMUS1B) list->AddLast(new TObjString("trigger:CINT1B+CMUS1B"));
 942
 943   return list;
 944 }
 945