[u/mrichter/AliRoot.git] / JETAN / AliJetUnitArray.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$ */

//_________________________________________________________________________
//  Unit used by UA1 algorithm
// --
//*-- Author: Sarah Blyth (LBL/UCT)
// --
// Revised Version for JETAN 
// -- Magali Estienne (magali.estienne@subatech.in2p3.fr)

#include "AliJetUnitArray.h"

class TVector3;
class TLorentzVector;
class TClonesArray;

ClassImp(AliJetUnitArray)

AliJetUnitArray::AliJetUnitArray():
  fUnitEnergy(0.0),
  fUnitEta(0.0),
  fUnitPhi(0.0),
  fUnitDeta(0.),
  fUnitDphi(0.),
  fUnitID(0),
  fUnitTrackID(0),
  fUnitNum(0),
  fUnitClusterID(0),
  fUnitFlag(kOutJet),
  fUnitCutFlag(kPtSmaller),
  fUnitCutFlag2(kPtSmaller),
  fUnitSignalFlag(kBad), 
  fUnitDetectorFlag(kTpc),
  fUnitPx(0.),
  fUnitPy(0.),
  fUnitPz(0.),
  fUnitMass(0.),
  fVc(0),
  fVn(0),
  fUnitTrackRef(new TRefArray),
  fUnitCellRef(new TRefArray),
  fUnitClusterRef(new TRefArray)
{
  // Default constructor
}  

AliJetUnitArray::AliJetUnitArray(Int_t absId, Int_t esdId, Float_t eta, Float_t phi, Float_t en, Float_t Deta, Float_t Dphi, AliJetFinderUnitDetectorFlagType_t det, AliJetFinderUnitFlagType_t inout, AliJetFinderUnitCutFlagType_t cut, AliJetFinderUnitCutFlagType_t cut2, AliJetFinderUnitSignalFlagType_t /*signal*/,Float_t mass, Int_t clusId):
  fUnitEnergy(en),
  fUnitEta(eta),
  fUnitPhi(phi),
  fUnitDeta(Deta),
  fUnitDphi(Dphi),
  fUnitID(absId),
  fUnitTrackID(esdId),
  fUnitNum(0),
  fUnitClusterID(clusId),
  fUnitFlag(inout),
  fUnitCutFlag(cut),
  fUnitCutFlag2(cut2),
  fUnitSignalFlag(kBad), 
  fUnitDetectorFlag(det),
  fUnitPx(0.),
  fUnitPy(0.),
  fUnitPz(0.),
  fUnitMass(mass),
  fVc(0),
  fVn(0),
  fUnitTrackRef(new TRefArray),
  fUnitCellRef(new TRefArray),
  fUnitClusterRef(new TRefArray)
{
  //abs ID (in a eta,phi grid, track ID in ESD, eta, phi, energy, px, py, pz, Deta, Dphi, detector flag, in/out jet, mass

  // Constructor 2
}

AliJetUnitArray::AliJetUnitArray(Int_t absId, Int_t esdId, Float_t eta, Float_t phi, Float_t en, Float_t px, Float_t py, Float_t pz, Float_t Deta, Float_t Dphi, AliJetFinderUnitDetectorFlagType_t det, AliJetFinderUnitFlagType_t inout, AliJetFinderUnitCutFlagType_t cut, Float_t mass, Int_t clusId):
  fUnitEnergy(en),
  fUnitEta(eta),
  fUnitPhi(phi),
  fUnitDeta(Deta),
  fUnitDphi(Dphi),
  fUnitID(absId),
  fUnitTrackID(esdId),
  fUnitNum(0),
  fUnitClusterID(clusId),
  fUnitFlag(inout),
  fUnitCutFlag(cut),
  fUnitCutFlag2(kPtSmaller),
  fUnitSignalFlag(kBad),
  fUnitDetectorFlag(det),
  fUnitPx(px),
  fUnitPy(py),
  fUnitPz(pz),
  fUnitMass(mass),
  fVc(0),
  fVn(0),
  fUnitTrackRef(new TRefArray),
  fUnitCellRef(new TRefArray),
  fUnitClusterRef(new TRefArray)
{
  // Constructor 2
}
 
