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