New analysis classes by Gustavo Conesa
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Aug 2007 12:40:04 +0000 (12:40 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Aug 2007 12:40:04 +0000 (12:40 +0000)
30 files changed:
PWG4/AliAnaGamma.cxx [new file with mode: 0644]
PWG4/AliAnaGamma.h [new file with mode: 0644]
PWG4/AliAnaGammaCorrelation.cxx [new file with mode: 0644]
PWG4/AliAnaGammaCorrelation.h [new file with mode: 0644]
PWG4/AliAnaGammaDirect.cxx
PWG4/AliAnaGammaDirect.h
PWG4/AliAnaGammaHadron.cxx
PWG4/AliAnaGammaHadron.h
PWG4/AliAnaGammaJetFinder.cxx [new file with mode: 0644]
PWG4/AliAnaGammaJetFinder.h [new file with mode: 0644]
PWG4/AliAnaGammaJetLeadCone.cxx [new file with mode: 0644]
PWG4/AliAnaGammaJetLeadCone.h [new file with mode: 0644]
PWG4/AliAnaGammaParton.cxx [new file with mode: 0644]
PWG4/AliAnaGammaParton.h [new file with mode: 0644]
PWG4/AliAnaGammaPhos.cxx
PWG4/AliAnalysisTaskGamma.cxx [new file with mode: 0644]
PWG4/AliAnalysisTaskGamma.h [new file with mode: 0644]
PWG4/AliGammaDataReader.cxx [new file with mode: 0644]
PWG4/AliGammaMCDataReader.cxx [new file with mode: 0644]
PWG4/AliGammaMCDataReader.h [new file with mode: 0644]
PWG4/AliGammaMCReader.cxx [new file with mode: 0644]
PWG4/AliGammaMCReader.h [new file with mode: 0644]
PWG4/AliGammaReader.cxx [new file with mode: 0644]
PWG4/AliGammaReader.h [new file with mode: 0644]
PWG4/AliNeutralMesonSelection.cxx [new file with mode: 0644]
PWG4/AliNeutralMesonSelection.h [new file with mode: 0644]
PWG4/ConfigGammaAnalysis.C [new file with mode: 0644]
PWG4/PWG4GammaLinkDef.h
PWG4/ana.C [new file with mode: 0644]
PWG4/libPWG4Gamma.pkg

diff --git a/PWG4/AliAnaGamma.cxx b/PWG4/AliAnaGamma.cxx
new file mode 100644 (file)
index 0000000..68d5179
--- /dev/null
@@ -0,0 +1,362 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for prompt gamma and correlation analysis
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+
+#include <TParticle.h>
+#include <TH2.h>
+
+//---- AliRoot system ---- 
+#include "AliAnaGamma.h" 
+#include "AliGammaReader.h" 
+#include "AliAnaGammaDirect.h" 
+#include "AliAnaGammaCorrelation.h" 
+#include "AliNeutralMesonSelection.h"
+#include "Riostream.h"
+#include "AliLog.h"
+
+ClassImp(AliAnaGamma)
+
+
+//____________________________________________________________________________
+  AliAnaGamma::AliAnaGamma() : 
+    TObject(),
+    fOutputContainer(0x0), 
+    fAnaType(0),  fCalorimeter(0), fData(0x0), fKine(0x0), 
+    fReader(0x0), fGammaDirect(0x0), fGammaCorrelation(0x0),
+    fNeutralMesonSelection(0x0)
+{
+  //Default Ctor
+
+  //Initialize parameters, pointers and histograms
+  if(!fReader)
+    fReader = new AliGammaReader();
+  if(!fGammaDirect)
+    fGammaDirect = new AliAnaGammaDirect();
+  if(!fGammaCorrelation)
+    fGammaCorrelation = new AliAnaGammaCorrelation();
+  if(!fNeutralMesonSelection)
+    fNeutralMesonSelection = new AliNeutralMesonSelection();
+
+  InitParameters();
+  
+}
+
+//____________________________________________________________________________
+AliAnaGamma::AliAnaGamma(const AliAnaGamma & g) :   
+  TObject(),
+  fOutputContainer(g. fOutputContainer), 
+  fAnaType(g.fAnaType),  fCalorimeter(g.fCalorimeter), 
+  fData(g.fData), fKine(g.fKine),fReader(g.fReader),
+  fGammaDirect(g.fGammaDirect), fGammaCorrelation(g.fGammaCorrelation),
+  fNeutralMesonSelection(g.fNeutralMesonSelection)
+{
+  // cpy ctor
+  
+}
+
+//_________________________________________________________________________
+AliAnaGamma & AliAnaGamma::operator = (const AliAnaGamma & source)
+{
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((TObject *)this)->operator=(source);
+
+  fOutputContainer = source.fOutputContainer ;
+  fAnaType = source.fAnaType;
+  fCalorimeter = source.fCalorimeter ;
+  fData = source.fData ; 
+  fKine = source.fKine ;
+  fReader = source.fReader ;
+  fGammaDirect = source.fGammaDirect ;
+  fGammaCorrelation = source.fGammaCorrelation ;
+  fNeutralMesonSelection = source.fNeutralMesonSelection ;
+
+  return *this;
+
+}
+
+//____________________________________________________________________________
+AliAnaGamma::~AliAnaGamma() 
+{
+  // Remove all pointers
+
+  fOutputContainer->Clear() ; 
+  delete fOutputContainer ;
+
+  delete fData ; 
+  delete fKine ;
+  delete fReader ;
+  delete fGammaDirect ;
+  delete fGammaCorrelation ;
+  delete fNeutralMesonSelection ;
+
+}
+
+//________________________________________________________________________
+void AliAnaGamma::Init()
+{  
+
+  //Init container histograms and other common variables
+
+  //Histograms container
+  fOutputContainer = new TList ;
+  
+  //Fill container with appropriate histograms
+  
+  //Set prompt photon analysis histograms
+  TList * promptcontainer =  fGammaDirect->GetCreateOutputObjects(); 
+  for(Int_t i = 0; i < promptcontainer->GetEntries(); i++)
+    fOutputContainer->Add(promptcontainer->At(i)) ;
+  
+  if(fAnaType == kCorrelation){
+    
+    //Check if selected options are correct
+    if (fGammaDirect->GetICMethod()==AliAnaGammaDirect::kSeveralIC)
+      AliFatal("Correlation not allowed with multiple isolation cuts, kCorrelation and kSeveralIC do not go together");
+    
+    if(fGammaCorrelation->GetCorrelationType() == AliAnaGammaCorrelation::kParton && 
+       fReader->GetDataType() != AliGammaReader::kMC)
+      AliFatal("kParton must be analyzed with data kMC");
+    
+    //Set the parameters for the neutral pair selection depending on the analysis, 
+    fNeutralMesonSelection->SetDeltaPhiCutRange(fGammaCorrelation->GetDeltaPhiMinCut(), 
+                                               fGammaCorrelation->GetDeltaPhiMaxCut());  
+    
+
+    if(fGammaCorrelation->GetCorrelationType() == AliAnaGammaCorrelation::kHadron){
+      fNeutralMesonSelection->SetPhiPtSelection(AliNeutralMesonSelection::kSelectPhiMinPt);
+      fNeutralMesonSelection->SetMinPt(fGammaCorrelation->GetMinPtHadron());
+      
+    }
+    
+    if(fGammaCorrelation->GetCorrelationType() == AliAnaGammaCorrelation::kJetLeadCone){
+      fNeutralMesonSelection->SetPhiPtSelection(AliNeutralMesonSelection::kSelectPhiPtRatio);
+      fNeutralMesonSelection->SetRatioCutRange(fGammaCorrelation->GetRatioMinCut(), 
+                                              fGammaCorrelation->GetRatioMaxCut());
+    }
+
+    //Set the neutral mesosn selection histograms
+    TList * neutralmesoncontainer =  fNeutralMesonSelection->GetCreateOutputObjects();
+    if(fNeutralMesonSelection->AreNeutralMesonSelectionHistosKept()){
+      for(Int_t i = 0; i < neutralmesoncontainer->GetEntries(); i++)
+       fOutputContainer->Add(neutralmesoncontainer->At(i)) ;
+    }
+    
+    //Set correlation histograms
+    TList * correlationcontainer =  fGammaCorrelation->GetCreateOutputObjects();
+    for(Int_t i = 0; i < correlationcontainer->GetEntries(); i++)
+      fOutputContainer->Add(correlationcontainer->At(i)) ;
+    fGammaCorrelation->SetOutputContainer(fOutputContainer);
+    fGammaCorrelation->SetNeutralMesonSelection(fNeutralMesonSelection);
+  }//kCorrelation  
+  
+}
+
+//____________________________________________________________________________
+void AliAnaGamma::InitParameters()
+{
+
+  //Init data members
+  fAnaType = kPrompt;
+  fCalorimeter = "EMCAL";
+
+}
+
+//__________________________________________________________________
+void AliAnaGamma::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("Analysis type           =     %d\n", fAnaType) ;
+  printf("Calorimeter           =     %s\n", fCalorimeter.Data()) ;
+
+  switch(fAnaType)
+    {
+    case kPrompt:
+      {
+       fGammaDirect->Print("");
+      }// case kIsolationCut
+      break;
+   
+    case kCorrelation:
+      {
+       fGammaCorrelation->Print("");
+      }//  case kCorrelation
+      break;
+      
+    }//switch
+} 
+
+
+//____________________________________________________________________________
+Bool_t AliAnaGamma::ProcessEvent(Long64_t entry){
+
+  AliDebug(1,Form("Entry %d",entry));
+
+  if(!fOutputContainer)
+    AliFatal("Histograms not initialized");
+
+  //CreateTLists with arrays of TParticles. Filled with particles only relevant for the analysis.
+
+  TClonesArray * plCTS      = new TClonesArray("TParticle",1000); // All particles refitted in Central Tracking System (ITS+TPC)
+  TClonesArray * plEMCAL    = new TClonesArray("TParticle",1000);   // All particles measured in Jet Calorimeter (EMCAL)
+  TClonesArray * plPHOS     = new TClonesArray("TParticle",1000);  // All particles measured  Gamma calorimeter
+  TClonesArray * plParton   = new TClonesArray("TParticle",1000);  // All partons
+  //Fill lists with photons, neutral particles and charged particles
+  //look for the highest energy photon in the event inside fCalorimeter
+    
+  //Fill particle lists 
+  if(fReader->GetDataType() == AliGammaReader::kData){
+    AliDebug(1,"Data analysis");
+    fReader->CreateParticleList(fData, NULL,plCTS,plEMCAL,plPHOS,NULL); 
+  }
+  else if( fReader->GetDataType()== AliGammaReader::kMC){
+    AliDebug(1,"Kinematics analysis");
+    fReader->CreateParticleList(fKine, NULL,plCTS,plEMCAL,plPHOS,plParton); 
+  }
+  else if(fReader->GetDataType() == AliGammaReader::kMCData) {
+   AliDebug(1,"Data + Kinematics analysis");
+   fReader->CreateParticleList(fData, fKine,plCTS,plEMCAL,plPHOS,NULL); 
+  }
+  else
+    AliError("Option not implemented");
+  
+  //Search highest energy prompt gamma in calorimeter
+  if(fCalorimeter == "PHOS")
+    MakeAnalysis(plPHOS, plEMCAL, plCTS, plParton) ; 
+  else if (fCalorimeter == "EMCAL")
+    MakeAnalysis(plEMCAL, plPHOS, plCTS,plParton) ; 
+  else
+    AliFatal("Wrong calorimeter name");
+
+  plCTS->Clear() ;
+  plEMCAL->Clear() ;
+  plPHOS->Clear() ;
+  plParton->Clear() ;
+
+  delete plCTS ;
+  delete plPHOS ;
+  delete plEMCAL ;
+  delete plParton ;
+
+  return kTRUE;
+
+}
+
+//____________________________________________________________________________
+void AliAnaGamma::MakeAnalysis(TClonesArray * plCalo, TClonesArray * plNe, TClonesArray * plCTS, TClonesArray * plParton)  {
+  
+  TParticle * pGamma = new TParticle ;
+  Bool_t isInCalo = kFALSE ;
+  
+  switch(fAnaType)
+    {
+      
+      //Only Prompt photon analysis
+    case kPrompt:
+      {          
+       AliDebug(1,"kPrompt analysis");
+       switch(fGammaDirect->GetICMethod())
+         {
+           
+         case AliAnaGammaDirect::kSeveralIC:
+           {
+             fGammaDirect->MakeSeveralICAnalysis(plCalo, plCTS);
+             AliDebug(1,"kSeveralIC analysis");
+           }
+           break;
+           
+         default :
+           {
+             fGammaDirect->GetPromptGamma(plCalo, plCTS,pGamma,isInCalo);
+             if(!isInCalo)
+               AliDebug(1,"Prompt gamma not found");
+           }
+           break;
+         }//IC method
+      }// case kPrompt:
+      break;
+      
+      //Correlate prompt photon with something: parton, hadron, jet.
+    case kCorrelation:
+      {
+       AliDebug(1,"kCorrelation analysis");
+       //Find prompt photon    
+       fGammaDirect->GetPromptGamma(plCalo, plCTS,pGamma,isInCalo);
+
+       if(isInCalo){//If prompt photon found, do correlation
+         
+         switch(fGammaCorrelation->GetCorrelationType())
+           {
+           case AliAnaGammaCorrelation::kParton:
+             {
+               AliDebug(1,"kParton correlation");
+               fGammaCorrelation->MakeGammaCorrelation(pGamma, plParton, NULL);
+             }//  case kParton
+             break;
+      
+           case AliAnaGammaCorrelation::kHadron:
+             {
+               AliDebug(1,"kHadron correlation");
+               fGammaCorrelation->MakeGammaCorrelation(pGamma, plCTS, plNe);
+             }//  case kHadron
+             break;
+
+           case AliAnaGammaCorrelation::kJetLeadCone:
+             {         
+               AliDebug(1,"kJetLeadCone correlation");
+               fGammaCorrelation->MakeGammaCorrelation(pGamma, plCTS, plNe);
+             }//  case kJetLeadCone
+             break;
+             
+           case AliAnaGammaCorrelation::kJetFinder:
+             { 
+               AliDebug(1,"kJetFinder correlation");
+               printf("Analysis not implemented \n");
+             }//  case kJetFinder
+             break;
+           }// switch correlation
+       }// is in calo
+       else  AliDebug(2,"Prompt gamma not found");
+      }// case kCorrelation
+      break;
+
+    } //switch(fAnaType)
+
+  delete pGamma ; 
+  
+}
diff --git a/PWG4/AliAnaGamma.h b/PWG4/AliAnaGamma.h
new file mode 100644 (file)
index 0000000..db34234
--- /dev/null
@@ -0,0 +1,98 @@
+#ifndef ALIANAGAMMA_H
+#define ALIANAGAMMA_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for prompt gamma and correlation analysis
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h> 
+#include <TList.h> 
+#include <TClonesArray.h> 
+#include <TH2F.h>
+#include<TObject.h>
+#include <TTree.h>
+#include <AliLog.h>
+
+class AliGammaReader ;
+class AliAnaGammaDirect ;
+class AliAnaGammaCorrelation ;
+class AliAnaGammaJetLeadCone ;
+class AliNeutralMesonSelection ;
+
+// --- AliRoot
+class AliAnaGamma : public TObject {
+
+public: 
+  
+  AliAnaGamma() ; // default ctor
+  AliAnaGamma(const AliAnaGamma & g) ; // cpy ctor
+  AliAnaGamma & operator = (const AliAnaGamma & g) ;//cpy assignment
+  virtual ~AliAnaGamma() ; //virtual dtor
+
+  enum anatype_t {kPrompt, kCorrelation};
+
+  //General methods
+  TList * GetOutputContainer()      const {return fOutputContainer ; }
+  
+  void Init();
+  void InitParameters();
+
+  Int_t GetAnalysisType(){  return fAnaType ; }
+  void SetAnalysisType(Int_t ana ){  fAnaType = ana ; }
+
+  void Print(const Option_t * opt) const;
+
+  void MakeAnalysis(TClonesArray * plCalo, TClonesArray * plNe, TClonesArray * plCTS, TClonesArray *plParton)  ;  
+  Bool_t ProcessEvent(Long64_t entry) ;
+  //TTree * MakeTreeG(TString name) ;
+
+  TString GetCalorimeter() {return fCalorimeter ; }
+  void SetCalorimeter(TString calo) {if (calo == "PHOS" || calo == "EMCAL") fCalorimeter = calo ;
+    else AliFatal("Wrong calorimeter name") ; }
+
+  TObject * GetData() {return fData ; }
+  TObject * GetKine() {return fKine ;}
+  void SetData(TObject * data) {fData = data ; }
+  void SetKine(TObject * kine) {fKine = kine ; }
+
+  AliGammaReader * GetReader() {return fReader ; }
+  void SetReader(AliGammaReader * reader) { fReader = reader ; }
+
+  void SetGammaDirect(AliAnaGammaDirect * dg) { fGammaDirect = dg ; }
+  void SetGammaCorrelation(AliAnaGammaCorrelation * gc) { fGammaCorrelation = gc ;}
+  void SetNeutralMesonSelection(AliNeutralMesonSelection * nms) { fNeutralMesonSelection = nms ; }
+  
+ private:
+  
+  //General Data members
+  TList  *fOutputContainer ; //! output data container
+  Int_t      fAnaType; //Analysis type to be done
+  TString fCalorimeter; //Prompt photon detector
+  TObject * fData ; //! ESD
+  TObject * fKine ; //! Stack
+  AliGammaReader *      fReader ; //! Pointer to reader 
+  AliAnaGammaDirect *   fGammaDirect ; //! Pointer to prompt gamma algorithm 
+  AliAnaGammaCorrelation *   fGammaCorrelation ; //! Pointer to gamma correlation algorithm
+  AliNeutralMesonSelection *  fNeutralMesonSelection ; //! Pointer to pair selection for pi0 identification.
+  
+  ClassDef(AliAnaGamma,0)
+} ;
+
+#endif //ALIANAGAMMA_H
+
+
+
diff --git a/PWG4/AliAnaGammaCorrelation.cxx b/PWG4/AliAnaGammaCorrelation.cxx
new file mode 100644 (file)
index 0000000..1918dc4
--- /dev/null
@@ -0,0 +1,149 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for the analysis of gamma correlations  
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+
+#include <TParticle.h>
+#include <TH2.h>
+
+//---- AliRoot system ----
+#include "AliAnaGammaCorrelation.h" 
+#include "AliNeutralMesonSelection.h" 
+#include "Riostream.h"
+#include "AliLog.h"
+
+ClassImp(AliAnaGammaCorrelation)
+
+
+//____________________________________________________________________________
+  AliAnaGammaCorrelation::AliAnaGammaCorrelation() : 
+    TObject(), fOutputContainer(0x0),   
+    fNeutralMesonSelection(0x0), fCorrelationType(0),
+    fJetsOnlyInCTS(0),
+    fMinPtHadron(0),
+    fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.), 
+    fRatioMaxCut(0.), fRatioMinCut(0.)
+{
+  //Default Ctor
+
+  //Initialize parameters
+
+  if(!fNeutralMesonSelection)
+    fNeutralMesonSelection = new AliNeutralMesonSelection();
+  
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliAnaGammaCorrelation::AliAnaGammaCorrelation(const AliAnaGammaCorrelation & g) :   
+  TObject(), fOutputContainer(g.fOutputContainer),  
+  fNeutralMesonSelection(g.fNeutralMesonSelection),
+  fCorrelationType(g.fCorrelationType),
+  fJetsOnlyInCTS(g.fJetsOnlyInCTS), 
+  fMinPtHadron(g.fMinPtHadron),
+  fDeltaPhiMaxCut(g.fDeltaPhiMaxCut), fDeltaPhiMinCut(g.fDeltaPhiMinCut), 
+  fRatioMaxCut(g.fRatioMaxCut), fRatioMinCut(g.fRatioMinCut) 
+{
+  // cpy ctor
+
+}
+
+//_________________________________________________________________________
+AliAnaGammaCorrelation & AliAnaGammaCorrelation::operator = (const AliAnaGammaCorrelation & source)
+{
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((TObject *)this)->operator=(source);
+
+  fOutputContainer = source.fOutputContainer;  
+  fNeutralMesonSelection = source.fNeutralMesonSelection ;
+  fCorrelationType = source.fCorrelationType;
+  fJetsOnlyInCTS = source.fJetsOnlyInCTS ;
+
+  fMinPtHadron = source.fMinPtHadron ;
+  fDeltaPhiMaxCut = source.fDeltaPhiMaxCut ; fDeltaPhiMinCut = source.fDeltaPhiMinCut ; 
+  fRatioMaxCut = source.fRatioMaxCut ; fRatioMinCut = source.fRatioMinCut ; 
+
+
+
+  return *this;
+
+}
+
+//____________________________________________________________________________
+AliAnaGammaCorrelation::~AliAnaGammaCorrelation() 
+{
+  // Remove all pointers
+  fOutputContainer->Clear();
+  delete fOutputContainer;
+
+  delete fNeutralMesonSelection ;
+}
+
+ //____________________________________________________________________________
+void AliAnaGammaCorrelation::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+  fCorrelationType = kHadron ;
+  //-----------kHadron----------------
+  fMinPtHadron = 0.   ;
+  //-----------kHadron & kJetLeadCone----------------
+  fJetsOnlyInCTS = kFALSE ;
+  fDeltaPhiMaxCut      = 4.5;
+  fDeltaPhiMinCut      = 1.5 ;
+  //-----------kJetLeadCone----------------
+  fRatioMaxCut = 1.0 ; 
+  fRatioMinCut = 0.1 ; 
+
+}
+
+//__________________________________________________________________
+void AliAnaGammaCorrelation::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("Correlation           =     %d\n", fCorrelationType) ;  
+  
+  printf("pT Hadron       >    %f\n", fMinPtHadron) ; 
+  printf("Phi gamma-Hadron      <     %f\n", fDeltaPhiMaxCut) ; 
+  printf("Phi gamma-Hadron      >     %f\n", fDeltaPhiMinCut) ;
+  printf("Ratio pt hadron/gamma      <     %f\n", fRatioMaxCut) ; 
+  printf("Ratio pt hadron/gamma      >     %f\n", fRatioMinCut) ;
+
+} 
diff --git a/PWG4/AliAnaGammaCorrelation.h b/PWG4/AliAnaGammaCorrelation.h
new file mode 100644 (file)
index 0000000..baf83e1
--- /dev/null
@@ -0,0 +1,100 @@
+#ifndef ALIANAGAMMACORRELATION_H
+#define ALIANAGAMMACORRELATION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for  gamma correlations 
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h> 
+#include <TClonesArray.h> 
+#include <TH2F.h>
+#include<TObject.h>
+#include<TList.h>
+
+class AliNeutralMesonSelection ;
+
+class AliAnaGammaCorrelation : public TObject {
+
+public: 
+  
+  AliAnaGammaCorrelation() ; // default ctor
+  AliAnaGammaCorrelation(const AliAnaGammaCorrelation & g) ; // cpy ctor
+  AliAnaGammaCorrelation & operator = (const AliAnaGammaCorrelation & g) ;//cpy assignment
+  virtual ~AliAnaGammaCorrelation() ; //virtual dtor
+
+  enum corrtype_t {kParton, kHadron, kJetLeadCone, kJetFinder};
+
+  //General methods
+
+  AliNeutralMesonSelection * GetNeutralMesonSelection() 
+  { return fNeutralMesonSelection ; }
+  void SetNeutralMesonSelection(AliNeutralMesonSelection * nms) 
+  { fNeutralMesonSelection = nms ; } 
+
+  TList * GetOutputContainer() {return fOutputContainer ;} 
+  void SetOutputContainer(TList * oc) {fOutputContainer = oc ;}  
+
+  void InitParameters();
+
+  Int_t GetCorrelationType(){  return fCorrelationType ; }
+  void SetCorrelationType(Int_t ana ){  fCorrelationType = ana ; }
+
+  void Print(const Option_t * opt) const;
+  Bool_t     AreJetsOnlyInCTS() const {return fJetsOnlyInCTS ; } 
+  void SetJetsOnlyInCTS(Bool_t opt){fJetsOnlyInCTS = opt; }
+
+  virtual TList * GetCreateOutputObjects() {return fOutputContainer ;}
+  virtual void MakeGammaCorrelation(TParticle * p,  TClonesArray * ob1, TClonesArray * ob2)  {;}
+
+  //Gamma hadron correlations methods: kHadron
+  Float_t    GetMinPtHadron() const {return fMinPtHadron ; }
+  void SetMinPtHadron(Float_t pt){fMinPtHadron = pt; };
+  
+  Double_t GetDeltaPhiMaxCut() const {return fDeltaPhiMaxCut ; }
+  Double_t GetDeltaPhiMinCut() const {return fDeltaPhiMinCut ; }
+  void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
+  {fDeltaPhiMaxCut =phimax;  fDeltaPhiMinCut =phimin;}
+
+  Double_t GetRatioMaxCut() const {return fRatioMaxCut ; }
+  Double_t GetRatioMinCut() const {return fRatioMinCut ; }
+  void SetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
+  {fRatioMaxCut = ratiomax;  fRatioMinCut = ratiomin;}
+  
+  private:
+  
+  TList * fOutputContainer; //Histograms container
+  AliNeutralMesonSelection *  fNeutralMesonSelection ; //! Pointer to pair selection for pi0 identification.
+
+  Int_t  fCorrelationType; //Type of correlation analysis
+  Bool_t   fJetsOnlyInCTS ;    // Jets measured only in TPC+ITS.
+  
+  private:
+  //Gamma hadron correlations data members kGammaHadron
+  Double_t   fMinPtHadron;       // Minimum pt of hadron (kHadron)
+  Double_t   fDeltaPhiMaxCut ;      // Minimum Delta Phi Gamma-Hadron/jet in leading cone
+  Double_t   fDeltaPhiMinCut ;      //  Maximum Delta Phi Gamma-Hadron/ jet in leading cone
+  Double_t   fRatioMaxCut ;    // Leading particle/gamma Ratio cut maximum (kLeadJetCone)
+  Double_t   fRatioMinCut ;    // Leading particle/gamma Ratio cut minimum (kLeadJetCone)
+  
+  ClassDef(AliAnaGammaCorrelation,0)
+} ;
+
+#endif //ALIANAGAMMACORRELATION_H
+
+
+
index 4c353612028b0cc11af1636b599bdb21ffa83ea6..6611cff720e5d5e16f931a4fafa81c281537ca72 100644 (file)
 /* History of cvs commits:
  *
  * $Log$
- * Revision 1.4  2007/03/15 11:47:39  schutz
- * Methods added
- *
- * Revision 1.3  2007/03/08 10:24:32  schutz
- * Coding convention
- *
- * Revision 1.2  2007/02/09 18:40:40  schutz
- * B\bNew version from Gustavo
- *
- * Revision 1.1  2007/01/23 17:17:29  schutz
- * New Gamma package
+ * Revision 1.4.4.4  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
  *
  *
  */
 
 //_________________________________________________________________________
-// Class for the analysis of gamma correlations (gamma-jet, 
-// gamma-hadron and isolation cut.
-// This class contains 3 main methods: one to fill lists of particles (ESDs) comming 
-//  from the CTS (ITS+TPC) and the calorimeters;  the other one tags a candidate 
-//  cluster as isolated;  the last one search in the 
-//  corresponing calorimeter for the highest energy cluster, identified it as 
-//  prompt photon;
+// Class for the prompt gamma analysis, isolation cut
 //
 //  Class created from old AliPHOSGammaJet 
 //  (see AliRoot versions previous Release 4-09)
 //
 //*-- Author: Gustavo Conesa (LNF-INFN) 
 //////////////////////////////////////////////////////////////////////////////
-
-
-// --- ROOT system ---
-
-#include <TFile.h>
+  
+  
+// --- ROOT system --- 
 #include <TParticle.h>
 #include <TH2.h>
-#include <TChain.h>
+#include <TList.h>
 #include "AliAnaGammaDirect.h" 
-#include "AliESD.h"
-#include "AliESDtrack.h"
-#include "AliESDCaloCluster.h"
 #include "Riostream.h"
 #include "AliLog.h"
-
+  
 ClassImp(AliAnaGammaDirect)
-
+  
 //____________________________________________________________________________
-  AliAnaGammaDirect::AliAnaGammaDirect(const char *name) : 
-    AliAnalysisTask(name,""), fChain(0), fESD(0),
-    fOutputContainer(new TObjArray(100)), 
-    fPrintInfo(0), fMinGammaPt(0.),
-    fCalorimeter(""), fEMCALPID(0),fPHOSPID(0),
-    fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.), fPHOSPhotonWeight(0.),
+  AliAnaGammaDirect::AliAnaGammaDirect() : 
+    TObject(),
+    fMinGammaPt(0.),
     fConeSize(0.),fPtThreshold(0.),fPtSumThreshold(0), 
-    fMakeICMethod(0),fhNGamma(0),fhPhiGamma(0),fhEtaGamma(0)
+    fICMethod(0),fhNGamma(0),fhPhiGamma(0),fhEtaGamma(0),  
+    //kSeveralIC
+    fNCones(0),fNPtThres(0), fConeSizes(),  fPtThresholds(), 
+    fhPtThresIsolated(), fhPtSumIsolated()
 {
-  //Ctor
-        
+  //default ctor
+  
   //Initialize parameters
   InitParameters();
 
-  // Input slot #0 works with an Ntuple
-  DefineInput(0, TChain::Class());
-  // Output slot #0 writes into a TH1 container
-  DefineOutput(0,  TObjArray::Class()) ; 
-  
 }
 
-
 //____________________________________________________________________________
 AliAnaGammaDirect::AliAnaGammaDirect(const AliAnaGammaDirect & g) : 
-  AliAnalysisTask(g), fChain(g.fChain), fESD(g.fESD),
-  fOutputContainer(g. fOutputContainer),  fPrintInfo(g.fPrintInfo),
-  fMinGammaPt(g.fMinGammaPt), fCalorimeter(g.fCalorimeter),
-  fEMCALPID(g.fEMCALPID),fPHOSPID(g.fPHOSPID),
-  fEMCALPhotonWeight(g.fEMCALPhotonWeight), 
-  fEMCALPi0Weight(g.fEMCALPi0Weight), 
-  fPHOSPhotonWeight(g.fPHOSPhotonWeight),
+  TObject(g),
+  fMinGammaPt(g.fMinGammaPt), 
   fConeSize(g.fConeSize),
   fPtThreshold(g.fPtThreshold),
   fPtSumThreshold(g.fPtSumThreshold), 
-  fMakeICMethod(g.fMakeICMethod),
-  fhNGamma(g.fhNGamma),fhPhiGamma(g.fhPhiGamma),fhEtaGamma(g.fhEtaGamma)
+  fICMethod(g.fICMethod),
+  fhNGamma(g.fhNGamma),fhPhiGamma(g.fhPhiGamma),fhEtaGamma(g.fhEtaGamma),  
+  //kSeveralIC
+  fNCones(g.fNCones),fNPtThres(g.fNPtThres), fConeSizes(),fPtThresholds(), 
+  fhPtThresIsolated(), fhPtSumIsolated()
 {
   // cpy ctor
-  SetName (g.GetName()) ; 
-  SetTitle(g.GetTitle()) ; 
+  
+  //kSeveralIC
+  for(Int_t i = 0; i < fNCones ; i++){
+    fConeSizes[i] =  g.fConeSizes[i];
+    fhPtSumIsolated[i] = g.fhPtSumIsolated[i]; 
+    for(Int_t j = 0; j < fNPtThres ; j++)
+      fhPtThresIsolated[i][j] = g.fhPtThresIsolated[i][j]; 
+  }
+  
+  for(Int_t i = 0; i < fNPtThres ; i++)
+    fPtThresholds[i]=   g.fPtThresholds[i];
 }
 
 //_________________________________________________________________________
 AliAnaGammaDirect & AliAnaGammaDirect::operator = (const AliAnaGammaDirect & source)
 {
   // assignment operator
-
+  
   if(&source == this) return *this;
 
-  fChain = source.fChain ; 
-  fESD = source.fESD ;
-  fOutputContainer = source.fOutputContainer ;
-  fPrintInfo = source.fPrintInfo ;
   fMinGammaPt = source.fMinGammaPt ;   
-  fCalorimeter = source. fCalorimeter ;  
-  fEMCALPID = source.fEMCALPID ;
-  fPHOSPID = source.fPHOSPID ;
-  fEMCALPhotonWeight = source. fEMCALPhotonWeight ;
-  fEMCALPi0Weight = source.fEMCALPi0Weight ;
-  fPHOSPhotonWeight = source.fPHOSPhotonWeight ;
   fConeSize = source.fConeSize ;
   fPtThreshold = source.fPtThreshold ;
   fPtSumThreshold = source.fPtSumThreshold ; 
-  fMakeICMethod = source.fMakeICMethod ;
+  fICMethod = source.fICMethod ;
   fhNGamma = source.fhNGamma ; 
   fhPhiGamma = source.fhPhiGamma ;
   fhEtaGamma = source.fhEtaGamma ;
-
-
+  
+  //kSeveralIC
+  fNCones = source.fNCones ;
+  fNPtThres = source.fNPtThres ; 
+   
+  for(Int_t i = 0; i < fNCones ; i++){
+    fConeSizes[i] =  source.fConeSizes[i];
+    fhPtSumIsolated[i] = source.fhPtSumIsolated[i] ;
+    for(Int_t j = 0; j < fNPtThres ; j++)
+      fhPtThresIsolated[i][j] = source.fhPtThresIsolated[i][j] ;
+  }
+  
+  for(Int_t i = 0; i < fNPtThres ; i++)
+    fPtThresholds[i]=   source.fPtThresholds[i];
+  
   return *this;
-
+  
 }
 
 //____________________________________________________________________________
 AliAnaGammaDirect::~AliAnaGammaDirect() 
 {
   // Remove all pointers
-  fOutputContainer->Clear() ; 
-  delete fOutputContainer ;
+  
   delete fhNGamma    ;  
   delete fhPhiGamma  ; 
   delete fhEtaGamma   ;  
-
-}
-
-//______________________________________________________________________________
-void AliAnaGammaDirect::ConnectInputData(const Option_t*)
-{
-  // Initialisation of branch container and histograms 
-    
-  AliInfo(Form("*** Initialization of %s", GetName())) ; 
   
-  // Get input data
-  fChain = dynamic_cast<TChain *>(GetInputData(0)) ;
-  if (!fChain) {
-    AliError(Form("Input 0 for %s not found\n", GetName()));
-    return ;
-  }
+  //kSeveralIC
+  delete [] fhPtThresIsolated ;
+  delete [] fhPtSumIsolated ;
   
-  // One should first check if the branch address was taken by some other task
-  char ** address = (char **)GetBranchAddress(0, "ESD");
-  if (address) {
-    fESD = (AliESD*)(*address);
-  } else {
-    fESD = new AliESD();
-    SetBranchAddress(0, "ESD", &fESD);
-  }
-
 }
 
 //________________________________________________________________________
-void AliAnaGammaDirect::CreateOutputObjects()
+TList *  AliAnaGammaDirect::GetCreateOutputObjects()
 {  
 
   // Create histograms to be saved in output file and 
-  // store them in fOutputContainer
-
-  fOutputContainer = new TObjArray(3) ;
-
+  // store them in outputContainer
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("DirectGammaHistos") ; 
+  
   //Histograms of highest gamma identified in Event
-  fhNGamma  = new TH1F("NGamma","Number of #gamma over PHOS",240,0,120); 
+  fhNGamma  = new TH1F("NGamma","Number of #gamma over calorimeter",240,0,120); 
   fhNGamma->SetYTitle("N");
   fhNGamma->SetXTitle("p_{T #gamma}(GeV/c)");
-  fOutputContainer->Add(fhNGamma) ; 
+  outputContainer->Add(fhNGamma) ; 
   
   fhPhiGamma  = new TH2F
     ("PhiGamma","#phi_{#gamma}",200,0,120,200,0,7); 
   fhPhiGamma->SetYTitle("#phi");
   fhPhiGamma->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhPhiGamma) ; 
