// Float_t pos[3]={7,9,4};
// v1.SetPosition(pos,"car");
//
-// Note : All quantities are in GeV, GeV/c or GeV/c**2
+// Note : By default all quantities are in meter, GeV, GeV/c or GeV/c**2
+// but the user can indicate the usage of a different scale for
+// the metric and/or energy-momentum units via the SetUnitScale()
+// and SetEscale() memberfunctions, respectively.
+// The actual metric and energy-momentum unit scales in use can be
+// obtained via the GetUnitScale() and GetEscale() memberfunctions.
//
//--- Author: Nick van Eijndhoven 04-apr-1998 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
///////////////////////////////////////////////////////////////////////////
+#include <cstdlib>
#include "AliVertex.h"
#include "Riostream.h"
AliJet::SetOwner(own);
}
///////////////////////////////////////////////////////////////////////////
-AliVertex::AliVertex(AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
+AliVertex::AliVertex(const AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
{
// Copy constructor
Init();
AliTrack* tx=0;
Int_t jetflag=0,connect=0;
AliTrack* tx2=0;
- for (Int_t it=1; it<=v.GetNtracks(); it++)
+ for (Int_t it=1; it<=v.fNtrk; it++)
{
tx=v.GetTrack(it);
if (tx)
// be stored according to the mode specified by SetJetCopy().
// The latter will enable jet studies based on a fixed list of tracks
// as contained e.g. in an AliVertex or AliEvent.
+//
+// In case a private copy is made, this is performed via the Clone() memberfunction.
+// All AliJet and derived classes have the default TObject::Clone() memberfunction.
+// However, derived classes generally contain an internal data structure which may
+// include pointers to other objects. Therefore it is recommended to provide
+// for all derived classes a specific copy constructor and override the default Clone()
+// memberfunction using this copy constructor.
+// An example for this may be seen from AliJet.
+
if (!fJets)
{
fJets=new TObjArray(fNjmax);
// Add the jet to the list
AliJet* jx=&j;
- if (fJetCopy) jx=new AliJet(j);
+ if (fJetCopy) jx=(AliJet*)j.Clone();
if (jx)
{
// has to introduce the connecting track lateron by hand
// explicitly in order to match the kinematics and charge.
//
+// In case a private copy is made, this is performed via the Clone() memberfunction.
+// All AliVertex and derived classes have the default TObject::Clone() memberfunction.
+// However, derived classes generally contain an internal data structure which may
+// include pointers to other objects. Therefore it is recommended to provide
+// for all derived classes a specific copy constructor and override the default Clone()
+// memberfunction using this copy constructor.
+// An example for this may be seen from AliVertex.
+
if (!fVertices)
{
fVertices=new TObjArray(fNvmax);
// Add the linked (secondary) vertex to the list
AliVertex* vx=&v;
- if (fVertexCopy) vx=new AliVertex(v);
+ if (fVertexCopy) vx=(AliVertex*)v.Clone();
if (vx)
{
}
}
///////////////////////////////////////////////////////////////////////////
-void AliVertex::Data(TString f)
+void AliVertex::Data(TString f,TString u)
{
// Provide vertex information within the coordinate frame f
- cout << " *AliVertex::Data* Name : " << GetName() << " Title : " << GetTitle() << endl;
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The defaults are f="car" and u="rad".
+
+ const char* name=GetName();
+ const char* title=GetTitle();
+ cout << " *AliVertex::Data*";
+ if (strlen(name)) cout << " Name : " << GetName();
+ if (strlen(title)) cout << " Title : " << GetTitle();
+ cout << endl;
cout << " Id : " << fUserId << " Invmass : " << GetInvmass()
<< " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
- << " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx
- << " Njets : " << fNjets << endl;
+ << " Ntracks : " << GetNtracks() << endl;
+ cout << " Nvertices : " << fNvtx << " Njets : " << fNjets
+ << " Energy scale : " << fEscale << " GeV" << endl;
cout << " ";
- Ali4Vector::Data(f);
+ Ali4Vector::Data(f,u);
cout << " Position";
- AliPosition::Data(f);
+ AliPosition::Data(f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliVertex::List(TString f)
+void AliVertex::List(TString f,TString u)
{
// Provide primary track and sec. vertex information within the coordinate frame f
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The defaults are f="car" and u="rad".
- Data(f); // Information of the current vertex
+ Data(f,u); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->Data(f);
+ t->Data(f,u);
}
else
{
{
cout << " ---Level 1 sec. vertex no. " << iv << endl;
cout << " ";
- v->Data(f);
+ v->Data(f,u);
}
else
{
}
}
///////////////////////////////////////////////////////////////////////////
-void AliVertex::ListAll(TString f)
+void AliVertex::ListAll(TString f,TString u)
{
// Provide complete (sec) vertex and (decay) track info within the coordinate frame f
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The defaults are f="car" and u="rad".
- Data(f); // Information of the current vertex
+ Data(f,u); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->ListAll(f);
+ t->ListAll(f,u);
}
else
{
}
AliVertex* v=this;
- Dumps(v,1,f); // Information of all sec. vertices
+ Dumps(v,1,f,u); // Information of all sec. vertices
}
//////////////////////////////////////////////////////////////////////////
-void AliVertex::Dumps(AliVertex* v,Int_t n,TString f)
+void AliVertex::Dumps(AliVertex* v,Int_t n,TString f,TString u)
{
// Recursively provide the info of all secondary vertices of this vertex
AliVertex* vs;
{
cout << " ---Level " << n << " sec. vertex no. " << iv << endl;
cout << " ";
- vs->Data(f);
+ vs->Data(f,u);
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->ListAll(f);
+ t->ListAll(f,u);
}
else
{
}
// Go for next sec. vertex level of this sec. vertex recursively
- Dumps(vs,n+1,f);
+ Dumps(vs,n+1,f,u);
}
else
{
}
}
//////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::GetNvertices()
+Int_t AliVertex::GetNvertices() const
{
// Return the current number of (secondary) vertices
return fNvtx;
}
///////////////////////////////////////////////////////////////////////////
-AliVertex* AliVertex::GetVertex(Int_t i)
+AliVertex* AliVertex::GetVertex(Int_t i) const
{
// Return the i-th (secondary) vertex of the current vertex
if (!fVertices)
}
}
///////////////////////////////////////////////////////////////////////////
-AliVertex* AliVertex::GetIdVertex(Int_t id)
+AliVertex* AliVertex::GetIdVertex(Int_t id) const
{
// Return the (sec.) vertex with user identifier "id"
AliVertex* vx=0;
}
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::GetVertexCopy()
+Int_t AliVertex::GetVertexCopy() const
{
// Provide value of the VertexCopy mode.
// 0 ==> No private copies are made; pointers of original vertices are stored.
return fVertexCopy;
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::GetNjets()
+Int_t AliVertex::GetNjets() const
{
// Return the current number of jets
return fNjets;
}
///////////////////////////////////////////////////////////////////////////
-AliJet* AliVertex::GetJet(Int_t i)
+AliJet* AliVertex::GetJet(Int_t i) const
{
// Return the i-th jet of the current vertex
if (!fJets)
}
}
///////////////////////////////////////////////////////////////////////////
-AliJet* AliVertex::GetIdJet(Int_t id)
+AliJet* AliVertex::GetIdJet(Int_t id) const
{
// Return the jet with user identifier "id"
AliJet* jx=0;
}
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::GetJetCopy()
+Int_t AliVertex::GetJetCopy() const
{
// Provide value of the JetCopy mode.
// 0 ==> No private copies are made; pointers of original jets are stored.
return fJetCopy;
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::IsConnectTrack(AliTrack* t)
+Int_t AliVertex::IsConnectTrack(AliTrack* t) const
{
// Indicate whether a track from the tracklist was created via the
// connection of a (secondary) vertex or not.
return connect;
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliVertex::IsJetTrack(AliTrack* t)
+Int_t AliVertex::IsJetTrack(AliTrack* t) const
{
// Indicate whether a track from the tracklist was created via the
// addition of a jet or not.
}
}
///////////////////////////////////////////////////////////////////////////
+TObjArray* AliVertex::SortJets(Int_t mode,TObjArray* jets)
+{
+// Order the references to an array of jets by looping over the input array "jets"
+// and checking the value of a certain observable.
+// The ordered array is returned as a TObjArray.
+// In case jets=0 (default), the registered jets of the current vertex are used.
+// Note that the original jet array is not modified.
+// Via the "mode" argument the user can specify the observable to be checked upon
+// and specify whether sorting should be performed in decreasing order (mode<0)
+// or in increasing order (mode>0).
+//
+// The convention for the observable selection is the following :
+// mode : 1 ==> Number of tracks in the jet
+// 2 ==> Jet energy
+// 3 ==> Jet momentum
+// 4 ==> Invariant mass of the jet
+// 5 ==> Transverse momentum of the jet
+// 6 ==> Longitudinal momentum of the jet
+// 7 ==> Transverse energy of the jet
+// 8 ==> Longitudinal energy of the jet
+// 9 ==> Transverse mass of the jet
+// 10 ==> Jet rapidity
+// 11 ==> Pseudo-rapidity of the jet
+// 12 ==> Number of associated signals
+// 13 ==> Total charge of the jet
+//
+// The default is mode=-1.
+//
+// Note : This sorting routine uses a common area in memory, which is used
+// by various other sorting facilities as well.
+// This means that the resulting sorted TObjArray may be overwritten
+// when another sorting is invoked.
+// To retain the sorted list of pointers, the user is advised to copy
+// the pointers contained in the returned TObjArray into a private
+// TObjArray instance.
+
+ if (fSelected)
+ {
+ delete fSelected;
+ fSelected=0;
+ }
+
+ if (!jets) jets=fJets;
+
+ if (!mode || abs(mode)>13 || !jets) return fSelected;
+
+ Int_t njets=jets->GetEntries();
+ if (!njets)
+ {
+ return fSelected;
+ }
+ else
+ {
+ fSelected=new TObjArray(njets);
+ }
+
+ Double_t val1,val2; // Values of the observable to be tested upon
+
+ Int_t nord=0;
+ for (Int_t i=0; i<njets; i++) // Loop over all jets of the array
+ {
+ AliJet* jx=(AliJet*)jets->At(i);
+
+ if (!jx) continue;
+
+ if (nord == 0) // store the first jet at the first ordered position
+ {
+ nord++;
+ fSelected->AddAt(jx,nord-1);
+ continue;
+ }
+
+ for (Int_t j=0; j<=nord; j++) // put jet in the right ordered position
+ {
+ if (j == nord) // jet has smallest (mode<0) or largest (mode>0) observable value seen so far
+ {
+ nord++;
+ fSelected->AddAt(jx,j); // add jet at the end
+ break; // go for next jet
+ }
+
+ val1=0;
+ val2=0;
+
+ switch (abs(mode))
+ {
+ case 1:
+ val1=jx->GetNtracks();
+ val2=((AliJet*)fSelected->At(j))->GetNtracks();
+ break;
+ case 2:
+ val1=jx->GetEnergy(1);
+ val2=((AliJet*)fSelected->At(j))->GetEnergy(1);
+ break;
+ case 3:
+ val1=jx->GetMomentum(1);
+ val2=((AliJet*)fSelected->At(j))->GetMomentum(1);
+ break;
+ case 4:
+ val1=jx->GetInvmass(1);
+ val2=((AliJet*)fSelected->At(j))->GetInvmass(1);
+ break;
+ case 5:
+ val1=jx->GetPt(1);
+ val2=((AliJet*)fSelected->At(j))->GetPt(1);
+ break;
+ case 6:
+ val1=jx->GetPl(1);
+ val2=((AliJet*)fSelected->At(j))->GetPl(1);
+ break;
+ case 7:
+ val1=jx->GetEt(1);
+ val2=((AliJet*)fSelected->At(j))->GetEt(1);
+ break;
+ case 8:
+ val1=jx->GetEl(1);
+ val2=((AliJet*)fSelected->At(j))->GetEl(1);
+ break;
+ case 9:
+ val1=jx->GetMt(1);
+ val2=((AliJet*)fSelected->At(j))->GetMt(1);
+ break;
+ case 10:
+ val1=jx->GetRapidity();
+ val2=((AliJet*)fSelected->At(j))->GetRapidity();
+ break;
+ case 11:
+ val1=jx->GetPseudoRapidity();
+ val2=((AliJet*)fSelected->At(j))->GetPseudoRapidity();
+ break;
+ case 12:
+ val1=jx->GetNsignals();
+ val2=((AliJet*)fSelected->At(j))->GetNsignals();
+ break;
+ case 13:
+ val1=jx->GetCharge();
+ val2=((AliJet*)fSelected->At(j))->GetCharge();
+ break;
+ }
+
+ if (mode<0 && val1 <= val2) continue;
+ if (mode>0 && val1 >= val2) continue;
+
+ nord++;
+ for (Int_t k=nord-1; k>j; k--) // create empty position
+ {
+ fSelected->AddAt(fSelected->At(k-1),k);
+ }
+ fSelected->AddAt(jx,j); // put jet at empty position
+ break; // go for next jet
+ }
+ }
+ return fSelected;
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliVertex::Clone(const char* name) const
+{
+// Make a deep copy of the current object and provide the pointer to the copy.
+// This memberfunction enables automatic creation of new objects of the
+// correct type depending on the object type, a feature which may be very useful
+// for containers when adding objects in case the container owns the objects.
+// This feature allows e.g. AliEvent to store either AliVertex objects or
+// objects derived from AliVertex via the AddVertex memberfunction, provided
+// these derived classes also have a proper Clone memberfunction.
+
+ AliVertex* vtx=new AliVertex(*this);
+ if (name)
+ {
+ if (strlen(name)) vtx->SetName(name);
+ }
+ return vtx;
+}
+///////////////////////////////////////////////////////////////////////////
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff