// 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 sec. vertices is set to the default value.
Init();
Reset();
- SetNtinit();
SetNvmax();
SetNjmax();
}
void AliVertex::Init()
{
// Initialisation of pointers etc...
- AliJet::Init();
fNvmax=0;
fVertices=0;
fConnects=0;
fLines=0;
}
///////////////////////////////////////////////////////////////////////////
-AliVertex::AliVertex(Int_t n)
+AliVertex::AliVertex(Int_t n) : AliJet(n),AliPosition()
{
// Create a vertex to hold initially a maximum of n tracks
// All variables initialised to 0
- Init();
- Reset();
- if (n > 0)
- {
- SetNtinit(n);
- }
- else
+ 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();
}
}
}
///////////////////////////////////////////////////////////////////////////
-AliVertex::AliVertex(AliVertex& v)
+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();
- Reset();
- SetNtinit();
- SetNvmax();
- SetNjmax();
+ fNvtx=0;
+ fNjets=0;
+ SetNvmax(v.fNvmax);
+ SetNjmax(v.fNjmax);
SetTrackCopy(v.GetTrackCopy());
SetVertexCopy(v.GetVertexCopy());
SetJetCopy(v.GetJetCopy());
SetId(v.GetId());
- SetPosition(v.GetPosition());
// Copy all tracks except the ones coming from jets
AliTrack* tx=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.
+//
+// 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::Info(TString f)
+void AliVertex::Data(TString f)
{
// Provide vertex information within the coordinate frame f
- cout << " *AliVertex::Info* Id : " << fUserId << " 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)
+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.
// negative track : blue
// jet-track : magenta (if explicit marking selected)
//
-// secs = 1 --> Draw secondary vertices.
+// secs = 1 --> Draw secondary vertices. (Default)
// 0 --> Don't draw secondary vertices.
//
-// cons = 1 --> Draw (auto generated) connecting tracks.
+// 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.
+// 0 --> Don't mark jet-tracks. (Default)
//
// Notes :
// -------
Double_t vec[3]={0,0,0};
AliTrack* tx=0;
AliVertex* vx=0;
- AliPosition r;
+ AliPosition* r=0;
Ali3Vector p;
- Int_t charge;
+ Float_t charge;
+
+ AliPosition dummy;
if (fLines) delete fLines;
fLines=new TObjArray();
if (cons==1)
{
r=tx->GetBeginPoint();
- r.GetPosition(vec,"car");
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
line->SetNextPoint(vec[0],vec[1],vec[2]);
r=tx->GetEndPoint();
- r.GetPosition(vec,"car");
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
line->SetNextPoint(vec[0],vec[1],vec[2]);
line->SetLineWidth(1);
}
else
{
r=tx->GetClosestPoint();
- r.GetPosition(vec,"car");
+ if (!r) r=&dummy;
+ r->GetPosition(vec,"car");
line->SetNextPoint(vec[0],vec[1],vec[2]);
p=tx->Get3Momentum();
- p=p+r;
+ p=p+(*r);
p.GetVector(vec,"car");
line->SetNextPoint(vec[0],vec[1],vec[2]);
line->SetLineWidth(3);
}
- if (charge>0) line->SetLineColor(kRed); // Positive track
- if (!charge) line->SetLineColor(kGreen); // Neutral track
- if (charge<0) line->SetLineColor(kBlue); // Negative track
+ 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))
}
}
///////////////////////////////////////////////////////////////////////////
+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