AliJetUnitArray::AliJetUnitArray(const AliJetUnitArray& rUnit):
  TObject(rUnit),
  fUnitEnergy(rUnit.fUnitEnergy),
  fUnitEta(rUnit.fUnitEta),
  fUnitPhi(rUnit.fUnitPhi),
  fUnitDeta(rUnit.fUnitDeta),
  fUnitDphi(rUnit.fUnitDphi),
  fUnitID(rUnit.fUnitID),
  fUnitTrackID(rUnit.fUnitTrackID),
  fUnitNum(rUnit.fUnitNum),
  fUnitClusterID(rUnit.fUnitClusterID),
  fUnitFlag(rUnit.fUnitFlag),
  fUnitCutFlag(rUnit.fUnitCutFlag),
  fUnitCutFlag2(rUnit.fUnitCutFlag2),
  fUnitSignalFlag(rUnit.fUnitSignalFlag),
  fUnitDetectorFlag(rUnit.fUnitDetectorFlag),
  fUnitPx(rUnit.fUnitPx),
  fUnitPy(rUnit.fUnitPy),
  fUnitPz(rUnit.fUnitPz),
  fUnitMass(rUnit.fUnitMass),
  fVc(rUnit.fVc),
  fVn(rUnit.fVn),
  fUnitTrackRef(rUnit.fUnitTrackRef),
  fUnitCellRef(rUnit.fUnitCellRef),
  fUnitClusterRef(rUnit.fUnitClusterRef)
{
  // Copy constructor
}

AliJetUnitArray& AliJetUnitArray::operator=(const AliJetUnitArray& rhs)
{
  // Assignment
    if (this != &rhs) {
	fUnitEnergy = rhs.fUnitEnergy;
	fUnitEta = rhs.fUnitEta;
	fUnitPhi = rhs.fUnitPhi;
	fUnitDeta = rhs.fUnitDeta;
	fUnitDphi = rhs.fUnitDphi;
	fUnitID = rhs.fUnitID;
	fUnitTrackID = rhs.fUnitTrackID;
	fUnitNum = rhs.fUnitNum;
	fUnitClusterID = rhs.fUnitClusterID;
	fUnitFlag = rhs.fUnitFlag;
	fUnitCutFlag = rhs.fUnitCutFlag;
	fUnitCutFlag2 = rhs.fUnitCutFlag2;
	fUnitSignalFlag = rhs.fUnitSignalFlag;
	fUnitDetectorFlag = rhs.fUnitDetectorFlag;
	fUnitPx = rhs.fUnitPx;
	fUnitPy = rhs.fUnitPy;
	fUnitPz = rhs.fUnitPz;
	fUnitMass = rhs.fUnitMass;
	fVc = rhs.fVc;
	fVn = rhs.fVn;
	fUnitTrackRef = rhs.fUnitTrackRef;
	fUnitCellRef = rhs.fUnitCellRef;
	fUnitClusterRef = rhs.fUnitClusterRef;
    }
  return *this;

}


//------------------------------------------------------------------------
AliJetUnitArray::~AliJetUnitArray()
{
  // Destructor 
  delete fUnitTrackRef;
  delete fUnitCellRef;
  delete fUnitClusterRef;

}

void AliJetUnitArray::ClearUnitTrackRef()
{
  fUnitTrackRef->Clear();
}

void AliJetUnitArray::ClearUnitCellRef()
{
  fUnitCellRef->Clear();
}

//------------------------------------------------------------------------
void AliJetUnitArray::SetUnitSignalFlagC(Bool_t init, AliJetFinderUnitSignalFlagType_t flag)
{
  // Set signal flag of the charged particle
  if(init){
    if(!fVc.empty())
      fVc.clear();
  }
  else fVc.push_back(flag);
}

//------------------------------------------------------------------------
void AliJetUnitArray::SetUnitSignalFlagN(Bool_t init, AliJetFinderUnitSignalFlagType_t flag)
{
  // Set signal flag of the neutral cell
  if(init){
    if(!fVn.empty())
      fVn.clear();
  }
  else fVn.push_back(flag);
}


//------------------------------------------------------------------------
Bool_t AliJetUnitArray::GetUnitSignalFlagC(Int_t ind, AliJetFinderUnitSignalFlagType_t &flagc)
{
  // Get signal flag of the charged particle
  if(ind <= (Int_t)fVc.size())
    {
      flagc = (AliJetFinderUnitSignalFlagType_t)fVc[ind];
      return kTRUE;
    }
  else return kFALSE;
}

//------------------------------------------------------------------------
Bool_t AliJetUnitArray::GetUnitSignalFlagN(Int_t ind, AliJetFinderUnitSignalFlagType_t &flagn)
{
  // Get signal flag of the neutral cell
  if(ind <= (Int_t)fVn.size())
    {
      flagn = (AliJetFinderUnitSignalFlagType_t)fVn[ind];
      return kTRUE;
    }
  else return kFALSE;
}

