ClassImp(AliAnalysisTaskMaterial)
+AliAnalysisTaskMaterial::AliAnalysisTaskMaterial() : AliAnalysisTaskSE(),
+ fV0Reader(NULL),
+ fConversionGammas(NULL),
+ fConversionCuts(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(kFALSE),
+ fIsMC(kFALSE),
+ fESDEvent(NULL),
+ fMCEvent(NULL)
+{
+
+
+}
+
+
//________________________________________________________________________
AliAnalysisTaskMaterial::AliAnalysisTaskMaterial(const char *name) : AliAnalysisTaskSE(name),
+ fV0Reader(NULL),
fConversionGammas(NULL),
fConversionCuts(NULL),
- fStreamMaterial(NULL),
- fStreamResolution(NULL),
- fIsHeavyIon(kFALSE),
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(kFALSE),
+ fIsMC(kFALSE),
fESDEvent(NULL),
fMCEvent(NULL)
{
// Default constructor
+
DefineInput(0, TChain::Class());
DefineOutput(1, TList::Class());
}
AliAnalysisTaskMaterial::~AliAnalysisTaskMaterial()
{
// default deconstructor
- if(fStreamMaterial){
- delete fStreamMaterial;
- fStreamMaterial = 0x0;
- }
- if(fStreamResolution){
- delete fStreamResolution;
- fStreamResolution = 0x0;
- }
}
//________________________________________________________________________
void AliAnalysisTaskMaterial::UserCreateOutputObjects()
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("nGoodTracksEta0914",&fNESDtracksEta0914,"fNESDtracksEta0914/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("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);
+ }
+
// V0 Reader Cuts
TString cutnumber = fConversionCuts->GetCutNumber();
-
- fStreamMaterial = new TTreeSRedirector(Form("GammaConvV1_Material_%s.root",cutnumber.Data()));
- fStreamResolution = new TTreeSRedirector(Form("GammaConvV1_Resolution_%s.root",cutnumber.Data()));
PostData(1, fOutputList);
+
}
//________________________________________________________________________
fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
- if(eventQuality != 0){// Event Not Accepted
+ if(eventQuality != 0){// Event Not Accepted
return;
}
fESDEvent = (AliESDEvent*) InputEvent();
+ if (fESDEvent==NULL) return;
if(fIsHeavyIon && !fConversionCuts->IsCentralitySelected(fESDEvent)) return;
- Int_t nESDtracks = CountESDTracks(); // Estimate Event Multiplicity
- Int_t nContrVtx;
+ fNESDtracksEta09 = CountTracks09(); // Estimate Event Multiplicity
+ fNESDtracksEta0914 = CountTracks0914(); // Estimate Event Multiplicity
+ fNESDtracksEta14 = fNESDtracksEta09 + fNESDtracksEta0914;
if(fESDEvent){
if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()>0) {
- nContrVtx = fESDEvent->GetPrimaryVertexTracks()->GetNContributors();
+ fNContrVtx = fESDEvent->GetPrimaryVertexTracks()->GetNContributors();
} else if(fESDEvent->GetPrimaryVertexTracks()->GetNContributors()<1) {
if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()>0) {
- nContrVtx = fESDEvent->GetPrimaryVertexSPD()->GetNContributors();
-
+ fNContrVtx = fESDEvent->GetPrimaryVertexSPD()->GetNContributors();
} else if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()<1) {
- nContrVtx = 0;
+ fNContrVtx = 0;
}
}
}
- Int_t primVtxZ = fESDEvent->GetPrimaryVertex()->GetZ();
+ fPrimVtxZ = fESDEvent->GetPrimaryVertex()->GetZ();
- if (fStreamMaterial){
- (*fStreamMaterial)<<"Event"
- << "primVtxZ=" << primVtxZ
- << "nContrVtx=" << nContrVtx
- << "nGoodTracks=" << nESDtracks
- << "\n";
+ if (fTreeEvent){
+ fTreeEvent->Fill();
}
fConversionGammas=fV0Reader->GetReconstructedGammas();
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(){
for(Int_t i = 0; i < ffMCStack->GetNprimary(); i++) {
TParticle* particle = (TParticle *)ffMCStack->Particle(i);
if (!particle) continue;
- if(fConversionCuts->PhotonIsSelectedMC(particle,ffMCStack,kFALSE)){
- Float_t gammaPt = particle->Pt();
- Float_t gammaP = particle->P();
- Float_t gammaEta = particle->Eta();
- if (fStreamMaterial){
- (*fStreamMaterial)<<"AllGamma"
- << "pt=" << gammaPt
- << "p=" << gammaP
- << "eta=" << gammaEta
- << "\n";
- }
- }
- if(fConversionCuts->PhotonIsSelectedMC(particle,ffMCStack,kTRUE)){
- Float_t gammaPt = particle->Pt();
- Float_t gammaP = particle->P();
- Float_t gammaEta = particle->Eta();
- TParticle* daughter = (TParticle *)ffMCStack->Particle(particle->GetFirstDaughter());
- Float_t gammaX = daughter->Vx();
- Float_t gammaY = daughter->Vy();
- Float_t gammaZ = daughter->Vz();
- Float_t gammaR = daughter->R();
- Float_t gammaPhi = particle->Phi();
-
- if (fStreamMaterial){
- (*fStreamMaterial)<<"ConvGammaMC"
- << "pt=" << gammaPt
- << "p=" << gammaP
- << "eta=" << gammaEta
- << "X=" << gammaX
- << "Y=" << gammaY
- << "Z=" << gammaZ
- << "R=" << gammaR
- << "Phi=" << gammaPhi
- << "\n";
+ 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));
}
- } // Converted MC Gamma
+ } else {
+ FillMCTree(i);
+ }
}
}
// 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;
-// cout << "i= " <<firstGammaIndex << " of "<< fConversionGammas->GetEntriesFast() << endl;
- Float_t gammaPt = gamma->GetPhotonPt();
- Float_t gammaP = gamma->GetPhotonP();
- Float_t gammaEta = gamma->GetPhotonEta();
- Float_t gammaChi2NDF = gamma->GetChi2perNDF();
- Float_t gammaX = gamma->GetConversionX();
- Float_t gammaY = gamma->GetConversionY();
- Float_t gammaZ = gamma->GetConversionZ();
- Float_t gammaR = gamma->GetConversionRadius();
- Float_t gammaPhi = gamma->GetPhotonPhi();
- UInt_t kind = 9;
+
+ 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();
// cout << "generate Daughters: "<<posDaughter << "\t" << negDaughter << endl;
if(posDaughter == NULL || negDaughter == NULL){
- kind = 9; // garbage
+ 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
- kind = 1;
+ fKind = 1;
// cout << "not the same mother" << endl;
Int_t pdgCodePos;
if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
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)
- kind = 10; //Electron Combinatorial
+ fKind = 10; //Electron Combinatorial
if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11 && (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1))
- kind = 15; //direct Electron Combinatorial
+ fKind = 15; //direct Electron Combinatorial
if(TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==211)
- kind = 11; //Pion Combinatorial
+ fKind = 11; //Pion Combinatorial
if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==2212) ||
(TMath::Abs(pdgCodePos)==2212 && TMath::Abs(pdgCodeNeg)==211))
- kind = 12; //Pion, Proton Combinatorics
+ fKind = 12; //Pion, Proton Combinatorics
if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==11) ||
(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==211))
- kind = 13; //Pion, Electron Combinatorics
+ fKind = 13; //Pion, Electron Combinatorics
if (TMath::Abs(pdgCodePos)==321 || TMath::Abs(pdgCodeNeg)==321)
- kind = 14; //Kaon combinatorics
+ fKind = 14; //Kaon combinatorics
} else {
// cout << "same mother" << endl;
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)
- kind = 2; // combinatorics from hadronic decays
+ fKind = 2; // combinatorics from hadronic decays
else if ( !(pdgCodeNeg==pdgCodePos)){
TParticle *truePhotonCanditate = gamma->GetMCParticle(fMCStack);
+ Int_t motherLabelPhoton = truePhotonCanditate->GetMother(0);
if(pdgCode == 111)
- kind = 3; // pi0 Dalitz
+ fKind = 3; // pi0 Dalitz
else if (pdgCode == 221)
- kind = 4; // eta Dalitz
+ fKind = 4; // eta Dalitz
else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
- if(pdgCode == 22 && negDaughter->GetMother(0) <= fMCStack->GetNprimary()){
- kind = 0; // primary photons
+ if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
+ fKind = 0; // primary photons
} else if (pdgCode == 22){
- kind = 5; //secondary photons
- }
- if(pdgCode == 22){
- Float_t mcPt = truePhotonCanditate->Pt();
- Float_t mcR = gamma->GetNegativeMCDaughter(fMCStack)->R();
- Float_t mcZ = gamma->GetNegativeMCDaughter(fMCStack)->Vz();
- Float_t mcPhi = gamma->GetNegativeMCDaughter(fMCStack)->Phi();
- Float_t mcEta = gamma->GetNegativeMCDaughter(fMCStack)->Eta();
- if (fStreamResolution){
- (*fStreamResolution)<<"Resolution"
- << "ESDpt=" << gammaPt
- << "ESDphi=" << gammaPhi
- << "ESDeta=" << gammaEta
- << "ESDr="<< gammaR
- << "ESDz="<< gammaZ
- << "MCpt=" << mcPt
- << "MCphi=" << mcPhi
- << "MCeta=" << mcEta
- << "MCr="<< mcR
- << "MCz="<< mcZ
- << "chi2ndf=" << gammaChi2NDF
- << "\n";
- }
+ fKind = 5; //secondary photons
}
- } else kind = 9; //garbage
- } else kind = 9; //garbage
- }
-// cout << gammaPt << "\t" << gammaP<< "\t" << gammaEta<< "\t" <<gammaChi2NDF << "\t" << gammaX<< "\t" <<gammaY << "\t" << gammaZ<< "\t" << gammaR<< "\t" << gammaPhi<< "\t" <<kind << endl;
-
- if (fStreamMaterial){
- (*fStreamMaterial)<<"ConvPointRec"
- << "pt=" << gammaPt
- << "p=" << gammaP
- << "eta=" << gammaEta
- << "chi2ndf=" << gammaChi2NDF
- << "kind=" << kind
- << "X=" << gammaX
- << "Y=" << gammaY
- << "Z=" << gammaZ
- << "R=" << gammaR
- << "Phi=" << gammaPhi
- << "\n";
- }
- } else {
- if (fStreamMaterial){
- (*fStreamMaterial)<<"ConvPointRec"
- << "pt=" << gammaPt
- << "p=" << gammaP
- << "eta=" << gammaEta
- << "chi2ndf=" << gammaChi2NDF
- << "X=" << gammaX
- << "Y=" << gammaY
- << "Z=" << gammaZ
- << "R=" << gammaR
- << "Phi=" << gammaPhi
- << "\n";
- }
+ } else fKind = 9; //garbage
+ } else fKind = 9; //garbage
+ }
}
+ if (fTreeMaterialRec){
+ fTreeMaterialRec->Fill();
+ }
}
}
//________________________________________________________________________
-Int_t AliAnalysisTaskMaterial::CountESDTracks(){
-
- AliESDtrackCuts *EsdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
- // Using standard function for setting Cuts
- Bool_t selectPrimaries=kTRUE;
- EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
- EsdTrackCuts->SetMaxDCAToVertexZ(2);
- EsdTrackCuts->SetEtaRange(-0.8, 0.8);
- EsdTrackCuts->SetPtRange(0.15);
-
+Int_t AliAnalysisTaskMaterial::CountTracks09(){
Int_t fNumberOfESDTracks = 0;
- for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
- AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
- if(!curTrack) continue;
- if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
+ if(fInputEvent->IsA()==AliESDEvent::Class()){
+ // Using standard function for setting Cuts
+ 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) ) fNumberOfESDTracks++;
+ }
+ delete EsdTrackCuts;
+ EsdTrackCuts=0x0;
+ }
+ else if(fInputEvent->IsA()==AliAODEvent::Class()){
+ for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
+ AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
+ if(!curTrack->IsPrimaryCandidate()) continue;
+ if(abs(curTrack->Eta())>0.9) continue;
+ if(curTrack->Pt()<0.15) continue;
+ if(abs(curTrack->ZAtDCA())>2) 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
+ 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) ) 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) ) fNumberOfESDTracks++;
+ }
+ delete EsdTrackCuts;
+ EsdTrackCuts=0x0;
+ }
+ else if(fInputEvent->IsA()==AliAODEvent::Class()){
+ for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
+ AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
+ if(abs(curTrack->Eta())<0.9 || abs(curTrack->Eta())>1.4 ) continue;
+ if(curTrack->Pt()<0.15) continue;
+ if(abs(curTrack->ZAtDCA())>5) continue;
+ fNumberOfESDTracks++;
+ }
+ }
+
+ return fNumberOfESDTracks;
+}
//________________________________________________________________________
void AliAnalysisTaskMaterial::Terminate(Option_t *)
{
- if (fStreamMaterial){
- fStreamMaterial->GetFile()->Write();
- }
- if (fStreamResolution){
- fStreamResolution->GetFile()->Write();
- }
+// if (fStreamMaterial){
+// fStreamMaterial->GetFile()->Write();
+// }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff