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