//------------------------------------------------------------------------
Float_t  AliJetUnitArray::EtaToTheta(Float_t arg) const
{
  // Eta to theta transformation
  return 2.*atan(exp(-arg));
}

//------------------------------------------------------------------------
Bool_t AliJetUnitArray::operator>(const AliJetUnitArray* unit) const
{
  // Greater than operator used by sort
  if( fUnitEnergy > unit->GetUnitEnergy())
    return kTRUE;
  else 
    return kFALSE;
}

//------------------------------------------------------------------------
Bool_t AliJetUnitArray::operator<(const AliJetUnitArray* unit) const
{
  // Less than operator used by sort
  if( fUnitEnergy < unit->GetUnitEnergy())
    return kTRUE;
  else
    return kFALSE;
}

//------------------------------------------------------------------------
Bool_t AliJetUnitArray::operator==(const AliJetUnitArray* unit) const
{
  // equality operator used by sort
  if( fUnitEnergy == unit->GetUnitEnergy())
    return kTRUE;
  else
    return kFALSE;
}
Commit	Line	Data
4a01bb2c	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
8838ab7a	16
	17	/* $Id$ */
	18
	19	//_________________________________________________________________________
4a01bb2c	20	// Unit used by UA1 algorithm
8838ab7a	21	// --
	22	//*-- Author: Sarah Blyth (LBL/UCT)
	23	// --
	24	// Revised Version for JETAN
be6e5811	25	// -- Magali Estienne (magali.estienne@subatech.in2p3.fr)
4a01bb2c	26
8838ab7a	27	#include "AliJetUnitArray.h"
4a01bb2c	28
be6e5811	29	class TVector3;
	30	class TLorentzVector;
	31	class TClonesArray;
	32
4a01bb2c	33	ClassImp(AliJetUnitArray)
4a01bb2c	34
b92e2ccf	35	AliJetUnitArray::AliJetUnitArray():
ee7de0dd	36	fUnitEnergy(0.0),
	37	fUnitEta(0.0),
	38	fUnitPhi(0.0),
	39	fUnitDeta(0.),
	40	fUnitDphi(0.),
	41	fUnitID(0),
	42	fUnitTrackID(0),
	43	fUnitNum(0),
	44	fUnitClusterID(0),
	45	fUnitFlag(kOutJet),
	46	fUnitCutFlag(kPtSmaller),
8838ab7a	47	fUnitCutFlag2(kPtSmaller),
ee7de0dd	48	fUnitSignalFlag(kBad),
	49	fUnitDetectorFlag(kTpc),
	50	fUnitPx(0.),
	51	fUnitPy(0.),
	52	fUnitPz(0.),
8838ab7a	53	fUnitMass(0.),
8838ab7a	54	fVc(0),
8838ab7a	55	fVn(0),
be6e5811	56	fUnitTrackRef(new TRefArray),
	57	fUnitCellRef(new TRefArray),
	58	fUnitClusterRef(new TRefArray)
4a01bb2c	59	{
4a01bb2c	60	// Default constructor
4a01bb2c	61	}
4a01bb2c	62
08c28025	63	AliJetUnitArray::AliJetUnitArray(Int_t absId, Int_t esdId, Float_t eta, Float_t phi, Float_t en, Float_t Deta, Float_t Dphi, AliJetFinderUnitDetectorFlagType_t det, AliJetFinderUnitFlagType_t inout, AliJetFinderUnitCutFlagType_t cut, AliJetFinderUnitCutFlagType_t cut2, AliJetFinderUnitSignalFlagType_t /signal/,Float_t mass, Int_t clusId):
8838ab7a	64	fUnitEnergy(en),
	65	fUnitEta(eta),
	66	fUnitPhi(phi),
	67	fUnitDeta(Deta),
	68	fUnitDphi(Dphi),
	69	fUnitID(absId),
	70	fUnitTrackID(esdId),
	71	fUnitNum(0),
	72	fUnitClusterID(clusId),
	73	fUnitFlag(inout),
	74	fUnitCutFlag(cut),
	75	fUnitCutFlag2(cut2),
be6e5811	76	fUnitSignalFlag(kBad),
8838ab7a	77	fUnitDetectorFlag(det),
	78	fUnitPx(0.),
	79	fUnitPy(0.),
	80	fUnitPz(0.),
	81	fUnitMass(mass),
8838ab7a	82	fVc(0),
8838ab7a	83	fVn(0),
be6e5811	84	fUnitTrackRef(new TRefArray),
	85	fUnitCellRef(new TRefArray),
	86	fUnitClusterRef(new TRefArray)
