PWG0/dNdPt/AlidNdPtHelper.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 //
  16 // static dNdPt helper functions
  17 //
  18 // basic functionality to select events and tracks
  19 // for dNdPt analysis
  20 //
  21 // Origin: Jan Fiete Grosse-Oetringhaus
  22 // Modified and Extended: Jacek Otwinowski 19/11/2009
  23 //
  24 //
  25
  26 #include <TROOT.h>
  27 #include <TCanvas.h>
  28 #include <TF1.h>
  29 #include <TH1.h>
  30 #include <TH2.h>
  31 #include <TH3.h>
  32
  33 #include <AliHeader.h>
  34 #include <AliStack.h>
  35 #include <AliLog.h>
  36 #include <AliESD.h>
  37 #include <AliESDEvent.h>
  38 #include <AliMCEvent.h>
  39 #include <AliESDVertex.h>
  40 #include <AliVertexerTracks.h>
  41 #include <AliMathBase.h>
  42 #include <AliESDtrackCuts.h>
  43 #include "dNdPt/AlidNdPtEventCuts.h"
  44 #include "dNdPt/AlidNdPtAcceptanceCuts.h"
  45 #include "dNdPt/AlidNdPtHelper.h"
  46
  47 //____________________________________________________________________
  48 ClassImp(AlidNdPtHelper)
  49
  50 //____________________________________________________________________
  51 const AliESDVertex* AlidNdPtHelper::GetVertex(AliESDEvent* const aEsd, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts, AnalysisMode analysisMode, Bool_t debug, Bool_t bRedoTPC, Bool_t bUseMeanVertex)
  52 {
  53   // Get the vertex from the ESD and returns it if the vertex is valid
  54   //
  55   // Second argument decides which vertex is used (this selects
  56   // also the quality criteria that are applied)
  57
  58   if(!aEsd)
  59   {
  60     ::Error("AlidNdPtHelper::GetVertex()","esd event is NULL");
  61     return NULL;
  62   }
  63
  64   if(!evtCuts || !accCuts || !trackCuts)
  65   {
  66     ::Error("AlidNdPtHelper::GetVertex()","cuts not available");
  67     return NULL;
  68   }
  69
  70   const AliESDVertex* vertex = 0;
  71   AliESDVertex *initVertex = 0;
  72   if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate)
  73   {
  74     vertex = aEsd->GetPrimaryVertexSPD();
  75     if (debug)
  76       Printf("AlidNdPtHelper::GetVertex: Returning SPD vertex");
  77   }
  78   else if (analysisMode == kTPC)
  79   {
  80     if(bRedoTPC) {
  81
  82       Double_t kBz = aEsd->GetMagneticField();
  83       AliVertexerTracks vertexer(kBz);
  84
  85       if(bUseMeanVertex) {
  86          Double_t pos[3]={evtCuts->GetMeanXv(),evtCuts->GetMeanYv(),evtCuts->GetMeanZv()};
  87          Double_t err[3]={evtCuts->GetSigmaMeanXv(),evtCuts->GetSigmaMeanYv(),evtCuts->GetSigmaMeanZv()};
  88          initVertex = new AliESDVertex(pos,err);
  89          vertexer.SetVtxStart(initVertex);
  90          vertexer.SetConstraintOn();
  91       }
  92
  93       Double_t maxDCAr = accCuts->GetMaxDCAr();
  94       Double_t maxDCAz = accCuts->GetMaxDCAz();
  95       Int_t minTPCClust = trackCuts->GetMinNClusterTPC();
  96
  97       //vertexer.SetTPCMode(Double_t dcacut=0.1, Double_t dcacutIter0=1.0, Double_t maxd0z0=5.0, Int_t minCls=10, Int_t mintrks=1, Double_t nsigma=3., Double_t mindetfitter=0.1, Double_t maxtgl=1.5, Double_t fidR=3., Double_t fidZ=30., Int_t finderAlgo=1, Int_t finderAlgoIter0=4);
  98       vertexer.SetTPCMode(0.1,1.0,5.0,minTPCClust,1,3.,0.1,2.0,maxDCAr,maxDCAz,1,4);
  99
 100       // TPC track preselection
 101       Int_t ntracks = aEsd->GetNumberOfTracks();
 102       TObjArray array(ntracks);
 103       UShort_t *id = new UShort_t[ntracks];
 104
 105       Int_t count=0;
 106       for (Int_t i=0;i <ntracks; i++) {
 107         AliESDtrack *t = aEsd->GetTrack(i);
 108         if (!t) continue;
 109         if (t->Charge() == 0) continue;
 110         if (!t->GetTPCInnerParam()) continue;
 111         if (t->GetTPCNcls()<vertexer.GetMinClusters()) continue;
 112         AliExternalTrackParam  *tpcTrack  = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
 113         if(tpcTrack) {
 114           array.AddLast(tpcTrack);
 115           id[count] = (UShort_t)t->GetID();
 116           count++;
 117         }
 118       }
 119       AliESDVertex *vTPC = vertexer.VertexForSelectedTracks(&array,id, kTRUE, kTRUE, bUseMeanVertex);
 120
 121       // set recreated TPC vertex
 122       aEsd->SetPrimaryVertexTPC(vTPC);
 123
 124       for (Int_t i=0; i<aEsd->GetNumberOfTracks(); i++) {
 125         AliESDtrack *t = aEsd->GetTrack(i);
 126         t->RelateToVertexTPC(vTPC, kBz, kVeryBig);
 127       }
 128
 129       delete vTPC;
 130       array.Delete();
 131       delete [] id; id=NULL;
 132
 133     }
 134     vertex = aEsd->GetPrimaryVertexTPC();
 135     if (debug)
 136       Printf("AlidNdPtHelper::GetVertex: Returning vertex from tracks");
 137     }
 138       else
 139        Printf("AlidNdPtHelper::GetVertex: ERROR: Invalid second argument %d", analysisMode);
 140
 141     if (!vertex) {
 142      if (debug)
 143       Printf("AlidNdPtHelper::GetVertex: No vertex found in ESD");
 144       return 0;
 145     }
 146
 147   if (debug)
 148   {
 149     Printf("AlidNdPtHelper::GetVertex: Returning valid vertex: %s", vertex->GetTitle());
 150     vertex->Print();
 151   }
 152
 153   if(initVertex) delete initVertex; initVertex=NULL;
 154   return vertex;
 155 }
 156
 157 //____________________________________________________________________
 158 Bool_t AlidNdPtHelper::TestRecVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug)
 159 {
 160   // Checks if a vertex meets the needed quality criteria
 161   if(!vertex) return kFALSE;
 162
 163   Float_t requiredZResolution = -1;
 164   if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate)
 165   {
 166     requiredZResolution = 0.1;
 167   }
 168   else if (analysisMode == kTPC)
 169     requiredZResolution = 10.;
 170
 171   // check Ncontributors
 172   if (vertex->GetNContributors() <= 0) {
 173     if (debug){
 174       Printf("AlidNdPtHelper::GetVertex: NContributors() <= 0: %d",vertex->GetNContributors());
 175       Printf("AlidNdPtHelper::GetVertex: NIndices(): %d",vertex->GetNIndices());
 176       vertex->Print();
 177     }
 178     return kFALSE;
 179   }
 180
 181   // check resolution
 182   Double_t zRes = vertex->GetZRes();
 183   if ((zRes-0.000000001) < 0.0) {
 184     Printf("AlidNdPtHelper::GetVertex: UNEXPECTED: resolution is 0.");
 185     return kFALSE;
 186   }
 187
 188   if (zRes > requiredZResolution) {
 189     if (debug)
 190       Printf("AlidNdPtHelper::TestVertex: Resolution too poor %f (required: %f", zRes, requiredZResolution);
 191     return kFALSE;
 192   }
 193
 194   return kTRUE;
 195 }
 196
 197 //____________________________________________________________________
 198 Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* const stack, Int_t idx, ParticleMode particleMode)
 199 {
 200 // check primary particles
 201 // depending on the particle mode
 202 //
 203   if(!stack) return kFALSE;
 204
 205   TParticle* particle = stack->Particle(idx);
 206   if (!particle) return  kFALSE;
 207
 208   // only charged particles
 209   Double_t charge = particle->GetPDG()->Charge()/3.;
 210   if (TMath::Abs(charge) < 0.001) return kFALSE;
 211
 212   Int_t pdg = TMath::Abs(particle->GetPdgCode());
 213
 214   // physical primary
 215   Bool_t prim = stack->IsPhysicalPrimary(idx);
 216
 217   if(particleMode==kMCPion) {
 218     if(prim && pdg==kPiPlus) return kTRUE;
 219     else return kFALSE;
 220   }
 221
 222   if (particleMode==kMCKaon) {
 223     if(prim && pdg==kKPlus) return kTRUE;
 224     else return kFALSE;
 225   }
 226
 227   if (particleMode==kMCProton) {
 228     if(prim && pdg==kProton) return kTRUE;
 229     else return kFALSE;
 230   }
 231
 232 return prim;
 233 }
 234
 235 //____________________________________________________________________
 236 /*
 237 Bool_t AlidNdPtHelper::IsCosmicTrack(TObjArray *const allChargedTracks, AliESDtrack *const track1, Int_t trackIdx, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts)
 238 {
 239 //
 240 // check cosmic tracks
 241 //
 242   if(!allChargedTracks) return kFALSE;
 243   if(!track1) return kFALSE;
 244   if(!accCuts) return kFALSE;
 245   if(!trackCuts) return kFALSE;
 246
 247   Int_t entries = allChargedTracks->GetEntries();
 248   for(Int_t i=0; i<entries;++i)
 249   {
 250       //
 251       // exclude the same tracks
 252       //
 253       if(i == trackIdx) continue;
 254
 255       AliESDtrack *track2 = (AliESDtrack*)allChargedTracks->At(i);
 256       if(!track2) continue;
 257       if(track2->Charge()==0) continue;
 258
 259       if(track1->Pt() > 6. && track2->Pt() > 6. && (track1->Charge() + track2->Charge()) == 0 )
 260       {
 261         printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
 262         printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
 263
 264         printf("deta %f, dphi %f, dq %d  \n", track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge());
 265
 266       }
 267
 268       //
 269       // cosmic tracks in TPC
 270       //
 271       //if( TMath::Abs( track1->Theta() - track2->Theta() ) < 0.004  &&
 272       //  ((TMath::Abs(track1->Phi()-track2->Phi()) - TMath::Pi() )<0.004) &&
 273       if( (track1->Pt()-track2->Pt()) < 0.1 && track1->Pt() > 4.0 && (track1->Charge()+track2->Charge()) == 0 )
 274       {
 275         //printf("COSMIC  candidate \n");
 276         printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
 277         printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
 278         printf("dtheta %f, deta %f, dphi %f, dq %d  \n", track1->Theta()-track2->Theta(),  track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge());
 279         return kTRUE;
 280       }
 281    }
 282
 283 return kFALSE;
 284 }
 285 */
 286
 287 //____________________________________________________________________
 288 Bool_t AlidNdPtHelper::IsCosmicTrack(AliESDtrack *const track1, AliESDtrack *const track2)
 289 {
 290 //
 291 // check cosmic tracks
 292 //
 293   if(!track1) return kFALSE;
 294   if(!track2) return kFALSE;
 295
 296   /*
 297   if(track1->Pt() > 6. && track2->Pt() > 6. && (track1->Charge() + track2->Charge()) == 0 )
 298   {
 299         printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
 300         printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
 301
 302         printf("deta %f, dphi %f, dq %d  \n", track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge());
 303
 304       }
 305       */
 306
 307       //
 308       // cosmic tracks in TPC
 309       //
 310       //if( TMath::Abs( track1->Theta() - track2->Theta() ) < 0.004  &&
 311       //  ((TMath::Abs(track1->Phi()-track2->Phi()) - TMath::Pi() )<0.004) &&
 312
 313       if( (track1->Pt()-track2->Pt()) < 0.2 && track1->Pt() > 3.0 &&
 314              (track1->Charge()+track2->Charge()) == 0 )
 315       //if( track1->Pt() > 6. || track2->Pt() > 6. )
 316       {
 317         //printf("COSMIC  candidate \n");
 318         /*
 319         printf("track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d  \n", track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
 320         printf("track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d  \n", track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
 321         printf("dtheta %f, deta %f, dphi %f, dq %d  \n", track1->Theta()-track2->Theta(),  track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge());
 322         */
 323         return kTRUE;
 324       }
 325
 326 return kFALSE;
 327 }
 328
 329 //____________________________________________________________________
 330 void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger)
 331 {
 332   //
 333   // Prints the given configuration
 334   //
 335
 336   TString str(">>>> Running with ");
 337
 338   switch (analysisMode)
 339   {
 340     case kInvalid: str += "invalid setting"; break;
 341     case kSPD : str += "SPD-only"; break;
 342     case kTPC : str += "TPC-only"; break;
 343     case kTPCITS : str += "Global tracking"; break;
 344     case kTPCSPDvtx : str += "TPC tracking + SPD event vertex"; break;
 345     case kTPCSPDvtxUpdate : str += "TPC tracks updated with SPD event vertex point"; break;
 346     case kMCRec : str += "TPC tracking + Replace rec. with MC values"; break;
 347   }
 348   str += " and trigger ";
 349
 350   str += AliTriggerAnalysis::GetTriggerName(trigger);
 351
 352   str += " <<<<";
 353
 354   Printf("%s", str.Data());
 355 }
 356
 357 //____________________________________________________________________
 358 Int_t AlidNdPtHelper::ConvertPdgToPid(TParticle *particle) {
 359 //
 360 // Convert Abs(pdg) to pid
 361 // (0 - e, 1 - muons, 2 - pions, 3 - kaons, 4 - protons, 5 -all rest)
 362 //
 363 Int_t pid=-1;
 364
 365   if (TMath::Abs(particle->GetPdgCode()) == kElectron)         { pid = 0; }
 366   else if (TMath::Abs(particle->GetPdgCode()) == kMuonMinus) { pid = 1; }
 367   else if (TMath::Abs(particle->GetPdgCode()) == kPiPlus)    { pid = 2; }
 368   else if (TMath::Abs(particle->GetPdgCode()) == kKPlus)     { pid = 3; }
 369   else if (TMath::Abs(particle->GetPdgCode()) == kProton)    { pid = 4; }
 370   else                                                       { pid = 5; }
 371
 372 return pid;
 373 }
 374
 375 //_____________________________________________________________________________
 376 TH1F* AlidNdPtHelper::CreateResHisto(TH2F* const hRes2, TH1F **phMean, Int_t integ,  Bool_t drawBinFits, Int_t minHistEntries)
 377 {
 378 //
 379 // Create mean and resolution
 380 // histograms
 381 //
 382   TVirtualPad* currentPad = gPad;
 383   TAxis* axis = hRes2->GetXaxis();
 384   Int_t nBins = axis->GetNbins();
 385   Bool_t overflowBinFits = kFALSE;
 386   TH1F* hRes, *hMean;
 387   if (axis->GetXbins()->GetSize()){
 388     hRes = new TH1F("hRes", "", nBins, axis->GetXbins()->GetArray());
 389     hMean = new TH1F("hMean", "", nBins, axis->GetXbins()->GetArray());
 390   }
 391   else{
 392     hRes = new TH1F("hRes", "", nBins, axis->GetXmin(), axis->GetXmax());
 393     hMean = new TH1F("hMean", "", nBins, axis->GetXmin(), axis->GetXmax());
 394
 395   }
 396   hRes->SetStats(false);
 397   hRes->SetOption("E");
 398   hRes->SetMinimum(0.);
 399   //
 400   hMean->SetStats(false);
 401   hMean->SetOption("E");
 402
 403   // create the fit function
 404   TF1 * fitFunc = new TF1("G","[0]*exp(-(x-[1])*(x-[1])/(2.*[2]*[2]))",-3,3);
 405
 406   fitFunc->SetLineWidth(2);
 407   fitFunc->SetFillStyle(0);
 408   // create canvas for fits
 409   TCanvas* canBinFits = NULL;
 410   Int_t nPads = (overflowBinFits) ? nBins+2 : nBins;
 411   Int_t nx = Int_t(sqrt(nPads-1.));// + 1;
 412   Int_t ny = (nPads-1) / nx + 1;
 413   if (drawBinFits) {
 414     canBinFits = (TCanvas*)gROOT->FindObject("canBinFits");
 415     if (canBinFits) delete canBinFits;
 416     canBinFits = new TCanvas("canBinFits", "fits of bins", 200, 100, 500, 700);
 417     canBinFits->Divide(nx, ny);
 418   }
 419
 420   // loop over x bins and fit projection
 421   Int_t dBin = ((overflowBinFits) ? 1 : 0);
 422   for (Int_t bin = 1-dBin; bin <= nBins+dBin; bin++) {
 423     if (drawBinFits) canBinFits->cd(bin + dBin);
 424     Int_t bin0=TMath::Max(bin-integ,0);
 425     Int_t bin1=TMath::Min(bin+integ,nBins);
 426     TH1D* hBin = hRes2->ProjectionY("hBin", bin0, bin1);
 427     //
 428     if (hBin->GetEntries() > minHistEntries) {
 429       fitFunc->SetParameters(hBin->GetMaximum(),hBin->GetMean(),hBin->GetRMS());
 430       hBin->Fit(fitFunc,"s");
 431       Double_t sigma = TMath::Abs(fitFunc->GetParameter(2));
 432
 433       if (sigma > 0.){
 434         hRes->SetBinContent(bin, TMath::Abs(fitFunc->GetParameter(2)));
 435         hMean->SetBinContent(bin, fitFunc->GetParameter(1));
 436       }
 437       else{
 438         hRes->SetBinContent(bin, 0.);
 439         hMean->SetBinContent(bin,0);
 440       }
 441       hRes->SetBinError(bin, fitFunc->GetParError(2));
 442       hMean->SetBinError(bin, fitFunc->GetParError(1));
 443
 444       //
 445       //
 446
 447     } else {
 448       hRes->SetBinContent(bin, 0.);
 449       hRes->SetBinError(bin, 0.);
 450       hMean->SetBinContent(bin, 0.);
 451       hMean->SetBinError(bin, 0.);
 452     }
 453
 454
 455     if (drawBinFits) {
 456       char name[256];
 457       if (bin == 0) {
 458         sprintf(name, "%s < %.4g", axis->GetTitle(), axis->GetBinUpEdge(bin));
 459       } else if (bin == nBins+1) {
 460         sprintf(name, "%.4g < %s", axis->GetBinLowEdge(bin), axis->GetTitle());
 461       } else {
 462         sprintf(name, "%.4g < %s < %.4g", axis->GetBinLowEdge(bin),
 463                 axis->GetTitle(), axis->GetBinUpEdge(bin));
 464       }
 465       canBinFits->cd(bin + dBin);
 466       hBin->SetTitle(name);
 467       hBin->SetStats(kTRUE);
 468       hBin->DrawCopy("E");
 469       canBinFits->Update();
 470       canBinFits->Modified();
 471       canBinFits->Update();
 472     }
 473
 474     delete hBin;
 475   }
 476
 477   delete fitFunc;
 478   currentPad->cd();
 479   *phMean = hMean;
 480   return hRes;
 481 }
 482
 483 //_____________________________________________________________________________
 484 TH1F* AlidNdPtHelper::MakeResol(TH2F * his, Int_t integ, Bool_t type, Bool_t drawBins, Int_t minHistEntries){
 485 // Create resolution histograms
 486
 487      TH1F *hisr=0, *hism=0;
 488      if (!gPad) new TCanvas;
 489          hisr = CreateResHisto(his,&hism,integ,drawBins,minHistEntries);
 490          if (type) return hism;
 491          else return hisr;
 492
 493 return hisr;
 494 }
 495
 496 //_____________________________________________________________________________
 497 TObjArray* AlidNdPtHelper::GetAllChargedTracks(AliESDEvent *esdEvent, AnalysisMode analysisMode)
 498 {
 499   //
 500   // all charged TPC particles
 501   //
 502   TObjArray *allTracks = new TObjArray();
 503   if(!allTracks) return allTracks;
 504
 505   AliESDtrack *track=0;
 506   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
 507   {
 508     if(analysisMode == AlidNdPtHelper::kTPC) {
 509       // track must be deleted by user
 510       track = AliESDtrackCuts::GetTPCOnlyTrack(esdEvent,iTrack);
 511       if(!track) continue;
 512     }
 513     else if (analysisMode == AlidNdPtHelper::kTPCSPDvtx || AlidNdPtHelper::kTPCSPDvtxUpdate)
 514     {
 515       // track must be deleted by the user
 516       track = AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(esdEvent,iTrack,kFALSE);
 517       if(!track) continue;
 518     }
 519     else {
 520       track=esdEvent->GetTrack(iTrack);
 521     }
 522     if(!track) continue;
 523
 524     if(track->Charge()==0) {
 525       if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
 526          analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate)
 527       {
 528         delete track; continue;
 529       } else {
 530         continue;
 531       }
 532     }
 533
 534     allTracks->Add(track);
 535   }
 536
 537   if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
 538      analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate) {
 539
 540      allTracks->SetOwner(kTRUE);
 541   }
 542
 543 return allTracks;
 544 }
 545
 546 //_____________________________________________________________________________
 547 AliESDtrack *AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(AliESDEvent* esdEvent, Int_t iTrack, Bool_t bUpdate)
 548 {
 549 //
 550 // Create ESD tracks from TPCinner parameters.
 551 // Propagte to DCA to SPD vertex.
 552 // Update using SPD vertex point (parameter)
 553 //
 554 // It is user responsibility to delete these tracks
 555 //
 556
 557   if (!esdEvent) return NULL;
 558   if (!esdEvent->GetPrimaryVertexSPD() ) { return NULL; }
 559   if (!esdEvent->GetPrimaryVertexSPD()->GetStatus() ) { return  NULL; }
 560
 561   //
 562   AliESDtrack* track = esdEvent->GetTrack(iTrack);
 563   if (!track)
 564     return NULL;
 565
 566   // create new ESD track
 567   AliESDtrack *tpcTrack = new AliESDtrack();
 568
 569   // relate TPC-only tracks (TPCinner) to SPD vertex
 570   AliExternalTrackParam cParam;
 571   if(bUpdate) {
 572     track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(),esdEvent->GetMagneticField(),kVeryBig,&cParam);
 573     track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());
 574
 575     // reject fake tracks
 576     if(track->Pt() > 10000.)  {
 577       ::Error("Exclude no physical tracks","pt>10000. GeV");
 578       delete tpcTrack;
 579       return NULL;
 580     }
 581   }
 582   else {
 583     track->RelateToVertexTPC(esdEvent->GetPrimaryVertexSPD(), esdEvent->GetMagneticField(), kVeryBig);
 584   }
 585
 586   // only true if we have a tpc track
 587   if (!track->FillTPCOnlyTrack(*tpcTrack))
 588   {
 589     delete tpcTrack;
 590     return NULL;
 591   }
 592
 593 return tpcTrack;
 594 }
 595
 596 //_____________________________________________________________________________
 597 Int_t AlidNdPtHelper::GetTPCMBTrackMult(AliESDEvent *const esdEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts)
 598 {
 599   //
 600   // get MB event track multiplicity
 601   //
 602   if(!esdEvent)
 603   {
 604     ::Error("AlidNdPtHelper::GetTPCMBTrackMult()","esd event is NULL");
 605     return 0;
 606   }
 607
 608   if(!evtCuts || !accCuts || !trackCuts)
 609   {
 610     ::Error("AlidNdPtHelper::GetTPCMBTrackMult()","cuts not available");
 611     return 0;
 612   }
 613
 614   //
 615   Double_t pos[3]={evtCuts->GetMeanXv(),evtCuts->GetMeanYv(),evtCuts->GetMeanZv()};
 616   Double_t err[3]={evtCuts->GetSigmaMeanXv(),evtCuts->GetSigmaMeanYv(),evtCuts->GetSigmaMeanZv()};
 617   AliESDVertex vtx0(pos,err);
 618
 619   //
 620   Float_t maxDCAr = accCuts->GetMaxDCAr();
 621   Float_t maxDCAz = accCuts->GetMaxDCAz();
 622   Float_t minTPCClust = trackCuts->GetMinNClusterTPC();
 623   //
 624   Int_t ntracks = esdEvent->GetNumberOfTracks();
 625   Double_t dca[2],cov[3];
 626   Int_t mult=0;
 627   for (Int_t i=0;i <ntracks; i++){
 628     AliESDtrack *t = esdEvent->GetTrack(i);
 629     if (!t) continue;
 630     if (t->Charge() == 0) continue;
 631     if (!t->GetTPCInnerParam()) continue;
 632     if (t->GetTPCNcls()<minTPCClust) continue;
 633     //
 634     AliExternalTrackParam  *tpcTrack  = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
 635     if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov))
 636     {
 637       if(tpcTrack) delete tpcTrack;
 638       continue;
 639     }
 640     //
 641     if (TMath::Abs(dca[0])>maxDCAr || TMath::Abs(dca[1])>maxDCAz) {
 642       if(tpcTrack) delete tpcTrack;
 643       continue;
 644     }
 645
 646     mult++;
 647
 648     if(tpcTrack) delete tpcTrack;
 649   }
 650
 651 return mult;
 652 }
 653
 654 //_____________________________________________________________________________
 655 Int_t AlidNdPtHelper::GetTPCMBPrimTrackMult(AliESDEvent *const esdEvent, AliStack *const  stack, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts)
 656 {
 657   //
 658   // get MB primary event track multiplicity
 659   //
 660   if(!esdEvent)
 661   {
 662     ::Error("AlidNdPtHelper::GetTPCMBPrimTrackMult()","esd event is NULL");
 663     return 0;
 664   }
 665
 666   if(!stack)
 667   {
 668     ::Error("AlidNdPtHelper::GetTPCMBPrimTrackMult()","esd event is NULL");
 669     return 0;
 670   }
 671
 672   if(!evtCuts || !accCuts || !trackCuts)
 673   {
 674     ::Error("AlidNdPtHelper::GetTPCMBPrimTrackMult()","cuts not available");
 675     return 0;
 676   }
 677
 678   //
 679   Double_t pos[3]={evtCuts->GetMeanXv(),evtCuts->GetMeanYv(),evtCuts->GetMeanZv()};
 680   Double_t err[3]={evtCuts->GetSigmaMeanXv(),evtCuts->GetSigmaMeanYv(),evtCuts->GetSigmaMeanZv()};
 681   AliESDVertex vtx0(pos,err);
 682
 683   //
 684   Float_t maxDCAr = accCuts->GetMaxDCAr();
 685   Float_t maxDCAz = accCuts->GetMaxDCAz();
 686   Float_t minTPCClust = trackCuts->GetMinNClusterTPC();
 687
 688   //
 689   Int_t ntracks = esdEvent->GetNumberOfTracks();
 690   Double_t dca[2],cov[3];
 691   Int_t mult=0;
 692   for (Int_t i=0;i <ntracks; i++){
 693     AliESDtrack *t = esdEvent->GetTrack(i);
 694     if (!t) continue;
 695     if (t->Charge() == 0) continue;
 696     if (!t->GetTPCInnerParam()) continue;
 697     if (t->GetTPCNcls()<minTPCClust) continue;
 698     //
 699     AliExternalTrackParam  *tpcTrack  = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
 700     if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov))
 701     {
 702       if(tpcTrack) delete tpcTrack;
 703       continue;
 704     }
 705     //
 706     if (TMath::Abs(dca[0])>maxDCAr || TMath::Abs(dca[1])>maxDCAz) {
 707       if(tpcTrack) delete tpcTrack;
 708       continue;
 709     }
 710
 711     Int_t label = TMath::Abs(t->GetLabel());
 712     TParticle *part = stack->Particle(label);
 713     if(!part) {
 714       if(tpcTrack) delete tpcTrack;
 715       continue;
 716     }
 717     if(!stack->IsPhysicalPrimary(label))
 718     {
 719       if(tpcTrack) delete tpcTrack;
 720       continue;
 721     }
 722
 723     mult++;
 724
 725     if(tpcTrack) delete tpcTrack;
 726   }
 727
 728 return mult;
 729 }
 730
 731
 732
 733
 734
 735 //_____________________________________________________________________________
 736 Int_t AlidNdPtHelper::GetMCTrueTrackMult(AliMCEvent *const mcEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts)
 737 {
 738   //
 739   // calculate mc event true track multiplicity
 740   //
 741   if(!mcEvent) return 0;
 742
 743   AliStack* stack = 0;
 744   Int_t mult = 0;
 745
 746   // MC particle stack
 747   stack = mcEvent->Stack();
 748   if (!stack) return 0;
 749
 750   Bool_t isEventOK = evtCuts->AcceptMCEvent(mcEvent);
 751   if(!isEventOK) return 0;
 752
 753   Int_t nPart  = stack->GetNtrack();
 754   for (Int_t iMc = 0; iMc < nPart; ++iMc)
 755   {
 756      TParticle* particle = stack->Particle(iMc);
 757      if (!particle)
 758      continue;
 759
 760      // only charged particles
 761      Double_t charge = particle->GetPDG()->Charge()/3.;
 762      if (TMath::Abs(charge) < 0.001)
 763      continue;
 764
 765      // physical primary
 766      Bool_t prim = stack->IsPhysicalPrimary(iMc);
 767      if(!prim) continue;
 768
 769      // checked accepted
 770      if(accCuts->AcceptTrack(particle))
 771      {
 772        mult++;
 773      }
 774   }
 775
 776 return mult;
 777 }
 778
 779 //_______________________________________________________________________
 780 void  AlidNdPtHelper::PrintMCInfo(AliStack *const pStack,Int_t label)
 781 {
 782 // print information about particles in the stack
 783
 784   if(!pStack)return;
 785   label = TMath::Abs(label);
 786   TParticle *part = pStack->Particle(label);
 787   Printf("########################");
 788   Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());
 789   part->Print();
 790   TParticle* mother = part;
 791   Int_t imo = part->GetFirstMother();
 792   Int_t nprim = pStack->GetNprimary();
 793
 794   while((imo >= nprim)) {
 795       mother =  pStack->Particle(imo);
 796       Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());
 797       mother->Print();
 798       imo =  mother->GetFirstMother();
 799  }
 800
 801  Printf("########################");
 802 }
 803
 804
 805 //_____________________________________________________________________________
 806 TH1* AlidNdPtHelper::GetContCorrHisto(TH1 *const hist)
 807 {
 808 //
 809 // get contamination histogram
 810 //
 811  if(!hist) return 0;
 812
 813  Int_t nbins = hist->GetNbinsX();
 814  TH1 *hCont = (TH1D *)hist->Clone();
 815
 816  for(Int_t i=0; i<=nbins+1; i++) {
 817    Double_t binContent = hist->GetBinContent(i);
 818    Double_t binError = hist->GetBinError(i);
 819
 820    hCont->SetBinContent(i,1.-binContent);
 821    hCont->SetBinError(i,binError);
 822  }
 823
 824 return hCont;
 825 }
 826
 827
 828 //_____________________________________________________________________________
 829 TH1* AlidNdPtHelper::ScaleByBinWidth(TH1 *const hist)
 830 {
 831 //
 832 // scale by bin width
 833 //
 834  if(!hist) return 0;
 835
 836  TH1 *hScale = (TH1D *)hist->Clone();
 837  hScale->Scale(1.,"width");
 838
 839 return hScale;
 840 }
 841
 842 //_____________________________________________________________________________
 843 TH1* AlidNdPtHelper::CalcRelativeDifference(TH1 *const hist1, TH1 *const hist2)
 844 {
 845 //
 846 // calculate rel. difference
 847 //
 848
 849  if(!hist1) return 0;
 850  if(!hist2) return 0;
 851
 852  TH1 *h1Clone = (TH1D *)hist1->Clone();
 853  h1Clone->Sumw2();
 854
 855  // (rec-mc)/mc
 856  h1Clone->Add(hist2,-1);
 857  h1Clone->Divide(hist2);
 858
 859 return h1Clone;
 860 }
 861
 862 //_____________________________________________________________________________
 863 TH1* AlidNdPtHelper::CalcRelativeDifferenceFun(TH1 *const hist1, TF1 *const fun)
 864 {
 865 //
 866 // calculate rel. difference
 867 // between histogram and function
 868 //
 869  if(!hist1) return 0;
 870  if(!fun) return 0;
 871
 872  TH1 *h1Clone = (TH1D *)hist1->Clone();
 873  h1Clone->Sumw2();
 874
 875  //
 876  h1Clone->Add(fun,-1);
 877  h1Clone->Divide(hist1);
 878
 879 return h1Clone;
 880 }
 881
 882 //_____________________________________________________________________________
 883 TH1* AlidNdPtHelper::NormalizeToEvent(TH2 *const hist1, TH1 *const hist2)
 884 {
 885 // normalise to event for a given multiplicity bin
 886 // return pt histogram
 887
 888  if(!hist1) return 0;
 889  if(!hist2) return 0;
 890  char name[256];
 891
 892  Int_t nbinsX = hist1->GetNbinsX();
 893  //Int_t nbinsY = hist1->GetNbinsY();
 894
 895  TH1D *histNorm = 0;
 896  for(Int_t i=0; i<=nbinsX+1; i++) {
 897    sprintf(name,"mom_%d",i);
 898    TH1D *hist = (TH1D*)hist1->ProjectionY(name,i+1,i+1);
 899
 900    sprintf(name,"mom_norm");
 901    if(i==0) {
 902      histNorm = (TH1D *)hist->Clone(name);
 903      histNorm->Reset();
 904    }
 905
 906    Double_t nbEvents = hist2->GetBinContent(i);
 907    if(!nbEvents) { nbEvents = 1.; };
 908
 909    hist->Scale(1./nbEvents);
 910    histNorm->Add(hist);
 911  }
 912
 913 return histNorm;
 914 }
 915
 916 //_____________________________________________________________________________
 917 THnSparse* AlidNdPtHelper::GenerateCorrMatrix(THnSparse *const hist1, THnSparse *const hist2, char *const name) {
 918 // generate correction matrix
 919 if(!hist1 || !hist2) return 0;
 920
 921 THnSparse *h =(THnSparse*)hist1->Clone(name);;
 922 h->Divide(hist1,hist2,1,1,"B");
 923
 924 return h;
 925 }
 926
 927 //_____________________________________________________________________________
 928 TH2* AlidNdPtHelper::GenerateCorrMatrix(TH2 *const hist1, TH2 *const hist2, char *const name) {
 929 // generate correction matrix
 930 if(!hist1 || !hist2) return 0;
 931
 932 TH2D *h =(TH2D*)hist1->Clone(name);;
 933 h->Divide(hist1,hist2,1,1,"B");
 934
 935 return h;
 936 }
 937
 938 //_____________________________________________________________________________
 939 TH1* AlidNdPtHelper::GenerateCorrMatrix(TH1 *const hist1, TH1 *const hist2, char *const name) {
 940 // generate correction matrix
 941 if(!hist1 || !hist2) return 0;
 942
 943 TH1D *h =(TH1D*)hist1->Clone(name);;
 944 h->Divide(hist1,hist2,1,1,"B");
 945
 946 return h;
 947 }
 948
 949 //_____________________________________________________________________________
 950 THnSparse* AlidNdPtHelper::GenerateContCorrMatrix(THnSparse *const hist1, THnSparse *const hist2, char *const name) {
 951 // generate contamination correction matrix
 952 if(!hist1 || !hist2) return 0;
 953
 954 THnSparse *hist =  GenerateCorrMatrix(hist1, hist2, name);
 955 if(!hist) return 0;
 956
 957 // only for non ZERO bins!!!!
 958
 959 Int_t* coord = new Int_t[hist->GetNdimensions()];
 960 memset(coord, 0, sizeof(Int_t) * hist->GetNdimensions());
 961
 962   for (Long64_t i = 0; i < hist->GetNbins(); ++i) {
 963     Double_t v = hist->GetBinContent(i, coord);
 964     hist->SetBinContent(coord, 1.0-v);
 965     //printf("v %f, hist->GetBinContent(i, coord) %f \n",v,hist->GetBinContent(i, coord));
 966     Double_t err = hist->GetBinError(coord);
 967     hist->SetBinError(coord, err);
 968   }
 969
 970 delete [] coord;
 971
 972 return hist;
 973 }
 974
 975 //_____________________________________________________________________________
 976 TH2* AlidNdPtHelper::GenerateContCorrMatrix(TH2 *const hist1, TH2 *const hist2, char *const name) {
 977 // generate contamination correction matrix
 978 if(!hist1 || !hist2) return 0;
 979
 980 TH2 *hist = GenerateCorrMatrix(hist1, hist2, name);
 981 if(!hist) return 0;
 982
 983 Int_t nBinsX = hist->GetNbinsX();
 984 Int_t nBinsY = hist->GetNbinsY();
 985
 986   for (Int_t i = 0; i < nBinsX+1; i++) {
 987   for (Int_t j = 0; j < nBinsY+1; j++) {
 988      Double_t cont = hist->GetBinContent(i,j);
 989      hist->SetBinContent(i,j,1.-cont);
 990      Double_t err = hist->GetBinError(i,j);
 991      hist->SetBinError(i,j,err);
 992   }
 993   }
 994
 995 return hist;
 996 }
 997
 998 //_____________________________________________________________________________
 999 TH1* AlidNdPtHelper::GenerateContCorrMatrix(TH1 *const hist1, TH1 *const hist2, char *const name) {
1000 // generate contamination correction matrix
1001 if(!hist1 || !hist2) return 0;
1002
1003 TH1 *hist = GenerateCorrMatrix(hist1, hist2, name);
1004 if(!hist) return 0;
1005
1006 Int_t nBinsX = hist->GetNbinsX();
1007
1008   for (Int_t i = 0; i < nBinsX+1; i++) {
1009      Double_t cont = hist->GetBinContent(i);
1010      hist->SetBinContent(i,1.-cont);
1011      Double_t err = hist->GetBinError(i);
1012      hist->SetBinError(i,err);
1013   }
1014
1015 return hist;
1016 }
1017
1018 //_____________________________________________________________________________
1019 const AliESDVertex* AlidNdPtHelper::GetTPCVertexZ(AliESDEvent* const esdEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts, Float_t fraction, Int_t ntracksMin){
1020   //
1021   // TPC Z vertexer
1022   //
1023   if(!esdEvent)
1024   {
1025     ::Error("AlidNdPtHelper::GetTPCVertexZ()","cuts not available");
1026     return NULL;
1027   }
1028
1029   if(!evtCuts || !accCuts || !trackCuts)
1030   {
1031     ::Error("AlidNdPtHelper::GetTPCVertexZ()","cuts not available");
1032     return NULL;
1033   }
1034
1035   Double_t vtxpos[3]={evtCuts->GetMeanXv(),evtCuts->GetMeanYv(),evtCuts->GetMeanZv()};
1036   Double_t vtxsigma[3]={evtCuts->GetSigmaMeanXv(),evtCuts->GetSigmaMeanYv(),evtCuts->GetSigmaMeanZv()};
1037   AliESDVertex vtx0(vtxpos,vtxsigma);
1038
1039   Double_t maxDCAr = accCuts->GetMaxDCAr();
1040   Double_t maxDCAz = accCuts->GetMaxDCAz();
1041   Int_t minTPCClust = trackCuts->GetMinNClusterTPC();
1042
1043   //
1044   Int_t ntracks = esdEvent->GetNumberOfTracks();
1045   TVectorD ztrack(ntracks);
1046   Double_t dca[2],cov[3];
1047   Int_t counter=0;
1048   for (Int_t i=0;i <ntracks; i++){
1049     AliESDtrack *t = esdEvent->GetTrack(i);
1050     if (!t) continue;
1051     if (!t->GetTPCInnerParam()) continue;
1052     if (t->GetTPCNcls()<minTPCClust) continue;
1053     //
1054     AliExternalTrackParam  *tpcTrack  = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
1055     if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov)) continue;
1056
1057     //
1058     if (TMath::Abs(dca[0])>maxDCAr) continue;
1059     //if (TMath::Sqrt(cov[0])>sigmaXYcut) continue;
1060     if (TMath::Abs(tpcTrack->GetZ())>maxDCAz) continue;
1061
1062     ztrack[counter]=tpcTrack->GetZ();
1063     counter++;
1064
1065     if(tpcTrack) delete tpcTrack;
1066   }
1067
1068   //
1069   // Find LTM z position
1070   //
1071   Double_t mean=0, sigma=0;
1072   if (counter<ntracksMin) return 0;
1073   //
1074   Int_t nused = TMath::Nint(counter*fraction);
1075   if (nused==counter) nused=counter-1;
1076   if (nused>1){
1077     AliMathBase::EvaluateUni(counter, ztrack.GetMatrixArray(), mean,sigma, TMath::Nint(counter*fraction));
1078     sigma/=TMath::Sqrt(nused);
1079   }else{
1080     mean  = TMath::Mean(counter, ztrack.GetMatrixArray());
1081     sigma = TMath::RMS(counter, ztrack.GetMatrixArray());
1082     sigma/=TMath::Sqrt(counter-1);
1083   }
1084   vtxpos[2]=mean;
1085   vtxsigma[2]=sigma;
1086   const AliESDVertex* vertex = new AliESDVertex(vtxpos, vtxsigma);
1087   return vertex;
1088 }
1089
1090 //_____________________________________________________________________________
1091 Int_t  AlidNdPtHelper::GetSPDMBTrackMult(AliESDEvent* const esdEvent, Float_t deltaThetaCut, Float_t deltaPhiCut)
1092 {
1093   //
1094   // SPD track multiplicity
1095   //
1096
1097   // get tracklets
1098   const AliMultiplicity* mult = esdEvent->GetMultiplicity();
1099   if (!mult)
1100      return 0;
1101
1102   // get multiplicity from SPD tracklets
1103   Int_t inputCount = 0;
1104   for (Int_t i=0; i<mult->GetNumberOfTracklets(); ++i)
1105   {
1106     //printf("%d %f %f %f\n", i, mult->GetTheta(i), mult->GetPhi(i), mult->GetDeltaPhi(i));
1107
1108      Float_t phi = mult->GetPhi(i);
1109      if (phi < 0)
1110        phi += TMath::Pi() * 2;
1111      Float_t deltaPhi = mult->GetDeltaPhi(i);
1112      Float_t deltaTheta = mult->GetDeltaTheta(i);
1113
1114      if (TMath::Abs(deltaPhi) > 1)
1115        printf("WARNING: Very high Delta Phi: %d %f %f %f\n", i, mult->GetTheta(i), mult->GetPhi(i), deltaPhi);
1116
1117      if (deltaThetaCut > 0. && TMath::Abs(deltaTheta) > deltaThetaCut)
1118         continue;
1119
1120      if (deltaPhiCut > 0. && TMath::Abs(deltaPhi) > deltaPhiCut)
1121         continue;
1122
1123      ++inputCount;
1124   }
1125
1126 return inputCount;
1127 }
1128
1129 //_____________________________________________________________________________
1130 Int_t  AlidNdPtHelper::GetSPDMBPrimTrackMult(AliESDEvent* const esdEvent, AliStack* const stack, Float_t deltaThetaCut, Float_t deltaPhiCut)
1131 {
1132   //
1133   // SPD track multiplicity
1134   //
1135
1136   // get tracklets
1137   const AliMultiplicity* mult = esdEvent->GetMultiplicity();
1138   if (!mult)
1139      return 0;
1140
1141   // get multiplicity from SPD tracklets
1142   Int_t inputCount = 0;
1143   for (Int_t i=0; i<mult->GetNumberOfTracklets(); ++i)
1144   {
1145     //printf("%d %f %f %f\n", i, mult->GetTheta(i), mult->GetPhi(i), mult->GetDeltaPhi(i));
1146
1147      Float_t phi = mult->GetPhi(i);
1148      if (phi < 0)
1149        phi += TMath::Pi() * 2;
1150      Float_t deltaPhi = mult->GetDeltaPhi(i);
1151      Float_t deltaTheta = mult->GetDeltaTheta(i);
1152
1153      if (TMath::Abs(deltaPhi) > 1)
1154        printf("WARNING: Very high Delta Phi: %d %f %f %f\n", i, mult->GetTheta(i), mult->GetPhi(i), deltaPhi);
1155
1156      if (deltaThetaCut > 0. && TMath::Abs(deltaTheta) > deltaThetaCut)
1157         continue;
1158
1159      if (deltaPhiCut > 0. && TMath::Abs(deltaPhi) > deltaPhiCut)
1160         continue;
1161
1162
1163      if (mult->GetLabel(i, 0) < 0 || mult->GetLabel(i, 0) != mult->GetLabel(i, 1) ||
1164          !stack->IsPhysicalPrimary(mult->GetLabel(i, 0)))
1165         continue;
1166
1167
1168      ++inputCount;
1169   }
1170
1171 return inputCount;
1172 }
1173
1174