Streaming problems in CAF solved
[u/mrichter/AliRoot.git] / PWG4 / AliAnaGammaDirect.h
index 2fb9327..3e2813f 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIANAGAMMADIRECT_H
-#define ALIANAGAMMADIRECT_H
+#ifndef AliAnaGammaDirect_H
+#define AliAnaGammaDirect_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.3  2007/03/08 10:24:32  schutz
- * Coding convention
+ * Revision 1.5  2007/08/17 12:40:04  schutz
+ * New analysis classes by Gustavo Conesa
  *
- * 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)
 
-//*-- Author: Gustavo Conesa (INFN-LNF)
+//-- Author: Gustavo Conesa (INFN-LNF)
 
 // --- ROOT system ---
 #include <TParticle.h> 
-#include <TClonesArray.h> 
-#include <TTree.h> 
-#include "AliAnalysisTask.h" 
+#include <TClonesArray.h>  
 #include <TH2F.h>
+#include <TString.h>
 
-class AliESD ; 
-class AliAnaGammaDirect : public AliAnalysisTask {
+// --- ANALYSIS system ---
+#include "AliAnaBaseClass.h"
+class AliAODParticleCorrelations ;
+
+class TList ;
+
+class AliAnaGammaDirect : public AliAnaBaseClass {
 
 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 ; }
-  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  ; }
+  enum mcTypes {kPrompt, kFragmentation, kPi0Decay, kEtaDecay, kOtherDecay, kPi0, kEta, kElectron, kConversion, kUnknown};
 
-  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);
+  Bool_t CheckInvMass(const Int_t icalo,const TLorentzVector mom, Double_t *v, TClonesArray * pl);
+  Int_t CheckOrigin(const Int_t label);
   
+  TList *  GetCreateOutputObjects();
+
+  void MakeAnalysisFillAOD()  ;
   
-  void GetPromptGamma(TClonesArray * plNe, TClonesArray * plCTS, TParticle * pGamma, Bool_t &Is)  const;
+  void MakeAnalysisFillHistograms() ; 
+
+  void MakeSeveralICAnalysis(AliAODParticleCorrelation * ph, Double_t v[3]); 
   
-  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;
   
- private:
-
-  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
-  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
-  //Histograms  
-  TH1F * fhNGamma    ; 
-  TH2F * fhPhiGamma    ; 
-  TH2F * fhEtaGamma    ; 
+  TString GetDetector()   const {return fDetector ; }
+  void SetDetector(TString det)    {fDetector = det ; }
 
