[u/mrichter/AliRoot.git] / JETAN / AliJet.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */
 
//---------------------------------------------------------------------
// Jet class 
// Stores the output of a jet algorithm
// Author: jgcn@mda.cinvestav.mx
//---------------------------------------------------------------------
 
#include <Riostream.h>
#include <TClonesArray.h>
#include <TLorentzVector.h>

#include "AliJet.h"
ClassImp(AliJet)
  
AliJet::AliJet():
  fNInput(0),
  fNJets(0),
  fEtAvg(0),
  fInJet(0),
  fMultiplicities(0),
  fNCells(0),
  fPtFromSignal(0),
  fJets(0),
  fEtaIn(0),
  fPhiIn(0),
  fPtIn(0)
{
  // Default constructor
  fJets = new TClonesArray("TLorentzVector",1000);
  fInJet = TArrayI();
  fPtIn = TArrayF();
  fEtaIn = TArrayF();
  fPhiIn = TArrayF();
  fPtFromSignal = TArrayF();
  fMultiplicities = TArrayI();
  fNCells = TArrayI();
} 

////////////////////////////////////////////////////////////////////////

AliJet::~AliJet()
{
  // destructor
  if (fJets) {
    fJets->Delete();
    delete fJets;
  }
}

////////////////////////////////////////////////////////////////////////

Bool_t AliJet::OutOfRange(Int_t i, const char *s) const
{
  // checks if i is a valid index. s = name of calling method
  if (i >= fNJets || i < 0) {
    cout << s << " Index " << i << " out of range" << endl;
    return kTRUE;
  }
  return kFALSE;
}

////////////////////////////////////////////////////////////////////////

TLorentzVector* AliJet::GetJet(Int_t i)
{
  // returns i-jet
  if (OutOfRange(i, "AliJet::GetJet:")) return 0;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv; 
}

////////////////////////////////////////////////////////////////////////

Int_t AliJet::GetMultiplicity(Int_t i) const
{
  // gets multiplicity of i-jet
  if (OutOfRange(i, "AliJet::GetMultiplicity:")) return 0;
  return fMultiplicities[i];
}

////////////////////////////////////////////////////////////////////////

Int_t AliJet::GetNCell(Int_t i) const
{
  // gets number of cell of i-jet
  if (OutOfRange(i, "AliJet::GetNCell:")) return 0;
  return fNCells[i];
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetPx(Int_t i)
{
// Get Px component of jet i
  if (OutOfRange(i, "AliJet::GetPx:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Px();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetPy(Int_t i)
{
// Get Py component of jet i
  if (OutOfRange(i, "AliJet::GetPy:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Py();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetPz(Int_t i)
{
// Get Pz component of jet i
  if (OutOfRange(i, "AliJet::GetPz:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Pz();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetP(Int_t i)
{
// Get momentum of jet i
  if (OutOfRange(i, "AliJet::GetP:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->P();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetE(Int_t i)
{
// Get energy of jet i
  if (OutOfRange(i, "AliJet::GetE:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->E();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetPt(Int_t i)
{
// Get transverse momentum of jet i
  if (OutOfRange(i, "AliJet::GetPt:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Pt();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetEta(Int_t i)
{
// Get eta of jet i
  if (OutOfRange(i, "AliJet::GetEta:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Eta();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetPhi(Int_t i)
{
// Get phi of jet i
  if (OutOfRange(i, "AliJet::GetPhi:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return ( (lv->Phi() < 0) ? (lv->Phi()) + 2. * TMath::Pi() : lv->Phi());
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetTheta(Int_t i)
{
// Get theta of jet i
  if (OutOfRange(i, "AliJet::GetTheta:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->Theta();
}

////////////////////////////////////////////////////////////////////////

Double_t AliJet::GetMass(Int_t i)
{
// Get invariant mass of jet i
  if (OutOfRange(i, "AliJet::GetMass:")) return -1e30;
  TLorentzVector *lv = (TLorentzVector*) fJets->At(i);
  return lv->M();
}

////////////////////////////////////////////////////////////////////////
 

void AliJet::AddJet(Double_t px, Double_t py, Double_t pz, Double_t e)
{
// Add new jet to the list
  new ((*fJets)[fNJets++]) TLorentzVector(px,py,pz,e);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetInJet(Int_t* j)
{
  // set information of which input object belongs
  // to each jet. If zero, object was not assigned to
  // a jet, if n,positive, it was assiged to jet n
  // if n, negative, it is within cone of jet n, but
  // it did not passed the user cuts. filled in by AliJetFinder
  if (fNInput>0) fInJet.Set(fNInput, j);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetEtaIn(Float_t* r)
{
  if (fNInput>0) fEtaIn.Set(fNInput, r);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetPtIn(Float_t* pt)
{
  if (fNInput>0) fPtIn.Set(fNInput, pt);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetPhiIn(Float_t* x)
{
  if (fNInput>0) fPhiIn.Set(fNInput, x);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetPtFromSignal(Float_t* p)
{
  // set information of percentage of pt of jets
  // coming from signal (ie Pythia)
  if (fNJets>0) fPtFromSignal.Set(fNJets, p);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetMultiplicities(Int_t* m)
{
  // set information of jet multiplicities
  // filled in by AliJetFinder
  if (fNJets>0) fMultiplicities.Set(fNJets, m);
}

////////////////////////////////////////////////////////////////////////

void AliJet::SetNCells(Int_t* n)
{
  if (fNJets>0) fNCells.Set(fNJets, n);
}

////////////////////////////////////////////////////////////////////////

void AliJet::ClearJets(Option_t *option)
{
  // reset all values
  fJets->Clear(option);
  fNInput=0;
  fNJets=0;
  fMultiplicities.Set(0);
  fInJet.Set(0); 
  fPtFromSignal.Set(0);
  fPhiIn.Set(0);
  fEtaIn.Set(0);
  fPtIn.Set(0);
  fNCells.Set(0);
}

////////////////////////////////////////////////////////////////////////

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