GammaConv/AliAODConversionMother.cxx
GammaConv/AliKFConversionPhoton.cxx
GammaConv/AliKFConversionMother.cxx
- GammaConv/ConvCorrelations/AliAnalysisTaskGammaJet.cxx
GammaConv/ConvCorrelations/AliAnaConvIsolation.cxx
GammaConv/ConvCorrelations/AliAnaConvCorrBase.cxx
GammaConv/ConvCorrelations/AliAnaConvCorrPion.cxx
#include "TList.h"
#include "AliAODConversionParticle.h"
-
#include <iostream>
// Gamma - jet correlation analysis task
ClassImp(AliAnaConvCorrBase)
//________________________________________________________________________
-AliAnaConvCorrBase::AliAnaConvCorrBase(TString name) : TObject(),
- fName(name),
+AliAnaConvCorrBase::AliAnaConvCorrBase(TString name, TString title = "title") : TNamed(name, title),
fHistograms(NULL),
- fNPhiBins(32),
- fdPhiBins(NULL),
- fPtBins(NULL)
+ fAxesList(NULL),
+ fAxistPt(),
+ fAxiscPt(),
+ fAxisdEta(),
+ fAxisdPhi(),
+ fSparse(NULL)
{
//Constructor
- fPtBins = new TArrayD(41);
- for(Int_t i = 0; i < 10; i++) {
- fPtBins->SetAt(i*0.5, i);
- fPtBins->SetAt(5 + i*0.5, i + 10);
-
- fPtBins->SetAt(10. + i, i+20);
- fPtBins->SetAt(20. + 2*i, i+30);
- }
-
- fPtBins->SetAt(50., fPtBins->GetSize() -1);
- fdPhiBins = new TArrayD(fNPhiBins + 1);
- for(Int_t i = 0; i < fNPhiBins+1; i++) {
- fdPhiBins->SetAt(-TMath::PiOver2() + i*TMath::TwoPi()/fNPhiBins, i);
- }
+ SetUpDefaultBins();
- for(int iIso = 0; iIso < 2; iIso++) {
- fHdPhi[iIso] = NULL;
- fHNTriggers[iIso] = NULL;
- }
-
+ fAxesList.SetOwner(kTRUE);
}
//________________________________________________________________________________
AliAnaConvCorrBase::~AliAnaConvCorrBase() {
///destructor
- if(fPtBins)
- delete fPtBins;
- fPtBins = NULL;
-
- if(fdPhiBins)
- delete fdPhiBins;
- fdPhiBins = NULL;
-
-
}
CreateBaseHistograms();
}
+///________________________________________________________________________________
+void AliAnaConvCorrBase::SetUpDefaultBins() {
+ //Set up default bins
+ Double_t ptbins[19] = {0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 8.0, 10.0, 12.5, 15, 20, 25, 30, 50, 100};
+ fAxisdEta.Set(160, -1.6, 1.6);
+ fAxisdEta.SetNameTitle("dEta", "delta eta");
+ fAxesList.AddAt(&fAxisdEta, 0);
+
+ fAxisdPhi.Set(64, -TMath::PiOver2(), 3*TMath::PiOver2());
+ fAxisdPhi.SetNameTitle("dPhi", "delta Phi");
+ fAxesList.AddAt(&fAxisdPhi, 1);
+
+ fAxistPt.Set(18, ptbins);
+ fAxistPt.SetNameTitle("tPt", "trigger Pt");
+ fAxesList.AddAt(&fAxistPt, 2);
+
+ fAxiscPt.Set(18, ptbins);
+ fAxiscPt.SetNameTitle("cPt", "track Pt");
+ fAxesList.AddAt(&fAxiscPt, 3);
+
+ for(int iIso = 0; iIso < 2; iIso++) {
+ fHNTriggers[iIso] = NULL;
+ }
+}
+
//________________________________________________________________________
void AliAnaConvCorrBase::CreateBaseHistograms() {
//Create histograms add, to outputlis
- cout << "Createing histograms for "<< fName.Data() << endl;
+ cout << "Creating histograms for "<< GetName() << endl;
fHistograms = new TList();
fHistograms->SetOwner(kFALSE);
for(int iIso = 0; iIso < 2; iIso++) {
- fHdPhi[iIso] = new TH3F(Form("%s_%s_dPhi", fName.Data(), (iIso==0)?"nonIso":"isolated"),
- Form("%s_%s_dPhi", fName.Data(), (iIso==0)?"nonIso":"isolated"),
- fPtBins->GetSize() -1, fPtBins->GetArray(),
- fPtBins->GetSize() - 1, fPtBins->GetArray(),
- fdPhiBins->GetSize() - 1, fdPhiBins->GetArray());
- fHdPhi[iIso]->Sumw2();
-
- fHistograms->Add(fHdPhi[iIso]);
-
fHNTriggers[iIso] = new TH1F(Form("%s_%s_fNTriggers", fName.Data(), (iIso==0)?"nonIso":"isolated"),
- Form("%s_%s_fNTriggers", fName.Data(), (iIso==0)?"nonIso":"isolated"),
- fPtBins->GetSize() - 1, fPtBins->GetArray());
+ Form("%s_%s_fNTriggers", fName.Data(), (iIso==0)?"nonIso":"isolated"),
+ fAxistPt.GetNbins(), fAxistPt.GetXbins()->GetArray());
fHNTriggers[iIso]->Sumw2();
fHistograms->Add(fHNTriggers[iIso]);
}
+ fSparse = CreateSparse(GetName(), GetTitle(), &fAxesList);
+ fHistograms->Add(fSparse);
+
}
+///________________________________________________________________________
+THnSparseF * AliAnaConvCorrBase::CreateSparse(TString nameString, TString titleString, TList * axesList) {
+ //Create sparse
+ const Int_t dim = axesList->GetSize();
+
+ cout << "dimesion: " << dim << endl;
+
+ 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;
+ }
+ }
-///____________________________________________________________________________
-void AliAnaConvCorrBase::FillTriggerCounters(Float_t tPt, Bool_t isolated){
- //Fill histogram with trigger counters
+ 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());
+ }
- fHNTriggers[0]->Fill(tPt);
+ THnSparseF * sparse = new THnSparseF(Form("%s", nameString.Data()),
+ Form("%s", titleString.Data()),
+ dim, bins, min, max);
- if(isolated) {
- fHNTriggers[isolated]->Fill(tPt);
-
+ 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 AliAnaConvCorrBase::FillHistograms(Float_t tPt, Float_t cPt, Float_t dPhi, Float_t dEta, Bool_t isolated) {
- //Fill histograms
- if(dEta) { ;}
- fHdPhi[0]->Fill(tPt, cPt, dPhi);
- if(isolated) {
- fHdPhi[isolated]->Fill(tPt, cPt, dPhi);
- }
-}
+///____________________________________________________________________________
+// void AliAnaConvCorrBase::FillTriggerCounters(Float_t tPt, Bool_t isolated){
+// //Fill histogram with trigger counters
+
+// fHNTriggers[0]->Fill(tPt);
+
+// if(isolated) {
+// fHNTriggers[isolated]->Fill(tPt);
+
+// }
+// }
+
+// ///_____________________________________________________________________________
+// void AliAnaConvCorrBase::FillHistograms(Float_t tPt, Float_t cPt, Float_t dPhi, Float_t dEta, Bool_t isolated) {
+// //Fill histograms
+
+// if(dEta) { ;}
+// //fHdPhi[0]->Fill(tPt, cPt, dPhi);
+// if(isolated) {
+// //fHdPhi[isolated]->Fill(tPt, cPt, dPhi);
+// }
+// }
//_______________________________________________________________________________
}
}
+
+
+//_______________________________________________________________________________
+void AliAnaConvCorrBase::FillTriggerCounters(const AliAODConversionParticle * particle, Bool_t leading) {
+ fHNTriggers[leading]->Fill(particle->Pt());
+}
+
+
+//________________________________________________________________
+void AliAnaConvCorrBase::CorrelateWithTracks(AliAODConversionParticle * particle, TObjArray * tracks, Int_t const tIDs[4], Bool_t isolated /*= kFALSE*/) {
+ //Correlate particle with tracks
+
+ FillTriggerCounters(particle, isolated);
+
+ Int_t nDim = fAxesList.GetSize();
+ Double_t dphivalues[nDim];
+
+ for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
+ AliVTrack * track = static_cast<AliVTrack*>(tracks->UncheckedAt(ij));
+ Int_t tid = track->GetID();
+
+ if((tid > 0) && (tid == tIDs[0] || tid == tIDs[1] || tid == tIDs[2] || tid == tIDs[3]) ) {
+ continue;
+ }
+
+ dphivalues[1] = GetDPhi(particle->Phi() - track->Phi());
+ dphivalues[0] = particle->Eta() - track->Eta();
+ dphivalues[2] = particle->Pt();
+ dphivalues[3] = track->Pt();
+ if(nDim > 4) dphivalues[4] = particle->M();
+ fSparse->Fill(dphivalues);
+ }
+}
+
#include "TMath.h"\r
#include "TList.h"\r
#include "TH1.h"\r
+#include <THnSparse.h>\r
\r
class TH1F;\r
class TH3F;\r
class TNtuple;\r
class TString;\r
\r
-\r
-class AliAnaConvCorrBase : public TObject {\r
+class AliAnaConvCorrBase : public TNamed {\r
\r
public:\r
\r
\r
\r
//Constructor / desctructor\r
- AliAnaConvCorrBase(TString name); \r
+ AliAnaConvCorrBase(TString name, TString title); \r
virtual ~AliAnaConvCorrBase();\r
\r
//Set and get min pt for triggers\r
//Add histogram to list\r
void AddHistogram(TH1 * histogram) { fHistograms->Add(dynamic_cast<TObject*>(histogram));}\r
\r
- //Set and get number of bins in phi direction\r
- void SetNPhiBins(Int_t bins) { fNPhiBins = bins; }\r
- Int_t GetNPhiBins() const { return fNPhiBins;}\r
+ void AddAxis(TAxis * axis) { fAxesList.Add(axis); }\r
\r
///Get the distance in phi between trigger particle and correlated particle\r
Float_t GetDPhi(Float_t dPhi) { \r
else return ( (dPhi>0)? dPhi - TMath::TwoPi() : dPhi + TMath::TwoPi() ); \r
}\r
\r
+ void PrintStatistics();\r
\r
- TArrayD * GetTriggerBins() const { return fPtBins; }\r
+ void CorrelateWithTracks(AliAODConversionParticle * particle, TObjArray * tracks, const Int_t tIDs[4], Bool_t isolated);\r
+ virtual void FillTriggerCounters(const AliAODConversionParticle * particle, Bool_t leading);\r
+\r
+ TAxis& GetAxistPt() { return fAxistPt; }\r
+ TAxis& GetAxiscPt() { return fAxiscPt; }\r
+ TAxis& GetAxisdEta() { return fAxisdEta; }\r
+ TAxis& GetAxisdPhi() { return fAxisdPhi; }\r
+ TList& GetAxisList() { return fAxesList; }\r
\r
- //Print statistics for histograms\r
- void PrintStatistics();\r
\r
\r
protected:\r
\r
//Fill histograms\r
- void FillHistograms(Float_t tPt, Float_t cPt, Float_t dPhi, Float_t dEta, Bool_t isolated);\r
+ //void FillHistograms(Float_t tPt, Float_t cPt, Float_t dPhi, Float_t dEta, Bool_t isolated);\r
//Fill trigger counter histograms\r
- void FillTriggerCounters(Float_t tPt, Bool_t isolated);\r
+ //virtual void FillTriggerCounters(Float_t tPt, Bool_t isolated) = NULL;\r
+ THnSparseF * CreateSparse(TString name, TString title, TList * axes);\r
+ TH1F * fHNTriggers[2]; //Histograms containing number of triggers in various bins\r
+\r
+private:\r
\r
- private:\r
+ void SetUpDefaultBins();\r
\r
- TString fName; //name of analysis\r
+ //TString fName; //name of analysis\r
TList * fHistograms; //List of histograms\r
+ TList fAxesList; //List over axes to be used in sparse\r
\r
- Int_t fNPhiBins; //Nbins in phi direction\r
- TArrayD * fdPhiBins; //!transient phi bin array\r
- TArrayD * fPtBins; //!Array of trigger bins\r
+ TAxis fAxistPt; //Pt axis\r
+ TAxis fAxiscPt; //correlated particle pt axis\r
+ TAxis fAxisdEta; //delta eta axis\r
+ TAxis fAxisdPhi; //delta phi axis\r
\r
-\r
- TH3F * fHdPhi[2]; //dPhi pt histogram\r
- TH1F * fHNTriggers[2]; //Histograms containing number of triggers in various bins\r
-\r
+ THnSparseF * fSparse; //Sparse\r
\r
//Default constructor prohibited\r
AliAnaConvCorrBase(); //not implemented\r
AliAnaConvCorrBase(const AliAnaConvCorrBase&); // not implemented\r
AliAnaConvCorrBase& operator=(const AliAnaConvCorrBase&); // not implemented\r
- ClassDef(AliAnaConvCorrBase, 3); // example of analysis\r
+\r
+ ClassDef(AliAnaConvCorrBase, 4); // example of analysis\r
+\r
};\r
\r
#endif\r
//________________________________________________________________________
AliAnaConvCorrPhoton::AliAnaConvCorrPhoton() :
-AliAnaConvCorrBase("photon_hadron_corr"),
+AliAnaConvCorrBase("photon_hadron_corr", "Photon corr"),
fSkipDecayParticles(kFALSE),
fDecayOnly(kFALSE)
{
//consctructor
}
//________________________________________________________________________
-AliAnaConvCorrPhoton::AliAnaConvCorrPhoton(TString name) :
-AliAnaConvCorrBase(name),
+AliAnaConvCorrPhoton::AliAnaConvCorrPhoton(TString name, TString title = "Photon corr") :
+AliAnaConvCorrBase(name, title),
fSkipDecayParticles(kFALSE),
fDecayOnly(kFALSE)
{
//consctructor
}
-
//________________________________________________________________________________
AliAnaConvCorrPhoton::~AliAnaConvCorrPhoton() {
//destructor
}
-///__________________________________________________________________________
-void AliAnaConvCorrPhoton::CorrelateWithHadrons(const AliAODConversionPhoton * const photon, const TClonesArray * const tracks, const Bool_t isolated, const Bool_t decayParticle) {
- //See header file for documentation
-
-
- if( decayParticle && fSkipDecayParticles ) return;
- else if ( fDecayOnly && !decayParticle ) return;
+//________________________________________________________________________________
+void AliAnaConvCorrPhoton::Process(TClonesArray * photons, TClonesArray * tracks, Bool_t isolated = kFALSE) {
+ //Process list of photons and correlate w tracks
+ for(Int_t ig = 0; ig < photons->GetEntriesFast(); ig++) {
- FillTriggerCounters(photon->Pt(), isolated);
+ AliAODConversionParticle * photon = static_cast<AliAODConversionParticle*>(photons->UncheckedAt(ig));
- if (tracks) {
-
- for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
- AliAODTrack * track = dynamic_cast<AliAODTrack*>(tracks->At(ij));
- if(track) {
-
- if ( (track->GetID() == photon->GetTrackLabel(0)) || track->GetID() == photon->GetTrackLabel(1) ) continue;
-
- //if (track->Pt() < GetCorrelatedPt() ) continue;
-
- FillHistograms(photon->Pt(), track->Pt(), GetDPhi(photon->Phi() - track->Phi()), photon->Eta() - track->Eta(), isolated);
-
- }
- }
+ Int_t tIDs[4] = {-1, -1, -1, -1};
+ tIDs[0] = photon->GetLabel(0);
+ tIDs[1] = photon->GetLabel(1);
+ CorrelateWithTracks(photon, tracks, tIDs, isolated);
+
}
}
public:\r
\r
AliAnaConvCorrPhoton(); \r
- AliAnaConvCorrPhoton(TString name); \r
+ AliAnaConvCorrPhoton(TString name, TString title); \r
virtual ~AliAnaConvCorrPhoton();\r
\r
///Correlation photon with tracks\r
- virtual void CorrelateWithHadrons(const AliAODConversionPhoton * const photon, const TClonesArray * const tracks, const Bool_t isolated, const Bool_t decayParticle);\r
+ //virtual void CorrelateWithHadrons(const AliAODConversionPhoton * const photon, const TClonesArray * const tracks, const Bool_t isolated, const Bool_t decayParticle);\r
\r
//Process particles identified as pion / eta decay \r
void SkipDecayParticles() { fSkipDecayParticles = kTRUE; }\r
void DoDecayParticles() { fSkipDecayParticles = kFALSE; }\r
void DoDecayOnly() { fSkipDecayParticles = kFALSE; fDecayOnly = kTRUE; }\r
\r
+ void Process(TClonesArray * photons, TClonesArray * tracks, Bool_t isolated);\r
+\r
private:\r
\r
\r
Bool_t fSkipDecayParticles; //Process particles identified as pion / eta decay particles\r
- Bool_t fDecayOnly;\r
+ Bool_t fDecayOnly; //Only process gamma from decay pion\r
\r
AliAnaConvCorrPhoton(const AliAnaConvCorrPhoton&); // not implemented\r
AliAnaConvCorrPhoton& operator=(const AliAnaConvCorrPhoton&); // not implemented\r
//________________________________________________________________________________
AliAnaConvCorrPhotonJet::AliAnaConvCorrPhotonJet() :
-AliAnaConvCorrBase("photonJet"),
+AliAnaConvCorrBase("photonJet", "Photon Jet"),
fhPtFracGamma(NULL),
fhPtFracPion(NULL)
{
}
//________________________________________________________________________________
AliAnaConvCorrPhotonJet::AliAnaConvCorrPhotonJet(TString name) :
- AliAnaConvCorrBase(name),
+ AliAnaConvCorrBase(name, "Photon Jet"),
fhPtFracGamma(NULL),
fhPtFracPion(NULL)
{
}
void AliAnaConvCorrPhotonJet::DoJetAnalysisGamma(AliAODJet * jet, const TClonesArray * const photons, const TClonesArray *const pions ) const{
-
- Int_t trackIDs[4] = {-9, -9, -9, -9};
+ //See header file for documetation
+ Int_t trackIDs[4];
for(Int_t i = 0; i < photons->GetEntriesFast(); i++) {
AliAODConversionParticle * photon = dynamic_cast<AliAODConversionParticle*>(photons->At(i));
//________________________________________________________________________________
Bool_t AliAnaConvCorrPhotonJet::IsParticleInJet(AliAODJet * jet, Int_t nTracks, Int_t * trackIds) const {
+ //See header file for documetation
Int_t mTracks = 0;
TRefArray * refTracks = jet->GetRefTracks();
//________________________________________________________________________________
Double_t AliAnaConvCorrPhotonJet::ExtractFromJet(AliAODJet * jet, const AliAODConversionParticle * const particle) const {
+ //See header file for documetation
Float_t jetPt = jet->Pt();
cout << "Jet pt before and after: " << jetPt << " ";
///_______________________________________________________________________________
void AliAnaConvCorrPhotonJet::CorrelateWithHadrons(const AliAODConversionParticle * const photon, const TClonesArray * const jets, const Bool_t isolated) {
- FillTriggerCounters(photon->Pt(), isolated);
+ FillTriggerCounters(photon, isolated);
//See header file for documentation
if (jets) {
for(int ij = 0; ij < jets->GetEntriesFast(); ij++) {
AliAODJet * jet = dynamic_cast<AliAODJet*>(jets->At(ij));
if(jet) {
- Double_t jetPt = ExtractFromJet(jet, photon);
- FillHistograms(photon->Pt(), jetPt, GetDPhi(photon->Phi() - jet->Phi()), photon->Eta() - jet->Eta(), isolated);
+ //Double_t jetPt = ExtractFromJet(jet, photon);
+ //FillHistograms(photon->Pt(), jetPt, GetDPhi(photon->Phi() - jet->Phi()), photon->Eta() - jet->Eta(), isolated);
}
}
}
+#include "TH2D.h"
#include "AliAnaConvCorrPion.h"
-#include "AliAODTrack.h"
+//#include "AliAODTrack.h"
#include "TClonesArray.h"
-#include "AliAODConversionPhoton.h"
-#include "THnSparse.h"
-#include "TH2F.h"
+#include "AliAODConversionParticle.h"
+//#include "AliAODConversionMother.h"
+//#include "AliAODConversionPhoton.h"
+//#include "THnSparse.h"
+//#include "TH2F.h"
#include <iostream>
//________________________________________________________________________________
AliAnaConvCorrPion::AliAnaConvCorrPion() :
-AliAnaConvCorrBase("pion_hadron_corr"),
- fhdPhiVsInvMassPi0(NULL),
- fhdPhiVsInvMassEta(NULL),
- fhPtVsInvMass(NULL)
+AliAnaConvCorrBase("pion_hadron_corr", "Pion dPhi"),
+ hTriggerPtvsMass(NULL),
+ fAxisM()
{
//consctructor
+ InitMassAxis();
}
//________________________________________________________________________________
-AliAnaConvCorrPion::AliAnaConvCorrPion(TString name) :
- AliAnaConvCorrBase(name),
- fhdPhiVsInvMassPi0(NULL),
- fhdPhiVsInvMassEta(NULL),
- fhPtVsInvMass(NULL)
+AliAnaConvCorrPion::AliAnaConvCorrPion(TString name, TString title = "Pion Corr") :
+ AliAnaConvCorrBase(name, title),
+ hTriggerPtvsMass(NULL),
+ fAxisM()
{
//consctructor
+ InitMassAxis();
}
//destructor
}
+void AliAnaConvCorrPion::InitMassAxis() {
+ Double_t mbins[7] = {0.1, 0.11, 0.12, 0.15, 0.16, 0.18, 0.2};
+ fAxisM.Set(6, mbins);
+ fAxisM.SetNameTitle("InvMass", "invariant mass");
+ GetAxisList().AddAt(&fAxisM, 4);
+}
+
///________________________________________________________________________________
void AliAnaConvCorrPion::CreateHistograms() {
//Create histograms
CreateBaseHistograms();
-
- const Int_t dim = 4;
- Int_t bins[dim] = {200, 200, 32, 14};
- Double_t min[dim] = {0, 0, -TMath::PiOver2(), 0.1};
- Double_t max[dim] = {100, 100, 3*TMath::PiOver2(), 0.17};
-
- fhdPhiVsInvMassPi0 = new THnSparseF("fhdPhiVsInvMassPi0", "fhdPhiVsInvMassPi0", dim, bins, min, max);
-
- min[3] = 450;
- max[3] = 650;
- bins[3] = 20;
- fhdPhiVsInvMassEta = new THnSparseF("fhdPhiVsInvMassEta", "fhdPhiVsInvMassEta", dim, bins, min, max);
- fhPtVsInvMass = new TH2F("fhPtVsInvMass", "Pt Vs inv mass", GetTriggerBins()->GetSize() -1, GetTriggerBins()->GetArray(), 400, 0, 1);
-
- GetHistograms()->Add(fhPtVsInvMass);
- GetHistograms()->Add(fhdPhiVsInvMassPi0);
- GetHistograms()->Add(fhdPhiVsInvMassEta);
-
+ hTriggerPtvsMass = new TH2D("hTriggerPtvsMass", "Pt vs Mass", 400, 0, .400, GetAxistPt().GetNbins(), GetAxistPt().GetXbins()->GetArray());
+ GetHistograms()->Add(hTriggerPtvsMass);
}
+
///________________________________________________________________________________
-void AliAnaConvCorrPion::GetTrackLabels(const AliAODConversionPhoton * pion, const TClonesArray * photons, Int_t* trackLabels) {
- ///Get the track labels of the electrons reconstructed as gamma forming the pion
-
- for(Int_t i = 0; i< 2; i++) {
- AliAODConversionPhoton * gamma = dynamic_cast<AliAODConversionPhoton*>(photons->At(pion->GetTrackLabel(i)));
-
- if(gamma) {
- for(Int_t j = 0; j< 2; j++) {
- cout << "index " << i + j + ((i>=j)?1:0) << " " << gamma->GetTrackLabel(j) << endl;
- trackLabels[ i*2+ j] = gamma->GetTrackLabel(j);
- }
- }
- }
+void AliAnaConvCorrPion::FillTriggerCounters(const AliAODConversionParticle * particle, Bool_t isolated) {
+ //Fill histograms counting triggers
+ fHNTriggers[isolated]->Fill(particle->Pt());
+ hTriggerPtvsMass->Fill(particle->M(), particle->Pt());
}
-
-///________________________________________________________________________________
-void AliAnaConvCorrPion::CorrelateWithHadrons(AliAODConversionPhoton * pion, const TClonesArray * tracks, const Bool_t isolated, const Int_t nSpawn, const Int_t * const spawn) {
- //See header file for documentation
-
- fhPtVsInvMass->Fill(pion->Pt(), pion->M());
- FillTriggerCounters(pion->Pt(), isolated);
-
- if (tracks) {
- for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
- AliAODTrack * track = dynamic_cast<AliAODTrack*>(tracks->At(ij));
- if(track) {
-
- if(nSpawn && spawn) {;}
-
- //if(pion->IsMySpawn(track->GetID(), nSpawn, spawn)) continue;
+//________________________________________________________________________________
+// void AliAnaConvCorrPion::Process(TClonesArray * pions, TClonesArray * photons, TClonesArray * tracks) {
+
+// for(Int_t ip = 0; ip < pions->GetEntriesFast(); ip++) {
+
+// AliAODConversionParticle * pion = static_cast<AliAODConversionParticle*>(pions->UncheckedAt(ip));
- // if (track->Pt() < GetCorrelatedPt() ) continue;
- Double_t x[4] = {pion->Pt(), track->Pt(), GetDPhi(pion->Phi() - track->Phi()), TMath::Abs(pion->M()) };
- if( (pion->M() > 0.1) && (pion->M() < 0.17) ){
- fhdPhiVsInvMassPi0->Fill(x);
- } else if ((pion->M() > 0.5) && (pion->M() < 0.6 ) ) {
- fhdPhiVsInvMassEta->Fill(x);
- }
- FillHistograms(pion->Pt(), track->Pt(), GetDPhi(pion->Phi() - track->Phi()), pion->Eta() - track->Eta(), isolated);
- }
- }
- }
-}
+// Int_t tIDs[4] = {-1, -1, -1, -1};
+// AliAODConversionParticle * photon1 = static_cast<AliAODConversionParticle*>(photons->UncheckedAt(pion->GetLabel(0)));
+// tIDs[0] = photon1->GetLabel(0);
+// tIDs[1] = photon1->GetLabel(1);
+// AliAODConversionParticle * photon2 = static_cast<AliAODConversionParticle*>(photons->UncheckedAt(pion->GetLabel(1)));
+// tIDs[2] = photon2->GetLabel(0);
+// tIDs[3] = photon2->GetLabel(1);
+
+// CorrelateWithTracks(static_cast<AliAODConversionParticle*>(pion), tracks, tIDs, kFALSE);
+// }
+// }
+
#define ALIANACONVCORRPION_CXX\r
\r
#include "AliAnaConvCorrBase.h"\r
-#include "THnSparse.h"\r
+class TH2D;\r
+//#include "THnSparse.h"\r
\r
-class AliAODConversionPhoton;\r
+//class AliAODConversionPhoton;\r
class TClonesArray;\r
\r
class AliAnaConvCorrPion : public AliAnaConvCorrBase {\r
public:\r
\r
AliAnaConvCorrPion(); \r
- AliAnaConvCorrPion(TString name);\r
+ AliAnaConvCorrPion(TString name, TString title);\r
virtual ~AliAnaConvCorrPion();\r
\r
+ TAxis& GetAxisM() { return fAxisM; }\r
+\r
+\r
//Correlate pions with charged tracks\r
- virtual void CorrelateWithHadrons(AliAODConversionPhoton * pion, const TClonesArray * tracks, const Bool_t isolated, const Int_t nSpawn, const Int_t * const spawn );\r
+ //virtual void CorrelateWithHadrons(AliAODConversionPhoton * pion, const TClonesArray * tracks, const Bool_t isolated, const Int_t nSpawn, const Int_t * const spawn );\r
\r
void CreateHistograms();\r
+\r
+ //void Process(TClonesArray * pions, TClonesArray * photons, TClonesArray * tracks);\r
+ \r
+\r
+ void FillTriggerCounters(const AliAODConversionParticle * particle, Bool_t isolated);\r
\r
private:\r
\r
+ void InitMassAxis();\r
//Get array of track labels of the 4 decay electrons (2gamma * 2 electrons)\r
- void GetTrackLabels(const AliAODConversionPhoton * pion, const TClonesArray * photons, Int_t* trackLabels);\r
+ //void GetTrackLabels(const AliAODConversionPhoton * pion, const TClonesArray * photons, Int_t* trackLabels);\r
+\r
+ //TH2F * fhPtVsInvMass;\r
\r
- THnSparseF * fhdPhiVsInvMassPi0; //!\r
- THnSparseF * fhdPhiVsInvMassEta; //!\r
- TH2F * fhPtVsInvMass;\r
+ TH2D * hTriggerPtvsMass; //Histograms containing number of triggers in various bins\r
+ TAxis fAxisM; //Mass axis\r
\r
AliAnaConvCorrPion(const AliAnaConvCorrPion&); // not implemented\r
AliAnaConvCorrPion& operator=(const AliAnaConvCorrPion&); // not implemented\r
- ClassDef(AliAnaConvCorrPion, 1); // example of analysis\r
+ ClassDef(AliAnaConvCorrPion, 2); //\r
\r
};\r
\r
//________________________________________________________________________________
AliAnaConvCorrPionJet::AliAnaConvCorrPionJet() :
-AliAnaConvCorrBase("photonJet") {
+AliAnaConvCorrBase("PionJet", "Pion Jet") {
//consctructor
}
//________________________________________________________________________________
AliAnaConvCorrPionJet::AliAnaConvCorrPionJet(TString name) :
-AliAnaConvCorrBase(name) {
+ AliAnaConvCorrBase(name, "Pion Jet") {
//consctructor
}
///_______________________________________________________________________________
void AliAnaConvCorrPionJet::CorrelateWithHadrons(const AliAODConversionParticle * const pion, const TClonesArray * const jets, const Bool_t isolated) {
- FillTriggerCounters(pion->Pt(), isolated);
+ FillTriggerCounters(pion, isolated);
//See header file for documentation
if (jets) {
for(int ij = 0; ij < jets->GetEntriesFast(); ij++) {
AliAODJet * jet = dynamic_cast<AliAODJet*>(jets->At(ij));
if(jet) {
- FillHistograms(pion->Pt(), jet->Pt(), GetDPhi(pion->Phi() - jet->Phi()), pion->Eta() - jet->Eta(), isolated);
+ //FillHistograms(pion->Pt(), jet->Pt(), GetDPhi(pion->Phi() - jet->Phi()), pion->Eta() - jet->Eta(), isolated);
}
}
}
}
+//________________________________________________________________________
+Bool_t AliAnaConvIsolation::IsLeading(AliAODConversionParticle * particle, const TObjArray * tracks, const TObjArray * aodParticles) {
+ //Check if particle is highest pt particle in cone
+ for(Int_t ip = 0; ip < aodParticles->GetEntriesFast(); ip++) {
+ AliAODConversionParticle * oparticle = static_cast<AliAODConversionParticle*>(aodParticles->UncheckedAt(ip));
+ if(oparticle == particle) continue;
+ if(oparticle->Pt() > particle->Pt() &&
+ IsInCone(particle->Eta() - oparticle->Eta(),
+ particle->Phi() - oparticle->Phi(),
+ fConeSize) ) {
+ return kFALSE;
+ }
+ }
+
+ for(Int_t it = 0; it < tracks->GetEntriesFast(); it++) {
+ AliAODTrack * track = static_cast<AliAODTrack*>(tracks->UncheckedAt(it));
+ if(track->Pt() > particle->Pt() &&
+ IsInCone(particle->Eta() - track->Eta(), particle->Phi() - track->Phi(), fConeSize) ) return kFALSE;
+ }
+
+ return kTRUE;
+}
//_________________________________________________________________________
Bool_t AliAnaConvIsolation::IsIsolated(AliAODConversionPhoton * particle, const TClonesArray * const tracks, const Int_t nSpawn, const Int_t * const spawn, Bool_t &leading) {
#ifndef ALIANACONVISOLATION_CXX\r
#define ALIANACONVISOLATION_CXX\r
\r
+#include <iostream>\r
#include "TObject.h"\r
#include "Rtypes.h"\r
#include "TF1.h"\r
+#include <TMath.h>\r
class TH2F;\r
class TH1F;\r
class AliAODConversionPhoton;\r
+class AliAODConversionParticle;\r
class TClonesArray;\r
class TList;\r
\r
+using namespace std;\r
+\r
class AliAnaConvIsolation : public TObject {\r
\r
public:\r
\r
\r
///Set And get cone size\r
- void SetConeSize(Float_t cs) {fConeSize = cs;}\r
- Float_t GetConeSize() const {return fConeSize;}\r
+ void SetConeSize(Float_t cs) {fConeSize = cs*cs;}\r
+ Float_t GetConeSize() const {return TMath::Sqrt(fConeSize);}\r
\r
\r
//Set and get max pt threshold\r
fCurveFunction = curve;\r
}\r
\r
+ Bool_t IsLeading(AliAODConversionParticle * particle, const TObjArray * tracks, const TObjArray * aodParticles);\r
+\r
+\r
//Fill histograms\r
void FillHistograms(Float_t pt, Float_t ptMax, Float_t ptSum, Bool_t isolated, Int_t nTracks);\r
\r
Bool_t IsIsolated( const AliAODConversionPhoton * const particle, const TClonesArray * const tracks, Bool_t &leading);\r
Bool_t IsIsolated( AliAODConversionPhoton * const particle, const TClonesArray * const tracks, const Int_t nSpawn, const Int_t * const spawn, Bool_t &leading );\r
\r
- private:\r
-\r
//Is eta - phi distance smaller than conesize ?\r
- Bool_t IsInCone(Float_t dEta, Float_t dPhi, Float_t coneSize) const {\r
- return ( (dEta*dEta + dPhi*dPhi) < coneSize*coneSize);\r
+ Bool_t IsInCone(Float_t dEta, Float_t dPhi, const Float_t coneSize) const {\r
+ dPhi = (TMath::Abs(dPhi) < TMath::Pi()) ? dPhi : TMath::TwoPi() - TMath::Abs(dPhi); \r
+ return ( (dEta*dEta + dPhi*dPhi) < coneSize);\r
}\r
\r
+ private:\r
+\r
///Evaluate whether particle is isolated according to criterie\r
Bool_t EvaluateIsolationCriteria(Float_t ptSum, Float_t pt) const;\r
\r
+++ /dev/null
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project *
- * ALICE Experiment at CERN, All rights reserved. *
- * *
- * Primary Author: Svein Lindal <slindal@fys.uio.no> *
- * *
- * 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. *
- **************************************************************************/
-
-/// @file AliAnalysisTaskGammaJet.cxx
-/// @author Svein Lindal
-/// @brief Class used to run conversion gamma/pion - hadron/jet analysis
-
-
-#include <iostream>
-#include "TChain.h"
-#include "TTree.h"
-#include "TH1F.h"
-#include "TCanvas.h"
-#include "TString.h"
-#include "TObjArray.h"
-
-
-#include "TH2F.h"
-
-#include "AliAnalysisTask.h"
-#include "AliAnalysisManager.h"
-#include "AliAnalysisTaskGammaJet.h"
-
-#include "AliESDEvent.h"
-#include "AliESDCaloCluster.h"
-#include "AliESDInputHandler.h"
-
-#include "AliAODPWG4ParticleCorrelation.h"
-#include "AliAODEvent.h"
-#include "AliAODHandler.h"
-#include "AliAODCaloCluster.h"
-#include "AliAODConversionPhoton.h"
-#include "AliAODJet.h"
-
-#include "AliAODInputHandler.h"
-
-#include "AliAnaConvIsolation.h"
-
-#include "AliAnaConvCorrPhoton.h"
-#include "AliAnaConvCorrPhotonJet.h"
-#include "AliAnaConvCorrPionJet.h"
-#include "AliAnaConvCorrPion.h"
-
-#include "AliAODTrack.h"
-
-// Gamma - jet correlation analysis task
-// Authors: Svein Lindal
-
-
-using namespace std;
-
-ClassImp(AliAnalysisTaskGammaJet)
-
-//________________________________________________________________________
-AliAnalysisTaskGammaJet::AliAnalysisTaskGammaJet() :
-AliAnalysisTaskSE(),
- fOutputList(NULL),
- fEtaLimit(0.8),
- fDeltaAODFileName("AliAODGammaConversion.root"),
- fGammaCutString("GammaConv"),
- fPionCutString("GammaConv"),
- fAnaIsolation(NULL),
- fAnaIsolationArray(NULL),
- fAnaPionArray(NULL),
- fAnaPhotonArray(NULL),
- fAnaPhotonJetArray(NULL),
- fAnaPionJetArray(NULL),
- fMinPt(1.0),
- fMinNTracks(20)
-{
- // Dummy Constructor
-}
-
-//________________________________________________________________________________
-AliAnalysisTaskGammaJet::~AliAnalysisTaskGammaJet() {
- //Destructor
-}
-
-
-//________________________________________________________________________
-AliAnalysisTaskGammaJet::AliAnalysisTaskGammaJet(const char *name) :
- AliAnalysisTaskSE(name),
- fOutputList(0),
- fEtaLimit(0.8),
- fDeltaAODFileName("AliAODGammaConversion.root"),
- fGammaCutString("GammaConv"),
- fPionCutString("GammaConv"),
- fAnaIsolation(NULL),
- fAnaIsolationArray(NULL),
- fAnaPionArray(NULL),
- fAnaPhotonArray(NULL),
- fAnaPhotonJetArray(NULL),
- fAnaPionJetArray(NULL),
- fMinPt(1.0),
- fMinNTracks(20)
-{
- // Constructor
- // Output slot #1 writes into a TList container
- DefineOutput(1, TList::Class());
-
- fAnaIsolation = new AliAnaConvIsolation();
-
- fAnaPionArray = new TObjArray();
- fAnaPionArray->SetOwner(kTRUE);
-
- fAnaPhotonArray = new TObjArray();
- fAnaPhotonArray->SetOwner(kTRUE);
-
- fAnaPhotonJetArray = new TObjArray();
- fAnaPhotonJetArray->SetOwner(kTRUE);
-
- fAnaPionJetArray = new TObjArray();
- fAnaPionJetArray->SetOwner(kTRUE);
-
- fAnaIsolationArray = new TObjArray();
- fAnaIsolationArray->SetOwner(kTRUE);
-
- fhTracksMissingPt[0] = NULL;
- fhTracksMissingPt[1] = NULL;
-
-
-
-}
-
-//________________________________________________________________________
-void AliAnalysisTaskGammaJet::UserExec(Option_t *)
-{
- //Inherited from AliAnalysisTaskSE
-
- ///Get AOD event
- AliAODEvent * aodEvent = GetAODEvent();
- if(!aodEvent) {
- cout << "No AOD event!!" << endl;
- return;
- }
-
- TClonesArray * photons = GetConversionGammas(aodEvent);
- if(!photons) {
- cout << "No Conversion gamma!!" << endl;
- return;
- }
-
- TClonesArray * pions = GetConversionPions(aodEvent);
- if(!pions) {
- cout << "No Conversion pion branch!!" << endl;
- return;
- }
-
- TClonesArray * tracks = aodEvent->GetTracks();
- if(!tracks) {
- cout << "Can't get tracks!!" << endl;
- return;
- }
-
- if(!((Entry() )%10000)) {
- AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
- AliInfo(Form("%d %d", photons->GetEntriesFast(), pions->GetEntriesFast()));
- }
-
-
- if(pions->GetEntriesFast() > photons->GetEntriesFast() ) {
- cout << "WTF!!!!"<<endl;
- }
-
- // if( (photons->GetEntriesFast() > 0) ) {
- // cout << "Neext evetn !!!!!!!!!!!!!!!!" << Entry() << endl;
- // } else {
- // cout << "____________________________"<<endl;
- // }
-
-
- if(aodEvent->GetNumberOfTracks() < 2 && photons->GetEntriesFast() > 0 ) {
- cout << "we have a photon but less than 2 tracks" << endl;
- return;
- }
-
- if(aodEvent->GetNumberOfTracks() < fMinNTracks) return;
-
- if( (photons->GetEntriesFast() > 0) ) {
- ProcessConvGamma(photons, pions, tracks);
- ProcessPions(pions, photons, tracks);
- }
-
-
-
- TClonesArray * jets = aodEvent->GetJets();
- if(jets && jets->GetEntriesFast() > 0) {
- for(int i = 0; i < fAnaPhotonJetArray->GetEntriesFast(); i++) {
- AliAnaConvCorrPhotonJet * jetAna = dynamic_cast<AliAnaConvCorrPhotonJet*>(fAnaPhotonJetArray->At(i));
- if(jetAna) {
- for(Int_t iJet = 0; iJet < jets->GetEntriesFast(); iJet++) {
- AliAODJet * jet = dynamic_cast<AliAODJet*>(jets->At(iJet));
- if(jet) {
- jetAna->DoJetAnalysisGamma(jet, photons, pions);
- }
- }
- }
- }
- }
- PostData(1, fOutputList);
-
-}
-
-
-
-//________________________________________________________________________
-void AliAnalysisTaskGammaJet::UserCreateOutputObjects()
-{
- //Create histograms add, to outputlist
- fOutputList = new TList();
- fOutputList->SetOwner(kTRUE);
-
-
- fhTracksMissingPt[0] = new TH2F("hpttracksmissing", "hpttracksmissing",200, 0, 200, 200, 0, 200);
- fOutputList->Add(fhTracksMissingPt[0]);
- fhTracksMissingPt[1] = new TH2F("hpttrackpresent", "hptbothtrackspresent" ,200, 0, 200, 200, 0, 200);
- fOutputList->Add(fhTracksMissingPt[1]);
-
- fAnaIsolation->CreateHistograms();
- fOutputList->Add(fAnaIsolation->GetHistograms());
-
- for(int i = 0; i < fAnaIsolationArray->GetEntriesFast(); i++) {
- AliAnaConvIsolation * isoAna = dynamic_cast<AliAnaConvIsolation*>(fAnaIsolationArray->At(i));
- if(isoAna) {
- isoAna->CreateHistograms();
- fOutputList->Add(isoAna->GetHistograms());
- } else {
- AliError("problem getting ana pointer!!!");
- cout << i << endl;
- }
- }
-
- for(int i = 0; i < fAnaPhotonArray->GetEntriesFast(); i++) {
- AliAnaConvCorrPhoton * photonAna = dynamic_cast<AliAnaConvCorrPhoton*>(fAnaPhotonArray->At(i));
- if(photonAna) {
- photonAna->CreateHistograms();
- fOutputList->Add(photonAna->GetHistograms());
- } else {
- AliError("problem getting ana pointer!!!");
- }
- }
-
-
- for(int i = 0; i < fAnaPionArray->GetEntriesFast(); i++) {
- AliAnaConvCorrPion * pionAna = dynamic_cast<AliAnaConvCorrPion*>(fAnaPionArray->At(i));
- if(pionAna) {
- pionAna->CreateHistograms();
- fOutputList->Add(pionAna->GetHistograms());
- } else {
- AliError("problem getting ana pointer!!!");
- }
- }
-
- for(int i = 0; i < fAnaPhotonJetArray->GetEntriesFast(); i++) {
- AliAnaConvCorrPhotonJet * jetAna = dynamic_cast<AliAnaConvCorrPhotonJet*>(fAnaPhotonJetArray->At(i));
- if(jetAna) {
- jetAna->CreateHistograms();
- fOutputList->Add(jetAna->GetHistograms());
- } else {
- AliError("problem getting jet ana pointer!!!");
- }
- }
-
- for(int i = 0; i < fAnaPionJetArray->GetEntriesFast(); i++) {
- AliAnaConvCorrPionJet * jetAna = dynamic_cast<AliAnaConvCorrPionJet*>(fAnaPionJetArray->At(i));
- if(jetAna) {
- jetAna->CreateHistograms();
- fOutputList->Add(jetAna->GetHistograms());
- } else {
- AliError("problem getting jet ana pointer!!!");
- }
- }
-
-
-
- PostData(1, fOutputList);
-
-
-}
-
-
-
-
-
-//______________________________________________________________________________________________
-void AliAnalysisTaskGammaJet::ProcessCalorimeters( const AliAODEvent * const aodEvent ) {
- //See header file for documentation
- TClonesArray * clusters = aodEvent->GetCaloClusters();
-
-
- for(int ic = 0; ic < clusters->GetEntriesFast(); ic++) {
- AliAODCaloCluster * cluster = dynamic_cast<AliAODCaloCluster*>(clusters->At(ic));
- if (!cluster) {
- AliError(Form("Error getting cluster"));
- continue;
- }
-
-
- if (cluster->GetNCells() < 6) continue;
- if (cluster->GetEmcCpvDistance() < 15) continue;
-
- TLorentzVector tlvec;
-
- AliAODVertex * vertex = aodEvent->GetPrimaryVertex();
- Double_t vertexPosition[3];
- vertex->GetXYZ(vertexPosition);
- cluster->GetMomentum(tlvec, vertexPosition);
- //if (tlvec.Pt() < GetMinPt()) continue;
-
- }
-
-}
-
-//______________________________________________________________________________________________
-Bool_t AliAnalysisTaskGammaJet::EventIsSynced(const TClonesArray * const tracks, const TClonesArray * const convGamma, const TClonesArray * const pions) {
- //See header file for documentation
-
- for (Int_t iPhot = 0; iPhot < convGamma->GetEntriesFast(); iPhot++) {
- AliAODConversionPhoton * photon = dynamic_cast<AliAODConversionPhoton*>(convGamma->At(iPhot));
- if(photon) {
- AliAODTrack * track1 = NULL;
- AliAODTrack * track2 = NULL;
- for(Int_t i = 0; i < tracks->GetEntriesFast(); i++) {
- AliAODTrack * track = dynamic_cast<AliAODTrack*>(tracks->At(i));
- if(track) {
- if(track->GetID() == photon->GetLabel1()) track1 = track;
- else if (track->GetID() == photon->GetLabel2()) track2 = track;
- if(track1 && track2) break;
- }
- }
-
- if(track1 && track2) {
- Float_t totE = track1->E() + track2->E();
- if(TMath::Abs(totE - photon->E()) > 1.0) {
- cout << "BALLE BALLE "<<TMath::Abs(totE - photon->P()) << endl;
-
- cout << track2->Px() << " "
- << track2->Py() << " "
- << track2->Pz() << " "
- << track2->P() << " "
- << track2->E() << endl;
-
- cout << track1->Px() << " "
- << track1->Py() << " "
- << track1->Pz() << " "
- << track1->P() << " "
- << track1->E() << endl;
-
-
- cout << track1->Px() + track2->Px() << " "
- << track1->Py() + track2->Py() << " "
- << track1->Pz() + track2->Pz() << " "
- << track1->P() + track2->P() << " "
- << track1->E() + track2->E() << endl;
-
- cout << photon->Px() << " " << photon->Py() << " " << photon->Pz() << " " << photon->P() << " " << photon->E() << endl;
- return kFALSE;
- }
- } else {
- cout << Entry() << " " << convGamma->GetEntriesFast() << " " << photon->GetLabel1() << " " << photon->GetLabel2() << endl;
- cout << "Could not get both tracks!!! " <<endl;
- return kFALSE;
- }
- }
- }
-
- if(pions) {
- //placeholder
- }
-
- //cout <<"insync"<<endl;
- return kTRUE;
-}
-
-
-//______________________________________________________________________________________________
-Bool_t AliAnalysisTaskGammaJet::BothTracksPresent(const AliAODConversionPhoton * const photon, const TClonesArray * const tracks) const {
-
- AliAODTrack * track1 = NULL;
- AliAODTrack * track2 = NULL;
- for(Int_t i = 0; i < tracks->GetEntriesFast(); i++) {
- AliAODTrack * track = dynamic_cast<AliAODTrack*>(tracks->At(i));
- if(track) {
- if(track->GetID() == photon->GetLabel1()) track1 = track;
- else if (track->GetID() == photon->GetLabel2()) track2 = track;
- if(track1 && track2) break;
- }
- }
-
- if(track1 && track2) {
- return kTRUE;
- }
- cout << "Could not get both tracks!!! labels " << photon->GetLabel1() << " " << photon->GetLabel2() <<endl;
- return kFALSE;
-
-
-}
-
-//______________________________________________________________________________________________
-Bool_t AliAnalysisTaskGammaJet::BothGammaPresent(const AliAODConversionPhoton * const pion, const TClonesArray * const photons, const TClonesArray * const tracks) const {
-
- AliAODConversionPhoton * photon1 = dynamic_cast<AliAODConversionPhoton*>(photons->At(pion->GetLabel1()));
- AliAODConversionPhoton * photon2 = dynamic_cast<AliAODConversionPhoton*>(photons->At(pion->GetLabel2()));
-
- if(photon1 && photon2) {
- if( BothTracksPresent(photon1, tracks) && BothTracksPresent(photon1, tracks)) {
- return kTRUE;
- }
- } else {
- cout << "can't find both photons "<< endl;
- }
-
- return kFALSE;
-}
-
-
-
-
-//___________________________________________________________________________________________
-void AliAnalysisTaskGammaJet::ProcessConvGamma( const TClonesArray * convGamma, const TClonesArray * const pions, const TClonesArray * tracks ) {
- //See header file for documentation
-
-
- for (Int_t iPhot = 0; iPhot < convGamma->GetEntriesFast(); iPhot++) {
- AliAODConversionPhoton * photon = dynamic_cast<AliAODConversionPhoton*>(convGamma->At(iPhot));
- if(!photon) {
- AliError(Form("ERROR: Could not receive ga %d\n", iPhot));
- continue;
- }
-
- Bool_t btp = BothTracksPresent(photon, tracks);
- fhTracksMissingPt[btp]->Fill(photon->Pt(), tracks->GetEntriesFast());
- if(!btp || photon->Pt() < fMinPt || TMath::Abs(photon->Eta()) > fEtaLimit) {
- continue;
- }
-
- Bool_t leading = kTRUE;
- Bool_t decayPion = IsDecayPion(iPhot, pions);
-
- for(Int_t i = 0; i < fAnaIsolationArray->GetEntriesFast(); i ++) {
- AliAnaConvIsolation * isoAna = dynamic_cast<AliAnaConvIsolation*>(fAnaIsolationArray->At(i));
- if(isoAna) isoAna->IsIsolated(photon, tracks, leading);
- }
-
- Bool_t isolated = fAnaIsolation->IsIsolated(photon, tracks, leading);
- if(leading) {
- for(Int_t i = 0; i < fAnaPhotonArray->GetEntriesFast(); i ++) {
- AliAnaConvCorrPhoton * ana = static_cast<AliAnaConvCorrPhoton*>(fAnaPhotonArray->At(i));
- if(ana) {
- ana->CorrelateWithHadrons(photon, tracks, isolated, decayPion);
- }
- }
-
- TClonesArray * jets = GetAODEvent()->GetJets();
- if(jets) {
- for(Int_t i = 0; i < fAnaPhotonJetArray->GetEntriesFast(); i ++) {
- AliAnaConvCorrPhotonJet * ana = static_cast<AliAnaConvCorrPhotonJet*>(fAnaPhotonJetArray->At(i));
- if(ana) {
- ana->CorrelateWithHadrons(photon, jets, isolated);
- }
- }
- } else {
- cout << "No jets "<<endl;
- }
- }
- } //
-}
-
-///______________________________________________________________________________________________
-void AliAnalysisTaskGammaJet::ProcessPions( const TClonesArray * const pions, const TClonesArray * const photons, const TClonesArray * const tracks) {
- //See header file for documentation
-
-
- for (Int_t iPi = 0; iPi < pions->GetEntriesFast(); iPi++) {
- AliAODConversionPhoton * pion = dynamic_cast<AliAODConversionPhoton*>(pions->At(iPi));
- if(!pion) {
- AliError(Form("ERROR: Could not receive ga %d\n", iPi));
- continue;
- }
-
- if (!BothGammaPresent(pion, photons, tracks) || pion->Pt() < fMinPt || TMath::Abs(pion->Eta()) > fEtaLimit ) {
- return;
- }
-
-
- Int_t trackLabels[4] = {-1, -1, -1, -1};
- GetPionGrandChildren(pion, photons, trackLabels);
- Bool_t leading = kTRUE;
-
- for(Int_t i = 0; i < fAnaIsolationArray->GetEntriesFast(); i ++) {
- AliAnaConvIsolation * isoAna = dynamic_cast<AliAnaConvIsolation*>(fAnaIsolationArray->At(i));
- if(isoAna) isoAna->IsIsolated(pion, tracks, 4, trackLabels, leading);
- }
-
- Bool_t isolated = fAnaIsolation->IsIsolated(pion, tracks, 4, trackLabels, leading);
- if(leading) {
- for(Int_t i = 0; i < fAnaPionArray->GetEntriesFast(); i ++) {
- AliAnaConvCorrPion * ana = dynamic_cast<AliAnaConvCorrPion*>(fAnaPionArray->At(i));
- if(ana) ana->CorrelateWithHadrons(pion, tracks, isolated, 4, trackLabels );
- }
-
-
- TClonesArray * jets = GetAODEvent()->GetJets();
- if(jets) {
- for(Int_t i = 0; i < fAnaPionJetArray->GetEntriesFast(); i ++) {
- AliAnaConvCorrPionJet * ana = static_cast<AliAnaConvCorrPionJet*>(fAnaPionJetArray->At(i));
- if(ana) {
- ana->CorrelateWithHadrons(pion, jets, isolated);
- }
- }
- } else {
- cout << "No jets "<<endl;
- }
-
-
- }
- } //
-
-
-
- // for (Int_t iPhot = 0; iPhot < photons->GetEntriesFast(); iPhot++) {
- // AliAODConversionPhoton * photon = dynamic_cast<AliAODConversionPhoton*>(photons->At(iPhot));
- // if(photon) {
- // for (Int_t iPhot2 = iPhot+1; iPhot2 < photons->GetEntriesFast(); iPhot2++) {
- // AliAODConversionPhoton * photon2 = dynamic_cast<AliAODConversionPhoton*>(photons->At(iPhot2));
- // if(photon2) {
- // Int_t trackLabels[4] = {photon->GetTrackLabel(0), photon->GetTrackLabel(1), photon2->GetTrackLabel(0), photon2->GetTrackLabel(1)};
- // AliAODConversionPhoton * pion = new AliAODConversionPhoton(photon, photon2);
- // Bool_t leading = kTRUE;
- // Bool_t isolated = fAnaIsolation->IsIsolated(pion, tracks, 4, trackLabels, leading);
- // if(leading) {
- // for(Int_t i = 0; i < fAnaPionArray->GetEntriesFast(); i ++) {
- // AliAnaConvCorrPion * ana = dynamic_cast<AliAnaConvCorrPion*>(fAnaPionArray->At(i));
- // if(ana) ana->CorrelateWithHadrons(pion, tracks, isolated, 4, trackLabels );
- // }
- // delete pion;
- // }
- // }
- // }
- // }
- // }
-}
-
-///_______________________________________________________________________________________________
-Bool_t AliAnalysisTaskGammaJet::IsDecayPion(Int_t iPhot, const TClonesArray * const pions) {
- //See header file for documentation
-
- for(int ip = 0; ip < pions->GetEntriesFast(); ip++) {
- AliAODConversionPhoton * pion = dynamic_cast<AliAODConversionPhoton*>(pions->At(ip));
- if(pion) {
- if(pion->GetLabel1() == iPhot || pion->GetLabel2() == iPhot)
-
- return kTRUE;
- } else {
- AliError("pion corrupted!");
- }
- }
-
- return kFALSE;
-}
-
-
-///_______________________________________________________________________________
-Bool_t AliAnalysisTaskGammaJet::UserNotify() {
- //See header file for documentation
-
- AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
-
- // AliAnaConvCorrPhoton * phJetAna = dynamic_cast<AliAnaConvCorrPhoton*>(fAnaPhotonArray->At(0));
- // phJetAna->PrintStatistics();
-
- return kTRUE;
-
-}
-
-///_______________________________________________________________________________
-void AliAnalysisTaskGammaJet::NotifyRun() {
- //See header file for documentation
-
- AliInfo(Form("we have a new run: %d", fCurrentRunNumber));
- cout << Form("we have a new run: %d", fCurrentRunNumber) << endl;
-
-}
-
-///_______________________________________________________________________________
-void AliAnalysisTaskGammaJet::GetPionGrandChildren(const AliAODConversionPhoton * pion, const TClonesArray * photons, Int_t* trackLabels) {
- ///Get the track labels of the electrons reconstructed as gamma forming the pion
-
- for(Int_t i = 0; i< 2; i++) {
- AliAODConversionPhoton * gamma = dynamic_cast<AliAODConversionPhoton*>(photons->At(pion->GetLabel(i)));
-
- if(gamma) {
- for(Int_t j = 0; j< 2; j++) {
- trackLabels[ i*2+ j] = gamma->GetLabel(j);
- }
-
- } else {
- cout << "AliAnaConvCorrPion::GetTrackLabels() :: Not good!!!"<<endl;
- }
- }
-}
-
-
-
-
-//_____________________________________________________________________
-void AliAnalysisTaskGammaJet::Terminate(Option_t *) {
- // Draw result to the screen
- // Called once at the end of the query
-}
-
-//_____________________________________________________________________
-AliAODEvent * AliAnalysisTaskGammaJet::GetAODEvent() {
- //Get the AOD event from whereever it might be
- AliAODEvent * aodEvent = dynamic_cast<AliAODEvent*>(InputEvent());
-
-
- if(!aodEvent) {
- cout << "!!!!!!!!!!!!!!!!!!!!!!!!Getting AODEvent();" << endl;
- aodEvent = AODEvent();
- } else {
- //cout << "got aod from input event1" << endl;
- }
- return aodEvent;
-
-}
-
-//_____________________________________________________________________
-TClonesArray * AliAnalysisTaskGammaJet::GetConversionGammas(const AliAODEvent * aodEvent) {
-
- //Get Conversion gamma branch of AOD. First try standard AOD
- TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(Form("%s_gamma", fGammaCutString.Data())));
-
- //If it's there, send it back
- if(convGamma) {
- //cout << "found conv gamma branch in aod event!!!"<<endl;
- return convGamma;
- }else {
- cout << "did NOT !!! find conv gamma branch in aod event!!!"<<endl;
- }
-
- //If AOD not in standard file have to locate it in delta AOD
- if( !(fDeltaAODFileName.Length() > 0) ) return NULL;
-
- AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
- if(aodHandler) {
- AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
- if(gExt) {
- AliAODEvent * gcEvent = gExt->GetAOD();
- return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_gamma", fGammaCutString.Data())));
- }
- }
-
- cout << "could not find branch " << Form("%s_gamma", fPionCutString.Data()) << endl;
- return NULL;
-}
-
-
-
-///_____________________________________________________________________
-TClonesArray * AliAnalysisTaskGammaJet::GetConversionPions(const AliAODEvent * aodEvent) {
-
- //Get Conversion pion branch of AOD. First try standard AOD
- TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(Form("%s_Pi0", fPionCutString.Data()) ));
-
- //If it's there, send it back
- if(convGamma) return convGamma;
-
-
- //If AOD not in standard file have to locate it in delta AOD
- if( !(fDeltaAODFileName.Length() > 0) ) return NULL;
-
- AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
- if(aodHandler) {
- AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
- if(gExt) {
- AliAODEvent * gcEvent = gExt->GetAOD();
- return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_Pi0", fPionCutString.Data())));
- }
- }
- return NULL;
-}
+++ /dev/null
-/* This file is property of and copyright *\r
- * ALICE Experiment at CERN, All rights reserved. *\r
- * See cxx source for full Copyright notice */\r
-\r
-/// @file AliAnalysisTaskGammaJet.h\r
-/// @author Svein Lindal\r
-/// @brief Class used to run isolation studies of conversion gamma / pions\r
- \r
-\r
-\r
-#ifndef ALIANALYSISTASKGAMMAJET_H\r
-#define ALIANALYSISTASKGAMMAJET_H\r
-\r
-\r
-\r
-class TH1F;\r
-class AliESDEvent;\r
-class AliGammaConversionAODObject;\r
-class AliAODConversionPhoton;\r
-class AliAODPWG4ParticleCorrelation;\r
-class AliAODPWG4Particle;\r
-class TObjArray;\r
-class TString;\r
-class TClonesArray;\r
-\r
-\r
-#include "AliAnaConvIsolation.h"\r
-#include "AliAnalysisTaskSE.h"\r
-\r
-class AliAnalysisTaskGammaJet : public AliAnalysisTaskSE {\r
-\r
-public:\r
- \r
- AliAnalysisTaskGammaJet(); \r
- AliAnalysisTaskGammaJet(const char *name);\r
- virtual ~AliAnalysisTaskGammaJet();\r
- \r
- virtual void UserCreateOutputObjects();\r
- virtual void UserExec(Option_t *option);\r
- virtual void Terminate(Option_t *);\r
-\r
- void SetDeltaAODFileName(TString string) { fDeltaAODFileName = string;}\r
- \r
- AliAnaConvIsolation * GetIsolation() const {return fAnaIsolation;}\r
- void SetIsolation( AliAnaConvIsolation * isolation) { fAnaIsolation = isolation; }\r
-\r
- void SetGammaCutId(TString cut) { fGammaCutString = Form("GammaConv_%s", cut.Data());}\r
- void SetPionCutId(TString cut) { fPionCutString = Form("GammaConv_%s", cut.Data());}\r
-\r
- void SetMinPt(Float_t minpt) { fMinPt = minpt;}\r
- void SetMinNTracks(Int_t nTracks) { fMinNTracks = nTracks; }\r
-\r
- void AddIsolationAna(TObject * isoAna) { fAnaIsolationArray->Add(isoAna);}\r
- void AddPhotonHadronAna(TObject * ana) { fAnaPhotonArray->Add(ana);}\r
- void AddPhotonJetAna(TObject * ana) { fAnaPhotonJetArray->Add(ana);}\r
- void AddPionJetAna(TObject * ana) { fAnaPionJetArray->Add(ana);}\r
- void AddPionHadronAna(TObject * ana) { fAnaPionArray->Add(ana);}\r
-\r
- void GetPionGrandChildren(const AliAODConversionPhoton * const pion, const TClonesArray * photons, Int_t* trackLabels);\r
- void SetEtaLimits(Float_t eta) { fEtaLimit = eta; }\r
-\r
-\r
- private:\r
-\r
- void NotifyRun();\r
- Bool_t UserNotify();\r
- Bool_t EventIsSynced(const TClonesArray * const tracks, const TClonesArray * const convGamma, const TClonesArray * const pions);\r
- Bool_t BothTracksPresent(const AliAODConversionPhoton * const photon, const TClonesArray * const tracks) const;\r
- Bool_t BothGammaPresent(const AliAODConversionPhoton * const pion, const TClonesArray * const photons, const TClonesArray * const tracks) const;\r
- AliAODEvent * GetAODEvent();\r
-\r
- //Get Conversion gammas branch\r
- TClonesArray * GetConversionGammas(const AliAODEvent * aodEvent);\r
- TClonesArray * GetConversionPions(const AliAODEvent * aodEvent);\r
-\r
- //Process conv gamma\r
- void ProcessConvGamma( const TClonesArray * const convGamma, const TClonesArray * const pions, const TClonesArray * const tracks);\r
- void ProcessPions( const TClonesArray * const pions, const TClonesArray * const photons, const TClonesArray * const tracks);\r
-\r
- //Process calorimeters\r
- void ProcessCalorimeters( const AliAODEvent * const aodEvent );\r
- \r
-\r
- //Does any pions have given photon (iPhot) index listed as daughter\r
- Bool_t IsDecayPion(Int_t iPhot, const TClonesArray * const pions); //see above\r
-\r
-\r
- TList *fOutputList; //! Output list\r
- Float_t fEtaLimit;\r
- TString fDeltaAODFileName; //! File where Gamma Conv AOD is located, if not in default AOD\r
- TString fGammaCutString; //! The cut string of the conversion analysis used to produce input AOD\r
- TString fPionCutString; //! The cut string of the conversion analysis used to produce input AOD\r
-\r
-\r
- AliAnaConvIsolation * fAnaIsolation;\r
-\r
- TObjArray * fAnaIsolationArray; //!Array of isolation analysis objects\r
- TObjArray * fAnaPionArray; //!Array of pion - hadron ana objects\r
- TObjArray * fAnaPhotonArray; //!Array of photon - hadron ana objects\r
- TObjArray * fAnaPhotonJetArray; //!Array of photon - jet ana objects\r
- TObjArray * fAnaPionJetArray; //!Array of photon - jet ana objects\r
-\r
- Float_t fMinPt; //Minimum pt for leading particles\r
- Int_t fMinNTracks; //Minimum number of tracks in event\r
- \r
- TH2F * fhTracksMissingPt[2];\r
- \r
-\r
-\r
- \r
- AliAnalysisTaskGammaJet(const AliAnalysisTaskGammaJet&); // not implemented\r
- AliAnalysisTaskGammaJet& operator=(const AliAnalysisTaskGammaJet&); // not implemented\r
- \r
- ClassDef(AliAnalysisTaskGammaJet, 4); // example of analysis\r
-};\r
-\r
-#endif\r
#pragma link C++ class AliGammaConversionBGHandler+;
#pragma link C++ class AliAnalysisTaskGammaConvDalitz+;
#pragma link C++ class AliAnalysisTaskGCPartToPWG4Part+;
-#pragma link C++ class AliAnalysisTaskGammaJet+;
#pragma link C++ class AliAnaConvIsolation+;
#pragma link C++ class AliAnaConvCorrBase++;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff