// creating only one AliVertex instance in the main programme and using the
// AliVertex::Reset, AliVertex::AddTrack and parameter setting memberfunctions.
//
+// See also the documentation provided for the memberfunction SetOwner().
+//
// Coding example to make 3 vertices v1, v2 and v3.
// ------------------------------------------------
// v1 contains the tracks 1,2,3 and 4
// Float_t r3[3]={6.2,4.8,1.3};
// v3.SetPosition(r3,"car");
//
-// v1.Info("sph");
+// v1.Data("sph");
// v2.ListAll();
// v3.List("cyl");
//
// Float_t loc[3];
// v1.GetPosition(loc,"sph");
// AliPosition r=v2.GetPosition();
-// r.Info();
+// r.Data();
// Int_t nt=v2.GetNtracks();
// AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
//
///////////////////////////////////////////////////////////////////////////
#include "AliVertex.h"
+#include "Riostream.h"
ClassImp(AliVertex) // Class implementation to enable ROOT I/O
-AliVertex::AliVertex()
+AliVertex::AliVertex() : AliJet(),AliPosition()
{
// Default constructor.
// All variables initialised to 0.
// Initial maximum number of tracks is set to the default value.
// Initial maximum number of sec. vertices is set to the default value.
- fNvmax=0;
- fVertices=0;
- fConnects=0;
- fVertexCopy=0;
- fNjmax=0;
- fJets=0;
- fJetCopy=0;
+ Init();
Reset();
- SetNtinit();
SetNvmax();
SetNjmax();
}
///////////////////////////////////////////////////////////////////////////
-AliVertex::AliVertex(Int_t n)
+void AliVertex::Init()
{
-// Create a vertex to hold initially a maximum of n tracks
-// All variables initialised to 0
+// Initialisation of pointers etc...
fNvmax=0;
fVertices=0;
fConnects=0;
fVertexCopy=0;
fNjmax=0;
fJets=0;
+ fJetTracks=0;
fJetCopy=0;
- Reset();
- if (n > 0)
- {
- SetNtinit(n);
- }
- else
+ fLines=0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliVertex::AliVertex(Int_t n) : AliJet(n),AliPosition()
+{
+// Create a vertex to hold initially a maximum of n tracks
+// All variables initialised to 0
+ if (n<=0)
{
- cout << endl;
- cout << " *AliVertex* Initial max. number of tracks entered : " << n << endl;
- cout << " This is invalid. Default initial maximum will be used." << endl;
- cout << endl;
- SetNtinit();
+ cout << " *** This AliJet initialisation was invoked via the AliVertex ctor." << endl;
}
+ Init();
+ Reset();
SetNvmax();
SetNjmax();
}
// Default destructor
if (fVertices)
{
- if (fVertexCopy) fVertices->Delete();
delete fVertices;
fVertices=0;
}
if (fConnects)
{
- fConnects->Delete();
delete fConnects;
fConnects=0;
}
if (fJets)
{
- if (fJetCopy) fJets->Delete();
delete fJets;
fJets=0;
}
+ if (fJetTracks)
+ {
+ delete fJetTracks;
+ fJetTracks=0;
+ }
+ if (fLines)
+ {
+ delete fLines;
+ fLines=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliVertex::SetOwner(Bool_t own)
+{
+// Set ownership of all added objects.
+// The default parameter is own=kTRUE.
+//
+// Invokation of this memberfunction also sets all the copy modes
+// (e.g. TrackCopy & co.) according to the value of own.
+//
+// This function (with own=kTRUE) is particularly useful when reading data
+// from a tree/file, since Reset() will then actually remove all the
+// added objects from memory irrespective of the copy mode settings
+// during the tree/file creation process. In this way it provides a nice way
+// of preventing possible memory leaks in the reading/analysis process.
+//
+// In addition this memberfunction can also be used as a shortcut to set all
+// copy modes in one go during a tree/file creation process.
+// However, in this case the user has to take care to only set/change the
+// ownership (and copy mode) for empty objects (e.g. newly created objects
+// or after invokation of the Reset() memberfunction) otherwise it will
+// very likely result in inconsistent destructor behaviour.
+
+ Int_t mode=1;
+ if (!own) mode=0;
+ if (fVertices) fVertices->SetOwner(own);
+ fVertexCopy=mode;
+ if (fJets) fJets->SetOwner(own);
+ fJetCopy=mode;
+
+ AliJet::SetOwner(own);
+}
+///////////////////////////////////////////////////////////////////////////
+AliVertex::AliVertex(const AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
+{
+// Copy constructor
+ Init();
+ fNvtx=0;
+ fNjets=0;
+ SetNvmax(v.fNvmax);
+ SetNjmax(v.fNjmax);
+ SetTrackCopy(v.GetTrackCopy());
+ SetVertexCopy(v.GetVertexCopy());
+ SetJetCopy(v.GetJetCopy());
+ SetId(v.GetId());
+
+ // Copy all tracks except the ones coming from jets
+ AliTrack* tx=0;
+ Int_t jetflag=0,connect=0;
+ AliTrack* tx2=0;
+ for (Int_t it=1; it<=v.fNtrk; it++)
+ {
+ tx=v.GetTrack(it);
+ if (tx)
+ {
+ jetflag=v.IsJetTrack(tx);
+ connect=v.IsConnectTrack(tx);
+
+ if (!jetflag && !connect) AddTrack(tx);
+
+ if (connect)
+ {
+ if (!fConnects)
+ {
+ fConnects=new TObjArray(fNvmax);
+ if (!fTrackCopy) fConnects->SetOwner();
+ }
+ tx2=new AliTrack(*tx);
+ fConnects->Add(tx2);
+ AddTrack(tx2,0);
+ }
+ }
+ }
+
+ // Copy all the (secondary) vertices without re-creating connecting tracks
+ // The connecting tracks have already been copied above
+ AliVertex* vx=0;
+ for (Int_t iv=1; iv<=v.GetNvertices(); iv++)
+ {
+ vx=v.GetVertex(iv);
+ if (vx) AddVertex(vx,0);
+ }
+
+ // Copy all the jets including the jet tracks for these jets for which
+ // this was also the case in the original vertex
+ AliJet* jx=0;
+ for (Int_t ij=1; ij<=v.GetNjets(); ij++)
+ {
+ jx=v.GetJet(ij);
+ if (jx)
+ {
+ jetflag=0;
+ if (jx->GetNtracks())
+ {
+ tx=jx->GetTrack(1);
+ if (tx)
+ {
+ jetflag=v.IsJetTrack(tx);
+ }
+ }
+ AddJet(jx,jetflag);
+ }
+ }
}
///////////////////////////////////////////////////////////////////////////
void AliVertex::SetNvmax(Int_t n)
}
if (fVertices)
{
- if (fVertexCopy) fVertices->Delete();
delete fVertices;
fVertices=0;
}
}
if (fJets)
{
- if (fJetCopy) fJets->Delete();
delete fJets;
fJets=0;
}
if (fNvmax>0) SetNvmax(fNvmax);
if (fConnects)
{
- fConnects->Delete();
delete fConnects;
fConnects=0;
}
fNjets=0;
if (fNjmax>0) SetNjmax(fNjmax);
+ if (fJetTracks)
+ {
+ delete fJetTracks;
+ fJetTracks=0;
+ }
+
+ if (fLines)
+ {
+ delete fLines;
+ fLines=0;
+ }
}
///////////////////////////////////////////////////////////////////////////
void AliVertex::ResetVertices()
fNtrk--;
(Ali4Vector&)(*this)-=(Ali4Vector&)(*t);
fQ-=t->GetCharge();
+ if (fTrackCopy) delete t;
}
}
fTracks->Compress();
if (fNvmax>0) SetNvmax(fNvmax);
if (fConnects)
{
- fConnects->Delete();
delete fConnects;
fConnects=0;
}
// 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.
- if (!fJets) fJets=new TObjArray(fNjmax);
+//
+// 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);
+ if (fJetCopy) fJets->SetOwner();
+ }
if (fNjets == fNjmax) // Check if maximum jet number is reached
{
fNjmax++;
}
// Add the jet to the list
- fNjets++;
- if (fJetCopy)
- {
- fJets->Add(j.Clone());
- }
- else
+ AliJet* jx=&j;
+ if (fJetCopy) jx=(AliJet*)j.Clone();
+
+ if (jx)
{
- fJets->Add(&j);
+ fNjets++;
+ fJets->Add(jx);
}
// Add the tracks of the jet to this vertex
if (tracks)
{
+ if (!fJetTracks)
+ {
+ fJetTracks=new TObjArray();
+ }
+ Int_t copy=1-(jx->GetTrackCopy());
AliTrack* tj;
- for (Int_t i=1; i<=j.GetNtracks(); i++)
+ for (Int_t i=1; i<=jx->GetNtracks(); i++)
{
- tj=j.GetTrack(i);
- AddTrack(tj);
+ tj=jx->GetTrack(i);
+ if (tj)
+ {
+ AddTrack(tj,copy);
+ fJetTracks->Add(tj);
+ }
}
}
}
// has to introduce the connecting track lateron by hand
// explicitly in order to match the kinematics and charge.
//
- if (!fVertices) fVertices=new TObjArray(fNvmax);
+// 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);
+ if (fVertexCopy) fVertices->SetOwner();
+ }
if (fNvtx == fNvmax) // Check if maximum vertex number is reached
{
fNvmax++;
}
// Add the linked (secondary) vertex to the list
- fNvtx++;
- if (fVertexCopy)
- {
- fVertices->Add(v.Clone());
- }
- else
+ AliVertex* vx=&v;
+ if (fVertexCopy) vx=(AliVertex*)v.Clone();
+
+ if (vx)
{
- fVertices->Add(&v);
- }
+ fNvtx++;
+ fVertices->Add(vx);
+ }
// Create connecting track and update 4-momentum and charge for current vertex
if (connect)
{
- AliPosition r1=GetPosition();
- AliPosition r2=v.GetPosition();
- Float_t q=v.GetCharge();
- Ali3Vector p=v.Get3Momentum();
- Double_t v2=v.GetInvariant();
- Double_t dv2=v.Ali4Vector::GetResultError();
-
- AliTrack* t=new AliTrack;
- t->SetBeginPoint(r1);
- t->SetEndPoint(r2);
- t->SetCharge(q);
- t->Set3Momentum(p);
- t->SetInvariant(v2,dv2);
+ AliTrack* t=new AliTrack();
+ t->SetBeginPoint(GetPosition());
+ t->SetEndPoint(v.GetPosition());
+ t->SetCharge(v.GetCharge());
+ t->Set4Momentum((Ali4Vector&)v);
- AddTrack(t);
+ AddTrack(t,0);
- if (!fConnects) fConnects=new TObjArray(fNvmax);
+ if (!fConnects)
+ {
+ fConnects=new TObjArray(fNvmax);
+ if (!fTrackCopy) fConnects->SetOwner();
+ }
fConnects->Add(t);
}
}
///////////////////////////////////////////////////////////////////////////
-void AliVertex::Info(TString f)
+void AliVertex::Data(TString f)
{
// Provide vertex information within the coordinate frame f
- cout << " *AliVertex::Info* Invmass : " << GetInvmass()
+ 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;
cout << " ";
- Ali4Vector::Info(f);
+ Ali4Vector::Data(f);
cout << " Position";
- AliPosition::Info(f);
+ AliPosition::Data(f);
}
///////////////////////////////////////////////////////////////////////////
void AliVertex::List(TString f)
{
// Provide primary track and sec. vertex information within the coordinate frame f
- Info(f); // Information of the current vertex
+ Data(f); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->Info(f);
+ t->Data(f);
}
else
{
{
cout << " ---Level 1 sec. vertex no. " << iv << endl;
cout << " ";
- v->Info(f);
+ v->Data(f);
}
else
{
{
// Provide complete (sec) vertex and (decay) track info within the coordinate frame f
- Info(f); // Information of the current vertex
+ Data(f); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
}
AliVertex* v=this;
- Dump(v,1,f); // Information of all sec. vertices
+ Dumps(v,1,f); // Information of all sec. vertices
}
//////////////////////////////////////////////////////////////////////////
-void AliVertex::Dump(AliVertex* v,Int_t n,TString f)
+void AliVertex::Dumps(AliVertex* v,Int_t n,TString f)
{
// Recursively provide the info of all secondary vertices of this vertex
AliVertex* vs;
{
cout << " ---Level " << n << " sec. vertex no. " << iv << endl;
cout << " ";
- vs->Info(f);
+ vs->Data(f);
// The tracks of this vertex
AliTrack* t;
}
else
{
- cout << " *AliVertex::Dump* Error : No track present." << endl;
+ cout << " *AliVertex::Dumps* Error : No track present." << endl;
}
}
// Go for next sec. vertex level of this sec. vertex recursively
- Dump(vs,n+1,f);
+ Dumps(vs,n+1,f);
}
else
{
- cout << " *AliVertex::Dump* Error : No sec. vertex present." << endl;
+ cout << " *AliVertex::Dumps* Error : No sec. vertex present." << endl;
}
}
}
//////////////////////////////////////////////////////////////////////////
-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) const
+{
+// Return the (sec.) vertex with user identifier "id"
+ AliVertex* vx=0;
+ AliVertex* v=0;
+ if (!fVertices)
+ {
+ cout << " *AliVertex*::GetIdVertex* No (secondary) vertices present." << endl;
+ return 0;
+ }
+ else
+ {
+ for (Int_t i=0; i<fNvtx; i++)
+ {
+ vx=(AliVertex*)fVertices->At(i);
+ if (id == vx->GetId()) v=vx;
+ }
+ return v;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
void AliVertex::SetVertexCopy(Int_t j)
{
// (De)activate the creation of private copies of the added vertices.
}
}
///////////////////////////////////////////////////////////////////////////
-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) const
+{
+// Return the jet with user identifier "id"
+ AliJet* jx=0;
+ AliJet* j=0;
+ if (!fJets)
+ {
+ cout << " *AliVertex*::GetIdJet* No jets present." << endl;
+ return 0;
+ }
+ else
+ {
+ for (Int_t i=0; i<fNjets; i++)
+ {
+ jx=(AliJet*)fJets->At(i);
+ if (id == jx->GetId()) j=jx;
+ }
+ return j;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
void AliVertex::SetJetCopy(Int_t j)
{
// (De)activate the creation of private copies of the added jets.
}
}
///////////////////////////////////////////////////////////////////////////
-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) const
+{
+// Indicate whether a track from the tracklist was created via the
+// connection of a (secondary) vertex or not.
+// In case the track was the result of (secondary) vertex addition the
+// return value is 1, otherwise the value 0 will be returned.
+ Int_t connect=0;
+ if (fConnects)
+ {
+ if (fConnects->FindObject(t)) connect=1;
+ }
+ return connect;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliVertex::IsJetTrack(AliTrack* t) const
+{
+// Indicate whether a track from the tracklist was created via the
+// addition of a jet or not.
+// In case the track was the result of jet addition the return value is 1,
+// otherwise the value 0 will be returned.
+ Int_t jetflag=0;
+ if (fJetTracks)
+ {
+ if (fJetTracks->FindObject(t)) jetflag=1;
+ }
+ return jetflag;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliVertex::Draw(Int_t secs,Int_t cons,Int_t jets)
+{
+// 3-Dimensional visualisation of an AliVertex with its attributes.
+// The displayed tracklength is proportional to the momentum of the track.
+//
+// Color conventions :
+// -------------------
+// positive track : red
+// neutral track : green
+// negative track : blue
+// jet-track : magenta (if explicit marking selected)
+//
+// secs = 1 --> Draw secondary vertices. (Default)
+// 0 --> Don't draw secondary vertices.
+//
+// cons = 1 --> Draw (auto generated) connecting tracks. (Default)
+// 0 --> Don't draw (auto generated) connecting tracks.
+//
+// jets = 1 --> Mark tracks belonging to jets.
+// 0 --> Don't mark jet-tracks. (Default)
+//
+// Notes :
+// -------
+// Auto generated connecting tracks will be drawn as thin lines.
+// Tracks belonging to jets will be marked as somewhat thinner magenta lines.
+// This memberfunction is used recursively.
+//
+ Double_t vec[3]={0,0,0};
+ AliTrack* tx=0;
+ AliVertex* vx=0;
+ AliPosition* r=0;
+ Ali3Vector p;
+ Float_t charge;
+
+ AliPosition dummy;
+
+ if (fLines) delete fLines;
+ fLines=new TObjArray();
+ fLines->SetOwner();
+
+ Int_t ntk=GetNtracks();
+ for (Int_t jtk=1; jtk<=ntk; jtk++)
+ {
+ tx=GetTrack(jtk);
+
+ if (!tx) continue;
+
+ charge=tx->GetCharge();
+
+ TPolyLine3D* line=new TPolyLine3D();
+ fLines->Add(line);
+
+ if (IsConnectTrack(tx))
+ {
+ if (cons==1)
+ {
+ r=tx->GetBeginPoint();
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
+ line->SetNextPoint(vec[0],vec[1],vec[2]);
+ r=tx->GetEndPoint();
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
+ line->SetNextPoint(vec[0],vec[1],vec[2]);
+ line->SetLineWidth(1);
+ }
+ }
+ else
+ {
+ r=tx->GetClosestPoint();
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
+ line->SetNextPoint(vec[0],vec[1],vec[2]);
+ p=tx->Get3Momentum();
+ p=p+(*r);
+ p.GetVector(vec,"car");
+ line->SetNextPoint(vec[0],vec[1],vec[2]);
+ line->SetLineWidth(3);
+ }
+
+ line->SetLineColor(kGreen); // Neutral track
+ if (charge>0) line->SetLineColor(kRed); // Positive track
+ if (charge<0) line->SetLineColor(kBlue); // Negative track
+
+ // Mark tracks belonging to jets
+ if (IsJetTrack(tx))
+ {
+ if (jets==1)
+ {
+ line->SetLineWidth(2);
+ line->SetLineColor(kMagenta);
+ }
+ }
+
+ line->Draw();
+ }
+
+ // Go for secondary vertices if selected
+ if (secs==1)
+ {
+ Int_t nvtx=GetNvertices();
+ for (Int_t jvtx=1; jvtx<=nvtx; jvtx++)
+ {
+ vx=GetVertex(jvtx);
+ if (vx) vx->Draw(secs,cons,jets);
+ }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+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;
+}
+///////////////////////////////////////////////////////////////////////////