PWGGA/GammaConv/AliAnalysisTaskMaterial.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                                                                                                                                              *
   4  * Authors: Friederike Bock                                                                                                                     *
   5  * Version 1.0                                                                                                                                                          *
   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 ////////////////////////////////////////////////
  17 //---------------------------------------------
  18 // QA Task for V0 Reader V1
  19 //---------------------------------------------
  20 ////////////////////////////////////////////////
  21
  22 #include "AliAnalysisTaskMaterial.h"
  23 #include "TChain.h"
  24 #include "AliAnalysisManager.h"
  25 #include "TParticle.h"
  26 #include "TVectorF.h"
  27 #include "AliPIDResponse.h"
  28 #include "AliESDtrackCuts.h"
  29 #include "TFile.h"
  30
  31 class iostream;
  32
  33 using namespace std;
  34
  35 ClassImp(AliAnalysisTaskMaterial)
  36
  37 AliAnalysisTaskMaterial::AliAnalysisTaskMaterial() : AliAnalysisTaskSE(),
  38    fV0Reader(NULL),
  39    fConversionGammas(NULL),
  40    fConversionCuts(NULL),
  41    fOutputList(NULL),
  42    fEventList(NULL),
  43    fRecGammaList(NULL),
  44    fAllMCGammaList(NULL),
  45    fAllMCConvGammaList(NULL),
  46    fTreeEvent(NULL),
  47    fTreeMaterialRec(NULL),
  48    fTreeMaterialAllGamma(NULL),
  49    fTreeMaterialConvGamma(NULL),
  50    fPrimVtxZ(0.),
  51    fNContrVtx(0),
  52    fNESDtracksEta09(0),
  53    fNESDtracksEta0914(0),
  54    fNESDtracksEta14(0),
  55    fGammaMCPt(0.),
  56    fGammaMCTheta(0.),
  57    fGammaMCConvPt(0.),
  58    fGammaMCConvTheta(0.),
  59    fMCConvCords(5),
  60    fMCConvDaughterProp(4),
  61    fGammaPt(0.),
  62    fGammaTheta(0.),
  63    fGammaChi2NDF(0.),
  64    fRecCords(5),
  65    fDaughterProp(4),
  66    fKind(0),
  67    fIsHeavyIon(0),
  68    fIsMC(kFALSE),
  69    fESDEvent(NULL),
  70    fMCEvent(NULL)
  71 {
  72
  73
  74 }
  75
  76
  77 //________________________________________________________________________
  78 AliAnalysisTaskMaterial::AliAnalysisTaskMaterial(const char *name) : AliAnalysisTaskSE(name),
  79    fV0Reader(NULL),
  80    fConversionGammas(NULL),
  81    fConversionCuts(NULL),
  82    fOutputList(NULL),
  83    fEventList(NULL),
  84    fRecGammaList(NULL),
  85    fAllMCGammaList(NULL),
  86    fAllMCConvGammaList(NULL),
  87    fTreeEvent(NULL),
  88    fTreeMaterialRec(NULL),
  89    fTreeMaterialAllGamma(NULL),
  90    fTreeMaterialConvGamma(NULL),
  91    fPrimVtxZ(0.),
  92    fNContrVtx(0),
  93    fNESDtracksEta09(0),
  94    fNESDtracksEta0914(0),
  95    fNESDtracksEta14(0),
  96    fGammaMCPt(0.),
  97    fGammaMCTheta(0.),
  98    fGammaMCConvPt(0.),
  99    fGammaMCConvTheta(0.),
 100    fMCConvCords(5),
 101    fMCConvDaughterProp(4),
 102    fGammaPt(0.),
 103    fGammaTheta(0.),
 104    fGammaChi2NDF(0.),
 105    fRecCords(5),
 106    fDaughterProp(4),
 107    fKind(0),
 108    fIsHeavyIon(0),
 109    fIsMC(kFALSE),
 110    fESDEvent(NULL),
 111    fMCEvent(NULL)
 112 {
 113         // Default constructor
 114
 115
 116         DefineInput(0, TChain::Class());
 117         DefineOutput(1, TList::Class());
 118 }
 119
 120 //________________________________________________________________________
 121 AliAnalysisTaskMaterial::~AliAnalysisTaskMaterial()
 122 {
 123         // default deconstructor
 124 }
 125 //________________________________________________________________________
 126 void AliAnalysisTaskMaterial::UserCreateOutputObjects()
 127 {
 128         // Create User Output Objects
 129
 130         if(fOutputList != NULL){
 131                 delete fOutputList;
 132                 fOutputList = NULL;
 133         }
 134         if(fOutputList == NULL){
 135                 fOutputList = new TList();
 136                 fOutputList->SetOwner(kTRUE);
 137         }
 138
 139         fEventList = new TList();
 140         fEventList->SetName("EventList");
 141         fEventList->SetOwner(kTRUE);
 142         fOutputList->Add(fEventList);
 143
 144         fTreeEvent = new TTree("Event","Event");
 145         fTreeEvent->Branch("primVtxZ",&fPrimVtxZ,"fPrimVtxZ/F");
 146         fTreeEvent->Branch("nContrVtx",&fNContrVtx,"fNContrVtx/I");
 147         fTreeEvent->Branch("nGoodTracksEta09",&fNESDtracksEta09,"fNESDtracksEta09/I");
 148         fTreeEvent->Branch("nGoodTracksEta0914",&fNESDtracksEta0914,"fNESDtracksEta0914/I");
 149         fTreeEvent->Branch("nGoodTracksEta14",&fNESDtracksEta14,"fNESDtracksEta14/I");
 150         fEventList->Add(fTreeEvent);
 151
 152         fRecGammaList= new TList();
 153         fRecGammaList->SetName("RecGammaList");
 154         fRecGammaList->SetOwner(kTRUE);
 155         fOutputList->Add(fRecGammaList);
 156
 157         fTreeMaterialRec = new TTree("ConvPointRec","ConvPointRec");
 158         fTreeMaterialRec->Branch("recCords",&fRecCords);
 159         fTreeMaterialRec->Branch("daughterProp",&fDaughterProp);
 160         fTreeMaterialRec->Branch("pt",&fGammaPt,"fGammaPt/F");
 161         fTreeMaterialRec->Branch("theta",&fGammaTheta,"fGammaTheta/F");
 162         fTreeMaterialRec->Branch("chi2ndf",&fGammaChi2NDF,"fGammaChi2NDF/F");
 163         if (fIsMC) {
 164                 fTreeMaterialRec->Branch("kind",&fKind,"fKind/b");
 165         }
 166         fRecGammaList->Add(fTreeMaterialRec);
 167
 168         if (fIsMC) {
 169                 fAllMCGammaList = new TList();
 170                 fAllMCGammaList->SetName("AllMCGammaList");
 171                 fAllMCGammaList->SetOwner(kTRUE);
 172                 fOutputList->Add(fAllMCGammaList);
 173
 174                 fTreeMaterialAllGamma = new TTree("AllGamma","AllGamma");
 175                 fTreeMaterialAllGamma->Branch("pt",&fGammaMCPt,"fGammaMCPt/F");
 176                 fTreeMaterialAllGamma->Branch("theta",&fGammaMCTheta,"fGammaMCTheta/F");
 177                 fAllMCGammaList->Add(fTreeMaterialAllGamma);
 178
 179                 fAllMCConvGammaList = new TList();
 180                 fAllMCConvGammaList->SetName("AllMCGammaConvList");
 181                 fAllMCConvGammaList->SetOwner(kTRUE);
 182                 fOutputList->Add(fAllMCConvGammaList);
 183
 184         //       fMCConvCords = new Float_t[5];
 185         //       fMCConvDaughterProp = new Float_t[4];
 186
 187
 188                 fTreeMaterialConvGamma = new TTree("ConvGammaMC","ConvGammaMC");
 189                 fTreeMaterialConvGamma->Branch("Cords",&fMCConvCords);
 190                 fTreeMaterialConvGamma->Branch("daughterProp",&fMCConvDaughterProp);
 191                 fTreeMaterialConvGamma->Branch("Pt",&fGammaMCConvPt,"fGammaMCConvPt/F");
 192                 fTreeMaterialConvGamma->Branch("Theta",&fGammaMCConvTheta,"fGammaMCConvTheta/F");
 193                 fAllMCConvGammaList->Add(fTreeMaterialConvGamma);
 194         }
 195
 196         PostData(1, fOutputList);
 197
 198 }
 199
 200 //________________________________________________________________________
 201 void AliAnalysisTaskMaterial::UserExec(Option_t *){
 202
 203         fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 204
 205         Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
 206                 if(eventQuality != 0){// Event Not Accepted
 207                 return;
 208         }
 209         fESDEvent = (AliESDEvent*) InputEvent();
 210         if (fESDEvent==NULL) return;
 211         if(MCEvent()){
 212                 fMCEvent = MCEvent();
 213         }
 214
 215         if(MCEvent()){
 216                 // Process MC Particle
 217                 if(fConversionCuts->GetSignalRejection() != 0){
 218 //              if(fESDEvent->IsA()==AliESDEvent::Class()){
 219                         fConversionCuts->GetNotRejectedParticles(       fConversionCuts->GetSignalRejection(),
 220                                                                                                                 fConversionCuts->GetAcceptedHeader(),
 221                                                                                                                 fMCEvent);
 222 //              }
 223 //              else if(fInputEvent->IsA()==AliAODEvent::Class()){
 224 //                      fConversionCuts->GetNotRejectedParticles(       fConversionCuts->GetSignalRejection(),
 225 //                                                                                                              fConversionCuts->GetAcceptedHeader(),
 226 //                                                                                                              fInputEvent);
 227 //              }
 228                 }
 229         }
 230
 231         if(fIsHeavyIon > 0 && !fConversionCuts->IsCentralitySelected(fESDEvent)) return;
 232         fNESDtracksEta09 = CountTracks09(); // Estimate Event Multiplicity
 233         fNESDtracksEta0914 = CountTracks0914(); // Estimate Event Multiplicity
 234         fNESDtracksEta14 = fNESDtracksEta09 + fNESDtracksEta0914;
 235         if(fESDEvent){
 236                 if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()>0) {
 237                         fNContrVtx = fESDEvent->GetPrimaryVertexTracks()->GetNContributors();
 238                 } else {
 239                         fNContrVtx = 0;
 240                 }
 241 //              else if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()<1) {
 242 //                      if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()>0) {
 243 //                              fNContrVtx = fESDEvent->GetPrimaryVertexSPD()->GetNContributors();
 244 //                      } else if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()<1) {
 245 //                              fNContrVtx = 0;
 246 //                      }
 247 //              }
 248         }
 249         fPrimVtxZ = fESDEvent->GetPrimaryVertex()->GetZ();
 250
 251         if (fIsHeavyIon == 2){
 252                 if (!(fNESDtracksEta09 > 20 && fNESDtracksEta09 < 80)) return;
 253         }
 254
 255
 256         if (fTreeEvent){
 257                 fTreeEvent->Fill();
 258         }
 259
 260         fConversionGammas=fV0Reader->GetReconstructedGammas();
 261         ProcessPhotons();
 262         if(MCEvent()){
 263                 ProcessMCPhotons();
 264         }
 265         PostData(1, fOutputList);
 266 }
 267
 268 ///________________________________________________________________________
 269 void AliAnalysisTaskMaterial::FillMCTree(Int_t stackPos){
 270         AliStack *MCStack = fMCEvent->Stack();
 271         TParticle* candidate = (TParticle *)MCStack->Particle(stackPos);
 272
 273         if(fConversionCuts->PhotonIsSelectedMC(candidate,MCStack,kFALSE)){
 274                 fGammaMCPt = candidate->Pt();
 275                 fGammaMCTheta = candidate->Theta();
 276                 if (fTreeMaterialAllGamma){
 277                         fTreeMaterialAllGamma->Fill();
 278                 }
 279         }
 280         if(fConversionCuts->PhotonIsSelectedMC(candidate,MCStack,kTRUE)){
 281                 fGammaMCConvPt = candidate->Pt();
 282                 fGammaMCConvTheta = candidate->Theta();
 283                 TParticle* daughter1 = (TParticle *)MCStack->Particle(candidate->GetFirstDaughter());
 284                 TParticle* daughter2 = (TParticle *)MCStack->Particle(candidate->GetLastDaughter());
 285                 fMCConvCords(0) = (Float_t)daughter1->Vx();
 286                 fMCConvCords(1) = (Float_t)daughter1->Vy();
 287                 fMCConvCords(2) = (Float_t)daughter1->Vz();
 288                 fMCConvCords(3) = (Float_t)daughter1->R();
 289                 fMCConvCords(4) = (Float_t)daughter1->Phi();
 290
 291                 fMCConvDaughterProp(0) = (Float_t)daughter1->Pt();
 292                 fMCConvDaughterProp(1) = (Float_t)daughter1->Theta();
 293                 fMCConvDaughterProp(2) = (Float_t)daughter2->Pt();
 294                 fMCConvDaughterProp(3) = (Float_t)daughter2->Theta();
 295
 296                 if (fTreeMaterialConvGamma){
 297                         fTreeMaterialConvGamma->Fill();
 298                 }
 299         } // Converted MC Gamma
 300 }
 301
 302 ///________________________________________________________________________
 303 void AliAnalysisTaskMaterial::ProcessMCPhotons(){
 304         // Loop over all primary MC particle
 305         AliStack *ffMCStack = fMCEvent->Stack();
 306         for(Int_t i = 0; i < ffMCStack->GetNprimary(); i++) {
 307                 TParticle* particle = (TParticle *)ffMCStack->Particle(i);
 308                 if (!particle) continue;
 309                 Int_t isMCFromMBHeader = -1;
 310                 if(fConversionCuts->GetSignalRejection() != 0){
 311                         isMCFromMBHeader
 312                                 = fConversionCuts->IsParticleFromBGEvent(i, ffMCStack, fESDEvent);
 313                         if(isMCFromMBHeader == 0) continue;
 314                 }
 315                 if (particle->GetPdgCode() == 111 && particle->GetFirstDaughter() >= ffMCStack->GetNprimary()){
 316 //                      cout << "Undecayed pi0 found with mother: " << particle->GetMother(0) << endl;
 317                         for (Int_t j = 0; j < 2 ; j++){
 318                                 FillMCTree(particle->GetDaughter(j));
 319                         }
 320                 } else {
 321                         FillMCTree(i);
 322                 }
 323         }
 324 }
 325
 326 ///________________________________________________________________________
 327 void AliAnalysisTaskMaterial::ProcessPhotons(){
 328
 329                 // Fill Histograms for QA and MC
 330         for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
 331                 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
 332                 if (gamma ==NULL) continue;
 333                 if(!fConversionCuts->PhotonIsSelected(gamma,fESDEvent)) continue;
 334
 335                 fGammaPt = gamma->GetPhotonPt();
 336                 fGammaTheta = gamma->GetPhotonTheta();
 337                 fGammaChi2NDF = gamma->GetChi2perNDF();
 338                 fRecCords(0) = (Float_t)gamma->GetConversionX();
 339                 fRecCords(1) = (Float_t)gamma->GetConversionY();
 340                 fRecCords(2) = (Float_t)gamma->GetConversionZ();
 341                 fRecCords(3) = (Float_t)gamma->GetConversionRadius();
 342                 fRecCords(4) = (Float_t)gamma->GetPhotonPhi();
 343
 344                 AliESDtrack * negTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelNegative());
 345                 AliESDtrack * posTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelPositive());
 346                 fDaughterProp(0) = (Float_t)posTrack->Pt();
 347                 fDaughterProp(1) = (Float_t)posTrack->Theta();
 348                 fDaughterProp(2) = (Float_t)negTrack->Pt();
 349                 fDaughterProp(3) = (Float_t)negTrack->Theta();
 350
 351                 fKind = 9;
 352
 353                 if(fMCEvent){
 354 //                      cout << "generating MC stack"<< endl;
 355                         AliStack *fMCStack = fMCEvent->Stack();
 356                         if (!fMCStack) continue;
 357                         TParticle *posDaughter = gamma->GetPositiveMCDaughter(fMCStack);
 358                         TParticle *negDaughter = gamma->GetNegativeMCDaughter(fMCStack);
 359 //                      cout << "generate Daughters: "<<posDaughter << "\t" << negDaughter << endl;
 360
 361                         if(fMCStack && fConversionCuts->GetSignalRejection() != 0){
 362                                 Int_t isPosFromMBHeader
 363                                 = fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fESDEvent);
 364                                 Int_t isNegFromMBHeader
 365                                 = fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fESDEvent);
 366                                 if( (isNegFromMBHeader < 1) || (isPosFromMBHeader < 1)) continue;
 367                         }
 368
 369                         if(posDaughter == NULL || negDaughter == NULL){
 370                                 fKind = 9; // garbage
 371 //                              cout << "one of the daughters not available" << endl;
 372                         } else if(posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)){
 373                                 // Not Same Mother == Combinatorial Bck
 374                                 fKind = 1;
 375 //                              cout << "not the same mother" << endl;
 376                                 Int_t pdgCodePos;
 377                                 if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
 378                                 Int_t pdgCodeNeg;
 379                                 if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
 380 //                              cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
 381                                 if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11)
 382                                         fKind = 10; //Electron Combinatorial
 383                                 if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11 && (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1))
 384                                         fKind = 15; //direct Electron Combinatorial
 385
 386                                 if(TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==211)
 387                                         fKind = 11; //Pion Combinatorial
 388                                 if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==2212) ||
 389                                         (TMath::Abs(pdgCodePos)==2212 && TMath::Abs(pdgCodeNeg)==211))
 390                                         fKind = 12; //Pion, Proton Combinatorics
 391                                 if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==11) ||
 392                                         (TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==211))
 393                                         fKind = 13; //Pion, Electron Combinatorics
 394                                 if (TMath::Abs(pdgCodePos)==321 || TMath::Abs(pdgCodeNeg)==321)
 395                                         fKind = 14; //Kaon combinatorics
 396
 397                         } else {
 398 //                              cout << "same mother" << endl;
 399                                 Int_t pdgCodePos;
 400                                 if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
 401                                 Int_t pdgCodeNeg;
 402                                 if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
 403 //                              cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
 404                                 Int_t pdgCode;
 405                                 if (gamma->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = gamma->GetMCParticle(fMCStack)->GetPdgCode(); else continue;
 406 //                              cout << "PDG code: " << pdgCode << endl;
 407                                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11)
 408                                         fKind = 2; // combinatorics from hadronic decays
 409                                 else if ( !(pdgCodeNeg==pdgCodePos)){
 410                                         TParticle *truePhotonCanditate = gamma->GetMCParticle(fMCStack);
 411                                         Int_t motherLabelPhoton = truePhotonCanditate->GetMother(0);
 412                                         if(pdgCode == 111)
 413                                                 fKind = 3; // pi0 Dalitz
 414                                         else if (pdgCode == 221)
 415                                                 fKind = 4; // eta Dalitz
 416                                         else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
 417                                                 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
 418                                                         fKind = 0; // primary photons
 419                                                 } else if (pdgCode == 22){
 420                                                         fKind = 5; //secondary photons
 421                                                 }
 422                                         } else  fKind = 9; //garbage
 423                                 } else fKind = 9; //garbage
 424                         }
 425                 }
 426                 if (fTreeMaterialRec){
 427                         fTreeMaterialRec->Fill();
 428                 }
 429         }
 430 }
 431
 432 //________________________________________________________________________
 433 Int_t AliAnalysisTaskMaterial::CountTracks09(){
 434         Int_t fNumberOfESDTracks = 0;
 435         if(fInputEvent->IsA()==AliESDEvent::Class()){
 436         // Using standard function for setting Cuts
 437
 438                 AliStack *fMCStack = NULL;
 439                 if (fMCEvent){
 440                         fMCStack= fMCEvent->Stack();
 441                         if (!fMCStack) return 0;
 442                 }
 443
 444                 Bool_t selectPrimaries=kTRUE;
 445                 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
 446                 EsdTrackCuts->SetMaxDCAToVertexZ(2);
 447                 EsdTrackCuts->SetEtaRange(-0.9, 0.9);
 448                 EsdTrackCuts->SetPtRange(0.15);
 449
 450                 for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
 451                         AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
 452                         if(!curTrack) continue;
 453                         if(EsdTrackCuts->AcceptTrack(curTrack) ){
 454                                 if (fMCEvent){
 455                                         if(fMCStack && fConversionCuts->GetSignalRejection() != 0){
 456                                                 Int_t isFromMBHeader
 457                                                 = fConversionCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
 458                                                 if( (isFromMBHeader < 1) ) continue;
 459                                         }
 460                                 }
 461                                 fNumberOfESDTracks++;
 462                         }
 463                 }
 464                 delete EsdTrackCuts;
 465                 EsdTrackCuts=0x0;
 466         } else if(fInputEvent->IsA()==AliAODEvent::Class()){
 467                 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
 468                         AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
 469                         if(!curTrack->IsPrimaryCandidate()) continue;
 470                         if(abs(curTrack->Eta())>0.9) continue;
 471                         if(curTrack->Pt()<0.15) continue;
 472                         if(abs(curTrack->ZAtDCA())>2) continue;
 473                         fNumberOfESDTracks++;
 474                 }
 475         }
 476
 477         return fNumberOfESDTracks;
 478 }
 479
 480 //________________________________________________________________________
 481 Int_t AliAnalysisTaskMaterial::CountTracks0914(){
 482         Int_t fNumberOfESDTracks = 0;
 483         if(fInputEvent->IsA()==AliESDEvent::Class()){
 484                 // Using standard function for setting Cuts
 485
 486                 AliStack *fMCStack = NULL;
 487                 if (fMCEvent){
 488                         fMCStack= fMCEvent->Stack();
 489                         if (!fMCStack) return 0;
 490                 }
 491
 492                 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
 493                 EsdTrackCuts->SetMaxDCAToVertexZ(5);
 494                 EsdTrackCuts->SetEtaRange(0.9, 1.4);
 495                 EsdTrackCuts->SetPtRange(0.15);
 496
 497                 for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
 498                         AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
 499                         if(!curTrack) continue;
 500                         if(EsdTrackCuts->AcceptTrack(curTrack) ){
 501                                 if (fMCEvent){
 502                                         if(fMCStack && fConversionCuts->GetSignalRejection() != 0){
 503                                                 Int_t isFromMBHeader
 504                                                 = fConversionCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
 505                                                 if( (isFromMBHeader < 1) ) continue;
 506                                         }
 507                                 }
 508                                 fNumberOfESDTracks++;
 509                         }
 510                 }
 511                 EsdTrackCuts->SetEtaRange(-1.4, -0.9);
 512                 for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
 513                         AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
 514                         if(!curTrack) continue;
 515                         if(EsdTrackCuts->AcceptTrack(curTrack) ){
 516                                 if (fMCEvent){
 517                                         if(fMCStack && fConversionCuts->GetSignalRejection() != 0){
 518                                                 Int_t isFromMBHeader
 519                                                 = fConversionCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
 520                                                 if( (isFromMBHeader < 1) ) continue;
 521                                         }
 522                                 }
 523                                 fNumberOfESDTracks++;
 524                         }
 525                 }
 526                 delete EsdTrackCuts;
 527                 EsdTrackCuts=0x0;
 528         } else if(fInputEvent->IsA()==AliAODEvent::Class()){
 529                 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
 530                         AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
 531                         if(abs(curTrack->Eta())<0.9 || abs(curTrack->Eta())>1.4 ) continue;
 532                         if(curTrack->Pt()<0.15) continue;
 533                         if(abs(curTrack->ZAtDCA())>5) continue;
 534                         fNumberOfESDTracks++;
 535                 }
 536         }
 537
 538         return fNumberOfESDTracks;
 539 }
 540
 541 //________________________________________________________________________
 542 void AliAnalysisTaskMaterial::Terminate(Option_t *)
 543 {
 544 //    if (fStreamMaterial){
 545 //       fStreamMaterial->GetFile()->Write();
 546 //    }
 547 }