HLT/trigger/tasks/AliAnalysisTasktrigger.cxx

   1 //-*- Mode: C++ -*-
   2
   3 #include "TChain.h"
   4 #include "TTree.h"
   5 #include "TH1F.h"
   6 #include "TCanvas.h"
   7 #include "TStopwatch.h"
   8 #include "TMath.h"
   9
  10 #include "AliAnalysisTask.h"
  11 #include "AliAnalysisManager.h"
  12 #include "AliTracker.h"
  13 #include "AliESDEvent.h"
  14 #include "AliESDInputHandler.h"
  15 #include "AliStack.h"
  16 #include "AliMCEvent.h"
  17 #include "AliMCEventHandler.h"
  18 #include "AliESDtrackCuts.h"
  19 #include "AliKineTrackCuts.h"
  20 #include "AliMCParticle.h"
  21
  22 #include "AliAnalysisTasktrigger.h"
  23
  24 using namespace std;
  25
  26 // Study trigger efficiencies for high-pt trigger
  27 // Author: Jochen Thaeder <jochen@thaeder.de>
  28
  29 ClassImp(AliAnalysisTasktrigger)
  30
  31 /*
  32  * ---------------------------------------------------------------------------------
  33  *                            Constructor / Destructor
  34  * ---------------------------------------------------------------------------------
  35  */
  36
  37 //________________________________________________________________________
  38 AliAnalysisTasktrigger::AliAnalysisTasktrigger(const char *name) :
  39   AliAnalysisTaskSE(name),
  40   fRandom(NULL),
  41   fMC(NULL), fESD(NULL), fESDHLT(NULL),
  42   fESDTrackCuts(NULL), fESDHLTTrackCuts(NULL), fMCTrackCuts(NULL),
  43   fIsSelected(kFALSE), fIsSelectedHLT(kFALSE), fIsSelectedMC(kFALSE),
  44   fIsSelectedTask(kFALSE),
  45   fOutputContainer(NULL),
  46   fPtCount(NULL), fMultiplicity(NULL),
  47   fTrigger(NULL) {
  48   // Constructor
  49
  50   // Define input and output slots here
  51   // Input slot #0 works with a TChain
  52   // DefineInput(0, TChain::Class());
  53
  54   // Output slot #1 writes into a TObjArray container
  55   DefineOutput(1, TObjArray::Class());
  56 }
  57
  58 //________________________________________________________________________
  59 const Int_t     AliAnalysisTasktrigger::fgkNSettings       = 7;
  60 //________________________________________________________________________
  61 const Double_t  AliAnalysisTasktrigger::fgkTriggerPt[]     = {1.0, 2.0, 2.5, 3.0, 5.0, 7.0, 10.0};
  62
  63
  64 //________________________________________________________________________
  65 const Int_t     AliAnalysisTasktrigger::fgkNTrigger        = 10;
  66
  67 //________________________________________________________________________
  68 const Char_t   *AliAnalysisTasktrigger::fgkTrigger[]       = {
  69   "p_{t}> 1.0",              "p_{t}> 2.0",              "p_{t}> 2.5",
  70   "p_{t}> 3.0",              "p_{t}> 5.0",              "p_{t}> 7.0",
  71   "p_{t}> 10.0",
  72   "S1",                      "S2",                      "S3",
  73 };
  74
  75 //________________________________________________________________________
  76 const Int_t     AliAnalysisTasktrigger::fgkNSelectionCuts  = 5;
  77
  78 //________________________________________________________________________
  79 const Char_t   *AliAnalysisTasktrigger::fgkSelectionCuts[] = {
  80   "All Events",
  81   "AliPhysSel",
  82   "AliPhysSel - PrimVertex",
  83   "AliPhysSel - PrimVertex - Track (OFF)",
  84   "AliPhysSel - PrimVertex - Track (HLT)",
  85 };
  86
  87 //________________________________________________________________________
  88 AliAnalysisTasktrigger::~AliAnalysisTasktrigger() {
  89   // Destructor
  90
  91   if (fRandom)
  92     delete fRandom;
  93   fRandom = NULL;
  94
  95   if (fESDTrackCuts)
  96     delete fESDTrackCuts;
  97   fESDTrackCuts = NULL;
  98
  99   if (fESDHLTTrackCuts)
 100     delete fESDHLTTrackCuts;
 101   fESDHLTTrackCuts = NULL;
 102
 103   if (fMCTrackCuts)
 104     delete fMCTrackCuts;
 105   fMCTrackCuts = NULL;
 106
 107   if (fPtCount)
 108     delete[] fPtCount;
 109   fPtCount = NULL;
 110
 111   if (fMultiplicity)
 112     delete[] fMultiplicity;
 113   fMultiplicity = NULL;
 114
 115   if (fTrigger)
 116     delete[] fTrigger;
 117   fTrigger = NULL;
 118 }
 119
 120 /*
 121  * ---------------------------------------------------------------------------------
 122  *                                    Methods
 123  * ---------------------------------------------------------------------------------
 124  */
 125
 126 //________________________________________________________________________
 127 void AliAnalysisTasktrigger::UserCreateOutputObjects() {
 128   // Create histograms
 129   // Called once
 130
 131   fOutputContainer = new TObjArray(1);
 132   fOutputContainer->SetName(GetName()) ;
 133   fOutputContainer->SetOwner(kTRUE) ;
 134
 135   SetupTrigHistograms();
 136   SetupPtHistograms();
 137   SetupMultHistograms();
 138
 139   SetupESDTrackCuts();
 140
 141   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 142
 143   fTrigger       = new Bool_t[kNModes*fgkNTrigger];
 144   fPtCount       = new Int_t[kNModes*fgkNTrigger];
 145
 146   fMultiplicity  = new Int_t[fgkNSelectionCuts];
 147
 148   fRandom = new TRandom3(0);
 149 }
 150
 151 //________________________________________________________________________
 152 void AliAnalysisTasktrigger::UserExec(Option_t *) {
 153   // Main loop
 154   // Called for each event
 155
 156   // -- Setup Event
 157   // ----------------
 158   if ( !SetupEvent() )
 159     return;
 160
 161   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 162
 163   for (Int_t mode = 0; mode < kNModes; ++mode) {
 164
 165     if (mode == kMC && !fMC) continue;
 166
 167     // -- Fill Cut Studies
 168     // ---------------------
 169     FillCutStudies(mode);
 170
 171     // -- Fill Counter loop
 172     // ----------------------
 173     FillCounters(mode);
 174   }
 175
 176   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 177
 178   // -- Evaluate Trigger
 179   // ---------------------
 180   EvaluateTrigger();
 181
 182   // -- Fill Trigger Histograms
 183   // ----------------------------
 184   FillTriggerHistograms();
 185
 186   // -- Fill Trigger Studies
 187   // -------------------------
 188   FillTriggerStudies();
 189   FillTriggerStudiesMC();
 190
 191   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 192
 193   // -- Post output data.
 194   PostData(1, fOutputContainer);
 195 }
 196
 197
 198 /*
 199  * ---------------------------------------------------------------------------------
 200  *                            Trigger Methods - private
 201  * ---------------------------------------------------------------------------------
 202  */
 203
 204 //________________________________________________________________________
 205 void AliAnalysisTasktrigger::EvaluateTrigger() {
 206   // Evaluate Counters and Trigger
 207
 208   for (Int_t mode = 0; mode < kNModes; ++mode) {
 209     Int_t offset = mode*fgkNTrigger;
 210
 211     // -- Single Particle Triggers
 212     for ( Int_t idx = 0; idx < fgkNSettings; ++idx ) {
 213
 214       if ( fPtCount[offset+idx] >= 1 )
 215         fTrigger[offset+idx] = kTRUE;
 216     }
 217
 218     // -- Scenarios
 219     // ------------------
 220     Bool_t s1 = kFALSE;
 221     Bool_t s2 = kFALSE;
 222     Bool_t s3 = kFALSE;
 223
 224     if (!fRandom)
 225       printf(" ERROR NO RANDOM !!!! \n");
 226
 227     // S1 : Reduce to 300 Hz --  [ 150 Hz min bias ]
 228     // ---------------------------------------------
 229
 230     //  > 1 GeV | 800 Hz * 0.1         ~ 80 Hz
 231     if ( fPtCount[offset+0] >= 1 )
 232       if ( fRandom->Rndm() < 0.1 )
 233         s1 = kTRUE;
 234     //  > 2 GeV | 230 Hz * 0.22        ~ 50 Hz
 235     if ( fPtCount[offset+1] >= 1 )
 236       if ( fRandom->Rndm() < 0.22 )
 237         s1 = kTRUE;
 238     //  > 3 GeV | 60 Hz * 0.5          ~ 30 Hz
 239     if ( fPtCount[offset+3] >= 1 )
 240       if ( fRandom->Rndm() < 0.5 )
 241         s1 = kTRUE;
 242     //  > 5 GeV |                      ~ 8  Hz
 243     if ( fPtCount[offset+4] >= 1 )
 244       s1 = kTRUE;
 245
 246
 247     // S2 : Reduce to 400 Hz --  [ 200 Hz min bias ]
 248     // ---------------------------------------------
 249
 250     //  > 1 GeV | 800 Hz * 0.14        ~110 Hz
 251     if ( fPtCount[offset+0] >= 1 )
 252       if ( fRandom->Rndm() < 0.14 )
 253         s2 = kTRUE;
 254     //  > 2 GeV | 230 Hz * 0.39        ~ 90 Hz
 255     if ( fPtCount[offset+1] >= 1 )
 256       if ( fRandom->Rndm() < 0.39 )
 257         s2 = kTRUE;
 258     //  > 3 GeV | 60 Hz * 0.5          ~ 30 Hz
 259     if ( fPtCount[offset+3] >= 1 )
 260       if ( fRandom->Rndm() < 0.5 )
 261         s2 = kTRUE;
 262     //  > 5 GeV |                      ~ 8  Hz
 263     if ( fPtCount[offset+4] >= 1 )
 264       s2 = kTRUE;
 265
 266
 267     // S3 : Reduce to 500 Hz --  [ 200 Hz min bias ]
 268     // ---------------------------------------------
 269
 270     //  > 1 GeV | 800 Hz * 0.2         ~160 Hz
 271     if ( fPtCount[offset+0] >= 1 )
 272       if ( fRandom->Rndm() < 0.2 )
 273         s3 = kTRUE;
 274     //  > 2 GeV | 230 Hz * 0.61        ~140 Hz
 275     if ( fPtCount[offset+1] >= 1 )
 276       if ( fRandom->Rndm() < 0.61 )
 277         s3 = kTRUE;
 278     //  > 3 GeV |                      ~ 60 Hz
 279     if ( fPtCount[offset+3] >= 1 )
 280       s3 = kTRUE;
 281
 282     fTrigger[offset+fgkNSettings]   = s1;
 283     fTrigger[offset+fgkNSettings+1] = s2;
 284     fTrigger[offset+fgkNSettings+2] = s3;
 285   }
 286
 287   return;
 288 }
 289
 290 /*
 291  * ---------------------------------------------------------------------------------
 292  *                            Setup Cuts Methods - private
 293  * ---------------------------------------------------------------------------------
 294  */
 295
 296 //________________________________________________________________________
 297 void AliAnalysisTasktrigger::SetupESDTrackCuts() {
 298   // Setup ESD cuts
 299
 300   // -- Pure Off-line track cuts
 301   //  fESDTrackCuts    = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(kTRUE);
 302
 303   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 304
 305   // -- HLT adopted track cuts
 306   fESDHLTTrackCuts = new AliESDtrackCuts;
 307
 308   // -- turn off criteria
 309   fESDHLTTrackCuts->SetDCAToVertex2D(kFALSE);
 310   fESDHLTTrackCuts->SetRequireSigmaToVertex(kFALSE);
 311   fESDHLTTrackCuts->SetRequireTPCRefit(kFALSE);
 312   fESDHLTTrackCuts->SetRequireITSRefit(kFALSE);
 313
 314   // -- CleanSample
 315   fESDHLTTrackCuts->SetMaxDCAToVertexXY(3.0);
 316   fESDHLTTrackCuts->SetMaxDCAToVertexZ(10.0);
 317   fESDHLTTrackCuts->SetEtaRange(-1.0,1.0);
 318   fESDHLTTrackCuts->SetMinNClustersTPC(60);
 319
 320   // -- Pre Trigger Bias
 321   fESDHLTTrackCuts->SetPtRange(0.3);
 322
 323   fESDTrackCuts = fESDHLTTrackCuts;
 324
 325   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 326
 327   fMCTrackCuts = new AliKineTrackCuts;
 328   fMCTrackCuts->SetEtaRange(-1.0,1.0);
 329   fMCTrackCuts->SetPtRange(0.3);
 330
 331   return;
 332 }
 333
 334 /*
 335  * ---------------------------------------------------------------------------------
 336  *                              Fill Methods - private
 337  * ---------------------------------------------------------------------------------
 338  */
 339
 340 //________________________________________________________________________
 341 void AliAnalysisTasktrigger::FillCutStudies( Int_t mode ) {
 342   // Fill histograms for cut studies
 343
 344   for ( Int_t idx = 0; idx < fgkNSelectionCuts; idx++ )
 345     fMultiplicity[idx] = 0;
 346
 347   Char_t *title = "";
 348   Bool_t hasVertex = kFALSE;
 349   AliESDEvent *esd = NULL;
 350
 351   if (mode == kOFF) {
 352     title = "OFF";
 353     hasVertex = fIsSelected;
 354     esd = fESD;
 355   }
 356   else if (mode == kHLT) {
 357     title = "HLT";
 358     hasVertex = fIsSelectedHLT;
 359     esd = fESDHLT;
 360   }
 361   else if (mode == kMC) {
 362     title = "MC";
 363     hasVertex = fIsSelectedMC;
 364   }
 365
 366   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 367   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 368
 369   if (mode == kOFF || mode == kHLT) {
 370
 371     for (Int_t idx = 0; idx < esd->GetNumberOfTracks(); idx++) {
 372
 373       AliESDtrack* track = esd->GetTrack(idx);
 374       if (!track) continue;
 375
 376       // -- "All Events"
 377       // --------------------------------------------
 378       Int_t cut = 0;
 379       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(track->Pt());
 380       ++(fMultiplicity[cut]);
 381
 382       // -- "AliPhysSel"
 383       // --------------------------------------------
 384       if (!fIsSelectedTask)
 385         continue;
 386
 387       cut = 1;
 388       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(track->Pt());
 389       ++(fMultiplicity[cut]);
 390
 391       // -- "AliPhysSel - PrimVertex"
 392       // --------------------------------------------
 393       if (!hasVertex)
 394         continue;
 395
 396       cut = 2;
 397       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(track->Pt());
 398       ++(fMultiplicity[cut]);
 399
 400       // -- "AliPhysSel - PrimVertex - Track (OFF)"
 401       // --------------------------------------------
 402       if (fESDTrackCuts->AcceptTrack(track)) {
 403         cut = 3;
 404         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(track->Pt());
 405         ++(fMultiplicity[cut]);
 406       }
 407
 408       // -- "AliPhysSel - PrimVertex - Track (HLT)"
 409       // --------------------------------------------
 410       if (fESDHLTTrackCuts->AcceptTrack(track)) {
 411         cut = 4;
 412         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(track->Pt());
 413         ++(fMultiplicity[cut]);
 414       }
 415
 416     } // for (Int_t idx = 0; idx < esd->GetNumberOfTracks(); idx++) {
 417   }
 418
 419   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 420   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 421
 422   else {
 423
 424     AliStack* stack = fMC->Stack();
 425     if (!stack) {
 426       printf("Error : No Stack. \n");
 427       return;
 428     }
 429
 430     for (Int_t iterStack = 0; iterStack <  stack->GetNtrack(); iterStack++) {
 431
 432       TParticle *particle = GetChargedPhysicalPrimary(stack, iterStack);
 433       if (!particle)
 434         continue;
 435
 436       // -- "All Events"
 437       Int_t cut = 0;
 438       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(particle->Pt());
 439       ++(fMultiplicity[cut]);
 440
 441       // -- "AliPhysSel"
 442       // -----------------
 443       if (!fIsSelectedTask)
 444         continue;
 445
 446       cut = 1;
 447       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(particle->Pt());
 448       ++(fMultiplicity[cut]);
 449
 450       // -- "AliPhysSel - PrimVertex"
 451       // --------------------------------------------
 452       if (!hasVertex)
 453         continue;
 454
 455       cut = 2;
 456       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(particle->Pt());
 457       ++(fMultiplicity[cut]);
 458
 459       // -- "AliPhysSel - PrimVertex - Track (MC)"
 460       // --------------------------------------------
 461       if (!fMCTrackCuts->IsSelected(particle))
 462         continue;
 463
 464       cut = 3;
 465       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(particle->Pt());
 466       ++(fMultiplicity[cut]);
 467
 468       // -- "AliPhysSel - PrimVertex - Track (MC) - Findable"
 469       // ------------------------------------------------------
 470       if (!IsFindableMC(iterStack, 60.))
 471         continue;
 472
 473       cut = 4;
 474       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sPt_%d", title, cut))))->Fill(particle->Pt());
 475       ++(fMultiplicity[cut]);
 476
 477     } // for (Int_t iterStack = 0; iterStack < stack->GetNtrack(); iterStack++) {
 478   }
 479
 480   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 481   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 482
 483   // -- Fill Multiplicity
 484   for ( Int_t idx = 0; idx < fgkNSelectionCuts; idx++ )
 485     (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHist%sMult_%d", title, idx))))->Fill(fMultiplicity[idx]);
 486
 487   return;
 488 }
 489
 490 //________________________________________________________________________
 491 void AliAnalysisTasktrigger::FillCounters( Int_t mode ) {
 492   // Fill counters for trigger
 493
 494   Int_t offset   = mode*fgkNTrigger ;
 495
 496   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 497   if (mode == kOFF || mode == kHLT) {
 498
 499     AliESDtrackCuts *cuts = fESDTrackCuts;
 500     AliESDEvent *esd      = fESD;
 501
 502     if (mode == kHLT) {
 503       esd   = fESDHLT;
 504       cuts  = fESDHLTTrackCuts;
 505     }
 506
 507     for (Int_t idx = 0; idx < esd->GetNumberOfTracks(); idx++) {
 508       AliESDtrack* track = esd->GetTrack(idx);
 509       if (!track) continue;
 510
 511       // -- ESD cuts
 512       if ( !cuts->AcceptTrack(track) ) continue;
 513
 514       Int_t   nClustersTPC = track->GetTPCclusters(0);
 515
 516       //      Float_t ptTr        = TMath::Abs(track->GetSigned1Pt()) - 3.5 * TMath::Sqrt( track->GetSigma1Pt2());
 517
 518       // -- Different Pt settings
 519       for ( Int_t set=0; set < fgkNSettings ; set++ ) {
 520
 521         if      ( fgkTriggerPt[set] ==  3. ) { if ( nClustersTPC < 100 ) continue; }
 522         else if ( fgkTriggerPt[set] ==  5. ) { if ( nClustersTPC < 110 ) continue; }
 523         else if ( fgkTriggerPt[set] ==  7. ) { if ( nClustersTPC < 120 ) continue; }
 524         else if ( fgkTriggerPt[set] == 10. ) { if ( nClustersTPC < 140 ) continue; }
 525         else                                 { if ( nClustersTPC <  80 ) continue; }
 526
 527         //      if ( ptTr < 1/fgkTriggerPt[set] )
 528         //        ++(fPtCount[offset+set]);
 529
 530         if ( track->Pt() > fgkTriggerPt[set] )
 531           ++(fPtCount[offset+set]);
 532       }
 533
 534     } // for (Int_t idx = 0; idx < esd->GetNumberOfTracks(); idx++) {
 535   } // if (mode == kOFF || mode == kHLT) {
 536   else {
 537
 538     AliStack* stack = fMC->Stack();
 539     if (!stack) {
 540       printf("Error : No Stack. \n");
 541       return;
 542     }
 543
 544     for (Int_t iterStack = 0; iterStack < stack->GetNtrack(); iterStack++) {
 545
 546       TParticle *particle = GetChargedPhysicalPrimary(stack, iterStack);
 547       if (!particle)
 548         continue;
 549
 550       // -- MC cuts
 551       if ( !fMCTrackCuts->IsSelected(particle) ) continue;
 552
 553       // -- Different Pt settings
 554       for ( Int_t set=0; set < fgkNSettings ; set++ ) {
 555
 556         if      ( fgkTriggerPt[set] ==  3. ) { if ( !IsFindableMC(iterStack, 100.) ) continue; }
 557         else if ( fgkTriggerPt[set] ==  5. ) { if ( !IsFindableMC(iterStack, 110.) ) continue; }
 558         else if ( fgkTriggerPt[set] ==  7. ) { if ( !IsFindableMC(iterStack, 120.) ) continue; }
 559         else if ( fgkTriggerPt[set] == 10. ) { if ( !IsFindableMC(iterStack, 140.) ) continue; }
 560         else                                 { if ( !IsFindableMC(iterStack,  80.) ) continue; }
 561
 562         if ( particle->Pt() > fgkTriggerPt[set] )
 563           ++(fPtCount[offset+set]);
 564       }
 565     } // for (Int_t iterStack = 0; iterStack < stack->GetNtrack(); iterStack++) {
 566   }
 567
 568   return;
 569 }
 570
 571 //________________________________________________________________________
 572 void AliAnalysisTasktrigger::FillTriggerHistograms() {
 573   // Fill histograms for trigger
 574
 575   Int_t nTracks = fESD->GetNumberOfTracks();
 576   Int_t nTracksH = fESDHLT->GetNumberOfTracks();
 577
 578   Int_t nTracksM = 0;
 579
 580   if (fMC)
 581     nTracksM = fMC->Stack()->GetNtrack();
 582
 583   static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggered"))->Fill(0);
 584   static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggered"))->Fill(fgkNTrigger+1, nTracks);
 585   static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggered"))->Fill(0);
 586   static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggered"))->Fill(fgkNTrigger+1, nTracksH);
 587   static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggered"))->Fill(0);
 588   static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggered"))->Fill(fgkNTrigger+1, nTracksM);
 589
 590   for ( Int_t idx = 0; idx < fgkNTrigger; idx++ ) {
 591     if (fTrigger[(kOFF*fgkNTrigger)+idx]) {
 592       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggered"))->Fill(idx+1);
 593       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggered"))->Fill(fgkNTrigger+idx+2,nTracks);
 594     }
 595     if (fTrigger[(kHLT*fgkNTrigger)+idx]) {
 596       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggered"))->Fill(idx+1);
 597       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggered"))->Fill(fgkNTrigger+idx+2,nTracksH);
 598     }
 599     if (fTrigger[(kMC*fgkNTrigger)+idx]) {
 600       static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggered"))->Fill(idx+1);
 601       static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggered"))->Fill(fgkNTrigger+idx+2,nTracksM);
 602     }
 603
 604     if (fTrigger[(kHLT*fgkNTrigger)+idx] && !fTrigger[(kOFF*fgkNTrigger)+idx]) {
 605       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToOFF"))->Fill(idx+1);
 606       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToOFF"))->Fill(fgkNTrigger+idx+2,nTracks);
 607     }
 608     if (fTrigger[(kHLT*fgkNTrigger)+idx] && !fTrigger[(kMC*fgkNTrigger)+idx]) {
 609       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToMC"))->Fill(idx+1);
 610       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToMC"))->Fill(fgkNTrigger+idx+2,nTracks);
 611     }
 612     if (fTrigger[(kOFF*fgkNTrigger)+idx] && !fTrigger[(kMC*fgkNTrigger)+idx]) {
 613       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFFakeToMC"))->Fill(idx+1);
 614       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFFakeToMC"))->Fill(fgkNTrigger+idx+2,nTracks);
 615     }
 616
 617
 618     if (!fTrigger[(kHLT*fgkNTrigger)+idx] && fTrigger[(kOFF*fgkNTrigger)+idx]) {
 619       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToOFF"))->Fill(idx+1);
 620       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToOFF"))->Fill(fgkNTrigger+idx+2,nTracks);
 621     }
 622     if (!fTrigger[(kHLT*fgkNTrigger)+idx] && fTrigger[(kMC*fgkNTrigger)+idx]) {
 623       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToMC"))->Fill(idx+1);
 624       static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToMC"))->Fill(fgkNTrigger+idx+2,nTracks);
 625     }
 626     if (!fTrigger[(kOFF*fgkNTrigger)+idx] && fTrigger[(kMC*fgkNTrigger)+idx]) {
 627       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFMissToMC"))->Fill(idx+1);
 628       static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFMissToMC"))->Fill(fgkNTrigger+idx+2,nTracks);
 629     }
 630
 631   }
 632
 633   if ( fIsSelected ) {
 634     static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggeredSel"))->Fill(0);
 635     static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggeredSel"))->Fill(fgkNTrigger+1, nTracks);
 636     static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggeredSel"))->Fill(0);
 637     static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggeredSel"))->Fill(fgkNTrigger+1, nTracksH);
 638     static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggeredSel"))->Fill(0);
 639     static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggeredSel"))->Fill(fgkNTrigger+1, nTracksM);
 640
 641     for ( Int_t idx = 0; idx < fgkNTrigger; idx++ ) {
 642       if (fTrigger[(kOFF*fgkNTrigger)+idx]) {
 643         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggeredSel"))->Fill(idx+1);
 644         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFTriggeredSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 645       }
 646       if (fTrigger[(kHLT*fgkNTrigger)+idx]) {
 647         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggeredSel"))->Fill(idx+1);
 648         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTTriggeredSel"))->Fill(fgkNTrigger+idx+2,nTracksH);
 649       }
 650       if (fTrigger[(kMC*fgkNTrigger)+idx]) {
 651         static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggeredSel"))->Fill(idx+1);
 652         static_cast<TH1F*>(fOutputContainer->FindObject("fNMCTriggeredSel"))->Fill(fgkNTrigger+idx+2,nTracksM);
 653       }
 654
 655       if (fTrigger[(kHLT*fgkNTrigger)+idx] && !fTrigger[(kOFF*fgkNTrigger)+idx]) {
 656         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToOFFSel"))->Fill(idx+1);
 657         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToOFFSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 658       }
 659       if (fTrigger[(kHLT*fgkNTrigger)+idx] && !fTrigger[(kMC*fgkNTrigger)+idx]) {
 660         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToMCSel"))->Fill(idx+1);
 661         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTFakeToMCSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 662       }
 663       if (fTrigger[(kOFF*fgkNTrigger)+idx] && !fTrigger[(kMC*fgkNTrigger)+idx]) {
 664         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFFakeToMCSel"))->Fill(idx+1);
 665         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFFakeToMCSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 666       }
 667
 668       if (!fTrigger[(kHLT*fgkNTrigger)+idx] && fTrigger[(kOFF*fgkNTrigger)+idx]) {
 669         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToOFFSel"))->Fill(idx+1);
 670         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToOFFSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 671       }
 672       if (!fTrigger[(kHLT*fgkNTrigger)+idx] && fTrigger[(kMC*fgkNTrigger)+idx]) {
 673         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToMCSel"))->Fill(idx+1);
 674         static_cast<TH1F*>(fOutputContainer->FindObject("fNHLTMissToMCSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 675       }
 676       if (!fTrigger[(kOFF*fgkNTrigger)+idx] && fTrigger[(kMC*fgkNTrigger)+idx]) {
 677         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFMissToMCSel"))->Fill(idx+1);
 678         static_cast<TH1F*>(fOutputContainer->FindObject("fNOFFMissToMCSel"))->Fill(fgkNTrigger+idx+2,nTracks);
 679       }
 680     }
 681   }
 682
 683   return;
 684 }
 685
 686 //________________________________________________________________________
 687 void AliAnalysisTasktrigger::FillTriggerStudies() {
 688   // Fill histograms for trigger studies
 689
 690   // -- "AliPhysSel - PrimVertex"
 691   // --------------------------------------------
 692   if (!fIsSelected)
 693     return;
 694
 695   Int_t multiplicity = 0;
 696
 697   for (Int_t idx = 0; idx < fESD->GetNumberOfTracks(); idx++) {
 698     AliESDtrack* track = fESD->GetTrack(idx);
 699     if (!track) continue;
 700
 701     // -- "AliPhysSel - PrimVertex - Track (OFF)"
 702     // --------------------------------------------
 703     if (!fESDTrackCuts->AcceptTrack(track))
 704       continue;
 705
 706     // -- Fill Triggered Pt Spectra
 707     for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 708
 709       // -- ESD
 710       if ( fTrigger[(kOFF*fgkNTrigger)+trg] )
 711         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_PtTriggered_OFF_%d",trg))))->Fill(track->Pt());
 712
 713       // -- HLT
 714       if ( fTrigger[(kHLT*fgkNTrigger)+trg] )
 715         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_PtTriggered_HLT_%d",trg))))->Fill(track->Pt());
 716
 717       // -- MC
 718       if ( fTrigger[(kMC*fgkNTrigger)+trg] )
 719         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_PtTriggered_MC_%d",trg))))->Fill(track->Pt());
 720
 721     } // for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 722
 723     ++multiplicity;
 724
 725   } // for (Int_t idx = 0; idx < esd->GetNumberOfTracks(); idx++) {
 726
 727   // -- Fill Triggered Mult Spectra
 728   for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 729
 730     // -- ESD
 731     if ( fTrigger[(kOFF*fgkNTrigger)+trg] )
 732       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_MultTriggered_OFF_%d",trg))))->Fill(multiplicity);
 733
 734     // -- HLT
 735     if ( fTrigger[(kHLT*fgkNTrigger)+trg] )
 736       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_MultTriggered_HLT_%d",trg))))->Fill(multiplicity);
 737
 738     // -- MC
 739     if ( fTrigger[(kMC*fgkNTrigger)+trg] )
 740       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistOFF_MultTriggered_MC_%d",trg))))->Fill(multiplicity);
 741
 742   } // for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 743
 744   return;
 745 }
 746
 747
 748 //________________________________________________________________________
 749 void AliAnalysisTasktrigger::FillTriggerStudiesMC() {
 750   // Fill histograms for trigger studies
 751
 752   if (!fMC)
 753     return;
 754
 755   // -- "AliPhysSel - PrimVertex"
 756   // --------------------------------------------
 757   if (!fIsSelectedMC)
 758     return;
 759
 760   Int_t multiplicity = 0;
 761
 762   AliStack* stack = fMC->Stack();
 763   if (!stack) {
 764     printf("Error : No Stack. \n");
 765     return;
 766   }
 767
 768   for (Int_t iterStack = 0; iterStack < stack->GetNtrack(); iterStack++) {
 769
 770     TParticle *particle = GetChargedPhysicalPrimary(stack, iterStack);
 771     if (!particle)
 772       continue;
 773
 774     if ( ! fMCTrackCuts->IsSelected(particle) )
 775       continue;
 776
 777     if ( ! IsFindableMC(iterStack, 60.) )
 778       continue;
 779
 780     for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 781
 782       // -- ESD
 783       if ( fTrigger[(kOFF*fgkNTrigger)+trg] )
 784         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_PtTriggered_OFF_%d",trg))))->Fill(particle->Pt());
 785
 786       // -- HLT
 787       if ( fTrigger[(kHLT*fgkNTrigger)+trg] )
 788         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_PtTriggered_HLT_%d",trg))))->Fill(particle->Pt());
 789
 790       // -- MC
 791       if ( fTrigger[(kMC*fgkNTrigger)+trg] )
 792         (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_PtTriggered_MC_%d",trg))))->Fill(particle->Pt());
 793
 794     } // for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 795
 796     ++multiplicity;
 797
 798   } // for (Int_t iterStack = 0; iterStack < stack->GetNtrack(); iterStack++) {
 799
 800   // -- Fill Triggered Mult Spectra
 801   for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 802
 803     // -- ESD
 804     if ( fTrigger[(kOFF*fgkNTrigger)+trg] )
 805       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_MultTriggered_OFF_%d",trg))))->Fill(multiplicity);
 806
 807     // -- HLT
 808     if ( fTrigger[(kHLT*fgkNTrigger)+trg] )
 809       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_MultTriggered_HLT_%d",trg))))->Fill(multiplicity);
 810
 811     // -- MC
 812     if ( fTrigger[(kMC*fgkNTrigger)+trg] )
 813       (static_cast<TH1F*>(fOutputContainer->FindObject(Form("fHistMC_MultTriggered_MC_%d",trg))))->Fill(multiplicity);
 814
 815   } // for ( Int_t trg= 0; trg < fgkNTrigger; trg++ ) {
 816
 817   return;
 818 }
 819
 820
 821 /*
 822  * ---------------------------------------------------------------------------------
 823  *                            Setup Methods - private
 824  * ---------------------------------------------------------------------------------
 825  */
 826
 827 //________________________________________________________________________
 828 Bool_t AliAnalysisTasktrigger::SetupEvent() {
 829   // Setup Reading of event
 830
 831   // -- Clear Counters and Triggers
 832   // --------------------------------
 833   for ( Int_t idx = 0; idx < kNModes*fgkNTrigger; idx++ ) {
 834     fTrigger[idx] = kFALSE;
 835     fPtCount[idx] = 0;
 836   }
 837
 838   fIsSelected = fIsSelectedHLT = fIsSelectedMC = fIsSelectedTask = kFALSE;
 839
 840   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 841
 842   // -- ESD Event Handler
 843   // ----------------------
 844
 845   AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>
 846     (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 847
 848   if (!esdH) {
 849     printf("ERROR: Could not get ESDInputHandler");
 850     return kFALSE;
 851   }
 852
 853   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 854
 855   // -- MC Event Handler  - MC Event
 856   // ---------------------------------
 857
 858   AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>
 859     (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 860
 861   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 862
 863   // -- Events
 864   // ------------
 865   fESD = esdH->GetEvent();
 866   if (!fESD) {
 867     printf("ERROR: fESD not available \n");
 868     return kFALSE;
 869   }
 870
 871   fESDHLT = esdH->GetHLTEvent();
 872   if (!fESDHLT) {
 873     printf("ERROR: fESDHLT not available \n");
 874     return kFALSE;
 875   }
 876
 877   fMC = MCEvent();
 878   if ( mcH && !fMC) {
 879     printf("ERROR: fMC not available \n");
 880     return kFALSE;
 881   }
 882
 883   if ( !fESD->GetPrimaryVertexTracks() ){
 884     printf("ERROR: No Vertex \n");
 885     return kFALSE;
 886   }
 887
 888   if ( !fESDHLT->GetPrimaryVertexTracks() ){
 889     printf("ERROR: No HLT Vertex \n");
 890     return kFALSE;
 891   }
 892
 893   if ( fMC && !fMC->GetPrimaryVertex() ){
 894     printf("ERROR: No MC Vertex \n");
 895     return kFALSE;
 896   }
 897
 898   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
 899
 900   // -- Physics Selection
 901   // ----------------------
 902
 903   fIsSelectedTask = esdH->IsEventSelected() & AliVEvent::kMB;
 904   fIsSelected     = fIsSelectedTask && (fESD->GetPrimaryVertexTracks())->GetStatus();
 905   fIsSelectedHLT  = fIsSelectedTask && (fESDHLT->GetPrimaryVertexTracks())->GetStatus();
 906   if (fMC)
 907     fIsSelectedMC   = fIsSelectedTask && (fMC->GetPrimaryVertex()); //->GetStatus();
 908
 909   return kTRUE;
 910 }
 911
 912 //________________________________________________________________________
 913 void AliAnalysisTasktrigger::SetupTrigHistograms() {
 914
 915   Int_t    n = 2*(fgkNTrigger+1);
 916   Double_t s = 0.;
 917   Double_t e = static_cast<Double_t>(2*(fgkNTrigger+1));
 918
 919   AddTriggerHist(new TH1F("fNOFFTriggered",    "N events OFF triggered;;N Events", n, s, e));
 920   AddTriggerHist(new TH1F("fNOFFTriggeredSel", "N events OFF triggered - OFF selected;;N Events", n, s, e));
 921
 922   AddTriggerHist(new TH1F("fNHLTTriggered",    "N events HLT triggered;;N Events", n, s, e));
 923   AddTriggerHist(new TH1F("fNHLTTriggeredSel", "N events HLT triggered - OFF selected;;N Events", n, s, e));
 924
 925   AddTriggerHist(new TH1F("fNMCTriggered",     "N events MC triggered;;N Events", n, s, e));
 926   AddTriggerHist(new TH1F("fNMCTriggeredSel",  "N events MC triggered - OFF selected;;N Events", n, s, e));
 927
 928   // -- -- -- --
 929
 930   AddTriggerHist(new TH1F("fNHLTFakeToOFF",    "N events HLT fake (to OFF) triggered;;N Events", n, s, e));
 931   AddTriggerHist(new TH1F("fNHLTFakeToOFFSel", "N events HLT fake (to OFF) triggered - OFF selected;;N Events", n, s, e));
 932
 933   AddTriggerHist(new TH1F("fNHLTFakeToMC",     "N events HLT fake (to MC) triggered;;N Events", n, s, e));
 934   AddTriggerHist(new TH1F("fNHLTFakeToMCSel",  "N events HLT fake (to MC) triggered - OFF selected;;N Events", n, s, e));
 935
 936   AddTriggerHist(new TH1F("fNOFFFakeToMC",     "N events OFF fake (to MC) triggered;;N Events", n, s, e));
 937   AddTriggerHist(new TH1F("fNOFFFakeToMCSel",  "N events OFF fake (to MC) triggered - OFF selected;;N Events", n, s, e));
 938
 939   // -- -- -- --
 940
 941   AddTriggerHist(new TH1F("fNHLTMissToOFF",    "N events HLT miss (to OFF) triggered;;N Events", n, s, e));
 942   AddTriggerHist(new TH1F("fNHLTMissToOFFSel", "N events HLT miss (to OFF) triggered - MC selected;;N Events", n, s, e));
 943
 944   AddTriggerHist(new TH1F("fNHLTMissToMC",     "N events HLT miss (to MC) triggered;;N Events", n, s, e));
 945   AddTriggerHist(new TH1F("fNHLTMissToMCSel",  "N events HLT miss (to MC) triggered - MC selected;;N Events", n, s, e));
 946
 947   AddTriggerHist(new TH1F("fNOFFMissToMC",     "N events OFF miss (to MC) triggered;;N Events", n, s, e));
 948   AddTriggerHist(new TH1F("fNOFFMissToMCSel",  "N events OFF miss (to MC) triggered - MC selected;;N Events", n, s, e));
 949
 950   return;
 951 }
 952
 953 //________________________________________________________________________
 954 void AliAnalysisTasktrigger::SetupPtHistograms() {
 955
 956   Int_t    n = 50;
 957   Double_t s = 0.1;
 958   Double_t e = 50.;
 959
 960   // -- Create LogPtBinning
 961   // ------------------------
 962   Double_t logMin = TMath::Log10(s);
 963   Double_t logMax = TMath::Log10(e);
 964   Double_t binwidth = (logMax-logMin)/n;
 965
 966   Double_t *logBinning = new Double_t[n+1];
 967
 968   logBinning[0] = s;
 969   for (Int_t ii = 1; ii <= n; ii++)
 970     logBinning[ii] = s + TMath::Power(10, logMin + ii*binwidth);
 971
 972   // -- Create Histograms
 973   // ----------------------
 974   for ( Int_t idx = 0; idx < fgkNSelectionCuts; idx++ ) {
 975     AddPtHist(new TH1F(Form("fHistOFFPt_%d",idx),
 976                        Form("OFF P_{T} distribution - %s", fgkSelectionCuts[idx]), n, logBinning));
 977     AddPtHist(new TH1F(Form("fHistHLTPt_%d",idx),
 978                        Form("HLT P_{T} distribution - %s", fgkSelectionCuts[idx]), n, logBinning));
 979     AddPtHist(new TH1F(Form("fHistMCPt_%d",idx),
 980                        Form("MC P_{T} distribution - %s", fgkSelectionCuts[idx]), n, logBinning));
 981   }
 982
 983   for ( Int_t idx = 0; idx < fgkNTrigger; idx++ ) {
 984     AddPtHist(new TH1F(Form("fHistOFF_PtTriggered_OFF_%d",idx),
 985                        Form("OFF Triggered - OFF P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 986     AddPtHist(new TH1F(Form("fHistOFF_PtTriggered_HLT_%d",idx),
 987                        Form("HLT Triggered - OFF P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 988     AddPtHist(new TH1F(Form("fHistOFF_PtTriggered_MC_%d",idx),
 989                        Form("MC Triggered - OFF P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 990     AddPtHist(new TH1F(Form("fHistMC_PtTriggered_OFF_%d",idx),
 991                        Form("OFF Triggered - MC P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 992     AddPtHist(new TH1F(Form("fHistMC_PtTriggered_HLT_%d",idx),
 993                        Form("HLT Triggered - MC P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 994     AddPtHist(new TH1F(Form("fHistMC_PtTriggered_MC_%d",idx),
 995                        Form("MC Triggered - MC P_{T} distribution - %s", fgkTrigger[idx]), n, logBinning));
 996   }
 997
 998   delete[] logBinning;
 999   logBinning = NULL;
1000
1001   return;
1002 }
1003
1004 //________________________________________________________________________
1005 void AliAnalysisTasktrigger::SetupMultHistograms() {
1006
1007   Int_t    n = 51;
1008   Double_t s = 0.;
1009   Double_t e = 50.;
1010
1011   for ( Int_t idx = 0; idx < fgkNSelectionCuts; idx++ ) {
1012     AddMultHist(new TH1F(Form("fHistOFFMult_%d",idx),
1013                          Form("Multiplicity distribution - %s", fgkSelectionCuts[idx]), n, s ,e));
1014     AddMultHist(new TH1F(Form("fHistHLTMult_%d",idx),
1015                          Form("HLT Multiplicity distribution - %s", fgkSelectionCuts[idx]), n, s ,e));
1016     AddMultHist(new TH1F(Form("fHistMCMult_%d",idx),
1017                          Form("MC Multiplicity distribution - %s", fgkSelectionCuts[idx]), n, s ,e));
1018   }
1019
1020   for ( Int_t idx = 0; idx < fgkNTrigger; idx++ ) {
1021     AddMultHist(new TH1F(Form("fHistOFF_MultTriggered_OFF_%d",idx),
1022                          Form("OFF Triggered - OFF Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1023     AddMultHist(new TH1F(Form("fHistOFF_MultTriggered_HLT_%d",idx),
1024                          Form("HLT Triggered - OFF Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1025     AddMultHist(new TH1F(Form("fHistOFF_MultTriggered_MC_%d",idx),
1026                          Form("MC Triggered - OFF Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1027     AddMultHist(new TH1F(Form("fHistMC_MultTriggered_OFF_%d",idx),
1028                          Form("OFF Triggered - MC Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1029     AddMultHist(new TH1F(Form("fHistMC_MultTriggered_HLT_%d",idx),
1030                          Form("HLT Triggered - MC Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1031     AddMultHist(new TH1F(Form("fHistMC_MultTriggered_MC_%d",idx),
1032                          Form("MC Triggered - MC Multiplicty distribution - %s", fgkTrigger[idx]), n, s ,e));
1033   }
1034
1035   return;
1036 }
1037
1038 /*
1039  * ---------------------------------------------------------------------------------
1040  *                            Helper Methods - private
1041  * ---------------------------------------------------------------------------------
1042  */
1043
1044 //________________________________________________________________________
1045 TParticle* AliAnalysisTasktrigger::GetChargedPhysicalPrimary( AliStack* stack, Int_t idx ) {
1046   // return charged physical primary particle
1047
1048   TParticle *particle = stack->Particle(idx);
1049   if (!particle)
1050     return NULL;
1051
1052   // -- primary
1053   if ( !(stack->IsPhysicalPrimary(idx)) )
1054     return NULL;
1055
1056   // -- charged only
1057   if (!particle->GetPDG())
1058     return NULL;
1059
1060   if (particle->GetPDG()->Charge() == 0.0)
1061     return NULL;
1062
1063   return particle;
1064 }
1065
1066 //________________________________________________________________________
1067 Bool_t AliAnalysisTasktrigger::IsFindableMC(Int_t idx, Float_t length) {
1068
1069   //  return kTRUE;
1070
1071   // Ok, if track longer 60cm
1072   AliMCParticle *mcParticle = dynamic_cast<AliMCParticle*> (fMC->GetTrack(idx));
1073   if(!mcParticle)
1074     return kFALSE;
1075
1076   Int_t counter;
1077   Float_t tpcTrackLength = mcParticle->GetTPCTrackLength(AliTracker::GetBz(),0.05,counter,3.0);
1078
1079   if ( tpcTrackLength > length )
1080     return kTRUE;
1081
1082   return kFALSE;
1083 }
1084
1085 //________________________________________________________________________
1086 void AliAnalysisTasktrigger::AddTriggerHist(TH1F* hist) {
1087   // add histogram to output
1088   fOutputContainer->Add(hist);
1089   return;
1090 }
1091
1092 //________________________________________________________________________
1093 void AliAnalysisTasktrigger::AddPtHist(TH1F* hist) {
1094   // add histogram to output
1095   hist->GetXaxis()->SetTitle("P_{T} (GeV/c)");
1096   hist->GetYaxis()->SetTitle("dN/dP_{T} (c/GeV)");
1097   fOutputContainer->Add(hist);
1098   return;
1099 }
1100
1101 //________________________________________________________________________
1102 void AliAnalysisTasktrigger::AddMultHist(TH1F* hist) {
1103   // add histogram to output
1104   hist->GetXaxis()->SetTitle("#ESD tracks");
1105   fOutputContainer->Add(hist);
1106   return;
1107 }
1108