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 && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 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 // == 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 //______________________________________________________________________________
 325 void 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 //______________________________________________________________________________
 530 Bool_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 //______________________________________________________________________________
 559 void 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