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