Restoring EMCAL digitization and reconstruction
[u/mrichter/AliRoot.git] / JETAN / AliJet.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15  
16 //---------------------------------------------------------------------
17 // Jet class 
18 // Stores the output of a jet algorithm
19 // Author: jgcn@mda.cinvestav.mx
20 //---------------------------------------------------------------------
21  
22 #include <Riostream.h>
23 #include <TClonesArray.h>
24 #include <TLorentzVector.h>
25
26 #include "AliJet.h"
27 ClassImp(AliJet)
28  
29  
30 ////////////////////////////////////////////////////////////////////////
31
32 AliJet::AliJet() 
33 {
34   //
35   // Constructor
36   //
37   fJets = new TClonesArray("TLorentzVector",1000);
38   fNInput=0;
39   fNJets=0;
40   fInJet=TArrayI();
41   fPtFromSignal=TArrayF();
42   fMultiplicities=TArrayI();
43
44
45 ////////////////////////////////////////////////////////////////////////
46
47 AliJet::~AliJet()
48 {
49   // destructor
50   if (fJets) {
51     fJets->Delete();
52     delete fJets;
53   }
54 }
55
56 ////////////////////////////////////////////////////////////////////////
57
58 Bool_t AliJet::OutOfRange(Int_t i, const char *s) const
59 {
60   // checks if i is a valid index. s= name of calling method
61   if (i >= fNJets || i < 0) {
62     cout << s << " Index " << i << " out of range" << endl;
63     return kTRUE;
64   }
65   return kFALSE;
66 }
67
68 ////////////////////////////////////////////////////////////////////////
69
70 TLorentzVector* AliJet::GetJet(Int_t i)
71 {
72   // returns i-jet
73   if (OutOfRange(i, "AliJet::GetJet:")) return 0;
74
75   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
76   return lv; 
77 }
78
79 ////////////////////////////////////////////////////////////////////////
80
81 Int_t AliJet::GetMultiplicity(Int_t i)
82 {
83   // gets multiplicity of i-jet
84   if (OutOfRange(i, "AliJet::GetMultiplicity:")) return 0;
85   return fMultiplicities[i];
86 }
87
88 ////////////////////////////////////////////////////////////////////////
89
90 Double_t AliJet::GetPx(Int_t i)
91 {
92 // Get Px component of jet i
93   if (OutOfRange(i, "AliJet::GetPx:")) return -1e30;
94
95   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
96   return lv->Px();
97 }
98
99 ////////////////////////////////////////////////////////////////////////
100
101 Double_t AliJet::GetPy(Int_t i)
102 {
103 // Get Py component of jet i
104   if (OutOfRange(i, "AliJet::GetPy:")) return -1e30;
105
106   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
107   return lv->Py();
108 }
109
110 ////////////////////////////////////////////////////////////////////////
111
112 Double_t AliJet::GetPz(Int_t i)
113 {
114 // Get Pz component of jet i
115   if (OutOfRange(i, "AliJet::GetPz:")) return -1e30;
116
117   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
118   return lv->Pz();
119 }
120
121 ////////////////////////////////////////////////////////////////////////
122
123 Double_t AliJet::GetP(Int_t i)
124 {
125 // Get momentum of jet i
126   if (OutOfRange(i, "AliJet::GetP:")) return -1e30;
127
128   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
129   return lv->P();
130 }
131
132 ////////////////////////////////////////////////////////////////////////
133
134 Double_t AliJet::GetE(Int_t i)
135 {
136 // Get energy of jet i
137   if (OutOfRange(i, "AliJet::GetE:")) return -1e30;
138
139   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
140   return lv->E();
141 }
142
143 ////////////////////////////////////////////////////////////////////////
144
145 Double_t AliJet::GetPt(Int_t i)
146 {
147 // Get transverse momentum of jet i
148   if (OutOfRange(i, "AliJet::GetPt:")) return -1e30;
149
150   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
151   return lv->Pt();
152 }
153
154 ////////////////////////////////////////////////////////////////////////
155
156 Double_t AliJet::GetEta(Int_t i)
157 {
158 // Get eta of jet i
159   if (OutOfRange(i, "AliJet::GetEta:")) return -1e30;
160
161   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
162   return lv->Eta();
163 }
164
165 ////////////////////////////////////////////////////////////////////////
166
167 Double_t AliJet::GetPhi(Int_t i)
168 {
169 // Get phi of jet i
170   if (OutOfRange(i, "AliJet::GetPhi:")) return -1e30;
171
172   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
173   return ( (lv->Phi() < 0) ? (lv->Phi()) + 2. * TMath::Pi() : lv->Phi());
174 }
175
176 ////////////////////////////////////////////////////////////////////////
177
178 Double_t AliJet::GetTheta(Int_t i)
179 {
180 // Get theta of jet i
181   if (OutOfRange(i, "AliJet::GetTheta:")) return -1e30;
182
183   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
184   return lv->Theta();
185 }
186
187 ////////////////////////////////////////////////////////////////////////
188
189 Double_t AliJet::GetMass(Int_t i)
190 {
191 // Get invariant mass of jet i
192   if (OutOfRange(i, "AliJet::GetMass:")) return -1e30;
193
194   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
195   return lv->M();
196 }
197
198 ////////////////////////////////////////////////////////////////////////
199  
200
201 void AliJet::AddJet(Double_t px, Double_t py, Double_t pz, Double_t e)
202 {
203 // Add new jet to the list
204   new ((*fJets)[fNJets++]) TLorentzVector(px,py,pz,e);
205 }
206
207 ////////////////////////////////////////////////////////////////////////
208
209 void AliJet::SetInJet(Int_t* j)
210 {
211   // set information of which input object belongs
212   // to each jet. filled in by AliJetFinder
213   if (fNInput>0) fInJet.Set(fNInput, j);
214 }
215
216 ////////////////////////////////////////////////////////////////////////
217
218 void AliJet::SetPtFromSignal(Float_t* p)
219 {
220   // set information of percentage of pt of jets
221   // coming from signal (ie Pythia)
222   if (fNJets>0) fPtFromSignal.Set(fNJets, p);
223 }
224
225 ////////////////////////////////////////////////////////////////////////
226
227 void AliJet::SetMultiplicities(Int_t* m)
228 {
229   // set information of jet multiplicities
230   // filled in by AliJetFinder
231   if (fNJets>0) fMultiplicities.Set(fNJets, m);
232 }
233
234 ////////////////////////////////////////////////////////////////////////
235
236 void AliJet::ClearJets(Option_t *option)
237 {
238   // reset all values
239   fJets->Clear(option);
240   fNInput=0;
241   fNJets=0;
242   fMultiplicities.Set(0);
243   fInJet.Set(0); 
244 }
245
246 ////////////////////////////////////////////////////////////////////////
247
248 void AliJet::PrintJets()
249 {
250 // Print jet information
251   if (fNJets == 0) {
252     cout << " AliJet::PrintJets: There are no jets in this event " << endl;
253     return;
254   }
255   cout << " AliJet::PrintJets: There are " << fNJets
256        << " jets in this event" << endl;
257   for(Int_t i=0;i<fNJets;i++) {
258     cout << "   Jet " << i << " (px,py,pz,en)=(" << GetPx(i)
259          << "," << GetPy(i)
260          << "," << GetPz(i)
261          << "," << GetE(i) 
262          << ")" << endl;
263     cout << "         (pt,eta,phi)=(" << GetPt(i)
264          << "," << GetEta(i)
265          << "," << GetPhi(i) << ")" << endl;
266     cout << "         # of tracks =" << GetMultiplicity(i) << endl;
267   }
268 }