[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskMaterial.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *																								*
 * Authors: Friederike Bock															*
 * Version 1.0																				*
 *																								*
 * Permission to use, copy, modify and distribute this software and its	 *
 * documentation strictly for non-commercial purposes is hereby granted	 *
 * without fee, provided that the above copyright notice appears in all	 *
 * copies and that both the copyright notice and this permission notice	 *
 * appear in the supporting documentation. The authors make no claims	 *
 * about the suitability of this software for any purpose. It is			*
 * provided "as is" without express or implied warranty.						*
 **************************************************************************/

////////////////////////////////////////////////
//---------------------------------------------
// QA Task for V0 Reader V1
//---------------------------------------------
////////////////////////////////////////////////

#include "AliAnalysisTaskMaterial.h"
#include "TChain.h"
#include "AliAnalysisManager.h"
#include "TParticle.h"
#include "TVectorF.h"
#include "AliPIDResponse.h"
#include "AliESDtrackCuts.h"
#include "TFile.h"

class iostream;

using namespace std;

ClassImp(AliAnalysisTaskMaterial)

AliAnalysisTaskMaterial::AliAnalysisTaskMaterial() : AliAnalysisTaskSE(),
	fV0Reader(NULL),
	fConversionGammas(NULL),
	fConversionCuts(NULL),
	fEventCuts(NULL),
	fOutputList(NULL),
	fEventList(NULL),
	fRecGammaList(NULL),
	fAllMCGammaList(NULL),
	fAllMCConvGammaList(NULL),
	fTreeEvent(NULL),
	fTreeMaterialRec(NULL),
	fTreeMaterialAllGamma(NULL),
	fTreeMaterialConvGamma(NULL),
	fPrimVtxZ(0.),
	fNContrVtx(0),
	fNESDtracksEta09(0),
	fNESDtracksEta0914(0),
	fNESDtracksEta14(0),
	fGammaMCPt(0.),
	fGammaMCTheta(0.),
	fGammaMCConvPt(0.),
	fGammaMCConvTheta(0.),
	fMCConvCords(5),
	fMCConvDaughterProp(4),
	fGammaPt(0.),
	fGammaTheta(0.),
	fGammaChi2NDF(0.),
	fRecCords(5),
	fDaughterProp(4),
	fKind(0),      
	fIsHeavyIon(0),
	fIsMC(kFALSE),
	fESDEvent(NULL),
	fMCEvent(NULL)
{
   
}


//________________________________________________________________________
AliAnalysisTaskMaterial::AliAnalysisTaskMaterial(const char *name) : AliAnalysisTaskSE(name),
	fV0Reader(NULL),
	fConversionGammas(NULL),
	fConversionCuts(NULL),
	fEventCuts(NULL),
	fOutputList(NULL),
	fEventList(NULL),
	fRecGammaList(NULL),
	fAllMCGammaList(NULL),
	fAllMCConvGammaList(NULL),
	fTreeEvent(NULL),
	fTreeMaterialRec(NULL),
	fTreeMaterialAllGamma(NULL),
	fTreeMaterialConvGamma(NULL),
	fPrimVtxZ(0.),
	fNContrVtx(0),
	fNESDtracksEta09(0),
	fNESDtracksEta0914(0),
	fNESDtracksEta14(0),
	fGammaMCPt(0.),
	fGammaMCTheta(0.),
	fGammaMCConvPt(0.),
	fGammaMCConvTheta(0.),
	fMCConvCords(5),
	fMCConvDaughterProp(4),
	fGammaPt(0.),
	fGammaTheta(0.),
	fGammaChi2NDF(0.),
	fRecCords(5),
	fDaughterProp(4),
	fKind(0),      
	fIsHeavyIon(0),
	fIsMC(kFALSE),
	fESDEvent(NULL),
	fMCEvent(NULL)
{
	// Default constructor
	
	DefineInput(0, TChain::Class());
	DefineOutput(1, TList::Class());
}

//________________________________________________________________________
AliAnalysisTaskMaterial::~AliAnalysisTaskMaterial()
{
	// default deconstructor
}
//________________________________________________________________________
void AliAnalysisTaskMaterial::UserCreateOutputObjects()
{
	// Create User Output Objects

	if(fOutputList != NULL){
		delete fOutputList;
		fOutputList = NULL;
	}
	if(fOutputList == NULL){
		fOutputList = new TList();
		fOutputList->SetOwner(kTRUE);
	}
	
	fEventList = new TList();
	fEventList->SetName("EventList");
	fEventList->SetOwner(kTRUE);
	fOutputList->Add(fEventList);
	
	fTreeEvent = new TTree("Event","Event");   
	fTreeEvent->Branch("primVtxZ",&fPrimVtxZ,"fPrimVtxZ/F");
	fTreeEvent->Branch("nContrVtx",&fNContrVtx,"fNContrVtx/I");
	fTreeEvent->Branch("nGoodTracksEta09",&fNESDtracksEta09,"fNESDtracksEta09/I");
	fTreeEvent->Branch("nGoodTracksEta14",&fNESDtracksEta14,"fNESDtracksEta14/I");
	fEventList->Add(fTreeEvent);
	
	fRecGammaList= new TList();
	fRecGammaList->SetName("RecGammaList");
	fRecGammaList->SetOwner(kTRUE);
	fOutputList->Add(fRecGammaList);
		
	fTreeMaterialRec = new TTree("ConvPointRec","ConvPointRec");   
	fTreeMaterialRec->Branch("nGoodTracksEta09",&fNESDtracksEta09,"fNESDtracksEta09/I");
	fTreeMaterialRec->Branch("recCords",&fRecCords);
	fTreeMaterialRec->Branch("daughterProp",&fDaughterProp);
	fTreeMaterialRec->Branch("pt",&fGammaPt,"fGammaPt/F");
	fTreeMaterialRec->Branch("theta",&fGammaTheta,"fGammaTheta/F");
	fTreeMaterialRec->Branch("chi2ndf",&fGammaChi2NDF,"fGammaChi2NDF/F");
	if (fIsMC) {
		fTreeMaterialRec->Branch("kind",&fKind,"fKind/b");
	}   
	fRecGammaList->Add(fTreeMaterialRec);
	
// 	if (fIsMC) {
// 		fAllMCGammaList = new TList();
// 		fAllMCGammaList->SetName("AllMCGammaList");
// 		fAllMCGammaList->SetOwner(kTRUE);
// 		fOutputList->Add(fAllMCGammaList);
// 		
// 		fTreeMaterialAllGamma = new TTree("AllGamma","AllGamma");   
// 		fTreeMaterialAllGamma->Branch("pt",&fGammaMCPt,"fGammaMCPt/F");
// 		fTreeMaterialAllGamma->Branch("theta",&fGammaMCTheta,"fGammaMCTheta/F");
// 		fAllMCGammaList->Add(fTreeMaterialAllGamma);
// 		
// 		fAllMCConvGammaList = new TList();
// 		fAllMCConvGammaList->SetName("AllMCGammaConvList");
// 		fAllMCConvGammaList->SetOwner(kTRUE);
// 		fOutputList->Add(fAllMCConvGammaList);
// 
// 	//       fMCConvCords = new Float_t[5];
// 	//       fMCConvDaughterProp = new Float_t[4];
// 
// 		
// 		fTreeMaterialConvGamma = new TTree("ConvGammaMC","ConvGammaMC");   
// 		fTreeMaterialConvGamma->Branch("Cords",&fMCConvCords);
// 		fTreeMaterialConvGamma->Branch("daughterProp",&fMCConvDaughterProp);
// 		fTreeMaterialConvGamma->Branch("Pt",&fGammaMCConvPt,"fGammaMCConvPt/F");
// 		fTreeMaterialConvGamma->Branch("Theta",&fGammaMCConvTheta,"fGammaMCConvTheta/F");   
// 		fAllMCConvGammaList->Add(fTreeMaterialConvGamma);
// 	}
	
	PostData(1, fOutputList);
   
}

//________________________________________________________________________
void AliAnalysisTaskMaterial::UserExec(Option_t *){

	fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");

	Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
		if(eventQuality != 0){// Event Not Accepted
		return;
	}
	fESDEvent = (AliESDEvent*) InputEvent();
	if (fESDEvent==NULL) return;
	if(MCEvent()){
		fMCEvent = MCEvent();
	}
 
	if(MCEvent()){
		// Process MC Particle
		if(fEventCuts->GetSignalRejection() != 0){
// 		if(fESDEvent->IsA()==AliESDEvent::Class()){
			fEventCuts->GetNotRejectedParticles(	fEventCuts->GetSignalRejection(),
													fEventCuts->GetAcceptedHeader(),
													fMCEvent);
// 		}
// 		else if(fInputEvent->IsA()==AliAODEvent::Class()){
// 			fEventCuts->GetNotRejectedParticles(	fEventCuts->GetSignalRejection(),
// 													fEventCuts->GetAcceptedHeader(),
// 													fInputEvent);
// 		}
		}
	}
   
	if(fIsHeavyIon > 0 && !fEventCuts->IsCentralitySelected(fESDEvent)) return;
	fNESDtracksEta09 = CountTracks09(); // Estimate Event Multiplicity
	fNESDtracksEta0914 = CountTracks0914(); // Estimate Event Multiplicity
	fNESDtracksEta14 = fNESDtracksEta09 + fNESDtracksEta0914;
	if(fESDEvent){
		if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()>0) {
			fNContrVtx = fESDEvent->GetPrimaryVertexTracks()->GetNContributors();
		} else {
			fNContrVtx = 0;
		}	
// 		else if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()<1) {
// 			if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()>0) {
// 				fNContrVtx = fESDEvent->GetPrimaryVertexSPD()->GetNContributors();
// 			} else if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()<1) {
// 				fNContrVtx = 0;
// 			}
// 		}
	}
	fPrimVtxZ = fESDEvent->GetPrimaryVertex()->GetZ();
	
// 	if (fIsHeavyIon == 2){
// 		if (!(fNESDtracksEta09 > 20 && fNESDtracksEta09 < 80)) return;
// 	}	
	
	
	if (fTreeEvent){
		fTreeEvent->Fill();
	}
		
	fConversionGammas=fV0Reader->GetReconstructedGammas();
	ProcessPhotons();
// 	if(MCEvent()){
// 		ProcessMCPhotons();
// 	}
	PostData(1, fOutputList);
}