-  ClassDef(AliAnaGammaDirect,0)
+  Int_t    GetNCones()                  const {return fNCones ; }
+  Int_t    GetNPtThresFrac()                const {return fNPtThresFrac ; }
+  Float_t GetConeSizes(Int_t i)      const {return fConeSizes[i] ; }
+  Float_t GetPtThresholds(Int_t i)  const {return fPtThresholds[i] ; }
+  Float_t GetPtFractions(Int_t i)  const {return fPtFractions[i] ; }
+
+  void InitParameters();
+  void SetNCones(Int_t ncs)              {fNCones = ncs ; }
+  void SetNPtThresFrac(Int_t npt)        {fNPtThresFrac = npt; }
+  void SetConeSizes(Int_t i, Float_t r)         {fConeSizes[i] = r ; }
+  void SetPtThresholds(Int_t i, Float_t pt)   {fPtThresholds[i] = pt; }
+  void SetPtFractions(Int_t i, Float_t pt)   {fPtFractions[i] = pt; } 
+
+  Bool_t IsIsolationOn() {return fMakeIC ; }
+  void SwitchOnIsolation() { fMakeIC = kTRUE;}
+  void SwitchOffIsolation() { fMakeIC = kFALSE;}
+
+  Bool_t IsReIsolationOn() {return fReMakeIC ; }
+  void SwitchOnReIsolation() { fReMakeIC = kTRUE;}
+  void SwitchOffReIsolation() { fReMakeIC = kFALSE;}
+
+  Bool_t IsSeveralIsolationOn() {return fMakeSeveralIC ; }
+  void SwitchOnSeveralIsolation() { fMakeSeveralIC = kTRUE;}
+  void SwitchOffSeveralIsolation() { fMakeSeveralIC = kFALSE;}
+
+  Bool_t IsInvariantMassOn() {return fMakeInvMass ; }
+  void SwitchOnInvariantMass() { fMakeInvMass = kTRUE;}
+  void SwitchOffInvariantMass() { fMakeInvMass = kFALSE;}
+
+  Bool_t SelectCluster(AliAODCaloCluster * calo, Double_t vertex[3], TLorentzVector & mom);
+
+  private:
+  TString fDetector ; // Detector where the gamma is searched;
+  Bool_t fMakeIC ; //Do isolation analysis
+  Bool_t fReMakeIC ; //Do isolation analysis
+  Bool_t fMakeSeveralIC ; //Do analysis for different IC
+  Bool_t fMakeInvMass; //Select candidate if no pair from decay
+
+  //Histograms  
+  TH1F * fhPtGamma    ;  //!Number of identified (isolated) gamma 
+  TH2F * fhPhiGamma  ; //! Phi of identified  (isolated) gamma
+  TH2F * fhEtaGamma  ; //! eta of identified  (isolated) gamma
+  TH2F * fhConeSumPt ; //! Sum Pt in the cone
+
+  //Prompt photon analysis data members for multiple cones and pt thresholds 
+  Int_t         fNCones   ; //!Number of cone sizes to test
+  Int_t         fNPtThresFrac ; //!Number of ptThres and ptFrac to test
+  Float_t     fConeSizes[5] ; //! Array with cones to test
+  Float_t     fPtThresholds[5] ; //! Array with pt thresholds to test
+  Float_t     fPtFractions[5] ; //! Array with pt thresholds to test
+
+  TH1F* fhPtThresIsolated[5][5]; //! Isolated gamma with pt threshold 
+  TH1F* fhPtFracIsolated[5][5]; //! Isolated gamma with pt threshold 
+  TH2F* fhPtSumIsolated[5] ;  //!  Isolated gamma with threshold on cone pt sume
+
+  //MC
+  TH1F * fhPtPrompt; //!Number of identified (isolated) prompt gamma 
+  TH2F * fhPhiPrompt;  //! Phi of identified  (isolated) prompt gamma
+  TH2F * fhEtaPrompt;  //! eta of identified  (isolated) prompt gamma
+  TH1F * fhPtThresIsolatedPrompt[5][5];  //! Isolated prompt gamma with pt threshold 
+  TH1F * fhPtFracIsolatedPrompt[5][5];    //! Isolated prompt gamma with pt frac
+  TH2F * fhPtSumIsolatedPrompt[5]; //!  Isolated prompt gamma with threshold on cone pt sume
+  TH1F * fhPtFragmentation; //!Number of identified (isolated) fragmentation gamma 
+  TH2F * fhPhiFragmentation;  //! Phi of identified  (isolated) fragmentation gamma
+  TH2F * fhEtaFragmentation;  //! eta of identified  (isolated) fragmentation gamma
+  TH1F * fhPtThresIsolatedFragmentation[5][5];  //! Isolated fragmentation gamma with pt threshold 
+  TH1F * fhPtFracIsolatedFragmentation[5][5];    //! Isolated fragmentation gamma with pt frac
+  TH2F * fhPtSumIsolatedFragmentation[5]; //!  Isolated fragmentation gamma with threshold on cone pt sume
+  TH1F * fhPtPi0Decay; //!Number of identified (isolated) Pi0Decay gamma 
+  TH2F * fhPhiPi0Decay;  //! Phi of identified  (isolated) Pi0Decay gamma
+  TH2F * fhEtaPi0Decay;  //! eta of identified  (isolated) Pi0Decay gamma
+  TH1F * fhPtThresIsolatedPi0Decay[5][5];  //! Isolated Pi0Decay gamma with pt threshold 
+  TH1F * fhPtFracIsolatedPi0Decay[5][5];    //! Isolated Pi0Decay gamma with pt frac
+  TH2F * fhPtSumIsolatedPi0Decay[5]; //!  Isolated Pi0Decay gamma with threshold on cone pt sume
+  TH1F * fhPtOtherDecay; //!Number of identified (isolated) OtherDecay gamma 
+  TH2F * fhPhiOtherDecay;  //! Phi of identified  (isolated) OtherDecay gamma
+  TH2F * fhEtaOtherDecay;  //! eta of identified  (isolated) OtherDecay gamma
+  TH1F * fhPtThresIsolatedOtherDecay[5][5];  //! Isolated OtherDecay gamma with pt threshold 
+  TH1F * fhPtFracIsolatedOtherDecay[5][5];    //! Isolated OtherDecay gamma with pt frac
+  TH2F * fhPtSumIsolatedOtherDecay[5]; //!  Isolated OtherDecay gamma with threshold on cone pt sume   
+  TH1F * fhPtConversion; //!Number of identified (isolated) Conversion gamma 
+  TH2F * fhPhiConversion;  //! Phi of identified  (isolated) Conversion gamma
+  TH2F * fhEtaConversion;  //! eta of identified  (isolated) Conversion gamma
+  TH1F * fhPtThresIsolatedConversion[5][5];  //! Isolated Conversion gamma with pt threshold 
+  TH1F * fhPtFracIsolatedConversion[5][5];    //! Isolated Conversion gamma with pt frac
+  TH2F * fhPtSumIsolatedConversion[5]; //!  Isolated Conversion gamma with threshold on cone pt sume
+  TH1F * fhPtUnknown; //!Number of identified (isolated) Unknown gamma 
+  TH2F * fhPhiUnknown;  //! Phi of identified  (isolated) Unknown gamma
+  TH2F * fhEtaUnknown;  //! eta of identified  (isolated) Unknown gamma
+  TH1F * fhPtThresIsolatedUnknown[5][5];  //! Isolated Unknown gamma with pt threshold 
+  TH1F * fhPtFracIsolatedUnknown[5][5];    //! Isolated Unknown gamma with pt frac
+  TH2F * fhPtSumIsolatedUnknown[5]; //!  Isolated Unknown gamma with threshold on cone pt sume
+                                               
+  ClassDef(AliAnaGammaDirect,1)
 } ;
  
 
-#endif //ALIANAGAMMADIRECT_H
+#endif //AliAnaGammaDirect_H