fab914d460402e2c97b1e89adaac9e608d24c65c
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliAnalysisTaskUE.h
1 #ifndef ALIANALYSISTASKUE_H
2 #define ALIANALYSISTASKUE_H
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               */
6
7 ////////////////////////////////////////////////////////////////////////
8 //
9 // Analysis class for Underlying Event studies
10 //
11 // Look for correlations on the tranverse regions to 
12 // the leading charged jet
13 //
14 // This class needs as input AOD with track and Jets.
15 // The output is a list of histograms
16 //
17 // AOD can be either connected to the InputEventHandler  
18 // for a chain of AOD files 
19 // or 
20 // to the OutputEventHandler
21 // for a chain of ESD files, so this case class should be 
22 // in the train after the Jet finder
23 //
24 //    Arian.Abrahantes.Quintana@cern.ch 
25 //    Ernesto.Lopez.Torres@cern.ch
26 //    vallero@physi.uni-heidelberg.de
27 // 
28 ////////////////////////////////////////////////////////////////////////
29
30 #include "AliAnalysisTask.h"
31
32 class AliAnalyseUE;
33 class AliHistogramsUE;
34 class AliAODEvent;
35 class AliAODInputHandler;
36 class AliESDEvent;
37 class TH1F;
38 class TH2F;
39 class TH1I;
40 class TProfile;
41 class TTree;
42 class TVector3;
43
44 class  AliAnalysisTaskUE : public AliAnalysisTask
45   {
46   public:
47     AliAnalysisTaskUE(const char* name="AliAnalysisTaskUE");
48     virtual           ~AliAnalysisTaskUE() {if ( fListOfHistos ) delete fListOfHistos; }
49     AliAnalysisTaskUE(const  AliAnalysisTaskUE &det);
50     AliAnalysisTaskUE&   operator=(const  AliAnalysisTaskUE &det);
51        
52     // return instance of the singleton
53     static  AliAnalysisTaskUE* Instance();
54       
55     // Implementation of interace methods
56     virtual     Bool_t Notify();
57     virtual     void   ConnectInputData(Option_t *);
58     virtual     void   CreateOutputObjects();
59     virtual     void   Exec(Option_t *option);
60     virtual     void   Terminate(Option_t *);
61
62     //  Setters/Getters
63     virtual     void         SetDebugLevel( Int_t level )  { fDebug = level; }
64     virtual const Int_t       GetDebugLevel()  { return fDebug; }
65     
66     void        SetPtRangeInHist( Int_t bin, Double_t min, Double_t max ) {
67                         fBinsPtInHist = bin; 
68                         fMinJetPtInHist = min; 
69                         fMaxJetPtInHist = max; 
70                         }
71
72     // Read AODs
73     void          SelectAODBranch(const char* val)     { fAODBranch = val;   }
74     virtual const TString       GetAODBranch()                       { return fAODBranch;   }
75     virtual const AliAODEvent*   GetAOD()                             { return fAOD; } 
76
77     // Setters/Getters for MC
78     void        SetConstrainDistance(Bool_t val1, Double_t val2){ fMinDistance = val2; fConstrainDistance = val1;}
79     void        SetSimulateChJetPt(){fSimulateChJetPt = kTRUE;}
80     void        SetUseAODMCParticle(){fUseAliStack = kFALSE;}
81     void        SetUseMCBranch(){fUseMCParticleBranch = kTRUE;}
82
83     virtual const Bool_t        GetConstrainDistance() {return fConstrainDistance;}
84     virtual const Double_t      GetMinDistance() {return fMinDistance;}
85     virtual const Bool_t        GetSimulateChJetPt(){return fSimulateChJetPt;}
86     virtual const Bool_t        GetUseAODMCParticle(){return fUseAliStack;}
87     virtual const Bool_t        GetUseMCParticleBranch(){return fUseMCParticleBranch;}
88
89     //Setters for Events QA
90     void  SetZVertex( Double_t val ) { fZVertex = val; }
91     void  SetTracksInVertex( Int_t val ){ fnTracksVertex = val; }
92     
93     // Setters/Getters for UE Analysis
94     void   SetAnaTopology( Int_t val )       { fAnaType = val;    }
95     void   SetConePosition(Int_t val)        { fConePosition= val; }
96     void   SetConeRadius( Double_t val )     { fConeRadius = val; }
97     void   SetDoNotNormalizeQuantities()     { fIsNorm2Area = kFALSE; }
98     void   SetFilterBit( UInt_t val )        { fFilterBit = val;  }
99     void   SetJetsOnFly( Bool_t val )        { fJetsOnFly = val;  }
100     void   SetPtSumOrdering( Int_t val )     { fOrdering = val;   }
101     void   SetRegionType( Int_t val )        { fRegionType = val; }
102     void   SetUseChargeHadrons( Bool_t val ) { fUseChargeHadrons = val; }
103     void   SetUseChPartJet( Int_t val )      { fUseChPartJet = val; }
104     void   SetUseNegativeChargeType()        { fUsePositiveCharge = kFALSE; }
105     void   SetUseSingleCharge()              { fUseSingleCharge = kTRUE; } 
106     
107     virtual const Int_t     GetAnaTopology()                     { return fAnaType; }
108     virtual const Int_t     GetConePosition()                  { return fConePosition; }
109     virtual const Double_t  GetConeRadius()                      { return fConeRadius; }
110     virtual const Bool_t    GetDoNotNormalizeQuantities()      { return fIsNorm2Area; }
111     virtual const UInt_t    GetFilterBit()               { return fFilterBit;  }
112     virtual const Bool_t    GetJetsOnFly()               { return fJetsOnFly;  }
113     virtual const Int_t     GetPtSumOrdering()                 { return fOrdering;   }
114     virtual const Int_t     GetRegionType()                    { return fRegionType; }
115     virtual const Bool_t    GetUseChargeHadrons()              { return fUseChargeHadrons; }
116     virtual const Int_t     GetUseChPartJet()                  { return fUseChPartJet; }
117     virtual const Bool_t    GetUseNegativeChargeType()         { return fUsePositiveCharge; }
118     virtual const Bool_t    GetUseSingleCharge()               { return fUseSingleCharge; } 
119     
120     // Jet cuts
121     void   SetJet1EtaCut( Double_t val )      { fJet1EtaCut = val; }
122     void   SetJet2DeltaPhiCut( Double_t val ) { fJet2DeltaPhiCut = val; }
123     void   SetJet2RatioPtCut( Double_t val )  { fJet2RatioPtCut = val; }
124     void   SetJet3PtCut( Double_t val )       { fJet3PtCut = val; }
125     void   SetPtMinChPartJet( Double_t val )  { fChJetPtMin = val; }
126     
127     virtual const Double_t   GetJet1EtaCut()                { return fJet1EtaCut; }
128     virtual const Double_t   GetJet2DeltaPhiCut()             { return fJet2DeltaPhiCut; }
129     virtual const Double_t   GetJet2RatioPtCut()            { return fJet2RatioPtCut; }
130     virtual const Double_t   GetJet3PtCut()                 { return fJet3PtCut; }
131     virtual const Double_t   GetPtMinChPartJet()            { return fChJetPtMin; }
132     
133     // track cuts
134     void   SetTrackEtaCut( Double_t val ) { fTrackEtaCut = val; }
135     void   SetTrackPtCut( Double_t val )  { fTrackPtCut = val; }
136
137     virtual const Double_t   GetTrackEtaCut()           { return fTrackEtaCut; }
138     virtual const Double_t   GetTrackPtCut()            { return fTrackPtCut; }
139     
140
141     AliHistogramsUE*    fHistosUE;        //! points to AliHistogramsUE class   
142   protected:
143   static AliAnalysisTaskUE*     fgTaskUE;        // Pointer to single instance
144
145   private:
146     void         AddSettingsTree();    
147     void         AnalyseUE();
148     void         FillAvePartPtRegion( Double_t leadingE, Double_t ptMax, Double_t ptMin );
149     void         FillMultRegion( Double_t leadingE, Double_t nTrackPtmax, Double_t nTrackPtmin, Double_t ptMin );
150     void         FillSumPtRegion( Double_t leadingE, Double_t ptMax, Double_t ptMin );
151     TObjArray*   FindChargedParticleJets();
152     Int_t        IsTrackInsideRegion(TVector3 *jetVect, TVector3 *partVect);
153     void         QSortTracks(TObjArray &a, Int_t first, Int_t last);
154     void         SetRegionArea(TVector3 *jetVect);
155     TObjArray*   SortChargedParticles();
156     void         WriteSettings();
157     
158     AliAnalyseUE*       fAnaUE;           //! points to AliAnalyseUE class
159     AliAODEvent*        fAOD;             //! AOD Event 
160     TString             fAODBranch;       //  Jet branch name from standard AOD
161     Int_t               fDebug;           //  Debug flag
162     TList*              fListOfHistos;    //  Output list of histograms
163     
164     // Config
165     Int_t               fBinsPtInHist;     //  # bins for Pt histos range
166     Bool_t              fIsNorm2Area;      // Apply Area Normalization to collected observables
167     Double_t            fMaxJetPtInHist;   //  max Jet Pt value for histo range
168     Double_t            fMinJetPtInHist;   //  min Jet Pt value for histo range
169     
170     // For MC
171     Bool_t              fConstrainDistance;    // Constrain Distance between rec jet and pyth
172     Double_t            fMinDistance;          // Minimum distance between rec jet and pyth
173     Bool_t              fSimulateChJetPt;      // Naive simulation of charged jet Pt from original Jet in MC Header
174     Bool_t              fUseAliStack;          // Use AliSatck for particle info otherwise "mcparticles" branch in AOD
175     Bool_t              fUseMCParticleBranch;  // Run Over mcparticles branch in AOD
176     
177     // Cuts Events type
178     Int_t               fnTracksVertex;        // QA tracks pointing to principal vertex (= 3 default) 
179     Double_t            fZVertex;              // Position of Vertex in Z direction
180     
181     // Cuts UE analysis
182     Int_t               fAnaType;              // Analysis type on jet topology: 
183                                                   //     1=inclusive  (default) 
184                                                   //     2=back to back inclusive
185                                                   //     3=back to back exclusive
186                                                   //     4=Pt max (max Pt track in region)
187                                                   //     5=gama jet (back to back) ???
188                                                   //  Minimum bias
189                                                   //     31 = Semi jet (charged leading particle jets)
190                                                   //     32 = Random jetcone  ?
191                                                   //     33 = Swiss chees   ?
192     
193     
194     Int_t               fConePosition;         // This parameter set how will cone center in transversal zone will be set
195                                                   //    1 : To be used in any jet topology (default value)
196                                                   //        eta_cone = eta_leadingjet
197                                                   //        phi_cone = phi_leadingjet + - 90
198                                                   //    2 : To be used in multiple jet topology (code will cry otherwise)
199                                                   //        eta_cone = (eta_leadingjet + eta_subleadingjet)/2
200                                                   //        phi_cone = phi_leadingjet + - 90
201     
202     Double_t            fConeRadius;           // if selected Cone-like region type, set Radius (=0.7 default)
203     
204     UInt_t              fFilterBit;            // Select tracks from an specific track cut (default 0xFF all track selected)
205     
206     Bool_t              fJetsOnFly;            // if jets are reconstructed on the fly from AOD tracks (see ConnectInputData() )
207     
208     // UE analysis is conducted in different type of regions
209     // Transverse are those like defined in: R. Field Acta Physica Polonica B. Vol 36 No. 2 pg 167 (2005) 
210     // Cone regions like defined in: Phys. Rev. D 70, 072002 (2004)
211     Int_t               fRegionType;           // 1 = transverse regions (default)
212                                                // 2 = cone regions   
213     
214
215
216     Bool_t              fUseChargeHadrons;     // Only use charge hadrons
217     Bool_t              fUseChPartJet;         // Use "Charged Particle Jet" instead of jets from AOD see FindChargedParticleJets()
218     
219     // Theoreticians ask for tools charge-aware
220     // especially those which are related to multiplicity and MC-tunings
221     // see arXiv:hep-ph/0507008v3
222     Bool_t              fUsePositiveCharge;    //If Single type of charge used then set which one (=kTRUE default positive)
223     Bool_t              fUseSingleCharge;      //Make analysis for a single type of charge (=kFALSE default)
224     
225     Int_t               fOrdering;             //  Pt and multiplicity summation ordering:
226                         //     1=CDF-like -independent sorting according quantity to be scored: Double sorting- (default)
227                         //        if Pt summation will be scored take Pt minimum between both zones and 
228                         //        fill Pt Max. and Min. histog. accordingly
229                         //        if Multiplicity summation will be scored take Mult. minimum between both zones and 
230                         //        fill Mult Max and Min histog. accordingly
231                         //       Bib:
232                         //     2=Marchesini-like (Only Pt sorting: Single sorting)
233                         //        sort only according Pt summation scored, find minimum between both zones and
234                         //        fill Pt and Multiplicity Max and Min summation histog. following only this criterium
235                         //        Bib: Phys. Rev. D 38, 3419 (1988)
236                         //     3=Nameless pt per track single sorting
237                         //        sort according to pt per track scored in each transverse zone 
238                         //        lowest values indicates minimum zone.   
239                         //     4=User Selection sorting (NOTE: USER must implement it within cxx)
240    
241     
242     // Jet cuts 
243     Double_t            fChJetPtMin;       // Min Pt for charged Particle Jet
244     Double_t            fJet1EtaCut;       // |jet1 eta| < fJet1EtaCut   (fAnaType = 1,2,3)
245     Double_t            fJet2DeltaPhiCut;  // |Jet1.Phi - Jet2.Phi| < fJet2DeltaPhiCut (fAnaType = 2,3)
246     Double_t            fJet2RatioPtCut;   // Jet2.Pt/Jet1Pt > fJet2RatioPtCut  (fAnaType = 2,3)
247     Double_t            fJet3PtCut;        // Jet3.Pt < fJet3PtCut  (fAnaType = 3)
248
249     // track cuts
250     Double_t            fTrackEtaCut;      // Eta cut on tracks in the regions (fRegionType=1)
251     Double_t            fTrackPtCut;       // Pt cut of tracks in the regions
252    
253     // MC cross-section 
254     Double_t            fAvgTrials;        // average trials used to fill the fh1Trials histogram in case we do not have trials on a event by event basis
255     
256     /*
257     // Histograms
258     TH1F*  fhNJets;                  //! number of reco. jets or leading particles
259     TH1F*  fhEleadingPt;             //! pT distribution of leading-jet (leading-particle)
260     
261     TH1F*  fhMinRegPtDist;           //! pT distribution in MIN region
262     TH1F*  fhRegionMultMin;          //! average pT in MIN region
263     TH1F*  fhMinRegAvePt;            //! sum pT in MIN region
264     TH1F*  fhMinRegSumPt;            //! maximum particle pT in MAX region
265     TH1F*  fhMinRegMaxPtPart;        //! sum pT vs. multiplicity in MIN region
266     TH1F*  fhMinRegSumPtvsMult;      //!
267     
268     TH2F*  fhdNdEtaPhiDist;          //! phi and eta correlation with leading-jet (leading particle)
269     TH2F*  fhFullRegPartPtDistVsEt;  //! particle pT distribution vs. transverse energy in FULL region
270     TH2F*  fhTransRegPartPtDistVsEt; //! particle pT distribution vs. transverse energy in TRANSVERSE (MIN+MAX) region 
271     
272     TH1F*  fhRegionSumPtMaxVsEt;     //! sum pT vs. transverse energy in MAX region
273     TH1I*  fhRegionMultMax;          //! multiplicity in MAX region 
274     TH1F*  fhRegionMultMaxVsEt;      //! multiplicity vs. transverse energy in MAX region
275     TH1F*  fhRegionSumPtMinVsEt;     //! sum pT vs. transverse energy in MIN region
276     TH1F*  fhRegionMultMinVsEt;      //! multiplicity vs. transverse energy in MIN region
277     TH1F*  fhRegionAveSumPtVsEt;     //! average sum pT in 2 regions
278     TH1F*  fhRegionDiffSumPtVsEt;    //! difference sum pT in 2 regions
279     
280     TH1F*  fhRegionAvePartPtMaxVsEt; //! average particle pT vs. transverse energy in MAX region
281     TH1F*  fhRegionAvePartPtMinVsEt; //! average particle pT vs. transverse energy in MIN region
282     TH1F*  fhRegionMaxPartPtMaxVsEt; //! maximum particle pT vs. transverse energy in MAX region
283     
284     TH2F*  fhRegForwardMult;         //! multiplicity in FORWARD region
285     TH2F*  fhRegForwardSumPtvsMult;  //! sum pT vs. multiplicity in FORWARD region
286     TH2F*  fhRegBackwardMult;        //! multiplicity in BACKWARD region
287     TH2F*  fhRegBackwardSumPtvsMult; //! sum pT vs. multiplicity in BACKWARD region
288     TH2F*  fhRegForwardPartPtDistVsEt; //! particle pT distribution vs. transverse energy in FORWARD region
289     TH2F*  fhRegBackwardPartPtDistVsEt; //! particle pT distribution vs. transverse energy in BACKWARD
290     TH2F*  fhRegTransMult;         //! multiplicity in TRANSVERSE (MIN+MAX) region
291     TH2F*  fhRegTransSumPtVsMult;    //! sum pT vs. multiplicity in TRANSVERSE (MIN+MAX) region
292     TH2F*  fhMinRegSumPtJetPtBin;    //!
293     TH2F*  fhMaxRegSumPtJetPtBin;    //!
294     TH1F*  fhVertexMult;             //! vertex multiplicity
295  
296     TProfile*  fh1Xsec;             //! cross-section from MC   
297     TH1F*  fh1Trials;               //! number of trials from MC
298     */
299
300     ClassDef( AliAnalysisTaskUE, 6); // Analysis task for Underlying Event analysis
301   };
302
303 #endif
304
305