// ///________________________________________________________________________
// void AliAnalysisTaskMaterial::FillMCTree(Int_t stackPos){
// 	AliStack *MCStack = fMCEvent->Stack();
// 	TParticle* candidate = (TParticle *)MCStack->Particle(stackPos);
// 	
// 	if(fConversionCuts->PhotonIsSelectedMC(candidate,MCStack,kFALSE)){
// 		fGammaMCPt = candidate->Pt();
// 		fGammaMCTheta = candidate->Theta();
// 		if (fTreeMaterialAllGamma){
// 			fTreeMaterialAllGamma->Fill();
// 		}	
// 	}
// 	if(fConversionCuts->PhotonIsSelectedMC(candidate,MCStack,kTRUE)){
// 		fGammaMCConvPt = candidate->Pt();
// 		fGammaMCConvTheta = candidate->Theta();
// 		TParticle* daughter1 = (TParticle *)MCStack->Particle(candidate->GetFirstDaughter()); 
// 		TParticle* daughter2 = (TParticle *)MCStack->Particle(candidate->GetLastDaughter()); 
// 		fMCConvCords(0) = (Float_t)daughter1->Vx();
// 		fMCConvCords(1) = (Float_t)daughter1->Vy();
// 		fMCConvCords(2) = (Float_t)daughter1->Vz();
// 		fMCConvCords(3) = (Float_t)daughter1->R();
// 		fMCConvCords(4) = (Float_t)daughter1->Phi();
// 		
// 		fMCConvDaughterProp(0) = (Float_t)daughter1->Pt();
// 		fMCConvDaughterProp(1) = (Float_t)daughter1->Theta();
// 		fMCConvDaughterProp(2) = (Float_t)daughter2->Pt();
// 		fMCConvDaughterProp(3) = (Float_t)daughter2->Theta();      
// 			
// 		if (fTreeMaterialConvGamma){
// 			fTreeMaterialConvGamma->Fill();
// 		}
// 	} // Converted MC Gamma		
// }
// 
// ///________________________________________________________________________
// void AliAnalysisTaskMaterial::ProcessMCPhotons(){
// 	// Loop over all primary MC particle
// 	AliStack *ffMCStack = fMCEvent->Stack();
// 	for(Int_t i = 0; i < ffMCStack->GetNprimary(); i++) {
// 		TParticle* particle = (TParticle *)ffMCStack->Particle(i);
// 		if (!particle) continue;
// 		Int_t isMCFromMBHeader = -1;
// 		if(fConversionCuts->GetSignalRejection() != 0){
// 			isMCFromMBHeader
// 				= fConversionCuts->IsParticleFromBGEvent(i, ffMCStack, fESDEvent);
// 			if(isMCFromMBHeader == 0) continue;
// 		}		
// 		if (particle->GetPdgCode() == 111 && particle->GetFirstDaughter() >= ffMCStack->GetNprimary()){
// // 			cout << "Undecayed pi0 found with mother: " << particle->GetMother(0) << endl;
// 			for (Int_t j = 0; j < 2 ; j++){
//  				FillMCTree(particle->GetDaughter(j));
// 			}
// 		} else {
// 			FillMCTree(i);
// 		}	
// 	}	
// }