+  outputContainer->Add(fhPhiGamma) ; 
   
   fhEtaGamma  = new TH2F
     ("EtaGamma","#phi_{#gamma}",200,0,120,200,-0.8,0.8); 
   fhEtaGamma->SetYTitle("#eta");
   fhEtaGamma->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhEtaGamma) ;
-
-}
-
-//____________________________________________________________________________
-void AliAnaGammaDirect::CreateParticleList(TClonesArray * pl, 
-                                       TClonesArray * plCTS, 
-                                       TClonesArray * plEMCAL,  
-                                       TClonesArray * plPHOS){
-  
-  //Create a list of particles from the ESD. These particles have been measured 
-  //by the Central Tracking system (TPC+ITS), PHOS and EMCAL 
-  
-  Int_t index = pl->GetEntries() ; 
-  Int_t npar  = 0 ;
-  Float_t *pid = new Float_t[AliPID::kSPECIESN];  
-  AliDebug(3,"Fill particle lists");
-  if(fPrintInfo)
-    AliInfo(Form("fCalorimeter %s",fCalorimeter.Data()));
-
-  Double_t v[3] ; //vertex ;
-  fESD->GetVertex()->GetXYZ(v) ; 
-
-  //########### PHOS ##############
-  if(fCalorimeter == "PHOS"){
-
-    Int_t begphos = fESD->GetFirstPHOSCluster();  
-    Int_t endphos = fESD->GetFirstPHOSCluster() + 
-      fESD->GetNumberOfPHOSClusters() ;  
-    Int_t indexNePHOS = plPHOS->GetEntries() ;
-    AliDebug(3,Form("First PHOS particle %d, last particle %d", begphos,endphos));
-
-    if(fCalorimeter == "PHOS"){
-      for (npar =  begphos; npar <  endphos; npar++) {//////////////PHOS track loop
-       AliESDCaloCluster * clus = fESD->GetCaloCluster(npar) ; // retrieve track from esd
-
-       //Create a TParticle to fill the particle list
-       TLorentzVector momentum ;
-       clus->GetMomentum(momentum, 0);
-       TParticle * particle = new TParticle() ;
-       //particle->SetMomentum(px,py,pz,en) ;
-       particle->SetMomentum(momentum) ;
-
-       AliDebug(4,Form("PHOS clusters: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
-       
-       //Select only photons
-       
-       pid=clus->GetPid();
-       //cout<<"pid "<<pid[AliPID::kPhoton]<<endl ;
-       if( !fPHOSPID)
-         new((*plPHOS)[indexNePHOS++])   TParticle(*particle) ;
-       else if( pid[AliPID::kPhoton] > fPHOSPhotonWeight)
-         new((*plPHOS)[indexNePHOS++])   TParticle(*particle) ;
-      }
-    }
+  outputContainer->Add(fhEtaGamma) ;
+
+  if(fICMethod == kSeveralIC){
+    char name[128];
+    char title[128];
+    for(Int_t icone = 0; icone<fNCones; icone++){
+      sprintf(name,"PtSumIsolated_Cone_%d",icone);
+      sprintf(title,"Candidate cone sum p_{T} for cone size %d vs candidate p_{T}",icone);
+      fhPtSumIsolated[icone]  = new TH2F(name, title,240,0,120,120,0,10);
+      fhPtSumIsolated[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
+      fhPtSumIsolated[icone]->SetXTitle("p_{T} (GeV/c)");
+      outputContainer->Add(fhPtSumIsolated[icone]) ; 
+      
+      for(Int_t ipt = 0; ipt<fNPtThres;ipt++){ 
+       sprintf(name,"PtThresIsol_Cone_%d_Pt%d",icone,ipt);
+       sprintf(title,"Isolated candidate p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
+       fhPtThresIsolated[icone][ipt]  = new TH1F(name, title,240,0,120);
+       fhPtThresIsolated[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtThresIsolated[icone][ipt]) ; 
+      }//icone loop
+    }//ipt loop
   }
 
-  //########## #####################
-  //Prepare bool array for EMCAL track matching
+  return outputContainer ;
 
-  // step 1, set the flag in a way that it rejects all not-V1 clusters
-  // but at this point all V1 clusters are accepted
-  
-  Int_t begem = fESD->GetFirstEMCALCluster();  
-  Int_t endem = fESD->GetFirstEMCALCluster() + 
-    fESD->GetNumberOfEMCALClusters() ;  
-//   if(endem < begem+12)
-//     AliError("Number of pseudoclusters smaller than 12");
-  Bool_t *useCluster = new Bool_t[endem+1];
-  
-//   for (npar =  0; npar <  endem; npar++){
-//     if(npar < begem+12)
-//       useCluster[npar] =kFALSE; //EMCAL Pseudoclusters and PHOS clusters
-//     else
-//       useCluster[npar] =kTRUE;   //EMCAL clusters 
-//   }
-  for (npar =  0; npar <  endem; npar++)
-    useCluster[npar] =kFALSE; //EMCAL Pseudoclusters and clusters
-  
-  //########### CTS (TPC+ITS) #####################
-  Int_t begtpc   = 0 ;  
-  Int_t endtpc   = fESD->GetNumberOfTracks() ;
-  Int_t indexCh  = plCTS->GetEntries() ;
-  AliDebug(3,Form("First CTS particle %d, last particle %d", begtpc,endtpc));
-
-  Int_t iemcalMatch  = -1 ;
-  for (npar =  begtpc; npar <  endtpc; npar++) {////////////// track loop
-    AliESDtrack * track = fESD->GetTrack(npar) ; // retrieve track from esd
-
-    // step 2 for EMCAL matching, change the flag for all matched clusters found in tracks
-    iemcalMatch = track->GetEMCALcluster(); 
-    if(iemcalMatch > 0) useCluster[iemcalMatch] = kTRUE; // reject matched cluster
-    
-    //We want tracks fitted in the detectors:
-    ULong_t status=AliESDtrack::kTPCrefit;
-    status|=AliESDtrack::kITSrefit;
-   
-    //We want tracks whose PID bit is set:
-    //     ULong_t status =AliESDtrack::kITSpid;
-    //     status|=AliESDtrack::kTPCpid;
-  
-    if ( (track->GetStatus() & status) == status) {//Check if the bits we want are set
-      // Do something with the tracks which were successfully
-      // re-fitted 
-      Double_t en = 0; //track ->GetTPCsignal() ;
-      Double_t mom[3];
-      track->GetPxPyPz(mom) ;
-      Double_t px = mom[0];
-      Double_t py = mom[1];
-      Double_t pz = mom[2]; //Check with TPC people if this is correct.
-      Int_t pdg = 11; //Give any charged PDG code, in this case electron.
-      //I just want to tag the particle as charged
-       TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
-                                           px, py, pz, en, v[0], v[1], v[2], 0);
-  
-      //TParticle * particle = new TParticle() ;
-      //particle->SetMomentum(px,py,pz,en) ;
-      new((*plCTS)[indexCh++])       TParticle(*particle) ;    
-      new((*pl)[index++])           TParticle(*particle) ;
-    }
-  }
-  
-  //################ EMCAL ##############
-  
-  Int_t indexNe  = plEMCAL->GetEntries() ; 
-  
-  AliDebug(3,Form("First EMCAL particle %d, last particle %d",begem,endem));
-    
-    for (npar =  begem; npar <  endem; npar++) {//////////////EMCAL track loop
-      AliESDCaloCluster * clus = fESD->GetCaloCluster(npar) ; // retrieve track from esd
-      Int_t clustertype= clus->GetClusterType();
-      if(clustertype == AliESDCaloCluster::kClusterv1 && !useCluster[npar] ){
-       TLorentzVector momentum ;
-       clus->GetMomentum(momentum, 0);
-       TParticle * particle = new TParticle() ;
-       //particle->SetMomentum(px,py,pz,en) ;
-       particle->SetMomentum(momentum) ;
-       cout<<"GOOD EMCAL "<<particle->Pt()<<endl;
-       pid=clus->GetPid();
-       if(fCalorimeter == "EMCAL")
-         {
-           TParticle * particle = new TParticle() ;
-           //particle->SetMomentum(px,py,pz,en) ;
-           AliDebug(4,Form("EMCAL clusters: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
-           if(!fEMCALPID) //Only identified particles
-             new((*plEMCAL)[indexNe++])       TParticle(*particle) ;
-           else if(pid[AliPID::kPhoton] > fEMCALPhotonWeight)
-             new((*plEMCAL)[indexNe++])       TParticle(*particle) ;       
-         }
-       else
-         {
-             Int_t pdg = 0;
-             if(fEMCALPID) 
-               {
-                 if( pid[AliPID::kPhoton] > fEMCALPhotonWeight) 
-                   pdg = 22;
-                 else if( pid[AliPID::kPi0] > fEMCALPi0Weight)
-                   pdg = 111;
-               }
-             else
-               pdg = 22; //No PID, assume all photons
-             
-             TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
-                                                  momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E(), v[0], v[1], v[2], 0);
-             AliDebug(4,Form("EMCAL clusters: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
-             
-             new((*plEMCAL)[indexNe++])       TParticle(*particle) ; 
-             new((*pl)[index++])           TParticle(*particle) ;
-         }
-      }
-    }
-    
-    AliDebug(3,"Particle lists filled");
-    
 }
 
-
-
 //____________________________________________________________________________
-void AliAnaGammaDirect::Exec(Option_t *) 
-{
-  
-  // Processing of one event
-
-  //Get ESDs
-  Long64_t entry = fChain->GetReadEntry() ;
-  
-  if (!fESD) {
-    AliError("fESD is not connected to the input!") ; 
-    return ; 
-  }
-  
-  if (fPrintInfo) 
-     AliInfo(Form("%s ----> Processing event # %lld",  (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ; 
-
-  //CreateTLists with arrays of TParticles. Filled with particles only relevant for the analysis.
-
-  TClonesArray * particleList = new TClonesArray("TParticle",1000); // All particles refitted in CTS and detected in EMCAL (jet)
-  TClonesArray * plCTS         = new TClonesArray("TParticle",1000); // All particles refitted in Central Tracking System (ITS+TPC)
-  TClonesArray * plNe         = new TClonesArray("TParticle",1000);   // All particles measured in Jet Calorimeter (EMCAL)
-  TClonesArray * plPHOS     = new TClonesArray("TParticle",1000);  // All particles measured in PHOS as Gamma calorimeter
-  TClonesArray * plEMCAL   = new TClonesArray("TParticle",1000);  // All particles measured in EMCAL as Gamma calorimeter
-
-  TParticle *pGamma = new TParticle(); //It will contain the kinematics of the found prompt gamma
-  //Fill lists with photons, neutral particles and charged particles
-  //look for the highest energy photon in the event inside fCalorimeter
-  
-  AliDebug(2, "Fill particle lists, get prompt gamma");
-  
-  //Fill particle lists 
-  CreateParticleList(particleList, plCTS,plEMCAL,plPHOS); 
-  
-  if(fCalorimeter == "PHOS")
-    plNe = plPHOS;
-  if(fCalorimeter == "EMCAL")
-    plNe = plEMCAL;
-  
-  
-  Bool_t iIsInPHOSorEMCAL = kFALSE ; //To check if Gamma was in any calorimeter
-  //Search highest energy prompt gamma in calorimeter
-  GetPromptGamma(plNe,  plCTS, pGamma, iIsInPHOSorEMCAL) ; 
-  
-  AliDebug(1, Form("Is Gamma in %s? %d",fCalorimeter.Data(),iIsInPHOSorEMCAL));
-  
-  //If there is any photon candidate in fCalorimeter
-  if(iIsInPHOSorEMCAL){
-    if (fPrintInfo)
-      AliInfo(Form("Prompt Gamma: pt %f, phi %f, eta %f", pGamma->Pt(),pGamma->Phi(),pGamma->Eta())) ;
-    
-  }//Gamma in Calo
-  
-  AliDebug(2, "End of analysis, delete pointers");
-  
-  particleList->Delete() ; 
-  plCTS->Delete() ;
-  plNe->Delete() ;
-  plEMCAL->Delete() ;
-  plPHOS->Delete() ;
-  pGamma->Delete();
-  PostData(0, fOutputContainer);
-
- delete plNe ;
-  delete plCTS ;
-  //delete plPHOS ;
-  //delete plEMCAL ;
-  delete particleList ;
-
-  //  delete pGamma;
-
-}    
-
-
-//____________________________________________________________________________
-void AliAnaGammaDirect::GetPromptGamma(TClonesArray * pl, TClonesArray * plCTS, TParticle *pGamma, Bool_t &Is) const 
+void AliAnaGammaDirect::GetPromptGamma(TClonesArray * pl, TClonesArray * plCTS, TParticle *pGamma, Bool_t &found) const 
 {
   //Search for the prompt photon in Calorimeter with pt > fMinGammaPt
 
@@ -469,30 +202,29 @@ void AliAnaGammaDirect::GetPromptGamma(TClonesArray * pl, TClonesArray * plCTS,
       index = ipr ;
       pt = particle->Pt();
       pGamma->SetMomentum(particle->Px(),particle->Py(),particle->Pz(),particle->Energy());
-      AliDebug(4,Form("Cluster in calo: pt %f, phi %f, eta %f", pGamma->Pt(),pGamma->Phi(),pGamma->Eta())) ;
-      Is  = kTRUE;
+      found  = kTRUE;
     }
   }
 
   //Do Isolation?
-  if(fMakeICMethod && Is)
+  if( ( fICMethod == kPtIC  ||  fICMethod == kSumPtIC )  && found)
     {
       Float_t coneptsum = 0 ;
       Bool_t  icPtThres   = kFALSE;
       Bool_t  icPtSum     = kFALSE;
       MakeIsolationCut(plCTS,pl, pGamma, index, 
                       icPtThres, icPtSum,coneptsum);
-      if(fMakeICMethod == 1) //Pt thres method
-       Is = icPtThres ;
-      if(fMakeICMethod == 2) //Pt cone sum method
-       Is = icPtSum ;
+      if(fICMethod == kPtIC) //Pt thres method
+       found = icPtThres ;
+      if(fICMethod == kSumPtIC) //Pt cone sum method
+       found = icPtSum ;
     }
   
-  if(Is){
-    AliDebug(3,Form("Cluster with p_{T} larger than %f found in calorimeter ", fMinGammaPt)) ;
-    AliDebug(3,Form("Gamma: pt %f, phi %f, eta %f", pGamma->Pt(),pGamma->Phi(),pGamma->Eta())) ;
-    //Fill prompt gamma histograms
-    fhNGamma  ->Fill(pGamma->Pt());
+  if(found){
+    AliDebug(1,Form("Cluster with p_{T} larger than %f found in calorimeter ", fMinGammaPt)) ;
+    AliDebug(1,Form("Gamma: pt %f, phi %f, eta %f", pGamma->Pt(),pGamma->Phi(),pGamma->Eta())) ;
+    //Fill prompt gamma histograms 
+    fhNGamma->Fill(pGamma->Pt());
     fhPhiGamma->Fill( pGamma->Pt(),pGamma->Phi());
     fhEtaGamma->Fill(pGamma->Pt(),pGamma->Eta());
   }
@@ -505,21 +237,21 @@ void AliAnaGammaDirect::InitParameters()
 {
  
   //Initialize the parameters of the analysis.
-  fCalorimeter="PHOS";
-  fPrintInfo           = kTRUE;
   fMinGammaPt  = 5. ;
 
   //Fill particle lists when PID is ok
-  fEMCALPID = kFALSE;
-  fPHOSPID = kFALSE;
-  fEMCALPhotonWeight = 0.5 ;
-  fEMCALPi0Weight = 0.5 ;
-  fPHOSPhotonWeight = 0.8 ;
   fConeSize             = 0.2 ; 
   fPtThreshold         = 2.0; 
   fPtSumThreshold  = 1.; 
 
-  fMakeICMethod = 1; // 0 don't isolate, 1 pt thresh method, 2 cone pt sum method
+  fICMethod = kNoIC; // 0 don't isolate, 1 pt thresh method, 2 cone pt sum method
+
+ //-----------kSeveralIC-----------------
+  fNCones           = 4 ; 
+  fNPtThres         = 4 ; 
+  fConeSizes[0] = 0.1; fConeSizes[1] = 0.2; fConeSizes[2] = 0.3; fConeSizes[3] = 0.4;
+  fPtThresholds[0]=1.; fPtThresholds[1]=2.; fPtThresholds[2]=3.; fPtThresholds[3]=4.;
+
 }
 
 //__________________________________________________________________
@@ -538,7 +270,7 @@ void  AliAnaGammaDirect::MakeIsolationCut(TClonesArray * plCTS,
   Float_t phi    = -100.  ;
   Float_t rad   = -100 ;
   Int_t    n        = 0 ;
-  TParticle * particle  = new TParticle();
+  TParticle * particle  = new TParticle;
 
   coneptsum = 0; 
   icmpt = kFALSE;
@@ -587,27 +319,71 @@ void  AliAnaGammaDirect::MakeIsolationCut(TClonesArray * plCTS,
 
 }
 
-void AliAnaGammaDirect::Print(const Option_t * opt) const
+//__________________________________________________________________
+void  AliAnaGammaDirect::MakeSeveralICAnalysis(TClonesArray * plCalo, TClonesArray * plCTS) 
 {
+  //Isolation Cut Analysis for both methods and different pt cuts and cones
 
+  if (fICMethod != kSeveralIC)
+    AliFatal("Remember to set in config file: directGamma->SetICMethod(kSeveralIC)");
+  
+  for(Int_t ipr = 0; ipr < plCalo->GetEntries() ; ipr ++ ){
+    TParticle * pCandidate = dynamic_cast<TParticle *>(plCalo->At(ipr)) ;
+    
+    if(pCandidate->Pt() > fMinGammaPt){
+      
+      Bool_t  icPtThres   = kFALSE;
+      Bool_t  icPtSum     = kFALSE;
+      
+      Float_t ptC      = pCandidate->Pt() ;
+   
+      fhNGamma->Fill(ptC);
+      fhPhiGamma->Fill( ptC,pCandidate->Phi());
+      fhEtaGamma->Fill(ptC,pCandidate->Eta());
+    
+      for(Int_t icone = 0; icone<fNCones; icone++){
+       fConeSize=fConeSizes[icone] ;
+       Float_t coneptsum = 0 ;
+       for(Int_t ipt = 0; ipt<fNPtThres;ipt++){ 
+         fPtThreshold=fPtThresholds[ipt] ;
+         MakeIsolationCut(plCTS,plCalo, pCandidate, ipr, icPtThres, icPtSum,coneptsum);
+         AliDebug(1,Form("Candidate pt %f, pt in cone %f, Isolated? ICPt %d, ICSum %d",
+                         pCandidate->Pt(), coneptsum, icPtThres, icPtSum));
+
+         fhPtThresIsolated[icone][ipt]->Fill(ptC); 
+       }//pt thresh loop
+       fhPtSumIsolated[icone]->Fill(ptC,coneptsum) ;
+      }//cone size loop
+    }//min pt candidate
+  }//candidate loop
+}
+
+void AliAnaGammaDirect::Print(const Option_t * opt) const
+{
+  
   //Print some relevant parameters set for the analysis
   if(! opt)
     return;
-
+  
   Info("Print", "%s %s", GetName(), GetTitle() ) ;
-  printf("IC method               =     %d\n", fMakeICMethod) ; 
+  
+  printf("Min Gamma pT      =     %f\n",  fMinGammaPt) ;
+  printf("IC method               =     %d\n", fICMethod) ; 
   printf("Cone Size               =     %f\n", fConeSize) ; 
-  printf("pT threshold           =     %f\n", fPtThreshold) ;
-  printf("pT sum threshold   =     %f\n", fPtSumThreshold) ; 
-  printf("Min Gamma pT      =     %f\n",  fMinGammaPt) ; 
-  printf("Calorimeter            =     %s\n", fCalorimeter.Data()) ; 
-} 
-
-void AliAnaGammaDirect::Terminate(Option_t *)
-{
-   // The Terminate() function is the last function to be called during
-   // a query. It always runs on the client, it can be used to present
-   // the results graphically or save the results to file.
-    
+   if(fICMethod == kPtIC) printf("pT threshold           =     %f\n", fPtThreshold) ;
+   if(fICMethod == kSumPtIC) printf("pT sum threshold   =     %f\n", fPtSumThreshold) ;
+   
+  if(fICMethod == kSeveralIC){
+    printf("N Cone Sizes               =     %d\n", fNCones) ; 
+    printf("N pT thresholds           =     %d\n", fNPtThres) ;
+    printf("Cone Sizes                  =    \n") ;
+    for(Int_t i = 0; i < fNCones; i++)
+      printf("   %f;",  fConeSizes[i]) ;
+    printf("    \n") ;
+    for(Int_t i = 0; i < fNPtThres; i++)
+      printf("   %f;",  fPtThresholds[i]) ;
+  }
 
-}
+  printf("    \n") ;
+  
+} 
index 2fb9327a28e53baf4ee0b8bd65d5f8cac392023e..f99bdf8f1cd104b28b23c4cfb1faade3604e159a 100644 (file)
@@ -7,26 +7,15 @@
 /* History of cvs commits:
  *
  * $Log$
- * Revision 1.3  2007/03/08 10:24:32  schutz
- * Coding convention
- *
- * Revision 1.2  2007/02/09 18:40:40  schutz
- * B\bNew version from Gustavo
- *
- * Revision 1.1  2007/01/23 17:17:29  schutz
- * New Gamma package
+ * Revision 1.4.4.3  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
  *
  *
  */
 
 //_________________________________________________________________________
 
-// Class for the analysis of gamma 
-// This class only contains 3 methods: one to fill lists of particles (ESDs) comming 
-//  from the CTS (ITS+TPC) and the calorimeters; the other search in the 
-//  corresponing calorimeter for the highest energy cluster, identify it as 
-//  prompt photon(Shower Shape and Isolation Cut), the last method does the 
-//  isolation selection
+// Class for the analysis of prompt gamma, isolation cut. 
 //
 //  Class created from old AliPHOSGammaJet
 //  (see AliRoot versions previous Release 4-09)
 // --- ROOT system ---
 #include <TParticle.h> 
 #include <TClonesArray.h> 
-#include <TTree.h> 
-#include "AliAnalysisTask.h" 
+#include "TObject.h" 
 #include <TH2F.h>
 
-class AliESD ; 
-class AliAnaGammaDirect : public AliAnalysisTask {
+class TList ;
+
+class AliAnaGammaDirect : public TObject {
 
 public: 
 
-  AliAnaGammaDirect(const char *name) ; // default ctor
+  AliAnaGammaDirect() ; // default ctor
   AliAnaGammaDirect(const AliAnaGammaDirect & g) ; // cpy ctor
   AliAnaGammaDirect & operator = (const AliAnaGammaDirect & g) ;//cpy assignment
   virtual ~AliAnaGammaDirect() ; //virtual dtor
-
-  virtual void Exec(Option_t * opt = "") ;
-  virtual void ConnectInputData(Option_t *);
-  virtual void CreateOutputObjects();
-  virtual void Terminate(Option_t * opt = "");
   
-  void InitParameters();
-  TTree *     GetChain()                const {return fChain ; }
-  AliESD *    GetESD()                  const {return fESD ; }
-  TObjArray * GetOutputContainer()      const {return fOutputContainer ; }
+  enum anatype_t {kNoIC, kPtIC, kSumPtIC, kSeveralIC};
+  
   Double_t  GetMinGammaPt()    const {return fMinGammaPt ; }
-  TString    GetCalorimeter()       const {return fCalorimeter ; }
-  Bool_t      GetPrintInfo()           const {return fPrintInfo ; }
   Float_t     GetConeSize()          const {return fConeSize ; }
   Float_t     GetPtThreshold()      const {return fPtThreshold ; }
   Float_t     GetPtSumThres()     const {return fPtSumThreshold ; }
-  Int_t        GetICMethod()          const {return fMakeICMethod ; }
-
-  Bool_t   IsEMCALPIDOn() const {return fEMCALPID ; }
-  Bool_t   IsPHOSPIDOn() const {return fPHOSPID ; }
-  Float_t  GetEMCALPhotonWeight() { return  fEMCALPhotonWeight  ; }
-  Float_t  GetEMCALPi0Weight()    {  return fEMCALPi0Weight  ; }
-  Float_t  GetPHOSPhotonWeight()  {  return fPHOSPhotonWeight  ; }
+  Int_t        GetICMethod()          const {return fICMethod ; }
 
+  TList *  GetCreateOutputObjects();
+  void GetPromptGamma(TClonesArray * plNe, TClonesArray * plCTS, TParticle * pGamma, Bool_t &Is)  const;
+  
+  void MakeSeveralICAnalysis(TClonesArray * plCalo, TClonesArray * plCTS); 
+  void MakeIsolationCut(TClonesArray * plCTS, TClonesArray * plNe, 
+                       TParticle *pCandidate, Int_t index, 
+                       Bool_t &imcpt, Bool_t &icms, Float_t &ptsum) const ;  
+  
   void Print(const Option_t * opt)const;
-
+  
   void SetMinGammaPt(Double_t ptcut){fMinGammaPt =ptcut;}
-  void SetCalorimeter(TString calo){ fCalorimeter= calo ; }
-  void SetPrintInfo(Bool_t print){ fPrintInfo = print ; }
   void SetConeSize(Float_t r)              {fConeSize = r ; }
   void SetPtThreshold(Float_t pt)        {fPtThreshold = pt; };
   void SetPtSumThreshold(Float_t pt) {fPtSumThreshold = pt; };
-  void SetICMethod(Int_t i )          {fMakeICMethod = i ; }
-  
-  void SetEMCALPIDOn(Bool_t pid){ fEMCALPID= pid ; }
-  void SetPHOSPIDOn(Bool_t pid){ fPHOSPID= pid ; }
-  void SetEMCALPhotonWeight(Float_t  w){  fEMCALPhotonWeight = w ; }
-  void SetEMCALPi0Weight(Float_t  w){  fEMCALPi0Weight = w ; }
-  void SetPHOSPhotonWeight(Float_t  w){  fPHOSPhotonWeight = w ; }
-
-  void CreateParticleList(TClonesArray * particleList, 
-                         TClonesArray * plCh, TClonesArray * plNe, 
-                         TClonesArray * plNePHOS);
-  
+  void SetICMethod(Int_t i )          {fICMethod = i ; }
   
-  void GetPromptGamma(TClonesArray * plNe, TClonesArray * plCTS, TParticle * pGamma, Bool_t &Is)  const;
-  
-  void MakeIsolationCut(TClonesArray * plCTS, TClonesArray * plNe, 
-                       TParticle *pCandidate, Int_t index, 
-                       Bool_t &imcpt, Bool_t &icms, Float_t &ptsum) const ;  
+  Int_t    GetNCones()                  const {return fNCones ; }
+  Int_t    GetNPtThresholds()                const {return fNPtThres ; }
+  Float_t GetConeSizes(Int_t i)      const {return fConeSizes[i] ; }
+  Float_t GetPtThresholds(Int_t i)  const {return fPtThresholds[i] ; }
   
- private:
+  void InitParameters();
+  void SetNCones(Int_t ncs)              {fNCones = ncs ; }
+  void SetNPtThresholds(Int_t npt)        {fNPtThres = npt; }
+  void SetConeSizes(Int_t i, Float_t r)         {fConeSizes[i] = r ; }
+  void SetPtThresholds(Int_t i, Float_t pt)   {fPtThresholds[i] = pt; }
 
-  TTree       *fChain ;   //!pointer to the analyzed TTree or TChain
-  AliESD       *fESD ;     //! Declaration of leave types
-  TObjArray  *fOutputContainer ; //! output data container
-  Bool_t        fPrintInfo ;      //Print most interesting information on screen
+  
+  private:
+     
   Double_t    fMinGammaPt ;  // Min pt in Calorimeter
-  TString      fCalorimeter ; //PHOS or EMCAL detects Gamma
-  Bool_t       fEMCALPID ;//Fill EMCAL particle lists with particles with corresponding pid
-  Bool_t       fPHOSPID;  //Fill PHOS particle lists with particles with corresponding pid
-  Float_t      fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL 
-  Float_t      fEMCALPi0Weight;  //Bayesian PID weight for pi0 in EMCAL 
-  Float_t      fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS 
   Float_t      fConeSize ; //Size of the isolation cone 
   Float_t      fPtThreshold ; //Mimium pt of the particles in the cone to set isolation
   Float_t      fPtSumThreshold ; //Mimium pt sum of the particles in the cone to set isolation  
-  Int_t        fMakeICMethod ; //Isolation cut method to be used
-                                           // 0: No isolation
-                                           // 1: Pt threshold method
-                                           // 2: Cone pt sum method
+  Int_t        fICMethod ; //Isolation cut method to be used
+                                           // kNoIC: No isolation
+                                           // kPtIC: Pt threshold method
+                                           // kSumPtIC: Cone pt sum method
+                                           // kSeveralIC: Analysis for several cuts
   //Histograms  
-  TH1F * fhNGamma    ; 
-  TH2F * fhPhiGamma    ; 
-  TH2F * fhEtaGamma    ; 
+  TH1F * fhNGamma    ;  //Number of (isolated) gamma identified
+  TH2F * fhPhiGamma    ; // Phi of identified gamma
+  TH2F * fhEtaGamma    ; // eta of identified gamma
+  
+  //Prompt photon analysis data members for multiple cones and pt thresholds kIsolationCut
+  Int_t         fNCones   ; //Number of cone sizes to test
+  Int_t         fNPtThres ; //Number of ptThres to test
+  Float_t     fConeSizes[10] ; // Array with cones to test
+  Float_t     fPtThresholds[10] ; // Array with pt thresholds to test
+  
+  TH1F* fhPtThresIsolated[20][20]; // Isolated gamma with pt threshold 
+  TH2F* fhPtSumIsolated[20] ;  //  Isolated gamma with threshold on cone pt sume
 
   ClassDef(AliAnaGammaDirect,0)
 } ;
index fd9fb2e3c321821da3a474e2db6bd08f1453e6be..fc9f2c4807053e9985a2d6223f3ac872b9f18e2d 100644 (file)
 /* History of cvs commits:
  *
  * $Log$
- * Revision 1.3  2007/03/08 10:24:32  schutz
- * Coding convention
- *
- * Revision 1.2  2007/02/09 18:40:40  schutz
- * New version from Gustavo
- *
- * Revision 1.1  2007/01/23 17:17:29  schutz
- * New Gamma package
+ * Revision 1.4.4.2  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
  *
  *
  */
 
 //_________________________________________________________________________
-// Class for the analysis of gamma-jet correlations 
-//  Basically it seaches for a prompt photon in the Calorimeters acceptance, 
-//  if so we construct a jet around the highest pt particle in the opposite 
-//  side in azimuth, inside the Central Tracking System (ITS+TPC) and 
-//  EMCAL acceptances (only when PHOS detects the gamma). First the leading 
-//  particle and then the jet have to fullfill several conditions 
-//  (energy, direction ..) to be accepted. Then the fragmentation function 
-//  of this jet is constructed   
-//  Class created from old AliPHOSGammaPion 
-//  (see AliRoot versions previous Release 4-09)
-//
+// Class for the analysis of gamma - hadron correlations
 //*-- Author: Gustavo Conesa (LNF-INFN) 
 //////////////////////////////////////////////////////////////////////////////
 
 
 // --- ROOT system ---
-
-#include <TFile.h>
-#include <TParticle.h>
-#include <TH2.h>
-
-#include "AliAnaGammaHadron.h" 
-#include "AliESD.h"
-#include "AliESDtrack.h"
-#include "AliESDCaloCluster.h"
 #include "Riostream.h"
+
+//---- AliRoot system ----
 #include "AliLog.h"
+#include "AliNeutralMesonSelection.h" 
+#include "AliAnaGammaHadron.h" 
 
 ClassImp(AliAnaGammaHadron)
 
+
 //____________________________________________________________________________
-AliAnaGammaHadron::AliAnaGammaHadron(const char *name) : 
-  AliAnaGammaDirect(name), 
-  fPhiMaxCut(0.), fPhiMinCut(0.), 
-  fInvMassMaxCut(0.), fInvMassMinCut(0.),
-  fMinPtPion(0),  fOutputContainer(new TObjArray(100)),
-  fAngleMaxParam(),  
-  fhPhiCharged(0), fhPhiNeutral(0), fhEtaCharged(0), fhEtaNeutral(0), 
-  fhDeltaPhiGammaCharged(0),  fhDeltaPhiGammaNeutral(0), 
-  fhDeltaEtaGammaCharged(0), fhDeltaEtaGammaNeutral(0), 
-  fhCorrelationGammaNeutral(0), fhCorrelationGammaCharged(0), 
-  fhAnglePairAccepted(0), fhAnglePairNoCut(0), fhAnglePairAzimuthCut(0), 
-  fhAnglePairOpeningAngleCut(0), fhAnglePairAllCut(0), 
-  fhInvMassPairNoCut(0), fhInvMassPairAzimuthCut(0), fhInvMassPairOpeningAngleCut(0), fhInvMassPairAllCut(0) 
-  
+  AliAnaGammaHadron::AliAnaGammaHadron() : 
+    AliAnaGammaCorrelation(),
+    fhPhiCharged(0), fhPhiNeutral(0), fhEtaCharged(0), fhEtaNeutral(0), 
+    fhDeltaPhiGammaCharged(0),  fhDeltaPhiGammaNeutral(0), 
+    fhDeltaEtaGammaCharged(0), fhDeltaEtaGammaNeutral(0), 
+    fhCorrelationGammaNeutral(0), fhCorrelationGammaCharged(0)
 {
-
-  // ctor
-  fAngleMaxParam.Set(4) ;
-  fAngleMaxParam.Reset(0.);
-
-  //Init Parameters        
-  InitParameters();
-
-  // Input slot #0 works with an Ntuple
-  DefineInput(0, TChain::Class());
-  // Output slot #0 writes into a TH1 container
-  DefineOutput(0,  TObjArray::Class()) ; 
+  //Default Ctor
   
+  SetCorrelationType(kHadron);
+  //Initialize parameters
+  InitParameters();
 }
 
-
 //____________________________________________________________________________
-AliAnaGammaHadron::AliAnaGammaHadron(const AliAnaGammaHadron & gh) : 
-  AliAnaGammaDirect(gh), 
-  fPhiMaxCut(gh.fPhiMaxCut), fPhiMinCut(gh.fPhiMinCut), 
-  fInvMassMaxCut(gh.fInvMassMaxCut), fInvMassMinCut(gh.fInvMassMinCut),
-  fMinPtPion(gh.fMinPtPion),
-  fOutputContainer(gh.fOutputContainer), fAngleMaxParam(gh.fAngleMaxParam),
-  fhPhiCharged(gh.fhPhiCharged), fhPhiNeutral(gh.fhPhiNeutral), fhEtaCharged(gh.fhEtaCharged), fhEtaNeutral(gh.fhEtaNeutral), 
-  fhDeltaPhiGammaCharged(gh.fhDeltaPhiGammaCharged),  fhDeltaPhiGammaNeutral(gh.fhDeltaPhiGammaNeutral), 
-  fhDeltaEtaGammaCharged(gh.fhDeltaEtaGammaCharged), fhDeltaEtaGammaNeutral(gh.fhDeltaEtaGammaNeutral), 
-  fhCorrelationGammaNeutral(gh.fhCorrelationGammaNeutral), fhCorrelationGammaCharged(gh.fhCorrelationGammaCharged), 
-  fhAnglePairAccepted(gh.fhAnglePairAccepted), fhAnglePairNoCut(gh. fhAnglePairNoCut), fhAnglePairAzimuthCut(gh.fhAnglePairAzimuthCut), 
-  fhAnglePairOpeningAngleCut(gh. fhAnglePairOpeningAngleCut), fhAnglePairAllCut(gh. fhAnglePairAllCut), 
-  fhInvMassPairNoCut(gh.fhInvMassPairNoCut), fhInvMassPairAzimuthCut(gh.fhInvMassPairAzimuthCut), 
-  fhInvMassPairOpeningAngleCut(gh.fhInvMassPairOpeningAngleCut), fhInvMassPairAllCut(gh.fhInvMassPairAllCut) 
-
+AliAnaGammaHadron::AliAnaGammaHadron(const AliAnaGammaHadron & g) :   
+  AliAnaGammaCorrelation(g),
+  fhPhiCharged(g.fhPhiCharged), fhPhiNeutral(g.fhPhiNeutral), 
+  fhEtaCharged(g.fhEtaCharged), fhEtaNeutral(g.fhEtaNeutral), 
+  fhDeltaPhiGammaCharged(g.fhDeltaPhiGammaCharged),  
+  fhDeltaPhiGammaNeutral(g.fhDeltaPhiGammaNeutral), 
+  fhDeltaEtaGammaCharged(g.fhDeltaEtaGammaCharged), 
+  fhDeltaEtaGammaNeutral(g.fhDeltaEtaGammaNeutral), 
+  fhCorrelationGammaNeutral(g.fhCorrelationGammaNeutral), 
+  fhCorrelationGammaCharged(g.fhCorrelationGammaCharged)
 {
   // cpy ctor
-  SetName (gh.GetName()) ; 
-  SetTitle(gh.GetTitle()) ; 
 
 }
 
 //_________________________________________________________________________
 AliAnaGammaHadron & AliAnaGammaHadron::operator = (const AliAnaGammaHadron & source)
 {
-  //assignment operator
-  if(&source == this) return *this;
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((AliAnaGammaCorrelation *)this)->operator=(source);
   
-  fPhiMaxCut = source.fPhiMaxCut ; fPhiMinCut = source.fPhiMinCut ; 
-  fInvMassMaxCut = source.fInvMassMaxCut ; fInvMassMinCut = source.fInvMassMinCut ;
-  fMinPtPion = source.fMinPtPion ;
-  fOutputContainer = source.fOutputContainer ; fAngleMaxParam = source.fAngleMaxParam ;
-  fhPhiCharged = source.fhPhiCharged ; fhPhiNeutral = source.fhPhiNeutral ; fhEtaCharged = source.fhEtaCharged ; fhEtaNeutral = source.fhEtaNeutral ; 
-  fhDeltaPhiGammaCharged = source.fhDeltaPhiGammaCharged ;  fhDeltaPhiGammaNeutral = source.fhDeltaPhiGammaNeutral ; 
-  fhDeltaEtaGammaCharged = source.fhDeltaEtaGammaCharged ; fhDeltaEtaGammaNeutral = source.fhDeltaEtaGammaNeutral ; 
-  fhCorrelationGammaNeutral = source.fhCorrelationGammaNeutral ; fhCorrelationGammaCharged = source.fhCorrelationGammaCharged ; 
-  fhAnglePairAccepted = source.fhAnglePairAccepted ; fhAnglePairNoCut = source. fhAnglePairNoCut ; fhAnglePairAzimuthCut = source.fhAnglePairAzimuthCut ; 
-  fhAnglePairOpeningAngleCut = source. fhAnglePairOpeningAngleCut ; fhAnglePairAllCut = source. fhAnglePairAllCut ; 
-  fhInvMassPairNoCut = source.fhInvMassPairNoCut ; fhInvMassPairAzimuthCut = source.fhInvMassPairAzimuthCut ; 
-  fhInvMassPairOpeningAngleCut = source.fhInvMassPairOpeningAngleCut ; fhInvMassPairAllCut = source.fhInvMassPairAllCut ; 
+  fhPhiCharged = source.fhPhiCharged ; fhPhiNeutral = source.fhPhiNeutral ; 
+  fhEtaCharged = source.fhEtaCharged ; fhEtaNeutral = source.fhEtaNeutral ; 
+  fhDeltaPhiGammaCharged = source.fhDeltaPhiGammaCharged ;  
+  fhDeltaPhiGammaNeutral = source.fhDeltaPhiGammaNeutral ; 
+  fhDeltaEtaGammaCharged = source.fhDeltaEtaGammaCharged ; 
+  fhDeltaEtaGammaNeutral = source.fhDeltaEtaGammaNeutral ; 
+
+  fhCorrelationGammaNeutral = source.fhCorrelationGammaNeutral ; 
+  fhCorrelationGammaCharged = source.fhCorrelationGammaCharged ; 
 
   return *this;
+
 }
 
 //____________________________________________________________________________
 AliAnaGammaHadron::~AliAnaGammaHadron() 
 {
-  // Remove all pointers
-  fOutputContainer->Clear() ; 
-  delete fOutputContainer ;
   
   delete fhPhiCharged  ;  
   delete fhPhiNeutral   ; 
@@ -154,277 +107,148 @@ AliAnaGammaHadron::~AliAnaGammaHadron()
   delete fhDeltaEtaGammaNeutral  ; 
 
   delete fhCorrelationGammaNeutral  ; 
-  delete fhCorrelationGammaCharged  ; 
-
-  delete fhAnglePairNoCut  ; 
-  delete fhAnglePairAzimuthCut  ; 
-  delete fhAnglePairOpeningAngleCut   ; 
-  delete fhAnglePairAllCut   ;  
-  delete fhInvMassPairNoCut    ; 
-  delete fhInvMassPairAzimuthCut  ; 
-  delete fhInvMassPairOpeningAngleCut  ; 
-  delete fhInvMassPairAllCut   ;    
-
+  delete fhCorrelationGammaCharged  ;
 }
 
-//______________________________________________________________________________
-void AliAnaGammaHadron::ConnectInputData(const Option_t*)
-{
-  // Initialisation of branch container and histograms 
-  AliAnaGammaDirect::ConnectInputData("");  
-}
 
 //________________________________________________________________________
-void AliAnaGammaHadron::CreateOutputObjects()
+TList *  AliAnaGammaHadron::GetCreateOutputObjects()
 {  
 
   // Create histograms to be saved in output file and 
-  // stores them in fOutputContainer
-  AliAnaGammaDirect::CreateOutputObjects();
-
-  fOutputContainer = new TObjArray(100) ;
-  
-  //Use histograms in AliAnaGammaDirect
-  TObjArray  * outputContainer =GetOutputContainer();
-  for(Int_t i = 0; i < outputContainer->GetEntries(); i++ )
-    fOutputContainer->Add(outputContainer->At(i)) ;
+  // store them in fOutputContainer
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("GammaCorrelationHistos") ; 
   
   fhPhiCharged  = new TH2F
     ("PhiCharged","#phi_{#pi^{#pm}}  vs p_{T #gamma}",
      120,0,120,120,0,7); 
   fhPhiCharged->SetYTitle("#phi_{#pi^{#pm}} (rad)");
   fhPhiCharged->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhPhiCharged) ;
-  
-  fhPhiNeutral  = new TH2F
-    ("PhiNeutral","#phi_{#pi^{0}}  vs p_{T #gamma}",
-     120,0,120,120,0,7); 
-  fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
-  fhPhiNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhPhiNeutral) ;  
   
   fhEtaCharged  = new TH2F
     ("EtaCharged","#eta_{#pi^{#pm}}  vs p_{T #gamma}",
      120,0,120,120,-1,1); 
   fhEtaCharged->SetYTitle("#eta_{#pi^{#pm}} (rad)");
   fhEtaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhEtaCharged) ;
-
-  fhEtaNeutral  = new TH2F
-    ("EtaNeutral","#eta_{#pi^{0}}  vs p_{T #gamma}",
-     120,0,120,120,-1,1); 
-  fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
-  fhEtaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhEtaNeutral) ;  
-
+  
   fhDeltaPhiGammaCharged  = new TH2F
     ("DeltaPhiGammaCharged","#phi_{#gamma} - #phi_{charged #pi} vs p_{T #gamma}",
      200,0,120,200,0,6.4); 
   fhDeltaPhiGammaCharged->SetYTitle("#Delta #phi");
   fhDeltaPhiGammaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhDeltaPhiGammaCharged) ; 
   
   fhDeltaEtaGammaCharged  = new TH2F
     ("DeltaEtaGammaCharged","#eta_{#gamma} - #eta_{#pi^{#pm}} vs p_{T #gamma}",
      200,0,120,200,-2,2); 
   fhDeltaEtaGammaCharged->SetYTitle("#Delta #eta");
   fhDeltaEtaGammaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhDeltaEtaGammaCharged) ; 
 
-  fhDeltaPhiGammaNeutral  = new TH2F
-    ("DeltaPhiGammaNeutral","#phi_{#gamma} - #phi_{#pi^{0}} vs p_{T #gamma}",
-     200,0,120,200,0,6.4); 
-  fhDeltaPhiGammaNeutral->SetYTitle("#Delta #phi");
-  fhDeltaPhiGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhDeltaPhiGammaNeutral) ; 
-  
-  fhDeltaEtaGammaNeutral  = new TH2F
-    ("DeltaEtaGammaNeutral","#eta_{#gamma} - #eta_{#pi^{#pm}} vs p_{T #gamma}",
-     200,0,120,200,-2,2); 
-  fhDeltaEtaGammaNeutral->SetYTitle("#Delta #eta");
-  fhDeltaEtaGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
-  fOutputContainer->Add(fhDeltaEtaGammaNeutral) ; 
-  
-  //
-  fhAnglePairAccepted  = new TH2F
-    ("AnglePairAccepted",
-     "Angle between #pi^{0} #gamma pair vs p_{T  #pi^{0}}, both #gamma in eta<0.7, inside window",
-     200,0,50,200,0,0.2); 
-  fhAnglePairAccepted->SetYTitle("Angle (rad)");
-  fhAnglePairAccepted->SetXTitle("E_{ #pi^{0}} (GeV/c)");
-  fOutputContainer->Add(fhAnglePairAccepted) ; 
-  
-  fhAnglePairNoCut  = new TH2F
-    ("AnglePairNoCut",
-     "Angle between all #gamma pair vs p_{T  #pi^{0}}",200,0,50,200,0,0.2); 
-  fhAnglePairNoCut->SetYTitle("Angle (rad)");
-  fhAnglePairNoCut->SetXTitle("E_{ #pi^{0}} (GeV/c)");
-  fOutputContainer->Add(fhAnglePairNoCut) ; 
-  
-  fhAnglePairAzimuthCut  = new TH2F
-    ("AnglePairAzimuthCut",
-     "Angle between all #gamma pair that have a good phi and pt vs p_{T  #pi^{0}}",
-     200,0,50,200,0,0.2); 
-  fhAnglePairAzimuthCut->SetYTitle("Angle (rad)");
-  fhAnglePairAzimuthCut->SetXTitle("E_{ #pi^{0}} (GeV/c)");
-  fOutputContainer->Add(fhAnglePairAzimuthCut) ; 
+  fhCorrelationGammaCharged  = 
+    new TH2F("CorrelationGammaCharged","z_{#gamma #pi} = p_{T #pi^{#pm}} / p_{T #gamma}",
+            240,0.,120.,1000,0.,1.2); 
+  fhCorrelationGammaCharged->SetYTitle("z_{#gamma #pi}");
+  fhCorrelationGammaCharged->SetXTitle("p_{T #gamma}");
   
-    fhAnglePairOpeningAngleCut  = new TH2F
-      ("AnglePairOpeningAngleCut",
-       "Angle between all #gamma pair (opening angle + azimuth cut) vs p_{T  #pi^{0}}"
-       ,200,0,50,200,0,0.2); 
-    fhAnglePairOpeningAngleCut->SetYTitle("Angle (rad)");
-    fhAnglePairOpeningAngleCut->SetXTitle("E_{ #pi^{0}} (GeV/c)");
-    fOutputContainer->Add(fhAnglePairOpeningAngleCut) ;
+  outputContainer->Add(fhPhiCharged) ;
+  outputContainer->Add(fhEtaCharged) ;
+  outputContainer->Add(fhDeltaPhiGammaCharged) ; 
+  outputContainer->Add(fhDeltaEtaGammaCharged) ;
+  outputContainer->Add(fhCorrelationGammaCharged) ;
+
+  if(!AreJetsOnlyInCTS()){
+    //---- kHadron and kJetLeadCone ----
+    fhPhiNeutral  = new TH2F
+      ("PhiNeutral","#phi_{#pi^{0}}  vs p_{T #gamma}",
+       120,0,120,120,0,7); 
+    fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
+    fhPhiNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
     
-    fhAnglePairAllCut  = new TH2F
-      ("AnglePairAllCut",
-       "Angle between all #gamma pair (opening angle + inv mass cut+azimuth) vs p_{T  #pi^{0}}"
-       ,200,0,50,200,0,0.2); 
-    fhAnglePairAllCut->SetYTitle("Angle (rad)");
-    fhAnglePairAllCut->SetXTitle("E_{ #pi^{0}} (GeV/c)");
-    fOutputContainer->Add(fhAnglePairAllCut) ; 
+    fhEtaNeutral  = new TH2F
+      ("EtaNeutral","#eta_{#pi^{0}}  vs p_{T #gamma}",
+       120,0,120,120,-1,1); 
+    fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
+    fhEtaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
     
+    fhDeltaPhiGammaNeutral  = new TH2F
+      ("DeltaPhiGammaNeutral","#phi_{#gamma} - #phi_{#pi^{0}} vs p_{T #gamma}",
+       200,0,120,200,0,6.4); 
+    fhDeltaPhiGammaNeutral->SetYTitle("#Delta #phi");
+    fhDeltaPhiGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
     
-    //
-    fhInvMassPairNoCut  = new TH2F
-      ("InvMassPairNoCut","Invariant Mass of all #gamma pair vs p_{T #gamma}",
-       120,0,120,360,0,0.5); 
-    fhInvMassPairNoCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-    fhInvMassPairNoCut->SetXTitle("p_{T #gamma} (GeV/c)");
-    fOutputContainer->Add(fhInvMassPairNoCut) ; 
+    fhDeltaEtaGammaNeutral  = new TH2F
+      ("DeltaEtaGammaNeutral","#eta_{#gamma} - #eta_{#pi^{#pm}} vs p_{T #gamma}",
+       200,0,120,200,-2,2); 
+    fhDeltaEtaGammaNeutral->SetYTitle("#Delta #eta");
+    fhDeltaEtaGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
     
-    fhInvMassPairAzimuthCut  = new TH2F
-      ("InvMassPairAzimuthCut",
-       "Invariant Mass of #gamma pair (azimuth cuts) vs p_{T #gamma}",
-       120,0,120,360,0,0.5); 
-    fhInvMassPairAzimuthCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-    fhInvMassPairAzimuthCut->SetXTitle("p_{T #gamma} (GeV/c)");
-    fOutputContainer->Add(fhInvMassPairAzimuthCut) ; 
-    
-    fhInvMassPairOpeningAngleCut  = new TH2F
-      ("InvMassPairOpeningAngleCut",
-       "Invariant Mass of #gamma pair (angle cut) vs p_{T #gamma}",
-       120,0,120,360,0,0.5); 
-    fhInvMassPairOpeningAngleCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-    fhInvMassPairOpeningAngleCut->SetXTitle("p_{T #gamma} (GeV/c)");
-    fOutputContainer->Add(fhInvMassPairOpeningAngleCut) ; 
-    
-    fhInvMassPairAllCut  = new TH2F
-      ("InvMassPairAllCut",
-       "Invariant Mass of #gamma pair (opening angle+invmass cut+azimuth) vs p_{T #gamma}",
-       120,0,120,360,0,0.5); 
-    fhInvMassPairAllCut->SetYTitle("Invariant Mass (GeV/c^{2})");
-    fhInvMassPairAllCut->SetXTitle("p_{T #gamma} (GeV/c)");
-    fOutputContainer->Add(fhInvMassPairAllCut) ; 
-    //   
-    fhCorrelationGammaCharged  = 
-      new TH2F("CorrelationGammaCharged","z_{#gamma #pi} = p_{T #pi^{#pm}} / p_{T #gamma}",
-              240,0.,120.,1000,0.,1.2); 
-    fhCorrelationGammaCharged->SetYTitle("z_{#gamma #pi}");
-    fhCorrelationGammaCharged->SetXTitle("p_{T #gamma}");
-    fOutputContainer->Add(fhCorrelationGammaCharged) ;
-
     fhCorrelationGammaNeutral  = 
       new TH2F("CorrelationGammaNeutral","z_{#gamma #pi} = p_{T #pi^{0}} / p_{T #gamma}",
               240,0.,120.,1000,0.,1.2); 
     fhCorrelationGammaNeutral->SetYTitle("z_{#gamma #pi}");
     fhCorrelationGammaNeutral->SetXTitle("p_{T #gamma}");
-    fOutputContainer->Add(fhCorrelationGammaNeutral) ;
-
-}
 
-//____________________________________________________________________________
-void AliAnaGammaHadron::Exec(Option_t *) 
-{
-  
-  // Processing of one event
-
-  //Get ESDs
-  Long64_t entry = GetChain()->GetReadEntry() ;
-  
-  if (!GetESD()) {
-    AliError("fESD is not connected to the input!") ; 
-    return ; 
+    outputContainer->Add(fhPhiNeutral) ;  
+    outputContainer->Add(fhEtaNeutral) ;   
+    outputContainer->Add(fhDeltaPhiGammaNeutral) ; 
+    outputContainer->Add(fhDeltaEtaGammaNeutral) ; 
+    outputContainer->Add(fhCorrelationGammaNeutral) ;
   }
+
+  SetOutputContainer(outputContainer);
   
-  if (GetPrintInfo()) 
-    AliInfo(Form("%s ----> Processing event # %lld",  (dynamic_cast<TChain *>(GetChain()))->GetFile()->GetName(), entry)) ; 
+  return outputContainer;
+}
 
-  //CreateTLists with arrays of TParticles. Filled with particles only relevant for the analysis.
+ //____________________________________________________________________________
+void AliAnaGammaHadron::InitParameters()
+{
+  //Initialize the parameters of the analysis.
 
-  TClonesArray * particleList = new TClonesArray("TParticle",1000); // All particles refitted in CTS and detected in EMCAL (jet)
-  TClonesArray * plCTS         = new TClonesArray("TParticle",1000); // All particles refitted in Central Tracking System (ITS+TPC)
-  TClonesArray * plNe          = new TClonesArray("TParticle",1000);   // All particles measured in Jet Calorimeter
-  TClonesArray * plCalo     = new TClonesArray("TParticle",1000);  // All particles measured in Prompt Gamma calorimeter
+  SetMinPtHadron(2.)   ;
+  SetDeltaPhiCutRange(1.5,4.5);
+  SetJetsOnlyInCTS(kFALSE) ;
 
+}
 
-  TParticle *pGamma = new TParticle(); //It will contain the kinematics of the found prompt gamma
+//__________________________________________________________________
+void AliAnaGammaHadron::Print(const Option_t * opt) const
+{
 
-  Bool_t iIsInPHOSorEMCAL = kFALSE ; //To check if Gamma was in any calorimeter
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("Correlation analysis           =     %d\n", kHadron) ;
+  printf("pT Hadron       >    %f\n", GetMinPtHadron()) ; 
+  printf("Phi gamma-Hadron      <     %f\n", GetDeltaPhiMaxCut()) ; 
+  printf("Phi gamma-Hadron      >     %f\n", GetDeltaPhiMinCut()) ;
   
-  //Fill lists with photons, neutral particles and charged particles
-  //look for the highest energy photon in the event inside fCalorimeter
-  //Fill particle lists 
-  AliDebug(2, "Fill particle lists, get prompt gamma");
-
-  //Fill particle lists 
-  if(GetCalorimeter() == "PHOS")
-    CreateParticleList(particleList, plCTS,plNe,plCalo); 
-  else if(GetCalorimeter() == "EMCAL")
-    CreateParticleList(particleList, plCTS,plCalo,plNe); 
-  else
-    AliError("No calorimeter selected");
-  //Search highest energy prompt gamma in calorimeter
-  GetPromptGamma(plCalo,  plCTS, pGamma, iIsInPHOSorEMCAL) ; 
-
 
-  AliDebug(1, Form("Is Gamma in %s? %d",GetCalorimeter().Data(),iIsInPHOSorEMCAL));
-    AliDebug(3,Form("Charged list entries %d, Neutral list entries %d, %s list entries %d",
-                   plCTS->GetEntries(),plNe->GetEntries(), GetCalorimeter().Data(),plCalo->GetEntries()));
-    
-  //If there is any prompt photon  in fCalorimeter, 
-  //search jet leading particle
+} 
 
-  if(iIsInPHOSorEMCAL){
+//____________________________________________________________________________
+void  AliAnaGammaHadron::MakeGammaCorrelation(TParticle * pGamma, TClonesArray * plCTS, TClonesArray * plCalo)  
+{  
+  //Gamma Hadron Correlation Analysis
+  AliDebug(2, "Make gamma-hadron correlation");
 
-    if (GetPrintInfo())
-      AliInfo(Form("Prompt Gamma: pt %f, phi %f, eta %f", pGamma->Pt(),pGamma->Phi(),pGamma->Eta())) ;
+  MakeGammaChargedCorrelation(pGamma, plCTS);  
+  if(!AreJetsOnlyInCTS())
+  MakeGammaNeutralCorrelation(pGamma, plCalo);
     
-    AliDebug(2, "Make correlation");
-    
-    //Search correlation 
-    MakeGammaChargedCorrelation(plCTS, pGamma);
-    MakeGammaNeutralCorrelation(plNe, pGamma);
-
-  }//Gamma in Calo
-     
-  AliDebug(2, "End of analysis, delete pointers");
-
-  particleList->Delete() ; 
-  plCTS->Delete() ;
-  plNe->Delete() ;
-  plCalo->Delete() ;
-  pGamma->Delete();
-
-  delete plNe ;
-  delete plCalo ;
-  delete plCTS ;
-  delete particleList ;
-  //  delete pGamma;
-
-  PostData(0, fOutputContainer);
-}    
 
+}
 
 //____________________________________________________________________________
-void  AliAnaGammaHadron::MakeGammaChargedCorrelation(TClonesArray * pl, TParticle * pGamma) const 
+void  AliAnaGammaHadron::MakeGammaChargedCorrelation(TParticle * pGamma, TClonesArray * pl)
 {  
-  //Search for the charged particle with highest with 
-  //Phi=Phi_gamma-Pi and pT=0.1E_gamma 
+  //Gamma Charged Hadron Correlation Analysis
+  AliDebug(2,"Make gamma-charged hadron correlation");
+
   Double_t ptg  = pGamma->Pt();
   Double_t phig = pGamma->Phi();
   Double_t pt    = -100.;
@@ -439,14 +263,14 @@ void  AliAnaGammaHadron::MakeGammaChargedCorrelation(TClonesArray * pl, TParticl
     rat   = pt/ptg ;
     phi   = particle->Phi() ;
     
-    AliDebug(3,Form("pt %f, phi %f, phi gamma %f. Cuts:  delta phi min %f,  max%f, pT min %f",pt,phi,phig,fPhiMinCut,fPhiMaxCut,fMinPtPion));
+    AliDebug(3,Form("pt %f, phi %f, phi gamma %f. Cuts:  delta phi min %f,  max%f, pT min %f",pt,phi,phig,GetDeltaPhiMinCut(),GetDeltaPhiMaxCut(),GetMinPtHadron()));
     
     fhEtaCharged->Fill(ptg,particle->Eta());
     fhPhiCharged->Fill(ptg,phi);
     fhDeltaEtaGammaCharged->Fill(ptg,pGamma->Eta()-particle->Eta());
     fhDeltaPhiGammaCharged->Fill(ptg,phig-phi);
     //Selection within angular and energy limits
-    if(((phig-phi)> fPhiMinCut) && ((phig-phi)<fPhiMaxCut) && pt > fMinPtPion){
+    if(((phig-phi)> GetDeltaPhiMinCut()) && ((phig-phi)<GetDeltaPhiMaxCut()) && pt > GetMinPtHadron()){
       AliDebug(2,Form("Selected: pt %f, phi %f",pt,phi));
       fhCorrelationGammaCharged->Fill(ptg,rat);
     } 
@@ -454,190 +278,84 @@ void  AliAnaGammaHadron::MakeGammaChargedCorrelation(TClonesArray * pl, TParticl
 }
 
 //____________________________________________________________________________
-void  AliAnaGammaHadron::MakeGammaNeutralCorrelation(TClonesArray * pl, TParticle * pGamma)  
+void  AliAnaGammaHadron::MakeGammaNeutralCorrelation(TParticle * pGamma, TClonesArray * pl)  
 {  
+  //Gamma Neutral Hadron Correlation Analysis
+  AliDebug(2,"Make gamma-neutral hadron correlation");
 
-  //Search for the neutral pion with highest with 
-  //Phi=Phi_gamma-Pi and pT=0.1E_gamma 
   Double_t pt = -100.;
   Double_t rat = -100.; 
   Double_t phi = -100. ;
   Double_t ptg  = pGamma->Pt();
   Double_t phig = pGamma->Phi();
-
-  TIter next(pl);
-  TParticle * particle = 0;
   
+  TIter next(pl);
+  TParticle * particlei = 0;
+  TParticle * particlej = 0;
+  TLorentzVector gammai;
+  TLorentzVector gammaj;
+
   Int_t iPrimary = -1;
-  TLorentzVector gammai,gammaj;
-  Double_t angle = 0., e = 0., invmass = 0.;
   Int_t ksPdg = 0;
   Int_t jPrimary=-1;
-
-  while ( (particle = (TParticle*)next()) ) {
+  
+  while ( (particlei = (TParticle*)next()) ) {
     iPrimary++;          
-    ksPdg = particle->GetPdgCode();
-
+    ksPdg = particlei->GetPdgCode();
+    AliDebug(2, Form("neutral particles opposite to gamma: pt %f, pdg %d", particlei->Pt(),ksPdg));
     //2 gamma overlapped, found with PID
     if(ksPdg == 111){ 
-      pt  = particle->Pt();
+      pt  = particlei->Pt();
       rat = pt/ptg ;
-      phi = particle->Phi() ;
-      fhEtaCharged->Fill(ptg,particle->Eta());
-      fhPhiCharged->Fill(ptg,phi);
-      fhDeltaEtaGammaCharged->Fill(ptg,pGamma->Eta()-particle->Eta());
-      fhDeltaPhiGammaCharged->Fill(ptg,phig-phi);
-      //AliDebug(3,Form("pt %f, phi %f",pt,phi));
-      if (GetPrintInfo())
-       AliInfo(Form("pt %f, phi %f",pt,phi));
+      phi = particlei->Phi() ;
+      fhEtaNeutral->Fill(ptg,particlei->Eta());
+      fhPhiNeutral->Fill(ptg,phi);
+      fhDeltaEtaGammaNeutral->Fill(ptg,pGamma->Eta()-particlei->Eta());
+      fhDeltaPhiGammaNeutral->Fill(ptg,phig-phi);
+      
       //Selection within angular and energy limits
-      if((pt> ptg)&& ((phig-phi)>fPhiMinCut)&&((phig-phi)<fPhiMaxCut)){
+      if( (phig-phi)>GetDeltaPhiMinCut() && (phig-phi)<GetDeltaPhiMaxCut() && pt > GetMinPtHadron()){
        fhCorrelationGammaNeutral ->Fill(ptg,rat);
-       //AliDebug(2,Form("Selected: pt %f, phi %f",pt,phi));
-       if (GetPrintInfo())
-         AliInfo(Form("Selected: pt %f, phi %f",pt,phi));
+       AliDebug(2,Form("Selected pi0: pt %f, phi %f",pt,phi));
       }// cuts
     }// pdg = 111
 
     //Make invariant mass analysis
-    else if(ksPdg == 22){
+    else if(ksPdg == 22){//  gamma i
+      
       //Search the photon companion in case it comes from  a Pi0 decay
-      //Apply several cuts to select the good pair
-      particle->Momentum(gammai);
-      jPrimary=-1;
+      //Apply several cuts to select the good pair;
+      particlei->Momentum(gammai);
+       jPrimary=-1;
       TIter next2(pl);
-      while ( (particle = (TParticle*)next2()) ) {
-       jPrimary++;
-       if(jPrimary>iPrimary){
-         ksPdg = particle->GetPdgCode();
-
-         if(ksPdg == 22){
-           particle->Momentum(gammaj);
-           //Info("GetLeadingPi0","Egammai %f, Egammaj %f", 
-           //gammai.Pt(),gammaj.Pt());
-           pt  = (gammai+gammaj).Pt();
+      while ( (particlej = (TParticle*)next2()) ) {
+       jPrimary++;
+       if(jPrimary>iPrimary){
+         ksPdg = particlej->GetPdgCode();
+         particlej->Momentum(gammaj);
+         if(ksPdg == 22 ){
+
            phi = (gammai+gammaj).Phi();
            if(phi < 0)
              phi+=TMath::TwoPi();
-           rat          = pt/ptg ;
-           invmass = (gammai+gammaj).M();
-           angle      = gammaj.Angle(gammai.Vect());
-           e             = (gammai+gammaj).E();
+           rat          = (gammai+gammaj).Pt()/ptg ;
+                   
+           //Fill histograms
            fhEtaNeutral->Fill(ptg,(gammai+gammaj).Eta());
            fhPhiNeutral->Fill(ptg,phi);
            fhDeltaEtaGammaNeutral->Fill(ptg,pGamma->Eta()-(gammai+gammaj).Eta());
            fhDeltaPhiGammaNeutral->Fill(ptg,phig-phi);
-           // AliDebug(3,Form("pt %f, phi %f",pt,phi));
-           if (GetPrintInfo())
-             AliInfo(Form("pt %f, phi %f",pt,phi));
-
-           //Fill histograms with no cuts applied.
-           fhAnglePairNoCut->Fill(e,angle);
-           fhInvMassPairNoCut->Fill(ptg,invmass);
-
-           //First cut on the energy and azimuth of the pair
-           if((phig-phi) > fPhiMinCut && (phig-phi) < fPhiMaxCut 
-              && pt > fMinPtPion){
-             fhAnglePairAzimuthCut     ->Fill(e,angle);
-             fhInvMassPairAzimuthCut->Fill(ptg,invmass);
-             AliDebug(3,Form("1st cut: pt %f, phi %f",pt,phi));
-
-             //Second cut on the aperture of the pair
-             if(IsAngleInWindow(angle,e)){
-               fhAnglePairOpeningAngleCut     ->Fill(e,angle);
-               fhInvMassPairOpeningAngleCut->Fill(ptg,invmass);
-                AliDebug(3,Form("2nd cut: pt %f, phi %f",pt,phi));
-
-               //Third cut on the invariant mass of the pair
-               if((invmass>fInvMassMinCut) && (invmass<fInvMassMaxCut)){ 
-                 fhInvMassPairAllCut  ->Fill(ptg,invmass);
-                 fhAnglePairAllCut       ->Fill(e,angle);
-                 //Fill correlation histogram
-                 fhCorrelationGammaNeutral ->Fill(ptg,rat);
-                 //AliDebug(2,Form("Selected: pt %f, phi %f",pt,phi));
-                 if (GetPrintInfo())
-                   AliInfo(Form("Selected: pt %f, phi %f",pt,phi));
-               }//(invmass>0.125) && (invmass<0.145)
-             }//Opening angle cut
-           }//Azimuth and pt cut.
-         }//if pdg = 22
-       }//iprimary<jprimary
+
+           //Select good pair (good phit, pt cuts, aperture and invariant mass)
+           if(GetNeutralMesonSelection()->SelectPair(pGamma, gammai, gammaj)){
+             AliDebug(2,Form("Selected gamma pair: pt %f, phi %f",(gammai+gammaj).Pt(),phi));
+             //correlation histogram
+             fhCorrelationGammaNeutral ->Fill(ptg,rat);
+           }//pair selection
+         }//if pair of gammas
+       }//jPrimary>iPrimary
       }//while
     }// if pdg = 22
   }//while
-}
-
-  //____________________________________________________________________________
-void AliAnaGammaHadron::InitParameters()
-{
-  // Initialisation of branch container 
-  //AliAnaGammaDirect::InitParameters();
-  //Initialize the parameters of the analysis.
-  //fCalorimeter="PHOS";
-  fAngleMaxParam.Set(4) ;
-  fAngleMaxParam.AddAt(0.4,0);//={0.4,-0.25,0.025,-2e-4};
-  fAngleMaxParam.AddAt(-0.25,1) ;
-  fAngleMaxParam.AddAt(0.025,2) ;
-  fAngleMaxParam.AddAt(-2e-4,3) ;
-
-  //fPrintInfo           = kTRUE;
-  fInvMassMaxCut  = 0.16 ;
-  fInvMassMinCut  = 0.11 ;
-  fPhiMaxCut      = 4.5;
-  fPhiMinCut      = 1.5 ;
-
-  fMinPtPion = 0.   ;
-
-  //Fill particle lists when PID is ok
-  // fEMCALPID = kFALSE;
-  // fPHOSPID = kFALSE;
-
-}
-
-//__________________________________________________________________________-
-Bool_t AliAnaGammaHadron::IsAngleInWindow(const Float_t angle,const Float_t e) {
-  //Check if the opening angle of the candidate pairs is inside 
-  //our selection windowd
-
-  Bool_t result = kFALSE;
-  Double_t mpi0 = 0.1349766;
-  Double_t max =  fAngleMaxParam.At(0)*TMath::Exp(fAngleMaxParam.At(1)*e)
-    +fAngleMaxParam.At(2)+fAngleMaxParam.At(3)*e;
-  Double_t arg = (e*e-2*mpi0*mpi0)/(e*e);
-  Double_t min = 100. ;
-  if(arg>0.)
-    min = TMath::ACos(arg);
-
-  if((angle<max)&&(angle>=min))
-    result = kTRUE;
-  return result;
-}
-
-//____________________________________________________________________________
-void AliAnaGammaHadron::Print(const Option_t * opt) const
-{
-
-  //Print some relevant parameters set for the analysis
-  if(! opt)
-    return;
-
-  Info("Print", "%s %s", GetName(), GetTitle() ) ;
-  printf("pT Pion       >    %f\n", fMinPtPion) ; 
-  printf("Phi Pion      <     %f\n", fPhiMaxCut) ; 
-  printf("Phi Pion      >     %f\n", fPhiMinCut) ;
-  printf("M_pair        <     %f\n", fInvMassMaxCut) ; 
-  printf("M_pair        >     %f\n", fInvMassMinCut) ; 
-} 
-
-//__________________________________________
-void AliAnaGammaHadron::Terminate(Option_t *)
-{
-   // The Terminate() function is the last function to be called during
-   // a query. It always runs on the client, it can be used to present
-   // the results graphically or save the results to file.
-    
-
+  
 }
index 3575bbeeec3c5ff51552348ba59f743931172373..ce5358e62d85dbaff2baeb8a05ac3834766bd47b 100644 (file)
@@ -7,88 +7,40 @@
 /* History of cvs commits:
  *
  * $Log$
- * Revision 1.2  2007/02/09 18:40:40  schutz
- * B\bNew version from Gustavo
- *
- * Revision 1.1  2007/01/23 17:17:29  schutz
- * New Gamma package
+ * Revision 1.3.4.2  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
  *
  *
  */
 
 //_________________________________________________________________________
-//  Class for the analysis of gamma-jet correlations.     
-//  Basically it seaches for a prompt photon in the Calorimeters acceptance, 
-//  if so we construct a jet around the highest pt particle in the opposite 
-//  side in azimuth. This jet has to fullfill several conditions to be 
-//  accepted. Then the fragmentation function of this jet is constructed 
-//  Class created from old AliPHOSGammaPion
-
+// Class that contains the algorithm for the analysis of gamma - hadron correlations
 //*-- Author: Gustavo Conesa (INFN-LNF)
 
-// --- ROOT system ---
-#include <TROOT.h>
-#include <TChain.h>
-#include "TTask.h"
-#include "TArrayD.h"
-#include "TChain.h"
-#include <TH2F.h>
-#include <TTree.h> 
-#include "AliAnaGammaDirect.h" 
+#include "AliAnaGammaCorrelation.h"
 
-class AliESD ; 
-class AliAnaGammaHadron : public AliAnaGammaDirect {
+class AliAnaGammaHadron : public AliAnaGammaCorrelation {
 
 public: 
-
-  AliAnaGammaHadron(const char *name) ; // default ctor
-  AliAnaGammaHadron(const AliAnaGammaHadron & gj) ; // cpy ctor
+  
+  AliAnaGammaHadron() ; // default ctor
+  AliAnaGammaHadron(const AliAnaGammaHadron & g) ; // cpy ctor
   AliAnaGammaHadron & operator = (const AliAnaGammaHadron & g) ;//cpy assignment
   virtual ~AliAnaGammaHadron() ; //virtual dtor
 
-  virtual void Exec(Option_t * opt = "") ;
-  virtual void ConnectInputData(Option_t *);
-  virtual void CreateOutputObjects();
-  virtual void Terminate(Option_t * opt = "");
-
-  void InitParameters(); 
-  Double_t GetAngleMaxParam(Int_t i) const {return fAngleMaxParam.At(i) ; }
-  Double_t GetInvMassMaxCut() const {return fInvMassMaxCut ; }
-  Double_t GetInvMassMinCut() const {return fInvMassMinCut ; }
-  Double_t GetPhiMaxCut() const {return fPhiMaxCut ; }
-  Double_t GetPhiMinCut() const {return fPhiMinCut ; }
-  Float_t    GetMinPtPion() const {return fMinPtPion ; }
+  TList * GetCreateOutputObjects();
 
-  void Print(const Option_t * opt)const;
-  
-  void SetAngleMaxParam(Int_t i, Double_t par)
-  {fAngleMaxParam.AddAt(par,i) ; }
-  void SetMinPtPion(Float_t pt){fMinPtPion = pt; };
-  void SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
-    {fInvMassMaxCut =invmassmax;  fInvMassMinCut =invmassmin;} 
-  void SetPhiCutRange(Double_t phimin, Double_t phimax)
-  {fPhiMaxCut =phimax;  fPhiMinCut =phimin;}
+  void InitParameters();
 
-  private:
-
-  Bool_t IsAngleInWindow(const Float_t angle, const Float_t e);
-  void MakeGammaChargedCorrelation(TClonesArray * pl, TParticle *pGamma) const ;
-  void MakeGammaNeutralCorrelation(TClonesArray * pl, TParticle *pGamma)  ;
-
- private:
-
-  Double_t   fPhiMaxCut ;      // 
-  Double_t   fPhiMinCut ;      // 
-  Double_t   fInvMassMaxCut ;  // Invariant Mass cut maximum
-  Double_t   fInvMassMinCut ;  // Invariant Masscut minimun
+  void Print(const Option_t * opt) const;
  
-  Double_t   fMinPtPion;       // Minimum pt of pion
-  TObjArray  *fOutputContainer ; //! output data container
-  TArrayD    fAngleMaxParam ; //Max opening angle selection parameters
+  void MakeGammaCorrelation(TParticle *pGamma, TClonesArray * plCTS,   TClonesArray * plNe) ;
+  void MakeGammaChargedCorrelation(TParticle *pGamma, TClonesArray * pl) ;
+  void MakeGammaNeutralCorrelation(TParticle *pGamma, TClonesArray * pl)  ;
 
+  private:
+  
   //Histograms
-
   TH2F * fhPhiCharged  ; 
   TH2F * fhPhiNeutral   ; 
   TH2F * fhEtaCharged  ; 
@@ -98,18 +50,8 @@ public:
   TH2F * fhDeltaEtaGammaCharged  ; 
   TH2F * fhDeltaEtaGammaNeutral  ; 
 
-  TH2F * fhCorrelationGammaNeutral  ; 
-  TH2F * fhCorrelationGammaCharged  ; 
-
-  TH2F * fhAnglePairAccepted  ; 
-  TH2F * fhAnglePairNoCut  ; 
-  TH2F * fhAnglePairAzimuthCut  ; 
-  TH2F * fhAnglePairOpeningAngleCut   ; 
-  TH2F * fhAnglePairAllCut   ; 
-  TH2F * fhInvMassPairNoCut    ; 
-  TH2F * fhInvMassPairAzimuthCut  ; 
-  TH2F * fhInvMassPairOpeningAngleCut  ; 
-  TH2F * fhInvMassPairAllCut   ; 
+  TH2F * fhCorrelationGammaNeutral  ; //Neutral hadron correlation histogram 
+  TH2F * fhCorrelationGammaCharged  ; //Charged hadron correlation histogram
   
   ClassDef(AliAnaGammaHadron,0)
 } ;
diff --git a/PWG4/AliAnaGammaJetFinder.cxx b/PWG4/AliAnaGammaJetFinder.cxx
new file mode 100644 (file)
index 0000000..ae895c5
--- /dev/null
@@ -0,0 +1,164 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for the analysis of gamma-jet (standard jet finder) correlations
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+#include "Riostream.h"
+
+//---- AliRoot system ----
+#include "AliAnaGammaJetFinder.h" 
+#include "AliLog.h"
+  
+  ClassImp(AliAnaGammaJetFinder)
+  
+
+//____________________________________________________________________________
+  AliAnaGammaJetFinder::AliAnaGammaJetFinder() : 
+    AliAnaGammaCorrelation(),   
+    fhDeltaEtaJet(0), fhDeltaPhiJet(0), 
+    fhDeltaPtJet(0), fhPtRatJet(0)
+{
+  //Default Ctor
+
+  SetCorrelationType(kJetFinder);
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliAnaGammaJetFinder::AliAnaGammaJetFinder(const AliAnaGammaJetFinder & g) :   
+  AliAnaGammaCorrelation(g),   
+  fhDeltaEtaJet(g.fhDeltaEtaJet), fhDeltaPhiJet(g.fhDeltaPhiJet), 
+  fhDeltaPtJet(g.fhDeltaPtJet), fhPtRatJet(g.fhPtRatJet)
+{
+  // cpy ctor
+
+}
+
+//_________________________________________________________________________
+AliAnaGammaJetFinder & AliAnaGammaJetFinder::operator = (const AliAnaGammaJetFinder & source)
+{
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((AliAnaGammaCorrelation *)this)->operator=(source);
+  fhDeltaEtaJet = source.fhDeltaEtaJet;
+  fhDeltaPhiJet = source.fhDeltaPhiJet;
+  fhDeltaPtJet = source.fhDeltaPtJet;
+  fhPtRatJet = source.fhPtRatJet;
+  
+  return *this;
+
+}
+
+//____________________________________________________________________________
+AliAnaGammaJetFinder::~AliAnaGammaJetFinder() 
+{
+  delete fhDeltaEtaJet ;
+  delete fhDeltaPhiJet ;
+  delete fhDeltaPtJet ;
+  delete fhPtRatJet ;
+}
+
+
+//________________________________________________________________________
+TList *  AliAnaGammaJetFinder::GetCreateOutputObjects()
+{  
+  // Create histograms to be saved in output file and 
+  // store them in fOutputContainer
+
+  AliDebug(1,"Init jet histograms");
+
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("GammaJetHistos") ; 
+
+  //---kJet---
+  fhDeltaPhiJet  = new TH2F
+    ("DeltaPhiJet","#phi_{#gamma} - #phi_{jet} vs p_{T #gamma}",
+     200,0,120,200,0,6.4); 
+  fhDeltaPhiJet->SetYTitle("#Delta #phi");
+  fhDeltaPhiJet->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhDeltaPhiJet);
+
+  fhDeltaEtaJet  = new TH2F
+    ("DeltaEtaJet","#eta_{#gamma} - #eta_{jet} vs p_{T #gamma}",
+     200,0,120,200,-2,2); 
+  fhDeltaEtaJet->SetYTitle("#Delta #eta");
+  fhDeltaEtaJet->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhDeltaEtaJet);
+
+  fhDeltaPtJet  = new TH2F
+    ("DeltaPtJet","#p_{T #gamma} - #p_{T jet} vs p_{T #gamma}",
+     200,0,120,100,-10,10); 
+  fhDeltaPtJet->SetYTitle("#Delta #p_{T}");
+  fhDeltaPtJet->SetXTitle("p_{T #gamma} (GeV/c)"); 
+  outputContainer->Add(fhDeltaPtJet);
+
+  fhPtRatJet  = new TH2F
+    ("PtRatJet","#p_{T jet} / #p_{T #gamma} vs p_{T #gamma}",
+     200,0,120,200,0,5); 
+  fhPtRatJet->SetYTitle("ratio");
+  fhPtRatJet->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhPtRatJet);
+
+  SetOutputContainer(outputContainer);
+
+  return outputContainer;
+}
+
+ //____________________________________________________________________________
+void AliAnaGammaJetFinder::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+
+  ;
+
+}
+
+//__________________________________________________________________
+void AliAnaGammaJetFinder::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+} 
+
+//__________________________________________________________________
+void  AliAnaGammaJetFinder::MakeGammaCorrelation(TParticle * pGamma, TClonesArray *pl, TClonesArray *) 
+{
+  //Gamma -Jet  Correlation Analysis
+  AliDebug(2, "Begin jet analysis");
+  AliInfo("Not implemented");  
+} 
diff --git a/PWG4/AliAnaGammaJetFinder.h b/PWG4/AliAnaGammaJetFinder.h
new file mode 100644 (file)
index 0000000..fcf6657
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef ALIANAGAMMAJETFINDER_H
+#define ALIANAGAMMAJETFINDER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class that contains the algorithm for the analysis of gamma-jet (standard finder) correlation 
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+#include "AliAnaGammaCorrelation.h"
+     
+class AliAnaGammaJetFinder : public AliAnaGammaCorrelation {
+       
+  public: 
+       
+       AliAnaGammaJetFinder() ; // default ctor
+       AliAnaGammaJetFinder(const AliAnaGammaJetFinder & g) ; // cpy ctor
+       AliAnaGammaJetFinder & operator = (const AliAnaGammaJetFinder & g) ;//cpy assignment
+       virtual ~AliAnaGammaJetFinder() ; //virtual dtor
+              
+       TList * GetCreateOutputObjects();
+       
+       void InitParameters();
+       
+       void Print(const Option_t * opt) const;
+       
+       void MakeGammaCorrelation( TParticle * pGamma, TClonesArray *pl, TClonesArray *)  ;
+       
+  private:
+       
+       TH2F * fhDeltaEtaJet;
+       TH2F * fhDeltaPhiJet;
+       TH2F * fhDeltaPtJet;
+       TH2F * fhPtRatJet;
+       
+       ClassDef(AliAnaGammaJetFinder,0)
+ } ;
+
+
+#endif //ALIANAGAMMAJETFINDER_H
+
+
+
diff --git a/PWG4/AliAnaGammaJetLeadCone.cxx b/PWG4/AliAnaGammaJetLeadCone.cxx
new file mode 100644 (file)
index 0000000..1aa58b8
--- /dev/null
@@ -0,0 +1,1232 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for the analysis of gamma-jet correlations, jet reconstructed in cone around leading
+//
+//  Class created from old AliPHOSGammaJet 
+//  (see AliRoot versions previous Release 4-09)
+//
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+#include "Riostream.h"
+
+//---- AliRoot system ----
+#include "AliLog.h"
+#include "AliNeutralMesonSelection.h"
+#include "AliAnaGammaJetLeadCone.h"  
+
+ClassImp(AliAnaGammaJetLeadCone)
+
+
+//____________________________________________________________________________
+  AliAnaGammaJetLeadCone::AliAnaGammaJetLeadCone() : 
+    AliAnaGammaCorrelation(),  fPbPb(kFALSE),     
+    fSeveralConeAndPtCuts(0),  
+    fEtaEMCALCut(0.),
+    fJetCTSRatioMaxCut(0.), fJetCTSRatioMinCut(0.), fJetRatioMaxCut(0.),
+    fJetRatioMinCut(0.), 
+    fJetNCone(0),fJetNPt(0), fJetCone(0), 
+    fJetPtThreshold(0),fJetPtThresPbPb(0),
+    fPtJetSelectionCut(0.0), fSelect(0),
+    fhPhiCharged(0), fhPhiNeutral(0), fhEtaCharged(0), fhEtaNeutral(0), 
+    fhDeltaPhiGammaCharged(0),  fhDeltaPhiGammaNeutral(0), 
+    fhDeltaEtaGammaCharged(0), fhDeltaEtaGammaNeutral(0), 
+    fhAnglePairLeading(), fhInvMassPairLeading(), 
+    fhChargedRatio(0), fhNeutralRatio (0), 
+    fhNBkg (0), fhNLeading(0), fhNJet(0), fhJetRatio(0), fhJetPt (0), 
+    fhBkgRatio (0), fhBkgPt(0),  fhJetFragment(0), fhBkgFragment(0), 
+    fhJetPtDist(0),  fhBkgPtDist(0) 
+{
+  //Default Ctor
+
+  //Initialize parameters
+
+  SetCorrelationType(kJetLeadCone);
+
+  for(Int_t i = 0; i<10; i++){
+    fJetCones[i]         = 0.0 ;
+    fJetNameCones[i]     = ""  ;
+    fJetPtThres[i]      = 0.0 ;
+    fJetNamePtThres[i]  = ""  ;
+    if( i < 6 ){
+      fJetXMin1[i]     = 0.0 ;
+      fJetXMin2[i]     = 0.0 ;
+      fJetXMax1[i]     = 0.0 ;
+      fJetXMax2[i]     = 0.0 ;
+      fBkgMean[i]      = 0.0 ;
+      fBkgRMS[i]       = 0.0 ;
+      if( i < 2 ){
+       fJetE1[i]        = 0.0 ;
+       fJetE2[i]        = 0.0 ;
+       fJetSigma1[i]    = 0.0 ;
+       fJetSigma2[i]    = 0.0 ;
+       fPhiEMCALCut[i]  = 0.0 ;
+      }
+    }
+  }
+
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliAnaGammaJetLeadCone::AliAnaGammaJetLeadCone(const AliAnaGammaJetLeadCone & g) :   
+  AliAnaGammaCorrelation(g), fPbPb(g.fPbPb), 
+  fSeveralConeAndPtCuts(g.fSeveralConeAndPtCuts), 
+  fEtaEMCALCut(g.fEtaEMCALCut),
+  fJetCTSRatioMaxCut(g.fJetCTSRatioMaxCut),
+  fJetCTSRatioMinCut(g.fJetCTSRatioMinCut), fJetRatioMaxCut(g.fJetRatioMaxCut),
+  fJetRatioMinCut(g.fJetRatioMinCut),  fJetNCone(g.fJetNCone),
+  fJetNPt(g.fJetNPt), fJetCone(g.fJetCone),
+  fJetPtThreshold(g.fJetPtThreshold),fJetPtThresPbPb(g.fJetPtThresPbPb),
+  fPtJetSelectionCut(g.fPtJetSelectionCut), fSelect(g.fSelect),  
+  fhPhiCharged(g.fhPhiCharged), fhPhiNeutral(g.fhPhiNeutral), 
+  fhEtaCharged(g.fhEtaCharged), fhEtaNeutral(g.fhEtaNeutral), 
+  fhDeltaPhiGammaCharged(g.fhDeltaPhiGammaCharged),  
+  fhDeltaPhiGammaNeutral(g.fhDeltaPhiGammaNeutral), 
+  fhDeltaEtaGammaCharged(g.fhDeltaEtaGammaCharged), 
+  fhDeltaEtaGammaNeutral(g.fhDeltaEtaGammaNeutral), 
+  fhAnglePairLeading(g.fhAnglePairLeading), fhInvMassPairLeading(g.fhInvMassPairLeading), 
+  fhChargedRatio(g.fhChargedRatio), fhNeutralRatio(g.fhNeutralRatio), 
+  fhNBkg(g. fhNBkg), fhNLeading(g. fhNLeading), fhNJet(g.fhNJet), fhJetRatio(g.fhJetRatio), fhJetPt(g.fhJetPt), 
+  fhBkgRatio (g.fhBkgRatio), fhBkgPt(g.fhBkgPt),  fhJetFragment(g.fhJetFragment), fhBkgFragment(g.fhBkgFragment), 
+  fhJetPtDist(g.fhJetPtDist),  fhBkgPtDist(g.fhBkgPtDist)   
+{
+  // cpy ctor
+
+  for(Int_t i = 0; i<10; i++){
+    fJetCones[i]        = g.fJetCones[i] ;
+    fJetNameCones[i]    = g.fJetNameCones[i] ;
+    fJetPtThres[i]      = g.fJetPtThres[i] ;
+    fJetNamePtThres[i]  = g.fJetNamePtThres[i] ;
+    if( i < 6 ){
+      fJetXMin1[i]       = g.fJetXMin1[i] ;
+      fJetXMin2[i]       = g.fJetXMin2[i] ;
+      fJetXMax1[i]       = g.fJetXMax1[i] ;
+      fJetXMax2[i]       = g.fJetXMax2[i] ;
+      fBkgMean[i]        = g.fBkgMean[i] ;
+      fBkgRMS[i]         = g.fBkgRMS[i] ;
+      if( i < 2 ){
+       fJetE1[i]        = g.fJetE1[i] ;
+       fJetE2[i]        = g.fJetE2[i] ;
+       fJetSigma1[i]    = g.fJetSigma1[i] ;
+       fJetSigma2[i]    = g.fJetSigma2[i] ;
+       fPhiEMCALCut[i]  = g.fPhiEMCALCut[i] ;
+      }
+    }          
+  } 
+
+  
+}
+
+//_________________________________________________________________________
+AliAnaGammaJetLeadCone & AliAnaGammaJetLeadCone::operator = (const AliAnaGammaJetLeadCone & source)
+{
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((AliAnaGammaCorrelation *)this)->operator=(source);
+
+  fSeveralConeAndPtCuts = source.fSeveralConeAndPtCuts ; 
+  fPbPb = source.fPbPb ;
+  fEtaEMCALCut = source.fEtaEMCALCut ;
+  fJetCTSRatioMaxCut = source.fJetCTSRatioMaxCut ;
+  fJetCTSRatioMinCut = source.fJetCTSRatioMinCut ; fJetRatioMaxCut = source.fJetRatioMaxCut ;
+  fJetRatioMinCut = source.fJetRatioMinCut ;  fJetNCone = source.fJetNCone ;
+  fJetNPt = source.fJetNPt ; fJetCone = source.fJetCone ; 
+  fJetPtThreshold = source.fJetPtThreshold ;
+  fJetPtThresPbPb = source.fJetPtThresPbPb ;
+  fPtJetSelectionCut = source.fPtJetSelectionCut ;
+  fSelect = source.fSelect ;  fhChargedRatio = source.fhChargedRatio ; fhNeutralRatio = source.fhNeutralRatio ; 
+
+  fhPhiCharged = source.fhPhiCharged ; fhPhiNeutral = source.fhPhiNeutral ; 
+  fhEtaCharged = source.fhEtaCharged ; fhEtaNeutral = source.fhEtaNeutral ; 
+  fhDeltaPhiGammaCharged = source.fhDeltaPhiGammaCharged ;  
+  fhDeltaPhiGammaNeutral = source.fhDeltaPhiGammaNeutral ; 
+  fhDeltaEtaGammaCharged = source.fhDeltaEtaGammaCharged ; 
+  fhDeltaEtaGammaNeutral = source.fhDeltaEtaGammaNeutral ; 
+  
+  fhAnglePairLeading = source.fhAnglePairLeading ; 
+  fhInvMassPairLeading = source.fhInvMassPairLeading ; 
+  fhNBkg = source. fhNBkg ; fhNLeading = source. fhNLeading ; 
+  fhNJet = source.fhNJet ; fhJetRatio = source.fhJetRatio ; fhJetPt = source.fhJetPt ; 
+  fhBkgRatio  = source.fhBkgRatio ; fhBkgPt = source.fhBkgPt ;  
+  fhJetFragment = source.fhJetFragment ; fhBkgFragment = source.fhBkgFragment ; 
+  fhJetPtDist = source.fhJetPtDist ;  fhBkgPtDist = source.fhBkgPtDist ;
+
+
+  for(Int_t i = 0; i<10; i++){
+    fJetCones[i]        = source.fJetCones[i] ;
+    fJetNameCones[i]    = source.fJetNameCones[i] ;
+    fJetPtThres[i]      = source.fJetPtThres[i] ;
+    fJetNamePtThres[i]  = source.fJetNamePtThres[i] ;
+    if( i < 6 ){
+      fJetXMin1[i]       = source.fJetXMin1[i] ;
+      fJetXMin2[i]       = source.fJetXMin2[i] ;
+      fJetXMax1[i]       = source.fJetXMax1[i] ;
+      fJetXMax2[i]       = source.fJetXMax2[i] ;
+      fBkgMean[i]        = source.fBkgMean[i] ;
+      fBkgRMS[i]         = source.fBkgRMS[i] ;
+      if( i < 2 ){
+       fJetE1[i]        = source.fJetE1[i] ;
+       fJetE2[i]        = source.fJetE2[i] ;
+       fJetSigma1[i]    = source.fJetSigma1[i] ;
+       fJetSigma2[i]    = source.fJetSigma2[i] ;
+       fPhiEMCALCut[i]  = source.fPhiEMCALCut[i] ;
+      }
+    }          
+  } 
+
+  return *this;
+
+}
+
+//____________________________________________________________________________
+AliAnaGammaJetLeadCone::~AliAnaGammaJetLeadCone() 
+{
+  delete fhChargedRatio  ; 
+  delete fhNeutralRatio   ; 
+
+  delete fhPhiCharged  ;  
+  delete fhPhiNeutral   ; 
+  delete fhEtaCharged  ; 
+  delete fhEtaNeutral  ; 
+  delete fhDeltaPhiGammaCharged  ;  
+  delete fhDeltaPhiGammaNeutral   ; 
+  delete fhDeltaEtaGammaCharged  ; 
+  delete fhDeltaEtaGammaNeutral  ; 
+  
+  delete fhAnglePairLeading  ; 
+  delete fhInvMassPairLeading  ; 
+  delete fhNBkg   ; 
+  delete fhNLeading  ; 
+  delete fhNJet  ; 
+  delete fhJetRatio  ; 
+  delete fhJetPt   ; 
+  delete fhBkgRatio   ; 
+  delete fhBkgPt  ; 
+  delete fhJetFragment  ; 
+  delete fhBkgFragment  ; 
+  delete fhJetPtDist  ; 
+  delete fhBkgPtDist  ; 
+  
+  delete [] fhJetRatios;  
+  delete [] fhJetPts;  
+  delete [] fhBkgRatios;
+  delete [] fhBkgPts;  
+
+  delete [] fhNLeadings;
+  delete [] fhNJets;  
+  delete [] fhNBkgs;
+  
+  delete [] fhJetFragments;
+  delete [] fhBkgFragments;
+  delete [] fhJetPtDists;
+  delete [] fhBkgPtDists;
+}
+
+
+
+//________________________________________________________________________
+TList *  AliAnaGammaJetLeadCone::GetCreateOutputObjects()
+{  
+  // Create histograms to be saved in output file and 
+  // store them in fOutputContainer
+  AliDebug(1,"Init jet in leading cone histograms");
+  
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("GammaJetCorrelationHistos") ; 
+
+  fhChargedRatio  = new TH2F
+    ("ChargedRatio","p_{T leading charge} /p_{T #gamma} vs p_{T #gamma}",
+     120,0,120,120,0,1); 
+  fhChargedRatio->SetYTitle("p_{T lead charge} /p_{T #gamma}");
+  fhChargedRatio->SetXTitle("p_{T #gamma} (GeV/c)");
+  
+  fhPhiCharged  = new TH2F
+    ("PhiCharged","#phi_{#pi^{#pm}}  vs p_{T #gamma}",
+     120,0,120,120,0,7); 
+  fhPhiCharged->SetYTitle("#phi_{#pi^{#pm}} (rad)");
+  fhPhiCharged->SetXTitle("p_{T #gamma} (GeV/c)");
+  
+  fhEtaCharged  = new TH2F
+    ("EtaCharged","#eta_{#pi^{#pm}}  vs p_{T #gamma}",
+     120,0,120,120,-1,1); 
+  fhEtaCharged->SetYTitle("#eta_{#pi^{#pm}} (rad)");
+  fhEtaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
+  
+  fhDeltaPhiGammaCharged  = new TH2F
+    ("DeltaPhiGammaCharged","#phi_{#gamma} - #phi_{charged #pi} vs p_{T #gamma}",
+     200,0,120,200,0,6.4); 
+  fhDeltaPhiGammaCharged->SetYTitle("#Delta #phi");
+  fhDeltaPhiGammaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
+  
+  fhDeltaEtaGammaCharged  = new TH2F
+    ("DeltaEtaGammaCharged","#eta_{#gamma} - #eta_{#pi^{#pm}} vs p_{T #gamma}",
+     200,0,120,200,-2,2); 
+  fhDeltaEtaGammaCharged->SetYTitle("#Delta #eta");
+  fhDeltaEtaGammaCharged->SetXTitle("p_{T #gamma} (GeV/c)");
+  
+  outputContainer->Add(fhPhiCharged) ;
+  outputContainer->Add(fhEtaCharged) ;
+  outputContainer->Add(fhChargedRatio) ;
+  outputContainer->Add(fhDeltaPhiGammaCharged) ; 
+  outputContainer->Add(fhDeltaEtaGammaCharged) ; 
+
+  if(!AreJetsOnlyInCTS()){
+    
+    fhNeutralRatio  = new TH2F
+      ("NeutralRatio","p_{T leading  #pi^{0}} /p_{T #gamma} vs p_{T #gamma}",
+       120,0,120,120,0,1); 
+    fhNeutralRatio->SetYTitle("p_{T lead  #pi^{0}} /p_{T #gamma}");
+    fhNeutralRatio->SetXTitle("p_{T #gamma} (GeV/c)");
+    
+    //
+    fhAnglePairLeading  = new TH2F
+      ("AnglePairLeading",
+       "Angle between all #gamma pair finally selected vs p_{T  #pi^{0}}",
+       200,0,50,200,0,0.2); 
+    fhAnglePairLeading->SetYTitle("Angle (rad)");
+    fhAnglePairLeading->SetXTitle("E_{ #pi^{0}} (GeV/c)");
+    
+    fhInvMassPairLeading  = new TH2F
+      ("InvMassPairLeading",
+       "Invariant Mass of #gamma pair selected vs p_{T #gamma}",
+       120,0,120,360,0,0.5); 
+    fhInvMassPairLeading->SetYTitle("Invariant Mass (GeV/c^{2})");
+    fhInvMassPairLeading->SetXTitle("p_{T #gamma} (GeV/c)");
+
+    fhPhiNeutral  = new TH2F
+      ("PhiNeutral","#phi_{#pi^{0}}  vs p_{T #gamma}",
+       120,0,120,120,0,7); 
+    fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
+    fhPhiNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
+    
+    fhEtaNeutral  = new TH2F
+      ("EtaNeutral","#eta_{#pi^{0}}  vs p_{T #gamma}",
+       120,0,120,120,-1,1); 
+    fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
+    fhEtaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
+    
+    fhDeltaPhiGammaNeutral  = new TH2F
+      ("DeltaPhiGammaNeutral","#phi_{#gamma} - #phi_{#pi^{0}} vs p_{T #gamma}",
+       200,0,120,200,0,6.4); 
+    fhDeltaPhiGammaNeutral->SetYTitle("#Delta #phi");
+    fhDeltaPhiGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
+    
+    fhDeltaEtaGammaNeutral  = new TH2F
+      ("DeltaEtaGammaNeutral","#eta_{#gamma} - #eta_{#pi^{#pm}} vs p_{T #gamma}",
+       200,0,120,200,-2,2); 
+    fhDeltaEtaGammaNeutral->SetYTitle("#Delta #eta");
+    fhDeltaEtaGammaNeutral->SetXTitle("p_{T #gamma} (GeV/c)");
+
+    outputContainer->Add(fhPhiNeutral) ;  
+    outputContainer->Add(fhEtaNeutral) ;  
+    outputContainer->Add(fhNeutralRatio) ; 
+    outputContainer->Add(fhDeltaPhiGammaNeutral) ; 
+    outputContainer->Add(fhDeltaEtaGammaNeutral) ;
+    
+    outputContainer->Add(fhInvMassPairLeading) ; 
+    outputContainer->Add(fhAnglePairLeading) ; 
+  }
+  
+  if(!fSeveralConeAndPtCuts){// not several cones
+    
+    //Count
+    fhNBkg = new TH1F("NBkg","bkg multiplicity",9000,0,9000); 
+    fhNBkg->SetYTitle("counts");
+    fhNBkg->SetXTitle("N");
+    outputContainer->Add(fhNBkg) ; 
+    
+    fhNLeading  = new TH2F
+      ("NLeading","Accepted Jet Leading", 240,0,120,240,0,120); 
+    fhNLeading->SetYTitle("p_{T charge} (GeV/c)");
+    fhNLeading->SetXTitle("p_{T #gamma}(GeV/c)");
+    outputContainer->Add(fhNLeading) ; 
+    
+    fhNJet  = new TH1F("NJet","Accepted jets",240,0,120); 
+    fhNJet->SetYTitle("N");
+    fhNJet->SetXTitle("p_{T #gamma}(GeV/c)");
+    outputContainer->Add(fhNJet) ; 
+    
+    //Ratios and Pt dist of reconstructed (not selected) jets
+    //Jet
+    fhJetRatio  = new TH2F
+      ("JetRatio","p_{T jet lead}/p_{T #gamma} vs p_{T #gamma}",
+       240,0,120,200,0,10);
+    fhJetRatio->SetYTitle("p_{T jet lead #pi^{0}}/p_{T #gamma}");
+    fhJetRatio->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhJetRatio) ; 
+    
+    fhJetPt  = new TH2F
+      ("JetPt", "p_{T jet lead} vs p_{T #gamma}",240,0,120,400,0,200);
+    fhJetPt->SetYTitle("p_{T jet}");
+    fhJetPt->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhJetPt) ; 
+    
+    //Bkg
+    
+    fhBkgRatio  = new TH2F
+      ("BkgRatio","p_{T bkg lead}/p_{T #gamma} vs p_{T #gamma}",
+       240,0,120,200,0,10);
+    fhBkgRatio->SetYTitle("p_{T bkg lead charge}/p_{T #gamma}");
+    fhBkgRatio->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhBkgRatio) ;
+    
+    fhBkgPt  = new TH2F
+      ("BkgPt","p_{T jet lead} vs p_{T #gamma}",240,0,120,400,0,200);
+    fhBkgPt->SetYTitle("p_{T jet lead charge}/p_{T #gamma}");
+    fhBkgPt->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhBkgPt) ;
+    
+    //Jet Distributions
+    
+    fhJetFragment  = 
+      new TH2F("JetFragment","x = p_{T i charged}/p_{T #gamma}",
+              240,0.,120.,1000,0.,1.2); 
+    fhJetFragment->SetYTitle("x_{T}");
+    fhJetFragment->SetXTitle("p_{T #gamma}");
+    outputContainer->Add(fhJetFragment) ;
+    
+    fhBkgFragment  = new TH2F
+      ("BkgFragment","x = p_{T i charged}/p_{T #gamma}",
+       240,0.,120.,1000,0.,1.2);
+    fhBkgFragment->SetYTitle("x_{T}");
+    fhBkgFragment->SetXTitle("p_{T #gamma}");
+    outputContainer->Add(fhBkgFragment) ;
+    
+    fhJetPtDist  = 
+      new TH2F("JetPtDist","x = p_{T i charged}",240,0.,120.,400,0.,200.); 
+    fhJetPtDist->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhJetPtDist) ;
+    
+    fhBkgPtDist  = new TH2F
+      ("BkgPtDist","x = p_{T i charged}",240,0.,120.,400,0.,200.); 
+    fhBkgPtDist->SetXTitle("p_{T #gamma} (GeV/c)");
+    outputContainer->Add(fhBkgPtDist) ;
+    
+  }//not several cones
+  else{ //If we want to study the jet for different cones and pt
+    for(Int_t icone = 0; icone<fJetNCone; icone++){//icone
+      for(Int_t ipt = 0; ipt<fJetNPt;ipt++){ //ipt
+       
+       //Jet
+       
+       fhJetRatios[icone][ipt]  = new TH2F
+         ("JetRatioCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt], 
+          "p_{T jet lead #pi^{0}}/p_{T #gamma} vs p_{T #gamma}, cone ="
+          +fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+" GeV/c",
+          240,0,120,200,0,10);
+       fhJetRatios[icone][ipt]->
+         SetYTitle("p_{T jet lead #pi^{0}}/p_{T #gamma}");
+       fhJetRatios[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhJetRatios[icone][ipt]) ; 
+       
+       
+       fhJetPts[icone][ipt]  = new TH2F
+         ("JetPtCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt], 
+          "p_{T jet lead #pi^{0}}/p_{T #gamma} vs p_{T #gamma}, cone ="
+          +fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+" GeV/c",
+          240,0,120,400,0,200);
+       fhJetPts[icone][ipt]->
+         SetYTitle("p_{T jet lead #pi^{0}}/p_{T #gamma}");
+       fhJetPts[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhJetPts[icone][ipt]) ; 
+       
+       //Bkg
+       fhBkgRatios[icone][ipt]  = new TH2F
+         ("BkgRatioCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt], 
+          "p_{T bkg lead #pi^{0}}/p_{T #gamma} vs p_{T #gamma}, cone ="
+          +fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+" GeV/c",
+          240,0,120,200,0,10);
+       fhBkgRatios[icone][ipt]->
+         SetYTitle("p_{T bkg lead #pi^{0}}/p_{T #gamma}");
+       fhBkgRatios[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhBkgRatios[icone][ipt]) ; 
+       
+       fhBkgPts[icone][ipt]  = new TH2F
+         ("BkgPtCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt], 
+          "p_{T jet lead #pi^{0}}/p_{T #gamma} vs p_{T #gamma}, cone ="
+          +fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+" GeV/c",
+          240,0,120,400,0,200);
+       fhBkgPts[icone][ipt]->
+         SetYTitle("p_{T jet lead #pi^{0}}/p_{T #gamma}");
+       fhBkgPts[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhBkgPts[icone][ipt]) ; 
+       
+       //Counts
+       fhNBkgs[icone][ipt]  = new TH1F
+         ("NBkgCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "bkg multiplicity cone ="+fJetNameCones[icone]+", pt>" 
+          +fJetNamePtThres[ipt]+" GeV/c",9000,0,9000); 
+       fhNBkgs[icone][ipt]->SetYTitle("counts");
+       fhNBkgs[icone][ipt]->SetXTitle("N");
+       outputContainer->Add(fhNBkgs[icone][ipt]) ; 
+       
+       fhNLeadings[icone][ipt]  = new TH2F
+         ("NLeadingCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "p_{T #gamma} vs p_{T #pi^{0}} cone ="+fJetNameCones[icone]+", pt>" 
+          +fJetNamePtThres[ipt]+" GeV/c",120,0,120,120,0,120); 
+       fhNLeadings[icone][ipt]->SetYTitle("p_{T #pi^{0}}(GeV/c)");
+       fhNLeadings[icone][ipt]->SetXTitle("p_{T #gamma}(GeV/c)");
+       outputContainer->Add(fhNLeadings[icone][ipt]) ; 
+       
+       fhNJets[icone][ipt]  = new TH1F
+         ("NJetCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "Number of neutral jets, cone ="+fJetNameCones[icone]+", pt>" 
+          +fJetNamePtThres[ipt]+" GeV/c",120,0,120); 
+       fhNJets[icone][ipt]->SetYTitle("N");
+       fhNJets[icone][ipt]->SetXTitle("p_{T #gamma}(GeV/c)");
+       outputContainer->Add(fhNJets[icone][ipt]) ; 
+       
+       //Fragmentation Function
+       fhJetFragments[icone][ipt]  = new TH2F
+         ("JetFragmentCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "x_{T} = p_{T i}/p_{T #gamma}, cone ="+fJetNameCones[icone]+", pt>" 
+          +fJetNamePtThres[ipt]+" GeV/c",120,0.,120.,240,0.,1.2); 
+       fhJetFragments[icone][ipt]->SetYTitle("x_{T}");
+       fhJetFragments[icone][ipt]->SetXTitle("p_{T #gamma}");
+       outputContainer->Add(fhJetFragments[icone][ipt]) ; 
+       
+       fhBkgFragments[icone][ipt]  = new TH2F
+         ("BkgFragmentCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "x_{T} = p_{T i}/p_{T #gamma}, cone ="+fJetNameCones[icone]+", pt>" 
+          +fJetNamePtThres[ipt]+" GeV/c",120,0.,120.,240,0.,1.2); 
+       fhBkgFragments[icone][ipt]->SetYTitle("x_{T}");
+       fhBkgFragments[icone][ipt]->SetXTitle("p_{T #gamma}");
+       outputContainer->Add(fhBkgFragments[icone][ipt]) ; 
+       
+       //Jet particle distribution
+       
+       fhJetPtDists[icone][ipt]  = new TH2F
+         ("JetPtDistCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "p_{T i}, cone ="+fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+
+          " GeV/c",120,0.,120.,120,0.,120.); 
+       fhJetPtDists[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhJetPtDists[icone][ipt]) ; 
+       
+       fhBkgPtDists[icone][ipt]  = new TH2F
+         ("BkgPtDistCone"+fJetNameCones[icone]+"Pt"+fJetNamePtThres[ipt],
+          "p_{T i}, cone ="+fJetNameCones[icone]+", pt>" +fJetNamePtThres[ipt]+
+          " GeV/c",120,0.,120.,120,0.,120.); 
+       fhBkgPtDists[icone][ipt]->SetXTitle("p_{T #gamma} (GeV/c)");
+       outputContainer->Add(fhBkgPtDists[icone][ipt]) ; 
+       
+      }//ipt
+    } //icone
+  }//If we want to study any cone or pt threshold
+
+  SetOutputContainer(outputContainer);
+
+  return outputContainer;
+}
+
+  //____________________________________________________________________________
+  void AliAnaGammaJetLeadCone::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+  SetJetsOnlyInCTS(kFALSE) ;
+  fPbPb                = kFALSE ;
+  fEtaEMCALCut     = 0.7 ;
+  fPhiEMCALCut[0] = 80. *TMath::Pi()/180.;
+  fPhiEMCALCut[1] = 190.*TMath::Pi()/180.;
+  SetDeltaPhiCutRange(2.9,3.4) ; 
+  SetRatioCutRange(0.1,1.0) ; 
+
+  //Jet selection parameters
+  //Fixed cut   
+  fJetRatioMaxCut = 1.2 ; 
+  fJetRatioMinCut = 0.3 ; 
+  fJetCTSRatioMaxCut = 1.2 ;
+  fJetCTSRatioMinCut = 0.3 ;
+  fSelect         = 0  ;
+
+  //Cut depending on gamma energy
+
+  fPtJetSelectionCut = 20.; //For Low pt jets+BKG, another limits applied
+  //Reconstructed jet energy dependence parameters 
+  //e_jet = a1+e_gamma b2. 
+  //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3
+  fJetE1[0] = -5.75; fJetE1[1] = -4.1;
+  fJetE2[0] = 1.005; fJetE2[1] = 1.05;
+
+  //Reconstructed sigma of jet energy dependence parameters 
+  //s_jet = a1+e_gamma b2. 
+  //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3
+  fJetSigma1[0] = 2.65;   fJetSigma1[1] = 2.75;
+  fJetSigma2[0] = 0.0018; fJetSigma2[1] = 0.033;
+
+  //Background mean energy and RMS
+  //Index 0-> No BKG; Index 1-> BKG > 2 GeV; 
+  //Index 2-> (low pt jets)BKG > 0.5 GeV;
+  //Index > 2, same for CTS conf
+  fBkgMean[0] = 0.; fBkgMean[1] = 8.8 ; fBkgMean[2] = 69.5;
+  fBkgMean[3] = 0.; fBkgMean[4] = 6.4;  fBkgMean[5] = 48.6;
+  fBkgRMS[0]  = 0.; fBkgRMS[1]  = 7.5;  fBkgRMS[2]  = 22.0; 
+  fBkgRMS[3]  = 0.; fBkgRMS[4]  = 5.4;  fBkgRMS[5]  = 13.2; 
+
+  //Factor x of min/max = E -+ x * sigma. Obtained after selecting the
+  //limits for monoenergetic jets.
+  //Index 0-> No BKG; Index 1-> BKG > 2 GeV; 
+  //Index 2-> (low pt jets) BKG > 0.5 GeV;
+  //Index > 2, same for CTS conf
+
+  fJetXMin1[0] =-0.69 ; fJetXMin1[1] = 0.39 ; fJetXMin1[2] =-0.88 ; 
+  fJetXMin1[3] =-2.0  ; fJetXMin1[4] =-0.442 ; fJetXMin1[5] =-1.1  ;
+  fJetXMin2[0] = 0.066; fJetXMin2[1] = 0.038; fJetXMin2[2] = 0.034; 
+  fJetXMin2[3] = 0.25 ; fJetXMin2[4] = 0.113; fJetXMin2[5] = 0.077 ;
+  fJetXMax1[0] =-3.8  ; fJetXMax1[1] =-0.76 ; fJetXMax1[2] =-3.6  ; 
+  fJetXMax1[3] =-2.7  ; fJetXMax1[4] =-1.21 ; fJetXMax1[5] =-3.7  ;
+  fJetXMax2[0] =-0.012; fJetXMax2[1] =-0.022; fJetXMax2[2] = 0.016; 
+  fJetXMax2[3] =-0.024; fJetXMax2[4] =-0.008; fJetXMax2[5] = 0.027;
+
+
+  //Different cones and pt thresholds to construct the jet
+
+  fJetCone        = 0.3  ;
+  fJetPtThreshold = 0.5   ;
+  fJetPtThresPbPb = 2.   ;
+  fJetNCone       = 4    ;
+  fJetNPt         = 4    ;
+  fJetCones[0]    = 0.2  ; fJetNameCones[0]   = "02" ;
+  fJetCones[1]    = 0.3  ; fJetNameCones[1]   = "03" ;
+  fJetCones[2]    = 0.4  ; fJetNameCones[2]   = "04" ;
+  fJetCones[2]    = 0.5  ; fJetNameCones[2]   = "05" ;
+
+  fJetPtThres[0]  = 0.0  ; fJetNamePtThres[0] = "00" ;
+  fJetPtThres[1]  = 0.5  ; fJetNamePtThres[1] = "05" ;
+  fJetPtThres[2]  = 1.0  ; fJetNamePtThres[2] = "10" ;
+  fJetPtThres[3]  = 2.0  ; fJetNamePtThres[3] = "20" ;
+}
+
+//__________________________________________________________________
+void AliAnaGammaJetLeadCone::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("Correlation analysis           =     %d\n",kJetLeadCone) ;
+  
+  
+  printf("Phi gamma-Leading      <     %f\n", GetDeltaPhiMaxCut()) ; 
+  printf("Phi gamma-Leading      >     %f\n", GetDeltaPhiMinCut()) ;
+  printf("pT Leading / pT Gamma             <     %f\n", GetRatioMaxCut()) ; 
+  printf("pT Leading / pT Gamma             >     %f\n", GetRatioMinCut()) ;
+  
+  if(fSelect == 2){
+    printf("pT Jet / pT Gamma                     <    %f\n", fJetRatioMaxCut) ; 
+    printf("pT Jet / pT Gamma                     >    %f\n", fJetRatioMinCut) ;
+    printf("pT Jet (Only CTS)/ pT Gamma   <    %f\n", fJetCTSRatioMaxCut) ; 
+    printf("pT Jet (Only CTS)/ pT Gamma   >    %f\n", fJetCTSRatioMinCut) ;
+  }
+  
+} 
+
+//__________________________________________________________________
+void  AliAnaGammaJetLeadCone::MakeGammaCorrelation(TParticle * pGamma, TClonesArray * plCTS,  TClonesArray * plNe) 
+{
+  //Gamma Jet Correlation Analysis
+  AliDebug(2, "Make correlation");
+  
+  TParticle *pLeading = new TParticle; //It will contain the kinematics of the found leading particle
+  
+  //Search leading particles in CTS and EMCAL 
+  if(GetLeadingParticle(plCTS, plNe, pGamma, pLeading)){
+    
+    AliDebug(1,Form("Leading: pt %f, phi %f, eta %f", pLeading->Pt(),pLeading->Phi(),pLeading->Eta())) ;
+    
+    //Search Jet
+    if(!fSeveralConeAndPtCuts)
+      MakeJet(plCTS, plNe, pGamma, pLeading, "");
+    else{
+      for(Int_t icone = 0; icone<fJetNCone; icone++) {
+       for(Int_t ipt = 0; ipt<fJetNPt;ipt++) {  
+         TString lastname ="Cone"+ fJetNameCones[icone]+"Pt"+ fJetNamePtThres[ipt];
+         fJetCone=fJetCones[icone];
+         fJetPtThreshold=fJetPtThres[ipt];
+         MakeJet(plCTS, plNe, pGamma, pLeading, lastname);
+       }//icone
+      }//ipt
+    }//fSeveralConeAndPtCuts
+  }//Leading
+       
+  AliDebug(2, "End of analysis, delete pointers");
+
+  pLeading->Delete();
+
+} 
+
+//____________________________________________________________________________
+Bool_t  AliAnaGammaJetLeadCone::GetLeadingParticle(TClonesArray * plCTS, TClonesArray * plNe,  
+                                           TParticle * pGamma, TParticle * pLeading) 
+{
+  //Search Charged or Neutral leading particle, select the highest one.
+  
+  TParticle * pLeadingCh = new TParticle();
+  TParticle * pLeadingPi0 = new TParticle();
+  
+  Double_t ptg  =  pGamma->Pt(); 
+  Double_t phig = pGamma->Phi(); 
+  Double_t etag = pGamma->Eta(); 
+  
+  if(!AreJetsOnlyInCTS())
+    {
+      AliDebug(3, "GetLeadingPi0");
+      GetLeadingPi0(plNe, pGamma, pLeadingPi0) ;
+      AliDebug(3, "GetLeadingCharge");
+      GetLeadingCharge(plCTS, pGamma, pLeadingCh) ;
+      
+      Double_t ptch = pLeadingCh->Pt(); 
+      Double_t phich = pLeadingCh->Phi(); 
+      Double_t etach = pLeadingCh->Eta(); 
+      Double_t ptpi = pLeadingPi0->Pt(); 
+      Double_t phipi = pLeadingPi0->Phi(); 
+      Double_t etapi = pLeadingPi0->Eta(); 
+
+      //Is leading cone inside EMCAL acceptance?
+      
+      Bool_t insidech = kFALSE ;
+      if((phich - fJetCone) >  fPhiEMCALCut[0] && 
+        (phich + fJetCone) <  fPhiEMCALCut[1] && 
+       (etach-fJetCone) < fEtaEMCALCut )
+       insidech = kTRUE ;
+      
+      Bool_t insidepi = kFALSE ;
+      if((phipi - fJetCone) >  fPhiEMCALCut[0] && 
+        (phipi + fJetCone) <  fPhiEMCALCut[1] &&
+       (etapi-fJetCone) < fEtaEMCALCut )
+       insidepi = kTRUE ;
+
+      AliDebug(2,Form("Leading:  charged pt %f, pi0 pt  %f",ptch,ptpi)) ;
+      
+      if (ptch > 0 || ptpi > 0)
+       {
+         if(insidech && (ptch > ptpi))
+           {
+           
+             AliDebug(1,"Leading found in CTS");
+             pLeading->SetMomentum(pLeadingCh->Px(),pLeadingCh->Py(),pLeadingCh->Pz(),pLeadingCh->Energy());
+             AliDebug(3,Form("Final leading found in CTS, pt %f, phi %f, eta %f",ptch,phich,etach)) ;
+             fhChargedRatio->Fill(ptg,ptch/pGamma->Pt());
+             fhEtaCharged->Fill(ptg,etach);
+             fhPhiCharged->Fill(ptg,phich);
+             fhDeltaPhiGammaCharged->Fill(ptg,pGamma->Phi()-phich);
+             fhDeltaEtaGammaCharged->Fill(ptg,pGamma->Eta()-etach);
+             return 1;
+           }
+         
+         else if((ptpi > ptch) && insidepi)
+           {
+             AliDebug(1,"Leading found in EMCAL");
+             pLeading->SetMomentum(pLeadingPi0->Px(),pLeadingPi0->Py(),pLeadingPi0->Pz(),pLeadingPi0->Energy());
+             AliDebug(3,Form("Final leading found in EMCAL, pt %f, phi %f, eta %f",ptpi,phipi,etapi)) ;
+             fhNeutralRatio ->Fill(ptg,ptpi/ptg);
+             fhEtaNeutral->Fill(ptg,etapi);
+             fhPhiNeutral->Fill(ptg,phipi);
+             fhDeltaPhiGammaNeutral->Fill(ptg,phig-phipi);
+             fhDeltaEtaGammaNeutral->Fill(ptg,etag-etapi);
+             return 1;     
+           }
+
+         else{
+           AliDebug(3,"NO LEADING PARTICLE FOUND");}
+         return 0; 
+       }
+      else{
+       AliDebug(3,"NO LEADING PARTICLE FOUND");
+       return 0;
+      }
+    }
+  else
+    {
+      //No calorimeter present for Leading particle detection
+      GetLeadingCharge(plCTS, pGamma, pLeading) ;
+      Double_t ptch = pLeading->Pt(); 
+      Double_t phich = pLeading->Phi(); 
+      Double_t etach = pLeading->Eta(); 
+      if(ptch > 0){
+       fhChargedRatio->Fill(ptg,ptch/ptg);
+       fhEtaCharged->Fill(ptg,etach);
+       fhPhiCharged->Fill(ptg,phich);
+       fhDeltaPhiGammaCharged->Fill(ptg,phig-phich);
+       fhDeltaEtaGammaCharged->Fill(ptg,etag-etach);
+       AliDebug(3,Form("Leading found :  pt %f, phi %f, eta %f",ptch,phich,etach)) ;
+       return 1;
+      }
+      else
+       {
+         AliDebug(3,"NO LEADING PARTICLE FOUND");      
+         return 0;
+       }
+    }
+}
+
+//____________________________________________________________________________
+void  AliAnaGammaJetLeadCone::GetLeadingCharge(TClonesArray * pl, TParticle * pGamma, TParticle * pLeading) const 
+{  
+  //Search for the charged particle with highest with 
+  //Phi=Phi_gamma-Pi and pT=0.1E_gamma 
+  Double_t pt  = -100.;
+  Double_t phi = -100.;
+
+  for(Int_t ipr = 0;ipr < pl->GetEntries() ; ipr ++ ){
+
+    TParticle * particle = dynamic_cast<TParticle *>(pl->At(ipr)) ;
+
+    Double_t ptl  = particle->Pt();
+    Double_t rat  = ptl/pGamma->Pt() ;
+    Double_t phil = particle->Phi() ;
+    Double_t phig = pGamma->Phi();
+
+    //Selection within angular and energy limits
+    if(((phig-phil)> GetDeltaPhiMinCut()) && ((phig-phil)<GetDeltaPhiMaxCut()) &&
+        (rat > GetRatioMinCut()) && (rat < GetRatioMaxCut())  && (ptl  > pt)) {
+       phi = phil ;
+       pt  = ptl ;
+       pLeading->SetMomentum(particle->Px(),particle->Py(),particle->Pz(),particle->Energy());
+       AliDebug(4,Form("Charge in CTS: pt %f eta %f phi %f pt/Eg %f \n", pt, particle->Eta(), phi,rat)) ;
+     }
+  }
+  
+  AliDebug(1,Form("Leading in CTS: pt %f eta %f phi %f pt/Eg %f \n", pt, pLeading->Eta(), phi,pt/pGamma->Pt())) ;
+
+}
+
+
+//____________________________________________________________________________
+void  AliAnaGammaJetLeadCone::GetLeadingPi0(TClonesArray * pl, TParticle * pGamma, TParticle * pLeading)  
+{  
+
+  //Search for the neutral pion with highest with 
+  //Phi=Phi_gamma-Pi and pT=0.1E_gamma 
+  Double_t pt  = -100.;
+  Double_t phi = -100.;
+  Double_t ptl = -100.;
+  Double_t rat = -100.; 
+  Double_t phil = -100. ;
+  Double_t ptg  = pGamma->Pt();
+  Double_t phig = pGamma->Phi();
+
+  TIter next(pl);
+  TParticle * particlei = 0;
+  TParticle * particlej = 0;
+  TLorentzVector gammai;
+  TLorentzVector gammaj;
+
+  Int_t iPrimary = -1;
+  Double_t angle = 0., e = 0., invmass = 0.;
+  Int_t ksPdg = 0;
+  Int_t jPrimary=-1;
+
+  while ( (particlei = (TParticle*)next()) ) {
+    iPrimary++;          
+    ksPdg = particlei->GetPdgCode();
+    
+    ptl  = particlei->Pt();   
+    //2 gamma overlapped, found with PID
+     if(ksPdg == 111){ 
+       rat = ptl/ptg ;
+       phil = particlei->Phi() ;
+       //Selection within angular and energy limits
+       if(ptl > pt  && rat > GetRatioMinCut()  && rat < GetRatioMaxCut()  && 
+         (phig-phil) > GetDeltaPhiMinCut() && (phig-phil) < GetDeltaPhiMaxCut() )
+        {
+          phi = phil ;
+          pt  = ptl ;
+          pLeading->SetMomentum(particlei->Px(),particlei->Py(),particlei->Pz(),particlei->Energy());
+          AliDebug(4,Form("Pi0 candidate: pt %f eta %f phi %f pt/Eg %f \n",  pLeading->Pt(), pLeading->Eta(),  pLeading->Phi(),  pLeading->Pt()/pGamma->Pt())) ;
+        }// cuts
+     }// pdg = 111
+
+    //Make invariant mass analysis
+    else if(ksPdg == 22){//  gamma i
+      //Search the photon companion in case it comes from  a Pi0 decay
+      //Apply several cuts to select the good pair
+      particlei->Momentum(gammai);
+      jPrimary=-1;
+      TIter next2(pl);
+      while ( (particlej = (TParticle*)next2()) ) {
+       jPrimary++;
+       if(jPrimary>iPrimary){
+         ksPdg = particlej->GetPdgCode();
+         particlej->Momentum(gammaj);
+         if(ksPdg == 22 && GetNeutralMesonSelection()->SelectPair(pGamma, gammai, gammaj))
+         {
+           //Info("GetLeadingPi0","Egammai %f, Egammaj %f", 
+           //gammai.Pt(),gammaj.Pt());
+           ptl  = (gammai+gammaj).Pt();
+           phil = (gammai+gammaj).Phi();
+           if(phil < 0)
+             phil+=TMath::TwoPi();
+           rat = ptl/ptg ;
+             
+           if(ptl > pt ){
+             pt       = ptl;
+             phi      = phil ;
+             e       = (gammai+gammaj).E();
+             angle   = gammaj.Angle(gammai.Vect());
+             invmass = (gammai+gammaj).M();
+             pLeading->SetMomentum( (gammai+gammaj).Px(), (gammai+gammaj).Py(), (gammai+gammaj).Pz(), (gammai+gammaj).E());
+             AliDebug(4,Form("Pi0 candidate: pt %f eta %f phi %f pt/Eg %f \n",  pLeading->Pt(), pLeading->Eta(),  pLeading->Phi(),  pLeading->Pt()/pGamma->Pt())) ;
+           }
+         }//if pdg = 22, pair selected
+       }//iprimary<jprimary
+      }//while
+    }// if pdg = 22
+  }//while
+  
+  //Final pi0 found, highest pair energy, fill histograms
+  if(e > 0.){
+    fhInvMassPairLeading->Fill(e,invmass);
+    fhAnglePairLeading->Fill(e,angle);
+  }
+  
+  AliDebug(3,Form("Leading EMCAL: pt %f eta %f phi %f pt/Eg %f \n",  pLeading->Pt(), pLeading->Eta(),  pLeading->Phi(),  pLeading->Pt()/pGamma->Pt())) ;
+}
+
+
+//__________________________________________________________________________-
+Bool_t AliAnaGammaJetLeadCone::IsJetSelected(const Double_t ptg, const Double_t ptj){
+  //Check if the energy of the reconstructed jet is within an energy window
+
+  Double_t par[6];
+  Double_t xmax[2];
+  Double_t xmin[2];
+
+  Int_t iCTS = 0;
+  if(AreJetsOnlyInCTS())
+    iCTS = 3 ;
+
+  if(!fPbPb){
+    //Phythia alone, jets with pt_th > 0.2, r = 0.3 
+    par[0] = fJetE1[0]; par[1] = fJetE2[0]; 
+    //Energy of the jet peak
+    //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
+    par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0];
+    //Sigma  of the jet peak
+    //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
+    par[4] = fBkgMean[0 + iCTS]; par[5] = fBkgRMS[0 + iCTS];
+    //Parameters reserved for PbPb bkg.
+    xmax[0] = fJetXMax1[0 + iCTS]; xmax[1] = fJetXMax2[0 + iCTS];
+    xmin[0] = fJetXMin1[0 + iCTS]; xmin[1] = fJetXMin2[0 + iCTS];
+    //Factor that multiplies sigma to obtain the best limits, 
+    //by observation, of mono jet ratios (ptjet/ptg)
+    //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
+   
+  }
+  else{
+    if(ptg > fPtJetSelectionCut){
+      //Phythia +PbPb with  pt_th > 2 GeV/c, r = 0.3 
+      par[0] = fJetE1[0]; par[1] = fJetE2[0]; 
+      //Energy of the jet peak, same as in pp
+      //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
+      par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0];
+      //Sigma  of the jet peak, same as in pp
+      //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
+      par[4] = fBkgMean[1 + iCTS]; par[5] = fBkgRMS[1 + iCTS];
+      //Mean value and RMS of PbPb Bkg 
+      xmax[0] = fJetXMax1[1 + iCTS]; xmax[1] = fJetXMax2[1 + iCTS];
+      xmin[0] = fJetXMin1[1 + iCTS]; xmin[1] = fJetXMin2[1 + iCTS];
+      //Factor that multiplies sigma to obtain the best limits, 
+      //by observation, of mono jet ratios (ptjet/ptg) mixed with PbPb Bkg, 
+      //pt_th > 2 GeV, r = 0.3
+      //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
+     
+    }
+    else{
+      //Phythia + PbPb with  pt_th > 0.5 GeV/c, r = 0.3
+      par[0] = fJetE1[1]; par[1] = fJetE2[1]; 
+      //Energy of the jet peak, pt_th > 2 GeV/c, r = 0.3 
+      //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
+      par[2] = fJetSigma1[1]; par[3] = fJetSigma2[1];
+      //Sigma  of the jet peak, pt_th > 2 GeV/c, r = 0.3
+      //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
+      par[4] = fBkgMean[2 + iCTS]; par[5] = fBkgRMS[2 + iCTS];
+      //Mean value and RMS of PbPb Bkg in a 0.3 cone, pt > 2 GeV.
+      xmax[0] = fJetXMax1[2 + iCTS]; xmax[1] = fJetXMax2[2 + iCTS];
+      xmin[0] = fJetXMin1[2 + iCTS]; xmin[1] = fJetXMin2[2 + iCTS];
+      //Factor that multiplies sigma to obtain the best limits, 
+      //by observation, of mono jet ratios (ptjet/ptg) mixed with PbPb Bkg, 
+      //pt_th > 2 GeV, r = 0.3
+      //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
+     
+    }//If low pt jet in bkg
+  }//if Bkg
+
+ //Calculate minimum and maximum limits of the jet ratio.
+  Double_t min = CalculateJetRatioLimit(ptg, par, xmin);
+  Double_t max = CalculateJetRatioLimit(ptg, par, xmax);
+  
+  AliDebug(3,Form("Jet selection?  : Limits min %f, max %f,  pt_jet %f,  pt_gamma %f, pt_jet / pt_gamma %f",min,max,ptj,ptg,ptj/ptg));
+
+  if(( min < ptj/ptg ) && ( max > ptj/ptg))
+    return kTRUE;
+  else
+    return kFALSE;
+
+}
+
+//____________________________________________________________________________
+void AliAnaGammaJetLeadCone::MakeJet(TClonesArray * plCTS, TClonesArray * plNe, 
+                                    TParticle * pGamma, TParticle* pLeading,TString lastname)
+{
+  //Fill the jet with the particles around the leading particle with 
+  //R=fJetCone and pt_th = fJetPtThres. Calculate the energy of the jet and 
+  //check if we select it. Fill jet histograms
+  
+  TClonesArray * jetList = new TClonesArray("TParticle",1000);
+  TClonesArray * bkgList = new TClonesArray("TParticle",1000);
+
+  TLorentzVector jet   (0,0,0,0);  
+  TLorentzVector bkg(0,0,0,0);
+  TLorentzVector lv (0,0,0,0);
+
+  Double_t ptjet = 0.0;
+  Double_t ptbkg = 0.0;
+  Int_t n0 = 0;
+  Int_t n1 = 0;  
+  Bool_t b1 = kFALSE;
+  Bool_t b0 = kFALSE;
+  
+  Double_t ptg  = pGamma->Pt();
+  Double_t phig = pGamma->Phi();
+  Double_t ptl  = pLeading->Pt();
+  Double_t phil = pLeading->Phi();
+  Double_t etal = pLeading->Eta();
+
+  Float_t ptcut = fJetPtThreshold;
+  if(fPbPb && !fSeveralConeAndPtCuts && ptg > fPtJetSelectionCut)  ptcut = fJetPtThresPbPb ;
+  //Add charged particles to jet
+  TIter nextch(plCTS) ; 
+  TParticle * particle = 0 ; 
+  while ( (particle = dynamic_cast<TParticle*>(nextch())) ) {
+    
+    b0 = kFALSE;
+    b1 = kFALSE;
+
+    //Particles in jet 
+    SetJet(particle, b0, fJetCone, etal, phil) ;  
+
+    if(b0){
+      new((*jetList)[n0++]) TParticle(*particle) ;
+      particle->Momentum(lv);
+      if(particle->Pt() > ptcut ){
+       jet+=lv;
+       ptjet+=particle->Pt();
+      }
+    }
+
+    //Background around (phi_gamma-pi, eta_leading)
+    SetJet(particle, b1, fJetCone,etal, phig) ;
+
+    if(b1) { 
+      new((*bkgList)[n1++]) TParticle(*particle) ;
+      particle->Momentum(lv);
+      if(particle->Pt() > ptcut ){
+       bkg+=lv;
+       ptbkg+=particle->Pt();    
+      }  
+    }
+  }
+
+   //Add neutral particles to jet
+  TIter nextne(plNe) ; 
+  particle = 0 ; 
+  while ( (particle = dynamic_cast<TParticle*>(nextne())) ) {
+    
+    b0 = kFALSE;
+    b1 = kFALSE;
+
+    //Particles in jet 
+    SetJet(particle, b0, fJetCone, etal, phil) ;  
+
+    if(b0){
+      new((*jetList)[n0++]) TParticle(*particle) ;
+      particle->Momentum(lv);
+      if(particle->Pt() > ptcut ){
+       jet+=lv;
+       ptjet+=particle->Pt();
+      }
+    }
+
+    //Background around (phi_gamma-pi, eta_leading)
+    SetJet(particle, b1, fJetCone,etal, phig) ;
+
+    if(b1) { 
+      new((*bkgList)[n1++]) TParticle(*particle) ;
+      particle->Momentum(lv);
+      if(particle->Pt() > ptcut ){
+       bkg+=lv;
+       ptbkg+=particle->Pt();    
+      }  
+    }
+  }
+  
+  ptjet = jet.Pt();
+  ptbkg = bkg.Pt();
+
+  if(ptjet > 0.) {
+
+    AliDebug(2,Form("Gamma   pt %f, Jet pt %f, Bkg pt %f",ptg,ptjet,ptbkg));
+    
+    //Fill histograms
+    
+    Double_t ratjet   = ptjet/ptg ;
+    Double_t ratbkg  = ptbkg/ptg ;
+
+    dynamic_cast<TH2F*>
+      (GetOutputContainer()->FindObject("JetRatio"+lastname))
+      ->Fill(ptg,ratjet);       
+    dynamic_cast<TH2F*>
+      (GetOutputContainer()->FindObject("JetPt"+lastname))
+      ->Fill(ptg,ptjet);
+    
+    dynamic_cast<TH2F*>
+      (GetOutputContainer()->FindObject("BkgRatio"+lastname))
+      ->Fill(ptg,ratbkg);
+    
+    dynamic_cast<TH2F*>
+      (GetOutputContainer()->FindObject("BkgPt"+lastname))
+      ->Fill(ptg,ptbkg);
+
+    //Jet selection
+    Bool_t kSelect = kFALSE;
+    if(fSelect == 0)
+      kSelect = kTRUE; //Accept all jets, no restriction
+    else if(fSelect == 1){
+      //Selection with parametrized cuts
+      if(IsJetSelected(ptg,ptjet))   kSelect = kTRUE;
+    }
+    else if(fSelect == 2){
+      //Simple selection
+      if(!AreJetsOnlyInCTS()){
+       if((ratjet <  fJetRatioMaxCut) && (ratjet > fJetRatioMinCut )) kSelect = kTRUE;
+      }
+      else{
+       if((ratjet <  fJetCTSRatioMaxCut) && (ratjet > fJetCTSRatioMinCut )) kSelect = kTRUE;
+      }
+    }
+    else
+      AliError("Jet selection option larger than 2, DON'T SELECT JETS");
+    
+    
+     if(kSelect){
+       AliDebug(1,Form("Jet Selected: pt %f ", ptjet)) ;
+      
+       FillJetHistos(jetList, ptg, ptl,"Jet",lastname);
+       FillJetHistos(bkgList, ptg, ptl, "Bkg",lastname);
+     }
+  } //ptjet > 0
+  
+  jetList ->Delete();
+  bkgList ->Delete();
+  
+}
+
+//___________________________________________________________________
+void AliAnaGammaJetLeadCone::SetJet(TParticle * part, Bool_t & b, Float_t cone, 
+                            Double_t eta, Double_t phi)
+{
+
+  //Check if the particle is inside the cone defined by the leading particle
+  b = kFALSE;
+  
+  if(phi > TMath::TwoPi())
+    phi-=TMath::TwoPi();
+  if(phi < 0.)
+    phi+=TMath::TwoPi();
+  
+  Double_t  rad = 10000 + cone;
+  
+  if(TMath::Abs(part->Phi()-phi) <= (TMath::TwoPi() - cone))
+    rad = TMath::Sqrt(TMath::Power(part->Eta()-eta,2)+
+                     TMath::Power(part->Phi()-phi,2));
+  else{
+    if(part->Phi()-phi > TMath::TwoPi() - cone)
+      rad = TMath::Sqrt(TMath::Power(part->Eta()-eta,2)+
+                       TMath::Power((part->Phi()-TMath::TwoPi())-phi,2));
+    if(part->Phi()-phi < -(TMath::TwoPi() - cone))
+      rad = TMath::Sqrt(TMath::Power(part->Eta()-eta,2)+
+                       TMath::Power((part->Phi()+TMath::TwoPi())-phi,2));
+  }
+
+  if(rad < cone )
+    b = kTRUE;
+  
+}
+
+//____________________________________________________________________________
+void AliAnaGammaJetLeadCone::FillJetHistos(TClonesArray * pl, Double_t ptg, Double_t ptl, TString type, TString lastname)
+{
+  //Fill histograms wth jet fragmentation 
+  //and number of selected jets and leading particles
+  //and the background multiplicity
+  TParticle * particle = 0 ;
+  Int_t ipr = 0;
+  Float_t  charge = 0;
+  
+  TIter next(pl) ; 
+  while ( (particle = dynamic_cast<TParticle*>(next())) ) {
+    ipr++ ;
+    Double_t pt = particle->Pt();
+    
+    charge = TDatabasePDG::Instance()
+      ->GetParticle(particle->GetPdgCode())->Charge();
+    if(charge != 0){//Only jet Charged particles 
+      dynamic_cast<TH2F*>
+       (GetOutputContainer()->FindObject(type+"Fragment"+lastname))
+       ->Fill(ptg,pt/ptg);
+      dynamic_cast<TH2F*>
+       (GetOutputContainer()->FindObject(type+"PtDist"+lastname))
+       ->Fill(ptg,pt);
+    }//charged
+    
+  }//while
+  
+  if(type == "Bkg")
+    dynamic_cast<TH1F*>
+      (GetOutputContainer()->FindObject("NBkg"+lastname))
+      ->Fill(ipr);
+  else{
+    dynamic_cast<TH1F*>
+      (GetOutputContainer()->FindObject("NJet"+lastname))->
+      Fill(ptg);
+    dynamic_cast<TH2F*>
+      (GetOutputContainer()->FindObject("NLeading"+lastname))
+      ->Fill(ptg,ptl);
+  }
+  
+}
diff --git a/PWG4/AliAnaGammaJetLeadCone.h b/PWG4/AliAnaGammaJetLeadCone.h
new file mode 100644 (file)
index 0000000..7b77efa
--- /dev/null
@@ -0,0 +1,192 @@
+#ifndef ALIANAGAMMAJETLEADCONE_H
+#define ALIANAGAMMAJETLEADCONE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class that contains the algorithm for the reconstruction of jet, cone around leading particle
+//  Class created from old AliPHOSGammaJet
+//  (see AliRoot versions previous Release 4-09)
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+#include "AliAnaGammaCorrelation.h"
+
+class AliAnaGammaJetLeadCone : public AliAnaGammaCorrelation {
+
+public: 
+  
+  AliAnaGammaJetLeadCone() ; // default ctor
+  AliAnaGammaJetLeadCone(const AliAnaGammaJetLeadCone & g) ; // cpy ctor
+  AliAnaGammaJetLeadCone & operator = (const AliAnaGammaJetLeadCone & g) ;//cpy assignment
+  virtual ~AliAnaGammaJetLeadCone() ; //virtual dtor
+  
+  TList * GetCreateOutputObjects();
+
+  void InitParameters();
+
+  void Print(const Option_t * opt) const;
+  Bool_t   AreSeveralConeAndPtCuts() const {return fSeveralConeAndPtCuts ; }
+  void SetSeveralConeAndPtCuts(Bool_t several){fSeveralConeAndPtCuts = several ;}
+
+  Bool_t   IsPbPb() const {return fPbPb ; }
+  void SetPbPb(Bool_t opt){fPbPb = opt; }
+
+  Double_t GetEtaEMCALCut() const {return fEtaEMCALCut;}
+  Double_t GetPhiEMCALCut(Int_t i) const {return fPhiEMCALCut[i];}
+  void SetEtaEMCALCut(Double_t etacut) {fEtaEMCALCut = etacut ; }
+  void SetPhiEMCALCut(Double_t phi, Int_t i){fPhiEMCALCut[i] = phi; }
+
+  Double_t GetPtJetSelectionCut() const {return fPtJetSelectionCut ; }
+  Double_t GetJetRatioMaxCut() const {return fJetRatioMaxCut ; }
+  Double_t GetJetRatioMinCut() const {return fJetRatioMinCut ; }
+  void SetPtJetSelectionCut(Double_t cut){fPtJetSelectionCut = cut; }
+  void SetJetSelection(UInt_t select){ fSelect= select ; }
+
+  Int_t       GetJetNCones() const {return fJetNCone ; }
+  Int_t       GetJetNPtThres() const {return fJetNPt ; }
+  Float_t    GetJetCone() const {return fJetCone ; }
+  Float_t    GetJetPtThreshold() const {return fJetPtThreshold ; }
+  Float_t    GetJetPtThresPbPb() const {return fJetPtThresPbPb ; }
+  Float_t    GetJetCones(Int_t i) const {return fJetCones[i] ; }
+  Float_t    GetJetPtThreshold(Int_t i) const {return fJetPtThres[i] ; }
+  TString   GetJetConeName(Int_t i) const {return fJetNameCones[i] ; }
+  TString   GetJetPtThresName(Int_t i) const {return fJetNamePtThres[i] ; }
+
+  void SetJetNCones(Int_t n){fJetNCone = n ; }
+  void SetJetNPtThresholds(Int_t n){fJetNPt = n ; }
+  void SetJetCones(Int_t i, Float_t cone, TString sc)
+    {fJetCones[i] = cone ; fJetNameCones[i] = sc; };
+  void SetCone(Float_t cone)
+    {fJetCone = cone; }
+  void SetJetPtThreshold(Float_t pt){fJetPtThreshold = pt; };
+  void SetJetPtThresPbPb(Float_t pt){fJetPtThresPbPb = pt; };
+  void SetJetPtThresholds(Int_t i,Float_t pt, TString spt){fJetPtThres[i] = pt ; 
+  fJetNamePtThres[i] = spt; };
+
+  void SetJetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
+    {fJetRatioMaxCut =ratiomax;  fJetRatioMinCut = ratiomin ; }
+  void SetJetCTSRatioCutRange(Double_t ratiomin, Double_t ratiomax)
+    {fJetCTSRatioMaxCut =ratiomax;  fJetCTSRatioMinCut = ratiomin ; }
+  
+  void MakeGammaCorrelation(TParticle * pGamma, TClonesArray * plCTS,   TClonesArray * plNe) ;
+  
+  private:
+
+  Double_t CalculateJetRatioLimit(const Double_t ptg, const Double_t *param, 
+                                 const Double_t *x);
+  void FillJetHistos(TClonesArray * pl, Double_t ptg, Double_t ptl,TString type, TString lastname);
+
+  Bool_t IsJetSelected(const Double_t ptg, const Double_t ptjet);
+
+  void MakeJet(TClonesArray * plCTS, TClonesArray * plNe, 
+              TParticle * pGamma, TParticle* pLeading, TString lastname); 
+  
+  void GetLeadingCharge(TClonesArray * pl, TParticle *pGamma, TParticle * pLeading) const ;
+  void GetLeadingPi0   (TClonesArray * pl, TParticle *pGamma, TParticle * pLeading)  ;
+  Bool_t GetLeadingParticle(TClonesArray * plCTS, TClonesArray * plNe, 
+                           TParticle *pGamma, TParticle * pLeading) ;
+  
+  void SetJet(TParticle * part, Bool_t & b, Float_t cone, Double_t eta, 
+             Double_t phi);
+
+  private:
+
+  Bool_t       fPbPb;          // PbPb event
+  Bool_t       fSeveralConeAndPtCuts;     //  To play with the jet cone size and pt th.
+
+  Double_t   fEtaEMCALCut ;         // Eta EMCAL acceptance
+  Double_t   fPhiEMCALCut[2] ; // Phi cut maximum
+
+  //Jet selection parameters
+  //Fixed cuts (old)
+  Double_t   fJetCTSRatioMaxCut ; // Leading particle/gamma Ratio cut maximum
+  Double_t   fJetCTSRatioMinCut ; // Leading particle/gamma Ratio cut minimum
+  Double_t   fJetRatioMaxCut ; // Jet/gamma Ratio cut maximum
+  Double_t   fJetRatioMinCut ; // Jet/gamma Ratio cut minimum
+
+  //Cuts depending on jet pt
+  Double_t fJetE1[2];    //Rec. jet energy parameters
+  Double_t fJetE2[2];    //Rec. jet energy parameters
+  Double_t fJetSigma1[2];//Rec. sigma of jet energy  parameters
+  Double_t fJetSigma2[2];//Rec. sigma of jet energy  parameters
+  Double_t fBkgMean[6];  //Background mean energy 
+  Double_t fBkgRMS[6];   //Background RMS
+  Double_t fJetXMin1[6]; //X Factor to set jet min limit for pp
+  Double_t fJetXMin2[6]; //X Factor to set jet min limit for PbPb
+  Double_t fJetXMax1[6]; //X Factor to set jet max limit for pp
+  Double_t fJetXMax2[6]; //X Factor to set jet max limit for PbPb
+
+  Int_t         fJetNCone ;            // Number of jet cones sizes
+  Int_t         fJetNPt   ;            // Number of jet particle pT threshold
+  Double_t   fJetCone  ;            // Jet cone sizes under study (!fSeveralConeAndPtCuts)
+  Double_t   fJetCones[10];         // Jet cone sizes under study (fSeveralConeAndPtCuts)
+  TString     fJetNameCones[10];     // String name of cone to append to histos
+  Double_t   fJetPtThreshold;       // Jet pT threshold under study(!fSeveralConeAndPtCuts)
+  Double_t   fJetPtThresPbPb;       // Jet pT threshold under study(!fSeveralConeAndPtCuts)
+  Double_t   fJetPtThres[10];       // Jet pT threshold under study(fSeveralConeAndPtCuts)
+  TString     fJetNamePtThres[10];   // String name of pt th to append to histos
+  Double_t   fPtJetSelectionCut; // Jet pt to change to low pt jets analysis
+  UInt_t       fSelect  ;   //kTRUE: Selects all jets, no limits.
+  //Histograms
+
+  TH2F * fhPhiCharged  ; 
+  TH2F * fhPhiNeutral   ; 
+  TH2F * fhEtaCharged  ; 
+  TH2F * fhEtaNeutral   ; 
+  TH2F * fhDeltaPhiGammaCharged  ;  
+  TH2F * fhDeltaPhiGammaNeutral   ; 
+  TH2F * fhDeltaEtaGammaCharged  ; 
+  TH2F * fhDeltaEtaGammaNeutral  ; 
+
+  TH2F * fhAnglePairLeading  ; 
+  TH2F * fhInvMassPairLeading  ; 
+  TH2F * fhChargedRatio  ; 
+  TH2F * fhNeutralRatio   ; 
+  TH1F * fhNBkg   ; 
+  TH2F * fhNLeading  ; 
+  TH1F * fhNJet  ; 
+  TH2F * fhJetRatio  ; 
+  TH2F * fhJetPt   ; 
+  TH2F * fhBkgRatio   ; 
+  TH2F * fhBkgPt  ; 
+  TH2F * fhJetFragment  ; 
+  TH2F * fhBkgFragment  ; 
+  TH2F * fhJetPtDist  ; 
+  TH2F * fhBkgPtDist  ; 
+
+  TH2F * fhJetRatios[5][5];
+  TH2F * fhJetPts[5][5];
+  TH2F * fhBkgRatios[5][5];  
+  TH2F * fhBkgPts[5][5];
+  
+  TH2F * fhNLeadings[5][5];
+  TH1F * fhNJets[5][5];
+  TH1F * fhNBkgs[5][5];
+  
+  TH2F * fhJetFragments[5][5];
+  TH2F * fhBkgFragments[5][5];
+  TH2F * fhJetPtDists[5][5];
+  TH2F * fhBkgPtDists[5][5];
+  
+
+  ClassDef(AliAnaGammaJetLeadCone,0)
+} ;
+
+#endif //ALIANAGAMMAJETLEADCONE_H
+
+
+
diff --git a/PWG4/AliAnaGammaParton.cxx b/PWG4/AliAnaGammaParton.cxx
new file mode 100644 (file)
index 0000000..b6c3d2c
--- /dev/null
@@ -0,0 +1,188 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+//_________________________________________________________________________
+// Class for the analysis of gamma-parton correlations
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+#include "Riostream.h"
+
+//---- AliRoot system ----
+#include "AliAnaGammaParton.h" 
+#include "AliLog.h"
+  
+  ClassImp(AliAnaGammaParton)
+  
+
+//____________________________________________________________________________
+  AliAnaGammaParton::AliAnaGammaParton() : 
+    AliAnaGammaCorrelation(),   
+    fhDeltaEtaParton(0), fhDeltaPhiParton(0), 
+    fhDeltaPtParton(0), fhPtRatParton(0)
+{
+  //Default Ctor
+
+  SetCorrelationType(kParton);
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliAnaGammaParton::AliAnaGammaParton(const AliAnaGammaParton & g) :   
+  AliAnaGammaCorrelation(g),   
+  fhDeltaEtaParton(g.fhDeltaEtaParton), fhDeltaPhiParton(g.fhDeltaPhiParton), 
+  fhDeltaPtParton(g.fhDeltaPtParton), fhPtRatParton(g.fhPtRatParton)
+{
+  // cpy ctor
+
+}
+
+//_________________________________________________________________________
+AliAnaGammaParton & AliAnaGammaParton::operator = (const AliAnaGammaParton & source)
+{
+  // assignment operator
+
+  if(this == &source)return *this;
+  ((AliAnaGammaCorrelation *)this)->operator=(source);
+  fhDeltaEtaParton = source.fhDeltaEtaParton;
+  fhDeltaPhiParton = source.fhDeltaPhiParton;
+  fhDeltaPtParton = source.fhDeltaPtParton;
+  fhPtRatParton = source.fhPtRatParton;
+  
+  return *this;
+
+}
+
+//____________________________________________________________________________
+AliAnaGammaParton::~AliAnaGammaParton() 
+{
+  delete fhDeltaEtaParton ;
+  delete fhDeltaPhiParton ;
+  delete fhDeltaPtParton ;
+  delete fhPtRatParton ;
+}
+
+
+//________________________________________________________________________
+TList *  AliAnaGammaParton::GetCreateOutputObjects()
+{  
+  // Create histograms to be saved in output file and 
+  // store them in fOutputContainer
+
+  AliDebug(1,"Init parton histograms");
+
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("GammaPartonHistos") ; 
+
+  //---kParton---
+  fhDeltaPhiParton  = new TH2F
+    ("DeltaPhiParton","#phi_{#gamma} - #phi_{parton} vs p_{T #gamma}",
+     200,0,120,200,0,6.4); 
+  fhDeltaPhiParton->SetYTitle("#Delta #phi");
+  fhDeltaPhiParton->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhDeltaPhiParton);
+
+  fhDeltaEtaParton  = new TH2F
+    ("DeltaEtaParton","#eta_{#gamma} - #eta_{parton} vs p_{T #gamma}",
+     200,0,120,200,-2,2); 
+  fhDeltaEtaParton->SetYTitle("#Delta #eta");
+  fhDeltaEtaParton->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhDeltaEtaParton);
+
+  fhDeltaPtParton  = new TH2F
+    ("DeltaPtParton","#p_{T #gamma} - #p_{T parton} vs p_{T #gamma}",
+     200,0,120,100,-10,10); 
+  fhDeltaPtParton->SetYTitle("#Delta #p_{T}");
+  fhDeltaPtParton->SetXTitle("p_{T #gamma} (GeV/c)"); 
+  outputContainer->Add(fhDeltaPtParton);
+
+  fhPtRatParton  = new TH2F
+    ("PtRatParton","#p_{T parton} / #p_{T #gamma} vs p_{T #gamma}",
+     200,0,120,200,0,5); 
+  fhPtRatParton->SetYTitle("ratio");
+  fhPtRatParton->SetXTitle("p_{T #gamma} (GeV/c)");
+  outputContainer->Add(fhPtRatParton);
+
+  SetOutputContainer(outputContainer);
+
+  return outputContainer;
+}
+
+ //____________________________________________________________________________
+void AliAnaGammaParton::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+
+  ;
+
+}
+
+//__________________________________________________________________
+void AliAnaGammaParton::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+} 
+
+//__________________________________________________________________
+void  AliAnaGammaParton::MakeGammaCorrelation(TParticle * pGamma, TClonesArray *pl, TClonesArray *) 
+{
+  //Gamma Parton Correlation Analysis
+  AliDebug(2, "Begin parton analysis");
+  
+  Double_t ptg  = pGamma->Pt();
+  Double_t phig = pGamma->Phi();
+  Double_t etag = pGamma->Eta();
+  
+  Double_t pt    = -100.;
+  Double_t eta   = -100.; 
+  Double_t phi   = -100. ;
+  for(Int_t ipr = 0;ipr < pl->GetEntries() ; ipr ++ ){//fCaloList==parton list
+    TParticle * particle = dynamic_cast<TParticle *>(pl->At(ipr)) ;
+    
+    if(particle->GetPdgCode() !=22 && (ipr ==4 || ipr == 5)){// 6 or 7 in list.
+      //Only good for gamma-jet events
+      pt    = particle->Pt();
+      phi   = particle->Phi() ;
+      eta   = particle->Eta() ;
+    }
+  }
+  
+  fhDeltaEtaParton->Fill(ptg,etag-eta);
+  fhDeltaPhiParton->Fill(ptg,phig-phi);
+  fhDeltaPtParton->Fill(ptg,ptg-pt);
+  fhPtRatParton->Fill(ptg,pt/ptg);
+  
+  AliDebug(2, "End of parton analysis");
+  
+} 
diff --git a/PWG4/AliAnaGammaParton.h b/PWG4/AliAnaGammaParton.h
new file mode 100644 (file)
index 0000000..37185fa
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef ALIANAGAMMAPARTON_H
+#define ALIANAGAMMAPARTON_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class that contains the algorithm for the analysis of gamma-parton correlation 
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+#include "AliAnaGammaCorrelation.h"
+     
+class AliAnaGammaParton : public AliAnaGammaCorrelation {
+       
+  public: 
+       
+       AliAnaGammaParton() ; // default ctor
+       AliAnaGammaParton(const AliAnaGammaParton & g) ; // cpy ctor
+       AliAnaGammaParton & operator = (const AliAnaGammaParton & g) ;//cpy assignment
+       virtual ~AliAnaGammaParton() ; //virtual dtor
+              
+       TList * GetCreateOutputObjects();
+       
+       void InitParameters();
+       
+       void Print(const Option_t * opt) const;
+       
+       void MakeGammaCorrelation( TParticle * pGamma, TClonesArray *pl, TClonesArray *)  ;
+       
+  private:
+       
+       TH2F * fhDeltaEtaParton;
+       TH2F * fhDeltaPhiParton;
+       TH2F * fhDeltaPtParton;
+       TH2F * fhPtRatParton;
+       
+       ClassDef(AliAnaGammaParton,0)
+ } ;
+
+
+#endif //ALIANAGAMMAPARTON_H
+
+
+
index b20f113a9372669565b98cf48450c3603cb5b30c..057cbdc55c085fd5b4534ec552abf20a06b5f9a1 100644 (file)
@@ -138,7 +138,7 @@ void AliAnaGammaPhos::CreateOutputObjects()
 
   fhPHOSPos            = new TNtuple("PHOSPos"         , "Position in PHOS"  , "x:y:z");
   fhPHOS               = new TNtuple("PHOS"            , "PHOS"  , "event:digits:clusters:photons");
-  fhPHOSEnergy         = new TH1D("PHOSEnergy"         , "PHOSEnergy"        , 1000, 0., 10. ) ;
+  fhPHOSEnergy         = new TH1D("PHOSEnergy"         , "PHOSEnergy"        , 100, 0., 100. ) ;
   fhPHOSDigits         = new TH1I("PHOSDigitsCluster"  , "PHOSDigits"        , 20 , 0 , 20  ) ;
   fhPHOSRecParticles   = new TH1D("PHOSRecParticles"   , "PHOSRecParticles" , 20 , 0., 20. ) ;
   fhPHOSPhotons        = new TH1I("PHOSPhotons"        , "PHOSPhotons"       , 20 , 0 , 20  ) ;
diff --git a/PWG4/AliAnalysisTaskGamma.cxx b/PWG4/AliAnalysisTaskGamma.cxx
new file mode 100644 (file)
index 0000000..ba14f06
--- /dev/null
@@ -0,0 +1,187 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+#include <TROOT.h>
+#include <TSystem.h>
+#include <TInterpreter.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <Riostream.h>
+
+#include "AliAnalysisTaskGamma.h"
+#include "AliAnalysisManager.h"
+#include "AliMCEventHandler.h"
+#include "AliAnaGamma.h"
+#include "AliGammaReader.h"
+#include "AliESDEvent.h"
+#include "AliStack.h"
+#include "AliLog.h"
+
+ClassImp(AliAnalysisTaskGamma)
+
+////////////////////////////////////////////////////////////////////////
+
+AliAnalysisTaskGamma::AliAnalysisTaskGamma():
+    fAna(0x0),
+    fChain(0x0),
+    fESD(0x0),
+    fTreeG(0x0),//Not used for the moment
+    fOutputContainer(0x0)
+{
+  // Default constructor
+}
+
+//_____________________________________________________
+AliAnalysisTaskGamma::AliAnalysisTaskGamma(const char* name):
+    AliAnalysisTask(name, "AnalysisTaskGamma"),
+    fAna(0x0),
+    fChain(0x0),
+    fESD(0x0),
+    fTreeG(0x0),//Not used for the moment
+    fOutputContainer(0x0)
+{
+  // Default constructor
+  
+  Init();
+  DefineInput (0, TChain::Class());
+  //DefineOutput(0, TTree::Class());// to create AODs, to be done
+  DefineOutput(0, TList::Class());
+
+}
+
+//_____________________________________________________
+AliAnalysisTaskGamma::~AliAnalysisTaskGamma() 
+{
+
+  // Remove all pointers
+  fOutputContainer->Clear() ; 
+  delete fOutputContainer ;
+
+  delete fTreeG ; //Not used for the moment
+}
+
+//_____________________________________________________
+void AliAnalysisTaskGamma::CreateOutputObjects()
+{
+  // Create the output container
+  //OpenFile(0);
+  //fTreeG = new TTree ; // fAna->MakeTreeG("TreeG");// to create AODs, to be done
+  
+  OpenFile(0);
+  fOutputContainer = fAna->GetOutputContainer();
+
+}
+
+//_____________________________________________________
+void AliAnalysisTaskGamma::Init()
+{
+  // Initialization
+  AliDebug(1,"Begin");
+   
+  // Call configuration file
+  gROOT->LoadMacro("ConfigGammaAnalysis.C");
+  fAna = (AliAnaGamma*) gInterpreter->ProcessLine("ConfigGammaAnalysis()");
+  
+  if(!fAna)
+    AliFatal("Analysis pointer not initialized, abort analysis!");
+  
+  // Initialise Gamma Analysis
+  fAna->Init();
+  
+  //In case of MC analysis
+  Int_t  datatype = fAna->GetReader()->GetDataType();
+  if(datatype == AliGammaReader::kMC || datatype == AliGammaReader::kMCData ){
+    AliMCEventHandler * mc = new AliMCEventHandler();
+    (AliAnalysisManager::GetAnalysisManager())->SetMCtruthEventHandler(mc);
+  }
+  
+  AliDebug(1,"End");
+  
+}
+
+//_____________________________________________________
+void AliAnalysisTaskGamma::ConnectInputData(Option_t */*option*/)
+{
+  // Connect the input data
+  //
+  AliDebug(1,"ConnectInputData() ");
+  fChain = (TChain*)GetInputData(0);
+  fESD = new AliESDEvent();
+  fESD->ReadFromTree(fChain);
+  
+}
+
+//_____________________________________________________
+void AliAnalysisTaskGamma::Exec(Option_t */*option*/)
+{
+  // Execute analysis for current event
+  //
+
+  //Get the type of data, check if type is correct
+  Int_t  datatype = fAna->GetReader()->GetDataType();
+  if(datatype != AliGammaReader::kData && 
+     datatype != AliGammaReader::kMC && 
+     datatype != AliGammaReader::kMCData){
+    AliFatal("Wrong type of data");
+    return ;
+  }
+
+  //Get MC data
+  AliStack* stack = 0x0; 
+  if(datatype == AliGammaReader::kMC || datatype == AliGammaReader::kMCData ){
+    AliMCEventHandler*    mctruth = (AliMCEventHandler*) 
+      ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
+    
+    if(mctruth){
+      stack = mctruth->Stack();
+      //printf("AliAnalysisTaskJets: Number of tracks %5d\n", stack->GetNtrack());
+    }
+  }
+  
+  //Get Event
+  Long64_t ientry = fChain->GetReadEntry();
+  if ( !((ientry)%100) ) 
+    AliInfo(Form("Analysing event # %5d\n", (Int_t) ientry));
+  
+  //Pass ESD pointer to analysis      
+  if (!fESD) {
+    AliError("fESD is not connected to the input!") ; 
+    return ; 
+  } 
+  fAna->SetData(fESD);
+  
+  //In case of montecarlo analysis, pass the stack also.
+  if((datatype == AliGammaReader::kMC || datatype == AliGammaReader::kMCData ) && stack)
+    fAna -> SetKine(stack);
+  
+  //Process event
+  fAna->ProcessEvent(ientry);
+  
+  //PostData(0, fTreeG); // Create AODs, to be done.
+  PostData(0, fOutputContainer);
+  
+}
+
+//_____________________________________________________
+void AliAnalysisTaskGamma::Terminate(Option_t */*option*/)
+{
+  // Terminate analysis
+  //
+  AliDebug(1,"Do nothing in Terminate");
+}
+
diff --git a/PWG4/AliAnalysisTaskGamma.h b/PWG4/AliAnalysisTaskGamma.h
new file mode 100644 (file)
index 0000000..bbe3042
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef ALIANALYSISTASKGAMMA_H
+#define ALIANALYSISTASKGAMMA_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+#include "AliAnalysisTask.h"
+class AliAnaGamma;
+class AliESDEvent;
+class TChain;
+class TList;
+
+class AliAnalysisTaskGamma : public AliAnalysisTask
+{
+ public:
+    AliAnalysisTaskGamma();
+    AliAnalysisTaskGamma(const char* name);
+    virtual ~AliAnalysisTaskGamma() ;// virtual dtor
+    // Implementation of interface methods
+    virtual void ConnectInputData(Option_t *option = "");
+    virtual void CreateOutputObjects();
+    virtual void Init();
+    //virtual void LocalInit() {Init();}
+    virtual void Exec(Option_t *option);
+    virtual void Terminate(Option_t *option);
+   
+ private:
+
+    AliAnaGamma* fAna; //  Pointer to the jet finder 
+    TChain*       fChain;     //! chained files
+    AliESDEvent*       fESD;       //! ESD
+    TTree*        fTreeG;     //  tree of prompt gamma, does nothing for the moment 
+    TList * fOutputContainer ; // Histogram container
+
+    ClassDef(AliAnalysisTaskGamma, 0); // Analysis task for standard gamma correlation analysis
+};
+#endif //ALIANALYSISTASKGAMMA_H
diff --git a/PWG4/AliGammaDataReader.cxx b/PWG4/AliGammaDataReader.cxx
new file mode 100644 (file)
index 0000000..42c0f07
--- /dev/null
@@ -0,0 +1,280 @@
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for reading data (ESDs) in order to do prompt gamma correlations
+//  Class created from old AliPHOSGammaJet 
+//  (see AliRoot versions previous Release 4-09)
+//
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+#include "Riostream.h"
+#include <TParticle.h>
+
+//---- ANALYSIS system ----
+#include "AliGammaDataReader.h" 
+#include "AliLog.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+#include "AliESDCaloCluster.h"
+
+ClassImp(AliGammaDataReader)
+
+//____________________________________________________________________________
+AliGammaDataReader::AliGammaDataReader() : 
+  AliGammaReader(),  
+  fEMCALPID(0),fPHOSPID(0),
+  fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.), fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.)  
+{
+  //Default Ctor
+  
+  //Initialize parameters
+  fDataType=kData;
+  InitParameters();
+  
+}
+
+//____________________________________________________________________________
+AliGammaDataReader::AliGammaDataReader(const AliGammaDataReader & g) :   
+  AliGammaReader(g),
+  fEMCALPID(g.fEMCALPID), 
+  fPHOSPID(g.fPHOSPID),
+  fEMCALPhotonWeight(g.fEMCALPhotonWeight), 
+  fEMCALPi0Weight(g.fEMCALPi0Weight), 
+  fPHOSPhotonWeight(g.fPHOSPhotonWeight),
+  fPHOSPi0Weight(g.fPHOSPi0Weight)
+{
+  // cpy ctor
+}
+
+//_________________________________________________________________________
+AliGammaDataReader & AliGammaDataReader::operator = (const AliGammaDataReader & source)
+{
+  // assignment operator
+
+  if(&source == this) return *this;
+
+  fEMCALPID = source.fEMCALPID ;
+  fPHOSPID = source.fPHOSPID ;
+  fEMCALPhotonWeight = source. fEMCALPhotonWeight ;
+  fEMCALPi0Weight = source.fEMCALPi0Weight ;
+  fPHOSPhotonWeight = source.fPHOSPhotonWeight ;
+  fPHOSPi0Weight = source.fPHOSPi0Weight ;
+
+  return *this;
+
+}
+
+//____________________________________________________________________________
+void AliGammaDataReader::CreateParticleList(TObject * data, TObject *,
+                                           TClonesArray * plCTS, 
+                                           TClonesArray * plEMCAL,  
+                                           TClonesArray * plPHOS, TClonesArray*){
+  
+  //Create a list of particles from the ESD. These particles have been measured 
+  //by the Central Tracking system (TPC+ITS), PHOS and EMCAL 
+
+  AliESDEvent* esd = (AliESDEvent*) data;
+
+  Int_t npar  = 0 ;
+  Float_t *pid = new Float_t[AliPID::kSPECIESN];  
+   AliDebug(3,"Fill particle lists");
+  
+  //Get vertex for momentum calculation  
+  Double_t v[3] ; //vertex ;
+  esd->GetVertex()->GetXYZ(v) ; 
+  
+  //########### PHOS ##############
+  
+  Int_t begphos = 0;  
+  Int_t endphos = esd->GetNumberOfCaloClusters() ;  
+  Int_t indexPH = plPHOS->GetEntries() ;
+  Int_t begem = 0;
+  Int_t endem = endphos;
+
+  AliDebug(3,Form("First Calorimeter particle %d, last particle %d", begphos,endphos));
+  
+  for (npar =  begphos; npar <  endphos; npar++) {//////////////PHOS track loop
+    AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd
+
+    //Check if it is PHOS cluster
+    if(!clus->IsEMCAL())
+      begem=npar+1;
+    else
+      continue;
+
+    AliDebug(4,Form("PHOS clusters: E %f, match %d", clus->E(),clus->GetTrackMatched()));
+    if(clus->GetTrackMatched()==-1){
+      //Create a TParticle to fill the particle list
+      TLorentzVector momentum ;
+      clus->GetMomentum(momentum, v);      
+      Double_t phi = momentum.Phi();
+      if(phi<0) phi+=TMath::TwoPi() ;
+      if(momentum.Pt() > fNeutralPtCut &&  TMath::Abs(momentum.Eta()) < fPHOSEtaCut &&
+        phi > fPhiPHOSCut[0] && phi < fPhiPHOSCut[1] ) {
+       
+       pid=clus->GetPid();     
+       Int_t pdg = 22;
+       
+       if(fPHOSPID){
+         AliDebug(4, Form("PID: photon %f, pi0 %f, electron %f",pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron]));
+         if( pid[AliPID::kPhoton] > fPHOSPhotonWeight) pdg=22;
+         else if( pid[AliPID::kPi0] > fPHOSPi0Weight) pdg=111;
+         else pdg = 0;
+       }
+       
+       TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                            momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E(), v[0], v[1], v[2], 0);
+       
+       AliDebug(3,Form("PHOS added: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
+       
+       new((*plPHOS)[indexPH++])   TParticle(*particle) ;
+       
+      }//pt, eta, phi cut
+      else     AliDebug(4,"Particle not added");
+    }//not charged
+  }//cluster loop
+  
+  //########### CTS (TPC+ITS) #####################
+  Int_t begtpc   = 0 ;  
+  Int_t endtpc   = esd->GetNumberOfTracks() ;
+  Int_t indexCh  = plCTS->GetEntries() ;
+  AliDebug(3,Form("First CTS particle %d, last particle %d", begtpc,endtpc));
+  
+  for (npar =  begtpc; npar <  endtpc; npar++) {////////////// track loop
+    AliESDtrack * track = esd->GetTrack(npar) ; // retrieve track from esd
+    
+    //We want tracks fitted in the detectors:
+    ULong_t status=AliESDtrack::kTPCrefit;
+    status|=AliESDtrack::kITSrefit;
+    
+    //We want tracks whose PID bit is set:
+    //     ULong_t status =AliESDtrack::kITSpid;
+    //     status|=AliESDtrack::kTPCpid;
+    
+    if ( (track->GetStatus() & status) == status) {//Check if the bits we want are set
+      // Do something with the tracks which were successfully
+      // re-fitted 
+      Double_t en = 0; //track ->GetTPCsignal() ;
+      Double_t mom[3];
+      track->GetPxPyPz(mom) ;
+      Double_t px = mom[0];
+      Double_t py = mom[1];
+      Double_t pz = mom[2]; //Check with TPC people if this is correct.
+      Int_t pdg = 11; //Give any charged PDG code, in this case electron.
+      //I just want to tag the particle as charged
+       TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                           px, py, pz, en, v[0], v[1], v[2], 0);
+  
+      //TParticle * particle = new TParticle() ;
+      //particle->SetMomentum(px,py,pz,en) ;
+       if(particle->Pt() > fChargedPtCut && TMath::Abs(particle->Eta())<fCTSEtaCut)
+        new((*plCTS)[indexCh++])       TParticle(*particle) ;    
+    }
+  }
+  
+  //################ EMCAL ##############
+  
+  Int_t indexEM  = plEMCAL->GetEntries() ; 
+  //Int_t begem = esd->GetFirstEMCALCluster();  
+  //Int_t endem = esd->GetFirstEMCALCluster() + 
+  //esd->GetNumberOfEMCALClusters() ;  
+  
+  //AliDebug(3,Form("First EMCAL particle %d, last particle %d",begem,endem));
+  
+  for (npar =  begem; npar <  endem; npar++) {//////////////EMCAL track loop
+    AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd
+    Int_t clustertype= clus->GetClusterType();
+    AliDebug(4,Form("EMCAL clusters: E %f, match %d", clus->E(),clus->GetTrackMatched()));
+
+    if(clustertype == AliESDCaloCluster::kClusterv1 && clus->GetTrackMatched()==-1 ){
+      
+      TLorentzVector momentum ;
+      clus->GetMomentum(momentum, v); 
+      Double_t phi = momentum.Phi();
+      if(phi<0) phi+=TMath::TwoPi() ;
+      if(momentum.Pt() > fNeutralPtCut &&  TMath::Abs(momentum.Eta()) < fEMCALEtaCut &&
+       phi > fPhiEMCALCut[0] && phi < fPhiEMCALCut[1] ) {
+      
+       pid=clus->GetPid();     
+       Int_t pdg = 22;
+       if(fEMCALPID){
+         AliDebug(4, Form("PID: photon %f, pi0 %f, electron %f",pid[AliPID::kPhoton],pid[AliPID::kPi0],pid[AliPID::kElectron]));
+         if( pid[AliPID::kPhoton] > fEMCALPhotonWeight) pdg=22;
+         else if( pid[AliPID::kPi0] > fEMCALPi0Weight) pdg=111;
+         else pdg = 0 ;
+       }
+
+       
+       TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                            momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E(), v[0], v[1], v[2], 0);
+       AliDebug(3,Form("EMCAL added: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
+       
+       new((*plEMCAL)[indexEM++])   TParticle(*particle) ;
+  
+      }//pt, phi, eta cut
+      else     AliDebug(4,"Particle not added");
+    }//not charged, not pseudocluster
+  }//Cluster loop
+  
+  AliDebug(3,"Particle lists filled");
+  
+}
+
+  //____________________________________________________________________________
+void AliGammaDataReader::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+
+  //Fill particle lists when PID is ok
+  fEMCALPID = kFALSE;
+  fPHOSPID = kFALSE;
+  fEMCALPhotonWeight = 0.5 ;
+  fEMCALPi0Weight = 0.5 ;
+  fPHOSPhotonWeight = 0.8 ;
+
+}
+
+
+void AliGammaDataReader::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("PHOS PID on?               =     %d\n",  fPHOSPID) ; 
+  printf("EMCAL PID  on?         =     %d\n",  fEMCALPID) ;
+  printf("PHOS PID weight , photon  %f\n",  fPHOSPhotonWeight) ; 
+  printf("EMCAL PID weight, photon %f, pi0 %f\n",   fEMCALPhotonWeight,  fEMCALPi0Weight) ; 
+
+}
diff --git a/PWG4/AliGammaMCDataReader.cxx b/PWG4/AliGammaMCDataReader.cxx
new file mode 100644 (file)
index 0000000..8c11c70
--- /dev/null
@@ -0,0 +1,272 @@
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for reading data (Kinematics and ESDs) in order to do prompt gamma correlations
+//  Class created from old AliPHOSGammaJet 
+//  (see AliRoot versions previous Release 4-09)
+//
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+#include "Riostream.h"
+#include <TParticle.h>
+
+//---- ANALYSIS system ----
+#include "AliGammaMCDataReader.h" 
+#include "AliLog.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+#include "AliESDCaloCluster.h"
+#include "AliStack.h"
+
+ClassImp(AliGammaMCDataReader)
+
+//____________________________________________________________________________
+  AliGammaMCDataReader::AliGammaMCDataReader() : 
+    AliGammaReader(),  
+    fEMCALPID(0),fPHOSPID(0),
+    fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.), fPHOSPhotonWeight(0.),  fPHOSPi0Weight(0.) 
+{
+  //Default Ctor
+  
+  //Initialize parameters
+  fDataType=kMCData;
+  InitParameters();
+  
+}
+
+//____________________________________________________________________________
+AliGammaMCDataReader::AliGammaMCDataReader(const AliGammaMCDataReader & g) :   
+  AliGammaReader(g),
+  fEMCALPID(g.fEMCALPID), 
+  fPHOSPID(g.fPHOSPID),
+  fEMCALPhotonWeight(g.fEMCALPhotonWeight), 
+  fEMCALPi0Weight(g.fEMCALPi0Weight), 
+  fPHOSPhotonWeight(g.fPHOSPhotonWeight),
+  fPHOSPi0Weight(g.fPHOSPi0Weight)
+{
+  // cpy ctor
+}
+
+//_________________________________________________________________________
+AliGammaMCDataReader & AliGammaMCDataReader::operator = (const AliGammaMCDataReader & source)
+{
+  // assignment operator
+  
+  if(&source == this) return *this;
+  
+  fEMCALPID = source.fEMCALPID ;
+  fPHOSPID = source.fPHOSPID ;
+  fEMCALPhotonWeight = source. fEMCALPhotonWeight ;
+  fEMCALPi0Weight = source.fEMCALPi0Weight ;
+  fPHOSPhotonWeight = source.fPHOSPhotonWeight ;
+  fPHOSPi0Weight = source.fPHOSPi0Weight ;
+  
+  return *this;
+  
+}
+
+//____________________________________________________________________________
+void AliGammaMCDataReader::CreateParticleList(TObject * data, TObject * kine,
+                                             TClonesArray * plCTS, 
+                                             TClonesArray * plEMCAL,  
+                                             TClonesArray * plPHOS, TClonesArray *){
+  
+  //Create a list of particles from the ESD. These particles have been measured 
+  //by the Central Tracking system (TPC+ITS), PHOS and EMCAL 
+
+  AliESDEvent* esd = (AliESDEvent*) data;
+  AliStack* stack = (AliStack*) kine;
+  
+  Int_t npar  = 0 ;
+  Float_t *pid = new Float_t[AliPID::kSPECIESN];  
+  AliDebug(3,"Fill particle lists");
+  
+  //Get vertex for momentum calculation  
+  Double_t v[3] ; //vertex ;
+  esd->GetVertex()->GetXYZ(v) ; 
+  
+  //########### PHOS ##############
+  
+  Int_t begphos = esd->GetFirstPHOSCluster();  
+  Int_t endphos = esd->GetFirstPHOSCluster() + 
+    esd->GetNumberOfPHOSClusters() ;  
+  Int_t indexPH = plPHOS->GetEntries() ;
+  AliDebug(3,Form("First PHOS particle %d, last particle %d", begphos,endphos));
+  
+  for (npar =  begphos; npar <  endphos; npar++) {//////////////PHOS track loop
+    AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd
+    if(clus->GetTrackMatched()==-1 ){
+      //Create a TParticle to fill the particle list
+      TLorentzVector momentum ;
+      clus->GetMomentum(momentum, v);
+      pid=clus->GetPid();      
+      Int_t pdg = 22;
+
+      if(fPHOSPID){
+       if( pid[AliPID::kPhoton] > fPHOSPhotonWeight) pdg=22;
+       if( pid[AliPID::kPi0] > fPHOSPi0Weight) pdg=111;
+       else pdg = 0 ;
+      }
+      
+      TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                          momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E(), v[0], v[1], v[2], 0);
+
+      AliDebug(4,Form("PHOS clusters: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
+      
+      //Look  if parent is prompt photon
+      Int_t label = clus->GetLabel();
+      if(label>=0){
+       TParticle * pmother = stack->Particle(label);
+       Int_t imother = pmother->GetFirstMother(); 
+       if(imother == 6 || imother == 7)
+         pmother->SetFirstMother(22);
+      }
+      
+      new((*plPHOS)[indexPH++])   TParticle(*particle) ;
+    
+    }//not charged
+  }//cluster loop
+
+  //########### CTS (TPC+ITS) #####################
+  Int_t begtpc   = 0 ;  
+  Int_t endtpc   = esd->GetNumberOfTracks() ;
+  Int_t indexCh  = plCTS->GetEntries() ;
+  AliDebug(3,Form("First CTS particle %d, last particle %d", begtpc,endtpc));
+  
+  for (npar =  begtpc; npar <  endtpc; npar++) {////////////// track loop
+    AliESDtrack * track = esd->GetTrack(npar) ; // retrieve track from esd
+    
+    //We want tracks fitted in the detectors:
+    ULong_t status=AliESDtrack::kTPCrefit;
+    status|=AliESDtrack::kITSrefit;
+    
+    //We want tracks whose PID bit is set:
+    //     ULong_t status =AliESDtrack::kITSpid;
+    //     status|=AliESDtrack::kTPCpid;
+    
+    if ( (track->GetStatus() & status) == status) {//Check if the bits we want are set
+      // Do something with the tracks which were successfully
+      // re-fitted 
+      Double_t en = 0; //track ->GetTPCsignal() ;
+      Double_t mom[3];
+      track->GetPxPyPz(mom) ;
+      Double_t px = mom[0];
+      Double_t py = mom[1];
+      Double_t pz = mom[2]; //Check with TPC people if this is correct.
+      Int_t pdg = 11; //Give any charged PDG code, in this case electron.
+      //I just want to tag the particle as charged
+       TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                           px, py, pz, en, v[0], v[1], v[2], 0);
+  
+      //TParticle * particle = new TParticle() ;
+      //particle->SetMomentum(px,py,pz,en) ;
+      new((*plCTS)[indexCh++])       TParticle(*particle) ;    
+    }
+  }
+  
+  //################ EMCAL ##############
+  
+  Int_t indexEM  = plEMCAL->GetEntries() ; 
+  Int_t begem = esd->GetFirstEMCALCluster();  
+  Int_t endem = esd->GetFirstEMCALCluster() + 
+    esd->GetNumberOfEMCALClusters() ;  
+  
+  AliDebug(3,Form("First EMCAL particle %d, last particle %d",begem,endem));
+  
+  for (npar =  begem; npar <  endem; npar++) {//////////////EMCAL track loop
+    AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd
+    Int_t clustertype= clus->GetClusterType();
+    if(clustertype == AliESDCaloCluster::kClusterv1 && clus->GetTrackMatched()==-1 ){
+      
+      TLorentzVector momentum ;
+      clus->GetMomentum(momentum, v);            
+      pid=clus->GetPid();      
+      Int_t pdg = 22;
+
+      if(fEMCALPID){
+       if( pid[AliPID::kPhoton] > fEMCALPhotonWeight) pdg=22;
+       else if( pid[AliPID::kPi0] > fEMCALPi0Weight) pdg=111;
+       else pdg = 0;
+      }
+      
+      TParticle * particle = new TParticle(pdg, 1, -1, -1, -1, -1, 
+                                          momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E(), v[0], v[1], v[2], 0);
+      AliDebug(4,Form("EMCAL clusters: pt %f, phi %f, eta %f", particle->Pt(),particle->Phi(),particle->Eta()));
+
+      //Look  if parent is prompt photon
+      Int_t label = clus->GetLabel();
+      if(label>=0){
+       TParticle * pmother = stack->Particle(label);
+       Int_t imother = pmother->GetFirstMother(); 
+       if(imother == 6 || imother == 7)
+         pmother->SetFirstMother(22);
+      }
+      
+      new((*plEMCAL)[indexEM++])   TParticle(*particle) ;
+      
+    }//not charged, not pseudocluster
+  }//Cluster loop
+  
+  AliDebug(3,"Particle lists filled");
+  
+}
+
+  //____________________________________________________________________________
+void AliGammaMCDataReader::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+
+  //Fill particle lists when PID is ok
+  fEMCALPID = kFALSE;
+  fPHOSPID = kFALSE;
+  fEMCALPhotonWeight = 0.5 ;
+  fEMCALPi0Weight = 0.5 ;
+  fPHOSPhotonWeight = 0.8 ;
+  fPHOSPi0Weight = 0.5 ;
+
+}
+
+
+void AliGammaMCDataReader::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("PHOS PID on?               =     %d\n",  fPHOSPID) ; 
+  printf("EMCAL PID  on?         =     %d\n",  fEMCALPID) ;
+  printf("PHOS PID weight , photon  %f, pi0 %f\n\n",  fPHOSPhotonWeight,  fPHOSPi0Weight) ; 
+  printf("EMCAL PID weight, photon %f, pi0 %f\n",   fEMCALPhotonWeight,  fEMCALPi0Weight) ; 
+
+}
diff --git a/PWG4/AliGammaMCDataReader.h b/PWG4/AliGammaMCDataReader.h
new file mode 100644 (file)
index 0000000..dcd97a9
--- /dev/null
@@ -0,0 +1,78 @@
+#ifndef ALIGAMMAMCDATAREADER_H
+#define ALIGAMMAMCDATAREADER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for reading data (Kinematics and ESDs) in order to do prompt gamma correlations
+//  Class created from old AliPHOSGammaJet
+//  (see AliRoot versions previous Release 4-09)
+
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h> 
+#include <TClonesArray.h> 
+#include "AliGammaReader.h" 
+
+class AliESDEvent ;
+
+class AliGammaMCDataReader : public AliGammaReader {
+
+public: 
+
+  AliGammaMCDataReader() ; // ctor
+  AliGammaMCDataReader(const AliGammaMCDataReader & g) ; // cpy ctor
+  AliGammaMCDataReader & operator = (const AliGammaMCDataReader & g) ;//cpy assignment
+  virtual ~AliGammaMCDataReader() {;} //virtual dtor
+
+  void InitParameters();
+
+  Bool_t   IsEMCALPIDOn() const {return fEMCALPID ; }
+  Bool_t   IsPHOSPIDOn() const {return fPHOSPID ; }
+  Float_t  GetEMCALPhotonWeight() { return  fEMCALPhotonWeight  ; }
+  Float_t  GetEMCALPi0Weight()    {  return fEMCALPi0Weight  ; }
+  Float_t  GetPHOSPhotonWeight()  {  return fPHOSPhotonWeight  ; }
+  Float_t  GetPHOSPi0Weight()  {  return fPHOSPi0Weight  ; }
+  
+  void Print(const Option_t * opt)const;
+  
+  void SetEMCALPIDOn(Bool_t pid){ fEMCALPID= pid ; }
+  void SetPHOSPIDOn(Bool_t pid){ fPHOSPID= pid ; }
+  void SetEMCALPhotonWeight(Float_t  w){  fEMCALPhotonWeight = w ; }
+  void SetEMCALPi0Weight(Float_t  w){  fEMCALPi0Weight = w ; }
+  void SetPHOSPhotonWeight(Float_t  w){  fPHOSPhotonWeight = w ; }
+  void SetPHOSPi0Weight(Float_t  w){  fPHOSPi0Weight = w ; }
+
+  void CreateParticleList(TObject * esd, TObject * stack, TClonesArray * plCh, 
+                         TClonesArray * plEMCAL, TClonesArray * plPHOS, TClonesArray *);
+
+  
+ private:
+
+  Bool_t       fEMCALPID ;//Fill EMCAL particle lists with particles with corresponding pid
+  Bool_t       fPHOSPID;  //Fill PHOS particle lists with particles with corresponding pid
+  Float_t      fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL 
+  Float_t      fEMCALPi0Weight;  //Bayesian PID weight for pi0 in EMCAL 
+  Float_t      fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS 
+  Float_t      fPHOSPi0Weight; //Bayesian PID weight for pi0 in PHOS 
+
+  ClassDef(AliGammaMCDataReader,0)
+} ;
+
+#endif //ALIGAMMAMCDATAREADER_H
+
+
+
diff --git a/PWG4/AliGammaMCReader.cxx b/PWG4/AliGammaMCReader.cxx
new file mode 100644 (file)
index 0000000..a593f2e
--- /dev/null
@@ -0,0 +1,344 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for reading data (Kinematics) in order to do prompt gamma correlations
+//  Class created from old AliPHOSGammaJet 
+//  (see AliRoot versions previous Release 4-09)
+//
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+
+#include <TFile.h>
+#include <TParticle.h>
+#include <TH2.h>
+#include <TChain.h>
+#include <TRandom.h>
+
+//---- ANALYSIS system ----
+#include "AliGammaMCReader.h" 
+#include "Riostream.h"
+#include "AliLog.h"
+
+ClassImp(AliGammaMCReader)
+
+//____________________________________________________________________________
+AliGammaMCReader::AliGammaMCReader() : 
+  AliGammaReader(),
+  fEMCALIPDistance(0.),   fPHOSIPDistance(0.), 
+  fEMCALMinDistance(0.),   fPHOSMinDistance(0.), 
+  fDecayPi0(kFALSE)
+{
+  //Ctor
+  
+  //Initialize parameters
+  fDataType = kMC;
+  InitParameters();
+  
+  
+}
+
+//____________________________________________________________________________
+AliGammaMCReader::AliGammaMCReader(const AliGammaMCReader & g) :   
+  AliGammaReader(g),
+  fEMCALIPDistance(g.fEMCALIPDistance),  fPHOSIPDistance(g.fPHOSIPDistance),  
+  fEMCALMinDistance(g.fEMCALMinDistance),  fPHOSMinDistance(g.fPHOSMinDistance), 
+  fDecayPi0(g.fDecayPi0)
+{
+  // cpy ctor
+}
+
+//_________________________________________________________________________
+AliGammaMCReader & AliGammaMCReader::operator = (const AliGammaMCReader & source)
+{
+  // assignment operator
+
+  if(&source == this) return *this;
+
+  fEMCALIPDistance = source.fEMCALIPDistance; 
+  fPHOSIPDistance = source.fPHOSIPDistance; 
+  fEMCALMinDistance = source.fEMCALMinDistance; 
+  fPHOSMinDistance = source.fPHOSMinDistance; 
+  fDecayPi0 = source.fDecayPi0;
+
+  return *this;
+
+}
+
+
+//____________________________________________________________________________
+void AliGammaMCReader::CreateParticleList(TObject * data, TObject *, 
+                                        TClonesArray * plCh, 
+                                        TClonesArray * plEMCAL,  
+                                         TClonesArray * plPHOS,
+                                         TClonesArray *plParton)
+{
+  //Create list of particles from EMCAL, PHOS and CTS. 
+  AliStack * stack = (AliStack *) data ;
+  Int_t indexCh     = plCh->GetEntries() ;
+  Int_t indexEMCAL = plEMCAL->GetEntries() ;
+  Int_t indexPHOS = plPHOS->GetEntries() ;
+  Int_t indexParton = plParton->GetEntries() ;
+  Int_t iParticle = 0 ;
+  Double_t charge = 0.;
+    
+  for (iParticle=0 ; iParticle <  stack->GetNprimary() ; iParticle++) {
+    TParticle * particle = stack->Particle(iParticle); 
+    
+    //Keep partons
+    if(particle->GetStatusCode() == 21 && iParticle>=2){//All partons, not nucleus
+      new((*plParton)[indexParton++])  TParticle(*particle) ;
+    }
+
+    //Keep Stable particles 
+    if((particle->GetStatusCode() == 0) && (particle->Pt() > 0)){
+      
+      charge = TDatabasePDG::Instance()->GetParticle(particle->GetPdgCode())->Charge();
+      
+      //---------- Charged particles ----------------------
+      if((charge != 0) && (particle->Pt() > fChargedPtCut)){
+       //Particles in CTS acceptance
+       if(TMath::Abs(particle->Eta())<fCTSEtaCut){  
+         //Fill lists
+         new((*plCh)[indexCh++])       TParticle(*particle) ;
+       }
+      }
+      //-------------Neutral particles ----------------------
+      else if((charge == 0) && particle->Pt() > fNeutralPtCut &&  
+             TMath::Abs(particle->GetPdgCode())>16){//Avoid neutrinos
+       
+       if(particle->GetPdgCode()!=111){
+         if(IsInPHOS(particle->Phi(),particle->Eta()))
+           new((*plPHOS)[indexPHOS++])  TParticle(*particle) ;
+         else if(IsInEMCAL(particle->Phi(),particle->Eta()))
+           new((*plEMCAL)[indexEMCAL++])  TParticle(*particle) ;
+       }//no pi0
+       else{
+         if(fDecayPi0 == kNoDecay){//keep the pi0 do not decay
+           if(IsInPHOS(particle->Phi(),particle->Eta()))
+             new((*plPHOS)[indexPHOS++])  TParticle(*particle) ;
+           else if(IsInEMCAL(particle->Phi(),particle->Eta()))
+             new((*plEMCAL)[indexEMCAL++])  TParticle(*particle) ;
+         }
+         else if(fDecayPi0 == kDecay)
+           MakePi0Decay(particle,plEMCAL,indexEMCAL,plPHOS, indexPHOS);
+         else if(fDecayPi0 == kGeantDecay)
+           SetGeantDecay(particle, stack,plEMCAL, indexEMCAL, plPHOS, indexPHOS);
+       }//pi0  
+      }//neutral particle
+    }//stable particle
+  }//particle loop
+}
+
+//___________________________________________________________________________
+Bool_t  AliGammaMCReader::IsInEMCAL(Double_t phi, Double_t eta){
+  //Check if particle is in EMCAL acceptance
+  if(phi<0)
+     phi+=TMath::TwoPi();
+     if( phi > fPhiEMCALCut[0] && phi < fPhiEMCALCut[1] && 
+       TMath::Abs(eta)<fEMCALEtaCut) return kTRUE ;
+  else  return kFALSE;     
+  
+  return kFALSE ;
+}
+
+//___________________________________________________________________________
+Bool_t  AliGammaMCReader::IsInPHOS(Double_t phi, Double_t eta){
+  //Check if particle is in EMCAL acceptance
+  if(phi<0)
+    phi+=TMath::TwoPi();
+  if( phi > fPhiPHOSCut[0] && phi < fPhiPHOSCut[1] && 
+      TMath::Abs(eta)<fPHOSEtaCut) return kTRUE ;
+  else  return kFALSE;
+  
+  return kFALSE ;
+}
+
+//___________________________________________________________________________
+void AliGammaMCReader::SetGeantDecay(TParticle * particle, AliStack * stack,
+                                    TClonesArray * plEMCAL, Int_t &indexEMCAL,
+                                    TClonesArray * plPHOS, Int_t &indexPHOS){
+  //Find decay gamma from pi0 and put them in the list.
+  
+  Int_t ndaug = particle->GetNDaughters() ;
+  if(ndaug<=2 && ndaug >0){//At least 1 daugther
+    TParticle * d1 = stack->Particle(particle->GetDaughter(0));
+    if(d1->GetPdgCode()==22){
+      if(IsInEMCAL(d1->Phi(),d1->Eta()))
+       new((*plEMCAL)[indexEMCAL++])       TParticle(*d1) ;
+      else if(IsInPHOS(d1->Phi(),d1->Eta()))
+       new((*plPHOS)[indexPHOS++])       TParticle(*d1) ;
+    }
+    
+    if(ndaug>1){//second daugther if present
+      TParticle * d2 = stack->Particle(particle->GetDaughter(1));
+      if(IsInEMCAL(d2->Phi(),d2->Eta()))
+       new((*plEMCAL)[indexEMCAL++])       TParticle(*d2) ;
+      else if(IsInPHOS(d2->Phi(),d2->Eta()))
+       new((*plPHOS)[indexPHOS++])       TParticle(*d2) ;
+    }
+  }
+}
+
+//___________________________________________________________________________
+void AliGammaMCReader::MakePi0Decay(TParticle * particle, 
+                                   TClonesArray * plEMCAL, Int_t &indexEMCAL,
+                                   TClonesArray * plPHOS, Int_t &indexPHOS){
+  
+  //Decays pi0, see if aperture angle is small and then add the pi0 or the 2 gamma
+  
+  TLorentzVector pPi0, pGamma1, pGamma2 ;
+  Double_t angle = 0, cellDistance = 0.;
+  Bool_t checkPhoton = kTRUE;
+  
+  pPi0.SetPxPyPzE(particle->Px(),particle->Py(),particle->Pz(),particle->Energy());
+  
+  //Decay
+  Pi0Decay(pPi0,pGamma1,pGamma2,angle);
+  
+  //Check if Pi0 is in the acceptance of the calorimeters, if aperture angle is small, keep it
+  if(IsInPHOS(particle->Phi(), particle->Eta())){
+    cellDistance = angle*fPHOSIPDistance;
+    if (cellDistance < fPHOSMinDistance){
+      new((*plPHOS)[indexPHOS++])       TParticle(*particle) ;
+      checkPhoton = kFALSE;
+    }
+  } 
+  else if(IsInEMCAL(particle->Phi(), particle->Eta())){
+    cellDistance = angle*fEMCALIPDistance;
+    if (cellDistance < fEMCALMinDistance) {
+      new((*plEMCAL)[indexEMCAL++])       TParticle(*particle) ;
+      checkPhoton = kFALSE;
+    }
+  } 
+  else checkPhoton = kTRUE ;
+  
+  if (checkPhoton) {
+    //Gamma Not overlapped
+    TParticle * photon1 = new TParticle(22,1,0,0,0,0,pGamma1.Px(),pGamma1.Py(),
+                                       pGamma1.Pz(),pGamma1.E(),0,0,0,0);    
+    if(photon1->Pt() > fNeutralPtCut) {
+      
+      if(IsInPHOS(photon1->Phi(), photon1->Eta()))
+       new((*plPHOS)[indexPHOS++])       TParticle(*photon1) ;
+      
+      else if(IsInEMCAL(photon1->Phi(), photon1->Eta()))
+       new((*plEMCAL)[indexEMCAL++])       TParticle(*photon1) ;
+      
+    }// photon 1 of pi0 in acceptance
+    
+    
+    TParticle * photon2 = new TParticle(22,1,0,0,0,0,pGamma2.Px(),pGamma2.Py(),
+                                       pGamma2.Pz(),pGamma2.E(),0,0,0,0);
+    
+    if(photon2->Pt() > fNeutralPtCut) {
+      
+      if(IsInPHOS(photon2->Phi(), photon2->Eta()))
+       new((*plPHOS)[indexPHOS++])       TParticle(*photon2) ;
+      
+      else if(IsInEMCAL(photon2->Phi(), photon2->Eta()))
+       new((*plEMCAL)[indexEMCAL++])       TParticle(*photon2) ;
+      
+    }// photon 2 of pi0 in acceptance
+  }//Not overlapped gamma
+}
+
+
+//_______________________________________________________________
+void AliGammaMCReader::InitParameters()
+{
+  
+  //Initialize the parameters of the analysis.
+  
+  //Fill particle lists when PID is ok
+  fEMCALMinDistance    = 10. ;  
+  fPHOSMinDistance    = 3.6 ;
+  fEMCALIPDistance    = 450. ;//cm  
+  fPHOSIPDistance    = 460. ;//cm
+  fDecayPi0 = kGeantDecay;
+}
+
+//____________________________________________________________________________
+void AliGammaMCReader::Pi0Decay(TLorentzVector &p0, TLorentzVector &p1, 
+                               TLorentzVector &p2, Double_t &angle) {
+  // Perform isotropic decay pi0 -> 2 photons
+  // p0 is pi0 4-momentum (inut)
+  // p1 and p2 are photon 4-momenta (output)
+  //  cout<<"Boost vector"<<endl;
+  Double_t mPi0 = TDatabasePDG::Instance()->GetParticle(111)->Mass();
+  TVector3 b = p0.BoostVector();
+  //cout<<"Parameters"<<endl;
+  //Double_t mPi0   = p0.M();
+  Double_t phi    = TMath::TwoPi() * gRandom->Rndm();
+  Double_t cosThe = 2 * gRandom->Rndm() - 1;
+  Double_t cosPhi = TMath::Cos(phi);
+  Double_t sinPhi = TMath::Sin(phi);
+  Double_t sinThe = TMath::Sqrt(1-cosThe*cosThe);
+  Double_t ePi0   = mPi0/2.;
+  //cout<<"ePi0 "<<ePi0<<endl;
+  //cout<<"Components"<<endl;
+  p1.SetPx(+ePi0*cosPhi*sinThe);
+  p1.SetPy(+ePi0*sinPhi*sinThe);
+  p1.SetPz(+ePi0*cosThe);
+  p1.SetE(ePi0);
+  //cout<<"p1: "<<p1.Px()<<" "<<p1.Py()<<" "<<p1.Pz()<<" "<<p1.E()<<endl;
+  //cout<<"p1 Mass: "<<p1.Px()*p1.Px()+p1.Py()*p1.Py()+p1.Pz()*p1.Pz()-p1.E()*p1.E()<<endl;
+  p2.SetPx(-ePi0*cosPhi*sinThe);
+  p2.SetPy(-ePi0*sinPhi*sinThe);
+  p2.SetPz(-ePi0*cosThe);
+  p2.SetE(ePi0);
+  //cout<<"p2: "<<p2.Px()<<" "<<p2.Py()<<" "<<p2.Pz()<<" "<<p2.E()<<endl;
+  //cout<<"p2 Mass: "<<p2.Px()*p2.Px()+p2.Py()*p2.Py()+p2.Pz()*p2.Pz()-p2.E()*p2.E()<<endl;
+  //cout<<"Boost "<<b.X()<<" "<<b.Y()<<" "<<b.Z()<<endl;
+  p1.Boost(b);
+  //cout<<"p1: "<<p1.Px()<<" "<<p1.Py()<<" "<<p1.Pz()<<" "<<p1.E()<<endl;
+  p2.Boost(b);
+  //cout<<"p2: "<<p2.Px()<<" "<<p2.Py()<<" "<<p2.Pz()<<" "<<p2.E()<<endl;
+  //cout<<"angle"<<endl;
+  angle = p1.Angle(p2.Vect());
+  //cout<<angle<<endl;
+}
+
+//________________________________________________________________
+void AliGammaMCReader::Print(const Option_t * opt) const
+{
+  
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  
+  printf("IP distance to PHOS         : %f\n", fPHOSIPDistance) ;
+  printf("IP distance to EMCAL         : %f\n", fEMCALIPDistance) ;
+  printf("Min gamma decay distance in PHOS         : %f\n", fPHOSMinDistance) ;
+  printf("Min gamma decay distance in EMCAL         : %f\n", fEMCALMinDistance) ;
+  printf("Decay Pi0?          : %d\n", fDecayPi0) ;
+  
+}
diff --git a/PWG4/AliGammaMCReader.h b/PWG4/AliGammaMCReader.h
new file mode 100644 (file)
index 0000000..b1ab3b6
--- /dev/null
@@ -0,0 +1,90 @@
+#ifndef ALIGAMMAMCREADER_H
+#define ALIGAMMAMCREADER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class for reading data (Kinematics) in order to do prompt gamma correlations
+//  Class created from old AliPHOSGammaJet
+//  (see AliRoot versions previous Release 4-09)
+
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h> 
+#include <TClonesArray.h> 
+#include "AliStack.h"
+#include "AliGammaReader.h" 
+class TH2F ; 
+
+class AliGammaMCReader : public AliGammaReader {
+
+public: 
+
+  AliGammaMCReader() ; // ctor
+  AliGammaMCReader(const AliGammaMCReader & g) ; // cpy ctor
+  AliGammaMCReader & operator = (const AliGammaMCReader & g) ;//cpy assignment
+  virtual ~AliGammaMCReader() {;} //virtual dtor
+
+  enum decay_t {kNoDecay, kGeantDecay, kDecay};
+  void InitParameters();
+
+  Bool_t  IsInEMCAL(Double_t phi, Double_t eta) ;
+  Bool_t  IsInPHOS(Double_t phi, Double_t eta) ;
+
+  Int_t    GetDecayPi0Flag() const {return fDecayPi0 ; }
+  Float_t  GetEMCALIPDistance()  {  return fEMCALIPDistance ; }
+  Float_t  GetPHOSIPDistance()  {  return fPHOSIPDistance ; }
+  Float_t  GetEMCALMinDistance()  {  return fEMCALMinDistance ; }
+  Float_t  GetPHOSMinDistance()  {  return fPHOSMinDistance ; }
+
+  void Print(const Option_t * opt)const;
+  
+  void SetDecayPi0Flag(Int_t d){ fDecayPi0 = d ; }
+  void SetEMCALIPDistance(Float_t  d){  fEMCALIPDistance = d ; }
+  void SetPHOSIPDistance(Float_t  d){  fPHOSIPDistance = d ; }
+  void SetEMCALMinDistance(Float_t  d){  fEMCALMinDistance = d ; }
+  void SetPHOSMinDistance(Float_t  d){  fPHOSMinDistance = d ; }
+
+  void CreateParticleList(TObject * stack, TObject * ,
+                         TClonesArray * plCh, TClonesArray * plEMCAL, 
+                         TClonesArray * plPHOS, TClonesArray * plParton);
+  void MakePi0Decay(TParticle * particle, TClonesArray * plEMCAL, Int_t &indexEMCAL,
+                   TClonesArray * plPHOS, Int_t &indexPHOS);
+  
+  void Pi0Decay(TLorentzVector &p0, TLorentzVector &p1, TLorentzVector &p2, 
+               Double_t &angle);
+
+  void SetGeantDecay(TParticle * particle, AliStack * stack,
+                    TClonesArray * plEMCAL, Int_t &indexEMCAL,
+                    TClonesArray * plPHOS, Int_t &indexPHOS);
+ private:
+
+  Float_t      fEMCALIPDistance; //Calorimeter IP distance.
+  Float_t      fPHOSIPDistance; //Calorimeter IP distance
+  Float_t      fEMCALMinDistance; //Gamma decay minimum aperture.
+  Float_t      fPHOSMinDistance; //Gamma decay minimum aperture.
+
+  Int_t      fDecayPi0; //Decay Pi0.
+
+  ClassDef(AliGammaMCReader,0)
+} ;
+
+#endif //ALIGAMMAMCREADER_H
+
+
+
diff --git a/PWG4/AliGammaReader.cxx b/PWG4/AliGammaReader.cxx
new file mode 100644 (file)
index 0000000..209e570
--- /dev/null
@@ -0,0 +1,137 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for reading data in order to do prompt gamma correlations
+//*-- Author: Gustavo Conesa (LNF-INFN) 
+//////////////////////////////////////////////////////////////////////////////
+
+
+// --- ROOT system ---
+
+//---- ANALYSIS system ----
+#include "Riostream.h"
+#include "AliLog.h"
+#include "AliGammaReader.h"
+
+ClassImp(AliGammaReader)
+
+
+//____________________________________________________________________________
+AliGammaReader::AliGammaReader() : 
+  TObject(), fDataType(0),
+  fCTSEtaCut(0.), fEMCALEtaCut(0.), fPHOSEtaCut(0.),
+  fNeutralPtCut(0.),
+  fChargedPtCut(0.)
+{
+  //Ctor
+
+  fPhiEMCALCut[0]=0.;
+  fPhiEMCALCut[1]=0.;
+  fPhiPHOSCut[0]=0.;
+  fPhiPHOSCut[1]=0.;
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliGammaReader::AliGammaReader(const AliGammaReader & g) :   
+  TObject(g), fDataType(g.fDataType),
+  fCTSEtaCut(g.fCTSEtaCut),  fEMCALEtaCut(g.fEMCALEtaCut),  fPHOSEtaCut(g.fPHOSEtaCut),
+  fNeutralPtCut(g.fNeutralPtCut),
+  fChargedPtCut(g.fChargedPtCut)
+{
+  // cpy ctor
+
+  fPhiEMCALCut[0]=g.fPhiEMCALCut[0];
+  fPhiEMCALCut[1]=g.fPhiEMCALCut[1];
+  fPhiPHOSCut[0]=g.fPhiPHOSCut[0];
+  fPhiPHOSCut[1]=g.fPhiPHOSCut[1];
+}
+
+//_________________________________________________________________________
+AliGammaReader & AliGammaReader::operator = (const AliGammaReader & source)
+{
+  // assignment operator
+
+  if(&source == this) return *this;
+
+  fDataType = source.fDataType ;
+  fCTSEtaCut = source.fCTSEtaCut;  
+  fEMCALEtaCut = source.fEMCALEtaCut;  
+  fPHOSEtaCut = source.fPHOSEtaCut;
+  fNeutralPtCut = source.fNeutralPtCut;
+  fChargedPtCut = source.fChargedPtCut; 
+
+  fPhiEMCALCut[0]=source.fPhiEMCALCut[0];
+  fPhiEMCALCut[1]=source.fPhiEMCALCut[1];
+  fPhiPHOSCut[0]=source.fPhiPHOSCut[0];
+  fPhiPHOSCut[1]=source.fPhiPHOSCut[1];
+
+  return *this;
+
+}
+
+//_______________________________________________________________
+void AliGammaReader::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+  fDataType = kData ;
+  fCTSEtaCut         = 0.7 ;  
+  fEMCALEtaCut         = 0.7 ;  
+  fPHOSEtaCut         = 0.12 ;
+  fPhiEMCALCut[0] = 80 *TMath::DegToRad();
+  fPhiEMCALCut[1] = 190*TMath::DegToRad();
+  fPhiPHOSCut[0] = 220. *TMath::DegToRad();
+  fPhiPHOSCut[1] = 320.*TMath::DegToRad();
+  fNeutralPtCut   = 0.5 ;
+  fChargedPtCut   = 0.5 ;
+
+}
+
+
+//________________________________________________________________
+void AliGammaReader::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+  printf("Data type           : %d\n", fDataType) ;
+  printf("CTS Eta cut           : %f\n", fCTSEtaCut) ;
+  printf("EMCAL Eta cut           : %f\n", fEMCALEtaCut) ;
+  printf("PHOS Eta cut           : %f\n", fPHOSEtaCut) ;
+  printf("Phi EMCAL cut           : [%f, %f]\n", fPhiEMCALCut[0],fPhiEMCALCut[1]) ;
+  printf("Phi PHOS cut           : [%f, %f]\n", fPhiPHOSCut[0],fPhiPHOSCut[1]) ;
+  printf("pT neutral cut           : %f GeV/c\n", fNeutralPtCut) ;
+  printf("pT charged cut           : %f GeV/c\n", fChargedPtCut) ;
+
+} 
+
+
diff --git a/PWG4/AliGammaReader.h b/PWG4/AliGammaReader.h
new file mode 100644 (file)
index 0000000..6ae0f4c
--- /dev/null
@@ -0,0 +1,86 @@
+#ifndef ALIGAMMAREADER_H
+#define ALIGAMMAREADER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Base class for reading data in order to do prompt gamma correlations 
+//*-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h> 
+#include <TClonesArray.h> 
+#include "AliStack.h"
+#include "TObject.h" 
+class AliESD ; 
+
+class TH2F ; 
+
+class AliGammaReader : public TObject {
+
+public: 
+
+  AliGammaReader() ; // ctor
+  AliGammaReader(const AliGammaReader & g) ; // cpy ctor
+  AliGammaReader & operator = (const AliGammaReader & g) ;//cpy assignment
+  virtual ~AliGammaReader() {;} //virtual dtor
+
+  enum datatype_t {kData, kMC, kMCData};
+  
+  void InitParameters();
+
+  Int_t GetDataType(){ return fDataType ; }
+  void SetDataType(Int_t data ){fDataType = data ; }
+
+  virtual Float_t   GetCTSEtaCut() const {return fCTSEtaCut ; }
+  virtual Float_t   GetEMCALEtaCut() const {return fEMCALEtaCut ; }
+  virtual Float_t   GetPHOSEtaCut() const {return fPHOSEtaCut ; }
+  virtual Float_t  GetPhiEMCALCut(Int_t i) { return  fPhiEMCALCut[i]  ; }
+  virtual Float_t  GetPhiPHOSCut(Int_t i) { return  fPhiPHOSCut[i]  ; }
+  virtual Float_t  GetNeutralPtCut()    {  return fNeutralPtCut  ; }
+  virtual Float_t  GetChargedPtCut()  {  return fChargedPtCut  ; }
+
+  virtual void Print(const Option_t * opt)const;
+  
+  virtual void SetCTSEtaCut(Float_t eta){ fCTSEtaCut= eta ; }
+  virtual void SetEMCALEtaCut(Float_t eta){ fEMCALEtaCut= eta ; }
+  virtual void SetPHOSEtaCut(Float_t eta){ fPHOSEtaCut= eta ; }
+  virtual void SetPhiEMCALCut(Float_t  phi0, Float_t  phi1)
+  { fPhiEMCALCut[0]= phi0 ; fPhiEMCALCut[1]= phi1 ;}
+  virtual void SetPhiPHOSCut(Float_t  phi0, Float_t  phi1)
+  { fPhiPHOSCut[0]= phi0 ; fPhiPHOSCut[1]= phi1 ;}
+  virtual void SetNeutralPtCut(Float_t  pt){  fNeutralPtCut = pt ; }
+  virtual void SetChargedPtCut(Float_t  pt){  fChargedPtCut = pt ; }
+
+  virtual void CreateParticleList(TObject* data, TObject * data2, 
+                                 TClonesArray * plCh, TClonesArray * plEMCAL, 
+                                 TClonesArray * plPHOS, TClonesArray * parton) {;}
+ protected:
+  Int_t        fDataType ;
+  Float_t      fCTSEtaCut ;//CTS  pseudorapidity acceptance
+  Float_t      fEMCALEtaCut ;//EMCAL pseudorapidity acceptance
+  Float_t      fPHOSEtaCut ;//PHOS pseudorapidity acceptance
+  Float_t      fPhiEMCALCut[2]; //EMCAL phi acceptance 
+  Float_t      fPhiPHOSCut[2];  //PHOS phi acceptance
+  Float_t      fNeutralPtCut; //
+  Float_t      fChargedPtCut;  // 
+
+   ClassDef(AliGammaReader,0)
+} ;
+
+#endif //ALIGAMMAREADER_H
+
+
+
diff --git a/PWG4/AliNeutralMesonSelection.cxx b/PWG4/AliNeutralMesonSelection.cxx
new file mode 100644 (file)
index 0000000..dfdcfa9
--- /dev/null
@@ -0,0 +1,353 @@
+ /**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+
+//_________________________________________________________________________
+// Class that contains methods to select candidate pairs to neutral meson 
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include <TParticle.h>
+#include <TLorentzVector.h>
+#include <TH2.h>
+#include <TList.h>
+
+//---- AliRoot system ----
+#include "AliNeutralMesonSelection.h" 
+#include "Riostream.h"
+#include "AliLog.h"
+
+ClassImp(AliNeutralMesonSelection)
+  
+  
+//____________________________________________________________________________
+  AliNeutralMesonSelection::AliNeutralMesonSelection() : 
+    TObject(), fSelect(0), fM(0),
+    fInvMassMaxCut(0.), fInvMassMinCut(0.),
+    fAngleMaxParam(),  fMinPt(0),
+    fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.),
+    fRatioMaxCut(0), fRatioMinCut(0),  fKeepNeutralMesonHistos(0),
+    fhAnglePairNoCut(0),  fhAnglePairCorrelationCut(0),
+    fhAnglePairOpeningAngleCut(0), fhAnglePairAllCut(0), 
+    fhInvMassPairNoCut(0),   fhInvMassPairCorrelationCut(0), 
+    fhInvMassPairOpeningAngleCut(0), fhInvMassPairAllCut(0) 
+{
+  //Default Ctor
+  
+  //Initialize parameters
+  
+  // kGammaHadron and kGammaJet 
+  fAngleMaxParam.Set(4) ;
+  fAngleMaxParam.Reset(0.);
+  
+  //Initialize parameters
+  InitParameters();
+}
+
+//____________________________________________________________________________
+AliNeutralMesonSelection::AliNeutralMesonSelection(const AliNeutralMesonSelection & g) :   
+  TObject(),  
+  fSelect(g.fSelect), fM(g.fM),
+  fInvMassMaxCut(g.fInvMassMaxCut), fInvMassMinCut(g.fInvMassMinCut),
+  fAngleMaxParam(g.fAngleMaxParam), fMinPt(g.fMinPt),
+  fDeltaPhiMaxCut(g.fDeltaPhiMaxCut), fDeltaPhiMinCut(g.fDeltaPhiMinCut), 
+  fRatioMaxCut(g.fRatioMaxCut), fRatioMinCut(g.fRatioMinCut), 
+  fKeepNeutralMesonHistos(g.fKeepNeutralMesonHistos),
+  fhAnglePairNoCut(g. fhAnglePairNoCut), 
+  fhAnglePairCorrelationCut(g. fhAnglePairCorrelationCut), 
+  fhAnglePairOpeningAngleCut(g. fhAnglePairOpeningAngleCut), 
+  fhAnglePairAllCut(g. fhAnglePairAllCut), 
+  fhInvMassPairNoCut(g.fhInvMassPairNoCut),  
+  fhInvMassPairCorrelationCut(g.fhInvMassPairCorrelationCut), 
+  fhInvMassPairOpeningAngleCut(g.fhInvMassPairOpeningAngleCut), 
+  fhInvMassPairAllCut(g.fhInvMassPairAllCut)
+{
+  // cpy ctor
+}
+
+//_________________________________________________________________________
+AliNeutralMesonSelection & AliNeutralMesonSelection::operator = (const AliNeutralMesonSelection & source)
+{
+  // assignment operator
+  
+  if(this == &source)return *this;
+  ((TObject *)this)->operator=(source);
+
+  fSelect = source.fSelect ;
+  fM = source.fM ;
+  fInvMassMaxCut = source.fInvMassMaxCut ; 
+  fInvMassMinCut = source.fInvMassMinCut ;
+  fAngleMaxParam = source.fAngleMaxParam ;
+  fMinPt = source.fMinPt ;
+  fDeltaPhiMaxCut = source.fDeltaPhiMaxCut ; 
+  fDeltaPhiMinCut = source.fDeltaPhiMinCut ; 
+  fRatioMaxCut = source.fRatioMaxCut ; 
+  fRatioMinCut = source.fRatioMinCut ;
+  fKeepNeutralMesonHistos = source.fKeepNeutralMesonHistos;
+  fhAnglePairNoCut = source. fhAnglePairNoCut ; 
+  fhAnglePairCorrelationCut = source. fhAnglePairCorrelationCut ; 
+  fhAnglePairOpeningAngleCut = source. fhAnglePairOpeningAngleCut ; 
+  fhAnglePairAllCut = source. fhAnglePairAllCut ; 
+  fhInvMassPairNoCut = source.fhInvMassPairNoCut ; 
+  fhInvMassPairCorrelationCut = source.fhInvMassPairCorrelationCut ; 
+  fhInvMassPairOpeningAngleCut = source.fhInvMassPairOpeningAngleCut ; 
+  fhInvMassPairAllCut = source.fhInvMassPairAllCut ; 
+  
+  return *this;
+  
+}
+
+//____________________________________________________________________________
+AliNeutralMesonSelection::~AliNeutralMesonSelection() 
+{
+  // Remove all pointers
+    
+  delete fhAnglePairNoCut  ; 
+  delete fhAnglePairCorrelationCut  ; 
+  delete fhAnglePairOpeningAngleCut   ; 
+  delete fhAnglePairAllCut   ;  
+  delete fhInvMassPairNoCut    ; 
+  delete fhInvMassPairCorrelationCut    ; 
+  delete fhInvMassPairOpeningAngleCut  ; 
+  delete fhInvMassPairAllCut   ;    
+  
+}
+
+
+
+//________________________________________________________________________
+TList *  AliNeutralMesonSelection::GetCreateOutputObjects()
+{  
+
+  // Create histograms to be saved in output file and 
+  // store them in outputContainer
+  TList * outputContainer = new TList() ; 
+  outputContainer->SetName("MesonDecayHistos") ; 
+  
+  fhAnglePairNoCut  = new TH2F
+    ("AnglePairNoCut",
+     "Angle between all #gamma pair vs E_{#pi^{0}}",200,0,50,200,0,0.2); 
+  fhAnglePairNoCut->SetYTitle("Angle (rad)");
+  fhAnglePairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhAnglePairOpeningAngleCut  = new TH2F
+    ("AnglePairOpeningAngleCut",
+     "Angle between all #gamma pair (opening angle + azimuth cut) vs E_{#pi^{0}}"
+     ,200,0,50,200,0,0.2); 
+  fhAnglePairOpeningAngleCut->SetYTitle("Angle (rad)");
+  fhAnglePairOpeningAngleCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhAnglePairAllCut  = new TH2F
+    ("AnglePairAllCut",
+     "Angle between all #gamma pair (opening angle + inv mass cut+azimuth) vs E_{#pi^{0}}"
+     ,200,0,50,200,0,0.2); 
+  fhAnglePairAllCut->SetYTitle("Angle (rad)");
+  fhAnglePairAllCut->SetXTitle("E_{ #pi^{0}} (GeV)");    
+  
+  //
+  fhInvMassPairNoCut  = new TH2F
+    ("InvMassPairNoCut","Invariant Mass of all #gamma pair vs E_{#pi^{0}}",
+     120,0,120,360,0,0.5); 
+  fhInvMassPairNoCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairNoCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  fhInvMassPairOpeningAngleCut  = new TH2F
+    ("InvMassPairOpeningAngleCut",
+     "Invariant Mass of #gamma pair (angle cut) vs E_{#pi^{0}}",
+     120,0,120,360,0,0.5); 
+  fhInvMassPairOpeningAngleCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairOpeningAngleCut->SetXTitle(" E_{#pi^{0}}(GeV)");
+  
+  fhInvMassPairAllCut  = new TH2F
+    ("InvMassPairAllCut",
+     "Invariant Mass of #gamma pair (opening angle+invmass cut) vs E_{#pi^{0}}",
+     120,0,120,360,0,0.5); 
+  fhInvMassPairAllCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairAllCut->SetXTitle("E_{#pi^{0}}(GeV)");
+
+  fhAnglePairCorrelationCut  = new TH2F
+    ("AnglePairCorrelationCut",
+     "Angle between correlated #gamma pair vs E_{#pi^{0}}",200,0,50,200,0,0.2); 
+  fhAnglePairCorrelationCut->SetYTitle("Angle (rad)");
+  fhAnglePairCorrelationCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+
+  fhInvMassPairCorrelationCut  = new TH2F
+    ("InvMassPairCorrelationCut","Invariant Mass of correlated #gamma pair vs E_{#pi^{0}}",
+     120,0,120,360,0,0.5); 
+  fhInvMassPairCorrelationCut->SetYTitle("Invariant Mass (GeV/c^{2})");
+  fhInvMassPairCorrelationCut->SetXTitle("E_{ #pi^{0}} (GeV)");
+  
+  outputContainer->Add(fhAnglePairNoCut) ; 
+  outputContainer->Add(fhAnglePairOpeningAngleCut) ;
+  outputContainer->Add(fhAnglePairAllCut) ; 
+  
+  outputContainer->Add(fhInvMassPairNoCut) ; 
+  outputContainer->Add(fhInvMassPairOpeningAngleCut) ; 
+  outputContainer->Add(fhInvMassPairAllCut) ; 
+
+  outputContainer->Add(fhAnglePairCorrelationCut) ; 
+  outputContainer->Add(fhInvMassPairCorrelationCut) ; 
+  
+  return outputContainer;
+}
+
+ //____________________________________________________________________________
+void AliNeutralMesonSelection::InitParameters()
+{
+  //Initialize the parameters of the analysis.
+  fKeepNeutralMesonHistos = kTRUE ;
+
+  //-------------kHadron, kJetLeadCone-----------------
+  fAngleMaxParam.Set(4) ;
+  fAngleMaxParam.AddAt(0.4,0);//={0.4,-0.25,0.025,-2e-4};
+  fAngleMaxParam.AddAt(-0.25,1) ;
+  fAngleMaxParam.AddAt(0.025,2) ;
+  fAngleMaxParam.AddAt(-2e-4,3) ;
+
+  fInvMassMaxCut  = 0.16 ;
+  fInvMassMinCut  = 0.11 ;
+
+  fM = 0.1349766;//neutralMeson mass
+
+  fMinPt = 0.   ;
+  fDeltaPhiMaxCut      = 4.5;
+  fDeltaPhiMinCut      = 1.5 ;
+  fRatioMaxCut    = 1.0 ;
+  fRatioMinCut    = 0.1 ; 
+}
+
+//__________________________________________________________________________-
+Bool_t AliNeutralMesonSelection::IsAngleInWindow(const Float_t angle,const Float_t e) {
+  //Check if the opening angle of the candidate pairs is inside 
+  //our selection windowd
+
+  Bool_t result = kFALSE;
+  Double_t max =  fAngleMaxParam.At(0)*TMath::Exp(fAngleMaxParam.At(1)*e)
+    +fAngleMaxParam.At(2)+fAngleMaxParam.At(3)*e;
+  Double_t arg = (e*e-2*fM*fM)/(e*e);
+  Double_t min = 100. ;
+  if(arg>0.)
+    min = TMath::ACos(arg);
+
+  if((angle<max)&&(angle>=min))
+    result = kTRUE;
+  return result;
+}
+
+//____________________________________________________________________________
+Bool_t  AliNeutralMesonSelection::CutPtPhi(Double_t ptg, Double_t phig, Double_t pt, Double_t phi)  
+{ 
+  //Select pair if delta
+  Bool_t cut = kFALSE ;
+  if(fSelect == kNoSelectPhiPt) cut = kTRUE ;
+  else if((phig-phi) > fDeltaPhiMinCut && ((phig-phi) < fDeltaPhiMaxCut)){
+    //Cut on pt
+    if((fSelect == kSelectPhiPtRatio && ptg > 0. && pt/ptg  > fRatioMinCut &&  pt/ptg  < fRatioMaxCut) ||
+       (fSelect == kSelectPhiMinPt && pt > fMinPt)  )  cut = kTRUE ;
+  }
+  else cut = kFALSE ;
+  
+  return cut ;
+  
+}
+
+//____________________________________________________________________________
+Bool_t  AliNeutralMesonSelection::SelectPair(TParticle * pGamma, TLorentzVector gammai, TLorentzVector gammaj)  
+{  
+  
+  //Search for the neutral pion within selection cuts
+  
+  Double_t ptg = pGamma->Pt();
+  Double_t phig = pGamma->Phi() ;
+  Bool_t goodpair = kFALSE ;
+  
+  Double_t pt  = (gammai+gammaj).Pt();
+  Double_t phi = (gammai+gammaj).Phi();
+  if(phi < 0)
+    phi+=TMath::TwoPi();
+  Double_t invmass = (gammai+gammaj).M();
+  Double_t angle   = gammaj.Angle(gammai.Vect());
+  Double_t e       = (gammai+gammaj).E();
+  
+  //Fill histograms with no cuts applied.
+  fhAnglePairNoCut->Fill(e,angle);
+  fhInvMassPairNoCut->Fill(e,invmass);
+  
+  //Cut on phig-phi meson
+  if(CutPtPhi(ptg, phig, pt, phi)){
+    
+    fhAnglePairCorrelationCut     ->Fill(e,angle);
+    fhInvMassPairCorrelationCut->Fill(e,invmass);
+    
+    //Cut on the aperture of the pair
+    if(IsAngleInWindow(angle,e)){
+      fhAnglePairOpeningAngleCut     ->Fill(e,angle);
+      fhInvMassPairOpeningAngleCut->Fill(e,invmass);
+      AliDebug(2,Form("Angle cut: pt %f, phi %f",pt,phi));
+      
+      //Cut on the invariant mass of the pair
+      if((invmass>fInvMassMinCut) && (invmass<fInvMassMaxCut)){ 
+       fhInvMassPairAllCut  ->Fill(e,invmass);
+       fhAnglePairAllCut       ->Fill(e,angle);
+       goodpair = kTRUE;
+       AliDebug(2,Form("IM cut: pt %f, phi %f",pt,phi));
+      }//(invmass>0.125) && (invmass<0.145)
+    }//Opening angle cut
+  } // cut on pt and phi
+  
+  
+  return goodpair; 
+  
+}
+
+//__________________________________________________________________
+void AliNeutralMesonSelection::Print(const Option_t * opt) const
+{
+
+  //Print some relevant parameters set for the analysis
+  if(! opt)
+    return;
+  
+  Info("Print", "%s %s", GetName(), GetTitle() ) ;
+
+  printf("mass : %f  \n", fM );
+  printf("Invariant mass limits : %f < m < %f \n", fInvMassMinCut , fInvMassMinCut );
+  printf("Angle selection param: \n");
+  printf("p0 :     %f", fAngleMaxParam.At(0));
+  printf("p1 :     %f", fAngleMaxParam.At(1));
+  printf("p2 :     %f", fAngleMaxParam.At(2));
+  printf("p3 :     %f", fAngleMaxParam.At(3));
+
+  printf("pT meson       >    %f\n", fMinPt) ; 
+  printf("Phi gamma-meson      <     %f\n", fDeltaPhiMaxCut) ; 
+  printf("Phi gamma-meson      >     %f\n", fDeltaPhiMinCut) ;
+  printf("pT meson / pT Gamma             <     %f\n", fRatioMaxCut) ; 
+  printf("pT meson / pT Gamma             >     %f\n", fRatioMinCut) ;
+  printf("Keep Neutral Meson Histos = %d\n",fKeepNeutralMesonHistos);
+
+} 
diff --git a/PWG4/AliNeutralMesonSelection.h b/PWG4/AliNeutralMesonSelection.h
new file mode 100644 (file)
index 0000000..b27f41a
--- /dev/null
@@ -0,0 +1,109 @@
+#ifndef ALINEUTRALMESONSELECTION_H
+#define ALINEUTRALMESONSELECTION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+/* $Id$ */
+
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
+ * new analysis classes in the the new analysis framework
+ *
+ *
+ */
+//_________________________________________________________________________
+// Class that contains methods to select candidate pairs to neutral meson 
+//-- Author: Gustavo Conesa (INFN-LNF)
+
+// --- ROOT system ---
+#include<TObject.h>
+#include <TArrayD.h>
+
+class TLorentzVector ;
+class TParticle ;
+class TList ;
+class TH2F ;
+
+class AliNeutralMesonSelection : public TObject {
+
+ public: 
+  
+  AliNeutralMesonSelection() ; // default ctor
+  AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
+  AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
+  virtual ~AliNeutralMesonSelection() ; //virtual dtor
+
+  enum type_t {kSelectPhiMinPt, kSelectPhiPtRatio, kNoSelectPhiPt};
+
+  TList * GetCreateOutputObjects();
+  
+  Double_t GetAngleMaxParam(Int_t i) const {return fAngleMaxParam.At(i) ; }
+  void SetAngleMaxParam(Int_t i, Double_t par){fAngleMaxParam.AddAt(par,i) ; }
+  
+  Double_t GetInvMassMaxCut() const {return fInvMassMaxCut ; }
+  Double_t GetInvMassMinCut() const {return fInvMassMinCut ; }
+  void SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
+  {fInvMassMaxCut =invmassmax;  fInvMassMinCut =invmassmin;}   
+  
+  Double_t GetDeltaPhiMaxCut() const {return fDeltaPhiMaxCut ; }
+  Double_t GetDeltaPhiMinCut() const {return fDeltaPhiMinCut ; }
+  void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
+  {fDeltaPhiMaxCut =phimax;  fDeltaPhiMinCut =phimin;}
+
+  Double_t GetRatioMaxCut() const {return fRatioMaxCut ; }
+  Double_t GetRatioMinCut() const {return fRatioMinCut ; }
+  void SetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
+  {fRatioMaxCut = ratiomax;  fRatioMinCut = ratiomin;}
+
+  Float_t    GetMinPt() const {return fMinPt ; }
+  void SetMinPt(Float_t pt){fMinPt = pt; };
+
+  Double_t GetMass() const {return fM ; }
+  void SetMass(Double_t m) { fM =m ; }
+  
+  Int_t GetPhiPtSelection(){  return fSelect ; }
+  void SetPhiPtSelection(Int_t ana ){  fSelect = ana ; }
+
+  Bool_t AreNeutralMesonSelectionHistosKept() { return fKeepNeutralMesonHistos ; }
+  void KeepNeutralMesonSelectionHistos(Bool_t keep) { fKeepNeutralMesonHistos = keep ; }
+
+  void InitParameters();       
+  Bool_t IsAngleInWindow(const Float_t angle, const Float_t e);
+  void Print(const Option_t * opt) const;
+
+  Bool_t  CutPtPhi(Double_t ptg, Double_t phig, Double_t pt, Double_t phi) ;
+  Bool_t  SelectPair(TParticle * photon, TLorentzVector particlei,  TLorentzVector particlej)  ;
+  
+  private:
+  Int_t fSelect; //Pair selection depends on analysis
+  Double_t fM ; //mass of the neutral meson
+  Double_t   fInvMassMaxCut ;  // Invariant Mass cut maximum
+  Double_t   fInvMassMinCut ;  // Invariant Masscut minimun
+  TArrayD    fAngleMaxParam ; //Max opening angle selection parameters
+  Double_t   fMinPt;       // Minimum pt 
+  Double_t   fDeltaPhiMaxCut ;      // 
+  Double_t   fDeltaPhiMinCut ;      // 
+  Double_t   fRatioMaxCut ;    // Leading particle/gamma Ratio cut maximum
+  Double_t   fRatioMinCut ;    // Leading particle/gamma Ratio cut minimum
+  Bool_t  fKeepNeutralMesonHistos ; // Keep neutral meson selection histograms
+
+  //Histograms
+  TH2F * fhAnglePairNoCut  ; 
+  TH2F * fhAnglePairCorrelationCut  ; 
+  TH2F * fhAnglePairOpeningAngleCut   ; 
+  TH2F * fhAnglePairAllCut   ; 
+  TH2F * fhInvMassPairNoCut    ; 
+  TH2F * fhInvMassPairCorrelationCut    ;
+  TH2F * fhInvMassPairOpeningAngleCut  ; 
+  TH2F * fhInvMassPairAllCut   ; 
+  
+  ClassDef(AliNeutralMesonSelection,0)
+    
+    } ;
+
+
+#endif //ALINEUTRALMESONSELECTION_H
+
+
+
diff --git a/PWG4/ConfigGammaAnalysis.C b/PWG4/ConfigGammaAnalysis.C
new file mode 100644 (file)
index 0000000..adc893c
--- /dev/null
@@ -0,0 +1,125 @@
+
+AliAnaGamma*  ConfigGammaAnalysis()
+{
+    //
+    // Configuration goes here
+    // 
+    printf("ConfigGammaAnalysis() \n");
+
+    //----------------------------------------------------------
+    //-----------------------------------------------------------  
+    // Define reader , uncomment 1 of the 2 options
+    //-----------------------------------------------------------
+    //----------------------------------------------------------
+
+    // -----Option 1------ Data, ESDs
+    AliGammaDataReader *reader = new AliGammaDataReader();
+//     //AliGammaMCDataReader *reader = new AliGammaMCDataReader(); //Copy of AliGammaDataReader for the moment
+//     //Set detectors acceptance (in real and montecarlo data)
+//     reader->SetCTSEtaCut(1); reader->SetEMCALEtaCut(1); reader->SetPHOSEtaCut(0.2);
+//     reader->SetPhiEMCALCut(40*TMath::DegToRad(), 200*TMath::DegToRad());     
+//     reader->SetPhiPHOSCut(200*TMath::DegToRad(), 350*TMath::DegToRad()); 
+//     //Set minimum pt for particles in analysis  (in real and montecarlo data)
+//     reader->SetNeutralPtCut(0.4); reader->SetChargedPtCut(0.4); 
+//     //pid of measured particles
+//     reader->SetEMCALPIDOn(kFALSE); reader->SetPHOSPIDOn(kFALSE); //No pid, accept all particles 
+//     //if previous kTrue
+//     reader->SetPHOSPhotonWeight(0.7);    reader->SetPHOSPi0Weight(0.7); 
+//     reader->SetEMCALPhotonWeight(0.7);    reader->SetEMCALPi0Weight(0.7);
+   
+     // -----Option 2------ Kinematics
+    //    AliGammaMCReader *reader = new AliGammaMCReader();
+//     //Set detectors acceptance (in real and montecarlo data)
+//     reader->SetCTSEtaCut(1); reader->SetEMCALEtaCut(1); reader->SetPHOSEtaCut(0.2);
+//     reader->SetPhiEMCALCut(40*TMath::DegToRad(), 200*TMath::DegToRad());     
+//     reader->SetPhiPHOSCut(200*TMath::DegToRad(), 350*TMath::DegToRad()); 
+//     //Set minimum pt for particles in analysis  (in real and montecarlo data)
+//     reader->SetNeutralPtCut(0.4); reader->SetChargedPtCut(0.4); 
+//     reader->SetDecayPi0Flag(AliGammaMCReader::kNoDecay) ; //Options
+//     //kNoDecay :Do not decay pi0, keep them in the list as they are
+//     //kGeantDecay: Look for gamma decayed by GEANT
+//     //kDecay: Decay pi0 by hand (geant was not used)
+//     //parameters to study if decay is overlapped:
+//     reader->SetEMCALIPDistance(450.); reader->SetPHOSIPDistance(460.);
+//     reader->SetEMCALMinDistance(3.6);    reader->SetPHOSMinDistance(11.); //Miimum overlapp distance
+    //----------------------------------------------------------
+    //----------------------------------------------------
+    //Define analysis algorithms
+    //----------------------------------------------------
+    //----------------------------------------------------------
+    //3 analysis types
+    //kPrompt: Find prompt gamma for a fixed cone and pt cut value
+    //kIsolationCut: Find prompt gamma for several cones and pt cuts values
+    //kCorrelation: Do prompt gamma - something correlation. Something can be
+    //      kParton: Gamma-Parton correlation
+    //      kHadron: Gamma-Hadron correlation
+    //      kJetLeadCone: Gamma-Jet correlation : constructed in cone around leading particle
+    //      kJetFinder: Gamma-Jet correlation : Jet reconstructed with standard algorithms. --Still not implemented--
+    //One of the first 3 analysis types is selected in the end with  ana->SetAnalysisType(AliAnaGamma::kCorrelation);
+    //The 4 correlation analysis are selected when the corresponding class is initialized
+
+    //============================
+    //First initialize prompt photon algoritm
+    //==============================
+    AliAnaGammaDirect *gd = new AliAnaGammaDirect();
+    gd->SetMinGammaPt(1.);
+    //not used in option kIsolationCut
+    gd->SetConeSize(0.3); gd->SetPtThreshold(1.); gd->SetPtSumThreshold(10.);
+    gd->SetICMethod(AliAnaGammaDirect::kNoIC) ;//Options:
+          //kNoIC: Accept all photons, no isolation used
+          //kPtIC: IC with cut on pT
+          //kSumPtIC: IC with cut on pT sum in cone
+          //kSeveralIC: Not allowed in kCorrelation analysis
+//     //for option kSeveralIC:
+//     gd->SetNCones(3); gd->SetNPtThresholds(3);
+//     gd->SetConeSizes(0,0.2); gd->SetConeSizes(1,0.3); gd->SetConeSizes(2,0.4); 
+//     gd->SetPtThresholds(0,0.5); gd->SetPtThresholds(1,1.); gd->SetPtThresholds(2,2);
+    //============================
+    //Second, select the correlation algoritm
+    //==============================
+    //Uncomment 1 of the 4 options
+
+    //--- Option 1 ---
+    //AliAnaGammaParton *gc = new AliAnaGammaParton();
+    //No associated setters and getters for the moment.
+
+    //--- Option 2 ---
+    //       AliAnaGammaHadron *gc = new AliAnaGammaHadron();
+//     gc->SetDeltaPhiCutRange(1,4); //Correlation in delta phi (gamma-particle), radians
+//     gc->SetMinPtHadron(5.);
+//     gc->SetJetsOnlyInCTS(kFALSE); // Don't consider particles in opposite calorimeter
+    
+    //--- Option 3 ---
+    AliAnaGammaJetLeadCone *gc = new AliAnaGammaJetLeadCone();
+//     gc->SetDeltaPhiCutRange(2.8,3.5); //Correlation with leading particle delta phi (gamma-particle), radians
+//     gc->SetRatioCutRange(0.1,1.2);
+//     gc->SetJetsOnlyInCTS(kFALSE); // Don't consider particles in opposite calorimeter
+//     //and many more setters and getters
+
+    //--- Option 4 ---
+    //    AliAnaGammaJetFinder *gc = new AliAnaGammaJetFinder();
+    //It does nothing for the moment
+
+    //In case of option 1 or 2, we need to select pairs to be candidate to pi0
+    //correlated with the opposite prompt photon. Need to play with this class
+    AliNeutralMesonSelection *nms = new AliNeutralMesonSelection();
+    nms->SetInvMassCutRange(0.1,0.17);
+    nms->KeepNeutralMesonSelectionHistos(kFALSE); //keep in file several histograms or not.
+    // and other parameters
+
+    //---------------------------------------------------------------------
+    // Finally: Set  analysis algorithm and reader
+    //---------------------------------------------------------------------
+    ana = new AliAnaGamma();
+    ana->SetReader(reader);//pointer to reader
+    ana->SetAnalysisType(AliAnaGamma::kPrompt); //set kPrompt, kCorrelation
+    ana->SetGammaDirect(gd);//pointer to direct photon algorithm
+    ana->SetGammaCorrelation(gc);//pointer to correlation algorithm
+    ana->SetNeutralMesonSelection(nms); //pi0 pair selection
+    ana->SetCalorimeter("EMCAL"); //Prompt photon calorimeter
+   
+    //
+    return ana ;
+}
index 14d2f7a7dcd4b4a682f81f2025bd869bd1be88e5..c416dc6cae92af935d316ef5d8caa79922b95725 100644 (file)
@@ -4,12 +4,23 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class AliAnaGammaDirect+;
-#pragma link C++ class AliAnaGammaIsolCut+;
-#pragma link C++ class AliAnaGammaHadron+;
-#pragma link C++ class AliAnaGammaJet+;
 #pragma link C++ class AliAnaCaloTrigger+;
