PWGPP/TRD/AliTRDinfoGen.cxx

   1 /**************************************************************************\r
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   3 *                                                                        *\r
   4 * Author: The ALICE Off-line Project.                                    *\r
   5 * Contributors are mentioned in the code where appropriate.              *\r
   6 *                                                                        *\r
   7 * Permission to use, copy, modify and distribute this software and its   *\r
   8 * documentation strictly for non-commercial purposes is hereby granted   *\r
   9 * without fee, provided that the above copyright notice appears in all   *\r
  10 * copies and that both the copyright notice and this permission notice   *\r
  11 * appear in the supporting documentation. The authors make no claims     *\r
  12 * about the suitability of this software for any purpose. It is          *\r
  13 * provided "as is" without express or implied warranty.                  *\r
  14 **************************************************************************/\r
  15 \r
  16 /* $Id: AliTRDinfoGen.cxx 27496 2008-07-22 08:35:45Z cblume $ */\r
  17 \r
  18 ////////////////////////////////////////////////////////////////////////////\r
  19 //\r
  20 //  Tender wagon for TRD performance/calibration train\r
  21 //\r
  22 // In this wagon the information from\r
  23 //   - ESD\r
  24 //   - Friends [if available]\r
  25 //   - MC [if available]\r
  26 // are grouped into AliTRDtrackInfo objects and fed to worker tasks\r
  27 //\r
  28 //  Authors:\r
  29 //    Markus Fasel <M.Fasel@gsi.de>\r
  30 //    Alexandru Bercuci <A.Bercuci@gsi.de>\r
  31 //\r
  32 ////////////////////////////////////////////////////////////////////////////\r
  33 \r
  34 #include <TClonesArray.h>\r
  35 #include <TObjArray.h>\r
  36 #include <TObject.h>\r
  37 #include <TString.h>\r
  38 #include <TVectorT.h>\r
  39 #include <TH1.h>\r
  40 #include <TH2.h>\r
  41 #include <TCanvas.h>\r
  42 #include <TPad.h>\r
  43 #include <TFile.h>\r
  44 #include <TTree.h>\r
  45 #include <TROOT.h>\r
  46 #include <TChain.h>\r
  47 #include <TParticle.h>\r
  48 \r
  49 #include "AliLog.h"\r
  50 #include "AliAnalysisManager.h"\r
  51 #include "AliGeomManager.h"\r
  52 #include "AliCDBManager.h"\r
  53 #include "AliCDBStorage.h"\r
  54 #include "AliCDBEntry.h"\r
  55 #include "AliCDBPath.h"\r
  56 #include "AliESDEvent.h"\r
  57 #include "AliMCEvent.h"\r
  58 #include "AliESDInputHandler.h"\r
  59 #include "AliESDInputHandlerRP.h"\r
  60 #include "AliMCEventHandler.h"\r
  61 \r
  62 #include "AliESDfriend.h"\r
  63 #include "AliESDfriendTrack.h"\r
  64 #include "AliESDHeader.h"\r
  65 #include "AliESDRun.h"\r
  66 #include "AliESDtrack.h"\r
  67 #include "AliESDv0.h"\r
  68 #include "AliESDtrackCuts.h"\r
  69 #include "AliESDv0KineCuts.h"\r
  70 #include "AliMCParticle.h"\r
  71 #include "AliMultiplicity.h"\r
  72 #include "AliCentrality.h"\r
  73 #include "AliPID.h"\r
  74 #include "AliStack.h"\r
  75 #include "AliTrackReference.h"\r
  76 #include "TTreeStream.h"\r
  77 \r
  78 #include <cstdio>\r
  79 #include <climits>\r
  80 #include <cstring>\r
  81 #include <iostream>\r
  82 #include <memory>\r
  83 \r
  84 #include "AliTRDReconstructor.h"\r
  85 #include "AliTRDrecoParam.h"\r
  86 #include "AliTRDcalibDB.h"\r
  87 #include "AliTRDtrackerV1.h"\r
  88 #include "AliTRDpadPlane.h"\r
  89 #include "AliTRDgeometry.h"\r
  90 #include "AliTRDtrackV1.h"\r
  91 #include "AliTRDseedV1.h"\r
  92 #include "AliTRDcluster.h"\r
  93 #include "AliTRDinfoGen.h"\r
  94 #include "AliTRDpwgppHelper.h"\r
  95 #include "info/AliTRDtrackInfo.h"\r
  96 #include "info/AliTRDeventInfo.h"\r
  97 #include "info/AliTRDv0Info.h"\r
  98 #include "info/AliTRDchmbInfo.h"\r
  99 #include "info/AliTRDtriggerInfo.h"\r
 100 #include "info/AliTRDeventCuts.h"\r
 101 \r
 102 ClassImp(AliTRDinfoGen)\r
 103 \r
 104 const Float_t AliTRDinfoGen::fgkITS = 100.; // to be checked\r
 105 const Float_t AliTRDinfoGen::fgkTPC = 290.;\r
 106 const Float_t AliTRDinfoGen::fgkTRD = 365.;\r
 107 \r
 108 const Float_t AliTRDinfoGen::fgkTrkDCAxy  = 3.;\r
 109 const Float_t AliTRDinfoGen::fgkTrkDCAz   = 10.;\r
 110 const Int_t   AliTRDinfoGen::fgkNclTPC    = 70;\r
 111 const Float_t AliTRDinfoGen::fgkPt        = 0.2;\r
 112 const Float_t AliTRDinfoGen::fgkEta       = 0.9;\r
 113 AliTRDReconstructor* AliTRDinfoGen::fgReconstructor(NULL);\r
 114 AliTRDgeometry* AliTRDinfoGen::fgGeo(NULL);\r
 115 //____________________________________________________________________\r
 116 AliTRDinfoGen::AliTRDinfoGen()\r
 117   :AliAnalysisTaskSE()\r
 118   ,fESDev(NULL)\r
 119   ,fMCev(NULL)\r
 120   ,fEventCut(NULL)\r
 121   ,fTrackCut(NULL)\r
 122   ,fV0Identifier(NULL)\r
 123   ,fV0Cut(NULL)\r
 124   ,fOCDB("local://$ALICE_ROOT/OCDB")\r
 125   ,fTrackInfo(NULL)\r
 126   ,fEventInfo(NULL)\r
 127   ,fV0Info(NULL)\r
 128   ,fTracksBarrel(NULL)\r
 129   ,fTracksSA(NULL)\r
 130   ,fTracksKink(NULL)\r
 131   ,fV0List(NULL)\r
 132   ,fClusters(NULL)\r
 133   ,fContainer(NULL)\r
 134   ,fRecos(NULL)\r
 135   ,fDebugStream(NULL)\r
 136 {\r
 137   //\r
 138   // Default constructor\r
 139   //\r
 140   SetNameTitle("TRDinfoGen", "MC-REC TRD-track list generator");\r
 141 }\r
 142 \r
 143 //____________________________________________________________________\r
 144 AliTRDinfoGen::AliTRDinfoGen(char* name)\r
 145   :AliAnalysisTaskSE(name)\r
 146   ,fESDev(NULL)\r
 147   ,fMCev(NULL)\r
 148   ,fEventCut(NULL)\r
 149   ,fTrackCut(NULL)\r
 150   ,fV0Identifier(NULL)\r
 151   ,fV0Cut(NULL)\r
 152   ,fOCDB("local://$ALICE_ROOT/OCDB")\r
 153   ,fTrackInfo(NULL)\r
 154   ,fEventInfo(NULL)\r
 155   ,fV0Info(NULL)\r
 156   ,fTracksBarrel(NULL)\r
 157   ,fTracksSA(NULL)\r
 158   ,fTracksKink(NULL)\r
 159   ,fV0List(NULL)\r
 160   ,fClusters(NULL)\r
 161   ,fContainer(NULL)\r
 162   ,fRecos(NULL)\r
 163   ,fDebugStream(NULL)\r
 164 {\r
 165   //\r
 166   // Default constructor\r
 167   //\r
 168   SetTitle("MC-REC TRD-track list generator");\r
 169   DefineOutput(AliTRDpwgppHelper::kTracksBarrel, TObjArray::Class());\r
 170   DefineOutput(AliTRDpwgppHelper::kTracksSA,     TObjArray::Class());\r
 171   DefineOutput(AliTRDpwgppHelper::kTracksKink,   TObjArray::Class());\r
 172   DefineOutput(AliTRDpwgppHelper::kEventInfo,    AliTRDeventInfo::Class());\r
 173   DefineOutput(AliTRDpwgppHelper::kV0List,       TObjArray::Class());\r
 174   DefineOutput(AliTRDpwgppHelper::kClusters,     TObjArray::Class());\r
 175   DefineOutput(AliTRDpwgppHelper::kMonitor,      TObjArray::Class()); // histogram list\r
 176 }\r
 177 \r
 178 //____________________________________________________________________\r
 179 AliTRDinfoGen::~AliTRDinfoGen()\r
 180 {\r
 181 // Destructor\r
 182   if(fgGeo) delete fgGeo;\r
 183   if(fgReconstructor) delete fgReconstructor;\r
 184   if(fDebugStream) delete fDebugStream;\r
 185   if(fV0Cut) delete fV0Cut;\r
 186   if(fV0Identifier) delete fV0Identifier;\r
 187   if(fTrackCut) delete fTrackCut;\r
 188   if(fEventCut) delete fEventCut;\r
 189   if(fTrackInfo) delete fTrackInfo; fTrackInfo = NULL;\r
 190   if(fEventInfo) delete fEventInfo; fEventInfo = NULL;\r
 191   if(fV0Info) delete fV0Info; fV0Info = NULL;\r
 192   if(fTracksBarrel){\r
 193     fTracksBarrel->Delete(); delete fTracksBarrel;\r
 194     fTracksBarrel = NULL;\r
 195   }\r
 196   if(fTracksSA){\r
 197     fTracksSA->Delete(); delete fTracksSA;\r
 198     fTracksSA = NULL;\r
 199   }\r
 200   if(fTracksKink){ \r
 201     fTracksKink->Delete(); delete fTracksKink;\r
 202     fTracksKink = NULL;\r
 203   }\r
 204   if(fV0List){ \r
 205     fV0List->Delete(); \r
 206     delete fV0List;\r
 207     fV0List = NULL;\r
 208   }\r
 209   if(fClusters){\r
 210     fClusters->Delete(); delete fClusters;\r
 211     fClusters = NULL;\r
 212   }\r
 213   if(fContainer && !(AliAnalysisManager::GetAnalysisManager() && AliAnalysisManager::GetAnalysisManager()->IsProofMode())){\r
 214     fContainer->Delete(); \r
 215     delete fContainer;\r
 216     fContainer = NULL;\r
 217   }\r
 218 }\r
 219 \r
 220 //____________________________________________________________________\r
 221 Bool_t AliTRDinfoGen::GetRefFigure(Int_t)\r
 222 {\r
 223 // General graphs for PWGPP/TRD train\r
 224   if(!gPad){\r
 225     AliWarning("Please provide a canvas to draw results.");\r
 226     return kFALSE;\r
 227   }\r
 228   fContainer->At(kStatTrk)->Draw("bar");\r
 229   return kTRUE;\r
 230 }\r
 231 \r
 232 //____________________________________________________________________\r
 233 void AliTRDinfoGen::UserCreateOutputObjects()\r
 234 {       \r
 235   //\r
 236   // Create Output Containers (TObjectArray containing 1D histograms)\r
 237   //\r
 238  \r
 239   fTrackInfo = new AliTRDtrackInfo();\r
 240   fEventInfo = new AliTRDeventInfo();\r
 241   fV0Info    = new AliTRDv0Info();\r
 242   fTracksBarrel = new TObjArray(200); fTracksBarrel->SetOwner(kTRUE);\r
 243   fTracksSA = new TObjArray(20); fTracksSA->SetOwner(kTRUE);\r
 244   fTracksKink = new TObjArray(20); fTracksKink->SetOwner(kTRUE);\r
 245   fV0List = new TObjArray(10); fV0List->SetOwner(kTRUE);\r
 246   fClusters = new TObjArray(AliTRDgeometry::kNdet); fClusters->SetOwner(kTRUE);\r
 247 \r
 248   // define general monitor\r
 249   fContainer = new TObjArray(kNclasses); fContainer->SetOwner(kTRUE);\r
 250   TH1 *h=new TH1I("hStat", "Run statistics;Observable;Entries", Int_t(kNObjects), -0.5, Float_t(kNObjects)-0.5);\r
 251   TAxis *ax(h->GetXaxis());\r
 252   ax->SetBinLabel(Int_t(kTracksESD) + 1, "ESD");\r
 253   ax->SetBinLabel(Int_t(kTracksMC) + 1, "MC");\r
 254   ax->SetBinLabel(Int_t(kV0) + 1, "V0");\r
 255   ax->SetBinLabel(Int_t(kTPC) + 1, "TPC");\r
 256   ax->SetBinLabel(Int_t(kITS) + 1, "ITS");\r
 257   ax->SetBinLabel(Int_t(kTRDin) + 1, "TRDin");\r
 258   ax->SetBinLabel(Int_t(kTRDout) + 1, "TRDout");\r
 259   ax->SetBinLabel(Int_t(kBarrel) + 1, "Barrel");\r
 260   ax->SetBinLabel(Int_t(kBarrelMC) + 1, "BarrelMC");\r
 261   ax->SetBinLabel(Int_t(kSA) + 1, "SA");\r
 262   ax->SetBinLabel(Int_t(kSAMC) + 1, "SAMC");\r
 263   ax->SetBinLabel(Int_t(kKink) + 1, "Kink");\r
 264   ax->SetBinLabel(Int_t(kKinkMC) + 1, "KinkMC");\r
 265   ax->SetBinLabel(Int_t(kBarrelFriend) + 1, "BFriend");\r
 266   ax->SetBinLabel(Int_t(kSAFriend) + 1, "SFriend");\r
 267   fContainer->AddAt(h, kStatTrk);\r
 268   h=new TH1I("hEv", "Run statistics;Event Class;Entries", 4, -0.5, 3.5);\r
 269   ax = h->GetXaxis();\r
 270   ax->SetBinLabel(1, "Low");\r
 271   ax->SetBinLabel(2, "High");\r
 272   ax->SetBinLabel(3, "Cosmic");\r
 273   ax->SetBinLabel(4, "Calib");\r
 274   fContainer->AddAt(h, kEvType);\r
 275   TH2I* h2=new TH2I("hBCtrack", "Track Statistics;Fill Bunch;TOF BC;Entries", 3500, -0.5, 3499.5, 31, -10.5, 20.5);\r
 276   fContainer->AddAt(h2, kBC);\r
 277   fContainer->AddAt(new AliTRDtriggerInfo(), kTrigger);\r
 278   TObjArray *chmb = new TObjArray(AliTRDgeometry::kNdet);\r
 279   chmb->SetName("Chambers Status"); chmb->SetOwner(kTRUE);\r
 280   fContainer->AddAt(chmb, kChmb);\r
 281 \r
 282   PostData(AliTRDpwgppHelper::kTracksBarrel, fTracksBarrel);\r
 283   PostData(AliTRDpwgppHelper::kTracksSA,     fTracksSA);\r
 284   PostData(AliTRDpwgppHelper::kTracksKink,   fTracksKink);\r
 285   PostData(AliTRDpwgppHelper::kEventInfo,    fEventInfo);\r
 286   PostData(AliTRDpwgppHelper::kV0List,       fV0List);\r
 287   PostData(AliTRDpwgppHelper::kClusters,     fClusters);\r
 288   PostData(AliTRDpwgppHelper::kMonitor,      fContainer);\r
 289 }\r
 290 \r
 291 //____________________________________________________________________\r
 292 Bool_t AliTRDinfoGen::Load(const Char_t *file, const Char_t *dir, const Char_t *name)\r
 293 {\r
 294 // Load data from performance file\r
 295 \r
 296   if(!TFile::Open(file)){\r
 297     AliWarning(Form("Couldn't open file %s.", file));\r
 298     return kFALSE;\r
 299   }\r
 300   if(dir){\r
 301     if(!gFile->cd(dir)){\r
 302       AliWarning(Form("Couldn't cd to %s in %s.", dir, file));\r
 303       return kFALSE;\r
 304     }\r
 305   }\r
 306   TObjArray *o(NULL);\r
 307   const Char_t *tn=(name ? name : GetName());\r
 308   if(!(o = (TObjArray*)gDirectory->Get(tn))){\r
 309     AliWarning(Form("Missing histogram container %s.", tn));\r
 310     return kFALSE;\r
 311   }\r
 312   fContainer = (TObjArray*)o->Clone(GetName());\r
 313   gFile->Close();\r
 314   return kTRUE;\r
 315 }\r
 316 \r
 317 //____________________________________________________________________\r
 318 void AliTRDinfoGen::UserExec(Option_t *){\r
 319   //\r
 320   // Run the Analysis\r
 321   //\r
 322 \r
 323   fTracksBarrel->Delete();\r
 324   fTracksSA->Delete();\r
 325   fTracksKink->Delete();\r
 326   fV0List->Delete();\r
 327   fClusters->Delete();\r
 328   fEventInfo->Delete("");\r
 329 \r
 330   fESDev = dynamic_cast<AliESDEvent*>(InputEvent());\r
 331   if(!fESDev){\r
 332     AliError("Failed retrieving ESD event");\r
 333     return;\r
 334   }\r
 335   // WARNING\r
 336   // This part may conflict with other detectors !!\r
 337   if(!IsInitOCDB()){\r
 338     AliCDBEntry* obj(NULL);\r
 339     AliCDBManager* ocdb = AliCDBManager::Instance();\r
 340     if(ocdb->IsDefaultStorageSet()){\r
 341       AliInfo("OCDB :: initialized externally.");\r
 342     } else {\r
 343       AliInfo("OCDB :: initializing locally ...");\r
 344       // prepare OCDB access\r
 345       ocdb->SetDefaultStorage(fOCDB.Data());\r
 346       //ocdb->SetSpecificStorage("TRD/Align/Data", "local:///home/niham/abercuci/local");\r
 347       ocdb->SetRun(fESDev->GetRunNumber());\r
 348       // create geo manager\r
 349       if(!(obj = ocdb->Get(AliCDBPath("GRP", "Geometry", "Data")))){\r
 350         AliError("GEOMETRY failed initialization.");\r
 351       } else {\r
 352         AliGeomManager::SetGeometry((TGeoManager*)obj->GetObject());\r
 353         AliGeomManager::GetNalignable("TRD");\r
 354         AliGeomManager::GetNalignable("TPC");\r
 355         AliGeomManager::GetNalignable("ITS");\r
 356         AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD");\r
 357       }\r
 358       //init magnetic field\r
 359       if(!TGeoGlobalMagField::Instance()->IsLocked() &&\r
 360         !fESDev->InitMagneticField()){\r
 361         AliError("MAGNETIC FIELD failed initialization.");\r
 362       }\r
 363       // set no of time bins\r
 364       AliTRDtrackerV1::SetNTimeBins(AliTRDcalibDB::Instance()->GetNumberOfTimeBinsDCS());\r
 365     }\r
 366     AliInfo(Form("OCDB :  Loc[%s] Run[%d] TB[%d]", ocdb->GetDefaultStorage()->GetURI().Data(), ocdb->GetRun(), AliTRDtrackerV1::GetNTimeBins()));\r
 367 \r
 368     // load misalignment\r
 369     fgGeo = new AliTRDgeometry;\r
 370     fgGeo->CreateClusterMatrixArray();\r
 371     MakeChambers();\r
 372     // load reco param list from OCDB\r
 373     AliInfo("Initializing TRD reco params ...");\r
 374     fgReconstructor = new AliTRDReconstructor();\r
 375     if(!(obj = ocdb->Get(AliCDBPath("TRD", "Calib", "RecoParam")))){\r
 376       AliError("RECO PARAM failed initialization.");\r
 377     } else {\r
 378       obj->PrintMetaData();\r
 379       fRecos = (TObjArray*)obj->GetObject();\r
 380     }\r
 381     SetInitOCDB();\r
 382   }\r
 383 \r
 384   AliDebug(2, "+++++++++++++++++++++++++++++++++++++++");\r
 385   AliDebug(2, Form("Analyse Ev[%d]", fESDev->GetEventNumberInFile()));\r
 386 \r
 387   // set reco param valid for this event\r
 388   TH1 *h = (TH1I*)fContainer->At(kEvType);\r
 389   if(!fRecos){\r
 390     fgReconstructor->SetRecoParam(AliTRDrecoParam::GetLowFluxParam());\r
 391     h->Fill(0);\r
 392   } else {\r
 393     for(Int_t ireco(0); ireco<fRecos->GetEntriesFast(); ireco++){\r
 394       AliTRDrecoParam *reco((AliTRDrecoParam*)fRecos->At(ireco));\r
 395       Int_t es(reco->GetEventSpecie());\r
 396       if(!(es&fESDev->GetEventSpecie())) continue;\r
 397       fgReconstructor->SetRecoParam(reco);\r
 398       if(AliLog::GetDebugLevel("PWGPP/TRD", "AliTRDinfoGen")>5) reco->Dump();\r
 399       TString s;\r
 400       if(es&AliRecoParam::kLowMult){ s="LowMult"; h->Fill(0);}\r
 401       else if(es&AliRecoParam::kHighMult){ s="HighMult"; h->Fill(1);}\r
 402       else if(es&AliRecoParam::kCosmic){ s="Cosmic"; h->Fill(2);}\r
 403       else if(es&AliRecoParam::kCalib){ s="Calib"; h->Fill(3);}\r
 404       else s="Unknown";\r
 405       AliDebug(2, Form("  Using reco param \"%s\" for event %d.", s.Data(), fESDev->GetEventNumberInFile()));\r
 406       break;\r
 407     }\r
 408   }\r
 409 \r
 410   // link MC if available\r
 411   fMCev = MCEvent();\r
 412   \r
 413   // trigger monitor\r
 414   AliTRDtriggerInfo *ti = (AliTRDtriggerInfo*)fContainer->At(kTrigger);\r
 415   TObjArray *evTriggers = fESDev->GetFiredTriggerClasses().Tokenize(" ");\r
 416   //printf("Ev[%03d] Triggers[%s]\n", fESDev->GetEventNumberInFile(), fESDev->GetFiredTriggerClasses().Data());\r
 417   for(Int_t iet(evTriggers->GetEntriesFast()); iet--;) ti->Add((*evTriggers)[iet]->GetName());\r
 418   evTriggers->Delete(); delete evTriggers;\r
 419 \r
 420   // event selection based on vertex cuts and trigger\r
 421   if(UseLocalEvSelection() && !fEventCut->IsSelected(fESDev, IsCollision())){\r
 422     AliDebug(2, "Event failed selection on vertex and trigger");\r
 423     return;\r
 424   }\r
 425 \r
 426   if(!fESDfriend){\r
 427     AliError("Failed retrieving ESD friend event");\r
 428     return;\r
 429   }\r
 430   if(HasMCdata() && !fMCev){\r
 431     AliError("Failed retrieving MC event");\r
 432     return;\r
 433   }\r
 434 \r
 435   new(fEventInfo)AliTRDeventInfo(fESDev->GetHeader(), const_cast<AliESDRun *>(fESDev->GetESDRun()));\r
 436   // Determine centrality\r
 437   // Author: Ionut Arsene <I.C.Arsene@gsi.de>\r
 438   TString beamtype = fESDev->GetESDRun()->GetBeamType();\r
 439   if(beamtype.Contains("Pb-Pb") || beamtype.Contains("A-A")){\r
 440     const AliMultiplicity *mult = fESDev->GetMultiplicity();\r
 441     fEventInfo->SetMultiplicity(mult?mult->GetNumberOfTracklets():0);\r
 442     const AliCentrality *cent = fESDev->GetCentrality();\r
 443     // centrality for different options V0 = "V0M", ITS = "TKL" etc\r
 444     fEventInfo->SetCentrality(cent?cent->GetCentralityPercentile("TKL"):-1.);\r
 445     AliDebug(2, Form("  Beam Type[%s] Mult[%d/%4d] Cent[%d/%5.2f]",\r
 446         beamtype.Data(),\r
 447         fEventInfo->GetMultiplicity(), mult?mult->GetNumberOfTracklets():0,\r
 448         fEventInfo->GetCentrality(), cent?cent->GetCentralityPercentile("TKL"):-1.));\r
 449   } else {\r
 450     fEventInfo->SetMultiplicity(0);\r
 451     fEventInfo->SetCentrality(-1.);\r
 452     AliDebug(2, Form("  Beam Type[%s]", beamtype.Data()));\r
 453   }\r
 454   UShort_t evBC(fESDev->GetBunchCrossNumber());\r
 455 \r
 456   // electron identifier from conversions\r
 457   if(!fV0Identifier) fV0Identifier = new AliESDv0KineCuts();\r
 458   fV0Identifier->SetEvent(fESDev);\r
 459 \r
 460   Bool_t *trackMap(NULL);\r
 461   AliStack * mStack(NULL);\r
 462   Int_t nTracksMC = HasMCdata() ? fMCev->GetNumberOfTracks() : 0, nTracksESD = fESDev->GetNumberOfTracks();\r
 463   if(HasMCdata()){\r
 464     mStack = fMCev->Stack();\r
 465     if(!mStack){\r
 466       AliError("Failed retrieving MC Stack");\r
 467       return;\r
 468     }\r
 469     trackMap = new Bool_t[nTracksMC];\r
 470     memset(trackMap, 0, sizeof(Bool_t) * nTracksMC);\r
 471   }\r
 472   \r
 473   Double32_t dedx[100]; Int_t nSlices(0);\r
 474   Int_t nTRDout(0), nTRDin(0), nTPC(0), nITS(0)\r
 475 //        ,nclsTrklt\r
 476        ,nBarrel(0), nSA(0), nKink(0)\r
 477        ,nBarrelFriend(0), nSAFriend(0)\r
 478        ,nBarrelMC(0), nSAMC(0), nKinkMC(0);\r
 479   AliESDtrack *esdTrack = NULL;\r
 480   AliESDfriendTrack *esdFriendTrack = NULL;\r
 481   TObject *calObject = NULL;\r
 482   AliTRDtrackV1 *track = NULL;\r
 483   AliTRDseedV1 *tracklet = NULL;\r
 484   AliTRDcluster *cl = NULL;\r
 485 \r
 486 \r
 487   // LOOP 0 - over ESD v0s\r
 488   Float_t bField(fESDev->GetMagneticField());\r
 489   AliESDv0 *v0(NULL);\r
 490   Int_t v0pid[AliPID::kSPECIES];\r
 491   for(Int_t iv0(0); iv0<fESDev->GetNumberOfV0s(); iv0++){\r
 492     if(!(v0 = fESDev->GetV0(iv0)) && !v0->GetOnFlyStatus()) continue; // Take only V0s from the On-the-fly v0 finder\r
 493     // register v0\r
 494     if(fV0Cut) new(fV0Info) AliTRDv0Info(*fV0Cut);\r
 495     else new(fV0Info) AliTRDv0Info();\r
 496     fV0Info->SetMagField(bField);\r
 497     fV0Info->SetV0tracks(fESDev->GetTrack(v0->GetPindex()), fESDev->GetTrack(v0->GetNindex()));\r
 498     fV0Info->SetV0Info(v0);\r
 499     // tag conversion electrons\r
 500     Int_t pdgV0, pdgP, pdgN;\r
 501     if(fV0Identifier->ProcessV0(v0, pdgV0, pdgP, pdgN)) {\r
 502       switch(pdgV0){\r
 503       case kGamma: fV0Info->SetDecay(AliTRDv0Info::kGamma); break;\r
 504       case kK0Short: fV0Info->SetDecay(AliTRDv0Info::kK0s); break;\r
 505       case kLambda0: fV0Info->SetDecay(AliTRDv0Info::kLambda); break;\r
 506       case kLambda0Bar: fV0Info->SetDecay(AliTRDv0Info::kAntiLambda); break;\r
 507       default: AliDebug(1, Form("V0[%+4d] -> +[%+4d] -[%+4d]. Decay not mapped.", pdgV0, pdgP, pdgN));\r
 508       }\r
 509     }\r
 510     fV0List->Add(new AliTRDv0Info(*fV0Info));//  kFOUND=kFALSE;\r
 511   }\r
 512 \r
 513 \r
 514   // LOOP 1 - over ESD tracks\r
 515   AliTRDv0Info *v0info=NULL;\r
 516   for(Int_t itrk = 0; itrk < nTracksESD; itrk++){\r
 517     new(fTrackInfo) AliTRDtrackInfo();\r
 518     esdTrack = fESDev->GetTrack(itrk);\r
 519     AliDebug(3, Form("\n%3d ITS[%d] TPC[%d] TRD[%d] TOF-BC[%d]\n", itrk, esdTrack->GetNcls(0), esdTrack->GetNcls(1), esdTrack->GetNcls(2), esdTrack->GetTOFBunchCrossing()));\r
 520     if(esdTrack->GetStatus()&AliESDtrack::kITSout) nITS++;\r
 521     if(esdTrack->GetStatus()&AliESDtrack::kTPCout) nTPC++;\r
 522     if(esdTrack->GetStatus()&AliESDtrack::kTRDout) nTRDout++;\r
 523     if(esdTrack->GetStatus()&AliESDtrack::kTRDin) nTRDin++;\r
 524 //     printf("  %3d ITS[%c] TPC[%c] TRDin[%c] TRDout[%c] TRDStop[%c]\n", itrk,\r
 525 //       (esdTrack->GetStatus()&AliESDtrack::kITSout)?'y':'n',\r
 526 //       (esdTrack->GetStatus()&AliESDtrack::kTPCout)?'y':'n',\r
 527 //       (esdTrack->GetStatus()&AliESDtrack::kTRDin)?'y':'n',\r
 528 //       (esdTrack->GetStatus()&AliESDtrack::kTRDout)?'y':'n',\r
 529 //       (esdTrack->GetStatus()&AliESDtrack::kTRDStop)?'y':'n');\r
 530     // look at external track param\r
 531     const AliExternalTrackParam *op = esdTrack->GetOuterParam();\r
 532     Double_t xyz[3];\r
 533     if(op){\r
 534       op->GetXYZ(xyz);\r
 535       op->Global2LocalPosition(xyz, op->GetAlpha());\r
 536       AliDebug(3, Form("op @ X[%7.3f]\n", xyz[0]));\r
 537     }\r
 538 \r
 539     // read MC info\r
 540     Int_t fPdg = -1;\r
 541     Int_t label = -1; UInt_t alab=UINT_MAX;\r
 542     Int_t nRefs = 0;\r
 543     if(HasMCdata()){\r
 544       label = esdTrack->GetLabel(); \r
 545       alab = TMath::Abs(label);\r
 546       // register the track\r
 547       if(alab < UInt_t(nTracksMC)){ \r
 548         trackMap[alab] = kTRUE; \r
 549       } else { \r
 550         AliError(Form("MC label[%d] outside scope for Ev[%d] Trk[%d].", label, (Int_t)AliAnalysisManager::GetAnalysisManager()->GetCurrentEntry(), itrk));\r
 551         continue; \r
 552       }\r
 553       AliMCParticle *mcParticle = NULL; \r
 554       if(!(mcParticle = (AliMCParticle*) fMCev->GetTrack(alab))){\r
 555         AliError(Form("MC particle label[%d] missing for Ev[%d] Trk[%d].", label, (Int_t)AliAnalysisManager::GetAnalysisManager()->GetCurrentEntry(), itrk));\r
 556         continue;\r
 557       }\r
 558       fPdg = mcParticle->Particle()->GetPdgCode();\r
 559       nRefs = mcParticle->GetNumberOfTrackReferences();\r
 560       Int_t iref = 0; AliTrackReference *ref = NULL; \r
 561       while(iref<nRefs){\r
 562         ref = mcParticle->GetTrackReference(iref);\r
 563         if(ref->LocalX() > fgkTPC) break;\r
 564         iref++;\r
 565       }\r
 566 \r
 567       fTrackInfo->SetMC();\r
 568       fTrackInfo->SetPDG(fPdg);\r
 569       fTrackInfo->SetPrimary(mcParticle->Particle()->IsPrimary());\r
 570       fTrackInfo->SetLabel(label);\r
 571       fTrackInfo->SetTRDlabel(esdTrack->GetTRDLabel());\r
 572       Int_t jref = iref;//, kref = 0;\r
 573       while(jref<nRefs){\r
 574         ref = mcParticle->GetTrackReference(jref);\r
 575         if(ref->LocalX() > fgkTRD) break;\r
 576         AliDebug(4, Form("  trackRef[%2d (%2d)] @ %7.3f OK", jref-iref, jref, ref->LocalX()));\r
 577         fTrackInfo->AddTrackRef(ref);\r
 578         jref++;\r
 579       }\r
 580       AliDebug(3, Form("NtrackRefs[%d(%d)]", fTrackInfo->GetNTrackRefs(), nRefs));\r
 581     }\r
 582 \r
 583     // copy some relevant info to TRD track info\r
 584     fTrackInfo->SetStatus(esdTrack->GetStatus());\r
 585     fTrackInfo->SetTrackId(esdTrack->GetID());\r
 586     Double_t p[AliPID::kSPECIES]; esdTrack->GetTRDpid(p);\r
 587     fTrackInfo->SetESDpid(p);\r
 588     fTrackInfo->SetESDpidQuality(esdTrack->GetTRDntrackletsPID());\r
 589     fTrackInfo->SetESDeta(esdTrack->Eta());\r
 590     Double_t loc[3];\r
 591     if(esdTrack->GetXYZAt(298., fESDev->GetMagneticField(), loc)) fTrackInfo->SetESDphi(TMath::ATan2(loc[1], loc[0]));\r
 592     fTrackInfo->SetESDpt(esdTrack->Pt());\r
 593     if(!nSlices) nSlices = esdTrack->GetNumberOfTRDslices();\r
 594     memset(dedx, 0, 100*sizeof(Double32_t));\r
 595     Int_t in(0);\r
 596     for(Int_t il=0; il<AliTRDgeometry::kNlayer; il++)\r
 597       for(Int_t is=0; is<nSlices; is++) \r
 598         dedx[in++]=esdTrack->GetTRDslice(il, is);\r
 599     for(Int_t il=0; il<AliTRDgeometry::kNlayer; il++) dedx[in++]=esdTrack->GetTRDmomentum(il);\r
 600     fTrackInfo->SetSlices(in, dedx);\r
 601     fTrackInfo->SetNumberOfClustersRefit(esdTrack->GetNcls(2));\r
 602     // some other Informations which we may wish to store in order to find problematic cases\r
 603     fTrackInfo->SetKinkIndex(esdTrack->GetKinkIndex(0));\r
 604     fTrackInfo->SetTPCncls(static_cast<UShort_t>(esdTrack->GetNcls(1)));\r
 605     fTrackInfo->SetTPCdedx(esdTrack->GetTPCsignal());\r
 606     Float_t tofTime = esdTrack->GetTOFsignal() - fESDev->GetT0TOF(0);\r
 607     fTrackInfo->SetTOFbeta(tofTime>0.?((esdTrack->GetIntegratedLength()/(tofTime*TMath::C()))*10e9):-999.);\r
 608     fTrackInfo->SetTOFbc(esdTrack->GetTOFBunchCrossing()==AliVTrack::kTOFBCNA?0:esdTrack->GetTOFBunchCrossing());\r
 609 //    nclsTrklt = 0;\r
 610   \r
 611     // set V0pid info\r
 612     //printf("%4d Looking for V0s...\n" , fTrackInfo->GetTrackId());\r
 613     for(Int_t iv(0); iv<fV0List->GetEntriesFast(); iv++){\r
 614       if(!(v0info = (AliTRDv0Info*)fV0List->At(iv))) continue;\r
 615       if(!v0info->GetV0Daughter(1) && !v0info->GetV0Daughter(-1)) continue;\r
 616       if(!v0info->HasTrack(fTrackInfo)) continue;\r
 617       //v0info->Print();\r
 618       memset(v0pid, 0, AliPID::kSPECIES*sizeof(Int_t));\r
 619       fTrackInfo->SetV0();\r
 620       for(Int_t is=AliPID::kSPECIES; is--;) v0pid[is] = v0info->GetPID(is, fTrackInfo); fTrackInfo->SetV0pid(v0pid);\r
 621       if(v0info->IsDecay(AliTRDv0Info::kGamma)) fTrackInfo->SetElectron();\r
 622       else if(v0info->IsDecay(AliTRDv0Info::kK0s)) fTrackInfo->SetPion();\r
 623       else if(v0info->IsDecay(AliTRDv0Info::kLambda)) esdTrack->Charge()>0?fTrackInfo->SetProton():fTrackInfo->SetPion();\r
 624       else if(v0info->IsDecay(AliTRDv0Info::kAntiLambda)) esdTrack->Charge()<0?fTrackInfo->SetProton():fTrackInfo->SetPion();\r
 625       \r
 626       //TODO one track can be attached to more than one v0. Ideally one would need a list of v0 attached to the track info\r
 627     }\r
 628 \r
 629     // read track REC info\r
 630     if((esdFriendTrack = (fESDfriend->GetNumberOfTracks() > itrk) ? fESDfriend->GetTrack(itrk): NULL)) {\r
 631       fTrackInfo->SetTPCoutParam(esdFriendTrack->GetTPCOut());\r
 632       fTrackInfo->SetITSoutParam(esdFriendTrack->GetITSOut());\r
 633       const AliTrackPointArray *tps(NULL);\r
 634       if((tps=esdFriendTrack->GetTrackPointArray()) && HasTrackPoints()) fTrackInfo->SetTrackPointArray(tps);\r
 635       Int_t icalib = 0;\r
 636       while((calObject = esdFriendTrack->GetCalibObject(icalib++))){\r
 637         if(strcmp(calObject->IsA()->GetName(),"AliTRDtrackV1") != 0) continue; // Look for the TRDtrack\r
 638         if(!(track = dynamic_cast<AliTRDtrackV1*>(calObject))) break;\r
 639         AliDebug(4, Form("TRD track OK"));\r
 640         // Set the clusters to unused\r
 641         for(Int_t ipl = 0; ipl < AliTRDgeometry::kNlayer; ipl++){\r
 642           if(!(tracklet = track->GetTracklet(ipl))) continue;\r
 643           tracklet->ResetClusterIter();\r
 644           while((cl = tracklet->NextCluster())) cl->Use(0);\r
 645         }\r
 646         fTrackInfo->SetTrack(track);\r
 647         ((TH2I*)fContainer->At(kBC))->Fill(evBC, esdTrack->GetTOFBunchCrossing());\r
 648         break;\r
 649       }\r
 650       AliDebug(3, Form("Ntracklets[%d]", fTrackInfo->GetNTracklets()));\r
 651     } else AliDebug(3, Form("No Friends for trk[%3d] Ntrk[%3d]", itrk, fESDfriend->GetNumberOfTracks()));\r
 652     if(op) fTrackInfo->SetOuterParam(op);\r
 653 \r
 654     if(DebugLevel() >= 1){\r
 655       AliTRDtrackInfo info(*fTrackInfo);\r
 656       (*DebugStream()) << "trackInfo"\r
 657       << "TrackInfo.=" << &info\r
 658       << "\n";\r
 659       info.Delete("");\r
 660     }\r
 661 \r
 662     ULong_t status(esdTrack->GetStatus());\r
 663     if((status&AliESDtrack::kTPCout)){  // TPC prolongation\r
 664       if(!esdTrack->GetKinkIndex(0)){ // Barrel  Track Selection\r
 665         Bool_t selected(kTRUE);\r
 666         if(UseLocalTrkSelection()){\r
 667           if(esdTrack->Pt() < fgkPt){ \r
 668             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Pt[%5.2f]", itrk, fESDev->GetEventNumberInFile(), esdTrack->Pt()));\r
 669             selected = kFALSE;\r
 670           }\r
 671           if(selected && TMath::Abs(esdTrack->Eta()) > fgkEta){\r
 672             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Eta[%5.2f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(esdTrack->Eta())));\r
 673             selected = kFALSE;\r
 674           }\r
 675           if(selected && esdTrack->GetTPCNcls() < fgkNclTPC){ \r
 676             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] NclTPC[%d]", itrk, fESDev->GetEventNumberInFile(), esdTrack->GetTPCNcls()));\r
 677             selected = kFALSE;\r
 678           }\r
 679           Float_t par[2], cov[3];\r
 680           esdTrack->GetImpactParameters(par, cov);\r
 681           if(IsCollision()){ // cuts on DCA\r
 682             if(selected && TMath::Abs(par[0]) > fgkTrkDCAxy){ \r
 683               AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] DCAxy[%f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(par[0])));\r
 684               selected = kFALSE;\r
 685             }\r
 686             if(selected && TMath::Abs(par[1]) > fgkTrkDCAz){ \r
 687               AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] DCAz[%f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(par[1])));\r
 688               selected = kFALSE;\r
 689             }\r
 690           } else if(selected && fMCev && !fMCev->IsPhysicalPrimary(alab)){;\r
 691             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Primary", itrk, fESDev->GetEventNumberInFile()));\r
 692             selected = kFALSE;\r
 693           }\r
 694         }\r
 695         if(fTrackCut && !fTrackCut->IsSelected(esdTrack)) selected = kFALSE;\r
 696         if(selected){ \r
 697           fTracksBarrel->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 698           nBarrel++;\r
 699           if(fTrackInfo->GetTrack()) \r
 700             nBarrelFriend++;\r
 701         }\r
 702       } else {\r
 703         fTracksKink->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 704         nKink++;\r
 705       }\r
 706     } else if((status&AliESDtrack::kITSout)) { // ITS prolongation \r
 707       Bool_t selected(kTRUE);\r
 708       if(UseLocalTrkSelection()){\r
 709         if(esdTrack->Pt() < fgkPt){\r
 710           AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Pt[%5.2f]", itrk, fESDev->GetEventNumberInFile(), esdTrack->Pt()));\r
 711           selected = kFALSE;\r
 712         }\r
 713         if(selected && TMath::Abs(esdTrack->Eta()) > fgkEta){\r
 714           AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Eta[%5.2f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(esdTrack->Eta())));\r
 715           selected = kFALSE;\r
 716         }\r
 717         Float_t par[2], cov[3];\r
 718         esdTrack->GetImpactParameters(par, cov);\r
 719         if(IsCollision()){ // cuts on DCA\r
 720           if(selected && TMath::Abs(par[0]) > fgkTrkDCAxy){\r
 721             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] DCAxy[%f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(par[0])));\r
 722             selected = kFALSE;\r
 723           }\r
 724           if(selected && TMath::Abs(par[1]) > fgkTrkDCAz){\r
 725             AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] DCAz[%f]", itrk, fESDev->GetEventNumberInFile(), TMath::Abs(par[1])));\r
 726             selected = kFALSE;\r
 727           }\r
 728         } else if(selected && fMCev && !fMCev->IsPhysicalPrimary(alab)){;\r
 729           AliDebug(3, Form("Reject Trk[%3d] Ev[%4d] Primary", itrk, fESDev->GetEventNumberInFile()));\r
 730           selected = kFALSE;\r
 731         }\r
 732       }\r
 733       if(fTrackCut && !fTrackCut->IsSelected(esdTrack)) selected = kFALSE;\r
 734       if(selected){\r
 735         fTracksBarrel->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 736         nBarrel++;\r
 737         if(fTrackInfo->GetTrack())\r
 738           nBarrelFriend++;\r
 739       }\r
 740     } else if((status&AliESDtrack::kTRDout) && !(status&AliESDtrack::kTRDin)){ // TRD SA tracking\r
 741       fTracksSA->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 742       nSA++;\r
 743       if(fTrackInfo->GetTrack()) \r
 744         nSAFriend++;\r
 745     }\r
 746     fTrackInfo->Delete("");\r
 747   }\r
 748   // read clusters REC info\r
 749   TTree * treeR(NULL); AliESDInputHandlerRP *esdRPhandler(NULL);\r
 750   if(fInputHandler) esdRPhandler = dynamic_cast<AliESDInputHandlerRP*>(fInputHandler);\r
 751   if(esdRPhandler){\r
 752     if((treeR = esdRPhandler->GetTreeR("TRD"))) {\r
 753       TObjArray *recPoints(NULL);\r
 754       if((treeR->GetBranch("TRDcluster"))){\r
 755         treeR->SetBranchAddress("TRDcluster", &recPoints);\r
 756         for(Int_t idet(0); idet<treeR->GetEntries(); idet++){\r
 757           treeR->GetEntry(idet);\r
 758           if(!recPoints->GetEntries()){\r
 759             AliDebug(1, Form("Missing entry %d from TreeR", idet));\r
 760             continue;\r
 761           }\r
 762           AliTRDcluster *c = (AliTRDcluster*)(*recPoints)[0];\r
 763           if(!c){\r
 764             AliDebug(1, Form("Missing first cluster in entry %d from TreeR", idet));\r
 765             continue;\r
 766           }\r
 767           fClusters->AddAt(recPoints->Clone(Form("%03d", c->GetDetector())), c->GetDetector());\r
 768         }\r
 769       } else AliDebug(3, "No TRDcluster branch");\r
 770     } else AliDebug(3, "No RecPoints");\r
 771   } else AliDebug(3, "No AliESDInputHandlerRP");\r
 772 \r
 773 \r
 774   // LOOP 2 - over MC tracks which are passing TRD where the track is not reconstructed\r
 775   if(HasMCdata()){\r
 776     AliDebug(10, "Output of the MC track map:");\r
 777     for(Int_t itk = 0; itk < nTracksMC;  itk++) AliDebug(10, Form("trackMap[%d] = %s", itk, trackMap[itk] == kTRUE ? "TRUE" : "kFALSE"));\r
 778   \r
 779     for(Int_t itk = 0; itk < nTracksMC; itk++){\r
 780       if(trackMap[itk]) continue;\r
 781       AliMCParticle *mcParticle =  (AliMCParticle*) fMCev->GetTrack(TMath::Abs(itk));\r
 782       Int_t fPdg = mcParticle->Particle()->GetPdgCode();\r
 783       Int_t nRefs = mcParticle->GetNumberOfTrackReferences();\r
 784       Int_t iref = 0; AliTrackReference *ref = NULL; \r
 785       Int_t nRefsTRD = 0;\r
 786       new(fTrackInfo) AliTRDtrackInfo();\r
 787       fTrackInfo->SetMC();\r
 788       fTrackInfo->SetPDG(fPdg);\r
 789       while(iref<nRefs){ // count TRD TR\r
 790         Bool_t kIN(kFALSE);\r
 791         ref = mcParticle->GetTrackReference(iref);\r
 792         if(ref->LocalX() > fgkTPC && ref->LocalX() < fgkTRD){\r
 793           fTrackInfo->AddTrackRef(ref);\r
 794           nRefsTRD++;kIN=kTRUE;\r
 795         }\r
 796         AliDebug(4, Form("  trackRef[%2d] @ x[%7.3f] %s", iref, ref->LocalX(), kIN?"IN":"OUT"));\r
 797         iref++;\r
 798       }\r
 799       if(!nRefsTRD){\r
 800         // In this stage we at least require 1 hit inside TRD. What will be done with this tracks is a task for the \r
 801         // analysis job\r
 802         fTrackInfo->Delete("");\r
 803         continue;\r
 804       }\r
 805       fTrackInfo->SetPrimary(mcParticle->Particle()->IsPrimary());\r
 806       fTrackInfo->SetLabel(itk);\r
 807       if(DebugLevel() >= 1){\r
 808         AliTRDtrackInfo info(*fTrackInfo);\r
 809         (*DebugStream()) << "trackInfo"\r
 810         << "TrackInfo.=" << &info\r
 811         << "\n";\r
 812         info.Delete("");\r
 813       }\r
 814       AliDebug(3, Form("Add MC track @ label[%d] nTRDrefs[%d].", itk, nRefsTRD));\r
 815       // check where the track starts\r
 816       ref = mcParticle->GetTrackReference(0);\r
 817       if(ref->LocalX() < fgkITS){ \r
 818         fTracksBarrel->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 819         nBarrelMC++;\r
 820       } else if(ref->LocalX() < fgkTPC) {\r
 821         fTracksKink->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 822         nKinkMC++;\r
 823       } else if(nRefsTRD>6){\r
 824         fTracksSA->Add(new AliTRDtrackInfo(*fTrackInfo));\r
 825         nSAMC++;\r
 826       }\r
 827       fTrackInfo->Delete("");\r
 828     }\r
 829     delete[] trackMap;\r
 830   }\r
 831   AliDebug(1, Form(\r
 832     "\nEv[%3d] Tracks: ESD[%d] MC[%d] V0[%d]\n"\r
 833     "        TPCout[%d] ITSout[%d] TRDin[%d] TRDout[%d]\n"\r
 834     "        Barrel[%3d+%3d=%3d] SA[%2d+%2d=%2d] Kink[%2d+%2d=%2d]"\r
 835     ,(Int_t)AliAnalysisManager::GetAnalysisManager()->GetCurrentEntry(), nTracksESD, nTracksMC, fV0List->GetEntries()\r
 836     , nTPC, nITS, nTRDin, nTRDout\r
 837     ,nBarrel, nBarrelMC, fTracksBarrel->GetEntries()\r
 838     ,nSA, nSAMC, fTracksSA->GetEntries()\r
 839     ,nKink, nKinkMC, fTracksKink->GetEntries()\r
 840   ));\r
 841   // save track statistics\r
 842   h = (TH1I*)fContainer->At(kStatTrk);\r
 843   h->Fill(Float_t(kTracksESD), nTracksESD);\r
 844   h->Fill(Float_t(kTracksMC), nTracksMC);\r
 845   h->Fill(Float_t(kV0), fV0List->GetEntries());\r
 846   h->Fill(Float_t(kTPC), nTPC);\r
 847   h->Fill(Float_t(kITS), nITS);\r
 848   h->Fill(Float_t(kTRDin), nTRDin);\r
 849   h->Fill(Float_t(kTRDout), nTRDout);\r
 850   h->Fill(Float_t(kBarrel), nBarrel);\r
 851   h->Fill(Float_t(kBarrelMC), nBarrelMC);\r
 852   h->Fill(Float_t(kSA), nSA);\r
 853   h->Fill(Float_t(kSAMC), nSAMC);\r
 854   h->Fill(Float_t(kKink), nKink);\r
 855   h->Fill(Float_t(kKinkMC), nKinkMC);\r
 856   h->Fill(Float_t(kBarrelFriend), nBarrelFriend);\r
 857   h->Fill(Float_t(kSAFriend), nSAFriend);\r
 858 }\r
 859 \r
 860 \r
 861 //____________________________________________________________________\r
 862 void AliTRDinfoGen::MakeChambers()\r
 863 {\r
 864 // Build chamber position and status\r
 865   if(!fContainer){\r
 866     AliError("Missing container");\r
 867     return;\r
 868   }\r
 869   AliTRDcalibDB *calib(AliTRDcalibDB::Instance());\r
 870   if(!calib){\r
 871     AliError("No access to calibration data");\r
 872     return;\r
 873   }\r
 874   TObjArray *chmb = (TObjArray*)fContainer->At(kChmb);\r
 875   Int_t stat(0);\r
 876   Double_t alpha(0.), cs(-2.), sn(0.), pos[4];\r
 877   for(Int_t isec(0); isec<AliTRDgeometry::kNsector; isec++){\r
 878     alpha = (0.5+isec)*AliTRDgeometry::GetAlpha();\r
 879     cs    = TMath::Cos(alpha);\r
 880     sn    = TMath::Sin(alpha);\r
 881 \r
 882     for(Int_t istk(0); istk<AliTRDgeometry::kNstack; istk++){\r
 883       for(Int_t ilyr(0); ilyr<AliTRDgeometry::kNlayer; ilyr++){\r
 884         Int_t idet(AliTRDgeometry::GetDetector(ilyr, istk, isec));\r
 885         TGeoHMatrix *matrix(fgGeo->GetClusterMatrix(idet));\r
 886         if(!matrix){\r
 887           AliDebug(2, Form("Missing matrix for %03d [%02d_%d_%d]", idet, isec, istk, ilyr));\r
 888           continue;\r
 889         }\r
 890         AliDebug(2, Form("Read info for %03d [%02d_%d_%d]", idet, isec, istk, ilyr));\r
 891         AliTRDpadPlane *pp(fgGeo->GetPadPlane(ilyr, istk));\r
 892         Double_t zm(0.5 * (pp->GetRow0() + pp->GetRowEnd())),\r
 893                  loc0[] = {AliTRDgeometry::AnodePos(), pp->GetCol0(), zm-pp->GetRow0()},\r
 894                  loc1[] = {AliTRDgeometry::AnodePos(), pp->GetColEnd(), zm-pp->GetRowEnd()},\r
 895                  glb[3] = {1,1,1};\r
 896         matrix->LocalToMaster(loc0, glb);\r
 897         Float_t phi = TMath::ATan2(glb[0]*sn + glb[1]*cs, glb[0]*cs - glb[1]*sn),\r
 898                 tgl = glb[2]/glb[0]/TMath::Sqrt(1.+glb[1]*glb[1]/glb[0]/glb[0]),\r
 899                 eta = -TMath::Log(TMath::Tan(0.5 *  (0.5*TMath::Pi() - TMath::ATan(tgl))));\r
 900         pos[0] = eta; pos[1] = phi;\r
 901         matrix->LocalToMaster(loc1, glb);\r
 902         phi = TMath::ATan2(glb[0]*sn + glb[1]*cs, glb[0]*cs - glb[1]*sn);\r
 903         tgl = glb[2]/glb[0]/TMath::Sqrt(1.+glb[1]*glb[1]/glb[0]/glb[0]);\r
 904         eta = -TMath::Log(TMath::Tan(0.5 *  (0.5*TMath::Pi() - TMath::ATan(tgl))));\r
 905         pos[2] = eta; pos[3] = phi;\r
 906         stat = 0;\r
 907         if(calib->IsChamberGood(idet)){\r
 908           if(calib->IsHalfChamberNoData(idet, 0)) stat += 2;\r
 909           if(calib->IsHalfChamberNoData(idet, 1)) stat += 3;\r
 910         } else stat = 1;\r
 911         chmb->Add(new AliTRDchmbInfo(idet, stat, pos));\r
 912       }\r
 913     }\r
 914   }\r
 915 }\r
 916 \r
 917 //____________________________________________________________________\r
 918 void AliTRDinfoGen::MakeSummary()\r
 919 {\r
 920 // Build summary plots\r
 921   if(!fContainer){\r
 922     AliError("Missing results");\r
 923     return;\r
 924   }\r
 925   TH1 *h1(NULL); TVirtualPad *p(NULL); TCanvas *cOut(NULL);\r
 926 \r
 927   const Int_t nx(1024), ny(1024);\r
 928   cOut = new TCanvas("infoGenSummary", "Run Statistics", nx, ny);\r
 929   cOut->Divide(2,2, 1.e-5, 1.e-5);\r
 930   //=========\r
 931   p=cOut->cd(1);p->SetRightMargin(0.025);p->SetTopMargin(0.01);p->SetLogy();\r
 932   h1 = (TH1*)fContainer->At(kStatTrk);\r
 933   h1->SetBarOffset(0.06); h1->SetBarWidth(0.88); h1->SetFillColor(kGreen); h1->SetFillStyle(3001);\r
 934   h1->Draw("bar1");\r
 935   //=========\r
 936   p=cOut->cd(2);p->SetRightMargin(0.025);p->SetTopMargin(0.01);p->SetLogy();\r
 937   h1 = (TH1*)fContainer->At(kEvType);\r
 938   h1->SetBarOffset(0.04); h1->SetBarWidth(0.92);h1->SetFillColor(kGreen); h1->SetFillStyle(3001);\r
 939   h1->Draw("bar1");\r
 940   //=========\r
 941   p=cOut->cd(3);p->SetRightMargin(0.025);p->SetTopMargin(0.01);p->SetLogz();\r
 942   TH2 *h2((TH2*)fContainer->At(kBC));\r
 943   h1 = h2->ProjectionX("_px");\r
 944   Int_t n(0); Int_t bins[3500];\r
 945   for(Int_t ib(1); ib<=3500; ib++){\r
 946     if(h1->GetBinContent(ib) < 1) continue;\r
 947     bins[n++] = ib;\r
 948   }\r
 949   delete h1;\r
 950 \r
 951   TAxis *ay(h2->GetYaxis());\r
 952   TH2 *hs = new TH2I("hBC_Summary", Form("%s;%s;%s", h2->GetTitle(), h2->GetXaxis()->GetTitle(), h2->GetYaxis()->GetTitle()),\r
 953                      n, -0.5, n-0.5, ay->GetNbins(), ay->GetXmin(), ay->GetXmax());\r
 954   hs->SetLineColor(kBlack);hs->SetLineWidth(1);\r
 955   hs->SetMarkerColor(kRed);\r
 956   TAxis *ax(hs->GetXaxis()); ax->CenterTitle(); ax->SetTitleOffset(1.4);\r
 957   for(Int_t ib(0); ib<n; ib++){\r
 958     ax->SetBinLabel(ib+1, Form("%d", bins[ib]));\r
 959     for(Int_t iy(1); iy<=ay->GetNbins(); iy++){\r
 960       hs->SetBinContent(ib+1, iy, h2->GetBinContent(bins[ib], iy));\r
 961     }\r
 962   }\r
 963   hs->Draw("textbox");\r
 964 \r
 965   //=========\r
 966   p=cOut->cd(4); p->SetRightMargin(0.0215);p->SetLeftMargin(0.414);//p->SetLogz();\r
 967   TObject *o = fContainer->At(kTrigger);\r
 968   if(o){\r
 969     if(!strcmp("TH1I", o->IsA()->GetName())){\r
 970       h1 = dynamic_cast<TH1I*>(o);\r
 971       h1->GetXaxis()->SetTitleOffset(6.5); h1->GetXaxis()->CenterTitle();\r
 972       h1->SetFillStyle(3001);h1->SetFillColor(kGreen);\r
 973       h1->SetBarWidth(0.8);h1->SetBarOffset(0.1);\r
 974       ((TH1I*)o)->Draw("hbar2");\r
 975     } else ((AliTRDtriggerInfo*)o)->Draw();\r
 976   }\r
 977   cOut->SaveAs(Form("%s.gif", cOut->GetName()));\r
 978 }\r
 979 \r
 980 //____________________________________________________________________\r
 981 void AliTRDinfoGen::SetLocalEvSelection(const AliTRDeventCuts &ec)\r
 982 {\r
 983 // Set event cuts from outside\r
 984   if(!fEventCut) fEventCut = new AliTRDeventCuts(ec);\r
 985   else new(fEventCut) AliTRDeventCuts(ec);\r
 986   fEventCut->Print();\r
 987 }\r
 988 \r
 989 //____________________________________________________________________\r
 990 void AliTRDinfoGen::SetLocalV0Selection(const AliTRDv0Info &v0)\r
 991 {\r
 992 // Set V0 cuts from outside\r
 993 \r
 994   if(!fV0Cut) fV0Cut = new AliTRDv0Info(v0);\r
 995   else new(fV0Cut) AliTRDv0Info(v0);\r
 996   fV0Cut->Print();\r
 997 }\r
 998 \r
 999 //____________________________________________________________________\r