///________________________________________________________________________
void AliAnalysisTaskMaterial::ProcessPhotons(){

		// Fill Histograms for QA and MC
	for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
		AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
		if (gamma ==NULL) continue;
		if(!fConversionCuts->PhotonIsSelected(gamma,fESDEvent)) continue;

		fNESDtracksEta09 = CountTracks09();
		fGammaPt = gamma->GetPhotonPt();
		fGammaTheta = gamma->GetPhotonTheta();
		fGammaChi2NDF = gamma->GetChi2perNDF();
		fRecCords(0) = (Float_t)gamma->GetConversionX();
		fRecCords(1) = (Float_t)gamma->GetConversionY();
		fRecCords(2) = (Float_t)gamma->GetConversionZ();
		fRecCords(3) = (Float_t)gamma->GetConversionRadius();
		fRecCords(4) = (Float_t)gamma->GetPhotonPhi();
		
		AliESDtrack * negTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelNegative());
		AliESDtrack * posTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelPositive());
		fDaughterProp(0) = (Float_t)posTrack->Pt();
		fDaughterProp(1) = (Float_t)posTrack->Theta();
		fDaughterProp(2) = (Float_t)negTrack->Pt();
		fDaughterProp(3) = (Float_t)negTrack->Theta();

		fKind = 9;	
		
		if(fMCEvent){
// 			cout << "generating MC stack"<< endl;
			AliStack *fMCStack = fMCEvent->Stack();
			if (!fMCStack) continue;
			TParticle *posDaughter = gamma->GetPositiveMCDaughter(fMCStack);
			TParticle *negDaughter = gamma->GetNegativeMCDaughter(fMCStack);
// 			cout << "generate Daughters: "<<posDaughter << "\t" << negDaughter << endl;
		
			if(fMCStack && fEventCuts->GetSignalRejection() != 0){
				Int_t isPosFromMBHeader
				= fEventCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fESDEvent);
				Int_t isNegFromMBHeader
				= fEventCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fESDEvent);
				if( (isNegFromMBHeader < 1) || (isPosFromMBHeader < 1)) continue;
			}
				
			if(posDaughter == NULL || negDaughter == NULL){ 
				fKind = 9; // garbage
// 				cout << "one of the daughters not available" << endl;
			} else if(posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)){ 
				// Not Same Mother == Combinatorial Bck
				fKind = 1;
// 				cout << "not the same mother" << endl;
				Int_t pdgCodePos; 
				if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
				Int_t pdgCodeNeg; 
				if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
// 				cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
				if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11)
					fKind = 10; //Electron Combinatorial
				if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11 && (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1))
					fKind = 15; //direct Electron Combinatorial
				
				if(TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==211)
					fKind = 11; //Pion Combinatorial
				if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==2212) ||
					(TMath::Abs(pdgCodePos)==2212 && TMath::Abs(pdgCodeNeg)==211))
					fKind = 12; //Pion, Proton Combinatorics
				if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==11) ||
					(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==211))
					fKind = 13; //Pion, Electron Combinatorics
				if (TMath::Abs(pdgCodePos)==321 || TMath::Abs(pdgCodeNeg)==321)	
					fKind = 14; //Kaon combinatorics

			} else {
// 				cout << "same mother" << endl;
				Int_t pdgCodePos; 
				if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
				Int_t pdgCodeNeg; 
				if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
// 				cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
				Int_t pdgCode; 
				if (gamma->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = gamma->GetMCParticle(fMCStack)->GetPdgCode(); else continue;
// 				cout << "PDG code: " << pdgCode << endl;
				if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11)
					fKind = 2; // combinatorics from hadronic decays
				else if ( !(pdgCodeNeg==pdgCodePos)){
					TParticle *truePhotonCanditate = gamma->GetMCParticle(fMCStack);
					Int_t motherLabelPhoton = truePhotonCanditate->GetMother(0);
					if(pdgCode == 111) 
						fKind = 3; // pi0 Dalitz
					else if (pdgCode == 221) 
						fKind = 4; // eta Dalitz
					else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
						if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
							fKind = 0; // primary photons
						} else if (pdgCode == 22){
							fKind = 5; //secondary photons
						}		
					} else 	fKind = 9; //garbage
				} else fKind = 9; //garbage
			}					
		}
				
		if (fTreeMaterialRec){
			fTreeMaterialRec->Fill();
		}
	}
}

