#include <TH2I.h>
#include <TList.h>
#include <TChain.h>
-
+#include <TFile.h>
#include <AliAnalysisManager.h>
#include <AliInputEventHandler.h>
#include <AliESDInputHandler.h>
#include <AliAODInputHandler.h>
-#include <AliAnalysisFilter.h>
+#include <TGeoGlobalMagField.h>
#include "AliConversionTrackCuts.h"
#include "AliConversionCuts.h"
+#include "AliConversionMesonCuts.h"
#include "AliAODConversionPhoton.h"
#include "AliAODConversionMother.h"
-#include "AliAnaConvCorrPhoton.h"
-#include "AliAnaConvCorrPion.h"
-#include "AliAnaConvIsolation.h"
+#include "TGrid.h"
+// #include "AliAnaConvCorrPhoton.h"
+// #include "AliAnaConvCorrPion.h"
+// #include "AliAnaConvIsolation.h"
+#include "AliV0ReaderV1.h"
// Author Svein Lindal <slindal@fys.uio.no>
using namespace std;
//________________________________________________________________________
AliAnalysisTaskdPhi::AliAnalysisTaskdPhi(const char *name) : AliAnalysisTaskSE(name),
- fHistograms(NULL),
- fHistoGamma(NULL),
- fHistoPion(NULL),
- fV0Filter(NULL),
- fTrackCuts(NULL),
- fGammas(NULL),
- fPions(NULL),
- hMETracks(NULL),
- hMEPhotons(NULL),
- hMEPions(NULL),
- hMEvents(NULL),
- fPhotonCorr(NULL),
- fPionCorr(NULL),
- fIsoAna(NULL),
- fDeltaAODBranchName("AliAODGammaConversion_gamma"),
- fAxistPt(),
- fAxiscPt(),
- fAxisEta(),
- fAxisPhi(),
- fAxisCent(),
- fAxisZ(),
- fAxisPiM()
+ fHistograms(NULL),
+ fCorrSparse(NULL),
+ fTrigSparse(NULL),
+ fTrackSparse(NULL),
+ fMassSparse(NULL),
+ fV0Reader(NULL),
+ fSaveReaderHists(kFALSE),
+ fV0FilterEvent(NULL),
+ fV0FilterPhoton(NULL),
+ fV0Filters(),
+ fEventFilters(),
+ fEventFilter(NULL),
+ fPhotonFilter(NULL),
+ fMesonFilter(NULL),
+ fMesonFilters(),
+ fTrackFilter(NULL),
+ fTrackFilters(),
+ fGammas(),
+ fTracks(),
+ hMEvents(NULL),
+ hTrackCent(NULL),
+ hTrigPt(NULL),
+ hTrackPt(NULL),
+ hTrigPhi(NULL),
+ fDeltaAODBranchName("AliAODGammaConversion_gamma"),
+ fAxistPt(),
+ fAxiscPt(),
+ fAxisdEta(),
+ fAxisTrigEta(),
+ fAxisAssEta(),
+ fAxisdPhi(),
+ fAxisCent(),
+ fAxisZ(),
+ fAxisPiM(),
+ fAxisTrackFilters(),
+ fAxisV0Filters(),
+ fAxisMesonFilters(),
+ fkTrackAxis(kFALSE),
+ fkV0Axis(kFALSE),
+ fkPionAxis(kFALSE),
+ fAxesList(),
+ fTrigAxesList(),
+ fTrackAxesList(),
+ fMassAxesList(),
+ fDoPhoton(kFALSE),
+ fCorrectionMap(NULL)
{
- //constructor
- fAxistPt.SetNameTitle("tPtAxis", "tPt");
- fAxistPt.Set(20, 0, 100);
+ //constructor
+ SetUpBins();
+
+ DefineInput(0, TChain::Class());
+ DefineOutput(1, TList::Class());
+
+ fGammas.SetOwner(kTRUE);
+ fTracks.SetOwner(kTRUE);
+}
- fAxiscPt.SetNameTitle("cPtAxis", "cPt");
- fAxiscPt.Set(20, 0, 100);
- fAxisEta.SetNameTitle("EtaAxis", "Eta");
- fAxisEta.Set(160, -0.8, 0.8);
- fAxisPhi.SetNameTitle("PhiAxis", "Phi");
- fAxisPhi.Set(128, 0, TMath::TwoPi());
+//________________________________________________________________________
+AliAnalysisTaskdPhi::~AliAnalysisTaskdPhi(){
+ //destructor
+
+ if(fV0FilterEvent)
+ delete fV0FilterEvent;
+ fV0FilterEvent = NULL;
- fAxisZ.SetNameTitle("ZAxis", "Z");
- fAxisZ.Set(4, -10, 10);
+ if(fV0FilterPhoton)
+ delete fV0FilterPhoton;
+ fV0FilterPhoton = NULL;
- fAxisCent.SetNameTitle("CentAxis", "Cent");
- Double_t centbins[5] = {0, 10, 30, 60, 100.1};
- fAxisCent.Set(4, centbins);
+ if(fMesonFilter)
+ delete fMesonFilter;
+ fMesonFilter = NULL;
- Double_t mbins[8] = {0.11, 0.12, 0.13, 0.132, 0.138, 0.14, 0.15, 0.16};
- fAxisPiM.SetNameTitle("InvMassPi0", "Invariant mass");
- fAxisPiM.Set(7, mbins);
+ if(fEventFilter)
+ delete fEventFilter;
+ fEventFilter = NULL;
- fGammas = new TObjArray();
- fGammas->SetOwner(kFALSE);
+ if(fPhotonFilter)
+ delete fPhotonFilter;
+ fPhotonFilter = NULL;
- fPions = new TObjArray();
- fPions->SetOwner(kFALSE);
+ if(fHistograms)
+ delete fHistograms;
+ fHistograms = NULL;
+
+ if(fTrackFilter)
+ delete fTrackFilter;
+ fTrackFilter = NULL;
+
+ fGammas.Delete();
+ fTracks.Delete();
- // Define input and output slots here
- DefineInput(0, TChain::Class());
- //DefineInput(1, TClonesArray::Class());
- DefineOutput(1, TList::Class());
- DefineOutput(2, TList::Class());
- DefineOutput(3, TList::Class());
}
+///________________________________________________________________________
+void AliAnalysisTaskdPhi::SetUpBins() {
+ fAxisTrigEta.SetNameTitle("tEta", "Eta");
+ fAxisTrigEta.Set(320, -0.8, 0.8);
-//________________________________________________________________________
-AliAnalysisTaskdPhi::~AliAnalysisTaskdPhi(){
- //destructor
- if(fPions)
- delete fPions;
- fPions = NULL;
-
- if(fGammas)
- delete fGammas;
- fGammas = NULL;
-
- if(fIsoAna)
- delete fIsoAna;
- fIsoAna = NULL;
+ fAxisAssEta.SetNameTitle("aEta", "Eta");
+ fAxisAssEta.Set(360, -0.9, 0.9);
- if(fV0Filter)
- delete fV0Filter;
- fV0Filter = NULL;
+ fAxisdEta.SetNameTitle("dEta", "Eta");
+ fAxisdEta.Set(34, -1.7, 1.7);
- if(fHistograms)
- delete fHistograms;
- fHistograms = NULL;
+ fAxisdPhi.SetNameTitle("dPhi", "delta Phi");
+ fAxisdPhi.Set(32, -TMath::PiOver2(), 3*TMath::PiOver2());
- if(fHistoPion)
- delete fHistoPion;
- fHistoPion = NULL;
+ Double_t tptbins[10] = {0.1, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 15, 50, 100}; fAxistPt.SetNameTitle("tPt", "tPt");
+ fAxistPt.Set(9, tptbins);
- if(fHistoGamma)
- delete fHistoGamma;
- fHistoGamma = NULL;
+ Double_t cptbins[13] = {0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 8.0, 10.0, 25, 50, 100}; fAxiscPt.SetNameTitle("cPt", "cPt");
+ fAxiscPt.Set(12, cptbins);
+ fAxisZ.SetNameTitle("vertexz", "Z");
+ fAxisZ.Set(4, -10, 10);
+
+ Double_t centbins[5] = {0, 10, 30, 60, 100.1};
+ fAxisCent.SetNameTitle("centrality", "Cent");
+ fAxisCent.Set(4, centbins);
+
+ fAxisPiM.SetNameTitle("InvMassPi0", "Invariant mass");
+ Double_t mbins[7] = {0.1, 0.11, 0.12, 0.15, 0.16, 0.18, 0.2};
+ fAxisPiM.Set(6, mbins);
}
-///________________________________________________________________________
-void AliAnalysisTaskdPhi::SetUpCorrObjects() {
- ///Creat corr obj
- fIsoAna = new AliAnaConvIsolation();
+///________________________________________________________________________
+// void AliAnalysisTaskdPhi::SetUpCorrObjects() {
+ // //Set up corr objects
+ // AliDebug(AliLog::kDebug + 5, "Set Up corr objects");
+
+ // if(fDoPhoton) {
+ // fPhotonCorr = new AliAnaConvCorrPhoton("PhotonCorr","photon %s");
+ // SetUpCorrAxes(fPhotonCorr);
+ // fPhotonCorr->CreateHistograms();
+ // fHistograms->Add(fPhotonCorr->GetHistograms());
+ // }
+
+ // fPionCorr = new AliAnaConvCorrPion("PionCorr", "pion");
+ // SetUpCorrAxes(fPionCorr);
+ // fPionCorr->GetAxisM().Set(fAxisPiM.GetNbins(), fAxisPiM.GetXbins()->GetArray());
+ // fPionCorr->CreateHistograms();
+ // fHistograms->Add(fPionCorr->GetHistograms());
+ //}
+
+ ///________________________________________________________________________
+// void AliAnalysisTaskdPhi::SetUpCorrAxes(AliAnaConvCorrBase * corr) {
+ ///Set up axes in corr object
+ // corr->GetAxisCent().Set(fAxisCent.GetNbins(), fAxisCent.GetXbins()->GetArray());
+ // const Double_t * zbins = fAxisZ.GetXbins()->GetArray();
+ // if(zbins) {
+ // corr->GetAxisZ().Set(fAxisZ.GetNbins(), fAxisZ.GetXbins()->GetArray());
+ // } else {
+ // corr->GetAxisZ().Set(fAxisZ.GetNbins(), fAxisZ.GetBinLowEdge(1), fAxisZ.GetBinUpEdge(fAxisZ.GetNbins()));
+ // }
+
+ // corr->GetAxistPt().Set(fAxistPt.GetNbins(), fAxistPt.GetXbins()->GetArray());
+ // corr->GetAxiscPt().Set(fAxiscPt.GetNbins(), fAxiscPt.GetXbins()->GetArray());
+ // corr->GetAxisdEta().Set(fAxisdEta.GetNbins(), fAxisdEta.GetBinLowEdge(1), fAxisdEta.GetBinUpEdge(fAxisdEta.GetNbins()));
+ // corr->GetAxisTrigEta().Set(fAxisTrigEta.GetNbins(), fAxisTrigEta.GetBinLowEdge(1), fAxisTrigEta.GetBinUpEdge(fAxisTrigEta.GetNbins()));
+ // corr->GetAxisAssEta().Set(fAxisAssEta.GetNbins(), fAxisAssEta.GetBinLowEdge(1), fAxisAssEta.GetBinUpEdge(fAxisAssEta.GetNbins()));
+// }
- fPhotonCorr = new TObjArray();
- fPionCorr = new TObjArray();
-
- TList * hPhoton = new TList();
- hPhoton->SetName("hPhotonCorr");
- hPhoton->SetOwner(kTRUE);
- fHistoGamma->Add(hPhoton);
-
- TList * hPion = new TList();
- hPion->SetName("hPionCorr");
- hPion->SetOwner(kTRUE);
- fHistoPion->Add(hPion);
-
-
- for(Int_t ic = 0; ic < fAxisCent.GetNbins(); ic++) {
- TObjArray * photonArray = new TObjArray();
- photonArray->SetOwner(kTRUE);
- fPhotonCorr->AddAt(photonArray, ic);
-
- TObjArray * pionArray = new TObjArray();
- pionArray->SetOwner(kTRUE);
- fPionCorr->AddAt(pionArray, ic);
-
- TList * photonList = new TList();
- photonList->SetName(Form("photon_%d", ic));
- photonList->SetOwner(kTRUE);
- hPhoton->AddAt(photonList, ic);
-
- TList * pionList = new TList();
- pionList->SetName(Form("pion_%d", ic));
- pionList->SetOwner(kTRUE);
- hPion->AddAt(pionList, ic);
-
-
- for(Int_t iz = 0; iz < fAxisZ.GetNbins(); iz++) {
- TString nameString = Form("%d_%d", ic, iz);
- TString titleString = Form("%f < Z < %f ... %f cent %f",
- fAxisZ.GetBinLowEdge(iz+1), fAxisZ.GetBinUpEdge(iz+1),
- fAxisCent.GetBinLowEdge(ic+1), fAxisCent.GetBinUpEdge(ic+1));
-
-
-
- AliAnaConvCorrPhoton * photonCorr = new AliAnaConvCorrPhoton(Form("PhotonCorr_%s", nameString.Data()), Form("photon %s", titleString.Data()));
- photonArray->AddAt(photonCorr, iz);
- photonCorr->GetAxistPt().Set(fAxistPt.GetNbins(), fAxistPt.GetXbins()->GetArray());
- photonCorr->GetAxiscPt().Set(fAxiscPt.GetNbins(), fAxiscPt.GetXbins()->GetArray());
- photonCorr->CreateHistograms();
- photonList->Add(photonCorr->GetHistograms());
-
- AliAnaConvCorrPion * pionCorr = new AliAnaConvCorrPion(Form("PionCorr_%s", nameString.Data()), Form("pion %s", titleString.Data()));
- pionArray->AddAt(pionCorr, iz);
- pionCorr->GetAxistPt().Set(fAxistPt.GetNbins(), fAxistPt.GetXbins()->GetArray());
- pionCorr->GetAxiscPt().Set(fAxiscPt.GetNbins(), fAxiscPt.GetXbins()->GetArray());
- pionCorr->GetAxisM().Set(fAxisPiM.GetNbins(), fAxisPiM.GetXbins()->GetArray());
- pionCorr->CreateHistograms();
- pionList->Add(pionCorr->GetHistograms());
- }
- }
-}
//________________________________________________________________________
void AliAnalysisTaskdPhi::UserCreateOutputObjects() {
- // Create histograms
-
- fHistograms = new TList();
- fHistograms->SetName("dPhi_histograms");
- fHistograms->SetOwner(kTRUE);
+ // Create histograms
+ // TGrid::Connect("alien://",0,0,"t");
+ // if(!gGrid) AliWarning("no GGrid");
+ // TFile *tfile = TFile::Open("alien:///alice/cern.ch/user/s/slindal/trackMap.root", "READ");
+ // if(tfile) {
+ // THnF * corrmap = dynamic_cast<THnF*>(tfile->Get("hTrackCorr"));
+ // if (corrmap) {
+ // fCorrectionMap = dynamic_cast<THnF*>(THn::CreateHn("corr", "corr", corrmap));
+ // for(Int_t i = 0; i < fCorrectionMap->GetNdimensions(); i++) {
+ // TAxis * axis = fCorrectionMap->GetAxis(i);
+ // axis->SetRange(1, axis->GetNbins());
+ // }
+
+ // cout << "yessssssssssssssssssssssssssssssssssssssssssssssssss"<<endl;
+ // } else {
+ // cout << "xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx"<<endl;
+ // }
+ // tfile->Close();
+ // } else {
+ // cout << "no tfile shit shit shit "<<endl;
+ // AliFatal("file not ther!!!");
+ // }
- fHistoGamma = new TList();
- fHistoGamma->SetName("Gamma_histo");
- fHistoGamma->SetOwner(kTRUE);
+
+ fHistograms = new TList();
+ fHistograms->SetName("dPhi_histograms");
+ fHistograms->SetOwner(kTRUE);
+
+
+ if(!fV0Reader){
+ fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
+ }
+
+ if(!fV0Reader){
+ printf("Error: No V0 Reader");
+ } // GetV0Reader
+
+
+ if(fSaveReaderHists) {
+ AliConversionPhotonCuts * v0cuts = fV0Reader->GetConversionCuts();
+ if(v0cuts) {
+ TList * histograms = v0cuts->GetCutHistograms();
+ if(!histograms) {
+ AliWarning("initializing v0 reader hists");
+ v0cuts->InitCutHistograms("V0Reader", kTRUE);
+ }
+ histograms = v0cuts->GetCutHistograms();
+ if(histograms) {
+ fHistograms->Add(histograms);
+ }
+ }
+ }
+
+ for(Int_t igf = 0; igf < fV0Filters[0].GetEntriesFast(); igf ++){
+ AliConversionPhotonCuts * f = dynamic_cast<AliConversionPhotonCuts*>(fV0Filters[0].At(igf));
+ if(f) {
+ TList * histograms = f->GetCutHistograms();
+ if(histograms) fHistograms->Add(f->GetCutHistograms());
+ }
+ }
- fHistoPion = new TList();
- fHistoPion->SetName("Pion_histo");
- fHistoPion->SetOwner(kTRUE);
+ for(Int_t igf = 0; igf < fV0Filters[1].GetEntriesFast(); igf ++){
+ AliConversionPhotonCuts * f = dynamic_cast<AliConversionPhotonCuts*>(fV0Filters[1].At(igf));
+ if(f) {
+ TList * histograms = f->GetCutHistograms();
+ if(histograms) fHistograms->Add(f->GetCutHistograms());
+ }
+ }
-
- if(fV0Filter) {
- fV0Filter->InitCutHistograms();
- fHistograms->Add(fV0Filter->GetCutHistograms());
- }
-
+ for(Int_t igf = 0; igf < fMesonFilters[0].GetEntriesFast(); igf ++){
+ AliConversionMesonCuts * f = dynamic_cast<AliConversionMesonCuts*>(fMesonFilters[0].At(igf));
+ if(f) {
+ TList * histograms = f->GetCutHistograms();
+ if(histograms) fHistograms->Add(f->GetCutHistograms());
+ }
+ }
- AliConversionTrackCuts * tc = dynamic_cast<AliConversionTrackCuts*>(fTrackCuts);
- if(tc) fHistograms->Add(tc->CreateHistograms());
+ for(Int_t igf = 0; igf < fMesonFilters[1].GetEntriesFast(); igf ++){
+ AliConversionMesonCuts * f = dynamic_cast<AliConversionMesonCuts*>(fMesonFilters[1].At(igf));
+ if(f) {
+ TList * histograms = f->GetCutHistograms();
+ if(histograms) fHistograms->Add(f->GetCutHistograms());
+ }
+ }
- SetUpCorrObjects();
+ if(fV0FilterEvent) {
+ fV0FilterEvent->InitCutHistograms("V0FilterEvent", kFALSE);
+ fHistograms->Add(fV0FilterEvent->GetCutHistograms());
+ }
+ if(fV0FilterPhoton) {
+ fV0FilterPhoton->InitCutHistograms("V0FilterPhoton", kFALSE);
+ fHistograms->Add(fV0FilterPhoton->GetCutHistograms());
+ }
+ if(fMesonFilter) {
+ fMesonFilter->InitCutHistograms("PionFilter", kFALSE);
+ fHistograms->Add(fMesonFilter->GetCutHistograms());
+ }
+ if(fPhotonFilter) {
+ fPhotonFilter->InitCutHistograms("PhotonFilter", kFALSE);
+ fHistograms->Add(fPhotonFilter->GetCutHistograms());
+ }
- ///Set up ME histograms
- TList * MEHistograms = new TList();
- MEHistograms->SetName("MEHistograms");
- MEHistograms->SetOwner(kTRUE);
- fHistograms->Add(MEHistograms);
+ AliConversionTrackCuts * tc = dynamic_cast<AliConversionTrackCuts*>(fTrackFilter);
+ if(tc) {
+ fHistograms->Add(tc->CreateHistograms());
+ }
- hMEvents = new TH2I("hMEvents", "Nevents vs centrality vertexz",
- fAxisZ.GetNbins(), fAxisZ.GetBinLowEdge(1), fAxisZ.GetBinUpEdge(fAxisZ.GetNbins()),
- fAxisCent.GetNbins(), fAxisCent.GetBinLowEdge(1), fAxisCent.GetBinUpEdge(fAxisCent.GetNbins()));
- hMEvents->GetYaxis()->Set(fAxisCent.GetNbins(), fAxisCent.GetXbins()->GetArray());
- MEHistograms->Add(hMEvents);
+ // for(Int_t i = 0; i < fTrackFilters.GetEntriesFast(); i++) {
+ // AliConversionTrackCuts * tc = dynamic_cast<AliConversionTrackCuts*>(fTrackFilters.At(i));
+ // if(tc) fHistograms->Add(tc->CreateHistograms());
+ // }
- TList * outAxesList = new TList();
- outAxesList->Add(&fAxisCent);
- outAxesList->Add(&fAxisZ);
- fHistograms->Add(outAxesList);
+ //SetUpCorrObjects();
- PostData(1, fHistograms);
- PostData(2, fHistoGamma);
- PostData(3, fHistoPion);
+ ///Set up ME histograms
+ TList * MEHistograms = new TList();
+ MEHistograms->SetName("MEHistograms");
+ MEHistograms->SetOwner(kTRUE);
+ fHistograms->Add(MEHistograms);
+
+ hMEvents = new TH2I("hMEvents", "Nevents vs centrality vertexz",
+ fAxisZ.GetNbins(), fAxisZ.GetXbins()->GetArray(),
+ fAxisCent.GetNbins(), fAxisCent.GetXbins()->GetArray());
+ MEHistograms->Add(hMEvents);
+
+ hTrackCent = new TH2I("hTrackCent", "N accepted tracks vs centrality",
+ fAxisCent.GetNbins() > 1 ? (int) (10*(fAxisCent.GetXmax() - fAxisCent.GetXmin())) : 1,
+ fAxisCent.GetXmin(), fAxisCent.GetXmax(),
+ fAxisCent.GetNbins() > 1 ? 900 : 50,
+ 0,
+ fAxisCent.GetNbins() > 1 ? 1800 : 50);
+ MEHistograms->Add(hTrackCent);
+
+ hTrigPt = new TH3F("hTrigPt", "trigger pt", 100, 0., 10.,
+ 10, 0., 50.,
+ 5, 0.05, 0.2);
+ MEHistograms->Add(hTrigPt);
+ hTrackPt = new TH2F("hTrackPt", "track pt", 100, 0, 10, 10, 0, 50);//fAxisCent.GetNbins(), fAxisCent.GetXbins()->GetArray());
+ MEHistograms->Add(hTrackPt);
+ hTrigPhi = new TH1F("hTrigPhi", "trigger pt", 32, 0, 2*TMath::Pi());
+ MEHistograms->Add(hTrigPhi);
+
+
+
+ Int_t ntrackfilters[2] = {fTrackFilters[0].GetEntriesFast(), fTrackFilters[1].GetEntriesFast()};
+ fkTrackAxis = kTRUE;
+ fAxisTrackFilters.SetNameTitle("trackCuts", "trackCuts");
+ fAxisTrackFilters.Set(ntrackfilters[0] + ntrackfilters[1] + 1, -ntrackfilters[0] -0.5, ntrackfilters[1] + 0.5);
+
+ Int_t nV0filters[2] = {fV0Filters[0].GetEntriesFast(), fV0Filters[1].GetEntriesFast()};
+ fkV0Axis = kTRUE;
+ fAxisV0Filters.SetNameTitle("V0Cuts", "V0Cuts");
+ fAxisV0Filters.Set(nV0filters[0] + nV0filters[1] + 1, -nV0filters[0] -0.5, nV0filters[1] + 0.5);
+
+ Int_t nmesonfilters[2] = {fMesonFilters[0].GetEntriesFast(), fMesonFilters[1].GetEntriesFast()};
+ fkPionAxis = kTRUE;
+ fAxisMesonFilters.SetNameTitle("mesonCuts", "mesonCuts");
+ fAxisMesonFilters.Set(nmesonfilters[0] + nmesonfilters[1] + 1, -nmesonfilters[0] -0.5, nmesonfilters[1] + 0.5);
+
+ fAxesList.AddAt(&fAxisdEta, 0);
+ fAxesList.AddAt(&fAxisdPhi, 1);
+ fAxesList.AddAt(&fAxistPt, 2);
+ fAxesList.AddAt(&fAxiscPt, 3);
+ fAxesList.AddAt(&fAxisCent, 4);
+ fAxesList.AddAt(&fAxisZ, 5);
+ fAxesList.AddAt(&fAxisPiM, 6);
+ fAxesList.AddAt(&fAxisTrackFilters, 7);
+ fAxesList.AddAt(&fAxisV0Filters, 8);
+ fAxesList.AddAt(&fAxisMesonFilters, 9);
+
+ fTrackAxesList.AddAt(&fAxisAssEta, 0);
+ fTrackAxesList.AddAt(&fAxistPt, 1);
+ fTrackAxesList.AddAt(&fAxiscPt, 2);
+ fTrackAxesList.AddAt(&fAxisCent, 3);
+ fTrackAxesList.AddAt(&fAxisZ, 4);
+ //fTrackAxesList.AddAt(&fAxisPiM, 5);
+ fTrackAxesList.AddAt(&fAxisTrackFilters, 5);
+ fTrackAxesList.AddAt(&fAxisV0Filters, 6);
+ fTrackAxesList.AddAt(&fAxisMesonFilters, 7);
+
+ fTrigAxesList.AddAt(&fAxisTrigEta, 0);
+ fTrigAxesList.AddAt(&fAxistPt, 1);
+ fTrigAxesList.AddAt(&fAxisCent, 2);
+ fTrigAxesList.AddAt(&fAxisZ, 3);
+ fTrigAxesList.AddAt(&fAxisPiM, 4);
+ fTrigAxesList.AddAt(&fAxisV0Filters, 5);
+ fTrigAxesList.AddAt(&fAxisMesonFilters, 6);
+
+ TList masslist;
+ TAxis massax;
+ massax.SetNameTitle("mass", "mass");
+ massax.Set(360, 0.04, 0.4); //hardcoded! change also in filling!
+
+ masslist.AddAt(&massax, 0);
+ masslist.AddAt(&fAxistPt, 1);
+ masslist.AddAt(&fAxisCent, 2);
+ masslist.AddAt(&fAxisV0Filters, 3);
+ masslist.AddAt(&fAxisMesonFilters, 4);
+
+ fCorrSparse = CreateSparse(TString("pionSparse"), TString("pionSparse"), &fAxesList);
+ fTrackSparse = CreateSparse(TString("trackSparse"), TString("trackSparse"), &fTrackAxesList);
+ fTrigSparse = CreateSparse(TString("trigSparse"), TString("trigSparse"), &fTrigAxesList);
+ fMassSparse = CreateSparse("massSparse", "massSparse", &masslist);
+
+ fHistograms->Add(fCorrSparse);
+ fHistograms->Add(fTrackSparse);
+ fHistograms->Add(fTrigSparse);
+ fHistograms->Add(fMassSparse);
+
+ ///Add gamma and track containers:
+ for(Int_t i = 0; i < fV0Filters[1].GetEntriesFast() + 1; i++) {
+ fGammas.Add(new TObjArray());
+ }
+
+ for(Int_t i = 0; i < fTrackFilters[1].GetEntriesFast() + 1; i++) {
+ fTracks.Add(new TObjArray());
+ }
+ PostData(1, fHistograms);
}
///________________________________________________________________________
THnSparseF * AliAnalysisTaskdPhi::CreateSparse(TString nameString, TString titleString, TList * axesList) {
- ///Create sparse
- const Int_t dim = axesList->GetSize();
-
- TAxis * axes[dim];
- Int_t bins[dim];
- Double_t min[dim];
- Double_t max[dim];
-
- for(Int_t i = 0; i<dim; i++) {
- TAxis * axis = dynamic_cast<TAxis*>(axesList->At(i));
- if(axis) {
- axes[i] = axis;
- } else {
- cout << "AliAnalysisTaskdPhi::CreateSparse: Error error, all the axes are not present in axis list" << endl;
- return NULL;
- }
- }
-
- for(Int_t i = 0; i<dim; i++) {
- bins[i] = axes[i]->GetNbins();
- min[i] = axes[i]->GetBinLowEdge(1);
- max[i] = axes[i]->GetBinUpEdge(axes[i]->GetNbins());
- }
-
- THnSparseF * sparse = new THnSparseF(Form("METracks_%s", nameString.Data()),
- Form("tracks %s", titleString.Data()),
- dim, bins, min, max);
-
- for(Int_t i = 0; i<dim; i++) {
- sparse->GetAxis(i)->SetNameTitle(axes[i]->GetName(), axes[i]->GetTitle() );
- if(axes[i]->GetXbins()->GetSize() > 0) {
- sparse->SetBinEdges(i, axes[i]->GetXbins()->GetArray() );
+ //Create sparse
+ const Int_t dim = axesList->GetSize();
+
+ TAxis * axes[dim];
+ Int_t bins[dim];
+ Double_t min[dim];
+ Double_t max[dim];
+
+ for(Int_t i = 0; i<dim; i++) {
+ TAxis * axis = dynamic_cast<TAxis*>(axesList->At(i));
+ if(axis) axes[i] = axis;
+ else {
+ cout << "AliAnalysisTaskdPhi::CreateSparse: Error error, all the axes are not present in axis list" << endl;
+ return NULL;
+ }
+ }
+
+ for(Int_t i = 0; i<dim; i++) {
+ //cout << axes[i]->GetTitle() << endl;
+ bins[i] = axes[i]->GetNbins();
+ min[i] = axes[i]->GetBinLowEdge(1);
+ max[i] = axes[i]->GetBinUpEdge(axes[i]->GetNbins());
}
- }
- return sparse;
+ THnSparseF * sparse = new THnSparseF(Form("%s", nameString.Data()),
+ Form("%s", titleString.Data()),
+ dim, bins, min, max);
+
+ for(Int_t i = 0; i<dim; i++) {
+ sparse->GetAxis(i)->SetNameTitle(axes[i]->GetName(), axes[i]->GetTitle() );
+ if(axes[i]->GetXbins()->GetSize() > 0) {
+ sparse->SetBinEdges(i, axes[i]->GetXbins()->GetArray() );
+ }
+ }
+ return sparse;
}
//________________________________________________________________________
void AliAnalysisTaskdPhi::UserExec(Option_t *) {
- ///User exec.
+ ///User exec.
+ ///This is a very ugly function, cut the complexity of the logic demands it.
+
- //if(! fV0Filter->EventIsSelected(fInputEvent)) return;
+ AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(fInputEvent);
+ if(esdEvent) {
+ if (!TGeoGlobalMagField::Instance()->GetField()) esdEvent->InitMagneticField();
+ }
- AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
- Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
-
- AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
- if (!inputHandler) {
- cout << "cout no input event handler"<<endl;
- return;
- }
-
- if ( fV0Filter && !fV0Filter->GetPIDResponse() ) {
- if ( inputHandler->GetPIDResponse() ){
- fV0Filter->SetPIDResponse( inputHandler->GetPIDResponse() );
- } else {
-
- //AOD case
- if (isAOD){
- if (!fV0Filter->GetPIDResponse()){
- fV0Filter->InitAODpidUtil(1);
- }
- }
+ //if(! fV0Filter->EventIsSelected(fInputEvent)) return;
+ if(!fV0Reader){
+ AliError("Error: No V0 Reader");
+ return;
+ } // GetV0Reader
+
+ if(!fV0Reader->IsEventSelected()) {
+ return;
}
- }
- Double_t centrality = 0.0;
- Double_t multiplicity = 0.0;
- Double_t eventPlane = 0.0;
- Double_t vertexz = fInputEvent->GetPrimaryVertex()->GetZ();
-
- if(isAOD) {
- AliAODHeader * header = static_cast<AliAODHeader*>(fInputEvent->GetHeader());
- centrality = header->GetCentrality();
- eventPlane = header->GetEventplane();
- multiplicity = header->GetRefMultiplicity();
- if(centrality < 0) centrality = multiplicity;
- } else {
- centrality = static_cast<AliESDEvent*>(fInputEvent)->GetCentrality()->GetCentralityPercentile("V0M");
- eventPlane = fInputEvent->GetEventplane()->GetEventplane("Q");
- }
+ AliDebug(5, "Processing event");
+
+
+ for(Int_t i = 0; i < fGammas.GetEntriesFast(); i++) {
+ static_cast<TObjArray*>(fGammas.At(i))->Clear();
+ }
+ for(Int_t i = 0; i < fTracks.GetEntriesFast(); i++) {
+ static_cast<TObjArray*>(fTracks.At(i))->Clear();
+ }
- const Int_t centBin = GetBin(fAxisCent, centrality);
- const Int_t vertexBin = GetBin(fAxisZ, vertexz);
+
+ AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
+ Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
+
+ AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
+ if (!inputHandler) {
+ cout << "cout no input event handler"<<endl;
+ return;
+ }
- if(DebugLevel () > 4) {
- cout << "centrality: " << centrality << " " << GetBin(fAxisCent, centrality) << endl;
- cout << "vertexz: " << vertexz << " " << GetBin(fAxisZ, vertexz) << endl;
- cout << "eventPlane: " << eventPlane << " " << endl;
- cout << "multiplicity: "<< multiplicity << " " << fInputEvent->GetNumberOfTracks() << endl;
+ for(Int_t igf = 0; igf < fV0Filters[0].GetEntriesFast(); igf++) {
+ AliConversionPhotonCuts * f = dynamic_cast<AliConversionPhotonCuts*>(fV0Filters[0].At(igf));
+ if ( f && !f->GetPIDResponse() ) {
+ if ( inputHandler->GetPIDResponse() ){
+ f->SetPIDResponse( inputHandler->GetPIDResponse() );
+ } else {
+ if (isAOD){
+ if (!f->GetPIDResponse()){
+ f->InitAODpidUtil(1);
+ }
+ }
+ }
+ } else {
+ break;
+ }
+ }
- }
+ for(Int_t igf = 0; igf < fV0Filters[1].GetEntriesFast(); igf++) {
+ AliConversionPhotonCuts * f = dynamic_cast<AliConversionPhotonCuts*>(fV0Filters[1].At(igf));
+ if ( f && !f->GetPIDResponse() ) {
+ if ( inputHandler->GetPIDResponse() ){
+ f->SetPIDResponse( inputHandler->GetPIDResponse() );
+ } else {
+ if (isAOD){
+ if (!f->GetPIDResponse()){
+ f->InitAODpidUtil(1);
+ }
+ }
+ }
+ } else {
+ break;
+ }
+ }
+
+ if ( fV0FilterPhoton && !fV0FilterPhoton->GetPIDResponse() ) {
+ if ( inputHandler->GetPIDResponse() ){
+ fV0FilterPhoton->SetPIDResponse( inputHandler->GetPIDResponse() );
+ } else {
+ //AOD case
+ if (isAOD){
+ if (!fV0FilterPhoton->GetPIDResponse()){
+ fV0FilterPhoton->InitAODpidUtil(1);
+ }
+ }
+ }
+ }
- if(centBin < 0 || vertexBin < 0) {
- AliError("bin out of range");
- //cout << "bad bin"<<endl;
- return;
- }
- fGammas->Clear();
- fPions->Clear();
+ ///Initialize track cuts. Delete tracks that have been constrained to vertex (copies)
+ AliConversionTrackCuts * tc = dynamic_cast<AliConversionTrackCuts*>(fTrackFilter);
+ if(tc) {
+ tc->SetEvent(fInputEvent);
+ tc->DeleteTracks();
+ }
+
+ for(Int_t i = 0; i < fTrackFilters[0].GetEntriesFast(); i++){
+ AliConversionTrackCuts * tct = dynamic_cast<AliConversionTrackCuts*>(fTrackFilters[0].At(i));
+ if(tct) {
+ tct->SetEvent(fInputEvent);
+ tct->DeleteTracks();
+ }
+ }
+ for(Int_t i = 0; i < fTrackFilters[1].GetEntriesFast(); i++){
+ AliConversionTrackCuts * tct = dynamic_cast<AliConversionTrackCuts*>(fTrackFilters[1].At(i));
+ if(tct) {
+ tct->SetEvent(fInputEvent);
+ tct->DeleteTracks();
+ }
+ }
+
+ Double_t centrality = 0.0;
+ Double_t vertexz = fInputEvent->GetPrimaryVertex()->GetZ();
+ if(isAOD) {
+ AliAODHeader * header = static_cast<AliAODHeader*>(fInputEvent->GetHeader());
+ centrality = header->GetCentrality();
+ } else {
+ centrality = static_cast<AliESDEvent*>(fInputEvent)->GetCentrality()->GetCentralityPercentile("V0M");
+ }
+
+ const Int_t centBin = GetBin(fAxisCent, centrality);
+ const Int_t vertexBin = GetBin(fAxisZ, vertexz);
+
+ if(DebugLevel () > 4) {
+ cout << "centrality: " << centrality << " " << GetBin(fAxisCent, centrality) << endl;
+ cout << "vertexz: " << vertexz << " " << GetBin(fAxisZ, vertexz) << endl;
+ }
+
+ if(centBin < 0 || vertexBin < 0) {
+ // AliError("bin out of range");
+ return;
+ }
+
+
+ //TClonesArray * aodGammas = GetConversionGammas(isAOD);
+ TClonesArray * aodGammas = fV0Reader->GetReconstructedGammas();
+ if(!aodGammas) {
+ AliError("no aod gammas found!");
+ return;
+ }
+
+ TObjArray * ggammas = static_cast<TObjArray*>(fGammas.At(0));
+
+ ///Fill arrays of accepted gammas
+ if(DebugLevel() > 1) printf("Number of conversion gammas %d \n", aodGammas->GetEntriesFast());
+ for(Int_t ig = 0; ig < aodGammas->GetEntriesFast(); ig++) {
+ AliAODConversionPhoton * photon = dynamic_cast<AliAODConversionPhoton*>(aodGammas->At(ig));
+ if(!photon) continue;
+ if(!fV0FilterPhoton || fV0FilterPhoton->PhotonIsSelected(photon, fInputEvent)) {
+ ggammas->Add(photon);
+ } else {
+ for(Int_t igf = 0; igf < fV0Filters[1].GetEntriesFast(); igf++) {
+ AliConversionPhotonCuts * gfilter = dynamic_cast<AliConversionPhotonCuts*>(fV0Filters[1].At(igf));
+ if(gfilter && gfilter->PhotonIsSelected(photon, fInputEvent)) {
+ static_cast<TObjArray*>(fGammas.At(igf+1))->Add(photon);
+ }
+ }
+ }
+ }
- TClonesArray * aodGammas = GetConversionGammas(isAOD);
+ Bool_t lowgmap[fV0Filters[0].GetEntriesFast()][ggammas->GetEntriesFast()];
+
+ for(Int_t ig = 0; ig < ggammas->GetEntriesFast(); ig++ ) {
+ AliAODConversionPhoton * gamma = static_cast<AliAODConversionPhoton*>(ggammas->At(ig));
+ for(Int_t igf = 0; igf < fV0Filters[0].GetEntriesFast(); igf++) {
+
+ AliConversionPhotonCuts * v0cuts = static_cast<AliConversionPhotonCuts*>(fV0Filters[0].At(igf));
+ if(!(v0cuts->PhotonIsSelected(gamma, fInputEvent))) {
+ lowgmap[igf][ig] = kTRUE;
+ } else {
+ lowgmap[igf][ig] = kFALSE;
+ }
+ }
+ }
+
- if(!aodGammas) {
- AliError("no aod gammas found!");
- return;
- }
+ if(DebugLevel() > 4) printf("Number of accepted gammas %d \n", ggammas->GetEntriesFast());
+ hMEvents->Fill(vertexz, centrality);
+
+ ///create track array
+ const Int_t ntrackfilters[2] = { fTrackFilters[0].GetEntriesFast(), fTrackFilters[1].GetEntriesFast()};
+
+ TObjArray * ttracks = static_cast<TObjArray*>(fTracks.At(0));
+ const Double_t aetalim[2] = { fAxisAssEta.GetXmin(), fAxisAssEta.GetXmax()};
+ const Double_t aptlim[2] = { fAxiscPt.GetXmin(), fAxiscPt.GetXmax()};
+ for(Int_t iTrack = 0; iTrack < fInputEvent->GetNumberOfTracks(); iTrack++) {
+ AliVTrack * track = static_cast<AliVTrack*>(fInputEvent->GetTrack(iTrack));
+ if(track->Pt() < aptlim[0] || track->Pt() > aptlim[1]) continue;
+ if(track->Eta() < aetalim[0] || track->Eta() > aetalim[1]) continue;
+ if(fTrackFilter->IsSelected(track)) {
+ hTrackPt->Fill(track->Pt(), centrality);
+ ttracks->Add(track);
+ } else {
+ ///upside cuts
+ for(Int_t itf = 1; itf < ntrackfilters[1] + 1; itf++) {
+ AliAnalysisCuts * trackCuts = static_cast<AliAnalysisCuts*>(fTrackFilters[1].At(itf -1));
+ if(trackCuts->IsSelected(track)) {
+ static_cast<TObjArray*>(fTracks.At(itf))->Add(track);
+ }
+ }
+ }
+ }
- if(DebugLevel() > 1) printf("Number of conversion gammas %d \n", aodGammas->GetEntriesFast());
- for(Int_t ig = 0; ig < aodGammas->GetEntriesFast(); ig++) {
- AliAODConversionPhoton * photon = dynamic_cast<AliAODConversionPhoton*>(aodGammas->At(ig));
-
- if(!photon) {
- cout << "can't get photon"<<endl;
- continue;
- }
- if(!VerifyAODGamma(photon)) {
- continue;
+ Bool_t lowtrackmap[ntrackfilters[0]][ttracks->GetEntriesFast()];
+ ///Check lowside cuts
+ for(Int_t iTrack = 0; iTrack < ttracks->GetEntriesFast(); iTrack++ ) {
+ AliVTrack * track = static_cast<AliVTrack*>(ttracks->At(iTrack));
+ for(Int_t itf = 0; itf < ntrackfilters[0]; itf++) {
+ AliAnalysisCuts * trackCuts = static_cast<AliAnalysisCuts*>(fTrackFilters[0].At(itf));
+ if(!trackCuts->IsSelected(track)) {
+ lowtrackmap[itf][iTrack] = kTRUE;
+ } else {
+ lowtrackmap[itf][iTrack] = kFALSE;
+ }
+ }
}
- if(!fV0Filter || fV0Filter->PhotonIsSelected(static_cast<AliConversionPhotonBase*>(photon), fInputEvent)) {
- fGammas->Add(static_cast<TObject*>(photon));
- }
- }
-
- if(DebugLevel() > 4) printf("Number of accepted gammas %d \n", fGammas->GetEntriesFast());
- hMEvents->Fill(vertexz, centrality);
-
-
-
- ///create track array
- TObjArray tracks;
- const Double_t etalim[2] = { fAxisEta.GetBinLowEdge(1), fAxisEta.GetBinUpEdge(fAxisEta.GetNbins())};
- for(Int_t iTrack = 0; iTrack < fInputEvent->GetNumberOfTracks(); iTrack++) {
-
- AliVTrack * track = static_cast<AliVTrack*>(fInputEvent->GetTrack(iTrack));
- if(track->Pt() < fAxiscPt.GetBinLowEdge(1) ) continue;
- if(track->Eta() < etalim[0] || track->Eta() > etalim[1]) continue;
-
-
- if(!fTrackCuts || fTrackCuts->IsSelected((track))) {
- tracks.Add(track);
- //cout <<"a"<<endl;
- } // else {
- // cout <<"b"<<endl;
- // }
- }
-
- Process(fGammas, &tracks, vertexBin, centBin);
-
- PostData(1, fHistograms);
- PostData(2, fHistoGamma);
- PostData(3, fHistoPion);
-
-}
-
+ hTrackCent->Fill(centrality, ttracks->GetEntriesFast());
+
+ const Double_t etalim[2] = { fAxisTrigEta.GetXmin(), fAxisTrigEta.GetXmax()};
+ if(DebugLevel() > 4) printf("Number of accepted gammas, tracks %d %d \n", ggammas->GetEntriesFast(), ttracks->GetEntriesFast());
+
+ //AliAnaConvCorrBase * gCorr = fPhotonCorr; //GetCorrObject(vertexBin, centBin, fPhotonCorr);
+ // AliAnaConvCorrPion * piCorr = fPionCorr; //static_cast<AliAnaConvCorrPion*>(GetCorrObject(vertexBin, centBin, fPionCorr));
+ // if(!piCorr) {
+ // AliError("corr object missing");
+ // return;
+ // }
+
+ TObjArray pions;
-//________________________________________________________________________
-void AliAnalysisTaskdPhi::Process(TObjArray * gammas, TObjArray * tracks, Int_t vertexBin, Int_t centBin) {
- ///Process stuff
+ ///corr values
+ Double_t dphivalues[fAxesList.GetSize()];
+ dphivalues[4] = centrality;
+ dphivalues[5] = vertexz;
- if(DebugLevel() > 4) printf("Number of accepted gammas, tracks %d %d \n", gammas->GetEntriesFast(), tracks->GetEntriesFast());
+ ///Trigger me counters
+ Double_t trigValues[7];
+ trigValues[2] = centrality;
+ trigValues[3] = vertexz;
-
- AliAnaConvCorrBase * gCorr = GetCorrObject(vertexBin, centBin, fPhotonCorr);
- AliAnaConvCorrPion * piCorr = dynamic_cast<AliAnaConvCorrPion*>(GetCorrObject(vertexBin, centBin, fPionCorr));
-
- if(!gCorr || !piCorr) {
- AliError("corr object missing");
- return;
- }
-
- for(Int_t i1 = 0; i1 < gammas->GetEntriesFast(); i1++) {
- AliAODConversionPhoton * ph1 = static_cast<AliAODConversionPhoton*>(gammas->UncheckedAt(i1));
- Int_t tIDs[4] = {ph1->GetLabel(0), ph1->GetLabel(1), -1, -1};
-
- Int_t leading = fIsoAna->IsLeading(static_cast<AliAODConversionParticle*>(ph1), tracks, tIDs);
- if(ph1->Pt() > fAxistPt.GetBinLowEdge(1)) {
- gCorr->CorrelateWithTracks( static_cast<AliAODConversionParticle*>(ph1), tracks, tIDs, leading);
- }
- for(Int_t i2 = 0; i2 < i1; i2++) {
- AliAODConversionPhoton * ph2 = static_cast<AliAODConversionPhoton*>(gammas->UncheckedAt(i2));
-
- if( ph2->GetTrackLabelPositive()==ph1->GetTrackLabelPositive()
- || ph2->GetTrackLabelNegative()==ph1->GetTrackLabelNegative()
- || ph2->GetTrackLabelNegative()==ph1->GetTrackLabelPositive()
- || ph2->GetTrackLabelPositive()==ph1->GetTrackLabelNegative()) {
- continue;
- }
-
- AliAODConversionMother * pion = new AliAODConversionMother(ph1, ph2);
- pion->SetLabels(i1, i2);
-
- if(!fV0Filter || fV0Filter->MesonIsSelected(pion, kTRUE) ) {
-
- Int_t leadingpi = fIsoAna->IsLeading(static_cast<AliAODConversionParticle*>(pion), tracks, tIDs);
- piCorr->FillTriggerCounters(pion, leadingpi);
-
- tIDs[2] = ph2->GetLabel(0);
- tIDs[3] = ph2->GetLabel(1);
- if(pion->Pt() > fAxistPt.GetBinLowEdge(1) &&
- pion->M() > fAxisPiM.GetBinLowEdge(1) &&
- pion->M() < fAxisPiM.GetBinUpEdge(fAxisPiM.GetNbins())) {
- piCorr->CorrelateWithTracks(pion, tracks, tIDs, leadingpi);
+ ///Mass histogram
+ Double_t massval[5];
+ massval[2] = centrality;
+
+ ///Set up track me counters and initialize
+ const Int_t nbins = fAxistPt.GetNbins();
+ Bool_t tmap[fAxistPt.GetNbins()];
+ Bool_t lv0tmap[fAxistPt.GetNbins()][fV0Filters[0].GetEntriesFast()];
+ Bool_t uv0tmap[fAxistPt.GetNbins()][fV0Filters[1].GetEntriesFast()];
+
+ Bool_t lpitmap[fAxistPt.GetNbins()][fMesonFilters[0].GetEntriesFast()];
+ Bool_t upitmap[fAxistPt.GetNbins()][fMesonFilters[1].GetEntriesFast()];
+
+ for(Int_t igf = 0; igf < fV0Filters[0].GetEntriesFast(); igf++) {
+ for(Int_t ptbin = 0; ptbin < fAxistPt.GetNbins(); ptbin++) {
+ lv0tmap[ptbin][igf] = kFALSE;
}
- }
}
- }
-}
+ for(Int_t igf = 0; igf < fV0Filters[1].GetEntriesFast(); igf++) {
+ for(Int_t ptbin = 0; ptbin < fAxistPt.GetNbins(); ptbin++) {
+ uv0tmap[ptbin][igf] = kFALSE;
+ }
+ }
-//________________________________________________________________________
-void AliAnalysisTaskdPhi::Terminate(Option_t *) {
-
- // Draw result to the screen
- // Called once at the end of the query
-}
-
-//________________________________________________________________________
-TClonesArray * AliAnalysisTaskdPhi::GetConversionGammas(Bool_t isAOD) {
-
+ for(Int_t igf = 0; igf < fMesonFilters[0].GetEntriesFast(); igf++) {
+ for(Int_t ptbin = 0; ptbin < fAxistPt.GetNbins(); ptbin++) {
+ lpitmap[ptbin][igf] = kFALSE;
+ }
+ }
- if(isAOD) {
+ for(Int_t igf = 0; igf < fMesonFilters[1].GetEntriesFast(); igf++) {
+ for(Int_t ptbin = 0; ptbin < fAxistPt.GetNbins(); ptbin++) {
+ upitmap[ptbin][igf] = kFALSE;
+ }
+ }
- TClonesArray * gammas = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fDeltaAODBranchName.Data()));
- if(gammas) {
- return gammas;
+ for(Int_t ptbin = 0; ptbin < nbins; ptbin++){
+ tmap[ptbin] = kFALSE;
}
- FindDeltaAODBranchName(fInputEvent);
- gammas = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fDeltaAODBranchName.Data()));
- return gammas;
+ /////////////////////////////////////////
+
+
+ for(Int_t igf1 = 0; igf1 < fV0Filters[1].GetEntriesFast() + 1; igf1++) {
+ TObjArray * gamm1 = static_cast<TObjArray*>(fGammas.At(igf1));
+ for(Int_t i1 = 0; i1 < gamm1->GetEntriesFast(); i1++) {
+ AliAODConversionPhoton * ph1 = static_cast<AliAODConversionPhoton*>(gamm1->UncheckedAt(i1));
+ Int_t tIDs[4] = {ph1->GetLabel(0), ph1->GetLabel(1), -1, -1};
+
+ ///Combine gamma into pions
+ Int_t igmax = 0;
+ for(Int_t igf2 = 0; igf2 <= igf1; igf2++) {
+ TObjArray * gamm2 = NULL;
+ if(igf2 == igf1) {
+ gamm2 = gamm1;
+ igmax = i1;
+ } else {
+ gamm2 = static_cast<TObjArray*>(fGammas.At(igf2));
+ igmax = gamm2->GetEntriesFast();
+ }
+
+ for(Int_t i2 = 0; i2 < igmax; i2++) {
+ AliAODConversionPhoton * ph2 = static_cast<AliAODConversionPhoton*>(gamm2->UncheckedAt(i2));
+
+ if( ph2->GetTrackLabelPositive()==ph1->GetTrackLabelPositive()
+ || ph2->GetTrackLabelNegative()==ph1->GetTrackLabelNegative()
+ || ph2->GetTrackLabelNegative()==ph1->GetTrackLabelPositive()
+ || ph2->GetTrackLabelPositive()==ph1->GetTrackLabelNegative()) {
+ continue;
+ }
+
+ AliAODConversionMother * pion = new AliAODConversionMother(ph1, ph2);
+ if(pion->Eta() < etalim[0] || pion->Eta() > etalim[1]) continue;
+ pion->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
+
+
+ tIDs[2] = ph2->GetLabel(0);
+ tIDs[3] = ph2->GetLabel(1);
+
+ massval[0] = pion->M();
+ massval[1] = pion->Pt();
+ massval[3] = igf1;
+ massval[4] = 0;
+
+ dphivalues[2] = pion->Pt();
+ dphivalues[6] = pion->M();
+ dphivalues[8] = igf1;
+ dphivalues[9] = 0;
+
+ trigValues[0] = pion->Eta();
+ trigValues[1] = pion->Pt();
+ trigValues[4] = pion->M();
+ trigValues[5] = igf1;
+ trigValues[6] = 0;
+
+
+ ///Check that particle is in histo phase space
+ if(pion->Pt() > fAxistPt.GetBinLowEdge(1) && pion->Pt() < fAxistPt.GetXmax() &&
+ pion->Eta() > etalim[0] && pion->Eta() < etalim[1] &&
+ pion->M() > 0.04 && pion->M() < 0.4
+ ) {
+
+
+ if(fMesonFilter->MesonIsSelected(pion, kTRUE)) {
+
+ fMassSparse->Fill(massval);
+
+ Bool_t lpimap[fMesonFilters[0].GetEntriesFast()];
+ ///See if it passes lowside cuts
+ if(igf1 == 0 && igf2 == 0) {
+
+ ///Low side pion
+ massval[3] = 0;
+ for(Int_t ilpf = 0; ilpf < fMesonFilters[0].GetEntriesFast(); ilpf++) {
+ if(!(static_cast<AliConversionMesonCuts*>(fMesonFilters[0].At(ilpf))->MesonIsSelected(pion, kTRUE))) {
+ lpimap[ilpf] = kTRUE;
+ massval[4] = -(ilpf + 1);
+ fMassSparse->Fill(massval);
+ } else {
+ lpimap[ilpf] = kFALSE;
+ }
+ massval[4] = 0;
+ }
+ ///Lowside v0
+ for(Int_t iglf = 0; iglf < fV0Filters[0].GetEntriesFast(); iglf++) {
+ if(lowgmap[iglf][i1] || lowgmap[iglf][i2]){
+ massval[3] = -(iglf+1);
+ fMassSparse->Fill(massval);
+ }
+ }
+ massval[3] = 0;
+ } /// End lowside mass histo fillers
+
+
+ ///Check that particle is in histo phase space
+ if(pion->Pt() > fAxistPt.GetBinLowEdge(1) && pion->Pt() < fAxistPt.GetXmax() &&
+ pion->M() > fAxisPiM.GetXmin() && pion->M() < fAxisPiM.GetXmax() &&
+ pion->Eta() > etalim[0] && pion->Eta() < etalim[1]) {
+
+ const Int_t tbin = fAxistPt.FindFixBin(pion->Pt());
+ ///Fill standard triggers including upside v0 filters
+ fTrigSparse->Fill(trigValues);
+ if(igf1 == 0 && igf2 == 0) {
+ // piCorr->FillTriggerCounters(pion);
+ // piCorr->CorrelateWithTracks(pion, &tracks[0], tIDs, centrality, vertexz);
+ ////Only mix events with pion in signal region
+ hTrigPt->Fill(pion->Pt(), centrality, pion->M());
+ if(pion->M() > 0.1 && pion->M() < 0.15) {
+ hTrigPhi->Fill(pion->Phi());
+ ///Check trigger bin
+ if (tbin > 0 && tbin < (nbins + 1)) {
+ tmap[tbin-1] = kTRUE;
+ }
+ ///Check if trigger also in low side (both gamma present in low side!)
+ for(Int_t ilgf = 0; ilgf < fV0Filters[0].GetEntriesFast(); ilgf++) {
+ if(!lowgmap[ilgf][i1] || !lowgmap[ilgf][i2]) {
+ lv0tmap[tbin-1][ilgf] = kTRUE;
+ }
+ }
+ ///See if the lowside pion filter also passes this, if not
+ for(Int_t ilpf = 0; ilpf < fMesonFilters[0].GetEntriesFast(); ilpf++) {
+ if(!lpimap[ilpf]) {
+ lpitmap[tbin-1][ilpf] = kTRUE;
+ }
+ }
+ }
+ } else {
+ if(pion->M() > 0.1 && pion->M() < 0.15) {
+ uv0tmap[tbin-1][igf1 - 1] = kTRUE;
+ }
+ }
+
+
+ ///Fill the triggers not selected in lowside filters only if passsing standard v0 filter
+ if(igf1 == 0 && igf2 == 0) {
+ ///Lowside v0 filters
+ for(Int_t iglf = 0; iglf < fV0Filters[0].GetEntriesFast(); iglf++) {
+ if(lowgmap[iglf][i1] || lowgmap[iglf][i2]){
+ trigValues[5] = -(iglf+1);
+ fTrigSparse->Fill(trigValues);
+ }
+ }
+ ////Low side pion filters
+ trigValues[5] = 0;
+ for(Int_t iplf = 0; iplf < fMesonFilters[0].GetEntriesFast(); iplf ++) {
+ if(lpimap[iplf]) {
+ trigValues[6] = -(iplf + 1);
+ fTrigSparse->Fill(trigValues);
+ }
+ }
+ } // ifg1 == 0
+
+ trigValues[5] = igf1;
+ trigValues[6] = 0;
+
+ ///////////////////////////////////////////////
+ /// Correlate with tracks
+ ///////////////////////////////////////////////
+
+ Int_t ntf = 1;
+ if(igf1 == 0 && igf2 == 0) {
+ ntf = fTrackFilters[1].GetEntriesFast() + 1;
+ }
+
+ for(Int_t itf = 0; itf < ntf; itf++) {
+ TObjArray * tracks = static_cast<TObjArray*>(fTracks.At(itf));
+ for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
+ AliVTrack * track = static_cast<AliVTrack*>(tracks->At(ij));
+ Int_t tid = track->GetID();
+
+ if(tid == tIDs[0] || tid == tIDs[1] || tid == tIDs[2] || tid == tIDs[3]) {
+ continue;
+ }
+
+ if(tid < 0) {
+ if(-tid-1 == tIDs[0]+1 || -tid-1 == tIDs[1]+1 || -tid-1 == tIDs[2]+1 || -tid-1 == tIDs[3]+1) {
+ continue;
+ }
+ }
+
+ dphivalues[0] = pion->Eta() - track->Eta();
+ dphivalues[1] = GetDPhi(pion->Phi() - track->Phi());
+ dphivalues[3] = track->Pt();
+ dphivalues[7] = itf;
+ dphivalues[8] = igf1;
+ dphivalues[9] = 0;
+ fCorrSparse->Fill(dphivalues, GetTrackCorrection(vertexz, track));
+
+ if(itf == 0 && igf1 == 0 && igf2 == 0) {
+ ///Fill the low side track filters
+ for(Int_t itlf = 0; itlf < fTrackFilters[0].GetEntriesFast(); itlf++) {
+ if(lowtrackmap[itlf][ij]){
+ dphivalues[7] = -(itlf+1);
+ fCorrSparse->Fill(dphivalues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ ///Fill the low side v0 filters
+ dphivalues[7] = 0;
+ for(Int_t iglf = 0; iglf < fV0Filters[0].GetEntriesFast(); iglf++) {
+ if(lowgmap[iglf][i1] || lowgmap[iglf][i2]){
+ dphivalues[8] = -(iglf+1);
+ fCorrSparse->Fill(dphivalues, GetTrackCorrection(vertexz, track));
+ }
+ }
+
+ ///Fill the low side pi filter
+ dphivalues[7] = 0;
+ dphivalues[8] = 0;
+ for(Int_t iplf = 0; iplf < fMesonFilters[0].GetEntriesFast(); iplf ++) {
+ if(lpimap[iplf]) {
+ dphivalues[9] = -(iplf + 1);
+ fCorrSparse->Fill(dphivalues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ } /// end non standard filters track corr
+
+ } // end for tracks
+ } // end trackfilters loop
+ } //end check pion in histogram range to prevent overflow
+ } else {
+ /////////////////////////////
+ //// Not passing standard meson cuts, check upside filters
+ ////////////////////////////
+
+ ///Only check the pions from standard v0 filter
+ if(igf1 == 0 && igf2 == 0) {
+ for(Int_t ipuf = 0; ipuf < fMesonFilters[1].GetEntriesFast(); ipuf++) {
+ if(static_cast<AliConversionMesonCuts*>(fMesonFilters[1].At(ipuf))->MesonIsSelected(pion, kTRUE)) {
+ ///Fill invariant mass hist
+ massval[4] = (ipuf + 1);
+ fMassSparse->Fill(massval);
+ ///Check that particle is in histo phase space --- redundant!
+
+
+
+ if(pion->Pt() > fAxistPt.GetBinLowEdge(1) && pion->Pt() < fAxistPt.GetXmax() &&
+ pion->M() > fAxisPiM.GetXmin() && pion->M() < fAxisPiM.GetXmax() &&
+ pion->Eta() > etalim[0] && pion->Eta() < etalim[1]) {
+
+
+ ////Only mix events with pion in signal region
+ if(pion->M() > 0.1 && pion->M() < 0.15) {
+ const Int_t tbin = fAxistPt.FindFixBin(pion->Pt());
+ upitmap[tbin-1][ipuf] = kTRUE;
+ }
+
+ ///Fill trigger counters
+ trigValues[6] = (ipuf + 1);
+ fTrigSparse->Fill(trigValues);
+
+ ///Correlate with standard tracks
+ for(int ij = 0; ij < ttracks->GetEntriesFast(); ij++) {
+ AliVTrack * track = static_cast<AliVTrack*>(ttracks->At(ij));
+ Int_t tid = track->GetID();
+
+ if(tid == tIDs[0] || tid == tIDs[1] || tid == tIDs[2] || tid == tIDs[3] ) {
+ continue;
+ }
+
+ if(tid < 0) {
+ if(-tid-1 == tIDs[0]+1 || -tid-1 == tIDs[1]+1 || -tid-1 == tIDs[2]+1 || -tid-1 == tIDs[3]+1) {
+ continue;
+ }
+ }
+
+ dphivalues[0] = pion->Eta() - track->Eta();
+ dphivalues[1] = GetDPhi(pion->Phi() - track->Phi());
+ dphivalues[3] = track->Pt();
+ dphivalues[7] = 0; // track filter
+ dphivalues[8] = 0; // v0 filter
+ dphivalues[9] = ipuf + 1; // pion filter
+ fCorrSparse->Fill(dphivalues, GetTrackCorrection(vertexz, track));
+ } /// end track corr
+ }
+ } // MesonIsSelected
+ }
+ }
+ } /// end else .. end upside meson filters
+ /////////////////////////////////////////////
+ } ///Etalim && pt limits
+ } // i2 second gamma
+ }
+ } // i1 first gamma
+ }
+ //FillCounters(&pions, tracks, ntrackfilters, centrality, vertexz);
+
+ ///////Fill track counters after entire event has been passed through
+ ////
+
+ Double_t trackValues[fTrackAxesList.GetSize()];
+ trackValues[3] = centrality;
+ trackValues[4] = vertexz;
+ //trackValues[5] = particle->M(); remove !!!
+
+ for(Int_t tbin = 0; tbin < fAxistPt.GetNbins(); tbin++) {
+ trackValues[1] = fAxistPt.GetBinCenter(tbin+1);
+
+ if(tmap[tbin]) {
+
+ for(Int_t itf = 0; itf < fTrackFilters[1].GetEntriesFast() + 1; itf++) {
+ TObjArray * tracks = static_cast<TObjArray*>(fTracks.At(itf));
+ for(Int_t iTrack = 0; iTrack < tracks->GetEntriesFast(); iTrack++) {
+ AliVTrack * track = static_cast<AliVTrack*>(tracks->At(iTrack));
+ trackValues[0] = track->Eta();
+ trackValues[2] = track->Pt();
+ trackValues[5] = itf;
+ trackValues[6] = 0; ///v0 filter
+ trackValues[7] = 0; ////Pi filter
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track));
+
+ if(itf == 0) {
+ for(Int_t itlf = 0; itlf < fTrackFilters[0].GetEntriesFast(); itlf++) {
+ if(lowtrackmap[itlf][iTrack]) {
+ trackValues[5] = -(itlf + 1);
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track) );
+ }
+ }
+ trackValues[5] = 0;
+
+ ///Check lowside gamma
+ for(Int_t iglf = 0; iglf < fV0Filters[0].GetEntriesFast(); iglf++) {
+ if(!lv0tmap[tbin][iglf]) {
+ trackValues[6] = -(iglf + 1);
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ trackValues[6] = 0;
+
+ ////Check lowside pion
+ for(Int_t iplf = 0; iplf < fMesonFilters[0].GetEntriesFast(); iplf++) {
+ if(!lpitmap[tbin][iplf]) {
+ trackValues[7] = -(iplf + 1);
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ } // itf == 00
+ }
+ }
+ } else {
+ ///If not in main, see if in upside filters
+ ///Do upside v0 filters
+ for(Int_t iguf = 0; iguf < fV0Filters[1].GetEntriesFast(); iguf++) {
+ if (uv0tmap[tbin][iguf] ) {
+
+ //cout << "c vtx " << centrality << vertexz << endl;
+
+ for(Int_t iTrack = 0; iTrack < ttracks->GetEntriesFast(); iTrack++) {
+ AliVTrack * track = static_cast<AliVTrack*>(ttracks->At(iTrack));
+ trackValues[0] = track->Eta();
+ trackValues[2] = track->Pt();
+ trackValues[5] = 0;
+ trackValues[6] = iguf+1; ///v0 filter
+ trackValues[7] = 0; ////Pi filter
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ }
+ ///Do upside pi filter
+ for(Int_t ipuf = 0; ipuf < fMesonFilters[1].GetEntriesFast(); ipuf++) {
+ if (upitmap[tbin][ipuf] ) {
+ //cout << "c2 vtx2 " << centrality << vertexz << endl;
+ for(Int_t iTrack = 0; iTrack < ttracks->GetEntriesFast(); iTrack++) {
+ AliVTrack * track = static_cast<AliVTrack*>(ttracks->At(iTrack));
+ trackValues[0] = track->Eta();
+ trackValues[2] = track->Pt();
+ trackValues[5] = 0;
+ trackValues[6] = 0; ///v0 filter
+ trackValues[7] = ipuf+1; ////Pi filter
+ fTrackSparse->Fill(trackValues, GetTrackCorrection(vertexz, track));
+ }
+ }
+ }
+ }
+ }
+ //////
+ //////
- } else {
- TClonesArray * gammas = dynamic_cast<TClonesArray*>(GetInputData(1));
- return gammas;
- }
+ //piCorr->FillCounters(&pions, tracks, centrality, vertexz);
+
+ PostData(1, fHistograms);
}
-//________________________________________________________________________
-void AliAnalysisTaskdPhi::FindDeltaAODBranchName(AliVEvent * event){
- ///Find aod branch
- TList *list=event->GetList();
- for(Int_t ii=0;ii<list->GetEntries();ii++){
- TString name((list->At(ii))->GetName());
- if(name.BeginsWith("GammaConv")&&name.EndsWith("gamma")){
- fDeltaAODBranchName=name;
- AliInfo(Form("Set DeltaAOD BranchName to: %s",fDeltaAODBranchName.Data()));
- cout <<fDeltaAODBranchName << endl;
- return;
- }
- }
-}
+//_______________________________________________________________________________
+// void AliAnalysisTaskdPhi::FillCounters(TObjArray * particles, TObjArray tracks[], Int_t ntrackfilters, Float_t cent, Float_t vtxz) {
+// return;
+
+
+// //Fill ME Counters
+// const Int_t nbins = fAxistPt.GetNbins();
+// Bool_t tmap[nbins];
+// for(Int_t ptbin = 0; ptbin < nbins; ptbin++){
+// tmap[ptbin] = kFALSE;
+// }
+// }
+
+
+// Double_t trackValues[fTrackAxesList.GetSize()];
+// trackValues[3] = cent;
+// trackValues[4] = vtxz;
+
+// for(Int_t ip = 0; ip < particles->GetEntriesFast(); ip++){
+// AliAODConversionParticle * particle = static_cast<AliAODConversionParticle*>(particles->At(ip));
+
+// Int_t tbin = fAxistPt.FindFixBin(particle->Pt());
+// if (tbin > 0 && tbin < nbins + 1) {
+// if(tmap[tbin - 1] == kTRUE) {
+// continue;
+// } else {
+// tmap[tbin -1 ] = kTRUE;
+
+// trackValues[5] = particle->M();
+// trackValues[1] = particle->Pt();
+
+// for(Int_t itf = 0; itf < ntrackfilters; itf++) {
+// if(fkTrackAxis) trackValues[6] = itf;
+// for(int ij = 0; ij < tracks[itf].GetEntriesFast(); ij++) {
+// AliVTrack * track = static_cast<AliVTrack*>(tracks->UncheckedAt(ij));
+// trackValues[0] = track->Eta();
+// trackValues[2] = track->Pt();
+// fTrackSparse->Fill(trackValues);
+// }
+// }
+// }
+// }
+// }
+// }
-///________________________________________________________________________
-Bool_t AliAnalysisTaskdPhi::VerifyAODGamma(AliAODConversionPhoton * gamma) {
-
- AliAODEvent * event = static_cast<AliAODEvent*>(fInputEvent);
-
- //cout << "label "<< gamma->GetV0Index() << endl;
-
- AliAODv0 * v0 = NULL;
-
- //Int_t v0idx = gamma->GetV0Index();
- for(Int_t i = 0; i < event->GetNumberOfV0s(); i++) {
- AliAODv0 * tv0 = event->GetV0(i);
-
- //cout << i << " " << v0->GetID() << " " << v0->GetSecondaryVtx()->GetID() << " " << v0->GetLabel() << " " << v0->GetSecondaryVtx()->GetLabel() << endl;
-
- if(tv0->GetSecondaryVtx()->GetID() == gamma->GetV0Index() ) {
- v0 = tv0;
- //cout << "found it" << endl;
- break;
- }
- }
-
- if(!v0) {
- //cout << "v0 not found"<<endl;
- return kFALSE;
- }
-
-
- AliAODTrack * d1 = dynamic_cast<AliAODTrack*>(v0->GetDaughter(0));
- AliAODTrack * d2 = dynamic_cast<AliAODTrack*>(v0->GetDaughter(1));
- Int_t t1 = -1;
- Int_t t2 = -2;
+// //________________________________________________________________
+// void AliAnalysisTaskdPhi::CorrelateWithTracks(AliAODConversionParticle * particle, TObjArray tracks[], Int_t ntrackfilters, Bool_t ** lowtrackmap, Int_t nltf, Int_t const tIDs[4], Double_t dphivalues[]) {
+// //Correlate particle with tracks
+// ///Correlate with tracks
- if(d1) t1 = d1->GetID();
- if(d2) t2 = d2->GetID();
+// }
- Int_t g1 = gamma->GetLabel(0);
- Int_t g2 = gamma->GetLabel(1);
+//________________________________________________________________________
+void AliAnalysisTaskdPhi::Terminate(Option_t *) {
+
+ // Draw result to the screen
+ // Called once at the end of the query
+}
- if((t1 == g1 &&
- t2 == g2) ||
- (t1 == g2 &&
- t2 == g1) ) {
- //cout <<"match"<< " " << gamma->Pt() << " " << d1->Pt() + d2->Pt() <<endl;
- return kTRUE;
- }
-
- // else {
+//________________________________________________________________________
+TClonesArray * AliAnalysisTaskdPhi::GetConversionGammas(Bool_t isAOD) {
+ if(isAOD) {
- // cout << g1 << " " << g2 <<endl;
- // cout << t1 << " " << t2 <<endl;
-
- // for(Int_t i = 0; i < event->GetNumberOfV0s(); i++) {
- // v0 = event->GetV0(i);
- // //cout << i << " " << v0->GetSecondaryVtx()->GetID() << " " <<dynamic_cast<AliAODTrack*>(v0->GetDaughter(0))->GetID() << " " << dynamic_cast<AliAODTrack*>(v0->GetDaughter(1))->GetID() << endl;
-
- // }
- // }
+ TClonesArray * gammas = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fDeltaAODBranchName.Data()));
+ if(gammas) {
+ return gammas;
+ }
+
+ FindDeltaAODBranchName(fInputEvent);
+ gammas = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fDeltaAODBranchName.Data()));
+ return gammas;
+
+ } else {
+ TClonesArray * gammas = dynamic_cast<TClonesArray*>(GetInputData(1));
+ return gammas;
+ }
- // Float_t sumdpt = d1->Pt() + d2->Pt();
- // cout << "pt: " << sumdpt << " " << gamma->Pt() << endl;
+}
- return kFALSE;
+//________________________________________________________________________
+void AliAnalysisTaskdPhi::FindDeltaAODBranchName(AliVEvent * event){
+ ///Find aod branch
+ TList *list=event->GetList();
+ for(Int_t ii=0;ii<list->GetEntries();ii++){
+ TString name((list->At(ii))->GetName());
+ if(name.BeginsWith("GammaConv")&&name.EndsWith("gamma")){
+ fDeltaAODBranchName=name;
+ AliDebug(AliLog::kDebug + 5, Form("Set DeltaAOD BranchName to: %s",fDeltaAODBranchName.Data()));
+ return;
+ }
+ }
+}
+
+//________________________________________________________________________
+Double_t AliAnalysisTaskdPhi::GetTrackCorrection(Double_t vtxz, AliVTrack * track) {
+ ////Get track correction from map
+ Int_t coord[4] = {-1, -1, -1, -1};
+ if(fCorrectionMap) {
+ Double_t values[4] = { vtxz, track->Pt(), track->Eta(), track->Phi() };
+ Double_t correction = fCorrectionMap->GetBinContent(fCorrectionMap->GetBin(values, kFALSE), coord);
+ if (fCorrectionMap->IsInRange(coord)) {
+ return correction;
+ }
+ }
+ return 1.0;
+}
-}