PWGPP/TPC/AliPerformanceMatch.cxx

   1 //------------------------------------------------------------------------------
   2 // Implementation of AliPerformanceMatch class. It checks the track matching
   3 // quality (residuals, pulls) bewteen tracking detectors TPC-ITS and TPC-TRD
   4 // with TPC as the reference detector. In addition, the ITS and TRD track
   5 // reconstruction efficiency with respect to TPC is calculated.
   6 //
   7 // The matchinig quality parameters are stored in the THnSparse histograms.
   8 // The analysis of these histograms to extract reference information is done in
   9 // the Analyse() function (post-processing).
  10 //
  11 // The histograms with reference information can be exported to the ROOT folder.
  12 //
  13 // Author: J.Otwinowski 17/10/2009
  14 // Changes by M.Knichel 22/10/2010
  15 //------------------------------------------------------------------------------
  16
  17 /*
  18
  19   // after running comparison task, read the file, and get component
  20   gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
  21   LoadMyLibs();
  22
  23   TFile f("Output.root");
  24   AliPerformanceMatch * compObj = (AliPerformanceMatch*)coutput->FindObject("AliPerformanceMatchTPCTRD");
  25
  26   // analyse comparison data
  27   compObj->Analyse();
  28
  29   // the output histograms/graphs will be stored in the folder "folderMatch"
  30   compObj->GetAnalysisFolder()->ls("*");
  31
  32   // user can save whole comparison object (or only folder with anlysed histograms)
  33   // in the seperate output file (e.g.)
  34   TFile fout("Analysed_Match.root","recreate");
  35   compObj->Write(); // compObj->GetAnalysisFolder()->Write();
  36   fout.Close();
  37
  38 */
  39
  40 #include "TCanvas.h"
  41 #include "TH1.h"
  42 #include "TH2.h"
  43 #include "TAxis.h"
  44 #include "TF1.h"
  45
  46 #include "AliPerformanceMatch.h"
  47 #include "AliESDEvent.h"
  48 #include "AliESDVertex.h"
  49 #include "AliESDtrack.h"
  50 #include "AliESDfriendTrack.h"
  51 #include "AliESDfriend.h"
  52 #include "AliLog.h"
  53 #include "AliMCEvent.h"
  54 #include "AliMCParticle.h"
  55 #include "AliHeader.h"
  56 #include "AliGenEventHeader.h"
  57 #include "AliStack.h"
  58 #include "AliMCInfoCuts.h"
  59 #include "AliRecInfoCuts.h"
  60 #include "AliTracker.h"
  61 #include "AliTRDtrackV1.h"
  62 #include "AliTreeDraw.h"
  63
  64 using namespace std;
  65
  66 ClassImp(AliPerformanceMatch)
  67
  68 Bool_t AliPerformanceMatch::fgMergeTHnSparse = kFALSE;
  69 Bool_t AliPerformanceMatch::fgUseMergeTHnSparse = kFALSE;
  70
  71 //_____________________________________________________________________________
  72 AliPerformanceMatch::AliPerformanceMatch():
  73   AliPerformanceObject("AliPerformanceMatch"),
  74   fResolHisto(0),
  75   fPullHisto(0),
  76   fTrackingEffHisto(0),
  77   fTPCConstrain(0),
  78   fFolderObj(0),
  79   // Cuts
  80   fCutsRC(0),
  81   fCutsMC(0),
  82
  83   // histogram folder
  84   fAnalysisFolder(0),
  85
  86   fUseHLT(0)
  87 {
  88   Init();
  89 }
  90
  91 //_____________________________________________________________________________
  92 AliPerformanceMatch::AliPerformanceMatch(Char_t* name="AliPerformanceMatch", Char_t* title="AliPerformanceMatch",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE):
  93   AliPerformanceObject(name,title),
  94   fResolHisto(0),
  95   fPullHisto(0),
  96   fTrackingEffHisto(0),
  97   fTPCConstrain(0),
  98   fFolderObj(0),
  99   // Cuts
 100   fCutsRC(0),
 101   fCutsMC(0),
 102
 103   // histogram folder
 104   fAnalysisFolder(0),
 105   fUseHLT(0)
 106 {
 107   // named constructor
 108   //
 109   SetAnalysisMode(analysisMode);
 110   SetHptGenerator(hptGenerator);
 111
 112   Init();
 113 }
 114
 115 //_____________________________________________________________________________
 116 AliPerformanceMatch::~AliPerformanceMatch()
 117 {
 118   // destructor
 119
 120   if(fResolHisto) delete fResolHisto; fResolHisto=0;
 121   if(fPullHisto)  delete fPullHisto;  fPullHisto=0;
 122   if(fTrackingEffHisto) delete fTrackingEffHisto; fTrackingEffHisto = 0x0;
 123   if(fTPCConstrain) delete fTPCConstrain; fTPCConstrain = 0x0;
 124
 125   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
 126   if(fFolderObj) delete fFolderObj; fFolderObj=0;
 127 }
 128
 129 //_____________________________________________________________________________
 130 void AliPerformanceMatch::Init(){
 131
 132   //
 133   // Make performance histogrms
 134   //
 135
 136   // set pt bins
 137   Int_t nPtBins = 50;
 138   Double_t ptMin = 1.e-2, ptMax = 20.;
 139
 140   Double_t *binsPt = 0;
 141
 142   if (IsHptGenerator())  {
 143         ptMax = 100.;
 144   }
 145    binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);
 146
 147
 148   // Double_t yMin = -0.02, yMax = 0.02;
 149   // Double_t zMin = -12.0, zMax = 12.0;
 150   // if(GetAnalysisMode() == 0 || GetAnalysisMode() == 1) {
 151   //   yMin = -100.; yMax = 100.;
 152   //   zMin = -100.; zMax = 100.;
 153   // }
 154
 155   //
 156   //init ITS TPC Mactching
 157   //
 158   if(GetAnalysisMode()==1){
 159     // res_y:res_z:res_phi,res_lambda:res_pt:y:z:eta:phi:pt:isRec
 160     Int_t binsResolHisto[9]={100,100,100,100,100,90,30,nPtBins,2};
 161     Double_t minResolHisto[9]={-1.,-1.,-0.03,-0.03,-0.2, 0., -1.5, ptMin,0};
 162     Double_t maxResolHisto[9]={ 1., 1., 0.03, 0.03, 0.2, 2.*TMath::Pi(), 1.5, ptMax,2};
 163
 164     fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_pt:phi:eta:pt:isRec",9,binsResolHisto,minResolHisto,maxResolHisto);
 165     fResolHisto->SetBinEdges(7,binsPt);
 166
 167     fResolHisto->GetAxis(0)->SetTitle("y-y_{ref} (cm)");
 168     fResolHisto->GetAxis(1)->SetTitle("z-z_{ref} (cm)");
 169     fResolHisto->GetAxis(2)->SetTitle("#phi-#phi_{ref} (rad)");
 170     fResolHisto->GetAxis(3)->SetTitle("#lambda-#lambda_{ref} (rad)");
 171     fResolHisto->GetAxis(4)->SetTitle("(p_{T}/p_{Tref}-1)");
 172     fResolHisto->GetAxis(5)->SetTitle("#phi_{ref} (rad)");
 173     fResolHisto->GetAxis(6)->SetTitle("#eta_{ref}");
 174     fResolHisto->GetAxis(7)->SetTitle("p_{Tref} (GeV/c)");
 175     fResolHisto->GetAxis(8)->SetTitle("isReconstructed");
 176     fResolHisto->Sumw2();
 177
 178     //pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec
 179     Int_t binsPullHisto[9]={100,100,100,100,100,90,30,nPtBins,2};
 180     Double_t minPullHisto[9]={-5.,-5.,-5.,-5.,-5., 0.,-1.5, ptMin,0};
 181     Double_t maxPullHisto[9]={ 5., 5., 5., 5., 5., 2.*TMath::Pi(), 1.5, ptMax,2};
 182     fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:phi:eta:1pt:isRec",9,binsPullHisto,minPullHisto,maxPullHisto);
 183
 184     fPullHisto->GetAxis(0)->SetTitle("(y-y_{ref})/#sigma");
 185     fPullHisto->GetAxis(1)->SetTitle("(z-z_{ref})/#sigma");
 186     fPullHisto->GetAxis(2)->SetTitle("(sin#phi-sin#phi_{ref})/#sigma");
 187     fPullHisto->GetAxis(3)->SetTitle("(tan#lambda-tan#lambda_{ref})/#sigma");
 188     fPullHisto->GetAxis(4)->SetTitle("(p_{Tref}/p_{T}-1)/#sigma");
 189     fPullHisto->GetAxis(5)->SetTitle("#phi_{ref} (rad)");
 190     fPullHisto->GetAxis(6)->SetTitle("#eta_{ref}");
 191     fPullHisto->GetAxis(7)->SetTitle("1/p_{Tref} (GeV/c)^{-1}");
 192     fPullHisto->GetAxis(8)->SetTitle("isReconstructed");
 193     fPullHisto->Sumw2();
 194   }
 195
 196   //
 197   //TPC  ITS  Mactching
 198   //
 199   if(GetAnalysisMode()==0){
 200     // -> has match:y:z:snp:tgl:phi:pt:ITSclusters
 201     Int_t binsTrackingEffHisto[5]    = { 2,   90,       nPtBins, 30,    7   };
 202     Double_t minTrackingEffHisto[5]  = {-0.5, 0.,          ptMin, -1.5, -0.5 };
 203     Double_t maxTrackingEffHisto[5]  = { 1.5, 2*TMath::Pi(), ptMax, 1.5,  6.5 };
 204
 205     fTrackingEffHisto = new THnSparseF("fTrackingEffHisto","has match:phi:pt:eta:ITSclusters",5,binsTrackingEffHisto,minTrackingEffHisto,maxTrackingEffHisto);
 206     fTrackingEffHisto->SetBinEdges(2,binsPt);
 207     fTrackingEffHisto->GetAxis(0)->SetTitle("IsMatching");
 208     fTrackingEffHisto->GetAxis(1)->SetTitle("phi (rad)");
 209     fTrackingEffHisto->GetAxis(2)->SetTitle("p_{T}");
 210     fTrackingEffHisto->GetAxis(3)->SetTitle("eta");
 211     fTrackingEffHisto->GetAxis(4)->SetTitle("number of ITS clusters");
 212     fTrackingEffHisto->Sumw2();
 213   }
 214
 215   //
 216   //TPC constraining to vertex
 217   //
 218   if(GetAnalysisMode()==2){
 219     //initilization of fTPCConstrain
 220     Int_t  binsTPCConstrain[4] = {100, 90,            nPtBins, 30};
 221     Double_t minTPCConstrain[4] = {-5, 0,             ptMin,   -1.5};
 222     Double_t maxTPCConstrain[4] = {5,  2*TMath::Pi(), ptMax,  1.5};
 223
 224     fTPCConstrain = new THnSparseF("fTPCConstrain","pull_phi:phi:pt:eta",4, binsTPCConstrain,minTPCConstrain,maxTPCConstrain);
 225     fTPCConstrain->SetBinEdges(2,binsPt);
 226     fTPCConstrain->GetAxis(0)->SetTitle("(#phi-#phi_{ref})/#sigma");
 227     fTPCConstrain->GetAxis(1)->SetTitle("phi (rad)");
 228     fTPCConstrain->GetAxis(2)->SetTitle("p_{T}");
 229     fTPCConstrain->GetAxis(3)->SetTitle("eta");
 230     fTPCConstrain->Sumw2();
 231   }
 232
 233   // Init cuts
 234   if(!fCutsMC)
 235     AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");
 236   if(!fCutsRC)
 237     AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");
 238
 239   // init folder
 240   fAnalysisFolder = CreateFolder("folderMatch","Analysis Matching Folder");
 241
 242    // save merge status in object
 243   fMergeTHnSparseObj = fgMergeTHnSparse;
 244
 245   delete [] binsPt;
 246
 247 }
 248
 249 //_____________________________________________________________________________
 250 void AliPerformanceMatch::ProcessITSTPC(Int_t iTrack, AliESDEvent *const esdEvent, AliStack* /*const stack*/, AliESDtrack *const esdTrack)
 251 {
 252   //
 253   // addition to standard analysis - check if ITS stand-alone tracks have a match in the TPC
 254   // Origin: A. Kalwait
 255   // Modified: J. Otwinowski
 256   if(!esdEvent) return;
 257   if(!esdTrack) return;
 258   //  if(!esdFriendTrack) return;
 259
 260   // ITS stand alone tracks with SPD layers
 261   if(!(esdTrack->GetStatus() & AliESDtrack::kITSpureSA)) return;
 262   if(!(esdTrack->GetStatus() & AliESDtrack::kITSrefit)) return;
 263   if(esdTrack->GetNcls(0)<4) return;
 264    if(!esdTrack->HasPointOnITSLayer(0) && !esdTrack->HasPointOnITSLayer(1)) return;
 265
 266   const AliESDVertex* vtxESD = esdEvent->GetPrimaryVertexTracks();
 267   //   const AliESDVertex *vtxESD = esdEvent->GetPrimaryVertexTPC();
 268  AliESDtrack* tpcTrack2 = NULL;
 269   Bool_t hasMatch = kFALSE;
 270   for (Int_t jTrack = 0; jTrack < esdEvent->GetNumberOfTracks(); jTrack++) {
 271     // loop for all those tracks and check if the corresponding TPC track is found
 272     if (jTrack==iTrack) continue;
 273     AliESDtrack *trackTPC = esdEvent->GetTrack(jTrack);
 274     if (!trackTPC) continue;
 275     if (!trackTPC->GetTPCInnerParam()) continue;
 276     if(!(trackTPC->GetStatus() & AliESDtrack::kTPCrefit)) continue;
 277
 278     // TPC nClust/track after first tracking pass
 279     // if(trackTPC->GetTPCNclsIter1()<fCutsRC->GetMinNClustersTPC()) continue;
 280     tpcTrack2 = AliESDtrackCuts::GetTPCOnlyTrack(esdEvent, jTrack);
 281     if(!tpcTrack2) continue;
 282     if(!tpcTrack2->RelateToVertex(vtxESD,esdEvent->GetMagneticField(),100.)) { delete tpcTrack2; continue; }
 283
 284      if(!fCutsRC->AcceptTrack(tpcTrack2)) { delete tpcTrack2; continue; }
 285     // check matching
 286     if (TMath::Abs(esdTrack->GetY() - tpcTrack2->GetY()) > 3) { delete tpcTrack2; continue; }
 287     if (TMath::Abs(esdTrack->GetSnp() - tpcTrack2->GetSnp()) > 0.2) { delete tpcTrack2; continue; }
 288     if (TMath::Abs(esdTrack->GetTgl() - tpcTrack2->GetTgl()) > 0.2) { delete tpcTrack2; continue; }
 289
 290     hasMatch=kTRUE;
 291     break;
 292   }
 293
 294   FillHistograms(tpcTrack2,esdTrack,hasMatch);
 295   /*  if(tpcTrack2) {
 296     delete tpcTrack2;
 297
 298     }*/
 299 }
 300
 301 //_____________________________________________________________________________
 302 void AliPerformanceMatch::ProcessTPCITS(AliStack* /*const stack*/, AliESDtrack *const esdTrack)
 303 {
 304   //
 305   // Match TPC and ITS min-bias tracks
 306   // at radius between detectors
 307   //
 308   if(!esdTrack) return;
 309   //   if(!esdFriendTrack) return;
 310
 311   Bool_t isTPC = kFALSE;
 312   Bool_t isMatch = kFALSE;
 313
 314
 315   if(esdTrack->Charge()==0) return;
 316   if(!esdTrack->GetTPCInnerParam()) return;
 317   if(!(esdTrack->GetStatus()&AliESDtrack::kTPCrefit)) return;
 318
 319   if(!fCutsRC->AcceptTrack(esdTrack)) return;
 320
 321   isTPC = kTRUE;
 322
 323   if( (esdTrack->GetStatus()&AliESDtrack::kITSrefit))
 324     isMatch = kTRUE;
 325
 326   if(isTPC){
 327     Double_t vecTrackingEff[5] = { isMatch,esdTrack->Phi(), esdTrack->Pt(),esdTrack->Eta(),esdTrack->GetITSclusters(0) };
 328     fTrackingEffHisto->Fill(vecTrackingEff);
 329   }
 330 }
 331
 332 //_____________________________________________________________________________
 333 /*void AliPerformanceMatch::ProcessTPCTRD(AliStack* , AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack)
 334 {
 335   return;
 336 }*/
 337
 338 void AliPerformanceMatch::ProcessTPCConstrain(AliStack* /*const stack*/, AliESDEvent *const esdEvent, AliESDtrack *const esdTrack){
 339   //
 340   // Contrain TPC inner track to the vertex
 341   // then compare to the global tracks
 342   //
 343   if(!esdTrack) return;
 344   if(esdTrack->Charge()==0) return;
 345
 346   if(!esdTrack->GetTPCInnerParam()) return;
 347   if(!(esdTrack->GetStatus()&AliESDtrack::kITSrefit)) return;
 348   if(!(esdTrack->GetStatus()&AliESDtrack::kTPCrefit)) return;
 349   if(!fCutsRC->AcceptTrack(esdTrack)) return;
 350
 351   Double_t x[3]; esdTrack->GetXYZ(x);
 352   Double_t b[3]; AliTracker::GetBxByBz(x,b);
 353   Bool_t isOK = kFALSE;
 354   const AliESDVertex* vtxESD = esdEvent->GetPrimaryVertexTracks();
 355
 356   AliExternalTrackParam * TPCinner = (AliExternalTrackParam *)esdTrack->GetTPCInnerParam();
 357   if(!TPCinner) return;
 358
 359   //  isOK = TPCinner->Rotate(esdTrack->GetAlpha());
 360   //isOK = TPCinner->PropagateTo(esdTrack->GetX(),esdEvent->GetMagneticField());
 361
 362   AliExternalTrackParam * TPCinnerC = new AliExternalTrackParam(*TPCinner);
 363   if (TPCinnerC) {
 364     isOK = TPCinnerC->ConstrainToVertex(vtxESD, b);
 365
 366     // transform to the track reference frame
 367     isOK = TPCinnerC->Rotate(esdTrack->GetAlpha());
 368     isOK = TPCinnerC->PropagateTo(esdTrack->GetX(),esdEvent->GetMagneticField());
 369   }
 370   if(!isOK) return;
 371
 372   Double_t sigmaPhi=0,deltaPhi=0,pullPhi=0;
 373   deltaPhi = TPCinnerC->GetSnp() - esdTrack->GetSnp();
 374   sigmaPhi = TMath::Sqrt(esdTrack->GetSigmaSnp2()+TPCinnerC->GetSigmaSnp2());
 375   if(sigmaPhi!=0)
 376     pullPhi = deltaPhi/sigmaPhi;
 377
 378   Double_t vTPCConstrain[4] = {pullPhi,esdTrack->Phi(),esdTrack->Pt(),esdTrack->Eta()};
 379   fTPCConstrain->Fill(vTPCConstrain);
 380
 381   if(TPCinnerC)
 382     delete TPCinnerC;
 383
 384   return;
 385 }
 386 //_____________________________________________________________________________
 387 void AliPerformanceMatch::FillHistograms(AliESDtrack *const refParam, AliESDtrack *const param, Bool_t isRec)
 388 {
 389   //
 390   // fill performance histograms
 391   // (TPC always as reference)
 392   //
 393
 394   if(!refParam) return;
 395   if(!param) return;
 396   if(!isRec) return;
 397
 398   //
 399   // Deltas (dy,dz,dphi,dtheta,dpt)
 400   //
 401   Float_t delta[5] = {0};
 402   if(param && isRec) {
 403     delta[0] = param->GetY()-refParam->GetY();
 404     delta[1] = param->GetZ()-refParam->GetZ();
 405     delta[2] = TMath::ATan2(param->Py(),param->Px())-TMath::ATan2(refParam->Py(),refParam->Px());
 406     delta[3] = TMath::ATan2(param->Pz(),param->Pt())-TMath::ATan2(refParam->Pz(),refParam->Pt());
 407     if(refParam->Pt()) delta[4] = (param->Pt()-refParam->Pt())/refParam->Pt();
 408   }
 409   //
 410   // Pulls (y,z,snp,tanl,1/pt)
 411   //
 412   Float_t sigma[5] = {0};
 413   Float_t pull[5] = {0};
 414   if(param && isRec) {
 415     sigma[0] = TMath::Sqrt(param->GetSigmaY2()+refParam->GetSigmaY2());
 416     sigma[1] = TMath::Sqrt(param->GetSigmaZ2()+refParam->GetSigmaZ2());
 417     sigma[2] = TMath::Sqrt(param->GetSigmaSnp2()+refParam->GetSigmaSnp2());
 418     sigma[3] = TMath::Sqrt(param->GetSigmaTgl2()+refParam->GetSigmaTgl2());
 419     sigma[4] = TMath::Sqrt(param->GetSigma1Pt2()+refParam->GetSigma1Pt2());
 420     if(sigma[0]) pull[0] = delta[0] / sigma[0];
 421     if(sigma[1]) pull[1] = delta[1] / sigma[1];
 422     if(sigma[2]) pull[2] = (param->GetSnp()-refParam->GetSnp()) / sigma[2];
 423     if(sigma[3]) pull[3] = (param->GetTgl()-refParam->GetTgl()) / sigma[3];
 424     if(sigma[4]) pull[4] = (param->OneOverPt()-refParam->OneOverPt()) / sigma[4];
 425   }
 426
 427   // Fill histograms
 428   Double_t vResolHisto[9] = {delta[0],delta[1],delta[2],delta[3],delta[4],refParam->Phi(),refParam->Eta(),refParam->Pt(),isRec};
 429   if(fabs(pull[4])<5)
 430     fResolHisto->Fill(vResolHisto);
 431
 432   Double_t vPullHisto[9] = {pull[0],pull[1],pull[2],pull[3],pull[4],refParam->Phi(),refParam->Eta(),refParam->OneOverPt(),isRec};
 433   if(fabs(pull[4])<5)
 434     fPullHisto->Fill(vPullHisto);
 435 }
 436
 437 //_____________________________________________________________________________
 438 void AliPerformanceMatch::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend */*const esdFriend*/, const Bool_t bUseMC, const Bool_t /*bUseESDfriend*/)
 439 {
 440   // Process comparison information
 441   //
 442   if(!esdEvent)
 443   {
 444     Error("Exec","esdEvent not available");
 445     return;
 446   }
 447   AliHeader* header = 0;
 448   AliGenEventHeader* genHeader = 0;
 449   AliStack* stack = 0;
 450   TArrayF vtxMC(3);
 451
 452   if(bUseMC)
 453   {
 454     if(!mcEvent) {
 455       Error("Exec","mcEvent not available");
 456       return;
 457     }
 458     // get MC event header
 459     header = mcEvent->Header();
 460     if (!header) {
 461       Error("Exec","Header not available");
 462       return;
 463     }
 464     // MC particle stack
 465     stack = mcEvent->Stack();
 466     if (!stack) {
 467       Error("Exec","Stack not available");
 468       return;
 469     }
 470     // get MC vertex
 471     genHeader = header->GenEventHeader();
 472     if (!genHeader) {
 473       Error("Exec","Could not retrieve genHeader from Header");
 474       return;
 475     }
 476     genHeader->PrimaryVertex(vtxMC);
 477   }
 478
 479   // use ESD friends
 480   /*  if(bUseESDfriend) {
 481     if(!esdFriend) {
 482       Error("Exec","esdFriend not available");
 483       return;
 484     }
 485     }*/
 486
 487   // trigger
 488   if(!bUseMC && GetTriggerClass()) {
 489     Bool_t isEventTriggered = esdEvent->IsTriggerClassFired(GetTriggerClass());
 490     if(!isEventTriggered) return;
 491   }
 492
 493   // get TPC event vertex
 494   const AliESDVertex *vtxESD = esdEvent->GetPrimaryVertexTPC();
 495   if(vtxESD && (vtxESD->GetStatus()<=0)) return;
 496
 497   //  Process events
 498   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
 499   {
 500     AliESDtrack *track = esdEvent->GetTrack(iTrack);
 501     if(!track) continue;
 502
 503     /*AliESDfriendTrack *friendTrack=0;
 504     if(bUseESDfriend) {
 505       friendTrack=esdFriend->GetTrack(iTrack);
 506       if(!friendTrack) continue;
 507       }*/
 508
 509     if(GetAnalysisMode() == 0){
 510       if(!IsUseTOFBunchCrossing()){
 511         ProcessTPCITS(stack,track);
 512       }
 513       else
 514         if( track->GetTOFBunchCrossing(esdEvent->GetMagneticField())==0) {
 515           ProcessTPCITS(stack,track);
 516         }
 517     }
 518     /* else if(GetAnalysisMode() == 2) ProcessTPCTRD(stack,track,friendTrack);*/
 519     else if(GetAnalysisMode() == 1) {ProcessITSTPC(iTrack,esdEvent,stack,track);}
 520     else if(GetAnalysisMode() == 2){
 521       if(!IsUseTOFBunchCrossing()){
 522         ProcessTPCConstrain(stack,esdEvent,track);
 523       }
 524       else
 525         if( track->GetTOFBunchCrossing(esdEvent->GetMagneticField())==0) {
 526           ProcessTPCConstrain(stack,esdEvent,track);
 527         }
 528     }
 529     else {
 530       printf("ERROR: AnalysisMode %d \n",fAnalysisMode);
 531       return;
 532     }
 533   }
 534
 535 }
 536
 537 //_____________________________________________________________________________
 538 TH1F* AliPerformanceMatch::MakeResol(TH2F * his, Int_t integ, Bool_t type, Int_t cut){
 539   // Create resolution histograms
 540
 541   TH1F *hisr, *hism;
 542   if (!gPad) new TCanvas;
 543   hisr = AliTreeDraw::CreateResHistoII(his,&hism,integ,kTRUE,cut);
 544   if (type) return hism;
 545   else
 546     return hisr;
 547 }
 548
 549 //_____________________________________________________________________________
 550 void AliPerformanceMatch::Analyse() {
 551   // Analyse comparison information and store output histograms
 552   // in the folder "folderMatch"
 553   //
 554   TString selString;
 555   /*
 556   TH1::AddDirectory(kFALSE);
 557   TH1F *h=0;
 558   TH1F *h2=0;
 559   TH2F *h2D=0;
 560   */
 561   TObjArray *aFolderObj = new TObjArray;
 562
 563   // write results in the folder
 564   // TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan");
 565   // c->cd();
 566
 567   // char name[256];
 568   // char title[256];
 569
 570   if(GetAnalysisMode()==1) {
 571
 572   fResolHisto->GetAxis(8)->SetRangeUser(1.0,2.0); // only reconstructed
 573   fPullHisto->GetAxis(8)->SetRangeUser(1.0,2.0);  // only reconstructed
 574   for(Int_t i=0; i<5; i++)
 575     {
 576       for(Int_t j=5; j<8; j++)
 577         {
 578           //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window
 579           if(j!=6) fResolHisto->GetAxis(6)->SetRangeUser(0.0,1.49); // eta window
 580           else fResolHisto->GetAxis(6)->SetRangeUser(-1.5,1.49);
 581           fResolHisto->GetAxis(7)->SetRangeUser(0.01,10.); // pt threshold
 582
 583           selString = "resol";
 584           AddProjection(aFolderObj, "match", fResolHisto, i, j, &selString);
 585
 586
 587           if(j!=6) fPullHisto->GetAxis(6)->SetRangeUser(0.0,1.49); // eta window
 588           else  fPullHisto->GetAxis(6)->SetRangeUser(-1.5,1.49); // eta window
 589           fPullHisto->GetAxis(7)->SetRangeUser(0.01,10.);  // pt threshold
 590           selString = "pull";
 591           AddProjection(aFolderObj, "match", fPullHisto, i, j, &selString);
 592
 593         }
 594     }
 595   }
 596   //
 597   // TPC efficiency wrt ITS
 598   //
 599   if(GetAnalysisMode()==0) {
 600     selString = "trackingeff";
 601     AddProjection(aFolderObj, "match", fTrackingEffHisto, 0, &selString);
 602
 603     for(Int_t i=1; i<5; i++)
 604       {
 605         // all ITS standalone tracks
 606         fTrackingEffHisto->GetAxis(0)->SetRange(1,fTrackingEffHisto->GetAxis(0)->GetNbins());
 607         selString = "trackingeff_all";
 608         AddProjection(aFolderObj, "match", fTrackingEffHisto, i, 3,&selString);
 609
 610       // TPC tracks which has matching with TPC
 611         fTrackingEffHisto->GetAxis(0)->SetRange(2,2);
 612         selString = "trackingeff_tpc";
 613         AddProjection(aFolderObj, "match", fTrackingEffHisto, i, 3,&selString);
 614       }
 615   }
 616
 617   //
 618   //TPC constrained to vertex
 619   //
 620   if(GetAnalysisMode()==2) {
 621     selString = "tpc";
 622     //    for(Int_t i=1; i<4; i++)
 623     AddProjection(aFolderObj, "constrain", fTPCConstrain, 0, 1, 2, &selString);
 624     AddProjection(aFolderObj, "constrain", fTPCConstrain, 0, 1, 3, &selString);
 625     AddProjection(aFolderObj, "constrain", fTPCConstrain, 0, 2, 3, &selString);
 626   }
 627
 628   printf("exportToFolder\n");
 629   fAnalysisFolder = ExportToFolder(aFolderObj);
 630
 631   // delete only TObjArray
 632   if(fFolderObj) delete fFolderObj;
 633   fFolderObj = aFolderObj;
 634   aFolderObj=0;
 635
 636   }
 637
 638
 639 //_____________________________________________________________________________
 640 TFolder* AliPerformanceMatch::ExportToFolder(TObjArray * array)
 641 {
 642   // recreate folder avery time and export objects to new one
 643   //
 644   AliPerformanceMatch * comp=this;
 645   TFolder *folder = comp->GetAnalysisFolder();
 646
 647   TString name, title;
 648   TFolder *newFolder = 0;
 649   Int_t i = 0;
 650   Int_t size = array->GetSize();
 651
 652   if(folder) {
 653      // get name and title from old folder
 654      name = folder->GetName();
 655      title = folder->GetTitle();
 656
 657          // delete old one
 658      delete folder;
 659
 660          // create new one
 661      newFolder = CreateFolder(name.Data(),title.Data());
 662      newFolder->SetOwner();
 663
 664          // add objects to folder
 665      while(i < size) {
 666        newFolder->Add(array->At(i));
 667        i++;
 668      }
 669   }
 670
 671   return newFolder;
 672 }
 673
 674 //_____________________________________________________________________________
 675 TFolder* AliPerformanceMatch::CreateFolder(TString name,TString title) {
 676 // create folder for analysed histograms
 677 //
 678 TFolder *folder = 0;
 679   folder = new TFolder(name.Data(),title.Data());
 680
 681   return folder;
 682 }
 683
 684 //_____________________________________________________________________________
 685 Long64_t AliPerformanceMatch::Merge(TCollection* const list)
 686 {
 687   // Merge list of objects (needed by PROOF)
 688
 689   if (!list)
 690   return 0;
 691
 692   if (list->IsEmpty())
 693   return 1;
 694
 695   Bool_t merge = ((fgUseMergeTHnSparse && fgMergeTHnSparse) || (!fgUseMergeTHnSparse && fMergeTHnSparseObj));
 696
 697   TIterator* iter = list->MakeIterator();
 698   TObject* obj = 0;
 699   TObjArray* objArrayList = 0;
 700   objArrayList = new TObjArray();
 701
 702   // collection of generated histograms
 703   Int_t count=0;
 704   while((obj = iter->Next()) != 0)
 705   {
 706     AliPerformanceMatch* entry = dynamic_cast<AliPerformanceMatch*>(obj);
 707     if (entry == 0) continue;
 708     if (merge) {
 709         if ((fResolHisto) && (entry->fResolHisto)) { fResolHisto->Add(entry->fResolHisto); }
 710         if ((fPullHisto) && (entry->fPullHisto)) { fPullHisto->Add(entry->fPullHisto); }
 711         if ((fTrackingEffHisto) && (entry->fTrackingEffHisto)) { fTrackingEffHisto->Add(entry->fTrackingEffHisto); }
 712
 713         if ((fTPCConstrain) && (entry->fTPCConstrain)) { fTPCConstrain->Add(entry->fTPCConstrain); }
 714     }
 715     // the analysisfolder is only merged if present
 716     if (entry->fFolderObj) { objArrayList->Add(entry->fFolderObj); }
 717
 718     count++;
 719   }
 720   if (fFolderObj) { fFolderObj->Merge(objArrayList); }
 721   // to signal that track histos were not merged: reset
 722   if (!merge) { fResolHisto->Reset(); fPullHisto->Reset(); fTrackingEffHisto->Reset(); fTPCConstrain->Reset(); }
 723   // delete
 724   if (objArrayList)  delete objArrayList;  objArrayList=0;
 725 return count;
 726 }