PWGPP/TRD/AliTRDcheckESD.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 //////////////////////////////////////////////////////////////////////////
  17 //                                                                      //
  18 // Check basic detector results at ESD level                            //
  19 //   - Geometrical efficiency                                           //
  20 //   - Tracking efficiency                                              //
  21 //   - PID efficiency                                                   //
  22 //   - Refit efficiency                                                 //
  23 //                                                                      //
  24 // Author                                                               //
  25 //   Alex Bercuci <A.Bercuci@gsi.de>                                    //
  26 //   Ionut Arsene <i.c.arsene@gsi.de>                                   //
  27 //                                                                      //
  28 //     The analysis task fills AliCFContainer objects defined in the    //
  29 //   configuration macro using the AddCFContainer() method.             //
  30 //   The CF containers can be filled with any of the variables defined  //
  31 //   in ETrdCfVariables and at any of the steps defined in ETrdCfSteps. //
  32 //     To define a new variable one needs to:                           //
  33 //   1. Add an entry in the ETrdCfVariables enumeration                 //
  34 //   2. Add the corresponding variable name (and in the correct order)  //
  35 //      in fgkVarNames                                                  //
  36 //   3. Define how the variable is filled in one of the Fill functions: //
  37 //      FillEventInfo(), FillTrackInfo(), FillTrackletInfo(),           //
  38 //      FillTrackletSliceInfo().                                        //
  39 //     To define a new step one needs to:                               //
  40 //   1. Add an entry in the ETrdCfSteps                                 //
  41 //   2. Add the corresponding name in fgkStepNames                      //
  42 //   3. Define the track level cuts for this step in IsTrackSelected()  //
  43 //                                                                      //
  44 //////////////////////////////////////////////////////////////////////////
  45
  46 #include <TClonesArray.h>
  47 #include <TCanvas.h>
  48 #include <TObjArray.h>
  49 #include <TPad.h>
  50 #include <TLegend.h>
  51 #include <TLatex.h>
  52 #include <TLine.h>
  53 #include <TF1.h>
  54 #include <TH1D.h>
  55 #include <TH2D.h>
  56 #include <TH3D.h>
  57 #include <TH2I.h>
  58 #include <TH2F.h>
  59 #include <TH3S.h>
  60 #include <TH3F.h>
  61 #include <TProfile2D.h>
  62 #include <TProfile.h>
  63 #include <TGraphErrors.h>
  64 #include <TGraphAsymmErrors.h>
  65 #include <TFile.h>
  66 #include <TTree.h>
  67 #include <TROOT.h>
  68 #include <TChain.h>
  69 #include <TParticle.h>
  70 #include <TTimeStamp.h>
  71 #include <TRandom.h>
  72 #include <TString.h>
  73
  74 #include "AliLog.h"
  75 #include "AliAnalysisManager.h"
  76 #include "AliAnalysisCuts.h"
  77 #include "AliPhysicsSelection.h"
  78 #include "AliESDEvent.h"
  79 #include "AliESDkink.h"
  80 #include "AliMCEvent.h"
  81 #include "AliESDInputHandler.h"
  82 #include "AliMCEventHandler.h"
  83 #include "AliESDpid.h"
  84 #include "AliExternalTrackParam.h"
  85
  86 #include "AliESDtrack.h"
  87 #include "AliMCParticle.h"
  88 #include "AliPID.h"
  89 #include "AliStack.h"
  90 #include "AliTrackReference.h"
  91 #include "AliMultiplicity.h"
  92 #include "AliCFContainer.h"
  93
  94 #include "AliTRDcheckESD.h"
  95 #include <iostream>
  96 using std::cout;
  97 using std::endl;
  98
  99 ClassImp(AliTRDcheckESD)
 100
 101 const Float_t AliTRDcheckESD::fgkxTPC = 290.;
 102 const Float_t AliTRDcheckESD::fgkxTOF = 365.;
 103 const Char_t* AliTRDcheckESD::fgkVarNames[AliTRDcheckESD::kNTrdCfVariables] = {
 104     "vtxZ", "multiplicity", "trigger", "BC", "TOFBC", "DCAxy", "DCAz", "charge", "OuterParam rad.", "phiVtx", "phi",
 105     "etaVtx", "eta", "pt", "ptTRD", "P", "PTRD", "TRDchi2", "tracklets", "clusters", "TrdQuality",
 106     "TrdBudget", "Qtot0", "ClustersPerRows", "Clusters/tracklet", "TrdP", "TrdPloss", "layer", "slice", "PH0"
 107 };
 108 const Char_t* AliTRDcheckESD::fgkStepNames[AliTRDcheckESD::kNSteps] = {"TPC", "TRD", "TOF", "TOFin", "TOFout"};
 109
 110 FILE* AliTRDcheckESD::fgFile = NULL;
 111
 112 //____________________________________________________________________
 113 AliTRDcheckESD::AliTRDcheckESD():
 114   AliAnalysisTaskSE()
 115   ,fStatus(0)
 116   ,fNRefFigures(0)
 117   ,fESD(NULL)
 118   ,fMC(NULL)
 119   ,fESDpid(new AliESDpid)
 120   ,fHistos(NULL)
 121   ,fReferenceTrackFilter(NULL)
 122   ,fPhysSelTriggersEnabled(kFALSE)
 123   ,fUserEnabledTriggers("")
 124   ,fNAssignedTriggers(0)
 125 {
 126   //
 127   // Default constructor
 128   //
 129   SetNameTitle("TRDcheckESD", "Check TRD @ ESD level");
 130   SetMC(kTRUE);
 131 }
 132
 133 //____________________________________________________________________
 134 AliTRDcheckESD::AliTRDcheckESD(char* name):
 135   AliAnalysisTaskSE(name)
 136   ,fStatus(0)
 137   ,fNRefFigures(0)
 138   ,fESD(NULL)
 139   ,fMC(NULL)
 140   ,fESDpid(new AliESDpid)
 141   ,fHistos(NULL)
 142   ,fReferenceTrackFilter(NULL)
 143   ,fPhysSelTriggersEnabled(kFALSE)
 144   ,fUserEnabledTriggers("")
 145   ,fNAssignedTriggers(0)
 146 {
 147   //
 148   // Default constructor
 149   //
 150   SetMC(kTRUE);
 151   SetTitle("Check TRD @ ESD level");
 152   DefineOutput(1, TObjArray::Class());
 153 }
 154
 155 //____________________________________________________________________
 156 AliTRDcheckESD::~AliTRDcheckESD()
 157 {
 158   // Destructor
 159   if(fHistos && !(AliAnalysisManager::GetAnalysisManager() && AliAnalysisManager::GetAnalysisManager()->IsProofMode())){
 160     if(fHistos->IsOwner()) fHistos->Delete();
 161     delete fHistos;
 162     fHistos = NULL;
 163   }
 164 }
 165
 166 //____________________________________________________________________
 167 void AliTRDcheckESD::FillEventInfo(Double_t* values) {
 168   //
 169   // Fill event information
 170   //
 171   values[kEventVtxZ] = fESD->GetPrimaryVertex()->GetZv();
 172   values[kEventBC] = fESD->GetBunchCrossNumber();
 173
 174   const AliMultiplicity* mult=fESD->GetMultiplicity();
 175   Double_t itsNTracklets = mult->GetNumberOfTracklets();
 176   values[kEventMult] = itsNTracklets;
 177 }
 178
 179 //____________________________________________________________________
 180 void AliTRDcheckESD::FillTrackInfo(Double_t* values, AliESDtrack* esdTrack) {
 181   //
 182   // Fill track information
 183   //
 184   Float_t dcaxy,dcaz;
 185   esdTrack->GetImpactParameters(dcaxy,dcaz);
 186   values[kTrackDCAxy]  = dcaxy;
 187   values[kTrackDCAz]   = dcaz;
 188   values[kTrackCharge] = esdTrack->Charge();
 189   values[kTrackPt]     = esdTrack->Pt();
 190   values[kTrackPhi]    = esdTrack->Phi();
 191   values[kTrackEta]    = esdTrack->Eta();
 192   values[kTrackP]      = esdTrack->P();
 193   values[kTrackTrdTracklets] = esdTrack->GetTRDntracklets();
 194   values[kTrackTrdClusters]  = esdTrack->GetTRDncls();
 195   values[kTrackTrdChi2]      = esdTrack->GetTRDchi2()/(esdTrack->GetTRDntracklets()>0 ? esdTrack->GetTRDntracklets() : 1.0);
 196   values[kTrackTrdQuality]   = esdTrack->GetTRDQuality();
 197   values[kTrackTRDBudget]    = esdTrack->GetTRDBudget();
 198   values[kTrackTOFBC]        = esdTrack->GetTOFBunchCrossing(fESD->GetMagneticField());
 199   const AliExternalTrackParam *out=esdTrack->GetOuterParam();
 200   Double_t p[3];
 201   if(out->GetXYZ(p))
 202     values[kTrackOuterParamRadius] = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
 203   else
 204     values[kTrackOuterParamRadius] = 0.0;
 205 }
 206
 207 //____________________________________________________________________
 208 void AliTRDcheckESD::FillTrackletInfo(Double_t* values, AliESDtrack* esdTrack, Int_t iPlane,
 209                                       Double_t* localSagitaPhi, Double_t localMom[][3], Bool_t* localMomGood) {
 210   //
 211   // Fill TRD tracklet info
 212   //
 213   values[kTrackletClustersVsRows] = esdTrack->GetTRDtrkltClCross(iPlane);
 214   values[kTrackletClusters]       = esdTrack->GetTRDtrkltOccupancy(iPlane);
 215   values[kTrackletQtot]           = esdTrack->GetTRDslice(iPlane, 0);
 216   values[kTrackletP]              = esdTrack->GetTRDmomentum(iPlane);
 217   values[kTrackPlossTRDlayer]     = esdTrack->P() - values[kTrackletP];
 218   values[kTrackletLayer]          = iPlane;
 219   values[kTrackPhiTRD]            = localSagitaPhi[iPlane];
 220   values[kTrackPtTRD]         = (localMomGood[iPlane] ? TMath::Sqrt(localMom[iPlane][0]*localMom[iPlane][0]+
 221                                                                     localMom[iPlane][1]*localMom[iPlane][1]) : values[kTrackPt]);
 222   values[kTrackPTRD]          = (localMomGood[iPlane] ? TMath::Sqrt(values[kTrackPtTRD]*values[kTrackPtTRD]+
 223                                                                     localMom[iPlane][2]*localMom[iPlane][2]) : values[kTrackP]);
 224   values[kTrackEtaTRD] = values[kTrackPTRD]-(localMomGood[iPlane] ? localMom[iPlane][2] : esdTrack->Pz());
 225   values[kTrackEtaTRD] = (TMath::Abs(values[kTrackPTRD])>1.0e-8 ? (values[kTrackPTRD]+(localMomGood[iPlane] ? localMom[iPlane][2] : esdTrack->Pz()))/values[kTrackEtaTRD] : 0.0);
 226   values[kTrackEtaTRD] = (values[kTrackEtaTRD]>1.0e-8 ? 0.5*TMath::Log(values[kTrackEtaTRD]) : -999.);
 227 }
 228
 229 //____________________________________________________________________
 230 void AliTRDcheckESD::FillTrackletSliceInfo(Double_t* values, AliESDtrack* esdTrack, Int_t iSlice) {
 231   //
 232   // Fill TRD tracklet info
 233   //
 234   values[kTrackletPHslice] = esdTrack->GetTRDslice(Int_t(values[kTrackletLayer]), iSlice);
 235   values[kTrackletSlice] = iSlice;
 236 }
 237
 238 //____________________________________________________________________
 239 Bool_t AliTRDcheckESD::IsTrackSelected(AliESDtrack* track, Double_t* /*values*/, Int_t step) {
 240   //
 241   // Select tracks at each step
 242   //
 243   Bool_t referenceFilter = fReferenceTrackFilter->IsSelected(track);
 244   if(step==kTPCreference) {    // reference track filter
 245     return referenceFilter;
 246   }
 247   if(step==kTRD) {    // TRD reference track filter
 248     return (referenceFilter && track->GetTRDntracklets()>0);
 249   }
 250   if(step==kTOF) {    // TOFpid request
 251     return (referenceFilter && track->GetTRDntracklets()>0 && (track->GetStatus() & AliESDtrack::kTOFpid));
 252   }
 253   if(step==kTOFin) {    // TOFin request
 254     return (referenceFilter && (track->GetStatus() & AliESDtrack::kTOFin));
 255   }
 256   if(step==kTOFout) {    // TOFout request
 257     return (referenceFilter && (track->GetStatus() & AliESDtrack::kTOFout));
 258   }
 259   return kFALSE;
 260 }
 261
 262 //____________________________________________________________________
 263 void AliTRDcheckESD::UserCreateOutputObjects()
 264 {
 265   //
 266   // Create Output Containers (TObjectArray containing 1D histograms)
 267   //
 268   Histos();
 269   PostData(1, fHistos);
 270 }
 271
 272 //____________________________________________________________________
 273 void AliTRDcheckESD::MakeSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/){
 274   //
 275   // Draw summary plots for the ESDcheck task using the CF container
 276   //
 277
 278   cout << "Make summary from CF" << endl;
 279   TCanvas *cOut=0x0;
 280   if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary");
 281   cOut = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200);
 282   cOut->cd();
 283   //PlotTrackingSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
 284   PlotTrackingSummaryFromCF(trendValues);
 285   cOut->SaveAs("trackingSummary.gif");
 286
 287   if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary");
 288   cOut = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200);
 289   cOut->cd();
 290   //PlotPidSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
 291   PlotPidSummaryFromCF(trendValues);
 292   cOut->SaveAs("pidSummary.gif");
 293
 294   if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary");
 295   cOut = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200);
 296   cOut->cd();
 297   //PlotCentSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
 298   PlotCentSummaryFromCF(trendValues);
 299   cOut->SaveAs("centSummary.gif");
 300
 301   PlotOtherSummaryFromCF(trendValues);
 302
 303   if(trendValues)
 304     for(Int_t i=0;i<50;++i) cout << "trend #" << i << " :: " << trendValues[i] << endl;
 305 }
 306
 307
 308 //____________________________________________________________________
 309 void AliTRDcheckESD::UserExec(Option_t *){
 310   //
 311   // Run the Analysis
 312   //
 313   fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 314   fMC = MCEvent();
 315
 316   if(!fESD){
 317     AliError("ESD event missing.");
 318     return;
 319   }
 320
 321   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 322   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 323   if(!inputHandler) return;
 324
 325   if(!fPhysSelTriggersEnabled) {
 326     InitializeCFContainers();
 327     fPhysSelTriggersEnabled = kTRUE;
 328   }
 329
 330   UInt_t isSelected = AliVEvent::kAny;
 331   if(inputHandler){
 332     if(inputHandler->GetEventSelection()) {
 333       isSelected = inputHandler->IsEventSelected();
 334     }
 335   }
 336   if(!isSelected) return;
 337
 338   TString triggerClasses = fESD->GetFiredTriggerClasses();
 339   //cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++triggers fired:  " << triggerClasses.Data() << endl;
 340   TObjArray* triggers = triggerClasses.Tokenize(" ");
 341   TObjArray* userTriggers = fUserEnabledTriggers.Tokenize(";");
 342   if(triggers->GetEntries()<1) {delete triggers; delete userTriggers; return;}
 343   Bool_t hasGoodTriggers = kFALSE;
 344   Int_t triggerIndices[kNMaxAssignedTriggers] = {0};
 345   Int_t nTrigFired=0;
 346   Bool_t trigAlreadyChecked = kFALSE;
 347   Bool_t trigSelected = kFALSE;
 348   Int_t trigIdx = 0;
 349   for(Int_t i=0; i<triggers->GetEntries(); ++i) {
 350     TString trigStr=triggers->At(i)->GetName();
 351     if(!trigStr.Contains("NOTRD") && !trigStr.Contains("MUON")) hasGoodTriggers = kTRUE;    // check wheter TRD was read out in this event
 352     if(trigStr.Contains("NOTRD")) continue;
 353     if(trigStr.Contains("MUON")) continue;
 354     if(i>=kNMaxAssignedTriggers) continue;
 355
 356     hasGoodTriggers = kTRUE;
 357     // enable the "All triggers" bit
 358     trigIdx = 1;
 359     trigAlreadyChecked = kFALSE;
 360     for(Int_t k=0;k<nTrigFired;++k)
 361       if(triggerIndices[k]==trigIdx) {
 362         trigAlreadyChecked = kTRUE;
 363         break;
 364     }
 365     if(!trigAlreadyChecked) triggerIndices[nTrigFired++] = trigIdx;
 366
 367     trigSelected = kFALSE;
 368     // check whether this trigger matches any of the user defined trigger families
 369     for(Int_t j=0;j<userTriggers->GetEntries();++j) {
 370       TString userTrigStr=userTriggers->At(j)->GetName();
 371       if(trigStr.Contains(userTrigStr.Data())) {
 372         trigSelected = kTRUE;
 373         trigIdx = GetTriggerIndex(userTrigStr.Data(), kFALSE);
 374         trigAlreadyChecked = kFALSE;
 375         for(Int_t k=0;k<nTrigFired;++k)
 376           if(triggerIndices[k]==trigIdx) {
 377             trigAlreadyChecked = kTRUE;
 378             break;
 379           }
 380         if(!trigAlreadyChecked) {    // add trigger to the list of enabled triggers only if it was not added already
 381           triggerIndices[nTrigFired++] = trigIdx;
 382         }
 383       }
 384     }
 385
 386     trigIdx = GetTriggerIndex(trigStr.Data(), kFALSE);
 387     if(trigIdx>0) trigSelected = kTRUE;
 388     if(trigIdx==-1) trigIdx=1;
 389     trigAlreadyChecked = kFALSE;
 390     for(Int_t k=0;k<nTrigFired;++k)
 391       if(triggerIndices[k]==trigIdx) {
 392         trigAlreadyChecked = kTRUE;
 393         break;
 394       }
 395     if(!trigAlreadyChecked) {
 396       triggerIndices[nTrigFired++]=1;  // 0-assigned to all other triggers
 397     }
 398   }  // end loop over triggers
 399
 400   if(!trigSelected && hasGoodTriggers) {
 401     triggerIndices[nTrigFired++]=2;
 402   }
 403
 404   TH1F* hTrig = (TH1F*)fHistos->FindObject("hTriggerDefs");
 405   for(Int_t i=0; i<nTrigFired; ++i)
 406     hTrig->Fill(triggerIndices[i]);
 407
 408   if(!hasGoodTriggers) {
 409     PostData(1, fHistos);
 410     delete triggers;
 411     delete userTriggers;
 412     return;
 413   }
 414
 415   Int_t* trigFiredIdx=new Int_t[nTrigFired];
 416   for(Int_t i=0;i<nTrigFired;++i) trigFiredIdx[i] = triggerIndices[i];
 417
 418   // Get MC information if available
 419   //AliStack * fStack = NULL;
 420   if(HasMC()){
 421     if(!fMC){
 422       AliWarning("MC event missing");
 423       SetMC(kFALSE);
 424     } else {
 425       if(!fMC->Stack()){
 426         AliWarning("MC stack missing");
 427         SetMC(kFALSE);
 428       }
 429     }
 430   }
 431
 432   Double_t values[kNTrdCfVariables];      // array where the CF container variables are stored
 433   for(Int_t i=0;i<kNTrdCfVariables; ++i) values[i] = -999.;
 434   FillEventInfo(values);
 435
 436   Int_t multLimits[6] = {0, 700, 1400, 2100, 2800, 3500};
 437   Int_t centralityClass = 0;
 438   for(Int_t iCent=0; iCent<5; ++iCent) {
 439     if(values[kEventMult]>=multLimits[iCent] && values[kEventMult]<multLimits[iCent+1])
 440       centralityClass=iCent+1;
 441   }
 442   if(centralityClass == 0) return;
 443
 444   // radius of TRD entrance plane in each layer
 445   Double_t rTRD[6] = {298.0, 311.0, 324.0, 337.0, 350.0, 363.0};
 446
 447   AliESDtrack *esdTrack(NULL);
 448   for(Int_t itrk = 0; itrk < fESD->GetNumberOfTracks(); itrk++){
 449     esdTrack = fESD->GetTrack(itrk);
 450
 451     Bool_t stepSelections[kNSteps];
 452     for(Int_t is=0;is<kNSteps;++is) {
 453       stepSelections[is] = IsTrackSelected(esdTrack, values, is);
 454     }
 455     if(!stepSelections[0]) continue;
 456
 457     FillTrackInfo(values, esdTrack);
 458
 459     // find position and momentum of the track at entrance in TRD
 460     const AliExternalTrackParam *outerParam = esdTrack->GetOuterParam();
 461     Double_t localCoord[6][3] = {{0.0}};
 462     Bool_t localCoordGood[6];
 463     for(Int_t il=0;il<6;++il)
 464       localCoordGood[il] = (outerParam ? outerParam : esdTrack)->GetXYZAt(rTRD[il], fESD->GetMagneticField(), localCoord[il]);
 465     Double_t localMom[6][3] = {{0.0}};
 466     Bool_t localMomGood[6];
 467     for(Int_t il=0; il<6; ++il)
 468       localMomGood[il] = (outerParam ? outerParam : esdTrack)->GetPxPyPzAt(rTRD[il], fESD->GetMagneticField(), localMom[il]);
 469     Double_t localSagitaPhi[6] = {-999.};
 470     for(Int_t il=0; il<6; ++il)
 471       localSagitaPhi[il] = (localCoordGood[il] ? TMath::ATan2(localCoord[il][1], localCoord[il][0]) : -999.);
 472     if(!localMomGood[0]) continue;
 473
 474     FillTrackletInfo(values, esdTrack, 0, localSagitaPhi, localMom, localMomGood);
 475
 476     for(Int_t itrig=0; itrig<nTrigFired; ++itrig) {
 477       values[kEventTrigger] = Double_t(trigFiredIdx[itrig]);
 478
 479       // check if cf needs tracklet or slice info
 480       FillGlobalTrackContainers(values, stepSelections, itrig);
 481
 482       for(Int_t iPlane=0; iPlane<6; iPlane++) {
 483         FillTrackletInfo(values, esdTrack, iPlane, localSagitaPhi, localMom, localMomGood);
 484         if(values[kTrackletQtot]>20.0) FillTrdTrackletContainers(values, stepSelections, itrig);
 485
 486         for(Int_t iSlice=0; iSlice<8; iSlice++) {
 487           FillTrackletSliceInfo(values, esdTrack, iSlice);
 488           if(values[kTrackletPHslice]>20.0) FillTrdSliceContainers(values, stepSelections, itrig);
 489         }  // end loop over slices
 490       }  // end loop over TRD layers
 491     }  // end loop over triggers
 492   }  // end loop over tracks
 493
 494   delete triggers;
 495   delete userTriggers;
 496   delete [] trigFiredIdx;
 497
 498   PostData(1, fHistos);
 499 }
 500
 501 //____________________________________________________________________
 502 TObjArray* AliTRDcheckESD::Histos()
 503 {
 504   // Retrieve histograms array if already build or build it
 505   if(!fHistos) {
 506     fHistos = new TObjArray();
 507     fHistos->SetOwner(kTRUE);
 508   }
 509
 510   TH1* h = 0x0;
 511   // Trigger definitions
 512   if(!(h=(TH1F*)gROOT->FindObject("hTriggerDefs"))) {
 513     h = new TH1F("hTriggerDefs", "Trigger definitions", kNMaxAssignedTriggers, 0.5, 0.5+Float_t(kNMaxAssignedTriggers));
 514   }
 515   else h->Reset();
 516   fHistos->Add(h);
 517
 518   return fHistos;
 519 }
 520
 521
 522 //__________________________________________________________________________________________________________
 523 void AliTRDcheckESD::InitializeCFContainers() {
 524   //
 525   //  Initialize the CF container
 526   //
 527   AliAnalysisManager* man=AliAnalysisManager::GetAnalysisManager();
 528   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 529   if(!inputHandler) return;
 530
 531   GetTriggerIndex("All triggers", kTRUE);
 532   GetTriggerIndex("Not specified triggers", kTRUE);
 533
 534   AliPhysicsSelection* physSel = (AliPhysicsSelection*)inputHandler->GetEventSelection();
 535   const TList* trigList = (physSel ? physSel->GetCollisionTriggerClasses() : 0x0);
 536   const TList* bgTrigList = (physSel ? physSel->GetBGTriggerClasses() : 0x0);
 537
 538   // Add collision triggers from PhysicsSelection
 539   if(trigList) {
 540     for(Int_t it=0; it<trigList->GetEntries(); ++it) {
 541       TString trigName = trigList->At(it)->GetName();
 542       TObjArray* arr = trigName.Tokenize(" ");
 543       trigName = arr->At(0)->GetName();
 544       trigName.Remove(0,1);
 545       TObjArray* arr2 = trigName.Tokenize(",");
 546       for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
 547         // Assign an index into the trigger histogram and the CF container for this trigger
 548         GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
 549       }
 550       delete arr;
 551     }
 552   }
 553   // Add background triggers from PhysicsSelection
 554   if(bgTrigList) {
 555     for(Int_t it=0; it<bgTrigList->GetEntries(); ++it) {
 556       TString trigName = bgTrigList->At(it)->GetName();
 557       TObjArray* arr = trigName.Tokenize(" ");
 558       trigName = arr->At(0)->GetName();
 559       trigName.Remove(0,1);
 560       TObjArray* arr2 = trigName.Tokenize(",");
 561       for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
 562         // Assign an index into the trigger histogram and the CF container for this trigger
 563         GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
 564       }
 565       delete arr;
 566     }
 567   }
 568
 569   // Add user enabled triggers
 570   TObjArray* arr = fUserEnabledTriggers.Tokenize(";");
 571   for(Int_t it=0; it<arr->GetEntries(); ++it) {
 572     GetTriggerIndex(arr->At(it)->GetName(), kTRUE);
 573   }
 574   delete arr;
 575 }
 576
 577
 578 //__________________________________________________________________________________________________________
 579 void AliTRDcheckESD::AddCFContainer(const Char_t* name, const Char_t* title,
 580                                     Int_t nSteps, Int_t* steps,
 581                                     Int_t nVars, UInt_t* vars, TArrayD* binLimits) {
 582   //
 583   // Add a CF container
 584   //
 585   if(!fHistos) {
 586     fHistos = new TObjArray();
 587     fHistos->SetOwner(kTRUE);
 588   }
 589   // get number of bins for each variable
 590   Int_t* nBins = new Int_t[nVars];
 591   for(Int_t iv=0;iv<nVars;++iv)
 592     nBins[iv] = binLimits[iv].GetSize()-1;
 593   // create the CF container
 594   AliCFContainer* cf = new AliCFContainer(name, title, nSteps, nVars, nBins);
 595   // set CF container variable binning and name
 596   for(Int_t iv=0;iv<nVars;++iv) {
 597     cf->SetBinLimits(iv, binLimits[iv].GetArray());
 598     cf->SetVarTitle(iv, fgkVarNames[vars[iv]]);
 599   }
 600   // set the step names
 601   for(Int_t is=0; is<nSteps; ++is) {
 602     cf->SetStepTitle(is, fgkStepNames[steps[is]]);
 603     for(Int_t iv=0;iv<nVars;++iv) cf->GetAxis(iv, is)->SetUniqueID(vars[iv]);
 604   }
 605   fHistos->Add(cf);
 606 }
 607
 608 //__________________________________________________________________________________________________
 609 void AliTRDcheckESD::FillTrdSliceContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
 610   //
 611   // fill TRD slice info
 612   //
 613   if(!fHistos) return;
 614   for(Int_t i=0;i<fHistos->GetEntries();++i) {
 615     TString objType = fHistos->At(i)->IsA()->GetName();
 616     if(!objType.Contains("AliCFContainer")) continue;
 617     AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
 618     if(cf->GetVar(fgkVarNames[kTrackletSlice])<0 && cf->GetVar(fgkVarNames[kTrackletPHslice])<0) continue;
 619     if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) || (cf->GetVar(fgkVarNames[kEventTrigger])>=0))
 620       FillCFContainer(cf, values, stepSelections);
 621   }
 622 }
 623
 624 //__________________________________________________________________________________________________
 625 void AliTRDcheckESD::FillTrdTrackletContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
 626   //
 627   // fill global track info
 628   //
 629   if(!fHistos) return;
 630   for(Int_t i=0;i<fHistos->GetEntries();++i) {
 631     TString objType = fHistos->At(i)->IsA()->GetName();
 632     if(!objType.Contains("AliCFContainer")) continue;
 633     AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
 634     if(cf->GetVar(fgkVarNames[kTrackletSlice])>=0 || cf->GetVar(fgkVarNames[kTrackletPHslice])>=0) continue;
 635     if(cf->GetVar(fgkVarNames[kTrackletLayer])<0 && cf->GetVar(fgkVarNames[kTrackletQtot])<0) continue;
 636     if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) || (cf->GetVar(fgkVarNames[kEventTrigger])>=0))
 637       FillCFContainer(cf, values, stepSelections);
 638   }
 639 }
 640
 641 //__________________________________________________________________________________________________
 642 void AliTRDcheckESD::FillGlobalTrackContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
 643   //
 644   // fill global track info
 645   //
 646   if(!fHistos) return;
 647   for(Int_t i=0;i<fHistos->GetEntries();++i) {
 648     TString objType = fHistos->At(i)->IsA()->GetName();
 649     if(!objType.Contains("AliCFContainer")) continue;
 650     AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
 651     if(cf->GetVar(fgkVarNames[kTrackletLayer])>=0 ||
 652        cf->GetVar(fgkVarNames[kTrackletSlice])>=0 ||
 653        cf->GetVar(fgkVarNames[kTrackletQtot])>=0 ||
 654        cf->GetVar(fgkVarNames[kTrackletPHslice])>=0) continue;
 655     if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) ||
 656        (cf->GetVar(fgkVarNames[kEventTrigger])>=0))
 657       FillCFContainer(cf, values, stepSelections);
 658   }
 659 }
 660
 661 //__________________________________________________________________________________________________
 662 void AliTRDcheckESD::FillCFContainer(AliCFContainer* cf, Double_t* values, Bool_t* stepSelections) {
 663   //
 664   // Fill CF container
 665   //
 666   Double_t* cfValues=new Double_t[cf->GetNVar()];
 667   for(Int_t iv=0;iv<cf->GetNVar();++iv)
 668     cfValues[iv] = values[cf->GetAxis(iv,0)->GetUniqueID()];
 669
 670   for(Int_t istep=0; istep<cf->GetNStep(); ++istep) {
 671     TString stepTitle = cf->GetStepTitle(istep);
 672     Int_t stepNo = -1;
 673     for(Int_t is=0;is<kNSteps;++is)
 674       if(!stepTitle.CompareTo(fgkStepNames[is])) {
 675         stepNo = is;
 676         break;
 677       }
 678     if(stepSelections[stepNo]) cf->Fill(cfValues, istep);
 679   }  // end loop over steps
 680
 681   delete [] cfValues;
 682 }
 683
 684 //____________________________________________________________________
 685 Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name)
 686 {
 687   //
 688   // Load data from performance file
 689   //
 690   if(!TFile::Open(file)){
 691     AliWarning(Form("Couldn't open file %s.", file));
 692     return kFALSE;
 693   }
 694   if(dir){
 695     if(!gFile->cd(dir)){
 696       AliWarning(Form("Couldn't cd to %s in %s.", dir, file));
 697       return kFALSE;
 698     }
 699   }
 700   TObjArray *o(NULL);
 701   const Char_t *tn=(name ? name : GetName());
 702   if(!(o = (TObjArray*)gDirectory->Get(tn))){
 703     AliWarning(Form("Missing histogram container %s.", tn));
 704     return kFALSE;
 705   }
 706   fHistos = (TObjArray*)o->Clone(GetName());
 707
 708   TH1F* trigHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
 709   for(Int_t i=1;i<=trigHist->GetXaxis()->GetNbins();++i) {
 710     if(trigHist->GetXaxis()->GetBinLabel(i)[0]!='\0') ++fNAssignedTriggers;
 711   }
 712   gFile->Close();
 713   return kTRUE;
 714 }
 715
 716 //_______________________________________________________
 717 Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val)
 718 {
 719 // Dump trending value to default file
 720
 721   if(!fgFile){
 722     fgFile = fopen("TRD.Performance.txt", "at");
 723   }
 724   fprintf(fgFile, "%s_%s %f\n", GetName(), name, val);
 725   return kTRUE;
 726 }
 727
 728 //____________________________________________________________________
 729 void AliTRDcheckESD::Terminate(Option_t *)
 730 {
 731   // Steer post-processing
 732   if(!fHistos){
 733     fHistos = dynamic_cast<TObjArray *>(GetOutputData(1));
 734     if(!fHistos){
 735       AliError("Histogram container not found in output");
 736       return;
 737     }
 738   }
 739 }
 740
 741 //____________________________________________________________________
 742 Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const
 743 {
 744   //
 745   // Helper function converting PDG code into AliPID index
 746   //
 747   switch(pdg){
 748   case kElectron:
 749   case kPositron: return AliPID::kElectron;
 750   case kMuonPlus:
 751   case kMuonMinus: return AliPID::kMuon;
 752   case kPiPlus:
 753   case kPiMinus: return AliPID::kPion;
 754   case kKPlus:
 755   case kKMinus: return AliPID::kKaon;
 756   case kProton:
 757   case kProtonBar: return AliPID::kProton;
 758   }
 759   return -1;
 760 }
 761
 762
 763 //________________________________________________________
 764 void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g)
 765 {
 766   //
 767   // Do the processing
 768   //
 769
 770   Int_t n = 0;
 771   if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n);
 772   if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n);
 773   TF1 f("fg", "gaus", -3.,3.);
 774   for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){
 775     Double_t x = h2->GetXaxis()->GetBinCenter(ibin);
 776     TH1D *h = h2->ProjectionY("py", ibin, ibin);
 777     if(h->GetEntries()<100) continue;
 778     //AdjustF1(h, f);
 779
 780     h->Fit(&f, "QN");
 781     Int_t ip = g[0]->GetN();
 782     g[0]->SetPoint(ip, x, f.GetParameter(1));
 783     g[0]->SetPointError(ip, 0., f.GetParError(1));
 784     g[1]->SetPoint(ip, x, f.GetParameter(2));
 785     g[1]->SetPointError(ip, 0., f.GetParError(2));
 786   }
 787   return;
 788 }
 789 //____________________________________________________________________
 790 void AliTRDcheckESD::PrintStatus(ULong_t status)
 791 {
 792 // Dump track status to stdout
 793
 794   printf("ITS[i(%d) o(%d) r(%d)] TPC[i(%d) o(%d) r(%d) p(%d)] TRD[i(%d) o(%d) r(%d) p(%d) s(%d)] HMPID[o(%d) p(%d)]\n"
 795     ,Bool_t(status & AliESDtrack::kITSin)
 796     ,Bool_t(status & AliESDtrack::kITSout)
 797     ,Bool_t(status & AliESDtrack::kITSrefit)
 798     ,Bool_t(status & AliESDtrack::kTPCin)
 799     ,Bool_t(status & AliESDtrack::kTPCout)
 800     ,Bool_t(status & AliESDtrack::kTPCrefit)
 801     ,Bool_t(status & AliESDtrack::kTPCpid)
 802     ,Bool_t(status & AliESDtrack::kTRDin)
 803     ,Bool_t(status & AliESDtrack::kTRDout)
 804     ,Bool_t(status & AliESDtrack::kTRDrefit)
 805     ,Bool_t(status & AliESDtrack::kTRDpid)
 806     ,Bool_t(status & AliESDtrack::kTRDStop)
 807     ,Bool_t(status & AliESDtrack::kHMPIDout)
 808     ,Bool_t(status & AliESDtrack::kHMPIDpid)
 809   );
 810 }
 811
 812 //____________________________________________________________________
 813 TH1D* AliTRDcheckESD::Proj2D(TH2* hist, TH1* mpvErr, TH1* widthErr, TH1* chi2) {
 814   //
 815   // project the PH vs Slice 2D-histo into a 1D histo with Landau MPV and widths
 816   //
 817
 818   TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm()));
 819   hProjection->Reset();
 820
 821   TF1* fitLandau = new TF1("landauFunc","landau",20.,3000.);
 822   TH1D *hD;
 823   for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) {
 824     if(gROOT->FindObject("projection"))
 825       delete gROOT->FindObject("projection");
 826     hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin);
 827     //hD->Rebin(4);
 828     if(hD->Integral()>10) {
 829       fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin()));
 830       fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin()));
 831       fitLandau->SetParameter(0, 1000.);
 832       fitLandau->SetParLimits(0, 1., 10000000.);
 833       fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin()));
 834       fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetRMS());
 835       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
 836       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
 837       hProjection->SetBinContent(iBin, fitLandau->GetParameter(1));
 838       hProjection->SetBinError(iBin, fitLandau->GetParameter(2));
 839       if(mpvErr) {
 840         mpvErr->SetBinContent(iBin, fitLandau->GetParameter(1));
 841         mpvErr->SetBinError(iBin, fitLandau->GetParError(1));
 842       }
 843       if(widthErr) {
 844         widthErr->SetBinContent(iBin, fitLandau->GetParameter(2));
 845         widthErr->SetBinError(iBin, fitLandau->GetParError(2));
 846       }
 847       if(chi2) {
 848         chi2->SetBinContent(iBin, (fitLandau->GetNDF()>0 ? fitLandau->GetChisquare()/Double_t(fitLandau->GetNDF()) : 0.0));
 849       }
 850     }
 851     else{
 852       hProjection->SetBinContent(iBin, 0);
 853       hProjection->SetBinError(iBin, 0);
 854     }
 855   }
 856   return hProjection;
 857 }
 858
 859 //____________________________________________________________________
 860 TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) {
 861   //
 862   //  Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh]
 863   //  Return the 2D histogram and also the number of entries into this projection (entries)
 864
 865   Int_t nBinsX = hist->GetXaxis()->GetNbins();   // X and Y axis bins are assumed to be all equal
 866   Float_t minX = hist->GetXaxis()->GetXmin();
 867   Float_t maxX = hist->GetXaxis()->GetXmax();
 868   Int_t nBinsY = hist->GetYaxis()->GetNbins();
 869   Float_t minY = hist->GetYaxis()->GetXmin();
 870   Float_t maxY = hist->GetYaxis()->GetXmax();
 871   Int_t nBinsZ = hist->GetZaxis()->GetNbins();  // Z axis bins (pt) might have different widths
 872
 873   TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto");
 874   if(projHisto)
 875     projHisto->Reset();
 876   else
 877     projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY);
 878
 879   for(Int_t iZ=1; iZ<=nBinsZ; iZ++) {
 880     if(iZ<zbinLow) continue;
 881     if(iZ>zbinHigh) continue;
 882     for(Int_t iX=1; iX<=nBinsX; iX++) {
 883       for(Int_t iY=1; iY<=nBinsY; iY++) {
 884         if(accMap) {
 885           if(accMap->GetBinContent(iX,iY)>0.1)
 886             projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
 887         }
 888         else    // no acc. cut
 889           projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
 890         // count only the entries which are inside the acceptance map
 891         if(accMap) {
 892           if(accMap->GetBinContent(iX,iY)>0.1)
 893             entries+=hist->GetBinContent(iX,iY,iZ);
 894         }
 895         else    // no acc. cut
 896           entries+=hist->GetBinContent(iX,iY,iZ);
 897       }
 898     }
 899   }
 900   return projHisto;
 901 }
 902
 903 //____________________________________________________________________
 904 void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) {
 905   //
 906   // Check the active super-modules
 907   //
 908   Double_t entries[18] = {0.0};
 909   Double_t smPhiLimits[19];
 910   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
 911   for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) {
 912     Double_t phi = phiProj->GetBinCenter(phiBin);
 913     Int_t sm = -1;
 914     for(Int_t ism=0; ism<18; ++ism)
 915       if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism;
 916     if(sm==-1) continue;
 917     entries[sm] += phiProj->GetBinContent(phiBin);
 918   }
 919   Double_t avEntries = Double_t(phiProj->Integral())/18.0;
 920   for(Int_t ism=0; ism<18; ++ism)
 921     if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE;
 922 }
 923
 924
 925 //__________________________________________________________________________________________________
 926 TH1F* AliTRDcheckESD::EfficiencyFromPhiPt(AliCFContainer* cf, Int_t minNtrkl, Int_t maxNtrkl,
 927                                           Int_t stepNom, Int_t stepDenom, Int_t var) {
 928   //
 929   // Use the CF container to extract the efficiency vs pt (other variable beside pt also posible)
 930   //
 931   Int_t varTrackPhi = cf->GetVar(fgkVarNames[kTrackPhiTRD]);
 932   Int_t otherVar = cf->GetVar(fgkVarNames[var]);
 933
 934   TH1D* phiProj = (TH1D*)cf->Project(kTRD, varTrackPhi);
 935   Bool_t activeSM[18] = {kFALSE};
 936   CheckActiveSM(phiProj, activeSM); delete phiProj;
 937   Double_t smPhiLimits[19];
 938   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
 939
 940   if((stepNom==kTRD || stepDenom==kTRD) &&
 941      (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7))
 942     cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), Double_t(minNtrkl), Double_t(maxNtrkl));
 943
 944   TH2D* hNomPhiVar = (TH2D*)cf->Project(stepNom, otherVar, varTrackPhi);
 945   TH2D* hDenomPhiVar = (TH2D*)cf->Project(stepDenom, otherVar, varTrackPhi);
 946   if((stepNom==kTRD || stepDenom==kTRD) &&
 947      (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7))
 948     cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0,6.0);
 949
 950   TH1F* hEff = new TH1F(Form("hEff%s_%d_%d_%f", fgkVarNames[var], stepNom, stepDenom, gRandom->Rndm()), "",
 951                         hNomPhiVar->GetXaxis()->GetNbins(), hNomPhiVar->GetXaxis()->GetXbins()->GetArray());
 952   for(Int_t ib=1;ib<=hNomPhiVar->GetXaxis()->GetNbins();++ib)
 953     hEff->GetXaxis()->SetBinLabel(ib, hNomPhiVar->GetXaxis()->GetBinLabel(ib));
 954
 955   for(Int_t ivar=1; ivar<=hEff->GetXaxis()->GetNbins(); ++ivar) {
 956     Double_t nom = 0.0; Double_t denom = 0.0;
 957     Double_t eff = 0.0; Double_t err = 0.0;
 958     for(Int_t iphi=1; iphi<=hNomPhiVar->GetYaxis()->GetNbins(); ++iphi) {
 959       Double_t phi = hNomPhiVar->GetYaxis()->GetBinCenter(iphi);
 960       Bool_t isActive = kFALSE;
 961       for(Int_t ism=0; ism<18; ++ism)
 962         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism])
 963           isActive = kTRUE;
 964       if(!isActive) continue;
 965       nom += hNomPhiVar->GetBinContent(ivar, iphi);
 966       denom += hDenomPhiVar->GetBinContent(ivar, iphi);
 967     }
 968     eff = (denom>0.001 ? nom/denom : 0.0);
 969     err = (denom>0.001 && (denom-nom)>0.001 && nom>0.001 ? (TMath::Sqrt(nom*(denom-nom)/denom/denom/denom)) : 0.0);
 970     hEff->SetBinContent(ivar, eff);
 971     hEff->SetBinError(ivar, err);
 972   }   // end loop over pt bins
 973   delete hNomPhiVar; delete hDenomPhiVar;
 974   return hEff;
 975 }
 976
 977
 978 //____________________________________________________________________
 979 TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) {
 980   //
 981   // Calculate the TRD-TPC matching efficiency as function of pt
 982   //
 983
 984   if(!tpc3D || !trd3D) return NULL;
 985   Int_t nBinsZ = trd3D->GetZaxis()->GetNbins();
 986   // project everything on the eta-phi map to obtain an acceptance map
 987   Float_t nada = 0.;
 988   TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0);
 989   TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0);
 990
 991   // prepare the acceptance map
 992   Bool_t activeSM[18] = {kFALSE};
 993   Double_t smPhiLimits[19];
 994   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
 995   if(phiProj) {
 996     CheckActiveSM(phiProj, activeSM);   // get the active SMs
 997     trdAcc->Reset();
 998     // Put 1 entry in every bin which belongs to an active SM
 999     for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) {
1000       Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY);
1001       Bool_t isActive = kFALSE;
1002       for(Int_t ism=0; ism<18; ++ism) {
1003         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
1004           isActive = kTRUE;
1005         }
1006       }
1007       if(!isActive) continue;
1008       for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX)
1009         if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0);
1010     }  // end for over Y(phi) bins
1011   }  // end if phiProj
1012
1013   // get the bin limits from the Z axis of 3D histos
1014   Float_t *ptBinLimits = new Float_t[nBinsZ+1];
1015   for(Int_t i=1; i<=nBinsZ; i++) {
1016     ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i);
1017   }
1018   ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ);
1019
1020   TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits);
1021
1022   // loop over Z bins
1023   Bool_t effGood = kFALSE;
1024   for(Int_t i=1; i<=nBinsZ; i++) {
1025     Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0;
1026     Proj3D(tpc3D, trdAcc, i, i, tpcEntries);
1027     Proj3D(trd3D, trdAcc, i, i, trdEntries);
1028     Float_t ratio = 0;
1029     if(tpcEntries>0) ratio = trdEntries/tpcEntries;
1030     Float_t error = 0;
1031     if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0)
1032       error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries);
1033     if(ratio>0.001) {
1034       efficiency->SetBinContent(i,ratio);
1035       efficiency->SetBinError(i,error);
1036       effGood = kTRUE;
1037     }
1038   }     // end loop over Z bins
1039   if(!effGood) return 0x0;
1040
1041   return efficiency;
1042 }
1043
1044
1045 //__________________________________________________________________________________________________
1046 void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* /*trendValues*/, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1047   //
1048   // Make the centrality summary figure from the CF container
1049   //
1050   if(!fHistos) return;
1051   AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
1052   if(!matchPt) return;
1053   AliCFContainer* centCF=(AliCFContainer*)fHistos->FindObject("CentralityCF");
1054   if(!centCF) return;
1055
1056   TLatex* lat=new TLatex();
1057   lat->SetTextSize(0.06);
1058   lat->SetTextColor(2);
1059
1060   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1061   gPad->Divide(3,3,0.,0.);
1062   TList* l=gPad->GetListOfPrimitives();
1063   TVirtualPad* pad=0x0;
1064
1065   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
1066   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
1067   rangeEffPt->SetStats(kFALSE);
1068   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1069   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1070
1071   Int_t padsForEffs[5] = {0,3,6,1,4};
1072   for(Int_t iCent=1; iCent<6; ++iCent) {
1073     pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
1074     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1075     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1076     rangeEffPt->Draw();
1077     TLine line;
1078     line.SetLineStyle(2);
1079     line.SetLineWidth(2);
1080     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
1081     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
1082
1083     matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1084
1085     matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1086     TH1F* hEffPosAll = EfficiencyFromPhiPt(matchPt,  0,  6, 1, 0);
1087     TH1F* hEffPosTrk4 = EfficiencyFromPhiPt(matchPt, 4,  4, 1, 0);
1088     TH1F* hEffPosTrk5 = EfficiencyFromPhiPt(matchPt, 5,  5, 1, 0);
1089     TH1F* hEffPosTrk6 = EfficiencyFromPhiPt(matchPt, 6,  6, 1, 0);
1090
1091     matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1092     TH1F* hEffNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1093     TH1F* hEffNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1094     TH1F* hEffNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1095     TH1F* hEffNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1096     matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);
1097     matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);
1098
1099     SetStyle(hEffPosAll,  1, kRed, 1, 24, kRed, 1);
1100     SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
1101     SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
1102     SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
1103     SetStyle(hEffNegAll,  1, kBlue, 1, 24, kBlue, 1);
1104     SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1105     SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1106     SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1107     hEffPosAll->Draw("same");
1108     hEffNegAll->Draw("same");
1109     hEffPosTrk4->Draw("same");
1110     hEffNegTrk4->Draw("same");
1111     hEffPosTrk5->Draw("same");
1112     hEffNegTrk5->Draw("same");
1113     hEffPosTrk6->Draw("same");
1114     hEffNegTrk6->Draw("same");
1115
1116     TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
1117     if(iCent==1) {
1118       leg->SetFillColor(0);
1119       leg->SetNColumns(2);
1120       leg->SetMargin(0.1);
1121       leg->SetBorderSize(0);
1122       leg->AddEntry(hEffPosAll,  "pos. (#geq 1 tracklet)", "p");
1123       leg->AddEntry(hEffNegAll,  "neg. (#geq 1 tracklet)", "p");
1124       leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
1125       leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
1126       leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
1127       leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
1128       leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");
1129       leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
1130       leg->Draw();
1131     }
1132     lat->DrawLatex(0.2, 1.32, Form("%.0f < SPD tracklets < %.0f", matchPt->GetAxis(matchPt->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent), matchPt->GetAxis(matchPt->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent)));
1133   }   // end for loop over multiplicity classes
1134
1135   // Reset the modified user ranges of the CF container
1136   matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), 0., 3500.);
1137
1138   // Cluster distributions in all multiplicity classes
1139   pad = ((TVirtualPad*)l->At(2)); pad->cd();
1140   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1141   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1142   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1143   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
1144   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
1145   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
1146   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1147   rangeNcls->SetStats(kFALSE);
1148   rangeNcls->Draw();
1149
1150   TH1D* hNcls[6]={0x0};
1151   TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
1152   legCls->SetBorderSize(0);
1153   legCls->SetFillColor(0);
1154   legCls->SetMargin(0.15);
1155
1156   for(Int_t iCent=0; iCent<6; ++iCent) {
1157     if(iCent>0)
1158       centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1159     hNcls[iCent] = (TH1D*)centCF->Project(0, centCF->GetVar(fgkVarNames[kTrackTrdClusters]));
1160     if(!hNcls[iCent]) continue;
1161
1162     hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1163     Double_t maximum = hNcls[iCent]->GetMaximum();
1164     if(maximum>1.0)
1165       hNcls[iCent]->Scale(1.0/maximum);
1166     hNcls[iCent]->SetStats(kFALSE);
1167     hNcls[iCent]->SetTitle("");
1168     hNcls[iCent]->SetLineWidth(2);
1169
1170     if(hNcls[iCent]->Integral()>0.01) {
1171       hNcls[iCent]->Draw("same");
1172       legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent),
1173                                                                            centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
1174     }
1175   }
1176   legCls->Draw();
1177   centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), 0.0, 6.0, kTRUE);
1178
1179   // Qtot vs P
1180   pad = ((TVirtualPad*)l->At(5)); pad->cd();
1181   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1182   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1183   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1184   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
1185   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
1186   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1187   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1188   rangeQtot->SetStats(kFALSE);
1189   rangeQtot->Draw();
1190
1191   TH1D* hQtot[6]={0x0};
1192   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
1193   leg2->SetFillColor(0);
1194   leg2->SetBorderSize(0);
1195
1196   for(Int_t iCent=0; iCent<6; ++iCent) {
1197     if(iCent>0)
1198       centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1199
1200     hQtot[iCent] = (TH1D*)centCF->Project(0, centCF->GetVar(fgkVarNames[kTrackletQtot]));
1201     if(!hQtot[iCent]) continue;
1202     hQtot[iCent]->SetBinContent(1, 0);
1203
1204     Double_t maximum = hQtot[iCent]->GetMaximum();
1205     if(maximum>1.0)
1206       hQtot[iCent]->Scale(1.0/maximum);
1207     hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1208     hQtot[iCent]->SetStats(kFALSE);
1209     hQtot[iCent]->SetTitle("");
1210     hQtot[iCent]->SetLineWidth(2);
1211     if(hQtot[iCent]->Integral()>0.01) {
1212       hQtot[iCent]->Draw(iCent==0 ? "" : "same");
1213       leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent),
1214                                                                            centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
1215     }
1216   }
1217   leg2->Draw();
1218   centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), 0.0, 5.0, kTRUE);
1219 }
1220
1221
1222
1223 //_________________________________________________________________
1224 void AliTRDcheckESD::PlotTrackingSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1225   //
1226   //  Plot tracking summary
1227   //
1228   if(!fHistos) return;
1229   AliCFContainer* matchPhiEta=(AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
1230   if(!matchPhiEta) return;
1231   AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
1232   if(!matchPt) return;
1233   AliCFContainer* clustersCF=(AliCFContainer*)fHistos->FindObject("CentralityCF");
1234   if(!clustersCF) return;
1235   AliCFContainer* bcCF=(AliCFContainer*)fHistos->FindObject("BunchCrossingsCF");
1236   if(!bcCF) return;
1237
1238   TLatex *lat=new TLatex();
1239   lat->SetTextSize(0.06);
1240   lat->SetTextColor(2);
1241   lat->SetTextFont(42);
1242
1243   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1244   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1245   gPad->Divide(3,3,0.,0.);
1246   TList* l=gPad->GetListOfPrimitives();
1247
1248   // eta-phi distr. for positive TPC tracks
1249   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
1250   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1251   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1252   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1253
1254   TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
1255   TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
1256   matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);
1257   matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);      // positive charges
1258   hTPCrefPos = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1259   hTRDrefPos = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1260   hTOFrefPos = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1261   matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);      // negative charges
1262   hTPCrefNeg = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1263   hTRDrefNeg = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1264   hTOFrefNeg = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1265   matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);      // reset charge cut
1266
1267   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
1268   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
1269   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
1270   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
1271   rangeEtaPhi->SetStats(kFALSE);
1272
1273   //----------------------------------------------
1274   // eta-phi efficiency for positive TRD tracks
1275   pad = ((TVirtualPad*)l->At(0)); pad->cd();
1276   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1277   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1278   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1279   rangeEtaPhi->Draw();
1280
1281   TH2D* hTRDeffPos = (hTRDrefPos ? (TH2D*)hTRDrefPos->Clone("hTRDeffPos") : 0x0);
1282   if(hTRDeffPos) {
1283     hTRDeffPos->Reset();
1284     hTRDeffPos->SetStats(kFALSE);
1285     hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
1286     hTRDeffPos->SetMaximum(1.0);
1287     hTRDeffPos->Draw("samecolz");
1288     lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for positive tracks");
1289     DrawTRDGrid();
1290   }
1291
1292   //----------------------------------------------
1293   // eta-phi efficiency for negative TRD tracks
1294   pad = ((TVirtualPad*)l->At(3)); pad->cd();
1295   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1296   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1297   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1298   rangeEtaPhi->Draw();
1299
1300   TH2D* hTRDeffNeg = (hTRDrefNeg ? (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg") : 0x0);
1301   if(hTRDeffNeg) {
1302     hTRDeffNeg->Reset();
1303     hTRDeffNeg->SetStats(kFALSE);
1304     hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
1305     hTRDeffNeg->SetMaximum(1.0);
1306     hTRDeffNeg->Draw("samecolz");
1307     lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for negative tracks");
1308     DrawTRDGrid();
1309   }
1310
1311   //----------------------------------------------
1312   // eta-phi TRD-TOF matching efficiency for positive tracks
1313   pad = ((TVirtualPad*)l->At(1)); pad->cd();
1314   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1315   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1316   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1317   rangeEtaPhi->Draw();
1318
1319   TH2D* hTOFeffPos = (hTOFrefPos ? (TH2D*)hTOFrefPos->Clone("hTOFeffPos") : 0x0);
1320   if(hTOFeffPos) {
1321     hTOFeffPos->Reset();
1322     hTOFeffPos->SetStats(kFALSE);
1323     hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
1324     hTOFeffPos->SetMaximum(1.0);
1325     hTOFeffPos->Draw("samecolz");
1326     lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for positive tracks");
1327     DrawTRDGrid();
1328   }
1329
1330   //----------------------------------------------
1331   // eta-phi TRD-TOF matching efficiency for negative tracks
1332   pad = ((TVirtualPad*)l->At(4)); pad->cd();
1333   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1334   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1335   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1336   rangeEtaPhi->Draw();
1337
1338   TH2D* hTOFeffNeg = (hTOFrefNeg ? (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg") : 0x0);
1339   if(hTOFeffNeg) {
1340     hTOFeffNeg->Reset();
1341     hTOFeffNeg->SetStats(kFALSE);
1342     hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
1343     hTOFeffNeg->SetMaximum(1.0);
1344     hTOFeffNeg->Draw("samecolz");
1345     lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for negative tracks");
1346     DrawTRDGrid();
1347   }
1348
1349   if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
1350   if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
1351
1352   // switch to the Pt cf container
1353   matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1354   TH1F* hTRDEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1355   TH1F* hTOFEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
1356   TH1F* hTRDEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1357   TH1F* hTOFEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
1358   TH1F* hTRDEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1359   TH1F* hTOFEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
1360   TH1F* hTRDEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1361   TH1F* hTOFEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
1362
1363   matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1364   TH1F* hTRDEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1365   TH1F* hTOFEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
1366   TH1F* hTRDEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1367   TH1F* hTOFEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
1368   TH1F* hTRDEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1369   TH1F* hTOFEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
1370   TH1F* hTRDEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1371   TH1F* hTOFEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
1372   matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);
1373
1374   TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
1375   if(trendValues) {
1376     if(hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
1377       hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1378       trendValues[0] = funcConst->GetParameter(0);
1379       trendValues[1] = funcConst->GetParError(0);
1380     }
1381   }
1382   if(trendValues) {
1383     if(hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
1384       hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1385       trendValues[2] = funcConst->GetParameter(0);
1386       trendValues[3] = funcConst->GetParError(0);
1387     }
1388   }
1389   if(trendValues) {
1390     if(hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
1391       hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1392       trendValues[4] = funcConst->GetParameter(0);
1393       trendValues[5] = funcConst->GetParError(0);
1394     }
1395   }
1396   if(trendValues) {
1397     if(hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
1398       hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1399       trendValues[6] = funcConst->GetParameter(0);
1400       trendValues[7] = funcConst->GetParError(0);
1401     }
1402   }
1403
1404   //---------------------------------------------------------
1405   // TPC-TRD matching efficiency vs pt
1406   pad = ((TVirtualPad*)l->At(6)); pad->cd();
1407   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1408   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1409   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1410
1411   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
1412   TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
1413   rangeEffPt->SetStats(kFALSE);
1414   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1415   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1416   rangeEffPt->Draw();
1417   lat->DrawLatex(0.2, 1.44, "TPC-TRD matching efficiency");
1418   //++++++++++++++++++
1419   TLine line;
1420   line.SetLineStyle(2);
1421   line.SetLineWidth(2);
1422   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
1423   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
1424   TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
1425   leg->SetNColumns(2);
1426   leg->SetMargin(0.15);
1427   leg->SetBorderSize(0);
1428   leg->SetFillColor(0);
1429
1430   SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
1431   SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
1432   SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
1433   SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1434   SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
1435   SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1436   SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
1437   SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1438   if(hTRDEffPtPosAll) {hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");}
1439   if(hTRDEffPtNegAll) {hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");}
1440   hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
1441   hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
1442   hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
1443   hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
1444   hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
1445   hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
1446
1447   leg->Draw();
1448
1449   //---------------------------------------------------------
1450   // TRD-TOF matching efficiency vs pt
1451   pad = ((TVirtualPad*)l->At(7)); pad->cd();
1452   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1453   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1454   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1455
1456   rangeEffPt->Draw();
1457   lat->DrawLatex(0.2, 1.44, "TRD-TOF matching efficiency");
1458   SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
1459   SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
1460   SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
1461   SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
1462   SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
1463   SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1464   SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1465   SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1466   if(hTOFEffPtPosAll) hTOFEffPtPosAll->Draw("same");
1467   hTOFEffPtPosTrk4->Draw("same");
1468   hTOFEffPtPosTrk5->Draw("same");
1469   hTOFEffPtPosTrk6->Draw("same");
1470   if(hTOFEffPtNegAll) hTOFEffPtNegAll->Draw("same");
1471   hTOFEffPtNegTrk4->Draw("same");
1472   hTOFEffPtNegTrk5->Draw("same");
1473   hTOFEffPtNegTrk6->Draw("same");
1474
1475   //-----------------------------------------------------
1476   // <ntracklets> vs (phi,eta)
1477   pad = ((TVirtualPad*)l->At(2)); pad->cd();
1478   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1479   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1480   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1481
1482   rangeEtaPhi->Draw();
1483   lat->DrawLatex(-0.9, 3.3, "TRD <N_{tracklets}>");
1484
1485   TH3D* hNtracklets = (TH3D*)matchPhiEta->Project(kTRD, matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]));
1486
1487   TProfile2D* hNtrackletsProf = hNtracklets->Project3DProfile();
1488   delete hNtracklets;
1489   if(hNtrackletsProf) {
1490     hNtrackletsProf->SetStats(kFALSE);
1491     hNtrackletsProf->SetMinimum(0.);
1492     hNtrackletsProf->SetMaximum(6.);
1493     hNtrackletsProf->Draw("samecolz");
1494     DrawTRDGrid();
1495   }
1496
1497   // calculate the trend value for tracklets/track
1498   TH2D* hNtrackletsVsP = (TH2D*)matchPt->Project(kTRD, matchPt->GetVar(fgkVarNames[kTrackPt]), matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]));
1499   if(trendValues &&  hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
1500     TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
1501     hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
1502     trendValues[8] = funcConst->GetParameter(0);
1503     trendValues[9] = funcConst->GetParError(0);
1504     delete hNtrackletsVsP;
1505   }
1506
1507   //--------------------------------------------------------------
1508   // Nclusters per TRD track vs momentum
1509   pad = ((TVirtualPad*)l->At(5)); pad->cd();
1510   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
1511   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1512   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1513   pad->SetLogz();
1514
1515   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
1516   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
1517   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1518   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
1519   rangeNclsP->SetStats(kFALSE);
1520   rangeNclsP->Draw();
1521   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
1522
1523   TH2D* hNclsVsP = (TH2D*)clustersCF->Project(0, clustersCF->GetVar(fgkVarNames[kTrackP]), clustersCF->GetVar(fgkVarNames[kTrackTrdClusters]));
1524   if(hNclsVsP) {
1525     hNclsVsP->SetStats(kFALSE);
1526     hNclsVsP->Draw("samecolz");
1527   }
1528
1529   if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
1530     TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
1531     hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
1532     trendValues[10] = funcConst->GetParameter(0);
1533     trendValues[11] = funcConst->GetParError(0);
1534   }
1535
1536   //--------------------------------------------------------------
1537   // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
1538   pad = ((TVirtualPad*)l->At(8)); pad->cd();
1539   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1540   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1541   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1542
1543   TH1F* hTRDEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 1, 0, kEventBC);
1544   TH1F* hTOFEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 2, 1, kEventBC);
1545
1546   if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
1547   TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
1548   rangeBC->SetStats(kFALSE);
1549   SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
1550   SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1551   rangeBC->Draw();
1552
1553   TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
1554   legBC->SetBorderSize(0);
1555   legBC->SetMargin(0.15);
1556   legBC->SetFillColor(0);
1557   if(hTRDEffBC) {
1558     hTRDEffBC->SetStats(kFALSE);
1559     SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
1560     SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
1561     hTRDEffBC->Draw("same");
1562     hTOFEffBC->Draw("same");
1563     legBC->Draw();
1564     lat->DrawLatex(200., 1.44, "Matching efficiency at 1<p_{T}<3 GeV/c");
1565   }
1566
1567   delete funcConst;
1568 }
1569
1570
1571
1572 //_________________________________________________________________
1573 void AliTRDcheckESD::PlotPidSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1574   //
1575   // PID summary
1576   //
1577   if(!fHistos) return;
1578   AliCFContainer* qtotCF = (AliCFContainer*)fHistos->FindObject("QtotCF");
1579   if(!qtotCF) return;
1580   AliCFContainer* phCF = (AliCFContainer*)fHistos->FindObject("PulseHeightCF");
1581   if(!phCF) return;
1582   AliCFContainer* centCF = (AliCFContainer*)fHistos->FindObject("CentralityCF");
1583   if(!centCF) return;
1584
1585   TLatex *lat=new TLatex();
1586   lat->SetTextSize(0.07);
1587   lat->SetTextColor(2);
1588   lat->SetTextFont(42);
1589   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1590   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1591   gPad->Divide(3,3,0.,0.);
1592   TList* l=gPad->GetListOfPrimitives();
1593
1594   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
1595   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
1596   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
1597   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
1598   rangeEtaPhi->SetStats(kFALSE);
1599
1600   // eta-phi distr. for <Qtot> in layer 0
1601   TVirtualPad* pad;
1602   TProfile2D* hProf2D;
1603   TH1D* hqtot = (TH1D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackletQtot]));
1604   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
1605     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
1606     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1607     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1608     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1609     rangeEtaPhi->Draw();
1610     qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), Double_t(iLayer), Double_t(iLayer));
1611     TH3D* hQtotEtaPhi = (TH3D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackPhiTRD]), qtotCF->GetVar(fgkVarNames[kTrackEtaTRD]), qtotCF->GetVar(fgkVarNames[kTrackletQtot]));
1612     hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
1613     if(hQtotEtaPhi) delete hQtotEtaPhi;
1614
1615     if(hProf2D) {
1616       hProf2D->SetName(Form("Qtot_layer%d",iLayer));
1617       hProf2D->SetStats(kFALSE);
1618       hProf2D->SetMinimum(0.);
1619       hProf2D->SetMaximum((hqtot->GetMean()<10 ? 4.0 : 2000.));
1620       hProf2D->Draw("samecolz");
1621     }
1622     lat->DrawLatex(-0.9, 3.3, Form("TRD <Q_{tot}> Layer %d", iLayer));
1623     DrawTRDGrid();
1624   }
1625   qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 5.0);
1626   // PH versus slice number
1627   pad = ((TVirtualPad*)l->At(2)); pad->cd();
1628   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1629   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1630   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1631
1632   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
1633   TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3000.));
1634   rangePHslice->SetStats(kFALSE);
1635   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
1636   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
1637   rangePHslice->Draw();
1638
1639   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
1640
1641   TH2D* hPH = (TH2D*)phCF->Project(0, phCF->GetVar(fgkVarNames[kTrackletSlice]), phCF->GetVar(fgkVarNames[kTrackletPHslice]));
1642   TH1D* hSliceErr = new TH1D(Form("hSliceErr%f", gRandom->Rndm()), "", hPH->GetXaxis()->GetNbins(), hPH->GetXaxis()->GetXbins()->GetArray());
1643   TH1D* hLandauFit = Proj2D(hPH, hSliceErr);
1644   hPH->SetStats(kFALSE);
1645   hPH->Draw("samecolz");
1646   const Double_t kQx = 0.002;
1647   if(trendValues) {
1648     hSliceErr->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
1649     trendValues[12] = kQx*funcPol1->GetParameter(0);  // PH plateau
1650     trendValues[13] = kQx*funcPol1->GetParError(0);   // PH plateau
1651     trendValues[14] = kQx*funcPol1->GetParameter(1);  // PH slope
1652     trendValues[15] = kQx*funcPol1->GetParError(1);   // PH slope
1653   }
1654   hLandauFit->SetLineWidth(2);
1655   hLandauFit->SetLineStyle(2);
1656   hLandauFit->Draw("same");
1657
1658   delete funcPol1; delete hSliceErr;
1659   // Qtot vs P
1660   pad = ((TVirtualPad*)l->At(5)); pad->cd();
1661   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1662   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1663   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1664   pad->SetLogz();
1665
1666   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
1667   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, (hqtot->GetMean()<10.0 ? 11.99 : 5999.));
1668   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1669   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
1670   rangeQtotP->SetStats(kFALSE);
1671   rangeQtotP->Draw();
1672
1673   Int_t pVar = centCF->GetVar(fgkVarNames[kTrackP]);
1674   if(pVar<0) pVar = centCF->GetVar(fgkVarNames[kTrackletP]);
1675   TH2D* hQtotP = (TH2D*)centCF->Project(0, pVar, centCF->GetVar(fgkVarNames[kTrackletQtot]));
1676   TH1D* mpvErr=new TH1D("mpvErr", "Landau MPV error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1677   TH1D* widthErr=new TH1D("widthErr", "Landau width error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1678   TH1D* landauChi2=new TH1D("landauChi2", "Landau fit #chi^{2} vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1679   if(hQtotP)
1680     for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i)
1681       hQtotP->SetBinContent(i, 1, 0.0);
1682   TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP, mpvErr, widthErr, landauChi2) : 0x0);
1683   //landauChi2->Scale(0.001);
1684   if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
1685   if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
1686     trendValues[16] = kQx*hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
1687     trendValues[17] = kQx*hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
1688   }
1689   if(hQtotP) {
1690     hQtotP->SetStats(kFALSE);
1691     hQtotP->Draw("samecolz");
1692     hQtotProj->Draw("same");
1693   }
1694
1695   // Qtot vs P (fit results)
1696   pad = ((TVirtualPad*)l->At(8)); pad->cd();
1697   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1698   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1699   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1700   pad->SetLogz();
1701
1702   if(gROOT->FindObject("rangeQtotPfit")) delete gROOT->FindObject("rangeQtotPfit");
1703   TH2F* rangeQtotPfit = new TH2F("rangeQtotPfit", "", 100, 0.0, 11.99, 100, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3999.));
1704   SetStyle(rangeQtotPfit->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1705   SetStyle(rangeQtotPfit->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
1706   rangeQtotPfit->SetStats(kFALSE);
1707   rangeQtotPfit->Draw();
1708
1709   if(mpvErr) SetStyle(mpvErr, 1, kBlue, 2, 1, kBlue, 1);
1710   if(widthErr) SetStyle(widthErr, 2, kRed, 2, 1, kRed, 1);
1711   if(mpvErr) {
1712     mpvErr->SetStats(kFALSE);
1713     mpvErr->Draw("same");
1714   }
1715   if(widthErr) {
1716     widthErr->SetStats(kFALSE);
1717     widthErr->Draw("same");
1718   }
1719   TLegend* leg=new TLegend(0.2,0.6,0.5,0.9);
1720   leg->SetFillColor(0);
1721   leg->SetBorderSize(0);
1722   leg->AddEntry("mpvErr","Landau MPV","l");
1723   leg->AddEntry("widthErr","Landau width","l");
1724   leg->Draw();
1725 }
1726
1727
1728 //__________________________________________________________________________________________________
1729 void AliTRDcheckESD::PlotOtherSummaryFromCF(Double_t* /*trendValues*/) {
1730   //
1731   //
1732   //
1733   if(!fHistos) return;
1734   AliCFContainer* matchPhiEta = (AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
1735   AliCFContainer* trdQuality = (AliCFContainer*)fHistos->FindObject("trdQuality");
1736   AliCFContainer* trdChi2 = (AliCFContainer*)fHistos->FindObject("trdChi2");
1737   AliCFContainer* trdBudget = (AliCFContainer*)fHistos->FindObject("trdBudget");
1738   AliCFContainer* ploss = (AliCFContainer*)fHistos->FindObject("Ploss");
1739   AliCFContainer* clusters = (AliCFContainer*)fHistos->FindObject("clustersPerTracklet");
1740   AliCFContainer* clsRows = (AliCFContainer*)fHistos->FindObject("clustersVsRows");
1741   AliCFContainer* tpcTofMatch = (AliCFContainer*)fHistos->FindObject("MatchingPhiEta_TPCTOF");
1742
1743   TLatex *lat=new TLatex();
1744   lat->SetTextSize(0.06);
1745   lat->SetTextColor(2);
1746   lat->SetNDC();
1747   lat->SetTextFont(42);
1748   TCanvas* c1 = new TCanvas("ESDsummary", "ESD summary 1", 1600, 1200);
1749   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1750   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1751   gPad->Divide(3,3,0.,0.);
1752   TList* l=gPad->GetListOfPrimitives();
1753   TVirtualPad* pad=0x0;
1754
1755   // matching as a function of trigger class
1756   if(matchPhiEta) {
1757     matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1758     TH1F* hTRDEffTriggerNeg = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
1759     matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1760     TH1F* hTRDEffTriggerPos = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
1761
1762     pad = ((TVirtualPad*)l->At(0)); pad->cd();
1763     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1764     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1765     hTRDEffTriggerNeg->SetStats(kFALSE);
1766     SetStyle(hTRDEffTriggerNeg->GetYaxis(), "efficiency", 0.06, 1.0, kTRUE, 0.06);
1767     hTRDEffTriggerNeg->GetXaxis()->SetRange(1,fNAssignedTriggers);
1768     hTRDEffTriggerPos->GetXaxis()->SetRange(1,fNAssignedTriggers);
1769     SetStyle(hTRDEffTriggerNeg, 1, 2, 2, 20, 2, 1);
1770     SetStyle(hTRDEffTriggerPos, 1, 4, 2, 20, 4, 1);
1771     hTRDEffTriggerNeg->Draw();
1772     hTRDEffTriggerPos->Draw("same");
1773     TLegend* legEff=new TLegend(0.5,0.5,0.7,0.7);
1774     legEff->SetFillColor(0);
1775     legEff->SetBorderSize(0);
1776     legEff->AddEntry(hTRDEffTriggerNeg, "negatives", "l");
1777     legEff->AddEntry(hTRDEffTriggerPos, "positives", "l");
1778     legEff->Draw();
1779     lat->DrawLatex(0.2, 0.95, "TPC-TRD matching efficiency");
1780   }
1781
1782   if(trdQuality) {
1783   // Track TRD quality vs (eta,phi) and vs TRD n-clusters
1784     TH3D* trdQuality3D = (TH3D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackEtaTRD]),
1785                                                        trdQuality->GetVar(fgkVarNames[kTrackPhiTRD]),
1786                                                        trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1787     trdQuality3D->GetZaxis()->SetRangeUser(0.1,100.0);
1788     trdQuality3D->SetName("trdQuality3D");
1789     TProfile2D* prof2DQuality = trdQuality3D->Project3DProfile("yx");
1790     prof2DQuality->SetName("prof2DQuality");
1791     trdQuality->SetRangeUser(trdQuality->GetVar(fgkVarNames[kTrackCharge]), -1.5,-0.5);
1792     TH2D* trdQualityPneg = (TH2D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackP]),
1793                                                          trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1794     trdQualityPneg->SetName("trdQualityPneg");
1795     trdQuality->SetRangeUser(trdQuality->GetVar(fgkVarNames[kTrackCharge]), +0.5,1.5);
1796     TH2D* trdQualityPpos = (TH2D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackP]),
1797                                                          trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1798     trdQualityPpos->SetName("trdQualityPpos");
1799     trdQualityPneg->GetYaxis()->SetRangeUser(0.1,100.0);
1800     TProfile* trdQualityPnegprof = trdQualityPneg->ProfileX();
1801     trdQualityPnegprof->SetName("trdQualityPnegprof");
1802     trdQualityPpos->GetYaxis()->SetRangeUser(0.1,100.0);
1803     TProfile* trdQualityPposprof = trdQualityPpos->ProfileX();
1804     trdQualityPposprof->SetName("trdQualityPposprof");
1805     pad = ((TVirtualPad*)l->At(3)); pad->cd();
1806     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1807     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1808     prof2DQuality->SetStats(kFALSE);
1809     prof2DQuality->SetTitle("");
1810     SetStyle(prof2DQuality->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1811     SetStyle(prof2DQuality->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1812     prof2DQuality->SetMaximum(1.6); prof2DQuality->SetMinimum(0.4);
1813     prof2DQuality->Draw("colz");
1814     lat->DrawLatex(0.2, 0.95, "TRD quality");
1815     pad = ((TVirtualPad*)l->At(6)); pad->cd();
1816     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1817     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1818     trdQualityPnegprof->SetStats(kFALSE);
1819     trdQualityPnegprof->SetTitle("");
1820     SetStyle(trdQualityPnegprof->GetXaxis(), "P (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1821     SetStyle(trdQualityPnegprof->GetYaxis(), "<TRD quality>", 0.06, 1.0, kTRUE, 0.06);
1822     SetStyle(trdQualityPnegprof, 1, 2, 2, 20, 2, 1);
1823     SetStyle(trdQualityPposprof, 1, 4, 2, 20, 4, 1);
1824     trdQualityPnegprof->GetYaxis()->SetRangeUser(0.5, 1.39);
1825     trdQualityPnegprof->Draw();
1826     trdQualityPposprof->Draw("same");
1827     lat->DrawLatex(0.2, 0.95, "TRD quality");
1828   }
1829
1830   if(trdChi2) {
1831     // Track TRD chi2 vs (eta,phi)
1832     TH3D* trdChi23D = (TH3D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackEtaTRD]),
1833                                                trdChi2->GetVar(fgkVarNames[kTrackPhiTRD]),
1834                                                trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1835     trdChi23D->SetName("trdChi23D");
1836     TProfile2D* prof2DChi2 = trdChi23D->Project3DProfile("yx");
1837     prof2DChi2->SetName("prof2DChi2");
1838     pad = ((TVirtualPad*)l->At(1)); pad->cd();
1839     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1840     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1841     prof2DChi2->SetStats(kFALSE);
1842     prof2DChi2->SetTitle("");
1843     SetStyle(prof2DChi2->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1844     SetStyle(prof2DChi2->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1845     prof2DChi2->SetMaximum(2.9);
1846     prof2DChi2->Draw("colz");
1847     lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
1848
1849     // Track TRD chi2 vs pt and charge
1850     trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1851     TH2D* trdChi2VsPtNeg = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
1852                                                     trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1853     trdChi2VsPtNeg->SetName("trdChi2VsPtNeg");
1854     TProfile* trdChi2VsPtNegProf = trdChi2VsPtNeg->ProfileX();
1855     trdChi2VsPtNegProf->SetName("trdChi2VsPtNegProf");
1856     trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), 1.0, 1.0);
1857     TH2D* trdChi2VsPtPos = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
1858                                                     trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1859     trdChi2VsPtPos->SetName("trdChi2VsPtPos");
1860     TProfile* trdChi2VsPtPosProf = trdChi2VsPtPos->ProfileX();
1861     trdChi2VsPtPosProf->SetName("trdChi2VsPtPosProf");
1862     pad = ((TVirtualPad*)l->At(4)); pad->cd();
1863     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1864     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1865     trdChi2VsPtNegProf->SetStats(kFALSE);
1866     trdChi2VsPtNegProf->SetTitle("");
1867     SetStyle(trdChi2VsPtNegProf->GetXaxis(), "p_{T} (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1868     SetStyle(trdChi2VsPtNegProf->GetYaxis(), "<TRD #chi^{2}>", 0.06, 1.0, kTRUE, 0.06);
1869     SetStyle(trdChi2VsPtNegProf, 1, 2, 2, 20, 2, 1);
1870     SetStyle(trdChi2VsPtPosProf, 1, 4, 2, 20, 4, 1);
1871     trdChi2VsPtNegProf->Draw();
1872     trdChi2VsPtPosProf->Draw("same");
1873     lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
1874   }
1875
1876   if(trdBudget) {
1877     // Track TRD budget vs (eta,phi)
1878     TH3D* trdBudget3D = (TH3D*)trdBudget->Project(0, trdBudget->GetVar(fgkVarNames[kTrackEtaTRD]),
1879                                                    trdBudget->GetVar(fgkVarNames[kTrackPhiTRD]),
1880                                                    trdBudget->GetVar(fgkVarNames[kTrackTRDBudget]));
1881     trdBudget3D->SetName("trdBudget3D");
1882     TProfile2D* prof2DBudget = trdBudget3D->Project3DProfile("yx");
1883     prof2DBudget->SetName("prof2DBudget");
1884     pad = ((TVirtualPad*)l->At(7)); pad->cd();
1885     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1886     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1887     prof2DBudget->SetStats(kFALSE);
1888     prof2DBudget->SetTitle("");
1889     SetStyle(prof2DBudget->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1890     SetStyle(prof2DBudget->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1891     prof2DBudget->Draw("colz");
1892     lat->DrawLatex(0.2, 0.95, "TRD budget");
1893   }
1894
1895   if(ploss) {
1896     // momentum loss
1897     ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1898     TH2D* plossLayerNeg = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]),
1899                                                    ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1900     plossLayerNeg->SetName("plossLayerNeg");
1901     TProfile* plossLayerNegProf = plossLayerNeg->ProfileX();
1902     plossLayerNegProf->SetName("plossLayerNegProf");
1903     ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1904     TH2D* plossLayerPos = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]),
1905                                                    ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1906     plossLayerPos->SetName("plossLayerPos");
1907     TProfile* plossLayerPosProf = plossLayerPos->ProfileX();
1908     plossLayerPosProf->SetName("plossLayerPosProf");
1909     ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.5, +1.5);
1910
1911     ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 0.0);
1912     TH3D* ploss3Dl0 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]),
1913                                              ploss->GetVar(fgkVarNames[kTrackPhiTRD]),
1914                                              ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1915     ploss3Dl0->SetName("ploss3Dl0");
1916     TProfile2D* plossEtaPhiL0Prof = ploss3Dl0->Project3DProfile("yx");
1917     plossEtaPhiL0Prof->SetName("plossEtaPhiL0Prof");
1918     ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 5.0, 5.0);
1919     TH3D* ploss3Dl5 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]),
1920                                              ploss->GetVar(fgkVarNames[kTrackPhiTRD]),
1921                                              ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1922     ploss3Dl5->SetName("ploss3Dl5");
1923     TProfile2D* plossEtaPhiL5Prof = ploss3Dl5->Project3DProfile("yx");
1924     plossEtaPhiL5Prof->SetName("plossEtaPhiL5Prof");
1925     pad = ((TVirtualPad*)l->At(2)); pad->cd();
1926     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1927     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1928     plossEtaPhiL0Prof->SetStats(kFALSE);
1929     plossEtaPhiL0Prof->SetTitle("");
1930     SetStyle(plossEtaPhiL0Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1931     SetStyle(plossEtaPhiL0Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1932     plossEtaPhiL0Prof->SetMaximum(0.08);
1933     plossEtaPhiL0Prof->SetMinimum(-0.02);
1934     plossEtaPhiL0Prof->Draw("colz");
1935     lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 0");
1936     pad = ((TVirtualPad*)l->At(5)); pad->cd();
1937     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1938     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1939     plossEtaPhiL5Prof->SetStats(kFALSE);
1940     plossEtaPhiL5Prof->SetTitle("");
1941     SetStyle(plossEtaPhiL5Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1942     SetStyle(plossEtaPhiL5Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1943     plossEtaPhiL5Prof->SetMaximum(0.08);
1944     plossEtaPhiL5Prof->SetMinimum(-0.02);
1945     plossEtaPhiL5Prof->Draw("colz");
1946     lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 5");
1947     pad = ((TVirtualPad*)l->At(8)); pad->cd();
1948     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1949     pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1950     plossLayerNegProf->SetStats(kFALSE);
1951     plossLayerNegProf->SetTitle("");
1952     SetStyle(plossLayerNegProf->GetYaxis(), "#Delta P (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1953     SetStyle(plossLayerNegProf->GetXaxis(), "TRD layer", 0.06, 1.0, kTRUE, 0.06);
1954     SetStyle(plossLayerNegProf, 1, 2, 2, 20, 2, 1);
1955     SetStyle(plossLayerPosProf, 1, 4, 2, 20, 4, 1);
1956     plossLayerNegProf->GetYaxis()->SetRangeUser(TMath::Min(plossLayerNegProf->GetMinimum(),plossLayerPosProf->GetMinimum()-0.01),
1957                                                 TMath::Max(plossLayerNegProf->GetMaximum(),plossLayerPosProf->GetMaximum())+0.01);
1958     plossLayerNegProf->Draw();
1959     plossLayerPosProf->Draw("same");
1960     lat->DrawLatex(0.2, 0.95, "P_{loss} vs layer");
1961   }
1962
1963   // clusters/tracklet and clusters/crossed rows
1964   TH3D* clustersEtaPhi[6]={0x0};
1965   TH3D* clsRowsEtaPhi[6]={0x0};
1966   for(Int_t il=0;il<6;++il) {
1967     if(clusters) {
1968       clusters->SetRangeUser(clusters->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
1969       clustersEtaPhi[il]=(TH3D*)clusters->Project(0, clusters->GetVar(fgkVarNames[kTrackEtaTRD]),
1970                                                    clusters->GetVar(fgkVarNames[kTrackPhiTRD]),
1971                                                    clusters->GetVar(fgkVarNames[kTrackletClusters]));
1972       clustersEtaPhi[il]->SetName(Form("clustersEtaPhi%d",il));
1973     }
1974     if(clsRows) {
1975       clsRows->SetRangeUser(clsRows->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
1976       clsRowsEtaPhi[il]=(TH3D*)clsRows->Project(0, clsRows->GetVar(fgkVarNames[kTrackEtaTRD]),
1977                                                  clsRows->GetVar(fgkVarNames[kTrackPhiTRD]),
1978                                                  clsRows->GetVar(fgkVarNames[kTrackletClustersVsRows]));
1979       clsRowsEtaPhi[il]->SetName(Form("clsRowsEtaPhi%d",il));
1980     }
1981   }
1982
1983   lat->SetTextSize(0.05);
1984   Int_t layerPads[6] = {0, 2, 4, 1, 3, 5};
1985
1986   TCanvas* c2=0x0;
1987   if(clusters) {
1988     c2 = new TCanvas("ESDsummary2", "ESD summary 2", 1600, 1200);
1989     gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1990     gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1991     gPad->Divide(3,2,0.,0.);
1992     l=gPad->GetListOfPrimitives();
1993     for(Int_t il=0;il<6;++il) {
1994       TProfile2D* clustersEtaPhiProf = clustersEtaPhi[il]->Project3DProfile("yx");
1995       pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
1996       pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1997       pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1998       clustersEtaPhiProf->SetStats(kFALSE);
1999       clustersEtaPhiProf->SetTitle("");
2000       SetStyle(clustersEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
2001       SetStyle(clustersEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
2002       clustersEtaPhiProf->Draw("colz");
2003       lat->DrawLatex(0.2, 0.95, Form("Clusters / tracklet, layer %d", il));
2004     }
2005   }
2006
2007   TCanvas* c3=0x0;
2008   if(clsRows) {
2009     c3 = new TCanvas("ESDsummary3", "ESD summary 3", 1600, 1200);
2010     gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2011     gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2012     gPad->Divide(3,2,0.,0.);
2013     l=gPad->GetListOfPrimitives();
2014     for(Int_t il=0;il<6;++il) {
2015       TProfile2D* clsRowsEtaPhiProf = clsRowsEtaPhi[il]->Project3DProfile("yx");
2016       pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
2017       pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2018       pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
2019       clsRowsEtaPhiProf->SetStats(kFALSE);
2020       clsRowsEtaPhiProf->SetTitle("");
2021       SetStyle(clsRowsEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
2022       SetStyle(clsRowsEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
2023       clsRowsEtaPhiProf->Draw("colz");
2024       lat->DrawLatex(0.2, 0.95, Form("Clusters / crossed rows, layer %d", il));
2025     }
2026   }
2027
2028   TCanvas* c4=0x0;
2029   if(tpcTofMatch) {
2030     TH2D* tpcRef = (TH2D*)tpcTofMatch->Project(0, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2031                                                   tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2032     TH2D* tpcPhiPt = (TH2D*)tpcTofMatch->Project(0, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2033                                                     tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2034     TH2D* tofin  = (TH2D*)tpcTofMatch->Project(1, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2035                                                   tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2036     TH2D* tofinPhiPt = (TH2D*)tpcTofMatch->Project(1, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2037                                                       tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2038     TH2D* tofout = (TH2D*)tpcTofMatch->Project(2, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2039                                                   tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2040     TH2D* tofoutPhiPt = (TH2D*)tpcTofMatch->Project(2, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2041                                                        tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2042     tofin->Divide(tpcRef);
2043     tofout->Divide(tpcRef);
2044     tofinPhiPt->Divide(tpcPhiPt);
2045     tofoutPhiPt->Divide(tpcPhiPt);
2046
2047     c4=new TCanvas("ESDsummary4", "TPC - TOF matching", 1600., 1200.);
2048     c4->SetLeftMargin(0.01); c4->SetRightMargin(0.01);
2049     c4->SetTopMargin(0.01); c4->SetBottomMargin(0.01);
2050     c4->Divide(2,2,0.,0.);
2051     pad=c4->cd(1);
2052     pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2053     pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2054     tofin->SetTitle(""); tofin->SetStats(kFALSE);
2055     tofin->Draw("colz");
2056     lat->DrawLatex(0.1, 0.94, "TPC - TOFin matching");
2057     pad=c4->cd(2);
2058     pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2059     pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2060     tofout->SetTitle(""); tofout->SetStats(kFALSE);
2061     tofout->Draw("colz");
2062     lat->DrawLatex(0.1, 0.94, "TPC - TOFout matching");
2063     pad=c4->cd(3);
2064     pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2065     pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2066     tofinPhiPt->SetTitle(""); tofinPhiPt->SetStats(kFALSE);
2067     tofinPhiPt->Draw("colz");
2068     lat->DrawLatex(0.1, 0.94, "TPC - TOFin matching");
2069     pad=c4->cd(4);
2070     pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2071     pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2072     tofoutPhiPt->SetTitle(""); tofoutPhiPt->SetStats(kFALSE);
2073     tofoutPhiPt->Draw("colz");
2074     lat->DrawLatex(0.1, 0.94, "TPC - TOFout matching");
2075   }
2076
2077   if(matchPhiEta || trdQuality || trdChi2 || trdBudget || ploss) c1->SaveAs("esdSummary1.gif");
2078   if(clusters) c2->SaveAs("esdSummary2.gif");
2079   if(clsRows) c3->SaveAs("esdSummary3.gif");
2080   if(tpcTofMatch) c4->SaveAs("esdSummary4.gif");
2081 }
2082
2083
2084 //__________________________________________________________________________________________________
2085 void AliTRDcheckESD::DrawTRDGrid() {
2086   //
2087   //   Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
2088   //   The canvas on which to draw must already exist.
2089   //
2090   TLine line;
2091   line.SetLineColor(2);
2092   line.SetLineWidth(1);
2093   line.SetLineStyle(2);
2094   for(Int_t i=-9; i<=9; ++i) {
2095     line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i);
2096   }
2097   line.DrawLine(-0.85, -3.15, -0.85, 3.15);
2098   line.DrawLine(-0.54, -3.15, -0.54, 3.15);
2099   line.DrawLine(-0.16, -3.15, -0.16, 3.15);
2100   line.DrawLine(+0.16, -3.15, +0.16, 3.15);
2101   line.DrawLine(+0.54, -3.15, +0.54, 3.15);
2102   line.DrawLine(+0.85, -3.15, +0.85, 3.15);
2103 }
2104
2105 //_________________________________________________________________
2106 void AliTRDcheckESD::SetStyle(TH1* hist,
2107                               Int_t lineStyle, Int_t lineColor, Int_t lineWidth,
2108                               Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
2109   //
2110   // Set style settings for histograms
2111   //
2112   if(!hist) return;
2113   hist->SetLineStyle(lineStyle);
2114   hist->SetLineColor(lineColor);
2115   hist->SetLineWidth(lineWidth);
2116   hist->SetMarkerStyle(markerStyle);
2117   hist->SetMarkerColor(markerColor);
2118   hist->SetMarkerSize(markerSize);
2119 }
2120
2121 //____________________________________________________________________
2122 void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle,
2123                               Float_t labelSize) {
2124   //
2125   // Set style settings for axes
2126   //
2127   if(!axis) return;
2128   axis->SetTitle(title);
2129   axis->SetTitleSize(titleSize);
2130   axis->SetTitleOffset(titleOffset);
2131   axis->CenterTitle(centerTitle);
2132   axis->SetLabelSize(labelSize);
2133   axis->SetTitleFont(42);
2134   axis->SetLabelFont(42);
2135   axis->SetNdivisions(507);
2136 }
2137
2138 //____________________________________________________________________
2139 void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
2140   //
2141   // Find the isolated bunch crossings
2142   //
2143   Int_t isolationSize = 5;      // number of free bunches in both directions
2144   for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
2145     Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
2146     if(bc<-0.001 || bc>3499.01) {
2147       isIsolated[bc] = kFALSE;
2148       continue;
2149     }
2150     Double_t entries = bcHist->GetBinContent(bcBin);
2151     if(entries<0.001) {
2152       isIsolated[bc] = kFALSE;
2153       continue;     // no entries
2154     }
2155
2156     // check isolation
2157     isIsolated[bc] = kTRUE;
2158     for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc<=TMath::Min(3499, bcBin+isolationSize); ++ibc) {
2159       if(ibc==bcBin) continue;
2160       if(bcHist->GetBinContent(ibc)>0.01) {
2161         isIsolated[bc] = kFALSE;
2162         break;
2163       }
2164     }
2165   }   // end loop over BC bins
2166
2167   cout << "Isolated bunches: " << endl;
2168   for(Int_t ibc=0; ibc<3500; ++ibc)
2169     if(isIsolated[ibc]) cout << "BC #" << ibc << endl;
2170 }
2171
2172
2173 //__________________________________________________________________________________________________
2174 Int_t AliTRDcheckESD::GetTriggerIndex(const Char_t* name, Bool_t createNew/*=kTRUE*/) {
2175   //
2176   //  Return the index of trigger "name" in the trigger histogram.
2177   //  If the index for this trigger does not exist yet, then assign one if createNew is set to TRUE
2178   //
2179   //cout << "GetTriggerIndex for " << name << endl;
2180   TH1F* triggerHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
2181   TString nameStr=name;
2182   for(Int_t i=1; i<=triggerHist->GetXaxis()->GetNbins(); ++i) {
2183     if(!nameStr.CompareTo(triggerHist->GetXaxis()->GetBinLabel(i))) {
2184       //cout << "       index found: " << i << endl;
2185       return i;
2186     }
2187   }
2188   if(createNew) {
2189     triggerHist->GetXaxis()->SetBinLabel(fNAssignedTriggers+1, name);
2190     for(Int_t i=1;i<fHistos->GetEntries();++i) {
2191       TString objType = fHistos->At(i)->IsA()->GetName();
2192       if(!objType.Contains("AliCFContainer")) continue;
2193       AliCFContainer* cf=(AliCFContainer*)fHistos->At(i);
2194       Int_t trigVar = cf->GetVar(fgkVarNames[kEventTrigger]);
2195       if(trigVar>=0)
2196         for(Int_t istep=0;istep<cf->GetNStep();++istep)
2197           cf->GetAxis(trigVar, istep)->SetBinLabel(fNAssignedTriggers+1, name);
2198     }  // end loop over histograms and CFs
2199
2200     ++fNAssignedTriggers;
2201     return fNAssignedTriggers+1;
2202   }
2203   else {
2204     return -1;
2205   }
2206 }
2207
2208 //__________________________________________________________________________________________________
2209 void AliTRDcheckESD::PrintTriggers() const {
2210   //
2211   //  Print the available triggers for this run
2212   //
2213   if(!fHistos) {
2214     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
2215     return;
2216   }
2217   TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
2218   cout << "Triggers found in this run" << endl;
2219   cout << "==========================" << endl;
2220   cout << "Name   Index   Entries    " << endl;
2221   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
2222     if(hTriggers->GetXaxis()->GetBinLabel(it)[0]!='\0') {
2223       cout << hTriggers->GetXaxis()->GetBinLabel(it) << "  " << hTriggers->GetXaxis()->GetBinCenter(it) << "  " << hTriggers->GetBinContent(it) << endl;
2224     }
2225   }
2226 }
2227
2228
2229 //__________________________________________________________________________________________________
2230 Int_t AliTRDcheckESD::GetTriggerCounter(const Char_t* triggerName) const {
2231   //
2232   // Get the number of events for a given trigger name
2233   //
2234   if(!fHistos) {
2235     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
2236     return -1;
2237   }
2238   TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
2239   Int_t counter = -1;
2240   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
2241     TString trgString = hTriggers->GetXaxis()->GetBinLabel(it);
2242     if(!trgString.CompareTo(triggerName))
2243       counter = (Int_t)hTriggers->GetBinContent(it);
2244   }
2245   if(counter<0) {cout << "AliTRDcheckESD::GetTriggerCounter()  Trigger not found !!";}
2246   return counter;
2247 }
2248
2249
2250 //__________________________________________________________________________________________________________
2251 Int_t AliTRDcheckESD::GetNAssignedTriggers() {
2252   //
2253   // Return the number of assigned triggers
2254   //
2255   return fNAssignedTriggers;
2256 }