]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGPP/TRD/AliTRDcheckESD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
/home/abercuci/usr/AliRoot/REF/.git/COMMIT_EDITMSG
[u/mrichter/AliRoot.git] / PWGPP / TRD / AliTRDcheckESD.cxx
CommitLineData
69656036
AB		 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>
96using std::cout;
97using std::endl;
98
99ClassImp(AliTRDcheckESD)
100
101const Float_t AliTRDcheckESD::fgkxTPC = 290.;
102const Float_t AliTRDcheckESD::fgkxTOF = 365.;
103const 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};
108const Char_t* AliTRDcheckESD::fgkStepNames[AliTRDcheckESD::kNSteps] = {"TPC", "TRD", "TOF", "TOFin", "TOFout"};
109
110FILE* AliTRDcheckESD::fgFile = NULL;
111
112//____________________________________________________________________
113AliTRDcheckESD::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//____________________________________________________________________
134AliTRDcheckESD::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//____________________________________________________________________
156AliTRDcheckESD::~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//____________________________________________________________________
167void 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//____________________________________________________________________
180void 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//____________________________________________________________________
208void 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//____________________________________________________________________
230void 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//____________________________________________________________________
239Bool_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//____________________________________________________________________
263void AliTRDcheckESD::UserCreateOutputObjects()
264{
265 //
266 // Create Output Containers (TObjectArray containing 1D histograms)
267 //
268 Histos();
269 PostData(1, fHistos);
270}
271
272//____________________________________________________________________
273void 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//____________________________________________________________________
309void 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(!(fStack = 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//____________________________________________________________________
502TObjArray* 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//__________________________________________________________________________________________________________
523void 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//__________________________________________________________________________________________________________
579void 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//__________________________________________________________________________________________________
609void 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//__________________________________________________________________________________________________
625void 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//__________________________________________________________________________________________________
642void 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//__________________________________________________________________________________________________
662void 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
682//____________________________________________________________________
683Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name)
684{
685 //
686 // Load data from performance file
687 //
688 if(!TFile::Open(file)){
689 AliWarning(Form("Couldn't open file %s.", file));
690 return kFALSE;
691 }
692 if(dir){
693 if(!gFile->cd(dir)){
694 AliWarning(Form("Couldn't cd to %s in %s.", dir, file));
695 return kFALSE;
696 }
697 }
698 TObjArray *o(NULL);
699 const Char_t *tn=(name ? name : GetName());
700 if(!(o = (TObjArray*)gDirectory->Get(tn))){
701 AliWarning(Form("Missing histogram container %s.", tn));
702 return kFALSE;
703 }
704 fHistos = (TObjArray*)o->Clone(GetName());
705
706 TH1F* trigHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
707 for(Int_t i=1;i<=trigHist->GetXaxis()->GetNbins();++i) {
708 if(trigHist->GetXaxis()->GetBinLabel(i)[0]!='\0') ++fNAssignedTriggers;
709 }
710 gFile->Close();
711 return kTRUE;
712}
713
714//_______________________________________________________
715Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val)
716{
717// Dump trending value to default file
718
719 if(!fgFile){
720 fgFile = fopen("TRD.Performance.txt", "at");
721 }
722 fprintf(fgFile, "%s_%s %f\n", GetName(), name, val);
723 return kTRUE;
724}
725
726//____________________________________________________________________
727void AliTRDcheckESD::Terminate(Option_t *)
728{
729 // Steer post-processing
730 if(!fHistos){
731 fHistos = dynamic_cast<TObjArray *>(GetOutputData(1));
732 if(!fHistos){
733 AliError("Histogram container not found in output");
734 return;
735 }
736 }
737}
738
739//____________________________________________________________________
740Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const
741{
742 //
743 // Helper function converting PDG code into AliPID index
744 //
745 switch(pdg){
746 case kElectron:
747 case kPositron: return AliPID::kElectron;
748 case kMuonPlus:
749 case kMuonMinus: return AliPID::kMuon;
750 case kPiPlus:
751 case kPiMinus: return AliPID::kPion;
752 case kKPlus:
753 case kKMinus: return AliPID::kKaon;
754 case kProton:
755 case kProtonBar: return AliPID::kProton;
756 }
757 return -1;
758}
759
760
761//________________________________________________________
762void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g)
763{
764 //
765 // Do the processing
766 //
767
768 Int_t n = 0;
769 if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n);
770 if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n);
771 TF1 f("fg", "gaus", -3.,3.);
772 for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){
773 Double_t x = h2->GetXaxis()->GetBinCenter(ibin);
774 TH1D *h = h2->ProjectionY("py", ibin, ibin);
775 if(h->GetEntries()<100) continue;
776 //AdjustF1(h, f);
777
778 h->Fit(&f, "QN");
779 Int_t ip = g[0]->GetN();
780 g[0]->SetPoint(ip, x, f.GetParameter(1));
781 g[0]->SetPointError(ip, 0., f.GetParError(1));
782 g[1]->SetPoint(ip, x, f.GetParameter(2));
783 g[1]->SetPointError(ip, 0., f.GetParError(2));
784 }
785 return;
786}
787//____________________________________________________________________
788void AliTRDcheckESD::PrintStatus(ULong_t status)
789{
790// Dump track status to stdout
791
792 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"
793 ,Bool_t(status & AliESDtrack::kITSin)
794 ,Bool_t(status & AliESDtrack::kITSout)
795 ,Bool_t(status & AliESDtrack::kITSrefit)
796 ,Bool_t(status & AliESDtrack::kTPCin)
797 ,Bool_t(status & AliESDtrack::kTPCout)
798 ,Bool_t(status & AliESDtrack::kTPCrefit)
799 ,Bool_t(status & AliESDtrack::kTPCpid)
800 ,Bool_t(status & AliESDtrack::kTRDin)
801 ,Bool_t(status & AliESDtrack::kTRDout)
802 ,Bool_t(status & AliESDtrack::kTRDrefit)
803 ,Bool_t(status & AliESDtrack::kTRDpid)
804 ,Bool_t(status & AliESDtrack::kTRDStop)
805 ,Bool_t(status & AliESDtrack::kHMPIDout)
806 ,Bool_t(status & AliESDtrack::kHMPIDpid)
807 );
808}
809
810//____________________________________________________________________
811TH1D* AliTRDcheckESD::Proj2D(TH2* hist, TH1* mpvErr, TH1* widthErr, TH1* chi2) {
812 //
813 // project the PH vs Slice 2D-histo into a 1D histo with Landau MPV and widths
814 //
815
816 TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm()));
817 hProjection->Reset();
818
819 TF1* fitLandau = new TF1("landauFunc","landau",20.,3000.);
820 TH1D *hD;
821 for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) {
822 if(gROOT->FindObject("projection"))
823 delete gROOT->FindObject("projection");
824 hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin);
825 //hD->Rebin(4);
826 if(hD->Integral()>10) {
827 fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin()));
828 fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin()));
829 fitLandau->SetParameter(0, 1000.);
830 fitLandau->SetParLimits(0, 1., 10000000.);
831 fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin()));
832 fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetRMS());
833 hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
834 hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
835 hProjection->SetBinContent(iBin, fitLandau->GetParameter(1));
836 hProjection->SetBinError(iBin, fitLandau->GetParameter(2));
837 if(mpvErr) {
838 mpvErr->SetBinContent(iBin, fitLandau->GetParameter(1));
839 mpvErr->SetBinError(iBin, fitLandau->GetParError(1));
840 }
841 if(widthErr) {
842 widthErr->SetBinContent(iBin, fitLandau->GetParameter(2));
843 widthErr->SetBinError(iBin, fitLandau->GetParError(2));
844 }
845 if(chi2) {
846 chi2->SetBinContent(iBin, (fitLandau->GetNDF()>0 ? fitLandau->GetChisquare()/Double_t(fitLandau->GetNDF()) : 0.0));
847 }
848 }
849 else{
850 hProjection->SetBinContent(iBin, 0);
851 hProjection->SetBinError(iBin, 0);
852 }
853 }
854 return hProjection;
855}
856
857//____________________________________________________________________
858TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) {
859 //
860 // Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh]
861 // Return the 2D histogram and also the number of entries into this projection (entries)
862
863 Int_t nBinsX = hist->GetXaxis()->GetNbins(); // X and Y axis bins are assumed to be all equal
864 Float_t minX = hist->GetXaxis()->GetXmin();
865 Float_t maxX = hist->GetXaxis()->GetXmax();
866 Int_t nBinsY = hist->GetYaxis()->GetNbins();
867 Float_t minY = hist->GetYaxis()->GetXmin();
868 Float_t maxY = hist->GetYaxis()->GetXmax();
869 Int_t nBinsZ = hist->GetZaxis()->GetNbins(); // Z axis bins (pt) might have different widths
870
871 TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto");
872 if(projHisto)
873 projHisto->Reset();
874 else
875 projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY);
876
877 for(Int_t iZ=1; iZ<=nBinsZ; iZ++) {
878 if(iZ<zbinLow) continue;
879 if(iZ>zbinHigh) continue;
880 for(Int_t iX=1; iX<=nBinsX; iX++) {
881 for(Int_t iY=1; iY<=nBinsY; iY++) {
882 if(accMap) {
883 if(accMap->GetBinContent(iX,iY)>0.1)
884 projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
885 }
886 else // no acc. cut
887 projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
888 // count only the entries which are inside the acceptance map
889 if(accMap) {
890 if(accMap->GetBinContent(iX,iY)>0.1)
891 entries+=hist->GetBinContent(iX,iY,iZ);
892 }
893 else // no acc. cut
894 entries+=hist->GetBinContent(iX,iY,iZ);
895 }
896 }
897 }
898 return projHisto;
899}
900
901//____________________________________________________________________
902void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) {
903 //
904 // Check the active super-modules
905 //
906 Double_t entries[18] = {0.0};
907 Double_t smPhiLimits[19];
908 for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
909 for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) {
910 Double_t phi = phiProj->GetBinCenter(phiBin);
911 Int_t sm = -1;
912 for(Int_t ism=0; ism<18; ++ism)
913 if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism;
914 if(sm==-1) continue;
915 entries[sm] += phiProj->GetBinContent(phiBin);
916 }
917 Double_t avEntries = Double_t(phiProj->Integral())/18.0;
918 for(Int_t ism=0; ism<18; ++ism)
919 if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE;
920}
921
922
923//__________________________________________________________________________________________________
924TH1F* AliTRDcheckESD::EfficiencyFromPhiPt(AliCFContainer* cf, Int_t minNtrkl, Int_t maxNtrkl,
925 Int_t stepNom, Int_t stepDenom, Int_t var) {
926 //
927 // Use the CF container to extract the efficiency vs pt (other variable beside pt also posible)
928 //
929 Int_t varTrackPhi = cf->GetVar(fgkVarNames[kTrackPhiTRD]);
930 Int_t otherVar = cf->GetVar(fgkVarNames[var]);
931
932 TH1D* phiProj = (TH1D*)cf->Project(kTRD, varTrackPhi);
933 Bool_t activeSM[18] = {kFALSE};
934 CheckActiveSM(phiProj, activeSM); delete phiProj;
935 Double_t smPhiLimits[19];
936 for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
937
938 if((stepNom==kTRD || stepDenom==kTRD) &&
939 (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7))
940 cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), Double_t(minNtrkl), Double_t(maxNtrkl));
941
942 TH2D* hNomPhiVar = (TH2D*)cf->Project(stepNom, otherVar, varTrackPhi);
943 TH2D* hDenomPhiVar = (TH2D*)cf->Project(stepDenom, otherVar, varTrackPhi);
944 if((stepNom==kTRD || stepDenom==kTRD) &&
945 (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7))
946 cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0,6.0);
947
948 TH1F* hEff = new TH1F(Form("hEff%s_%d_%d_%f", fgkVarNames[var], stepNom, stepDenom, gRandom->Rndm()), "",
949 hNomPhiVar->GetXaxis()->GetNbins(), hNomPhiVar->GetXaxis()->GetXbins()->GetArray());
950 for(Int_t ib=1;ib<=hNomPhiVar->GetXaxis()->GetNbins();++ib)
951 hEff->GetXaxis()->SetBinLabel(ib, hNomPhiVar->GetXaxis()->GetBinLabel(ib));
952
953 for(Int_t ivar=1; ivar<=hEff->GetXaxis()->GetNbins(); ++ivar) {
954 Double_t nom = 0.0; Double_t denom = 0.0;
955 Double_t eff = 0.0; Double_t err = 0.0;
956 for(Int_t iphi=1; iphi<=hNomPhiVar->GetYaxis()->GetNbins(); ++iphi) {
957 Double_t phi = hNomPhiVar->GetYaxis()->GetBinCenter(iphi);
958 Bool_t isActive = kFALSE;
959 for(Int_t ism=0; ism<18; ++ism)
960 if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism])
961 isActive = kTRUE;
962 if(!isActive) continue;
963 nom += hNomPhiVar->GetBinContent(ivar, iphi);
964 denom += hDenomPhiVar->GetBinContent(ivar, iphi);
965 }
966 eff = (denom>0.001 ? nom/denom : 0.0);
967 err = (denom>0.001 && (denom-nom)>0.001 && nom>0.001 ? (TMath::Sqrt(nom*(denom-nom)/denom/denom/denom)) : 0.0);
968 hEff->SetBinContent(ivar, eff);
969 hEff->SetBinError(ivar, err);
970 } // end loop over pt bins
971 delete hNomPhiVar; delete hDenomPhiVar;
972 return hEff;
973}
974
975
976//____________________________________________________________________
977TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) {
978 //
979 // Calculate the TRD-TPC matching efficiency as function of pt
980 //
981
982 if(!tpc3D || !trd3D) return NULL;
983 Int_t nBinsZ = trd3D->GetZaxis()->GetNbins();
984 // project everything on the eta-phi map to obtain an acceptance map
985 Float_t nada = 0.;
986 TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0);
987 TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0);
988
989 // prepare the acceptance map
990 Bool_t activeSM[18] = {kFALSE};
991 Double_t smPhiLimits[19];
992 for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
993 if(phiProj) {
994 CheckActiveSM(phiProj, activeSM); // get the active SMs
995 trdAcc->Reset();
996 // Put 1 entry in every bin which belongs to an active SM
997 for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) {
998 Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY);
999 Bool_t isActive = kFALSE;
1000 for(Int_t ism=0; ism<18; ++ism) {
1001 if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
1002 isActive = kTRUE;
1003 }
1004 }
1005 if(!isActive) continue;
1006 for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX)
1007 if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0);
1008 } // end for over Y(phi) bins
1009 } // end if phiProj
1010
1011 // get the bin limits from the Z axis of 3D histos
1012 Float_t *ptBinLimits = new Float_t[nBinsZ+1];
1013 for(Int_t i=1; i<=nBinsZ; i++) {
1014 ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i);
1015 }
1016 ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ);
1017
1018 TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits);
1019
1020 // loop over Z bins
1021 Bool_t effGood = kFALSE;
1022 for(Int_t i=1; i<=nBinsZ; i++) {
1023 Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0;
1024 Proj3D(tpc3D, trdAcc, i, i, tpcEntries);
1025 Proj3D(trd3D, trdAcc, i, i, trdEntries);
1026 Float_t ratio = 0;
1027 if(tpcEntries>0) ratio = trdEntries/tpcEntries;
1028 Float_t error = 0;
1029 if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0)
1030 error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries);
1031 if(ratio>0.001) {
1032 efficiency->SetBinContent(i,ratio);
1033 efficiency->SetBinError(i,error);
1034 effGood = kTRUE;
1035 }
1036 } // end loop over Z bins
1037 if(!effGood) return 0x0;
1038
1039 return efficiency;
1040}
1041
1042
1043//__________________________________________________________________________________________________
1044void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* /*trendValues*/, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1045 //
1046 // Make the centrality summary figure from the CF container
1047 //
1048 if(!fHistos) return;
1049 AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
1050 if(!matchPt) return;
1051 AliCFContainer* centCF=(AliCFContainer*)fHistos->FindObject("CentralityCF");
1052 if(!centCF) return;
1053
1054 TLatex* lat=new TLatex();
1055 lat->SetTextSize(0.06);
1056 lat->SetTextColor(2);
1057
1058 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1059 gPad->Divide(3,3,0.,0.);
1060 TList* l=gPad->GetListOfPrimitives();
1061 TVirtualPad* pad=0x0;
1062
1063 if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
1064 TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
1065 rangeEffPt->SetStats(kFALSE);
1066 SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1067 SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1068
1069 Int_t padsForEffs[5] = {0,3,6,1,4};
1070 for(Int_t iCent=1; iCent<6; ++iCent) {
1071 pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
1072 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1073 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1074 rangeEffPt->Draw();
1075 TLine line;
1076 line.SetLineStyle(2);
1077 line.SetLineWidth(2);
1078 line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
1079 line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
1080
1081 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1082
1083 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1084 TH1F* hEffPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1085 TH1F* hEffPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1086 TH1F* hEffPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1087 TH1F* hEffPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1088
1089 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1090 TH1F* hEffNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1091 TH1F* hEffNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1092 TH1F* hEffNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1093 TH1F* hEffNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1094 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);
1095 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);
1096
1097 SetStyle(hEffPosAll, 1, kRed, 1, 24, kRed, 1);
1098 SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
1099 SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
1100 SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
1101 SetStyle(hEffNegAll, 1, kBlue, 1, 24, kBlue, 1);
1102 SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1103 SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1104 SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1105 hEffPosAll->Draw("same");
1106 hEffNegAll->Draw("same");
1107 hEffPosTrk4->Draw("same");
1108 hEffNegTrk4->Draw("same");
1109 hEffPosTrk5->Draw("same");
1110 hEffNegTrk5->Draw("same");
1111 hEffPosTrk6->Draw("same");
1112 hEffNegTrk6->Draw("same");
1113
1114 TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
1115 if(iCent==1) {
1116 leg->SetFillColor(0);
1117 leg->SetNColumns(2);
1118 leg->SetMargin(0.1);
1119 leg->SetBorderSize(0);
1120 leg->AddEntry(hEffPosAll, "pos. (#geq 1 tracklet)", "p");
1121 leg->AddEntry(hEffNegAll, "neg. (#geq 1 tracklet)", "p");
1122 leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
1123 leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
1124 leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
1125 leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
1126 leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");
1127 leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
1128 leg->Draw();
1129 }
1130 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)));
1131 } // end for loop over multiplicity classes
1132
1133 // Reset the modified user ranges of the CF container
1134 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), 0., 3500.);
1135
1136 // Cluster distributions in all multiplicity classes
1137 pad = ((TVirtualPad*)l->At(2)); pad->cd();
1138 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1139 pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1140 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1141 if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
1142 TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
1143 SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
1144 SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1145 rangeNcls->SetStats(kFALSE);
1146 rangeNcls->Draw();
1147
1148 TH1D* hNcls[6]={0x0};
1149 TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
1150 legCls->SetBorderSize(0);
1151 legCls->SetFillColor(0);
1152 legCls->SetMargin(0.15);
1153
1154 for(Int_t iCent=0; iCent<6; ++iCent) {
1155 if(iCent>0)
1156 centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1157 hNcls[iCent] = (TH1D*)centCF->Project(0, centCF->GetVar(fgkVarNames[kTrackTrdClusters]));
1158 if(!hNcls[iCent]) continue;
1159
1160 hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1161 Double_t maximum = hNcls[iCent]->GetMaximum();
1162 if(maximum>1.0)
1163 hNcls[iCent]->Scale(1.0/maximum);
1164 hNcls[iCent]->SetStats(kFALSE);
1165 hNcls[iCent]->SetTitle("");
1166 hNcls[iCent]->SetLineWidth(2);
1167
1168 if(hNcls[iCent]->Integral()>0.01) {
1169 hNcls[iCent]->Draw("same");
1170 legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent),
1171 centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
1172 }
1173 }
1174 legCls->Draw();
1175 centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), 0.0, 6.0, kTRUE);
1176
1177 // Qtot vs P
1178 pad = ((TVirtualPad*)l->At(5)); pad->cd();
1179 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1180 pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1181 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1182 if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
1183 TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
1184 SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1185 SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1186 rangeQtot->SetStats(kFALSE);
1187 rangeQtot->Draw();
1188
1189 TH1D* hQtot[6]={0x0};
1190 TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
1191 leg2->SetFillColor(0);
1192 leg2->SetBorderSize(0);
1193
1194 for(Int_t iCent=0; iCent<6; ++iCent) {
1195 if(iCent>0)
1196 centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
1197
1198 hQtot[iCent] = (TH1D*)centCF->Project(0, centCF->GetVar(fgkVarNames[kTrackletQtot]));
1199 if(!hQtot[iCent]) continue;
1200 hQtot[iCent]->SetBinContent(1, 0);
1201
1202 Double_t maximum = hQtot[iCent]->GetMaximum();
1203 if(maximum>1.0)
1204 hQtot[iCent]->Scale(1.0/maximum);
1205 hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1206 hQtot[iCent]->SetStats(kFALSE);
1207 hQtot[iCent]->SetTitle("");
1208 hQtot[iCent]->SetLineWidth(2);
1209 if(hQtot[iCent]->Integral()>0.01) {
1210 hQtot[iCent]->Draw(iCent==0 ? "" : "same");
1211 leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent),
1212 centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
1213 }
1214 }
1215 leg2->Draw();
1216 centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), 0.0, 5.0, kTRUE);
1217}
1218
1219
1220
1221//_________________________________________________________________
1222void AliTRDcheckESD::PlotTrackingSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1223 //
1224 // Plot tracking summary
1225 //
1226 if(!fHistos) return;
1227 AliCFContainer* matchPhiEta=(AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
1228 if(!matchPhiEta) return;
1229 AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
1230 if(!matchPt) return;
1231 AliCFContainer* clustersCF=(AliCFContainer*)fHistos->FindObject("CentralityCF");
1232 if(!clustersCF) return;
1233 AliCFContainer* bcCF=(AliCFContainer*)fHistos->FindObject("BunchCrossingsCF");
1234 if(!bcCF) return;
1235
1236 TLatex *lat=new TLatex();
1237 lat->SetTextSize(0.06);
1238 lat->SetTextColor(2);
1239 lat->SetTextFont(42);
1240
1241 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1242 gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1243 gPad->Divide(3,3,0.,0.);
1244 TList* l=gPad->GetListOfPrimitives();
1245
1246 // eta-phi distr. for positive TPC tracks
1247 TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
1248 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1249 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1250 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1251
1252 TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
1253 TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
1254 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);
1255 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0); // positive charges
1256 hTPCrefPos = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1257 hTRDrefPos = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1258 hTOFrefPos = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1259 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0); // negative charges
1260 hTPCrefNeg = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1261 hTRDrefNeg = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1262 hTOFrefNeg = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
1263 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0); // reset charge cut
1264
1265 if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
1266 TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
1267 SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
1268 SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
1269 rangeEtaPhi->SetStats(kFALSE);
1270
1271 //----------------------------------------------
1272 // eta-phi efficiency for positive TRD tracks
1273 pad = ((TVirtualPad*)l->At(0)); pad->cd();
1274 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1275 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1276 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1277 rangeEtaPhi->Draw();
1278
1279 TH2D* hTRDeffPos = (hTRDrefPos ? (TH2D*)hTRDrefPos->Clone("hTRDeffPos") : 0x0);
1280 if(hTRDeffPos) {
1281 hTRDeffPos->Reset();
1282 hTRDeffPos->SetStats(kFALSE);
1283 hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
1284 hTRDeffPos->SetMaximum(1.0);
1285 hTRDeffPos->Draw("samecolz");
1286 lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for positive tracks");
1287 DrawTRDGrid();
1288 }
1289
1290 //----------------------------------------------
1291 // eta-phi efficiency for negative TRD tracks
1292 pad = ((TVirtualPad*)l->At(3)); pad->cd();
1293 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1294 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1295 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1296 rangeEtaPhi->Draw();
1297
1298 TH2D* hTRDeffNeg = (hTRDrefNeg ? (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg") : 0x0);
1299 if(hTRDeffNeg) {
1300 hTRDeffNeg->Reset();
1301 hTRDeffNeg->SetStats(kFALSE);
1302 hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
1303 hTRDeffNeg->SetMaximum(1.0);
1304 hTRDeffNeg->Draw("samecolz");
1305 lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for negative tracks");
1306 DrawTRDGrid();
1307 }
1308
1309 //----------------------------------------------
1310 // eta-phi TRD-TOF matching efficiency for positive tracks
1311 pad = ((TVirtualPad*)l->At(1)); pad->cd();
1312 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1313 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1314 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1315 rangeEtaPhi->Draw();
1316
1317 TH2D* hTOFeffPos = (hTOFrefPos ? (TH2D*)hTOFrefPos->Clone("hTOFeffPos") : 0x0);
1318 if(hTOFeffPos) {
1319 hTOFeffPos->Reset();
1320 hTOFeffPos->SetStats(kFALSE);
1321 hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
1322 hTOFeffPos->SetMaximum(1.0);
1323 hTOFeffPos->Draw("samecolz");
1324 lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for positive tracks");
1325 DrawTRDGrid();
1326 }
1327
1328 //----------------------------------------------
1329 // eta-phi TRD-TOF matching efficiency for negative tracks
1330 pad = ((TVirtualPad*)l->At(4)); pad->cd();
1331 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1332 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1333 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1334 rangeEtaPhi->Draw();
1335
1336 TH2D* hTOFeffNeg = (hTOFrefNeg ? (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg") : 0x0);
1337 if(hTOFeffNeg) {
1338 hTOFeffNeg->Reset();
1339 hTOFeffNeg->SetStats(kFALSE);
1340 hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
1341 hTOFeffNeg->SetMaximum(1.0);
1342 hTOFeffNeg->Draw("samecolz");
1343 lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for negative tracks");
1344 DrawTRDGrid();
1345 }
1346
1347 if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
1348 if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
1349
1350 // switch to the Pt cf container
1351 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1352 TH1F* hTRDEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1353 TH1F* hTOFEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
1354 TH1F* hTRDEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1355 TH1F* hTOFEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
1356 TH1F* hTRDEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1357 TH1F* hTOFEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
1358 TH1F* hTRDEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1359 TH1F* hTOFEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
1360
1361 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1362 TH1F* hTRDEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
1363 TH1F* hTOFEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
1364 TH1F* hTRDEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
1365 TH1F* hTOFEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
1366 TH1F* hTRDEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
1367 TH1F* hTOFEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
1368 TH1F* hTRDEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
1369 TH1F* hTOFEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
1370 matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);
1371
1372 TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
1373 if(trendValues) {
1374 if(hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
1375 hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1376 trendValues[0] = funcConst->GetParameter(0);
1377 trendValues[1] = funcConst->GetParError(0);
1378 }
1379 }
1380 if(trendValues) {
1381 if(hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
1382 hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1383 trendValues[2] = funcConst->GetParameter(0);
1384 trendValues[3] = funcConst->GetParError(0);
1385 }
1386 }
1387 if(trendValues) {
1388 if(hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
1389 hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1390 trendValues[4] = funcConst->GetParameter(0);
1391 trendValues[5] = funcConst->GetParError(0);
1392 }
1393 }
1394 if(trendValues) {
1395 if(hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
1396 hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
1397 trendValues[6] = funcConst->GetParameter(0);
1398 trendValues[7] = funcConst->GetParError(0);
1399 }
1400 }
1401
1402 //---------------------------------------------------------
1403 // TPC-TRD matching efficiency vs pt
1404 pad = ((TVirtualPad*)l->At(6)); pad->cd();
1405 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1406 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1407 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1408
1409 if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
1410 TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
1411 rangeEffPt->SetStats(kFALSE);
1412 SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1413 SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1414 rangeEffPt->Draw();
1415 lat->DrawLatex(0.2, 1.44, "TPC-TRD matching efficiency");
1416 //++++++++++++++++++
1417 TLine line;
1418 line.SetLineStyle(2);
1419 line.SetLineWidth(2);
1420 line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
1421 line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
1422 TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
1423 leg->SetNColumns(2);
1424 leg->SetMargin(0.15);
1425 leg->SetBorderSize(0);
1426 leg->SetFillColor(0);
1427
1428 SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
1429 SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
1430 SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
1431 SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1432 SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
1433 SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1434 SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
1435 SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1436 if(hTRDEffPtPosAll) {hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");}
1437 if(hTRDEffPtNegAll) {hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");}
1438 hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
1439 hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
1440 hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
1441 hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
1442 hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
1443 hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
1444
1445 leg->Draw();
1446
1447 //---------------------------------------------------------
1448 // TRD-TOF matching efficiency vs pt
1449 pad = ((TVirtualPad*)l->At(7)); pad->cd();
1450 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1451 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1452 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1453
1454 rangeEffPt->Draw();
1455 lat->DrawLatex(0.2, 1.44, "TRD-TOF matching efficiency");
1456 SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
1457 SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
1458 SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
1459 SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
1460 SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
1461 SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1462 SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1463 SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1464 if(hTOFEffPtPosAll) hTOFEffPtPosAll->Draw("same");
1465 hTOFEffPtPosTrk4->Draw("same");
1466 hTOFEffPtPosTrk5->Draw("same");
1467 hTOFEffPtPosTrk6->Draw("same");
1468 if(hTOFEffPtNegAll) hTOFEffPtNegAll->Draw("same");
1469 hTOFEffPtNegTrk4->Draw("same");
1470 hTOFEffPtNegTrk5->Draw("same");
1471 hTOFEffPtNegTrk6->Draw("same");
1472
1473 //-----------------------------------------------------
1474 // <ntracklets> vs (phi,eta)
1475 pad = ((TVirtualPad*)l->At(2)); pad->cd();
1476 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1477 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1478 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1479
1480 rangeEtaPhi->Draw();
1481 lat->DrawLatex(-0.9, 3.3, "TRD <N_{tracklets}>");
1482
1483 TH3D* hNtracklets = (TH3D*)matchPhiEta->Project(kTRD, matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]));
1484
1485 TProfile2D* hNtrackletsProf = hNtracklets->Project3DProfile();
1486 delete hNtracklets;
1487 if(hNtrackletsProf) {
1488 hNtrackletsProf->SetStats(kFALSE);
1489 hNtrackletsProf->SetMinimum(0.);
1490 hNtrackletsProf->SetMaximum(6.);
1491 hNtrackletsProf->Draw("samecolz");
1492 DrawTRDGrid();
1493 }
1494
1495 // calculate the trend value for tracklets/track
1496 TH2D* hNtrackletsVsP = (TH2D*)matchPt->Project(kTRD, matchPt->GetVar(fgkVarNames[kTrackPt]), matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]));
1497 if(trendValues && hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
1498 TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
1499 hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
1500 trendValues[8] = funcConst->GetParameter(0);
1501 trendValues[9] = funcConst->GetParError(0);
1502 delete hNtrackletsVsP;
1503 }
1504
1505 //--------------------------------------------------------------
1506 // Nclusters per TRD track vs momentum
1507 pad = ((TVirtualPad*)l->At(5)); pad->cd();
1508 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
1509 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1510 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1511 pad->SetLogz();
1512
1513 if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
1514 TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
1515 SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1516 SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
1517 rangeNclsP->SetStats(kFALSE);
1518 rangeNclsP->Draw();
1519 lat->DrawLatex(1.0, 205., "TRD Clusters / track");
1520
1521 TH2D* hNclsVsP = (TH2D*)clustersCF->Project(0, clustersCF->GetVar(fgkVarNames[kTrackP]), clustersCF->GetVar(fgkVarNames[kTrackTrdClusters]));
1522 if(hNclsVsP) {
1523 hNclsVsP->SetStats(kFALSE);
1524 hNclsVsP->Draw("samecolz");
1525 }
1526
1527 if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
1528 TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
1529 hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
1530 trendValues[10] = funcConst->GetParameter(0);
1531 trendValues[11] = funcConst->GetParError(0);
1532 }
1533
1534 //--------------------------------------------------------------
1535 // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
1536 pad = ((TVirtualPad*)l->At(8)); pad->cd();
1537 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1538 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1539 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1540
1541 TH1F* hTRDEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 1, 0, kEventBC);
1542 TH1F* hTOFEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 2, 1, kEventBC);
1543
1544 if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
1545 TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
1546 rangeBC->SetStats(kFALSE);
1547 SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
1548 SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1549 rangeBC->Draw();
1550
1551 TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
1552 legBC->SetBorderSize(0);
1553 legBC->SetMargin(0.15);
1554 legBC->SetFillColor(0);
1555 if(hTRDEffBC) {
1556 hTRDEffBC->SetStats(kFALSE);
1557 SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
1558 SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
1559 hTRDEffBC->Draw("same");
1560 hTOFEffBC->Draw("same");
1561 legBC->Draw();
1562 lat->DrawLatex(200., 1.44, "Matching efficiency at 1<p_{T}<3 GeV/c");
1563 }
1564
1565 delete funcConst;
1566}
1567
1568
1569
1570//_________________________________________________________________
1571void AliTRDcheckESD::PlotPidSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
1572 //
1573 // PID summary
1574 //
1575 if(!fHistos) return;
1576 AliCFContainer* qtotCF = (AliCFContainer*)fHistos->FindObject("QtotCF");
1577 if(!qtotCF) return;
1578 AliCFContainer* phCF = (AliCFContainer*)fHistos->FindObject("PulseHeightCF");
1579 if(!phCF) return;
1580 AliCFContainer* centCF = (AliCFContainer*)fHistos->FindObject("CentralityCF");
1581 if(!centCF) return;
1582
1583 TLatex *lat=new TLatex();
1584 lat->SetTextSize(0.07);
1585 lat->SetTextColor(2);
1586 lat->SetTextFont(42);
1587 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1588 gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1589 gPad->Divide(3,3,0.,0.);
1590 TList* l=gPad->GetListOfPrimitives();
1591
1592 if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
1593 TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
1594 SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
1595 SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
1596 rangeEtaPhi->SetStats(kFALSE);
1597
1598 // eta-phi distr. for <Qtot> in layer 0
1599 TVirtualPad* pad;
1600 TProfile2D* hProf2D;
1601 TH1D* hqtot = (TH1D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackletQtot]));
1602 for(Int_t iLayer=0; iLayer<6; ++iLayer) {
1603 pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
1604 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1605 pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1606 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1607 rangeEtaPhi->Draw();
1608 qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), Double_t(iLayer), Double_t(iLayer));
1609 TH3D* hQtotEtaPhi = (TH3D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackPhiTRD]), qtotCF->GetVar(fgkVarNames[kTrackEtaTRD]), qtotCF->GetVar(fgkVarNames[kTrackletQtot]));
1610 hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
1611 if(hQtotEtaPhi) delete hQtotEtaPhi;
1612
1613 if(hProf2D) {
1614 hProf2D->SetName(Form("Qtot_layer%d",iLayer));
1615 hProf2D->SetStats(kFALSE);
1616 hProf2D->SetMinimum(0.);
1617 hProf2D->SetMaximum((hqtot->GetMean()<10 ? 4.0 : 2000.));
1618 hProf2D->Draw("samecolz");
1619 }
1620 lat->DrawLatex(-0.9, 3.3, Form("TRD <Q_{tot}> Layer %d", iLayer));
1621 DrawTRDGrid();
1622 }
1623 qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 5.0);
1624 // PH versus slice number
1625 pad = ((TVirtualPad*)l->At(2)); pad->cd();
1626 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1627 pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1628 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1629
1630 if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
1631 TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3000.));
1632 rangePHslice->SetStats(kFALSE);
1633 SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
1634 SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
1635 rangePHslice->Draw();
1636
1637 TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
1638
1639 TH2D* hPH = (TH2D*)phCF->Project(0, phCF->GetVar(fgkVarNames[kTrackletSlice]), phCF->GetVar(fgkVarNames[kTrackletPHslice]));
1640 TH1D* hSliceErr = new TH1D(Form("hSliceErr%f", gRandom->Rndm()), "", hPH->GetXaxis()->GetNbins(), hPH->GetXaxis()->GetXbins()->GetArray());
1641 TH1D* hLandauFit = Proj2D(hPH, hSliceErr);
1642 hPH->SetStats(kFALSE);
1643 hPH->Draw("samecolz");
1644 const Double_t kQx = 0.002;
1645 if(trendValues) {
1646 hSliceErr->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
1647 trendValues[12] = kQx*funcPol1->GetParameter(0); // PH plateau
1648 trendValues[13] = kQx*funcPol1->GetParError(0); // PH plateau
1649 trendValues[14] = kQx*funcPol1->GetParameter(1); // PH slope
1650 trendValues[15] = kQx*funcPol1->GetParError(1); // PH slope
1651 }
1652 hLandauFit->SetLineWidth(2);
1653 hLandauFit->SetLineStyle(2);
1654 hLandauFit->Draw("same");
1655
1656 delete funcPol1; delete hSliceErr;
1657 // Qtot vs P
1658 pad = ((TVirtualPad*)l->At(5)); pad->cd();
1659 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1660 pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1661 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1662 pad->SetLogz();
1663
1664 if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
1665 TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, (hqtot->GetMean()<10.0 ? 11.99 : 5999.));
1666 SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1667 SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
1668 rangeQtotP->SetStats(kFALSE);
1669 rangeQtotP->Draw();
1670
1671 Int_t pVar = centCF->GetVar(fgkVarNames[kTrackP]);
1672 if(pVar<0) pVar = centCF->GetVar(fgkVarNames[kTrackletP]);
1673 TH2D* hQtotP = (TH2D*)centCF->Project(0, pVar, centCF->GetVar(fgkVarNames[kTrackletQtot]));
1674 TH1D* mpvErr=new TH1D("mpvErr", "Landau MPV error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1675 TH1D* widthErr=new TH1D("widthErr", "Landau width error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1676 TH1D* landauChi2=new TH1D("landauChi2", "Landau fit #chi^{2} vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
1677 if(hQtotP)
1678 for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i)
1679 hQtotP->SetBinContent(i, 1, 0.0);
1680 TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP, mpvErr, widthErr, landauChi2) : 0x0);
1681 //landauChi2->Scale(0.001);
1682 if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
1683 if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
1684 trendValues[16] = kQx*hQtotProj->GetBinContent(hQtotProj->FindBin(1.0)); // Landau MPV at 1GeV/c
1685 trendValues[17] = kQx*hQtotProj->GetBinError(hQtotProj->FindBin(1.0)); // Landau width at 1 GeV/c
1686 }
1687 if(hQtotP) {
1688 hQtotP->SetStats(kFALSE);
1689 hQtotP->Draw("samecolz");
1690 hQtotProj->Draw("same");
1691 }
1692
1693 // Qtot vs P (fit results)
1694 pad = ((TVirtualPad*)l->At(8)); pad->cd();
1695 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1696 pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
1697 pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1698 pad->SetLogz();
1699
1700 if(gROOT->FindObject("rangeQtotPfit")) delete gROOT->FindObject("rangeQtotPfit");
1701 TH2F* rangeQtotPfit = new TH2F("rangeQtotPfit", "", 100, 0.0, 11.99, 100, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3999.));
1702 SetStyle(rangeQtotPfit->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1703 SetStyle(rangeQtotPfit->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
1704 rangeQtotPfit->SetStats(kFALSE);
1705 rangeQtotPfit->Draw();
1706
1707 if(mpvErr) SetStyle(mpvErr, 1, kBlue, 2, 1, kBlue, 1);
1708 if(widthErr) SetStyle(widthErr, 2, kRed, 2, 1, kRed, 1);
1709 if(mpvErr) {
1710 mpvErr->SetStats(kFALSE);
1711 mpvErr->Draw("same");
1712 }
1713 if(widthErr) {
1714 widthErr->SetStats(kFALSE);
1715 widthErr->Draw("same");
1716 }
1717 TLegend* leg=new TLegend(0.2,0.6,0.5,0.9);
1718 leg->SetFillColor(0);
1719 leg->SetBorderSize(0);
1720 leg->AddEntry("mpvErr","Landau MPV","l");
1721 leg->AddEntry("widthErr","Landau width","l");
1722 leg->Draw();
1723}
1724
1725
1726//__________________________________________________________________________________________________
1727void AliTRDcheckESD::PlotOtherSummaryFromCF(Double_t* trendValues) {
1728 //
1729 //
1730 //
1731 if(!fHistos) return;
1732 AliCFContainer* matchPhiEta = (AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
1733 AliCFContainer* trdQuality = (AliCFContainer*)fHistos->FindObject("trdQuality");
1734 AliCFContainer* trdChi2 = (AliCFContainer*)fHistos->FindObject("trdChi2");
1735 AliCFContainer* trdBudget = (AliCFContainer*)fHistos->FindObject("trdBudget");
1736 AliCFContainer* ploss = (AliCFContainer*)fHistos->FindObject("Ploss");
1737 AliCFContainer* clusters = (AliCFContainer*)fHistos->FindObject("clustersPerTracklet");
1738 AliCFContainer* clsRows = (AliCFContainer*)fHistos->FindObject("clustersVsRows");
1739 AliCFContainer* tpcTofMatch = (AliCFContainer*)fHistos->FindObject("MatchingPhiEta_TPCTOF");
1740
1741 TLatex *lat=new TLatex();
1742 lat->SetTextSize(0.06);
1743 lat->SetTextColor(2);
1744 lat->SetNDC();
1745 lat->SetTextFont(42);
1746 TCanvas* c1 = new TCanvas("ESDsummary", "ESD summary 1", 1600, 1200);
1747 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1748 gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1749 gPad->Divide(3,3,0.,0.);
1750 TList* l=gPad->GetListOfPrimitives();
1751 TVirtualPad* pad=0x0;
1752
1753 // matching as a function of trigger class
1754 if(matchPhiEta) {
1755 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1756 TH1F* hTRDEffTriggerNeg = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
1757 matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1758 TH1F* hTRDEffTriggerPos = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
1759
1760 pad = ((TVirtualPad*)l->At(0)); pad->cd();
1761 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1762 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1763 hTRDEffTriggerNeg->SetStats(kFALSE);
1764 SetStyle(hTRDEffTriggerNeg->GetYaxis(), "efficiency", 0.06, 1.0, kTRUE, 0.06);
1765 hTRDEffTriggerNeg->GetXaxis()->SetRange(1,fNAssignedTriggers);
1766 hTRDEffTriggerPos->GetXaxis()->SetRange(1,fNAssignedTriggers);
1767 SetStyle(hTRDEffTriggerNeg, 1, 2, 2, 20, 2, 1);
1768 SetStyle(hTRDEffTriggerPos, 1, 4, 2, 20, 4, 1);
1769 hTRDEffTriggerNeg->Draw();
1770 hTRDEffTriggerPos->Draw("same");
1771 TLegend* legEff=new TLegend(0.5,0.5,0.7,0.7);
1772 legEff->SetFillColor(0);
1773 legEff->SetBorderSize(0);
1774 legEff->AddEntry(hTRDEffTriggerNeg, "negatives", "l");
1775 legEff->AddEntry(hTRDEffTriggerPos, "positives", "l");
1776 legEff->Draw();
1777 lat->DrawLatex(0.2, 0.95, "TPC-TRD matching efficiency");
1778 }
1779
1780 if(trdQuality) {
1781 // Track TRD quality vs (eta,phi) and vs TRD n-clusters
1782 TH3D* trdQuality3D = (TH3D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackEtaTRD]),
1783 trdQuality->GetVar(fgkVarNames[kTrackPhiTRD]),
1784 trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1785 trdQuality3D->GetZaxis()->SetRangeUser(0.1,100.0);
1786 trdQuality3D->SetName("trdQuality3D");
1787 TProfile2D* prof2DQuality = trdQuality3D->Project3DProfile("yx");
1788 prof2DQuality->SetName("prof2DQuality");
1789 trdQuality->SetRangeUser(trdQuality->GetVar(fgkVarNames[kTrackCharge]), -1.5,-0.5);
1790 TH2D* trdQualityPneg = (TH2D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackP]),
1791 trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1792 trdQualityPneg->SetName("trdQualityPneg");
1793 trdQuality->SetRangeUser(trdQuality->GetVar(fgkVarNames[kTrackCharge]), +0.5,1.5);
1794 TH2D* trdQualityPpos = (TH2D*)trdQuality->Project(0, trdQuality->GetVar(fgkVarNames[kTrackP]),
1795 trdQuality->GetVar(fgkVarNames[kTrackTrdQuality]));
1796 trdQualityPpos->SetName("trdQualityPpos");
1797 trdQualityPneg->GetYaxis()->SetRangeUser(0.1,100.0);
1798 TProfile* trdQualityPnegprof = trdQualityPneg->ProfileX();
1799 trdQualityPnegprof->SetName("trdQualityPnegprof");
1800 trdQualityPpos->GetYaxis()->SetRangeUser(0.1,100.0);
1801 TProfile* trdQualityPposprof = trdQualityPpos->ProfileX();
1802 trdQualityPposprof->SetName("trdQualityPposprof");
1803 pad = ((TVirtualPad*)l->At(3)); pad->cd();
1804 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1805 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1806 prof2DQuality->SetStats(kFALSE);
1807 prof2DQuality->SetTitle("");
1808 SetStyle(prof2DQuality->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1809 SetStyle(prof2DQuality->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1810 prof2DQuality->SetMaximum(1.6); prof2DQuality->SetMinimum(0.4);
1811 prof2DQuality->Draw("colz");
1812 lat->DrawLatex(0.2, 0.95, "TRD quality");
1813 pad = ((TVirtualPad*)l->At(6)); pad->cd();
1814 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1815 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1816 trdQualityPnegprof->SetStats(kFALSE);
1817 trdQualityPnegprof->SetTitle("");
1818 SetStyle(trdQualityPnegprof->GetXaxis(), "P (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1819 SetStyle(trdQualityPnegprof->GetYaxis(), "<TRD quality>", 0.06, 1.0, kTRUE, 0.06);
1820 SetStyle(trdQualityPnegprof, 1, 2, 2, 20, 2, 1);
1821 SetStyle(trdQualityPposprof, 1, 4, 2, 20, 4, 1);
1822 trdQualityPnegprof->GetYaxis()->SetRangeUser(0.5, 1.39);
1823 trdQualityPnegprof->Draw();
1824 trdQualityPposprof->Draw("same");
1825 lat->DrawLatex(0.2, 0.95, "TRD quality");
1826 }
1827
1828 if(trdChi2) {
1829 // Track TRD chi2 vs (eta,phi)
1830 TH3D* trdChi23D = (TH3D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackEtaTRD]),
1831 trdChi2->GetVar(fgkVarNames[kTrackPhiTRD]),
1832 trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1833 trdChi23D->SetName("trdChi23D");
1834 TProfile2D* prof2DChi2 = trdChi23D->Project3DProfile("yx");
1835 prof2DChi2->SetName("prof2DChi2");
1836 pad = ((TVirtualPad*)l->At(1)); pad->cd();
1837 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1838 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1839 prof2DChi2->SetStats(kFALSE);
1840 prof2DChi2->SetTitle("");
1841 SetStyle(prof2DChi2->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1842 SetStyle(prof2DChi2->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1843 prof2DChi2->SetMaximum(2.9);
1844 prof2DChi2->Draw("colz");
1845 lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
1846
1847 // Track TRD chi2 vs pt and charge
1848 trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1849 TH2D* trdChi2VsPtNeg = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
1850 trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1851 trdChi2VsPtNeg->SetName("trdChi2VsPtNeg");
1852 TProfile* trdChi2VsPtNegProf = trdChi2VsPtNeg->ProfileX();
1853 trdChi2VsPtNegProf->SetName("trdChi2VsPtNegProf");
1854 trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), 1.0, 1.0);
1855 TH2D* trdChi2VsPtPos = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
1856 trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
1857 trdChi2VsPtPos->SetName("trdChi2VsPtPos");
1858 TProfile* trdChi2VsPtPosProf = trdChi2VsPtPos->ProfileX();
1859 trdChi2VsPtPosProf->SetName("trdChi2VsPtPosProf");
1860 pad = ((TVirtualPad*)l->At(4)); pad->cd();
1861 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1862 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1863 trdChi2VsPtNegProf->SetStats(kFALSE);
1864 trdChi2VsPtNegProf->SetTitle("");
1865 SetStyle(trdChi2VsPtNegProf->GetXaxis(), "p_{T} (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1866 SetStyle(trdChi2VsPtNegProf->GetYaxis(), "<TRD #chi^{2}>", 0.06, 1.0, kTRUE, 0.06);
1867 SetStyle(trdChi2VsPtNegProf, 1, 2, 2, 20, 2, 1);
1868 SetStyle(trdChi2VsPtPosProf, 1, 4, 2, 20, 4, 1);
1869 trdChi2VsPtNegProf->Draw();
1870 trdChi2VsPtPosProf->Draw("same");
1871 lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
1872 }
1873
1874 if(trdBudget) {
1875 // Track TRD budget vs (eta,phi)
1876 TH3D* trdBudget3D = (TH3D*)trdBudget->Project(0, trdBudget->GetVar(fgkVarNames[kTrackEtaTRD]),
1877 trdBudget->GetVar(fgkVarNames[kTrackPhiTRD]),
1878 trdBudget->GetVar(fgkVarNames[kTrackTRDBudget]));
1879 trdBudget3D->SetName("trdBudget3D");
1880 TProfile2D* prof2DBudget = trdBudget3D->Project3DProfile("yx");
1881 prof2DBudget->SetName("prof2DBudget");
1882 pad = ((TVirtualPad*)l->At(7)); pad->cd();
1883 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1884 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1885 prof2DBudget->SetStats(kFALSE);
1886 prof2DBudget->SetTitle("");
1887 SetStyle(prof2DBudget->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1888 SetStyle(prof2DBudget->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1889 prof2DBudget->Draw("colz");
1890 lat->DrawLatex(0.2, 0.95, "TRD budget");
1891 }
1892
1893 if(ploss) {
1894 // momentum loss
1895 ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
1896 TH2D* plossLayerNeg = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]),
1897 ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1898 plossLayerNeg->SetName("plossLayerNeg");
1899 TProfile* plossLayerNegProf = plossLayerNeg->ProfileX();
1900 plossLayerNegProf->SetName("plossLayerNegProf");
1901 ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
1902 TH2D* plossLayerPos = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]),
1903 ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1904 plossLayerPos->SetName("plossLayerPos");
1905 TProfile* plossLayerPosProf = plossLayerPos->ProfileX();
1906 plossLayerPosProf->SetName("plossLayerPosProf");
1907 ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.5, +1.5);
1908
1909 ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 0.0);
1910 TH3D* ploss3Dl0 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]),
1911 ploss->GetVar(fgkVarNames[kTrackPhiTRD]),
1912 ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1913 ploss3Dl0->SetName("ploss3Dl0");
1914 TProfile2D* plossEtaPhiL0Prof = ploss3Dl0->Project3DProfile("yx");
1915 plossEtaPhiL0Prof->SetName("plossEtaPhiL0Prof");
1916 ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 5.0, 5.0);
1917 TH3D* ploss3Dl5 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]),
1918 ploss->GetVar(fgkVarNames[kTrackPhiTRD]),
1919 ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
1920 ploss3Dl5->SetName("ploss3Dl5");
1921 TProfile2D* plossEtaPhiL5Prof = ploss3Dl5->Project3DProfile("yx");
1922 plossEtaPhiL5Prof->SetName("plossEtaPhiL5Prof");
1923 pad = ((TVirtualPad*)l->At(2)); pad->cd();
1924 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1925 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1926 plossEtaPhiL0Prof->SetStats(kFALSE);
1927 plossEtaPhiL0Prof->SetTitle("");
1928 SetStyle(plossEtaPhiL0Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1929 SetStyle(plossEtaPhiL0Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1930 plossEtaPhiL0Prof->SetMaximum(0.08);
1931 plossEtaPhiL0Prof->SetMinimum(-0.02);
1932 plossEtaPhiL0Prof->Draw("colz");
1933 lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 0");
1934 pad = ((TVirtualPad*)l->At(5)); pad->cd();
1935 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1936 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1937 plossEtaPhiL5Prof->SetStats(kFALSE);
1938 plossEtaPhiL5Prof->SetTitle("");
1939 SetStyle(plossEtaPhiL5Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1940 SetStyle(plossEtaPhiL5Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
1941 plossEtaPhiL5Prof->SetMaximum(0.08);
1942 plossEtaPhiL5Prof->SetMinimum(-0.02);
1943 plossEtaPhiL5Prof->Draw("colz");
1944 lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 5");
1945 pad = ((TVirtualPad*)l->At(8)); pad->cd();
1946 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
1947 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1948 plossLayerNegProf->SetStats(kFALSE);
1949 plossLayerNegProf->SetTitle("");
1950 SetStyle(plossLayerNegProf->GetYaxis(), "#Delta P (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
1951 SetStyle(plossLayerNegProf->GetXaxis(), "TRD layer", 0.06, 1.0, kTRUE, 0.06);
1952 SetStyle(plossLayerNegProf, 1, 2, 2, 20, 2, 1);
1953 SetStyle(plossLayerPosProf, 1, 4, 2, 20, 4, 1);
1954 plossLayerNegProf->GetYaxis()->SetRangeUser(TMath::Min(plossLayerNegProf->GetMinimum(),plossLayerPosProf->GetMinimum()-0.01),
1955 TMath::Max(plossLayerNegProf->GetMaximum(),plossLayerPosProf->GetMaximum())+0.01);
1956 plossLayerNegProf->Draw();
1957 plossLayerPosProf->Draw("same");
1958 lat->DrawLatex(0.2, 0.95, "P_{loss} vs layer");
1959 }
1960
1961 // clusters/tracklet and clusters/crossed rows
1962 TH3D* clustersEtaPhi[6]={0x0};
1963 TH3D* clsRowsEtaPhi[6]={0x0};
1964 for(Int_t il=0;il<6;++il) {
1965 if(clusters) {
1966 clusters->SetRangeUser(clusters->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
1967 clustersEtaPhi[il]=(TH3D*)clusters->Project(0, clusters->GetVar(fgkVarNames[kTrackEtaTRD]),
1968 clusters->GetVar(fgkVarNames[kTrackPhiTRD]),
1969 clusters->GetVar(fgkVarNames[kTrackletClusters]));
1970 clustersEtaPhi[il]->SetName(Form("clustersEtaPhi%d",il));
1971 }
1972 if(clsRows) {
1973 clsRows->SetRangeUser(clsRows->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
1974 clsRowsEtaPhi[il]=(TH3D*)clsRows->Project(0, clsRows->GetVar(fgkVarNames[kTrackEtaTRD]),
1975 clsRows->GetVar(fgkVarNames[kTrackPhiTRD]),
1976 clsRows->GetVar(fgkVarNames[kTrackletClustersVsRows]));
1977 clsRowsEtaPhi[il]->SetName(Form("clsRowsEtaPhi%d",il));
1978 }
1979 }
1980
1981 lat->SetTextSize(0.05);
1982 Int_t layerPads[6] = {0, 2, 4, 1, 3, 5};
1983
1984 TCanvas* c2=0x0;
1985 if(clusters) {
1986 c2 = new TCanvas("ESDsummary2", "ESD summary 2", 1600, 1200);
1987 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1988 gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1989 gPad->Divide(3,2,0.,0.);
1990 l=gPad->GetListOfPrimitives();
1991 for(Int_t il=0;il<6;++il) {
1992 TProfile2D* clustersEtaPhiProf = clustersEtaPhi[il]->Project3DProfile("yx");
1993 pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
1994 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1995 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
1996 clustersEtaPhiProf->SetStats(kFALSE);
1997 clustersEtaPhiProf->SetTitle("");
1998 SetStyle(clustersEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
1999 SetStyle(clustersEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
2000 clustersEtaPhiProf->Draw("colz");
2001 lat->DrawLatex(0.2, 0.95, Form("Clusters / tracklet, layer %d", il));
2002 }
2003 }
2004
2005 TCanvas* c3=0x0;
2006 if(clsRows) {
2007 c3 = new TCanvas("ESDsummary3", "ESD summary 3", 1600, 1200);
2008 gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2009 gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2010 gPad->Divide(3,2,0.,0.);
2011 l=gPad->GetListOfPrimitives();
2012 for(Int_t il=0;il<6;++il) {
2013 TProfile2D* clsRowsEtaPhiProf = clsRowsEtaPhi[il]->Project3DProfile("yx");
2014 pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
2015 pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2016 pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
2017 clsRowsEtaPhiProf->SetStats(kFALSE);
2018 clsRowsEtaPhiProf->SetTitle("");
2019 SetStyle(clsRowsEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
2020 SetStyle(clsRowsEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
2021 clsRowsEtaPhiProf->Draw("colz");
2022 lat->DrawLatex(0.2, 0.95, Form("Clusters / crossed rows, layer %d", il));
2023 }
2024 }
2025
2026 TCanvas* c4=0x0;
2027 if(tpcTofMatch) {
2028 TH2D* tpcRef = (TH2D*)tpcTofMatch->Project(0, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2029 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2030 TH2D* tpcPhiPt = (TH2D*)tpcTofMatch->Project(0, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2031 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2032 TH2D* tofin = (TH2D*)tpcTofMatch->Project(1, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2033 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2034 TH2D* tofinPhiPt = (TH2D*)tpcTofMatch->Project(1, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2035 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2036 TH2D* tofout = (TH2D*)tpcTofMatch->Project(2, tpcTofMatch->GetVar(fgkVarNames[kTrackEtaTRD]),
2037 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2038 TH2D* tofoutPhiPt = (TH2D*)tpcTofMatch->Project(2, tpcTofMatch->GetVar(fgkVarNames[kTrackPt]),
2039 tpcTofMatch->GetVar(fgkVarNames[kTrackPhiTRD]));
2040 tofin->Divide(tpcRef);
2041 tofout->Divide(tpcRef);
2042 tofinPhiPt->Divide(tpcPhiPt);
2043 tofoutPhiPt->Divide(tpcPhiPt);
2044
2045 c4=new TCanvas("ESDsummary4", "TPC - TOF matching", 1600., 1200.);
2046 c4->SetLeftMargin(0.01); c4->SetRightMargin(0.01);
2047 c4->SetTopMargin(0.01); c4->SetBottomMargin(0.01);
2048 c4->Divide(2,2,0.,0.);
2049 pad=c4->cd(1);
2050 pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2051 pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2052 tofin->SetTitle(""); tofin->SetStats(kFALSE);
2053 tofin->Draw("colz");
2054 lat->DrawLatex(0.1, 0.94, "TPC - TOFin matching");
2055 pad=c4->cd(2);
2056 pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2057 pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2058 tofout->SetTitle(""); tofout->SetStats(kFALSE);
2059 tofout->Draw("colz");
2060 lat->DrawLatex(0.1, 0.94, "TPC - TOFout matching");
2061 pad=c4->cd(3);
2062 pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2063 pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2064 tofinPhiPt->SetTitle(""); tofinPhiPt->SetStats(kFALSE);
2065 tofinPhiPt->Draw("colz");
2066 lat->DrawLatex(0.1, 0.94, "TPC - TOFin matching");
2067 pad=c4->cd(4);
2068 pad->SetLeftMargin(0.12); pad->SetRightMargin(0.12);
2069 pad->SetTopMargin(0.07); pad->SetBottomMargin(0.12);
2070 tofoutPhiPt->SetTitle(""); tofoutPhiPt->SetStats(kFALSE);
2071 tofoutPhiPt->Draw("colz");
2072 lat->DrawLatex(0.1, 0.94, "TPC - TOFout matching");
2073 }
2074
2075 if(matchPhiEta || trdQuality || trdChi2 || trdBudget || ploss) c1->SaveAs("esdSummary1.gif");
2076 if(clusters) c2->SaveAs("esdSummary2.gif");
2077 if(clsRows) c3->SaveAs("esdSummary3.gif");
2078 if(tpcTofMatch) c4->SaveAs("esdSummary4.gif");
2079}
2080
2081
2082//__________________________________________________________________________________________________
2083void AliTRDcheckESD::DrawTRDGrid() {
2084 //
2085 // Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
2086 // The canvas on which to draw must already exist.
2087 //
2088 TLine line;
2089 line.SetLineColor(2);
2090 line.SetLineWidth(1);
2091 line.SetLineStyle(2);
2092 for(Int_t i=-9; i<=9; ++i) {
2093 line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i);
2094 }
2095 line.DrawLine(-0.85, -3.15, -0.85, 3.15);
2096 line.DrawLine(-0.54, -3.15, -0.54, 3.15);
2097 line.DrawLine(-0.16, -3.15, -0.16, 3.15);
2098 line.DrawLine(+0.16, -3.15, +0.16, 3.15);
2099 line.DrawLine(+0.54, -3.15, +0.54, 3.15);
2100 line.DrawLine(+0.85, -3.15, +0.85, 3.15);
2101}
2102
2103//_________________________________________________________________
2104void AliTRDcheckESD::SetStyle(TH1* hist,
2105 Int_t lineStyle, Int_t lineColor, Int_t lineWidth,
2106 Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
2107 //
2108 // Set style settings for histograms
2109 //
2110 if(!hist) return;
2111 hist->SetLineStyle(lineStyle);
2112 hist->SetLineColor(lineColor);
2113 hist->SetLineWidth(lineWidth);
2114 hist->SetMarkerStyle(markerStyle);
2115 hist->SetMarkerColor(markerColor);
2116 hist->SetMarkerSize(markerSize);
2117}
2118
2119//____________________________________________________________________
2120void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle,
2121 Float_t labelSize) {
2122 //
2123 // Set style settings for axes
2124 //
2125 if(!axis) return;
2126 axis->SetTitle(title);
2127 axis->SetTitleSize(titleSize);
2128 axis->SetTitleOffset(titleOffset);
2129 axis->CenterTitle(centerTitle);
2130 axis->SetLabelSize(labelSize);
2131 axis->SetTitleFont(42);
2132 axis->SetLabelFont(42);
2133 axis->SetNdivisions(507);
2134}
2135
2136//____________________________________________________________________
2137void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
2138 //
2139 // Find the isolated bunch crossings
2140 //
2141 Int_t isolationSize = 5; // number of free bunches in both directions
2142 for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
2143 Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
2144 if(bc<-0.001 || bc>3499.01) {
2145 isIsolated[bc] = kFALSE;
2146 continue;
2147 }
2148 Double_t entries = bcHist->GetBinContent(bcBin);
2149 if(entries<0.001) {
2150 isIsolated[bc] = kFALSE;
2151 continue; // no entries
2152 }
2153
2154 // check isolation
2155 isIsolated[bc] = kTRUE;
2156 for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc<=TMath::Min(3499, bcBin+isolationSize); ++ibc) {
2157 if(ibc==bcBin) continue;
2158 if(bcHist->GetBinContent(ibc)>0.01) {
2159 isIsolated[bc] = kFALSE;
2160 break;
2161 }
2162 }
2163 } // end loop over BC bins
2164
2165 cout << "Isolated bunches: " << endl;
2166 for(Int_t ibc=0; ibc<3500; ++ibc)
2167 if(isIsolated[ibc]) cout << "BC #" << ibc << endl;
2168}
2169
2170
2171//__________________________________________________________________________________________________
2172Int_t AliTRDcheckESD::GetTriggerIndex(const Char_t* name, Bool_t createNew/*=kTRUE*/) {
2173 //
2174 // Return the index of trigger "name" in the trigger histogram.
2175 // If the index for this trigger does not exist yet, then assign one if createNew is set to TRUE
2176 //
2177 //cout << "GetTriggerIndex for " << name << endl;
2178 TH1F* triggerHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
2179 TString nameStr=name;
2180 for(Int_t i=1; i<=triggerHist->GetXaxis()->GetNbins(); ++i) {
2181 if(!nameStr.CompareTo(triggerHist->GetXaxis()->GetBinLabel(i))) {
2182 //cout << " index found: " << i << endl;
2183 return i;
2184 }
2185 }
2186 if(createNew) {
2187 triggerHist->GetXaxis()->SetBinLabel(fNAssignedTriggers+1, name);
2188 for(Int_t i=1;i<fHistos->GetEntries();++i) {
2189 TString objType = fHistos->At(i)->IsA()->GetName();
2190 if(!objType.Contains("AliCFContainer")) continue;
2191 AliCFContainer* cf=(AliCFContainer*)fHistos->At(i);
2192 Int_t trigVar = cf->GetVar(fgkVarNames[kEventTrigger]);
2193 if(trigVar>=0)
2194 for(Int_t istep=0;istep<cf->GetNStep();++istep)
2195 cf->GetAxis(trigVar, istep)->SetBinLabel(fNAssignedTriggers+1, name);
2196 } // end loop over histograms and CFs
2197
2198 ++fNAssignedTriggers;
2199 return fNAssignedTriggers+1;
2200 }
2201 else {
2202 return -1;
2203 }
2204}
2205
2206//__________________________________________________________________________________________________
2207void AliTRDcheckESD::PrintTriggers() const {
2208 //
2209 // Print the available triggers for this run
2210 //
2211 if(!fHistos) {
2212 cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
2213 return;
2214 }
2215 TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
2216 cout << "Triggers found in this run" << endl;
2217 cout << "==========================" << endl;
2218 cout << "Name Index Entries " << endl;
2219 for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
2220 if(hTriggers->GetXaxis()->GetBinLabel(it)[0]!='\0') {
2221 cout << hTriggers->GetXaxis()->GetBinLabel(it) << " " << hTriggers->GetXaxis()->GetBinCenter(it) << " " << hTriggers->GetBinContent(it) << endl;
2222 }
2223 }
2224}
2225
2226
2227//__________________________________________________________________________________________________
2228Int_t AliTRDcheckESD::GetTriggerCounter(const Char_t* triggerName) const {
2229 //
2230 // Get the number of events for a given trigger name
2231 //
2232 if(!fHistos) {
2233 cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
2234 return -1;
2235 }
2236 TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
2237 Int_t counter = -1;
2238 for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
2239 TString trgString = hTriggers->GetXaxis()->GetBinLabel(it);
2240 if(!trgString.CompareTo(triggerName))
2241 counter = (Int_t)hTriggers->GetBinContent(it);
2242 }
2243 if(counter<0) {cout << "AliTRDcheckESD::GetTriggerCounter() Trigger not found !!";}
2244 return counter;
2245}
2246
2247
2248//__________________________________________________________________________________________________________
2249Int_t AliTRDcheckESD::GetNAssignedTriggers() {
2250 //
2251 // Return the number of assigned triggers
2252 //
2253 return fNAssignedTriggers;
2254}