1000 TTreeSRedirector* AliTRDinfoGen::DebugStream()\r
1001 {\r
1002 // Manage debug stream for task\r
1003   if(!fDebugStream){\r
1004     TDirectory *savedir = gDirectory;\r
1005     fDebugStream = new TTreeSRedirector("TRD.DebugInfoGen.root");\r
1006     savedir->cd();\r
1007   }\r
1008   return fDebugStream;\r
1009 }\r
1010 \r
1011 //____________________________________________________________________\r
1012 void AliTRDinfoGen::Terminate(Option_t* /*option*/)\r
1013 {\r
1014 // Process run information\r
1015   AliInfo("");\r
1016   if(!(fContainer = dynamic_cast<TObjArray *>(GetOutputData(AliTRDpwgppHelper::kMonitor)))) return;\r
1017   AliInfo(Form("fContainer(%p)", (void*)fContainer));\r
1018 \r
1019   AliTRDtriggerInfo* ti(NULL);\r
1020   if(UseLocalEvSelection()){\r
1021     if(!(ti = (AliTRDtriggerInfo*)fContainer->At(kTrigger))) return;\r
1022     for(Int_t ix(0); ix<ti->GetNTriggers(); ix++){\r
1023       if(fEventCut->CheckTrigger(ti->GetTrigger(ix))) ti->SetSelectTrigger(ix);\r
1024       //ax->SetBinLabel(ix, Form("#color[2]{%s}", ax->GetBinLabel(ix)));\r
1025     }\r
1026   }\r
1027 }\r
1028 \r