//________________________________________________________________________
Int_t AliAnalysisTaskMaterial::CountTracks09(){
	Int_t fNumberOfESDTracks = 0;
	if(fInputEvent->IsA()==AliESDEvent::Class()){
	// Using standard function for setting Cuts
		
		AliStack *fMCStack = NULL;
		if (fMCEvent){
			fMCStack= fMCEvent->Stack();
			if (!fMCStack) return 0;
		}	
				
		Bool_t selectPrimaries=kTRUE;
		AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
		EsdTrackCuts->SetMaxDCAToVertexZ(2);
		EsdTrackCuts->SetEtaRange(-0.9, 0.9);
		EsdTrackCuts->SetPtRange(0.15);
		
		for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
			AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
			if(!curTrack) continue;
			if(EsdTrackCuts->AcceptTrack(curTrack) ){
				if (fMCEvent){
					if(fMCStack && fEventCuts->GetSignalRejection() != 0){
						Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
						if( (isFromMBHeader < 1) ) continue;
					}					
				}	
				fNumberOfESDTracks++;
			}	
		}
		delete EsdTrackCuts;
		EsdTrackCuts=0x0;
	} 
	return fNumberOfESDTracks;
}

//________________________________________________________________________
Int_t AliAnalysisTaskMaterial::CountTracks0914(){
	Int_t fNumberOfESDTracks = 0;
	if(fInputEvent->IsA()==AliESDEvent::Class()){
		// Using standard function for setting Cuts
		
		AliStack *fMCStack = NULL;
		if (fMCEvent){
			fMCStack= fMCEvent->Stack();
			if (!fMCStack) return 0;
		}	

		AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
		EsdTrackCuts->SetMaxDCAToVertexZ(5);
		EsdTrackCuts->SetEtaRange(0.9, 1.4);
		EsdTrackCuts->SetPtRange(0.15);
		
		for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
			AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
			if(!curTrack) continue;
			if(EsdTrackCuts->AcceptTrack(curTrack) ){
				if (fMCEvent){
					if(fMCStack && fEventCuts->GetSignalRejection() != 0){
						Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
						if( (isFromMBHeader < 1) ) continue;
					}					
				}	
				fNumberOfESDTracks++;
			}
		}
		EsdTrackCuts->SetEtaRange(-1.4, -0.9);
		for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
			AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
			if(!curTrack) continue;
			if(EsdTrackCuts->AcceptTrack(curTrack) ){
				if (fMCEvent){
					if(fMCStack && fEventCuts->GetSignalRejection() != 0){
						Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
						if( (isFromMBHeader < 1) ) continue;
					}					
				}	
				fNumberOfESDTracks++;
			}	
		}
		delete EsdTrackCuts;
		EsdTrackCuts=0x0;
	} 
	
	return fNumberOfESDTracks;
}

