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 /* $Id$ */
  17
  18 //---------------------------------------------------------------------
  19 // Jet class
  20 // Stores the output of a jet algorithm
  21 // Author: jgcn@mda.cinvestav.mx
  22 //---------------------------------------------------------------------
  23
  24
  25 #include <Riostream.h>
  26 #include <TClonesArray.h>
  27 #include <TLorentzVector.h>
  28
  29 #include "AliJet.h"
  30 ClassImp(AliJet)
  31
  32 AliJet::AliJet():
  33   fNInput(0),
  34   fNJets(0),
  35   fEtAvg(0),
  36   fInJet(0),
  37   fMultiplicities(0),
  38   fNCells(0),
  39   fPtFromSignal(0),
  40   fJets(0),
  41   fEtaIn(0),
  42   fPhiIn(0),
  43   fPtIn(0),
  44   fPtChPtCutIn(0),
  45   fEnTotChPtCutIn(0),
  46   fDetIn(0),
  47   fTrackRef(new TRefArray())
  48 {
  49   // Default constructor
  50   fJets = new TClonesArray("TLorentzVector",1000);
  51   fInJet = TArrayI();
  52   fPtIn = TArrayF();
  53   fEtaIn = TArrayF();
  54   fPhiIn = TArrayF();
  55   fPtFromSignal = TArrayF();
  56   fMultiplicities = TArrayI();
  57   fNCells = TArrayI();
  58   fPtChPtCutIn = TArrayF();
  59   fEnTotChPtCutIn = TArrayF();
  60   fDetIn = TArrayI();
  61 }
  62
  63 ////////////////////////////////////////////////////////////////////////
  64
  65 AliJet::~AliJet()
  66 {
  67   // destructor
  68   if (fJets) {
  69     fJets->Delete();
  70     delete fJets;
  71   }
  72 }
  73
  74 ////////////////////////////////////////////////////////////////////////
  75
  76 Bool_t AliJet::OutOfRange(Int_t i, const char *s) const
  77 {
  78   // checks if i is a valid index. s = name of calling method
  79   if (i >= fNJets || i < 0) {
  80     cout << s << " Index " << i << " out of range" << endl;
  81     return kTRUE;
  82   }
  83   return kFALSE;
  84 }
  85
  86 ////////////////////////////////////////////////////////////////////////
  87
  88 TLorentzVector* AliJet::GetJet(Int_t i)
  89 {
  90   // returns i-jet
  91   if (OutOfRange(i, "AliJet::GetJet:")) return 0;
  92   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  93   return lv;
  94 }
  95
  96 ////////////////////////////////////////////////////////////////////////
  97
  98 Int_t AliJet::GetMultiplicity(Int_t i) const
  99 {
 100   // gets multiplicity of i-jet
 101   if (OutOfRange(i, "AliJet::GetMultiplicity:")) return 0;
 102   return fMultiplicities[i];
 103 }
 104
 105 ////////////////////////////////////////////////////////////////////////
 106
 107 Int_t AliJet::GetNCell(Int_t i) const
 108 {
 109   // gets number of cell of i-jet
 110   if (OutOfRange(i, "AliJet::GetNCell:")) return 0;
 111   return fNCells[i];
 112 }
 113
 114 ////////////////////////////////////////////////////////////////////////
 115
 116 Double_t AliJet::GetPx(Int_t i)
 117 {
 118 // Get Px component of jet i
 119   if (OutOfRange(i, "AliJet::GetPx:")) return -1e30;
 120   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 121   return lv->Px();
 122 }
 123
 124 ////////////////////////////////////////////////////////////////////////
 125
 126 Double_t AliJet::GetPy(Int_t i)
 127 {
 128 // Get Py component of jet i
 129   if (OutOfRange(i, "AliJet::GetPy:")) return -1e30;
 130   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 131   return lv->Py();
 132 }
 133
 134 ////////////////////////////////////////////////////////////////////////
 135
 136 Double_t AliJet::GetPz(Int_t i)
 137 {
 138 // Get Pz component of jet i
 139   if (OutOfRange(i, "AliJet::GetPz:")) return -1e30;
 140   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 141   return lv->Pz();
 142 }
 143
 144 ////////////////////////////////////////////////////////////////////////
 145
 146 Double_t AliJet::GetP(Int_t i)
 147 {
 148 // Get momentum of jet i
 149   if (OutOfRange(i, "AliJet::GetP:")) return -1e30;
 150   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 151   return lv->P();
 152 }
 153
 154 ////////////////////////////////////////////////////////////////////////
 155
 156 Double_t AliJet::GetE(Int_t i)
 157 {
 158 // Get energy of jet i
 159   if (OutOfRange(i, "AliJet::GetE:")) return -1e30;
 160   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 161   return lv->E();
 162 }
 163
 164 ////////////////////////////////////////////////////////////////////////
 165
 166 Double_t AliJet::GetPt(Int_t i)
 167 {
 168 // Get transverse momentum of jet i
 169   if (OutOfRange(i, "AliJet::GetPt:")) return -1e30;
 170   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 171   return lv->Pt();
 172 }
 173
 174 ////////////////////////////////////////////////////////////////////////
 175
 176 Double_t AliJet::GetEta(Int_t i)
 177 {
 178 // Get eta of jet i
 179   if (OutOfRange(i, "AliJet::GetEta:")) return -1e30;
 180   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 181   return lv->Eta();
 182 }
 183
 184 ////////////////////////////////////////////////////////////////////////
 185
 186 Double_t AliJet::GetPhi(Int_t i)
 187 {
 188 // Get phi of jet i
 189   if (OutOfRange(i, "AliJet::GetPhi:")) return -1e30;
 190   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 191   return ( (lv->Phi() < 0) ? (lv->Phi()) + 2. * TMath::Pi() : lv->Phi());
 192 }
 193
 194 ////////////////////////////////////////////////////////////////////////
 195
 196 Double_t AliJet::GetTheta(Int_t i)
 197 {
 198 // Get theta of jet i
 199   if (OutOfRange(i, "AliJet::GetTheta:")) return -1e30;
 200   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 201   return lv->Theta();
 202 }
 203
 204 ////////////////////////////////////////////////////////////////////////
 205
 206 Double_t AliJet::GetMass(Int_t i)
 207 {
 208 // Get invariant mass of jet i
 209   if (OutOfRange(i, "AliJet::GetMass:")) return -1e30;
 210   TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
 211   return lv->M();
 212 }
 213
 214 ////////////////////////////////////////////////////////////////////////
 215
 216
 217 void AliJet::AddJet(Double_t px, Double_t py, Double_t pz, Double_t e)
 218 {
 219 // Add new jet to the list
 220   new ((*fJets)[fNJets++]) TLorentzVector(px,py,pz,e);
 221 }
 222
 223 ////////////////////////////////////////////////////////////////////////
 224
 225 void AliJet::SetInJet(Int_t* j)
 226 {
 227   // set information of which input object belongs
 228   // to each jet. If zero, object was not assigned to
 229   // a jet, if n,positive, it was assiged to jet n
 230   // if n, negative, it is within cone of jet n, but
 231   // it did not passed the user cuts. filled in by AliJetFinder
 232   if (fNInput>0) fInJet.Set(fNInput, j);
 233 }
 234
 235 ////////////////////////////////////////////////////////////////////////
 236
 237 void AliJet::SetEtaIn(Float_t* r)
 238 {
 239   if (fNInput>0) fEtaIn.Set(fNInput, r);
 240 }
 241
 242 ////////////////////////////////////////////////////////////////////////
 243
 244 void AliJet::SetPtIn(Float_t* pt)
 245 {
 246   if (fNInput>0) fPtIn.Set(fNInput, pt);
 247 }
 248
 249 ////////////////////////////////////////////////////////////////////////
 250
 251 void AliJet::SetPhiIn(Float_t* x)
 252 {
 253   if (fNInput>0) fPhiIn.Set(fNInput, x);
 254 }
 255 ////////////////////////////////////////////////////////////////////////
 256
 257 void AliJet::SetPtChargedPtCutIn(Float_t* x)
 258 {
 259   if (fNInput>0) fPtChPtCutIn.Set(fNInput, x);
 260 }
 261 ////////////////////////////////////////////////////////////////////////
 262
 263 void AliJet::SetEnTotChargedPtCutIn(Float_t* x)
 264 {
 265   if (fNInput>0) fEnTotChPtCutIn.Set(fNInput, x);
 266 }
 267
 268 ////////////////////////////////////////////////////////////////////////
 269
 270 void AliJet::SetDetectorFlagIn(Int_t* x)
 271 {
 272   if (fNInput>0) fDetIn.Set(fNInput, x);
 273 }
 274
 275 ////////////////////////////////////////////////////////////////////////
 276
 277 void AliJet::SetPtFromSignal(Float_t* p)
 278 {
 279   // set information of percentage of pt of jets
 280   // coming from signal (ie Pythia)
 281   if (fNJets>0) fPtFromSignal.Set(fNJets, p);
 282 }
 283
 284 ////////////////////////////////////////////////////////////////////////
 285
 286 void AliJet::SetMultiplicities(Int_t* m)
 287 {
 288   // set information of jet multiplicities
 289   // filled in by AliJetFinder
 290   if (fNJets>0) fMultiplicities.Set(fNJets, m);
 291 }
 292
 293 ////////////////////////////////////////////////////////////////////////
 294
 295 void AliJet::SetNCells(Int_t* n)
 296 {
 297   if (fNJets>0) fNCells.Set(fNJets, n);
 298 }
 299
 300 ////////////////////////////////////////////////////////////////////////
 301
 302 void AliJet::ClearJets(Option_t *option)
 303 {
 304   // reset all values
 305   fJets->Clear(option);
 306   fNInput=0;
 307   fNJets=0;
 308   fMultiplicities.Set(0);
 309   fInJet.Set(0);
 310   fPtFromSignal.Set(0);
 311   fPhiIn.Set(0);
 312   fEtaIn.Set(0);
 313   fPtIn.Set(0);
 314   fNCells.Set(0);
 315   fPtChPtCutIn.Set(0);
 316   fEnTotChPtCutIn.Set(0);
 317   fDetIn.Set(0);
 318 }
 319
 320 ////////////////////////////////////////////////////////////////////////
 321
 322 void AliJet::PrintJets()
 323 {
 324 // Print jet information
 325   if (fNJets == 0) {
 326     cout << " AliJet::PrintJets: There are no jets in this event " << endl;
 327     return;
 328   }
 329   cout << " AliJet::PrintJets: There are " << fNJets
 330        << " jets in this event" << endl;
 331   for(Int_t i=0;i<fNJets;i++) {
 332     cout << "   Jet " << i << " (px,py,pz,en)=(" << GetPx(i)
 333          << "," << GetPy(i)
 334          << "," << GetPz(i)
 335          << "," << GetE(i)
 336          << ")" << endl;
 337     cout << "         (pt,eta,phi)=(" << GetPt(i)
 338          << "," << GetEta(i)
 339          << "," << GetPhi(i) << ")" << endl;
 340     cout << "         # of tracks =" << GetMultiplicity(i) << endl;
 341   }
 342 }