]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - PWGPP/ITS/AliAnalysisTaskSDDRP.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Additional protection against empty fit results and empty (or low
[u/mrichter/AliRoot.git] / PWGPP / ITS / AliAnalysisTaskSDDRP.cxx
... / ...
CommitLineData
1#include "AliAnalysisTask.h"
2#include "AliAnalysisManager.h"
3#include "AliAnalysisDataContainer.h"
4#include "AliITSRecPoint.h"
5#include "AliESDEvent.h"
6#include "AliTrackPointArray.h"
7#include "AliITSgeomTGeo.h"
8#include "AliESDfriend.h"
9#include "AliCDBManager.h"
10#include "AliCDBEntry.h"
11#include "AliITSCalibrationSDD.h"
12#include "AliITSresponseSDD.h"
13#include "AliGeomManager.h"
14#include <TSystem.h>
15#include <TTree.h>
16#include <TH1F.h>
17#include <TH2F.h>
18#include <TChain.h>
19#include <TGeoGlobalMagField.h>
20#include "AliESDInputHandlerRP.h"
21/**************************************************************************
22 * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
23 * *
24 * Author: The ALICE Off-line Project. *
25 * Contributors are mentioned in the code where appropriate. *
26 * *
27 * Permission to use, copy, modify and distribute this software and its *
28 * documentation strictly for non-commercial purposes is hereby granted *
29 * without fee, provided that the above copyright notice appears in all *
30 * copies and that both the copyright notice and this permission notice *
31 * appear in the supporting documentation. The authors make no claims *
32 * about the suitability of this software for any purpose. It is *
33 * provided "as is" without express or implied warranty. *
34 **************************************************************************/
35
36//*************************************************************************
37// Implementation of class AliAnalysiTaskSDDRP
38// AliAnalysisTaskSE to extract from ESD + ESDfreinds + ITS rec points
39// performance plots for SDD detector
40//
41// Author: F. Prino, prino@to.infn.it
42//*************************************************************************
43
44
45#include "AliAnalysisTaskSDDRP.h"
46
47ClassImp(AliAnalysisTaskSDDRP)
48//______________________________________________________________________________
49AliAnalysisTaskSDDRP::AliAnalysisTaskSDDRP() : AliAnalysisTaskSE("SDD RecPoints"),
50 fOutput(0),
51 fHistNEvents(0),
52 fHistCluInLay(0),
53 fHistAllPMod(0),
54 fHistGoodPMod(0),
55 fHistBadRegMod(0),
56 fHistMissPMod(0),
57 fHistSkippedMod(0),
58 fHistOutAccMod(0),
59 fHistNoRefitMod(0),
60 fHistAllPXloc(0),
61 fHistGoodPXloc(0),
62 fHistBadRegXloc(0),
63 fHistMissPXloc(0),
64 fHistAllPZloc(0),
65 fHistGoodPZloc(0),
66 fHistBadRegZloc(0),
67 fHistMissPZloc(0),
68 fHistdEdxL3VsP(0),
69 fHistdEdxL4VsP(0),
70 fHistdEdxVsMod(0),
71 fRecPMod(0),
72 fTrackPMod(0),
73 fGoodAnMod(0),
74 fRecPLadLay3(0),
75 fRecPLadLay4(0),
76 fTrackPLadLay3(0),
77 fTrackPLadLay4(0),
78 fGoodAnLadLay3(0),
79 fGoodAnLadLay4(0),
80 fDriftTimeRP(0),
81 fDriftTimeTPAll(0),
82 fDriftTimeTPNoExtra(0),
83 fDriftTimeTPExtra(0),
84 fCluSizAnVsTime(0),
85 fCluSizTbVsTime(0),
86 fResp(0),
87 fUseITSsaTracks(kFALSE),
88 fMinITSpts(3),
89 fMinTPCpts(70),
90 fMinPfordEdx(0.5),
91 fOnlyCINT1BTrig(0),
92 fExcludeBadMod(kFALSE)
93{
94 //
95 DefineOutput(1, TList::Class());
96}
97
98
99//___________________________________________________________________________
100AliAnalysisTaskSDDRP::~AliAnalysisTaskSDDRP(){
101 //
102 if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
103 delete fOutput;
104 fOutput = 0;
105 }
106
107}
108
109
110//___________________________________________________________________________
111
112void AliAnalysisTaskSDDRP::UserCreateOutputObjects() {
113
114 fOutput = new TList();
115 fOutput->SetOwner();
116 fOutput->SetName("OutputHistos");
117
118 fHistNEvents = new TH1F("hNEvents", "Number of processed events",3,-1.5,1.5);
119 fHistNEvents->Sumw2();
120 fHistNEvents->SetMinimum(0);
121 fOutput->Add(fHistNEvents);
122
123 fHistCluInLay = new TH1F("hCluInLay","hCluInLay",7,-1.5,5.5);
124 fHistCluInLay->Sumw2();
125 fHistCluInLay->SetMinimum(0);
126 fOutput->Add(fHistCluInLay);
127
128 // -- Module histos
129
130 fHistAllPMod = new TH1F("hAllPmod","Crossing Tracks vs. Module",260,239.5,499.5);
131 fHistAllPMod->Sumw2();
132 fHistAllPMod->SetMinimum(0);
133 fOutput->Add(fHistAllPMod);
134
135 fHistGoodPMod = new TH1F("hGoodPmod","PointsAssocToTrack per Module",260,239.5,499.5);
136 fHistGoodPMod->Sumw2();
137 fHistGoodPMod->SetMinimum(0);
138 fOutput->Add(fHistGoodPMod);
139
140 fHistBadRegMod = new TH1F("hBadRegmod","Tracks in BadRegion per Module",260,239.5,499.5);
141 fHistBadRegMod->Sumw2();
142 fHistBadRegMod->SetMinimum(0);
143 fOutput->Add(fHistBadRegMod);
144
145 fHistMissPMod = new TH1F("hMissPmod","Missing Points per Module",260,239.5,499.5);
146 fHistMissPMod->Sumw2();
147 fHistMissPMod->SetMinimum(0);
148 fOutput->Add(fHistMissPMod);
149
150 fHistSkippedMod = new TH1F("hSkippedmod","Tracks in Skipped Module",260,239.5,499.5);
151 fHistSkippedMod->Sumw2();
152 fHistSkippedMod->SetMinimum(0);
153 fOutput->Add(fHistSkippedMod);
154
155 fHistOutAccMod = new TH1F("hOutAccmod","Tracks outside zAcc per Module",260,239.5,499.5);
156 fHistOutAccMod->Sumw2();
157 fHistOutAccMod->SetMinimum(0);
158 fOutput->Add(fHistOutAccMod);
159
160 fHistNoRefitMod = new TH1F("hNoRefitmod","Points rejected in refit per Module",260,239.5,499.5);
161 fHistNoRefitMod->Sumw2();
162 fHistNoRefitMod->SetMinimum(0);
163 fOutput->Add(fHistNoRefitMod);
164
165
166
167 fRecPMod = new TH1F("hRPMod","Rec Points per Module",260,239.5,499.5);
168 fRecPMod->Sumw2();
169 fRecPMod->SetMinimum(0);
170 fOutput->Add(fRecPMod);
171
172 fTrackPMod = new TH1F("hTPMod","Track Points per Module",260,239.5,499.5);
173 fTrackPMod->Sumw2();
174 fTrackPMod->SetMinimum(0);
175 fOutput->Add(fTrackPMod);
176
177 fGoodAnMod = new TH1F("hGAMod","Good Anodes per Module",260,239.5,499.5);
178 fOutput->Add(fGoodAnMod);
179
180 // -- Local coordinates
181
182 fHistAllPXloc = new TH1F("hAllPxloc","Crossing Tracks vs. Xloc",75, -3.75, 3.75);
183 fHistAllPXloc->Sumw2();
184 fHistAllPXloc->SetMinimum(0);
185 fOutput->Add(fHistAllPXloc);
186
187 fHistGoodPXloc = new TH1F("hGoodPxloc","PointsAssocToTrack vs. Xloc",75, -3.75, 3.75);
188 fHistGoodPXloc->Sumw2();
189 fHistGoodPXloc->SetMinimum(0);
190 fOutput->Add(fHistGoodPXloc);
191
192 fHistBadRegXloc = new TH1F("hBadRegxloc","Tracks in BadRegion vs. Xloc",75, -3.75, 3.75);
193 fHistBadRegXloc->Sumw2();
194 fHistBadRegXloc->SetMinimum(0);
195 fOutput->Add(fHistBadRegXloc);
196
197 fHistMissPXloc = new TH1F("hMissPxloc","Missing Points vs. Xloc",75, -3.75, 3.75);
198 fHistMissPXloc->Sumw2();
199 fHistMissPXloc->SetMinimum(0);
200 fOutput->Add(fHistMissPXloc);
201
202 fHistAllPZloc = new TH1F("hAllPzloc","Crossing Tracks vs. Zloc",77, -3.85, 3.85);
203 fHistAllPZloc->Sumw2();
204 fHistAllPZloc->SetMinimum(0);
205 fOutput->Add(fHistAllPZloc);
206
207 fHistGoodPZloc = new TH1F("hGoodPzloc","PointsAssocToTrack vs. Zloc",77, -3.85, 3.85);
208 fHistGoodPZloc->Sumw2();
209 fHistGoodPZloc->SetMinimum(0);
210 fOutput->Add(fHistGoodPZloc);
211
212 fHistBadRegZloc = new TH1F("hBadRegzloc","Tracks in BadRegion vs. Zloc",77, -3.85, 3.85);
213 fHistBadRegZloc->Sumw2();
214 fHistBadRegZloc->SetMinimum(0);
215 fOutput->Add(fHistBadRegZloc);
216
217 fHistMissPZloc = new TH1F("hMissPzloc","Missing Points vs. Zloc",77, -3.85, 3.85);
218 fHistMissPZloc->Sumw2();
219 fHistMissPZloc->SetMinimum(0);
220 fOutput->Add(fHistMissPZloc);
221
222 // -- Ladder histos
223
224 fRecPLadLay3 = new TH1F("hRPLad3","Rec Points per Ladder Layer 3",14,-0.5,13.5);
225 fRecPLadLay3->Sumw2();
226 fRecPLadLay3->SetMinimum(0);
227 fOutput->Add(fRecPLadLay3);
228
229 fRecPLadLay4 = new TH1F("hRPLad4","Rec Points per Ladder Layer 4",22,-0.5,21.5);
230 fRecPLadLay4->Sumw2();
231 fRecPLadLay4->SetMinimum(0);
232 fOutput->Add(fRecPLadLay4);
233
234 fTrackPLadLay3 = new TH1F("hTPLad3","Track Points per Ladder Layer 3",14,-0.5,13.5);
235 fTrackPLadLay3->Sumw2();
236 fTrackPLadLay3->SetMinimum(0);
237 fOutput->Add(fTrackPLadLay3);
238
239 fTrackPLadLay4 = new TH1F("hTPLad4","Track Points per Ladder Layer 4",22,-0.5,21.5);
240 fTrackPLadLay4->Sumw2();
241 fTrackPLadLay4->SetMinimum(0);
242 fOutput->Add(fTrackPLadLay4);
243
244 fGoodAnLadLay3 = new TH1F("hGALad3","Good Anodes per Ladder Layer 3",14,-0.5,13.5);
245 fOutput->Add(fGoodAnLadLay3);
246
247 fGoodAnLadLay4 = new TH1F("hGALad4","Good Anodes per Ladder Layer 4",22,-0.5,21.5);
248 fOutput->Add(fGoodAnLadLay4);
249
250 fDriftTimeRP=new TH1F("hDrTimRP","Drift Time from Rec Points (ns)",640,0.,6400.);
251 fDriftTimeRP->Sumw2();
252 fDriftTimeRP->SetMinimum(0.);
253 fOutput->Add(fDriftTimeRP);
254
255 fDriftTimeTPAll=new TH1F("hDrTimTPAll","Drift Time from Track Points (ns)",640,0.,6400.);
256 fDriftTimeTPAll->Sumw2();
257 fDriftTimeTPAll->SetMinimum(0.);
258 fOutput->Add(fDriftTimeTPAll);
259
260 fDriftTimeTPNoExtra=new TH1F("hDrTimTPNoExtra","Drift Time from Track Points (ns)",640,0.,6400.);
261 fDriftTimeTPNoExtra->Sumw2();
262 fDriftTimeTPNoExtra->SetMinimum(0.);
263 fOutput->Add(fDriftTimeTPNoExtra);
264
265 fDriftTimeTPExtra=new TH1F("hDrTimTPExtra","Drift Time from Track Points (ns)",640,0.,6400.);
266 fDriftTimeTPExtra->Sumw2();
267 fDriftTimeTPExtra->SetMinimum(0.);
268 fOutput->Add(fDriftTimeTPExtra);
269
270 // dE/dx histos
271
272 fHistdEdxL3VsP=new TH2F("hdEdxL3VsP","dE/dx vs. p lay3",40,0.,2.,100,0.,500.);
273 fHistdEdxL3VsP->Sumw2();
274 fHistdEdxL3VsP->SetMinimum(0);
275 fOutput->Add(fHistdEdxL3VsP);
276
277 fHistdEdxL4VsP=new TH2F("hdEdxL4VsP","dE/dx vs. p lay4",40,0.,2.,100,0.,500);
278 fHistdEdxL4VsP->Sumw2();
279 fHistdEdxL4VsP->SetMinimum(0);
280 fOutput->Add(fHistdEdxL4VsP);
281
282 fHistdEdxVsMod=new TH2F("hdEdxVsMod","dE/dx vs. mod",260,239.5,499.5,100,0.,500.);
283 fHistdEdxVsMod->Sumw2();
284 fHistdEdxVsMod->SetMinimum(0);
285 fOutput->Add(fHistdEdxVsMod);
286
287 for(Int_t it=0; it<8; it++){
288 fSignalTime[it]=new TH1F(Form("hSigTimeInt%d",it),Form("hSigTimeInt%d",it),100,0.,300.);
289 fSignalTime[it]->Sumw2();
290 fSignalTime[it]->SetMinimum(0);
291 fOutput->Add(fSignalTime[it]);
292 }
293
294 // cluster size histos
295
296 fCluSizAnVsTime = new TH2F("hCluSizAn","hCluSizAn",40,0.,6400.,15,-0.5,14.5);
297 fCluSizAnVsTime->Sumw2();
298 fCluSizAnVsTime->SetMinimum(0);
299 fOutput->Add(fCluSizAnVsTime);
300
301 fCluSizTbVsTime = new TH2F("hCluSizTb","hCluSizTb",40,0.,6400.,15,-0.5,14.5);
302 fCluSizTbVsTime->Sumw2();
303 fCluSizTbVsTime->SetMinimum(0);
304 fOutput->Add(fCluSizTbVsTime);
305
306
307 // Read dead channels from OCDB
308
309// == Not allowed in QA train. This is set by AliTaskCDBconnect. (A.G. 14/10/2011)
310// If needed for independent use of the task, protect via a flag that is OFF by default.
311/*
312 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
313 if (!mgr) AliFatal("No analysis manager");
314
315 AliCDBManager* man = AliCDBManager::Instance();
316 man->SetDefaultStorage("raw://");
317 Int_t nrun=mgr->GetRunFromPath();
318 man->SetRun(nrun);
319*/
320
321 PostData(1, fOutput);
322
323}
324//______________________________________________________________________________
325void AliAnalysisTaskSDDRP::UserExec(Option_t *)
326{
327 //
328 static Bool_t initCalib = kFALSE;
329 AliESDEvent *esd = (AliESDEvent*) (InputEvent());
330
331
332 if(!esd) {
333 printf("AliAnalysisTaskSDDRP::Exec(): bad ESD\n");
334 return;
335 }
336
337
338 if(!ESDfriend()) {
339 printf("AliAnalysisTaskSDDRP::Exec(): bad ESDfriend\n");
340 return;
341 }
342
343// Code below moved from UserCreateOutputObjects where the run for OCDB may not
344// be yet properly set. Make sure this is called only once. (A.G. 14/10/2011)
345
346/************/
347 if (!initCalib) {
348 AliCDBManager* man = AliCDBManager::Instance();
349 if (!man) {
350 AliFatal("CDB not set but needed by AliAnalysisTaskSDDRP");
351 return;
352 }
353 AliCDBEntry* eR=(AliCDBEntry*)man->Get("ITS/Calib/RespSDD");
354 if (eR) {
355 eR->PrintId();
356 eR->PrintMetaData();
357 fResp=(AliITSresponseSDD*)eR->GetObject();
358 }
359
360 AliCDBEntry* eC=(AliCDBEntry*)man->Get("ITS/Calib/CalibSDD");
361 if (!eC) {
362 AliError("Cannot retrieve CDB entry for ITS/Calib/CalibSDD");
363 return;
364 }
365 Int_t countGood3[14];
366 Int_t countGood4[22];
367 Int_t countGoodMod[260];
368 eC->PrintId();
369 eC->PrintMetaData();
370 TObjArray* calsdd=(TObjArray*)eC->GetObject();
371 for(Int_t ilad=0;ilad<14;ilad++) countGood3[ilad]=0;
372 for(Int_t ilad=0;ilad<22;ilad++) countGood4[ilad]=0;
373 for(Int_t imod=0;imod<260;imod++) countGoodMod[imod]=0;
374 for(Int_t imod=0;imod<260;imod++){
375 AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)calsdd->At(imod);
376 if(cal->IsBad()) continue;
377 Int_t modId=imod+AliITSgeomTGeo::GetModuleIndex(3,1,1);
378 Int_t lay,lad,det;
379 AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
380 if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
381 for(Int_t ian=0; ian<512; ian++){
382 if(cal->IsBadChannel(ian)) continue;
383 countGoodMod[imod]++;
384 if(lay==3) countGood3[lad-1]++;
385 else if(lay==4) countGood4[lad-1]++;
386 }
387 }
388
389 for(Int_t imod=0;imod<260;imod++) fGoodAnMod->SetBinContent(imod+1,countGoodMod[imod]);
390 fGoodAnMod->SetMinimum(0);
391 for(Int_t ilad=0;ilad<14;ilad++) fGoodAnLadLay3->SetBinContent(ilad+1,countGood3[ilad]);
392 fGoodAnLadLay3->SetMinimum(0);
393 for(Int_t ilad=0;ilad<22;ilad++) fGoodAnLadLay4->SetBinContent(ilad+1,countGood4[ilad]);
394 fGoodAnLadLay4->SetMinimum(0);
395 initCalib = kTRUE;
396 }
397/************/
398
399 PostData(1, fOutput);
400
401 fHistNEvents->Fill(0);
402 if(fOnlyCINT1BTrig){
403 if(!esd->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL")) return;
404 fHistNEvents->Fill(1);
405 }
406 const AliTrackPointArray *array = 0;
407 Int_t ntracks = esd->GetNumberOfTracks();
408 for (Int_t itrack=0; itrack < ntracks; itrack++) {
409 AliESDtrack * track = esd->GetTrack(itrack);
410 if (!track) continue;
411
412 Bool_t accept=kTRUE;
413 if(fUseITSsaTracks){
414 if(track->GetNcls(1)>0) accept=kFALSE;
415 }else{
416 if(track->GetNcls(1)<fMinTPCpts) accept=kFALSE;
417 }
418 if(track->GetNcls(0) < fMinITSpts) accept=kFALSE;
419 Int_t trstatus=track->GetStatus();
420 if(!(trstatus&AliESDtrack::kITSrefit)) accept=kFALSE;
421 if(!accept) continue;
422
423 fHistCluInLay->Fill(-1.); // bin -1 counts accepted tracks
424 UChar_t clumap=track->GetITSClusterMap();
425 for(Int_t iBit=0; iBit<6; iBit++){
426 if(clumap&(1<<iBit)) fHistCluInLay->Fill(iBit);
427 }
428
429
430 Double_t dedx[4];
431 track->GetITSdEdxSamples(dedx);
432 Float_t mom=track->P();
433 Int_t iMod,status;
434 Float_t xloc,zloc;
435 for(Int_t iLay=2; iLay<=3; iLay++){
436 Bool_t ok=track->GetITSModuleIndexInfo(iLay,iMod,status,xloc,zloc);
437 if(ok){
438 iMod+=240;
439 fHistAllPMod->Fill(iMod);
440 fHistAllPXloc->Fill(xloc);
441 fHistAllPZloc->Fill(zloc);
442 if(status==1){
443 fHistGoodPMod->Fill(iMod);
444 fHistGoodPXloc->Fill(xloc);
445 fHistGoodPZloc->Fill(zloc);
446 if(mom>fMinPfordEdx) fHistdEdxVsMod->Fill(iMod,dedx[iLay-2]);
447 if(iLay==2) fHistdEdxL3VsP->Fill(mom,dedx[0]);
448 else fHistdEdxL4VsP->Fill(mom,dedx[1]);
449 }
450 else if(status==2){
451 fHistBadRegMod->Fill(iMod);
452 fHistBadRegXloc->Fill(xloc);
453 fHistBadRegZloc->Fill(zloc);
454 }
455 else if(status==3) fHistSkippedMod->Fill(iMod);
456 else if(status==4) fHistOutAccMod->Fill(iMod);
457 else if(status==5){
458 fHistMissPMod->Fill(iMod);
459 fHistMissPXloc->Fill(xloc);
460 fHistMissPZloc->Fill(zloc);
461 }
462 else if(status==6) fHistNoRefitMod->Fill(iMod);
463 }
464 }
465
466
467 array = track->GetTrackPointArray();
468 if(!array) continue;
469 for(Int_t ipt=0; ipt<array->GetNPoints(); ipt++) {
470 AliTrackPoint point;
471 Int_t modId;
472 array->GetPoint(point,ipt);
473 Int_t volId = point.GetVolumeID();
474 Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
475 if(layerId<3 || layerId>4) continue;
476 modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
477 Int_t lay,lad,det;
478 AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
479 if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
480 fTrackPMod->Fill(modId);
481 fDriftTimeTPAll->Fill(point.GetDriftTime());
482 if(point.IsExtra()) fDriftTimeTPExtra->Fill(point.GetDriftTime());
483 else fDriftTimeTPNoExtra->Fill(point.GetDriftTime());
484 Float_t dtime=point.GetDriftTime()-fResp->GetTimeZero(modId);
485 Int_t cluTyp=point.GetClusterType();
486 Int_t clSizAn=(cluTyp>>8)&0xFF;
487 Int_t clSizTb=cluTyp&0xFF;
488 fCluSizAnVsTime->Fill(dtime,clSizAn);
489 fCluSizTbVsTime->Fill(dtime,clSizTb);
490 Int_t theBin=int(dtime/6500.*8.);
491 if(layerId==3){
492 fTrackPLadLay3->Fill(lad-1);
493 if(dedx[0]>0. && track->P()>fMinPfordEdx) fSignalTime[theBin]->Fill(dedx[0]);
494 }
495 if(layerId==4){
496 fTrackPLadLay4->Fill(lad-1);
497 if(dedx[1]>0.&& track->P()>fMinPfordEdx) fSignalTime[theBin]->Fill(dedx[1]);
498 }
499 }
500 }
501
502 AliESDInputHandlerRP *hand = dynamic_cast<AliESDInputHandlerRP*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
503 TTree* tR = 0;
504 if (hand) tR = hand->GetTreeR("ITS");
505 if (tR){
506 TClonesArray *ITSrec= new TClonesArray("AliITSRecPoint");
507 TBranch *branch =tR->GetBranch("ITSRecPoints");
508 branch->SetAddress(&ITSrec);
509 for (Int_t modId=240; modId<500; modId++){
510 Int_t lay,lad,det;
511 AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
512 if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
513 branch->GetEvent(modId);
514 Int_t nrecp = ITSrec->GetEntries();
515 fRecPMod->Fill(modId,nrecp);
516 if(lay==3) fRecPLadLay3->Fill(lad-1,nrecp);
517 if(lay==4) fRecPLadLay4->Fill(lad-1,nrecp);
518 for(Int_t irec=0;irec<nrecp;irec++) {
519 AliITSRecPoint *recp = (AliITSRecPoint*)ITSrec->At(irec);
520 fDriftTimeRP->Fill(recp->GetDriftTime());
521 }
522 }
523 ITSrec->Delete();
524 delete ITSrec;
525 }
526 PostData(1,fOutput);
527
528}
529//______________________________________________________________________________
530Bool_t AliAnalysisTaskSDDRP::CheckModule(Int_t lay, Int_t lad, Int_t det) const{
531 //
532 if(lay==4){
533 if(lad==3 && det==5) return kFALSE; // 1500 V
534 if(lad==3 && det==6) return kFALSE; // 0 V
535 if(lad==3 && det==7) return kFALSE; // 1500 V
536 if(lad==4 && det==1) return kFALSE; // 0 V
537 if(lad==4 && det==2) return kFALSE; // 1500 V
538 if(lad==7 && det==5) return kFALSE; // 0 MV
539 if(lad==9 && det==3) return kFALSE; // 1500 V
540 if(lad==9 && det==4) return kFALSE; // 0 V
541 if(lad==9 && det==5) return kFALSE; // 1500 V
542 if(lad==11 && det==6) return kFALSE; // 1500 V
543 if(lad==11 && det==7) return kFALSE; // 0 V
544 if(lad==11 && det==8) return kFALSE; // 1500 V
545 if(lad==18 && det==5) return kFALSE; // 1500 V
546 if(lad==18 && det==6) return kFALSE; // 0 V
547 if(lad==18 && det==7) return kFALSE; // 1500 V
548 if(lad==22 && det==1) return kFALSE; // 0 V
549 if(lad==22 && det==2) return kFALSE; // 1500 V
550 }
551 if(lay==3){
552 if(lad==4 && det==4) return kFALSE; // 1500 V
553 if(lad==3) return kFALSE; // swapped in geometry
554 }
555 return kTRUE;
556}
557
558//______________________________________________________________________________
559void AliAnalysisTaskSDDRP::Terminate(Option_t */*option*/)
560{
561 // Terminate analysis
562 fOutput = dynamic_cast<TList*> (GetOutputData(1));
563 if (!fOutput) {
564 printf("ERROR: fOutput not available\n");
565 return;
566 }
567 fHistNEvents= dynamic_cast<TH1F*>(fOutput->FindObject("hNEvents"));
568 fHistCluInLay= dynamic_cast<TH1F*>(fOutput->FindObject("hCluInLay"));
569
570 fHistAllPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPMod"));
571 fHistGoodPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPMod"));
572 fHistBadRegMod= dynamic_cast<TH1F*>(fOutput->FindObject("hBadRegMod"));
573 fHistMissPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPMod"));
574 fHistSkippedMod= dynamic_cast<TH1F*>(fOutput->FindObject("hSkippedMod"));
575 fHistOutAccMod= dynamic_cast<TH1F*>(fOutput->FindObject("hOutAccMod"));
576 fHistNoRefitMod= dynamic_cast<TH1F*>(fOutput->FindObject("hNoRefitMod"));
577
578 fHistAllPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPxloc"));
579 fHistGoodPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPxloc"));
580 fHistBadRegXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hBadRegxloc"));
581 fHistMissPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPxloc"));
582 fHistAllPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPzloc"));
583 fHistGoodPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPzloc"));
584 fHistBadRegZloc= dynamic_cast<TH1F*>(fOutput->FindObject("fHistBadRegZloc"));
585 fHistMissPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPzloc"));
586
587 fHistdEdxL3VsP= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxL3VsP"));
588 fHistdEdxL4VsP= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxL4VsP"));
589 fHistdEdxVsMod= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxVsMod"));
590
591 fRecPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hRPMod"));
592 fTrackPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hTPMod"));
593 fGoodAnMod= dynamic_cast<TH1F*>(fOutput->FindObject("hGAMod"));
594
595 fRecPLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hRPLad3"));
596 fRecPLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hRPLad4"));
597 fTrackPLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hTPLad3"));
598 fTrackPLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hTPLad4"));
599 fGoodAnLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hGALad3"));
600 fGoodAnLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hGALad4"));
601
602 fDriftTimeRP= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimRP"));
603 fDriftTimeTPAll= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPAll"));
604 fDriftTimeTPNoExtra= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPNoExtra"));
605 fDriftTimeTPExtra= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPExtra"));
606
607 for(Int_t it=0; it<8; it++){
608 fSignalTime[it]= dynamic_cast<TH1F*>(fOutput->FindObject(Form("hSigTimeInt%d",it)));
609 }
610 fCluSizAnVsTime= dynamic_cast<TH2F*>(fOutput->FindObject("hCluSizAn"));
611 fCluSizTbVsTime= dynamic_cast<TH2F*>(fOutput->FindObject("hCluSizTb"));
612
613 return;
614}
615
616
617
618
619