PWG1/ITS/AliAnalysisTaskSDDRP.cxx

   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
  47 ClassImp(AliAnalysisTaskSDDRP)
  48 //______________________________________________________________________________
  49 AliAnalysisTaskSDDRP::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 //___________________________________________________________________________
 100 AliAnalysisTaskSDDRP::~AliAnalysisTaskSDDRP(){
 101   //
 102   if (fOutput) {
 103     delete fOutput;
 104     fOutput = 0;
 105   }
 106
 107 }
 108
 109
 110 //___________________________________________________________________________
 111
 112 void 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   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 310   if (!mgr) AliFatal("No analysis manager");
 311
 312   AliCDBManager* man = AliCDBManager::Instance();
 313   man->SetDefaultStorage("raw://");
 314   Int_t nrun=mgr->GetRunFromPath();
 315   man->SetRun(nrun);
 316
 317
 318   AliCDBEntry* eR=(AliCDBEntry*)man->Get("ITS/Calib/RespSDD");
 319   if (eR) {
 320       eR->PrintId();
 321       eR->PrintMetaData();
 322       fResp=(AliITSresponseSDD*)eR->GetObject();
 323   }
 324
 325   AliCDBEntry* eC=(AliCDBEntry*)man->Get("ITS/Calib/CalibSDD");
 326   Int_t countGood3[14];
 327   Int_t countGood4[22];
 328   Int_t countGoodMod[260];
 329   if (eC) {
 330       eC->PrintId();
 331       eC->PrintMetaData();
 332       TObjArray* calsdd=(TObjArray*)eC->GetObject();
 333       for(Int_t ilad=0;ilad<14;ilad++) countGood3[ilad]=0;
 334       for(Int_t ilad=0;ilad<22;ilad++) countGood4[ilad]=0;
 335       for(Int_t imod=0;imod<260;imod++) countGoodMod[imod]=0;
 336       for(Int_t imod=0;imod<260;imod++){
 337           AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)calsdd->At(imod);
 338           if(cal->IsBad()) continue;
 339           Int_t modId=imod+AliITSgeomTGeo::GetModuleIndex(3,1,1);
 340           Int_t lay,lad,det;
 341           AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
 342           if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
 343           for(Int_t ian=0; ian<512; ian++){
 344               if(cal->IsBadChannel(ian)) continue;
 345               countGoodMod[imod]++;
 346               if(lay==3) countGood3[lad-1]++;
 347               else if(lay==4) countGood4[lad-1]++;
 348           }
 349       }
 350   }
 351
 352   for(Int_t imod=0;imod<260;imod++) fGoodAnMod->SetBinContent(imod+1,countGoodMod[imod]);
 353   fGoodAnMod->SetMinimum(0);
 354   for(Int_t ilad=0;ilad<14;ilad++) fGoodAnLadLay3->SetBinContent(ilad+1,countGood3[ilad]);
 355   fGoodAnLadLay3->SetMinimum(0);
 356   for(Int_t ilad=0;ilad<22;ilad++) fGoodAnLadLay4->SetBinContent(ilad+1,countGood4[ilad]);
 357   fGoodAnLadLay4->SetMinimum(0);
 358
 359   PostData(1, fOutput);
 360
 361 }
 362 //______________________________________________________________________________
 363 void AliAnalysisTaskSDDRP::UserExec(Option_t *)
 364 {
 365   //
 366   AliESDEvent *esd = (AliESDEvent*) (InputEvent());
 367
 368
 369   if(!esd) {
 370     printf("AliAnalysisTaskSDDRP::Exec(): bad ESD\n");
 371     return;
 372   }
 373
 374
 375   if(!ESDfriend()) {
 376     printf("AliAnalysisTaskSDDRP::Exec(): bad ESDfriend\n");
 377     return;
 378   }
 379
 380
 381   PostData(1, fOutput);
 382
 383   fHistNEvents->Fill(0);
 384   if(fOnlyCINT1BTrig){
 385     if(!esd->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL")) return;
 386     fHistNEvents->Fill(1);
 387   }
 388   const AliTrackPointArray *array = 0;
 389   Int_t ntracks = esd->GetNumberOfTracks();
 390   for (Int_t itrack=0; itrack < ntracks; itrack++) {
 391     AliESDtrack * track = esd->GetTrack(itrack);
 392     if (!track) continue;
 393
 394     Bool_t accept=kTRUE;
 395     if(fUseITSsaTracks){
 396       if(track->GetNcls(1)>0) accept=kFALSE;
 397     }else{
 398       if(track->GetNcls(1)<fMinTPCpts) accept=kFALSE;
 399     }
 400     if(track->GetNcls(0) < fMinITSpts) accept=kFALSE;
 401     Int_t trstatus=track->GetStatus();
 402     if(!(trstatus&AliESDtrack::kITSrefit)) accept=kFALSE;
 403     if(!accept) continue;
 404
 405     fHistCluInLay->Fill(-1.); // bin -1 counts accepted tracks
 406     UChar_t clumap=track->GetITSClusterMap();
 407     for(Int_t iBit=0; iBit<6; iBit++){
 408       if(clumap&(1<<iBit)) fHistCluInLay->Fill(iBit);
 409     }
 410
 411
 412     Double_t dedx[4];
 413     track->GetITSdEdxSamples(dedx);
 414     Float_t mom=track->P();
 415     Int_t iMod,status;
 416     Float_t xloc,zloc;
 417     for(Int_t iLay=2; iLay<=3; iLay++){
 418       Bool_t ok=track->GetITSModuleIndexInfo(iLay,iMod,status,xloc,zloc);
 419       if(ok){
 420         iMod+=240;
 421         fHistAllPMod->Fill(iMod);
 422         fHistAllPXloc->Fill(xloc);
 423         fHistAllPZloc->Fill(zloc);
 424         if(status==1){
 425           fHistGoodPMod->Fill(iMod);
 426           fHistGoodPXloc->Fill(xloc);
 427           fHistGoodPZloc->Fill(zloc);
 428           if(mom>fMinPfordEdx) fHistdEdxVsMod->Fill(iMod,dedx[iLay-2]);
 429           if(iLay==2) fHistdEdxL3VsP->Fill(mom,dedx[0]);
 430           else fHistdEdxL4VsP->Fill(mom,dedx[1]);
 431         }
 432         else if(status==2){
 433           fHistBadRegMod->Fill(iMod);
 434           fHistBadRegXloc->Fill(xloc);
 435           fHistBadRegZloc->Fill(zloc);
 436         }
 437         else if(status==3) fHistSkippedMod->Fill(iMod);
 438         else if(status==4) fHistOutAccMod->Fill(iMod);
 439         else if(status==5){
 440           fHistMissPMod->Fill(iMod);
 441           fHistMissPXloc->Fill(xloc);
 442           fHistMissPZloc->Fill(zloc);
 443         }
 444         else if(status==6) fHistNoRefitMod->Fill(iMod);
 445       }
 446     }
 447
 448
 449     array = track->GetTrackPointArray();
 450     if(!array) continue;
 451     for(Int_t ipt=0; ipt<array->GetNPoints(); ipt++) {
 452       AliTrackPoint point;
 453       Int_t modId;
 454       array->GetPoint(point,ipt);
 455       Int_t volId = point.GetVolumeID();
 456       Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
 457       if(layerId<3 || layerId>4) continue;
 458       modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
 459       Int_t lay,lad,det;
 460       AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
 461       if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
 462       fTrackPMod->Fill(modId);
 463       fDriftTimeTPAll->Fill(point.GetDriftTime());
 464       if(point.IsExtra()) fDriftTimeTPExtra->Fill(point.GetDriftTime());
 465       else fDriftTimeTPNoExtra->Fill(point.GetDriftTime());
 466       Float_t dtime=point.GetDriftTime()-fResp->GetTimeZero(modId);
 467       Int_t cluTyp=point.GetClusterType();
 468       Int_t clSizAn=(cluTyp>>8)&0xFF;
 469       Int_t clSizTb=cluTyp&0xFF;
 470       fCluSizAnVsTime->Fill(dtime,clSizAn);
 471       fCluSizTbVsTime->Fill(dtime,clSizTb);
 472       Int_t theBin=int(dtime/6500.*8.);
 473       if(layerId==3){
 474         fTrackPLadLay3->Fill(lad-1);
 475         if(dedx[0]>0. && track->P()>fMinPfordEdx) fSignalTime[theBin]->Fill(dedx[0]);
 476       }
 477       if(layerId==4){
 478         fTrackPLadLay4->Fill(lad-1);
 479         if(dedx[1]>0.&& track->P()>fMinPfordEdx) fSignalTime[theBin]->Fill(dedx[1]);
 480       }
 481     }
 482   }
 483
 484   AliESDInputHandlerRP *hand = dynamic_cast<AliESDInputHandlerRP*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 485   TTree* tR = 0;
 486   if (hand) tR = hand->GetTreeR("ITS");
 487   if (tR){
 488     TClonesArray *ITSrec= new TClonesArray("AliITSRecPoint");
 489     TBranch *branch =tR->GetBranch("ITSRecPoints");
 490     branch->SetAddress(&ITSrec);
 491     for (Int_t modId=240; modId<500; modId++){
 492       Int_t lay,lad,det;
 493       AliITSgeomTGeo::GetModuleId(modId,lay,lad,det);
 494       if(fExcludeBadMod && !CheckModule(lay,lad,det)) continue;
 495       branch->GetEvent(modId);
 496       Int_t nrecp = ITSrec->GetEntries();
 497       fRecPMod->Fill(modId,nrecp);
 498       if(lay==3) fRecPLadLay3->Fill(lad-1,nrecp);
 499       if(lay==4) fRecPLadLay4->Fill(lad-1,nrecp);
 500       for(Int_t irec=0;irec<nrecp;irec++) {
 501         AliITSRecPoint *recp = (AliITSRecPoint*)ITSrec->At(irec);
 502         fDriftTimeRP->Fill(recp->GetDriftTime());
 503       }
 504     }
 505     ITSrec->Delete();
 506     delete ITSrec;
 507   }
 508   PostData(1,fOutput);
 509
 510 }
 511 //______________________________________________________________________________
 512 Bool_t AliAnalysisTaskSDDRP::CheckModule(Int_t lay, Int_t lad, Int_t det) const{
 513   //
 514   if(lay==4){
 515     if(lad==3 && det==5) return kFALSE; // 1500 V
 516     if(lad==3 && det==6) return kFALSE; // 0 V
 517     if(lad==3 && det==7) return kFALSE; // 1500 V
 518     if(lad==4 && det==1) return kFALSE; // 0 V
 519     if(lad==4 && det==2) return kFALSE; // 1500 V
 520     if(lad==7 && det==5) return kFALSE; // 0 MV
 521     if(lad==9 && det==3) return kFALSE; // 1500 V
 522     if(lad==9 && det==4) return kFALSE; // 0 V
 523     if(lad==9 && det==5) return kFALSE; // 1500 V
 524     if(lad==11 && det==6) return kFALSE; // 1500 V
 525     if(lad==11 && det==7) return kFALSE; // 0 V
 526     if(lad==11 && det==8) return kFALSE; // 1500 V
 527     if(lad==18 && det==5) return kFALSE; // 1500 V
 528     if(lad==18 && det==6) return kFALSE; // 0 V
 529     if(lad==18 && det==7) return kFALSE; // 1500 V
 530     if(lad==22 && det==1) return kFALSE; // 0 V
 531     if(lad==22 && det==2) return kFALSE; // 1500 V
 532   }
 533   if(lay==3){
 534     if(lad==4 && det==4) return kFALSE; // 1500 V
 535     if(lad==3) return kFALSE;  // swapped in geometry
 536   }
 537   return kTRUE;
 538 }
 539
 540 //______________________________________________________________________________
 541 void AliAnalysisTaskSDDRP::Terminate(Option_t */*option*/)
 542 {
 543   // Terminate analysis
 544   fOutput = dynamic_cast<TList*> (GetOutputData(1));
 545   if (!fOutput) {
 546     printf("ERROR: fOutput not available\n");
 547     return;
 548   }
 549   fHistNEvents= dynamic_cast<TH1F*>(fOutput->FindObject("hNEvents"));
 550   fHistCluInLay= dynamic_cast<TH1F*>(fOutput->FindObject("hCluInLay"));
 551
 552   fHistAllPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPMod"));
 553   fHistGoodPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPMod"));
 554   fHistBadRegMod= dynamic_cast<TH1F*>(fOutput->FindObject("hBadRegMod"));
 555   fHistMissPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPMod"));
 556   fHistSkippedMod= dynamic_cast<TH1F*>(fOutput->FindObject("hSkippedMod"));
 557   fHistOutAccMod= dynamic_cast<TH1F*>(fOutput->FindObject("hOutAccMod"));
 558   fHistNoRefitMod= dynamic_cast<TH1F*>(fOutput->FindObject("hNoRefitMod"));
 559
 560   fHistAllPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPxloc"));
 561   fHistGoodPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPxloc"));
 562   fHistBadRegXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hBadRegxloc"));
 563   fHistMissPXloc= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPxloc"));
 564   fHistAllPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hAllPzloc"));
 565   fHistGoodPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hGoodPzloc"));
 566   fHistBadRegZloc= dynamic_cast<TH1F*>(fOutput->FindObject("fHistBadRegZloc"));
 567   fHistMissPZloc= dynamic_cast<TH1F*>(fOutput->FindObject("hMissPzloc"));
 568
 569   fHistdEdxL3VsP= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxL3VsP"));
 570   fHistdEdxL4VsP= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxL4VsP"));
 571   fHistdEdxVsMod= dynamic_cast<TH2F*>(fOutput->FindObject("hdEdxVsMod"));
 572
 573   fRecPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hRPMod"));
 574   fTrackPMod= dynamic_cast<TH1F*>(fOutput->FindObject("hTPMod"));
 575   fGoodAnMod= dynamic_cast<TH1F*>(fOutput->FindObject("hGAMod"));
 576
 577   fRecPLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hRPLad3"));
 578   fRecPLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hRPLad4"));
 579   fTrackPLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hTPLad3"));
 580   fTrackPLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hTPLad4"));
 581   fGoodAnLadLay3= dynamic_cast<TH1F*>(fOutput->FindObject("hGALad3"));
 582   fGoodAnLadLay4= dynamic_cast<TH1F*>(fOutput->FindObject("hGALad4"));
 583
 584   fDriftTimeRP= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimRP"));
 585   fDriftTimeTPAll= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPAll"));
 586   fDriftTimeTPNoExtra= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPNoExtra"));
 587   fDriftTimeTPExtra= dynamic_cast<TH1F*>(fOutput->FindObject("hDrTimTPExtra"));
 588
 589   for(Int_t it=0; it<8; it++){
 590     fSignalTime[it]= dynamic_cast<TH1F*>(fOutput->FindObject(Form("hSigTimeInt%d",it)));
 591   }
 592   fCluSizAnVsTime= dynamic_cast<TH2F*>(fOutput->FindObject("hCluSizAn"));
 593   fCluSizTbVsTime= dynamic_cast<TH2F*>(fOutput->FindObject("hCluSizTb"));
 594
 595   return;
 596 }
 597
 598
 599
 600
 601