Updating conv correlation software
authorslindal <slindal@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 May 2011 13:22:26 +0000 (13:22 +0000)
committerslindal <slindal@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 May 2011 13:22:26 +0000 (13:22 +0000)
15 files changed:
PWG4/GammaConv/AliAODConversionParticle.cxx
PWG4/GammaConv/AliAODConversionParticle.h
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrBase.cxx
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrBase.h
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPhoton.cxx
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPhoton.h
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPhotonJet.cxx
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPhotonJet.h
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPion.cxx
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPion.h
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.cxx [new file with mode: 0644]
PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.h [new file with mode: 0644]
PWG4/GammaConv/ConvCorrelations/AliAnalysisTaskGammaJet.cxx
PWG4/GammaConv/ConvCorrelations/AliAnalysisTaskGammaJet.h
PWG4/GammaConv/ConvCorrelations/macros/ConfigGammaJet.C

index 3bd87b5..7fa312a 100644 (file)
@@ -212,3 +212,20 @@ Bool_t AliAODConversionParticle::IsMySpawn(const Int_t trackId, const Int_t nSpa
   return kFALSE;
 }
 
+///_______________________________________________________________________________
+void AliAODConversionParticle::GetGrandChildren(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++) {
+    AliAODConversionParticle * gamma = dynamic_cast<AliAODConversionParticle*>(photons->At(GetTrackLabel(i)));
+
+    if(gamma) { 
+      for(Int_t j = 0; j< 2; j++) {
+       trackLabels[ i*2+ j] = gamma->GetTrackLabel(j);
+      }
+
+    } else {
+      cout << "AliAODConversionParticle::GetTrackLabels() :: Not good!!!"<<endl;
+    }
+  }
+}
index 047d942..9439989 100644 (file)
@@ -85,7 +85,7 @@ class AliAODConversionParticle : public AliAODPhoton {
   Int_t GetElectronMCLabel2() const;
 
   Bool_t IsMySpawn(const Int_t trackId, const Int_t nSpawn, const Int_t * const spawn) const;
-
+  void GetGrandChildren(const TClonesArray * photons, Int_t* trackLabels);
  private:
 
   Int_t fLabel[2];
index 1e37e8b..a880a6e 100644 (file)
 
 #include "TClonesArray.h"
 #include "TH1F.h"
-#include "TH1I.h"
-#include "TH2F.h"
+#include "TH3.h"
 #include "TList.h"
-#include "TNtuple.h"
 #include "AliAODConversionParticle.h"
 
 
@@ -43,187 +41,118 @@ ClassImp(AliAnaConvCorrBase)
 AliAnaConvCorrBase::AliAnaConvCorrBase(TString name) : TObject(),
   fName(name),
   fHistograms(NULL),
-  fTriggerPt(0), 
-  fCorrelatedPt(0),
-  fNPhiBins(32)
+  fNPhiBins(32),
+  fdPhiBins(NULL),
+  fPtBins(NULL)
 {
   //Constructor
-  fTBins[0] = 7.0;
-  fTBins[1] = 5.0;
-  fTBins[2] = 3.0;
+  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);
+  }
 
-  fCBins[0] = 5.0;
-  fCBins[1] = 3.0;
-  fCBins[2] = 1.5;
+  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);
+  }
+  
   for(int iIso = 0; iIso < 2; iIso++) {
-    fHEtaPhiPt[iIso] = NULL;
-    fHdEta[iIso] = NULL;
     fHdPhi[iIso] = NULL;
     fHNTriggers[iIso] = NULL;
-    for(Int_t tBin = 0; tBin < fNTBins; tBin++) {
-      for(Int_t cBin = 0; cBin < fNCBins; cBin++) {
-       fHdPhiBins[iIso][tBin][cBin] = NULL;
-      }
-    }
   }
 
+
+
 }
 
 
 //________________________________________________________________________________
 AliAnaConvCorrBase::~AliAnaConvCorrBase() {
-  
   ///destructor
-  // delete[] fCBins;
-  // delete[] fTBins;
+  if(fPtBins)
+    delete fPtBins;
+  fPtBins = NULL;
+  
+  if(fdPhiBins)
+    delete fdPhiBins;
+  fdPhiBins = NULL;
+  
 
 }
 
 