//________________________________________________________________________
void AliAnalysisTaskMaterial::Terminate(Option_t *)
{
//    if (fStreamMaterial){
//       fStreamMaterial->GetFile()->Write();
//    }
}
Commit	Line	Data
ca91a3e1	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
72395bd9	37	AliAnalysisTaskMaterial::AliAnalysisTaskMaterial() : AliAnalysisTaskSE(),
344100c4	38	fV0Reader(NULL),
	39	fConversionGammas(NULL),
	40	fConversionCuts(NULL),
	41	fEventCuts(NULL),
	42	fOutputList(NULL),
	43	fEventList(NULL),
	44	fRecGammaList(NULL),
	45	fAllMCGammaList(NULL),
	46	fAllMCConvGammaList(NULL),
	47	fTreeEvent(NULL),
	48	fTreeMaterialRec(NULL),
	49	fTreeMaterialAllGamma(NULL),
	50	fTreeMaterialConvGamma(NULL),
	51	fPrimVtxZ(0.),
	52	fNContrVtx(0),
	53	fNESDtracksEta09(0),
	54	fNESDtracksEta0914(0),
	55	fNESDtracksEta14(0),
	56	fGammaMCPt(0.),
	57	fGammaMCTheta(0.),
	58	fGammaMCConvPt(0.),
	59	fGammaMCConvTheta(0.),
	60	fMCConvCords(5),
	61	fMCConvDaughterProp(4),
	62	fGammaPt(0.),
	63	fGammaTheta(0.),
	64	fGammaChi2NDF(0.),
	65	fRecCords(5),
	66	fDaughterProp(4),
	67	fKind(0),
	68	fIsHeavyIon(0),
	69	fIsMC(kFALSE),
	70	fESDEvent(NULL),
	71	fMCEvent(NULL)
72395bd9	72	{
72395bd9	73
	74	}
	75
	76
ca91a3e1	77	//________________________________________________________________________
ca91a3e1	78	AliAnalysisTaskMaterial::AliAnalysisTaskMaterial(const char *name) : AliAnalysisTaskSE(name),
344100c4	79	fV0Reader(NULL),
	80	fConversionGammas(NULL),
	81	fConversionCuts(NULL),
	82	fEventCuts(NULL),
	83	fOutputList(NULL),
	84	fEventList(NULL),
	85	fRecGammaList(NULL),
	86	fAllMCGammaList(NULL),
	87	fAllMCConvGammaList(NULL),
	88	fTreeEvent(NULL),
	89	fTreeMaterialRec(NULL),
	90	fTreeMaterialAllGamma(NULL),
	91	fTreeMaterialConvGamma(NULL),
	92	fPrimVtxZ(0.),
	93	fNContrVtx(0),
	94	fNESDtracksEta09(0),
	95	fNESDtracksEta0914(0),
	96	fNESDtracksEta14(0),
	97	fGammaMCPt(0.),
	98	fGammaMCTheta(0.),
	99	fGammaMCConvPt(0.),
	100	fGammaMCConvTheta(0.),
	101	fMCConvCords(5),
	102	fMCConvDaughterProp(4),
	103	fGammaPt(0.),
	104	fGammaTheta(0.),
	105	fGammaChi2NDF(0.),
	106	fRecCords(5),
	107	fDaughterProp(4),
	108	fKind(0),
	109	fIsHeavyIon(0),
	110	fIsMC(kFALSE),
	111	fESDEvent(NULL),
	112	fMCEvent(NULL)