8838ab7a	87	{
	88	//abs ID (in a eta,phi grid, track ID in ESD, eta, phi, energy, px, py, pz, Deta, Dphi, detector flag, in/out jet, mass
	89
	90	// Constructor 2
	91	}
	92
ee7de0dd	93	AliJetUnitArray::AliJetUnitArray(Int_t absId, Int_t esdId, Float_t eta, Float_t phi, Float_t en, Float_t px, Float_t py, Float_t pz, Float_t Deta, Float_t Dphi, AliJetFinderUnitDetectorFlagType_t det, AliJetFinderUnitFlagType_t inout, AliJetFinderUnitCutFlagType_t cut, Float_t mass, Int_t clusId):
	94	fUnitEnergy(en),
	95	fUnitEta(eta),
	96	fUnitPhi(phi),
	97	fUnitDeta(Deta),
	98	fUnitDphi(Dphi),
	99	fUnitID(absId),
	100	fUnitTrackID(esdId),
	101	fUnitNum(0),
	102	fUnitClusterID(clusId),
	103	fUnitFlag(inout),
	104	fUnitCutFlag(cut),
8838ab7a	105	fUnitCutFlag2(kPtSmaller),
8838ab7a	106	fUnitSignalFlag(kBad),
ee7de0dd	107	fUnitDetectorFlag(det),
	108	fUnitPx(px),
	109	fUnitPy(py),
	110	fUnitPz(pz),
8838ab7a	111	fUnitMass(mass),
8838ab7a	112	fVc(0),
8838ab7a	113	fVn(0),
be6e5811	114	fUnitTrackRef(new TRefArray),
	115	fUnitCellRef(new TRefArray),
	116	fUnitClusterRef(new TRefArray)
ee7de0dd	117	{
	118	// Constructor 2
	119	}
8838ab7a	120
be6e5811	121	AliJetUnitArray::AliJetUnitArray(const AliJetUnitArray& rUnit):
	122	TObject(rUnit),
	123	fUnitEnergy(rUnit.fUnitEnergy),
	124	fUnitEta(rUnit.fUnitEta),
	125	fUnitPhi(rUnit.fUnitPhi),
	126	fUnitDeta(rUnit.fUnitDeta),
	127	fUnitDphi(rUnit.fUnitDphi),
	128	fUnitID(rUnit.fUnitID),
	129	fUnitTrackID(rUnit.fUnitTrackID),
	130	fUnitNum(rUnit.fUnitNum),
	131	fUnitClusterID(rUnit.fUnitClusterID),
	132	fUnitFlag(rUnit.fUnitFlag),
	133	fUnitCutFlag(rUnit.fUnitCutFlag),
	134	fUnitCutFlag2(rUnit.fUnitCutFlag2),
	135	fUnitSignalFlag(rUnit.fUnitSignalFlag),
	136	fUnitDetectorFlag(rUnit.fUnitDetectorFlag),
	137	fUnitPx(rUnit.fUnitPx),
	138	fUnitPy(rUnit.fUnitPy),
	139	fUnitPz(rUnit.fUnitPz),
	140	fUnitMass(rUnit.fUnitMass),
	141	fVc(rUnit.fVc),
	142	fVn(rUnit.fVn),
	143	fUnitTrackRef(rUnit.fUnitTrackRef),
	144	fUnitCellRef(rUnit.fUnitCellRef),
	145	fUnitClusterRef(rUnit.fUnitClusterRef)
	146	{
	147	// Copy constructor
	148	}
	149
	150	AliJetUnitArray& AliJetUnitArray::operator=(const AliJetUnitArray& rhs)
	151	{
	152	// Assignment
53cf790b	153	if (this != &rhs) {
	154	fUnitEnergy = rhs.fUnitEnergy;
	155	fUnitEta = rhs.fUnitEta;
	156	fUnitPhi = rhs.fUnitPhi;
	157	fUnitDeta = rhs.fUnitDeta;
	158	fUnitDphi = rhs.fUnitDphi;
	159	fUnitID = rhs.fUnitID;
	160	fUnitTrackID = rhs.fUnitTrackID;
	161	fUnitNum = rhs.fUnitNum;
	162	fUnitClusterID = rhs.fUnitClusterID;
	163	fUnitFlag = rhs.fUnitFlag;
	164	fUnitCutFlag = rhs.fUnitCutFlag;
	165	fUnitCutFlag2 = rhs.fUnitCutFlag2;
	166	fUnitSignalFlag = rhs.fUnitSignalFlag;
	167	fUnitDetectorFlag = rhs.fUnitDetectorFlag;
	168	fUnitPx = rhs.fUnitPx;
	169	fUnitPy = rhs.fUnitPy;
	170	fUnitPz = rhs.fUnitPz;
	171	fUnitMass = rhs.fUnitMass;
	172	fVc = rhs.fVc;
	173	fVn = rhs.fVn;
	174	fUnitTrackRef = rhs.fUnitTrackRef;
	175	fUnitCellRef = rhs.fUnitCellRef;
	176	fUnitClusterRef = rhs.fUnitClusterRef;
	177	}
be6e5811	178	return *this;
	179
	180	}
	181
	182