-//________________________________________________________________________
 void AliAnaConvCorrBase::CreateHistograms() {
+  CreateBaseHistograms();
+}
+
+//________________________________________________________________________
+void AliAnaConvCorrBase::CreateBaseHistograms() {
   //Create histograms add, to outputlis
 
+  cout << "Createing histograms for "<< fName.Data() << endl;
+
   fHistograms = new TList();
   fHistograms->SetOwner(kFALSE);
   fHistograms->SetName(fName);
 
-
-
   for(int iIso = 0; iIso < 2; iIso++) {
-    fHEtaPhiPt[iIso] = new TH2F(
-                                 Form("%s_deta_dphi_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                                 Form("%s_deta_dphi_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                                 200, -2., 2., fNPhiBins, -TMath::PiOver2(), 3*TMath::PiOver2());
-      fHistograms->Add(fHEtaPhiPt[iIso]);
-  }
-
-  for(int iIso = 0; iIso < 2; iIso++) {
-    fHdEta[iIso] = new TH1F(Form("%s_deta_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                           Form("%s_deta_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                           200, -2, 2);
-    fHistograms->Add(fHdEta[iIso]);
-  }
 
-  for(int iIso = 0; iIso < 2; iIso++) {
-    fHdPhi[iIso] = new TH1F(Form("%s_dphi_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                           Form("%s_dphi_corr_%s", fName.Data(),  (iIso==0)?"nonIso":"isolated"),
-                           fNPhiBins, -TMath::PiOver2(), 3*TMath::PiOver2());
+    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());
+    fHNTriggers[iIso]->Sumw2();
+    fHistograms->Add(fHNTriggers[iIso]);
   
-  for(int iIso = 0; iIso < 2; iIso++) {
-      fHNTriggers[iIso] = new TH1I(Form("%s_%s_fNTriggers", fName.Data(), (iIso==0)?"nonIso":"isolated"), 
-                                  Form("%s_%s_fNTriggers", fName.Data(), (iIso==0)?"nonIso":"isolated"), 
-                                  fNTBins, 0, fNTBins );
-      fHistograms->Add(fHNTriggers[iIso]);
   }
 
-
-  for(int iIso = 0; iIso < 2; iIso++) {
-    for(Int_t tBin = 0; tBin < fNTBins; tBin++) {
-      for(Int_t cBin = 0; cBin < fNCBins; cBin++) {
-       fHdPhiBins[iIso][tBin][cBin] =  new TH1F(Form("%s_%s_phi_corr_tBin_%d_cBin_%d", fName.Data(), (iIso==0)?"nonIso":"isolated", tBin, cBin),
-                                                Form("%s particles dPhi %f<tPt< %f  %f<cPt<%f", (iIso==0)?"not isolated":"isolated", GetLowerBinLimit(tBin, fTBins), GetUpperBinLimit(tBin, fTBins), 
-                                                     GetLowerBinLimit(cBin, fCBins), GetUpperBinLimit(cBin, fCBins)),
-                                                fNPhiBins, -TMath::PiOver2(), 3*TMath::PiOver2());
-       fHistograms->Add(fHdPhiBins[iIso][tBin][cBin]);
-      }
-    }
-  }
 }
 
 
 ///____________________________________________________________________________
 void AliAnaConvCorrBase::FillTriggerCounters(Float_t tPt, Bool_t isolated){ 
   //Fill histogram with trigger counters
-  fHNTriggers[0]->Fill(GetTriggerBin(tPt));
-  if(isolated)   fHNTriggers[isolated]->Fill(GetTriggerBin(tPt));
-
 
+  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
-  Float_t ptFrac = cPt/tPt;
-
-  Int_t triggerBin = GetTriggerBin(tPt);
-  Int_t corrBin = GetCorrBin(cPt);
-
-  if(triggerBin < 0 ||corrBin < 0) return;
-
-  fHEtaPhiPt[0]->Fill(dEta, dPhi, cPt);
-  fHdEta[0]->Fill(dEta, cPt);
-  fHdPhi[0]->Fill(dPhi, cPt);
-  fHdPhiBins[0][triggerBin][corrBin]->Fill(dPhi);
-  
 
+  if(dEta) { ;}
+  fHdPhi[0]->Fill(tPt, cPt, dPhi);
   if(isolated) {
-    fHEtaPhiPt[isolated]->Fill(dEta, dPhi, cPt);
-    fHdEta[isolated]->Fill(dEta, ptFrac);
-    fHdPhi[isolated]->Fill(dPhi, ptFrac);
-    fHdPhiBins[isolated][triggerBin][corrBin]->Fill(dPhi);
-
-  }
-}
-
-///____________________________________________________________________________
-Int_t AliAnaConvCorrBase::GetTriggerBin(Float_t pt) const {
-  //Get trigger bin
-  for(Int_t i = 0; i < fNTBins; i++) {
-    if(pt > fTBins[i]) return i;
-  }
-
-  return -1;
-}
-
-///____________________________________________________________________________
-Int_t AliAnaConvCorrBase::GetCorrBin(Float_t pt) const {
-  //Get correlation particle bin
-  for(Int_t i = 0; i < fNCBins; i++) {
-    if(pt > fCBins[i]) return i;
+    fHdPhi[isolated]->Fill(tPt, cPt, dPhi);
   }
-
-  return -1;
-}
-
-
-
-///______________________________________________________________________________
-Float_t AliAnaConvCorrBase::GetLowerBinLimit(const Int_t bin, const Float_t * const bins) const {
-  //Get lower bin limit for bin 
-  return bins[bin];
-}
-
-///______________________________________________________________________________
-Float_t AliAnaConvCorrBase::GetUpperBinLimit(const Int_t bin, const Float_t * const bins) const {
-  //Get upper bin limit for bin 
-
-  Float_t limit = -999.;
-  if(bin < 1)
-    limit = 999.;
-  else
-    limit = bins[bin - 1];
-
-  return limit;
-
 }
 
-
 //_______________________________________________________________________________
 
 void AliAnaConvCorrBase::PrintStatistics()  { 
   //Print some statistics between each file
-  
-  for(Int_t i = 0; i < fNTBins; i++) {
+  for(Int_t i = 1; i <= fHNTriggers[0]->GetNbinsX(); i++) {
     Int_t nTrig = (Int_t) fHNTriggers[0]->GetBinContent(i+1);
     cout << "triggers: " << nTrig << endl;
-    for(int j = 0; j < fNCBins; j++) {
-      cout << fHdPhiBins[0][i][j]->GetEntries() << "/" << ((nTrig>0)? fHdPhiBins[0][i][j]->GetEntries()/nTrig : 0) << ";  ";
-    }
-    cout << endl;
+
   }
 }
index 1de58bb..233291d 100644 (file)
@@ -15,7 +15,7 @@
 #include "TH1.h"\r
 \r
 class TH1F;\r
-class TH1I;\r
+class TH3F;\r
 class TH2F;\r
 class AliAODConversionParticle;\r
 class TClonesArray;\r
@@ -34,16 +34,18 @@ public:
   virtual ~AliAnaConvCorrBase();\r
   \r
   //Set and get min pt for triggers\r
-  void SetTriggerPt(Float_t pt) { fTriggerPt = pt; }\r
-  inline Float_t GetTriggerPt() const {return fTriggerPt; }\r
+  // void SetTriggerPt(Float_t pt) { fTriggerPt = pt; }\r
+  // inline Float_t GetTriggerPt() const {return fTriggerPt; }\r
 \r
 \r
-  //Set and get min pt for correlation particles\r
-  void SetCorrelatedPt(Float_t pt) { fCorrelatedPt = pt; }\r
-  inline Float_t GetCorrelatedPt() const {return fCorrelatedPt; }\r
+  // //Set and get min pt for correlation particles\r
+  // void SetCorrelatedPt(Float_t pt) { fCorrelatedPt = pt; }\r
+  // inline Float_t GetCorrelatedPt() const {return fCorrelatedPt; }\r
 \r
   //CreateHistograms\r
-  void CreateHistograms();\r
+  void CreateBaseHistograms();\r
+  //To be overrriden by children. Should always call CreateBaseHistograms()\r
+  virtual void CreateHistograms();\r
   \r
   //Get list of histograms\r
   TList * GetHistograms() const { return fHistograms;}\r
@@ -61,15 +63,8 @@ public:
     else return ( (dPhi>0)? dPhi - TMath::TwoPi() : dPhi + TMath::TwoPi() ); \r
   }\r
 \r
-  ///Get bin limits of various pt bins\r
-  Float_t GetLowerBinLimit(const Int_t bin, const Float_t * const bins) const;\r
-  Float_t GetUpperBinLimit(const Int_t bin, const Float_t * const bins) const;\r
-\r
-  //Get trigger bin for particle carrying given pt\r
-  Int_t GetTriggerBin(Float_t pt) const;\r
-  //Get correlation particle pt bin for particle carrying given pt\r
-  Int_t GetCorrBin(Float_t pt) const;\r
 \r
+  TArrayD * GetTriggerBins() const { return fPtBins; }\r
 \r
   //Print statistics for histograms\r
   void PrintStatistics();\r
@@ -85,32 +80,22 @@ protected:
  private:\r
   \r
   TString fName; //name of analysis\r
-\r
-  static const Int_t fNTBins = 3; //Number of trigger pt bins\r
-  static const Int_t fNCBins = 3; //Number of corr particles pt bins\r
-\r
   TList * fHistograms; //List of histograms\r
 \r
-  TH2F * fHEtaPhiPt[2]; //2D eta phi correlations histogram\r
-  TH1F * fHdEta[2]; //Eta correlations histogram\r
-  TH1F * fHdPhi[2]; //Phi correlations histogram\r
-\r
-  TH1F * fHdPhiBins[2][fNTBins][fNCBins]; //dPhi correlations histograms in several bins\r
-  TH1I * fHNTriggers[2]; //Histograms containing number of triggers in various bins\r
+  Int_t fNPhiBins;  //Nbins in phi direction\r
+  TArrayD * fdPhiBins; //!transient phi bin array\r
+  TArrayD * fPtBins; //!Array of trigger bins\r
   \r
-  Float_t fTBins[fNTBins]; ///Array of trigger bin limits\r
-  Float_t fCBins[fNCBins];///Array of corr particle pt bin limits\r
-  \r
-  Float_t fTriggerPt; //Min trigger particle pt\r
-  Float_t fCorrelatedPt; // Min correlation particle pt\r
 \r
-  Int_t fNPhiBins; //Number of bins in phi \r
-  \r
+  TH3F * fHdPhi[2]; //dPhi pt histogram\r
+  TH1F * fHNTriggers[2]; //Histograms containing number of triggers in various bins\r
+\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, 2); // example of analysis\r
+  ClassDef(AliAnaConvCorrBase, 3); // example of analysis\r
 };\r
 \r
 #endif\r
index 4d24b43..31abf21 100644 (file)
@@ -33,14 +33,16 @@ ClassImp(AliAnaConvCorrPhoton)
 //________________________________________________________________________
 AliAnaConvCorrPhoton::AliAnaConvCorrPhoton() :
 AliAnaConvCorrBase("photon_hadron_corr"), 
-  fSkipDecayParticles(kFALSE)
+  fSkipDecayParticles(kFALSE),
+  fDecayOnly(kFALSE)
 {
   //consctructor
 }
 //________________________________________________________________________
 AliAnaConvCorrPhoton::AliAnaConvCorrPhoton(TString name) :
 AliAnaConvCorrBase(name), 
-fSkipDecayParticles(kFALSE)
+fSkipDecayParticles(kFALSE),
+fDecayOnly(kFALSE)
 {
   //consctructor
 }
@@ -53,12 +55,14 @@ AliAnaConvCorrPhoton::~AliAnaConvCorrPhoton() {
 
 ///__________________________________________________________________________
 void AliAnaConvCorrPhoton::CorrelateWithHadrons(const AliAODConversionParticle * 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;
 
   FillTriggerCounters(photon->Pt(), isolated);
-  //See header file for documentation
+
   if (tracks) {
       
     for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
index ceec7b1..b1dc46d 100644 (file)
@@ -28,11 +28,13 @@ public:
   //Process particles identified as pion / eta decay \r
   void SkipDecayParticles() { fSkipDecayParticles = kTRUE; }\r
   void DoDecayParticles() { fSkipDecayParticles = kFALSE; }\r
-  \r
+  void DoDecayOnly() { fSkipDecayParticles = kFALSE; fDecayOnly = kTRUE; }\r
+\r
  private:\r
 \r
   \r
   Bool_t fSkipDecayParticles; //Process particles identified as pion / eta decay particles\r
+  Bool_t fDecayOnly;\r
 \r
   AliAnaConvCorrPhoton(const AliAnaConvCorrPhoton&); // not implemented\r
   AliAnaConvCorrPhoton& operator=(const AliAnaConvCorrPhoton&); // not implemented\r
index 11626e9..e95709b 100644 (file)
@@ -23,6 +23,8 @@
 #include "AliAODConversionParticle.h"
 #include "AliAODJet.h"
 
+#include "TRefArray.h"
+#include "TH1F.h"
 #include <iostream>
 // Gamma - jet correlation analysis task
 // Authors: Svein Lindal
@@ -48,16 +50,108 @@ AliAnaConvCorrPhotonJet::~AliAnaConvCorrPhotonJet() {
   //destructor
 }
 
-///_______________________________________________________________________________
-void AliAnaConvCorrPhotonJet::CorrelateWithHadrons(const AliAODConversionParticle * const photon, const TClonesArray * const tracks, const Bool_t isolated) {
 
+void AliAnaConvCorrPhotonJet::CreateHistograms() {
+  
+  CreateBaseHistograms();
+  fhPtFracGamma = new TH1F("fhPtFracGamma", "fhPtFracGamma", 100, 0, 10);
+  GetHistograms()->Add(fhPtFracGamma);
+  fhPtFracPion = new TH1F("fhPtFracPion", "fhPtFracPion", 100, 0, 10);
+  GetHistograms()->Add(fhPtFracPion);
+
+}
+
+void AliAnaConvCorrPhotonJet::DoJetAnalysisGamma(AliAODJet * jet, const TClonesArray * const photons, const  TClonesArray *const pions ) const{
+  
+  Int_t trackIDs[4];
+
+  for(Int_t i = 0; i < photons->GetEntriesFast(); i++) {
+    AliAODConversionParticle * photon = dynamic_cast<AliAODConversionParticle*>(photons->At(i));
+    if(photon) {
+      trackIDs[0] = photon->GetLabel1();
+      trackIDs[1] = photon->GetLabel2();
+      if(IsParticleInJet(jet, photon, 2, trackIDs)){
+       fhPtFracGamma->Fill(photon->Pt()/jet->Pt());
+      }
+    }
+  }
+
+
+
+  for(Int_t i = 0; i < pions->GetEntriesFast(); i++) {
+    AliAODConversionParticle * pion = dynamic_cast<AliAODConversionParticle*>(pions->At(i));
+    if(pion) {
+      pion->GetGrandChildren(photons, trackIDs);
+      if(IsParticleInJet(jet, pion, 4, trackIDs)){
+       fhPtFracPion->Fill(pion->Pt()/jet->Pt());
+      }
+    }
+  }
+  
+  
+  
+
+  
+}
+
+//________________________________________________________________________________
+Bool_t AliAnaConvCorrPhotonJet::IsParticleInJet(AliAODJet * jet, const AliAODConversionParticle * const particle, Int_t nTracks, Int_t * trackIds) const {
+
+  Int_t mTracks = 0;
+  TRefArray * refTracks = jet->GetRefTracks();
+  for(Int_t jRef = 0; jRef < refTracks->GetEntriesFast(); jRef++) {
+    AliAODTrack * track = dynamic_cast<AliAODTrack*>(refTracks->At(jRef));
+    if(track) {
+      for(Int_t it = 0; it < nTracks; it++) {
+       if (track->GetID() == trackIds[it]) {
+         mTracks++;
+       }
+      }
+    }
+  }
+
+  //cout <<mTracks << " " << (mTracks > 1) << endl;
+  return (mTracks > 1);
+}
+
+
+//________________________________________________________________________________
+Double_t AliAnaConvCorrPhotonJet::ExtractFromJet(AliAODJet * jet, const AliAODConversionParticle * const particle) const {
+  
+  Float_t jetPt = jet->Pt();
+  cout << "Jet pt before and after: " << jetPt << "    ";
+
+  TRefArray * refTracks = jet->GetRefTracks();
+  for(Int_t jRef = 0; jRef < refTracks->GetEntriesFast(); jRef++) {
+    AliAODTrack * track = dynamic_cast<AliAODTrack*>(refTracks->At(jRef));
+    if(track) {
+      if (track->GetID() == particle->GetLabel1() || track->GetID() == particle->GetLabel2()) {
+       cout << " - " << track->Pt() << "  ";
+       jetPt = jetPt - track->Pt();
+      } else {
+       //cout << track->Pt() << endl;
+      }
+    } else {
+      cout <<"FUUUUUUUUUUUUUUUUUCJK"<<endl;
+    }
+  }
+  
+  cout << jetPt << endl;
+  return jetPt;
+}
+
+
+
+///_______________________________________________________________________________
+void AliAnaConvCorrPhotonJet::CorrelateWithHadrons(const AliAODConversionParticle * const photon, const TClonesArray * const jets, const Bool_t isolated) {
+  FillTriggerCounters(photon->Pt(), isolated);
   //See header file for documentation
-  if (tracks) {
-      
-    for(int ij = 0; ij < tracks->GetEntriesFast(); ij++) {
-      AliAODJet * jet = dynamic_cast<AliAODJet*>(tracks->At(ij));
+  if (jets) {
+    for(int ij = 0; ij < jets->GetEntriesFast(); ij++) {
+      AliAODJet * jet = dynamic_cast<AliAODJet*>(jets->At(ij));
       if(jet) {
-       FillHistograms(photon->Pt(), jet->Pt(), 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);
       }
     }
   }
index ae570ff..9d631c2 100644 (file)
 \r
 #include "AliAnaConvCorrBase.h"\r
 \r
+class TH1F;\r
+\r
 class AliAODConversionParticle;\r
 class TClonesArray;\r
-\r
+class AliAODJet;\r
 class AliAnaConvCorrPhotonJet : public AliAnaConvCorrBase {\r
 \r
 public:\r
@@ -24,13 +26,20 @@ public:
   \r
   //Correlate photon with jets\r
   virtual void CorrelateWithHadrons(const AliAODConversionParticle * const photon, const TClonesArray * const jets, const Bool_t isolated);\r
-  \r
+  Double_t ExtractFromJet(AliAODJet * jet, const AliAODConversionParticle * const particle)  const;\r
+  Bool_t IsParticleInJet(AliAODJet * jet, const AliAODConversionParticle * const particle, Int_t nTracks, Int_t * trackIds) const;\r
+  void DoJetAnalysisGamma(AliAODJet * jet, const TClonesArray * const photons, const  TClonesArray *const pions ) const;\r
+  void CreateHistograms();\r
+\r
  private:\r
 \r
   AliAnaConvCorrPhotonJet(const AliAnaConvCorrPhotonJet&); // not implemented\r
   AliAnaConvCorrPhotonJet& operator=(const AliAnaConvCorrPhotonJet&); // not implemented\r
   ClassDef(AliAnaConvCorrPhotonJet, 1); // \r
 \r
+  TH1F * fhPtFracGamma;// = new TH1F("fhPtFracGamma", "fhPtFracGamma", 100, 0, 10);\r
+  TH1F * fhPtFracPion;// = new TH1F("fhPtFracPion", "fhPtFracPion", 100, 0, 10);\r
+\r
 };\r
 \r
 #endif\r
index 5bc7eca..b7dec4f 100644 (file)
@@ -23,6 +23,8 @@
 #include "AliAODTrack.h"
 #include "TClonesArray.h"
 #include "AliAODConversionParticle.h"
+#include "THnSparse.h"
+#include "TH2F.h"
 
 #include <iostream>
 
 using namespace std;
 ClassImp(AliAnaConvCorrPion)
 
-//________________________________________________________________________
+//________________________________________________________________________________
 AliAnaConvCorrPion::AliAnaConvCorrPion() :
-AliAnaConvCorrBase("pion_hadron_corr") {
+AliAnaConvCorrBase("pion_hadron_corr"), 
+  fhdPhiVsInvMassPi0(NULL), 
+  fhdPhiVsInvMassEta(NULL), 
+  fhPtVsInvMass(NULL)
+{
   //consctructor
 }
-//________________________________________________________________________
+//________________________________________________________________________________
 AliAnaConvCorrPion::AliAnaConvCorrPion(TString name) :
-AliAnaConvCorrBase(name) {
+  AliAnaConvCorrBase(name),
+  fhdPhiVsInvMassPi0(NULL), 
+  fhdPhiVsInvMassEta(NULL), 
+  fhPtVsInvMass(NULL)
+{
   //consctructor
 }
 
@@ -47,8 +57,31 @@ AliAnaConvCorrPion::~AliAnaConvCorrPion() {
   //destructor
 }
 
+///________________________________________________________________________________
+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);
 
-///_______________________________________________________________________________
+}
+
+///________________________________________________________________________________
 void AliAnaConvCorrPion::GetTrackLabels(const AliAODConversionParticle * pion, const TClonesArray * photons, Int_t* trackLabels) {
   ///Get the track labels of the electrons reconstructed as gamma forming the pion
 
@@ -74,23 +107,27 @@ void AliAnaConvCorrPion::GetTrackLabels(const AliAODConversionParticle * pion, c
 }
  
 
-///__________________________________________________________________________
+///________________________________________________________________________________
 void AliAnaConvCorrPion::CorrelateWithHadrons(AliAODConversionParticle * 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(pion->IsMySpawn(track->GetID(), nSpawn, spawn)) continue;
        
-       if (track->Pt() < GetCorrelatedPt() ) continue;
-
+       //      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);
-
       }
     }
   }
index 6cec4d3..e8993c6 100644 (file)
@@ -11,6 +11,7 @@
 #define ALIANACONVCORRPION_CXX\r
 \r
 #include "AliAnaConvCorrBase.h"\r
+#include "THnSparse.h"\r
 \r
 class AliAODConversionParticle;\r
 class TClonesArray;\r
@@ -25,12 +26,18 @@ public:
 \r
   //Correlate pions with charged tracks\r
   virtual void CorrelateWithHadrons(AliAODConversionParticle * pion, const TClonesArray * tracks, const Bool_t isolated, const Int_t nSpawn, const Int_t * const spawn );\r
+\r
+  void CreateHistograms();\r
   \r
  private:\r
 \r
   //Get array of track labels of the 4 decay electrons (2gamma * 2 electrons)\r
   void GetTrackLabels(const AliAODConversionParticle * pion, const TClonesArray * photons, Int_t* trackLabels);\r
 \r
+  THnSparseF * fhdPhiVsInvMassPi0; //!\r
+  THnSparseF * fhdPhiVsInvMassEta; //!\r
+  TH2F * fhPtVsInvMass;\r
+\r
   AliAnaConvCorrPion(const AliAnaConvCorrPion&); // not implemented\r
   AliAnaConvCorrPion& operator=(const AliAnaConvCorrPion&); // not implemented\r
   ClassDef(AliAnaConvCorrPion, 1); // example of analysis\r
diff --git a/PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.cxx b/PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.cxx
new file mode 100644 (file)
index 0000000..40a6972
--- /dev/null
@@ -0,0 +1,66 @@
+/**************************************************************************
+ * 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   AliAnaConvCorrPion.cxx
+/// @author Svein Lindal
+/// @brief  Class used to fill calculate correlation between photons - jets
+
+#include "AliAnaConvCorrPionJet.h"
+#include "AliAODTrack.h"
+#include "TClonesArray.h"
+#include "AliAODConversionParticle.h"
+#include "AliAODJet.h"
+
+#include <iostream>
+// Gamma - jet correlation analysis task
+// Authors: Svein Lindal
+
+
+using namespace std;
+ClassImp(AliAnaConvCorrPionJet)
+
+//________________________________________________________________________________
+AliAnaConvCorrPionJet::AliAnaConvCorrPionJet() :
+AliAnaConvCorrBase("photonJet") {
+  //consctructor
+}
+//________________________________________________________________________________
+AliAnaConvCorrPionJet::AliAnaConvCorrPionJet(TString name) :
+AliAnaConvCorrBase(name) {
+  //consctructor
+}
+
+
+//________________________________________________________________________________
+AliAnaConvCorrPionJet::~AliAnaConvCorrPionJet() {
+  //destructor
+}
+
+///_______________________________________________________________________________
+void AliAnaConvCorrPionJet::CorrelateWithHadrons(const AliAODConversionParticle * const pion, const TClonesArray * const jets, const Bool_t isolated) {
+
+  FillTriggerCounters(pion->Pt(), 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);
+      }
+    }
+  }
+}
diff --git a/PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.h b/PWG4/GammaConv/ConvCorrelations/AliAnaConvCorrPionJet.h
new file mode 100644 (file)
index 0000000..d5e654e
--- /dev/null
@@ -0,0 +1,36 @@
+/* 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   AliAnaConvCorrPion.h\r
+/// @author Svein Lindal\r
+/// @brief  Class used to find correlations between photons and jets\r
+\r
+#ifndef ALIANACONVCORRPIONJET_CXX\r
+#define ALIANACONVCORRPIONJET_CXX\r
+\r
+#include "AliAnaConvCorrBase.h"\r
+\r
+class AliAODConversionParticle;\r
+class TClonesArray;\r
+\r
+class AliAnaConvCorrPionJet : public AliAnaConvCorrBase {\r
+\r
+public:\r
+\r
+  AliAnaConvCorrPionJet(); \r
+  AliAnaConvCorrPionJet(TString name); \r
+  virtual ~AliAnaConvCorrPionJet();\r
+  \r
+  //Correlate photon with jets\r
+  virtual void CorrelateWithHadrons(const AliAODConversionParticle * const photon, const TClonesArray * const jets, const Bool_t isolated);\r
+  \r
+ private:\r
+\r
+  AliAnaConvCorrPionJet(const AliAnaConvCorrPionJet&); // not implemented\r
+  AliAnaConvCorrPionJet& operator=(const AliAnaConvCorrPionJet&); // not implemented\r
+  ClassDef(AliAnaConvCorrPionJet, 1); // \r
+\r
+};\r
+\r
+#endif\r
index ece64cd..5486a0a 100644 (file)
@@ -1,3 +1,4 @@
+
 /**************************************************************************
  * This file is property of and copyright by the ALICE HLT Project        *
  * ALICE Experiment at CERN, All rights reserved.                         *
@@ -27,6 +28,8 @@
 #include "TObjArray.h"
 
 
+#include "TH2F.h"
+
 #include "AliAnalysisTask.h"
 #include "AliAnalysisManager.h"
 #include "AliAnalysisTaskGammaJet.h"
 
 #include "AliAnaConvCorrPhoton.h"
 #include "AliAnaConvCorrPhotonJet.h"
+#include "AliAnaConvCorrPionJet.h"
 #include "AliAnaConvCorrPion.h"
+
+#include "AliAODTrack.h"
+
 // Gamma - jet correlation analysis task
 // Authors: Svein Lindal
 
@@ -62,14 +69,17 @@ ClassImp(AliAnalysisTaskGammaJet)
 AliAnalysisTaskGammaJet::AliAnalysisTaskGammaJet() : 
 AliAnalysisTaskSE(), 
   fOutputList(NULL), 
+  fEtaLimit(0.8),
   fDeltaAODFileName("AliAODGammaConversion.root"),
-  fConversionCutString("GammaConv"),
+  fGammaCutString("GammaConv"),
+  fPionCutString("GammaConv"),
   fAnaIsolation(NULL), 
   fAnaIsolationArray(NULL), 
   fAnaPionArray(NULL), 
   fAnaPhotonArray(NULL),
   fAnaPhotonJetArray(NULL),
-  fMinPt(3.0), 
+  fAnaPionJetArray(NULL),
+  fMinPt(1.0), 
   fMinNTracks(20)
 {
   // Dummy Constructor
@@ -85,14 +95,17 @@ AliAnalysisTaskGammaJet::~AliAnalysisTaskGammaJet() {
 AliAnalysisTaskGammaJet::AliAnalysisTaskGammaJet(const char *name) : 
   AliAnalysisTaskSE(name), 
   fOutputList(0), 
+  fEtaLimit(0.8),
   fDeltaAODFileName("AliAODGammaConversion.root"),
-  fConversionCutString("GammaConv"),
+  fGammaCutString("GammaConv"),
+  fPionCutString("GammaConv"),
   fAnaIsolation(NULL),
   fAnaIsolationArray(NULL),
   fAnaPionArray(NULL),
   fAnaPhotonArray(NULL),
   fAnaPhotonJetArray(NULL), 
-  fMinPt(3.0),
+  fAnaPionJetArray(NULL),
+  fMinPt(1.0),
   fMinNTracks(20)
 {
   // Constructor
@@ -110,18 +123,108 @@ AliAnalysisTaskGammaJet::AliAnalysisTaskGammaJet(const char *name) :
   fAnaPhotonJetArray = new TObjArray();
   fAnaPhotonJetArray->SetOwner(kTRUE);
 
+  fAnaPionJetArray = new TObjArray();
+  fAnaPionJetArray->SetOwner(kTRUE);
+
   fAnaIsolationArray = new TObjArray();
   fAnaIsolationArray->SetOwner(kTRUE);
 
 }
 
 //________________________________________________________________________
+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());
 
@@ -166,69 +269,28 @@ void AliAnalysisTaskGammaJet::UserCreateOutputObjects()
       AliError("problem getting jet  ana pointer!!!");
     }
   }
-  
-
-  PostData(1, fOutputList);
-
-
-}
-
-//________________________________________________________________________
-void AliAnalysisTaskGammaJet::UserExec(Option_t *) 
-{
-  //Inherited from AliAnalysisTaskSE
-
-  ///Get AOD event
-  AliAODEvent * aodEvent = GetAODEvent();
-  if(!aodEvent) {
-    AliError("No AOD event!!");
-    return;
-  }
-
-  TClonesArray * photons = GetConversionGammas(aodEvent);
-  if(!photons) {
-    AliError("No Conversion gamma!!");
-    return;
-  }
-
-  TClonesArray * pions = GetConversionPions(aodEvent);
-  if(!pions) {
-    AliError("No Conversion gamma!!");
-    return;
-  }
 
-  TClonesArray * tracks = aodEvent->GetTracks();
-  if(!tracks) {
-    AliError("Can't get tracks!!");
-    return;
-  }
-
-  if(!((Entry() )%10000)) {
-    AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
-    AliInfo(Form("%d %d", photons->GetEntriesFast(), pions->GetEntriesFast()));
+  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!!!");
+    }
   }
 
+  
 
- if(aodEvent->GetNumberOfTracks() < fMinNTracks) return;
-
-  if(photons->GetEntriesFast() > aodEvent->GetNumberOfTracks()) {
-    AliError(Form("more conv gamma than tracks, ntracks %d, nconvGamma %d:  ", aodEvent->GetNumberOfTracks(), photons->GetEntriesFast()));
-    return;
-
-  } else if(photons->GetEntriesFast() > 0) {
-    
-    ProcessConvGamma(photons, pions, tracks);
-    ProcessPions(pions, photons, tracks);
-  } 
-
-       
   PostData(1, fOutputList);
 
+
 }
 
 
 
 
+
 //______________________________________________________________________________________________
 void AliAnalysisTaskGammaJet::ProcessCalorimeters( const AliAODEvent * const aodEvent ) {
   //See header file for documentation
@@ -258,10 +320,107 @@ void AliAnalysisTaskGammaJet::ProcessCalorimeters( const AliAODEvent * const aod
   
 }
 
+//______________________________________________________________________________________________
+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++) {
+    AliAODConversionParticle * photon = dynamic_cast<AliAODConversionParticle*>(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->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;
+      }
+    }
+  }
+  
+  //cout  <<"insync"<<endl;
+  return kTRUE;
+}
+
+
+//______________________________________________________________________________________________
+Bool_t AliAnalysisTaskGammaJet::BothTracksPresent(const AliAODConversionParticle * 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->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 AliAODConversionParticle * const pion, const TClonesArray * const photons, const TClonesArray * const tracks)  const {
+
+  AliAODConversionParticle * photon1 = dynamic_cast<AliAODConversionParticle*>(photons->At(pion->GetLabel1()));
+  AliAODConversionParticle * photon2 = dynamic_cast<AliAODConversionParticle*>(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++) {
     Bool_t delP = kFALSE;
@@ -277,7 +436,9 @@ void AliAnalysisTaskGammaJet::ProcessConvGamma( const TClonesArray * convGamma,
       delP = kTRUE;
     } 
     
-    if(photon->Pt() < fMinPt) {
+    Bool_t btp = BothTracksPresent(photon, tracks);
+    fhTracksMissingPt[btp]->Fill(photon->Pt(), tracks->GetEntriesFast());
+    if(!btp || photon->Pt() < fMinPt || TMath::Abs(photon->Eta()) > fEtaLimit) {
       if(delP) delete photon;
       continue;
     }
@@ -319,24 +480,24 @@ void AliAnalysisTaskGammaJet::ProcessConvGamma( const TClonesArray * convGamma,
 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++) {
     Bool_t delP = kFALSE;
     AliAODConversionParticle * pion = dynamic_cast<AliAODConversionParticle*>(pions->At(iPi));
     if(!pion) {
       AliGammaConversionAODObject * aodO = dynamic_cast<AliGammaConversionAODObject*>(pions->At(iPi));
       if (!aodO) {
-       AliError(Form("ERROR: Could not receive ga %d\n", iPi));
-       continue;
+       AliError(Form("ERROR: Could not receive ga %d\n", iPi));
+       continue;
       }
       
       pion = new AliAODConversionParticle(aodO);
       delP = kTRUE;
     } 
 
-
-    if(pion->Pt() < fMinPt) {
+    if (!BothGammaPresent(pion, photons, tracks) || pion->Pt() < fMinPt || TMath::Abs(pion->Eta()) > fEtaLimit ) {
       if(delP) delete pion;
-      continue;
+      return;
     }
 
     
@@ -352,14 +513,51 @@ void AliAnalysisTaskGammaJet::ProcessPions( const TClonesArray * const pions, co
     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 );
+       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;
       }
+      
+      
     } 
     if (delP) delete pion;
   } // 
 
-
+  
+  // for (Int_t iPhot = 0; iPhot < photons->GetEntriesFast(); iPhot++) {
+  //   AliAODConversionParticle * photon = dynamic_cast<AliAODConversionParticle*>(photons->At(iPhot));
+  //   if(photon) {
+  //     for (Int_t iPhot2 = iPhot+1; iPhot2 < photons->GetEntriesFast(); iPhot2++) {
+  //   AliAODConversionParticle * photon2 = dynamic_cast<AliAODConversionParticle*>(photons->At(iPhot2));
+  //   if(photon2) {
+  //     Int_t trackLabels[4] = {photon->GetTrackLabel(0), photon->GetTrackLabel(1), photon2->GetTrackLabel(0), photon2->GetTrackLabel(1)};
+  //     AliAODConversionParticle * pion = new AliAODConversionParticle(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;
+  //     }
+  //   }
+  //     }
+  //   }
+  // }
 }
 
 ///_______________________________________________________________________________________________
@@ -393,8 +591,8 @@ Bool_t AliAnalysisTaskGammaJet::UserNotify() {
 
     AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
 
-    AliAnaConvCorrPhoton * phJetAna = dynamic_cast<AliAnaConvCorrPhoton*>(fAnaPhotonArray->At(0));
-    phJetAna->PrintStatistics();
+    // AliAnaConvCorrPhoton * phJetAna = dynamic_cast<AliAnaConvCorrPhoton*>(fAnaPhotonArray->At(0));
+    // phJetAna->PrintStatistics();
 
     return kTRUE;
 
@@ -446,10 +644,14 @@ void AliAnalysisTaskGammaJet::Terminate(Option_t *) {
 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;
 
 }
@@ -458,11 +660,15 @@ AliAODEvent * AliAnalysisTaskGammaJet::GetAODEvent() {
 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", fConversionCutString.Data())));
+  TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(Form("%s_gamma", fGammaCutString.Data())));
   
   //If it's there, send it back
-  if(convGamma)  return convGamma;
-
+  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;
@@ -472,11 +678,11 @@ TClonesArray * AliAnalysisTaskGammaJet::GetConversionGammas(const AliAODEvent *
     AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
     if(gExt) {
       AliAODEvent * gcEvent = gExt->GetAOD();
-      return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_gamma", fConversionCutString.Data())));
+      return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_gamma", fGammaCutString.Data())));
     }
   }
 
-  cout << "could not find branch " << Form("%s_gamma", fConversionCutString.Data()) << endl; 
+  cout << "could not find branch " << Form("%s_gamma", fPionCutString.Data()) << endl; 
   return NULL;
 }
 
@@ -486,7 +692,7 @@ TClonesArray * AliAnalysisTaskGammaJet::GetConversionGammas(const AliAODEvent *
 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", fConversionCutString.Data()) ));
+  TClonesArray * convGamma = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(Form("%s_Pi0", fPionCutString.Data()) ));
   
   //If it's there, send it back
   if(convGamma)  return convGamma;
@@ -500,7 +706,7 @@ TClonesArray * AliAnalysisTaskGammaJet::GetConversionPions(const AliAODEvent * a
     AliAODExtension * gExt = dynamic_cast<AliAODExtension*>(aodHandler->GetExtensions()->FindObject(fDeltaAODFileName));
     if(gExt) {
       AliAODEvent * gcEvent = gExt->GetAOD();
-      return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_Pi0", fConversionCutString.Data())));
+      return dynamic_cast<TClonesArray*>(gcEvent->FindListObject(Form("%s_Pi0", fPionCutString.Data())));
     }
   }  
   return NULL;
index 9203e9c..5111737 100644 (file)
@@ -44,7 +44,8 @@ public:
   AliAnaConvIsolation * GetIsolation() const {return fAnaIsolation;}\r
   void SetIsolation( AliAnaConvIsolation * isolation) { fAnaIsolation = isolation; }\r
 \r
-  void SetConversionCutId(TString cut) { fConversionCutString = Form("GammaConv_%s", cut.Data());}\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
@@ -52,17 +53,20 @@ public:
   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 AliAODConversionParticle * 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
-\r
-\r
-  //Get the AOD event from whereever it might be accessible\r
+  Bool_t EventIsSynced(const TClonesArray * const tracks, const TClonesArray * const convGamma, const TClonesArray * const pions);\r
+  Bool_t BothTracksPresent(const AliAODConversionParticle * const photon, const TClonesArray * const tracks) const;\r
+  Bool_t BothGammaPresent(const AliAODConversionParticle * const pion, const TClonesArray * const photons, const TClonesArray * const tracks) const;\r
   AliAODEvent * GetAODEvent();\r
 \r
   //Get Conversion gammas branch\r
@@ -82,8 +86,10 @@ public:
 \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 fConversionCutString;   //! The cut string of the conversion analysis used to produce input 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
@@ -92,10 +98,16 @@ public:
   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
index deaec9f..137719a 100644 (file)
@@ -1,4 +1,5 @@
 
+
 void ConfigGammaJet (TString inputfile = "files.txt" ) {
 
   Int_t debugLevel = 0;
@@ -39,7 +40,10 @@ void ConfigGammaJet (TString inputfile = "files.txt" ) {
 
   AliAnalysisTaskGammaJet * gammaJetAna = new AliAnalysisTaskGammaJet("gamma jet analysis");
   gammaJetAna->SetDebugLevel(0);
-  gammaJetAna->SetConversionCutId("90022670901120321036000000090");
+  //gammaJetAna->SetConversionCutId("90022670901120321036000000090");
+  gammaJetAna->SetGammaCutId("90035620801003321136000000090"); 
+  gammaJetAna->SetPionCutId("90036620801003321136000000090"); 
+
   gammaJetAna->SetMinNTracks(0);
   mgr->AddTask(gammaJetAna);
 
@@ -57,29 +61,28 @@ void ConfigGammaJet (TString inputfile = "files.txt" ) {
   ghAna2->SkipDecayParticles();
   gammaJetAna->AddPhotonHadronAna(dynamic_cast<TObject*>(ghAna2));
 
+  AliAnaConvCorrPhoton * ghAna3 = new AliAnaConvCorrPhoton("photon_DecOnly");
+  ghAna3->DoDecayOnly();
+  gammaJetAna->AddPhotonHadronAna(dynamic_cast<TObject*>(ghAna3));
+
   AliAnaConvCorrPion * gPiAna = new AliAnaConvCorrPion("pionHadron");
   gammaJetAna->AddPionHadronAna(dynamic_cast<TObject*>(gPiAna));
 
   inpHandler->AddFriend("AliAODs.pwg4jets.root");
   AliAnaConvCorrPhotonJet* gJetAna = new AliAnaConvCorrPhotonJet("photonJet");
-  gJetAna->SetTriggerPt(0.0);
-  gJetAna->SetCorrelatedPt(0.0);
   gammaJetAna->AddPhotonJetAna(gJetAna);
-
-  // gROOT->LoadMacro("AddTaskGammaJet.C");
-  // AliAnalysisTaskGammaJet * gj2 =  AddTaskGammaJet("test", 3.0, 40, 0.4);
-  // isolation = gj2->GetIsolation();
-  // isolation->SetMinPt(0.3);
-
+  AliAnaConvCorrPionJet* pJetAna = new AliAnaConvCorrPionJet("pionJet");
+  gammaJetAna->AddPionJetAna(pJetAna);
 
   mgr->ConnectInput  (gammaJetAna,  0, cinput1  );
   mgr->ConnectOutput (gammaJetAna,  1, coutput2 );
   
   mgr->InitAnalysis();
   mgr->PrintStatus();
-  mgr->StartAnalysis("local",chain);
-  //mgr->StartAnalysis("local",chain, 10000);
-
+  //mgr->StartAnalysis("local",chain);
+  mgr->StartAnalysis("local",chain, 100000);
+  
 }