ca91a3e1	113	{
63674d67	114	// Default constructor
63674d67	115
	116	DefineInput(0, TChain::Class());
	117	DefineOutput(1, TList::Class());
ca91a3e1	118	}
	119
	120	//________________________________________________________________________
	121	AliAnalysisTaskMaterial::~AliAnalysisTaskMaterial()
	122	{
63674d67	123	// default deconstructor
ca91a3e1	124	}
	125	//________________________________________________________________________
	126	void AliAnalysisTaskMaterial::UserCreateOutputObjects()
	127	{
63674d67	128	// Create User Output Objects
ca91a3e1	129
63674d67	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");
63674d67	148	fTreeEvent->Branch("nGoodTracksEta14",&fNESDtracksEta14,"fNESDtracksEta14/I");
	149	fEventList->Add(fTreeEvent);
	150
	151	fRecGammaList= new TList();
	152	fRecGammaList->SetName("RecGammaList");
	153	fRecGammaList->SetOwner(kTRUE);
	154	fOutputList->Add(fRecGammaList);
	155
	156	fTreeMaterialRec = new TTree("ConvPointRec","ConvPointRec");
97146ba4	157	fTreeMaterialRec->Branch("nGoodTracksEta09",&fNESDtracksEta09,"fNESDtracksEta09/I");
63674d67	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
97146ba4	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	// }
63674d67	195
63674d67	196	PostData(1, fOutputList);
72395bd9	197
ca91a3e1	198	}
	199
	200	//________________________________________________________________________
	201	void AliAnalysisTaskMaterial::UserExec(Option_t *){
	202
51ead2dc	203	fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
ca91a3e1	204
344100c4	205	Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
51ead2dc	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
344100c4	217	if(fEventCuts->GetSignalRejection() != 0){
51ead2dc	218	// if(fESDEvent->IsA()==AliESDEvent::Class()){
344100c4	219	fEventCuts->GetNotRejectedParticles( fEventCuts->GetSignalRejection(),
	220	fEventCuts->GetAcceptedHeader(),
	221	fMCEvent);
51ead2dc	222	// }
51ead2dc	223	// else if(fInputEvent->IsA()==AliAODEvent::Class()){
344100c4	224	// fEventCuts->GetNotRejectedParticles( fEventCuts->GetSignalRejection(),
	225	// fEventCuts->GetAcceptedHeader(),
	226	// fInputEvent);
51ead2dc	227	// }
	228	}
	229	}
	230
344100c4	231	if(fIsHeavyIon > 0 && !fEventCuts->IsCentralitySelected(fESDEvent)) return;
72395bd9	232	fNESDtracksEta09 = CountTracks09(); // Estimate Event Multiplicity
	233	fNESDtracksEta0914 = CountTracks0914(); // Estimate Event Multiplicity
	234	fNESDtracksEta14 = fNESDtracksEta09 + fNESDtracksEta0914;
ca91a3e1	235	if(fESDEvent){
ca91a3e1	236	if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()>0) {
72395bd9	237	fNContrVtx = fESDEvent->GetPrimaryVertexTracks()->GetNContributors();
51ead2dc	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	}
72395bd9	249	fPrimVtxZ = fESDEvent->GetPrimaryVertex()->GetZ();
ca91a3e1	250
97146ba4	251	// if (fIsHeavyIon == 2){
	252	// if (!(fNESDtracksEta09 > 20 && fNESDtracksEta09 < 80)) return;
	253	// }
ca91a3e1	254
51ead2dc	255
	256	if (fTreeEvent){
	257	fTreeEvent->Fill();
ca91a3e1	258	}
51ead2dc	259
	260	fConversionGammas=fV0Reader->GetReconstructedGammas();
	261	ProcessPhotons();
97146ba4	262	// if(MCEvent()){
	263	// ProcessMCPhotons();
	264	// }