8838ab7a	183	//------------------------------------------------------------------------
4a01bb2c	184	AliJetUnitArray::~AliJetUnitArray()
	185	{
	186	// Destructor
be6e5811	187	delete fUnitTrackRef;
	188	delete fUnitCellRef;
	189	delete fUnitClusterRef;
	190
	191	}
	192
	193	void AliJetUnitArray::ClearUnitTrackRef()
	194	{
	195	fUnitTrackRef->Clear();
	196	}
	197
	198	void AliJetUnitArray::ClearUnitCellRef()
	199	{
	200	fUnitCellRef->Clear();
4a01bb2c	201	}
8838ab7a	202
	203	//------------------------------------------------------------------------
	204	void AliJetUnitArray::SetUnitSignalFlagC(Bool_t init, AliJetFinderUnitSignalFlagType_t flag)
	205	{
	206	// Set signal flag of the charged particle
	207	if(init){
	208	if(!fVc.empty())
	209	fVc.clear();
	210	}
	211	else fVc.push_back(flag);
	212	}
	213
	214	//------------------------------------------------------------------------
	215	void AliJetUnitArray::SetUnitSignalFlagN(Bool_t init, AliJetFinderUnitSignalFlagType_t flag)
	216	{
	217	// Set signal flag of the neutral cell
	218	if(init){
	219	if(!fVn.empty())
	220	fVn.clear();
	221	}
	222	else fVn.push_back(flag);
	223	}
	224
8838ab7a	225
	226	//------------------------------------------------------------------------
	227	Bool_t AliJetUnitArray::GetUnitSignalFlagC(Int_t ind, AliJetFinderUnitSignalFlagType_t &flagc)
	228	{
	229	// Get signal flag of the charged particle
	230	if(ind <= (Int_t)fVc.size())
	231	{
	232	flagc = (AliJetFinderUnitSignalFlagType_t)fVc[ind];
	233	return kTRUE;
	234	}
	235	else return kFALSE;
	236	}
	237
	238	//------------------------------------------------------------------------
	239	Bool_t AliJetUnitArray::GetUnitSignalFlagN(Int_t ind, AliJetFinderUnitSignalFlagType_t &flagn)
	240	{
	241	// Get signal flag of the neutral cell
	242	if(ind <= (Int_t)fVn.size())
	243	{
	244	flagn = (AliJetFinderUnitSignalFlagType_t)fVn[ind];
	245	return kTRUE;
	246	}
	247	else return kFALSE;
8838ab7a	248	}
	249
	250	//------------------------------------------------------------------------
	251	Float_t AliJetUnitArray::EtaToTheta(Float_t arg) const
	252	{
	253	// Eta to theta transformation
	254	return 2.*atan(exp(-arg));
	255	}
	256
	257	//------------------------------------------------------------------------
1240edf5	258	Bool_t AliJetUnitArray::operator>(const AliJetUnitArray* unit) const
4a01bb2c	259	{
4a01bb2c	260	// Greater than operator used by sort
1dfd2819	261	if( fUnitEnergy > unit->GetUnitEnergy())
4a01bb2c	262	return kTRUE;
	263	else
	264	return kFALSE;
	265	}
	266
8838ab7a	267	//------------------------------------------------------------------------
1240edf5	268	Bool_t AliJetUnitArray::operator<(const AliJetUnitArray* unit) const
4a01bb2c	269	{
4a01bb2c	270	// Less than operator used by sort
1dfd2819	271	if( fUnitEnergy < unit->GetUnitEnergy())
4a01bb2c	272	return kTRUE;
	273	else
	274	return kFALSE;
	275	}
	276
8838ab7a	277	//------------------------------------------------------------------------
1240edf5	278	Bool_t AliJetUnitArray::operator==(const AliJetUnitArray* unit) const
4a01bb2c	279	{
4a01bb2c	280	// equality operator used by sort
1dfd2819	281	if( fUnitEnergy == unit->GetUnitEnergy())
4a01bb2c	282	return kTRUE;
	283	else
	284	return kFALSE;
	285	}