+#pragma link C++ class AliAnaCaloTriggerMC+;
 #pragma link C++ class AliAnaGammaPhos+;
 #pragma link C++ class AliAnaScale+;
+#pragma link C++ class AliMCScale+;
+#pragma link C++ class AliNeutralMesonSelection+;
+#pragma link C++ class AliAnaGamma+;
+#pragma link C++ class AliAnaGammaDirect+;
+#pragma link C++ class AliAnaGammaCorrelation+;
+#pragma link C++ class AliAnaGammaParton+;
+#pragma link C++ class AliAnaGammaHadron+;
+#pragma link C++ class AliAnaGammaJetLeadCone+;
+#pragma link C++ class AliAnaGammaJetFinder+;
+#pragma link C++ class AliAnalysisTaskGamma+;
+#pragma link C++ class AliGammaReader+;
+#pragma link C++ class AliGammaDataReader+;
+#pragma link C++ class AliGammaMCReader+;
+#pragma link C++ class AliGammaMCDataReader+;
 
 #endif
diff --git a/PWG4/ana.C b/PWG4/ana.C
new file mode 100644 (file)
index 0000000..bbaf6c6
--- /dev/null
@@ -0,0 +1,166 @@
+Bool_t gIsAnalysisLoaded = kFALSE ; 
+
+//______________________________________________________________________
+Bool_t LoadLib( const char* pararchivename) 
+{
+  // Loads the AliRoot required libraries from a tar file 
+
+  Bool_t rv = kTRUE ; 
+  char cdir[1024] ; 
+  sprintf(cdir, "%s", gSystem->WorkingDirectory() ) ; 
+  
+  // Setup par File
+  if (pararchivename) {
+   char parpar[80] ; 
+   sprintf(parpar, "%s.par", pararchivename) ;
+   if ( gSystem->AccessPathName(parpar) ) {
+    gSystem->ChangeDirectory(gSystem->Getenv("ALICE_ROOT")) ;
+    char processline[1024];
+    sprintf(processline, ".! make %s", parpar) ; 
+    cout << processline << endl ; 
+    gROOT->ProcessLine(processline) ;
+    gSystem->ChangeDirectory(cdir) ; 
+    sprintf(processline, ".! mv /tmp/%s .", parpar) ;
+    gROOT->ProcessLine(processline) ;  
+    sprintf(processline,".! tar xvzf %s",parpar);
+    gROOT->ProcessLine(processline);
+   }
+   gSystem->ChangeDirectory(pararchivename);
+   
+    // check for BUILD.sh and execute
+    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
+      printf("*** Building PAR archive  %s  ***\n", pararchivename);
+
+      if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
+       AliError(Form("Cannot Build the PAR Archive %s! - Abort!", pararchivename) );
+        return kFALSE ;
+      }
+    }
+
+    // check for SETUP.C and execute
+    if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
+      printf("*** Setup PAR archive  %s     ***\n", pararchivename);
+      gROOT->Macro("PROOF-INF/SETUP.C");
+    }    
+  }
+
+  if ( strstr(pararchivename, "AnalysisCheck") ) {
+    gSystem->Load("libSpectrum.so");
+  }
+  
+  printf("lib%s done\n", pararchivename);
+
+  gSystem->ChangeDirectory(cdir);
+
+  gIsAnalysisLoaded = kTRUE ; 
+  return rv ; 
+}
+
+//________________________________ana______________________________________
+
+void ana(const Int_t kEvent=10)  
+{ 
+
+  //AliLog::SetGlobalDebugLevel(5);
+  gSystem->AddIncludePath("-I\"$ALICE_ROOT/include\"");
+  gSystem->Load("libANALYSIS.so");
+  gSystem->Load("libANALYSISRL.so");
+
+  if (! gIsAnalysisLoaded ) {
+    //    LoadLib("ESD") ; 
+    //   LoadLib("AOD") ;
+    //   LoadLib("ANALYSIS") ;
+    LoadLib("PWG4Gamma") ; 
+  }
+  
+  // create the analysis goodies object
+  AliAnalysisGoodies * ag = new AliAnalysisGoodies() ; 
+  
+  AliAnalysisTaskGamma * task = new AliAnalysisTaskGamma ("GammaCorrelations");
+  ag->ConnectInput(task, TChain::Class(), 0) ; 
+  ag->ConnectOuput(task, TList::Class(), 0) ;  
+  //ag->ConnectOuput(task, TTree::Class(), 0, "AOD") ;  
+   
+  // get the data to analyze
+
+  // definition of Tag cuts 
+  const char * runCuts = 0x0 ; 
+  const char * evtCuts = 0x0 ; 
+  const char * lhcCuts = 0x0 ; 
+  const char * detCuts = 0x0 ; 
+  
+  //"fEventTag.fNPHOSClustersMin == 1 && fEventTag.fNEMCALClustersMin == 1" ; 
+  
+  TString input = gSystem->Getenv("ANA_INPUT") ; 
+  cout<<"ANA_INPUT >>> "<<input<<endl;
+  if ( input != "") {
+    cout<<"ANALYSIS 1"<<endl;
+
+    char argument[1024] ;  
+
+    if ( input.Contains("tag?") ) {
+      //create the ESD collection from the tag collection 
+      input.ReplaceAll("tag?", "") ; 
+
+      const char * collESD = "esdCollection.xml" ;
+      ag->MakeEsdCollectionFromTagCollection(runCuts, lhcCuts, detCuts, evtCuts, input.Data(), collESD) ;
+      sprintf(argument, "esd?%s", collESD) ; 
+      cout<<"TAG collection >> "<<argument<<endl; 
+    } 
+
+    else if ( input.Contains("esd?") ){
+      sprintf(argument, "%s", input.Data()) ;
+      cout<<"ESD collection >> "<<argument<<endl; 
+    } 
+    
+    ag->Process(argument) ;
+    
+  } 
+  else {
+    cout<<"ANALYSIS 2"<<endl;
+    TChain* analysisChain = new TChain("esdTree") ;
+    //   input = "alien:///alice/cern.ch/user/a/aliprod/prod2006_2/output_pp/105/411/AliESDs.root" ; 
+    //   analysisChain->AddFile(input);
+    input = "AliESDs.root" ; 
+    const char * kInDir = gSystem->Getenv("OUTDIR") ; 
+    if ( kInDir ) {
+      if ( ! gSystem->cd(kInDir) ) {
+       printf("%s does not exist\n", kInDir) ;
+       return ;
+      }     
+      Int_t event, skipped=0 ; 
+      char file[120] ;
+      for (event = 0 ; event < kEvent ; event++) {
+        sprintf(file, "%s/%d/AliESDs.root", kInDir,event) ; 
+       TFile * fESD = 0 ; 
+       if ( fESD = TFile::Open(file)) 
+         if ( fESD->Get("esdTree") ) { 
+            printf("++++ Adding %s\n", file) ;
+            analysisChain->AddFile(file);
+         }
+         else { 
+            printf("---- Skipping %s\n", file) ;
+            skipped++ ;
+         }
+      }
+      printf("number of entries # %lld, skipped %d\n", analysisChain->GetEntries(), skipped*100) ;     
+    }
+    else  
+      analysisChain->AddFile(input);
+    
+    ag->Process(analysisChain) ; 
+  }
+  return ;
+}
+
+//______________________________________________________________________
+void Merge(const char * xml, const char * sub, const char * out) 
+{
+  if (! gIsAnalysisLoaded ) 
+    LoadLib("ESD") ; 
+  
+  AliAnalysisGoodies * ag = new AliAnalysisGoodies() ; 
+  ag->Merge(xml, sub, out) ;
+}
+
index 6fca346394298a5a6eeea91194e92c30e1752512..66edb160ca2365b136dd5764f337e333b357f1aa 100644 (file)
@@ -1,5 +1,11 @@
-SRCS = AliAnaGammaDirect.cxx AliAnaGammaIsolCut.cxx AliAnaGammaHadron.cxx AliAnaGammaJet.cxx AliAnaCaloTrigger.cxx \
-       AliAnaGammaPhos.cxx AliAnaScale.cxx
+SRCS = AliAnaCaloTrigger.cxx AliAnaCaloTriggerMC.cxx \
+       AliAnaGammaPhos.cxx AliNeutralMesonSelection.cxx \
+       AliAnaScale.cxx AliMCScale.cxx \
+       AliAnaGamma.cxx  AliAnaGammaDirect.cxx  \
+       AliAnaGammaCorrelation.cxx  AliAnaGammaParton.cxx AliAnaGammaHadron.cxx AliAnaGammaJetLeadCone.cxx  AliAnaGammaJetFinder.cxx \
+       AliAnalysisTaskGamma.cxx \
+       AliGammaReader.cxx AliGammaDataReader.cxx \
+       AliGammaMCReader.cxx  AliGammaMCDataReader.cxx 
 
 HDRS:= $(SRCS:.cxx=.h)