51ead2dc	265	PostData(1, fOutputList);
ca91a3e1	266	}
ca91a3e1	267
97146ba4	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	// }
ca91a3e1	325
	326	///________________________________________________________________________
	327	void AliAnalysisTaskMaterial::ProcessPhotons(){
	328
51ead2dc	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;
72395bd9	334
97146ba4	335	fNESDtracksEta09 = CountTracks09();
51ead2dc	336	fGammaPt = gamma->GetPhotonPt();
72395bd9	337	fGammaTheta = gamma->GetPhotonTheta();
72395bd9	338	fGammaChi2NDF = gamma->GetChi2perNDF();
51ead2dc	339	fRecCords(0) = (Float_t)gamma->GetConversionX();
	340	fRecCords(1) = (Float_t)gamma->GetConversionY();
	341	fRecCords(2) = (Float_t)gamma->GetConversionZ();
	342	fRecCords(3) = (Float_t)gamma->GetConversionRadius();
	343	fRecCords(4) = (Float_t)gamma->GetPhotonPhi();
	344
e5b6e8a6	345	AliESDtrack * negTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelNegative());
51ead2dc	346	AliESDtrack * posTrack = fConversionCuts->GetESDTrack(fESDEvent, gamma->GetTrackLabelPositive());
	347	fDaughterProp(0) = (Float_t)posTrack->Pt();
	348	fDaughterProp(1) = (Float_t)posTrack->Theta();
	349	fDaughterProp(2) = (Float_t)negTrack->Pt();
	350	fDaughterProp(3) = (Float_t)negTrack->Theta();
72395bd9	351
	352	fKind = 9;
	353
ca91a3e1	354	if(fMCEvent){
	355	// cout << "generating MC stack"<< endl;
	356	AliStack *fMCStack = fMCEvent->Stack();
	357	if (!fMCStack) continue;
	358	TParticle *posDaughter = gamma->GetPositiveMCDaughter(fMCStack);
	359	TParticle *negDaughter = gamma->GetNegativeMCDaughter(fMCStack);
	360	// cout << "generate Daughters: "<<posDaughter << "\t" << negDaughter << endl;
51ead2dc	361
344100c4	362	if(fMCStack && fEventCuts->GetSignalRejection() != 0){
51ead2dc	363	Int_t isPosFromMBHeader
344100c4	364	= fEventCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fESDEvent);
51ead2dc	365	Int_t isNegFromMBHeader
344100c4	366	= fEventCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fESDEvent);
51ead2dc	367	if( (isNegFromMBHeader < 1) \|\| (isPosFromMBHeader < 1)) continue;
	368	}
	369
ca91a3e1	370	if(posDaughter == NULL \|\| negDaughter == NULL){
72395bd9	371	fKind = 9; // garbage
ca91a3e1	372	// cout << "one of the daughters not available" << endl;
	373	} else if(posDaughter->GetMother(0) != negDaughter->GetMother(0) \|\| (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)){
	374	// Not Same Mother == Combinatorial Bck
72395bd9	375	fKind = 1;
ca91a3e1	376	// cout << "not the same mother" << endl;
	377	Int_t pdgCodePos;
	378	if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
	379	Int_t pdgCodeNeg;
	380	if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
	381	// cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
	382	if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11)
72395bd9	383	fKind = 10; //Electron Combinatorial
ca91a3e1	384	if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11 && (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1))
72395bd9	385	fKind = 15; //direct Electron Combinatorial
ca91a3e1	386
ca91a3e1	387	if(TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==211)
72395bd9	388	fKind = 11; //Pion Combinatorial
ca91a3e1	389	if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==2212) \|\|
ca91a3e1	390	(TMath::Abs(pdgCodePos)==2212 && TMath::Abs(pdgCodeNeg)==211))
72395bd9	391	fKind = 12; //Pion, Proton Combinatorics
ca91a3e1	392	if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==11) \|\|
ca91a3e1	393	(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==211))
72395bd9	394	fKind = 13; //Pion, Electron Combinatorics
ca91a3e1	395	if (TMath::Abs(pdgCodePos)==321 \|\| TMath::Abs(pdgCodeNeg)==321)
72395bd9	396	fKind = 14; //Kaon combinatorics
ca91a3e1	397
	398	} else {
	399	// cout << "same mother" << endl;
	400	Int_t pdgCodePos;
	401	if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
	402	Int_t pdgCodeNeg;
	403	if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
	404	// cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
	405	Int_t pdgCode;
	406	if (gamma->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = gamma->GetMCParticle(fMCStack)->GetPdgCode(); else continue;
	407	// cout << "PDG code: " << pdgCode << endl;
	408	if(TMath::Abs(pdgCodePos)!=11 \|\| TMath::Abs(pdgCodeNeg)!=11)
72395bd9	409	fKind = 2; // combinatorics from hadronic decays
ca91a3e1	410	else if ( !(pdgCodeNeg==pdgCodePos)){
ca91a3e1	411	TParticle *truePhotonCanditate = gamma->GetMCParticle(fMCStack);
e5b6e8a6	412	Int_t motherLabelPhoton = truePhotonCanditate->GetMother(0);
ca91a3e1	413	if(pdgCode == 111)
72395bd9	414	fKind = 3; // pi0 Dalitz
ca91a3e1	415	else if (pdgCode == 221)
72395bd9	416	fKind = 4; // eta Dalitz
ca91a3e1	417	else if (!(negDaughter->GetUniqueID() != 5 \|\| posDaughter->GetUniqueID() !=5)){
e5b6e8a6	418	if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
72395bd9	419	fKind = 0; // primary photons
ca91a3e1	420	} else if (pdgCode == 22){
72395bd9	421	fKind = 5; //secondary photons
	422	}
	423	} else fKind = 9; //garbage
	424	} else fKind = 9; //garbage
	425	}
ca91a3e1	426	}
97146ba4	427
72395bd9	428	if (fTreeMaterialRec){
51ead2dc	429	fTreeMaterialRec->Fill();
51ead2dc	430	}
ca91a3e1	431	}
	432	}
	433
	434	//________________________________________________________________________
ae947965	435	Int_t AliAnalysisTaskMaterial::CountTracks09(){
51ead2dc	436	Int_t fNumberOfESDTracks = 0;
	437	if(fInputEvent->IsA()==AliESDEvent::Class()){
	438	// Using standard function for setting Cuts
	439
	440	AliStack *fMCStack = NULL;
	441	if (fMCEvent){
	442	fMCStack= fMCEvent->Stack();
	443	if (!fMCStack) return 0;
	444	}
	445
	446	Bool_t selectPrimaries=kTRUE;
	447	AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	448	EsdTrackCuts->SetMaxDCAToVertexZ(2);
	449	EsdTrackCuts->SetEtaRange(-0.9, 0.9);
	450	EsdTrackCuts->SetPtRange(0.15);
	451
	452	for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
	453	AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
	454	if(!curTrack) continue;
	455	if(EsdTrackCuts->AcceptTrack(curTrack) ){
	456	if (fMCEvent){
344100c4	457	if(fMCStack && fEventCuts->GetSignalRejection() != 0){
344100c4	458	Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
51ead2dc	459	if( (isFromMBHeader < 1) ) continue;
	460	}
	461	}
	462	fNumberOfESDTracks++;
	463	}
	464	}
	465	delete EsdTrackCuts;
	466	EsdTrackCuts=0x0;
97146ba4	467	}
51ead2dc	468	return fNumberOfESDTracks;
e5b6e8a6	469	}
e5b6e8a6	470
51ead2dc	471	//________________________________________________________________________
ae947965	472	Int_t AliAnalysisTaskMaterial::CountTracks0914(){
51ead2dc	473	Int_t fNumberOfESDTracks = 0;
	474	if(fInputEvent->IsA()==AliESDEvent::Class()){
	475	// Using standard function for setting Cuts
	476
	477	AliStack *fMCStack = NULL;
	478	if (fMCEvent){
	479	fMCStack= fMCEvent->Stack();
	480	if (!fMCStack) return 0;
	481	}
e5b6e8a6	482
51ead2dc	483	AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	484	EsdTrackCuts->SetMaxDCAToVertexZ(5);
	485	EsdTrackCuts->SetEtaRange(0.9, 1.4);
	486	EsdTrackCuts->SetPtRange(0.15);
	487
	488	for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
	489	AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
	490	if(!curTrack) continue;
	491	if(EsdTrackCuts->AcceptTrack(curTrack) ){
	492	if (fMCEvent){
344100c4	493	if(fMCStack && fEventCuts->GetSignalRejection() != 0){
344100c4	494	Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
51ead2dc	495	if( (isFromMBHeader < 1) ) continue;
	496	}
	497	}
	498	fNumberOfESDTracks++;
	499	}
	500	}
	501	EsdTrackCuts->SetEtaRange(-1.4, -0.9);
	502	for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
	503	AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
	504	if(!curTrack) continue;
	505	if(EsdTrackCuts->AcceptTrack(curTrack) ){
	506	if (fMCEvent){
344100c4	507	if(fMCStack && fEventCuts->GetSignalRejection() != 0){
344100c4	508	Int_t isFromMBHeader = fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack, fESDEvent);
51ead2dc	509	if( (isFromMBHeader < 1) ) continue;
	510	}
	511	}
	512	fNumberOfESDTracks++;
	513	}
	514	}
	515	delete EsdTrackCuts;
	516	EsdTrackCuts=0x0;
97146ba4	517	}
51ead2dc	518
51ead2dc	519	return fNumberOfESDTracks;
ca91a3e1	520	}
ca91a3e1	521
ca91a3e1	522	//________________________________________________________________________
	523	void AliAnalysisTaskMaterial::Terminate(Option_t *)
	524	{
0a2b2b4b	525	// if (fStreamMaterial){
	526	// fStreamMaterial->GetFile()->Write();
	527	// }
ca91a3e1	528	}