AliInvmass, AliJet, AliTrack and AliVertex to adapt to the new memory
management of ROOT 3.01 (and later) in case of reading trees.
06-dec-2001 NvE Memory usage optimised for AliVertex & co. and memory leak due to
cloning solved.
07-dec-2001 NvE ClassDef() and ClassImp() statements introduced for AliSample.
17-dec-2001 NvE Copy constructor and Init() memberfunction introduced for AliTrack & co.
14-jan-2002 NvE New schema evolution activated via the "+" behind the classnames
in RALICELinkDef.h. Note that the new schema evolution only works
correctly for ROOT version 3.02/07 and later.
// Destructor to delete dynamically allocated memory
if (fVetos)
{
- fVetos->Delete();
delete fVetos;
fVetos=0;
}
{
fNvetos=0;
fVetos=new TObjArray();
+ fVetos->SetOwner();
}
fVetos->Add(new AliSignal(1));
{
// Provide access to the i-th veto signal of this cluster.
// Note : The first hit corresponds to i=1.
-
- if (i>0 && i<=fNvetos)
+ if (!fVetos)
{
- return (AliSignal*)fVetos->At(i-1);
+ cout << " *AliCalcluster::GetVetoSignal* No veto signals present." << endl;
+ return 0;
}
else
{
- cout << " *AliCalcluster::GetVetoSignal* Signal number " << i
- << " out of range." << endl;
- cout << " --- First signal (if any) returned." << endl;
- return (AliSignal*)fVetos->At(0);
+ if (i>0 && i<=fNvetos)
+ {
+ return (AliSignal*)fVetos->At(i-1);
+ }
+ else
+ {
+ cout << " *AliCalcluster::GetVetoSignal* Signal number " << i << " out of range."
+ << " Nvetos = " << fNvetos << endl;
+ return 0;
+ }
}
}
///////////////////////////////////////////////////////////////////////////
}
fModules=new TObjArray(); // Default size, expanded automatically
+ fModules->SetOwner();
fHmodules=0;
fHclusters=0;
fClusters=0;
}
fClusters=new TObjArray();
+ fClusters->SetOwner();
fNclusters=0;
Int_t row=0;
Int_t col=0;
{
fNvetos=0;
fVetos=new TObjArray();
+ fVetos->SetOwner();
}
fVetos->Add(new AliSignal);
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// $Id: AliEvent.cxx,v 1.3 2001/07/04 15:59:20 nick Exp $
+// $Id: AliEvent.cxx,v 1.4 2001/07/06 09:30:59 nick Exp $
///////////////////////////////////////////////////////////////////////////
// Class AliEvent
// Note : All quantities are in GeV, GeV/c or GeV/c**2
//
//--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
-//- Modified: NvE $Date: 2001/07/04 15:59:20 $ UU-SAP Utrecht
+//- Modified: NvE $Date: 2001/07/06 09:30:59 $ UU-SAP Utrecht
///////////////////////////////////////////////////////////////////////////
#include "AliEvent.h"
// Default destructor
if (fCalorimeters)
{
- if (fCalCopy) fCalorimeters->Delete();
delete fCalorimeters;
fCalorimeters=0;
}
fNcals=0;
if (fCalorimeters)
{
- if (fCalCopy) fCalorimeters->Delete();
delete fCalorimeters;
fCalorimeters=0;
}
void AliEvent::AddCalorimeter(AliCalorimeter& c)
{
// Add a calorimeter system to the event
- if (!fCalorimeters) fCalorimeters=new TObjArray();
+ if (!fCalorimeters)
+ {
+ fCalorimeters=new TObjArray();
+ if (fCalCopy) fCalorimeters->SetOwner();
+ }
// Add the calorimeter system to this event
fNcals++;
if (fCalCopy)
{
- fCalorimeters->AddLast(c.Clone());
+ fCalorimeters->AddLast((AliCalorimeter*)c.Clone());
}
else
{
// Destructor to delete dynamically allocated memory
if (fMinv)
{
- fMinv->Delete();
delete fMinv;
fMinv=0;
}
if (fMbkg)
{
- fMbkg->Delete();
delete fMbkg;
fMbkg=0;
}
if ((!fBkg || fMode==1) && fMinv)
{
- fMinv->Delete();
delete fMinv;
fMinv=0;
}
if (fBkg && (fMode !=1) && fMbkg)
{
- fMbkg->Delete();
delete fMbkg;
fMbkg=0;
}
t->SetCharge(q1+q2);
if (!fBkg || fMode==1)
{
- if (!fMinv) fMinv=new TObjArray();
+ if (!fMinv)
+ {
+ fMinv=new TObjArray();
+ fMinv->SetOwner();
+ }
fMinv->Add(t);
}
else
{
- if (!fMbkg) fMbkg=new TObjArray();
+ if (!fMbkg)
+ {
+ fMbkg=new TObjArray();
+ fMbkg->SetOwner();
+ }
fMbkg->Add(t);
}
}
// Default constructor
// All variables initialised to 0
// Initial maximum number of tracks is set to the default value
+ Init();
+ Reset();
+ SetNtinit();
+}
+///////////////////////////////////////////////////////////////////////////
+void AliJet::Init()
+{
+// Initialisation of pointers etc...
fTracks=0;
fNtinit=0;
fTrackCopy=0;
- Reset();
- SetNtinit();
}
///////////////////////////////////////////////////////////////////////////
AliJet::AliJet(Int_t n)
{
// Create a jet to hold initially a maximum of n tracks
// All variables initialised to 0
- fTracks=0;
- fNtinit=0;
- fTrackCopy=0;
+ Init();
Reset();
if (n > 0)
{
// Default destructor
if (fTracks)
{
- if (fTrackCopy) fTracks->Delete();
delete fTracks;
fTracks=0;
}
}
///////////////////////////////////////////////////////////////////////////
+AliJet::AliJet(AliJet& j)
+{
+// Copy constructor
+ Init();
+ Reset();
+ SetNtinit();
+ SetTrackCopy(j.GetTrackCopy());
+ SetId(j.GetId());
+
+ AliTrack* tx=0;
+ for (Int_t i=1; i<=j.GetNtracks(); i++)
+ {
+ tx=j.GetTrack(i);
+ if (tx) AddTrack(tx);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
void AliJet::SetNtinit(Int_t n)
{
// Set the initial maximum number of tracks for this jet
fNtmax=n;
if (fTracks)
{
- if (fTrackCopy) fTracks->Delete();
delete fTracks;
fTracks=0;
}
if (fNtinit > 0) SetNtinit(fNtinit);
}
///////////////////////////////////////////////////////////////////////////
-void AliJet::AddTrack(AliTrack& t)
+void AliJet::AddTrack(AliTrack& t,Int_t copy)
{
// Add a track to the jet.
-// Note : In case TrackCopy is set, the originally entered track
-// will be automatically reset.
+// Note : The optional parameter "copy" is for internal use only.
// In case the maximum number of tracks has been reached
// space will be extended to hold an additional amount of tracks as
// was initially reserved.
- if (!fTracks) fTracks=new TObjArray(fNtmax);
+ if (!fTracks)
+ {
+ fTracks=new TObjArray(fNtmax);
+ if (fTrackCopy) fTracks->SetOwner();
+ }
if (fNtrk == fNtmax) // Check if maximum track number is reached
{
fNtmax+=fNtinit;
// Add the track to this jet
fNtrk++;
- if (fTrackCopy)
+ if (fTrackCopy && copy)
{
- fTracks->Add(t.Clone());
+ fTracks->Add(new AliTrack(t));
}
else
{
AliJet(); // Default constructor
AliJet(Int_t n); // Create a Jet to hold initially n Tracks
~AliJet(); // Default destructor
+ AliJet(AliJet& j); // Copy constructor
void Reset(); // Reset all values
- virtual void AddTrack(AliTrack& t);// Add a track to the jet
- virtual void AddTrack(AliTrack* t) { AddTrack(*t); }
+ void AddTrack(AliTrack& t,Int_t copy=1);// Add a track to the jet
+ void AddTrack(AliTrack* t,Int_t copy=1) { AddTrack(*t,copy); }
void Info(TString f); // Print jet information in coordinate frame f
void List(TString f="car"); // Print jet prim. track information for coord. frame f
void ListAll(TString f="car"); // Print jet prim. and decay track information for coord. frame f
Int_t GetId(); // Provide the user defined identifier
protected:
+ void Init(); // Initialisation of pointers etc...
void SetNtinit(Int_t n=2); // Set the initial max. number of tracks for this Jet
Int_t fNtinit; // The initial max. number of tracks for this jet
Int_t fNtmax; // The maximum number of tracks for this Jet
///////////////////////////////////////////////////////////////////////////
// Class AliSample
-// Perform statistics on various multi-dimensional data samples
+// Perform statistics on various multi-dimensional data samples.
// A data sample can be filled using the "Enter" and/or "Remove" functions,
// whereas the "Reset" function resets the complete sample to 'empty'.
// The info which can be extracted from a certain data sample are the
#include "AliSample.h"
+ClassImp(AliSample) // Class implementation to enable ROOT I/O
+
AliSample::AliSample()
{
// Creation of an Aliample object and resetting the statistics values
Float_t fSigma[fMaxdim]; // Standard deviation for each variable
Float_t fCov[fMaxdim][fMaxdim]; // Covariances of pairs of variables
Float_t fCor[fMaxdim][fMaxdim]; // Correlations of pairs of variables
+
+ ClassDef(AliSample,0) // Statistics tools for various multi-dimensional data samples.
};
#endif
{
// Default constructor
// All variables initialised to 0
+ Init();
+ Reset();
+}
+///////////////////////////////////////////////////////////////////////////
+void AliTrack::Init()
+{
+// Initialisation of pointers etc...
fDecays=0;
fSignals=0;
fMasses=0;
fDmasses=0;
fPmasses=0;
- Reset();
}
///////////////////////////////////////////////////////////////////////////
AliTrack::~AliTrack()
// Destructor to delete memory allocated for decay tracks array
if (fDecays)
{
- fDecays->Delete();
delete fDecays;
fDecays=0;
}
}
}
///////////////////////////////////////////////////////////////////////////
+AliTrack::AliTrack(AliTrack& t)
+{
+// Copy constructor
+ Init();
+
+ fQ=t.GetCharge();
+ fChi2=t.GetChi2();
+ fNdf=t.GetNdf();
+ fUserId=t.GetId();
+ fNdec=t.GetNdecay();
+ fNsig=t.GetNsignals();
+ fNmasses=t.GetNMassHypotheses();
+ Set4Momentum((Ali4Vector&)t);
+ fBegin=t.GetBeginPoint();
+ fEnd=t.GetEndPoint();
+ fImpactXY=t.GetImpactPoint("z");
+ fImpactXZ=t.GetImpactPoint("y");
+ fImpactYZ=t.GetImpactPoint("x");
+ fClosest=t.GetClosestPoint();
+
+ AliTrack* tx;
+ if (fNdec)
+ {
+ fDecays=new TObjArray(fNdec);
+ fDecays->SetOwner();
+ for (Int_t it=1; it<=fNdec; it++)
+ {
+ tx=t.GetDecayTrack(it);
+ fDecays->Add(new AliTrack(*tx));
+ }
+ }
+
+ AliSignal* sx;
+ if (fNsig)
+ {
+ fSignals=new TObjArray(fNsig);
+ for (Int_t is=1; is<=fNsig; is++)
+ {
+ sx=t.GetSignal(is);
+ fSignals->Add(sx);
+ }
+ }
+
+ Double_t prob,m,dm;
+ if (fNmasses)
+ {
+ fMasses=new TArrayD(fNmasses);
+ fDmasses=new TArrayD(fNmasses);
+ fPmasses=new TArrayD(fNmasses);
+ for (Int_t ih=1; ih<=fNmasses; ih++)
+ {
+ prob=t.GetMassHypothesisProb(ih);
+ m=t.GetMassHypothesis(ih);
+ dm=t.GetResultError();
+ fMasses->AddAt(m,ih-1);
+ fDmasses->AddAt(dm,ih-1);
+ fPmasses->AddAt(prob,ih-1);
+ }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
void AliTrack::Reset()
{
// Reset all variables to 0 and delete all auto-generated decay tracks.
SetVector(a,"sph");
if (fDecays)
{
- fDecays->Delete();
delete fDecays;
fDecays=0;
}
// Enter the boosted data into the decay tracks array
if (fDecays)
{
- fDecays->Delete();
delete fDecays;
+ fDecays=0;
}
fDecays=new TObjArray();
+ fDecays->SetOwner();
fDecays->Add(new AliTrack);
((AliTrack*)fDecays->At(0))->Set4Momentum(p1);
{
// Provide decay produced track number j
// Note : j=1 denotes the first decay track
- if ((j >= 1) && (j <= fNdec))
+ if (!fDecays)
{
- return (AliTrack*)fDecays->At(j-1);
+ cout << " *AliTrack::GetDecayTrack* No tracks present." << endl;
+ return 0;
}
else
{
- cout << " *AliTrack* decay track number : " << j << " out of range." << endl;
- cout << " -- Decay track number 1 (if any) returned." << endl;
- return (AliTrack*)fDecays->At(0);
+ if ((j >= 1) && (j <= fNdec))
+ {
+ return (AliTrack*)fDecays->At(j-1);
+ }
+ else
+ {
+ cout << " *AliTrack* decay track number : " << j << " out of range."
+ << " Ndec = " << fNdec << endl;
+ return 0;
+ }
}
}
///////////////////////////////////////////////////////////////////////////
{
// Provide the related AliSignal number j.
// Note : j=1 denotes the first signal.
- if ((j >= 1) && (j <= fNsig))
+ if (!fSignals)
{
- return (AliSignal*)fSignals->At(j-1);
+ cout << " *AliTrack::GetSignal* No signals present." << endl;
+ return 0;
}
else
{
- cout << " *AliTrack* signal number : " << j << " out of range." << endl;
- cout << " -- Signal number 1 (if any) returned." << endl;
- return (AliSignal*)fDecays->At(0);
+ if ((j >= 1) && (j <= fNsig))
+ {
+ return (AliSignal*)fSignals->At(j-1);
+ }
+ else
+ {
+ cout << " *AliTrack* signal number : " << j << " out of range."
+ << " Nsig = " << fNsig << endl;
+ return 0;
+ }
}
}
///////////////////////////////////////////////////////////////////////////
public:
AliTrack(); // Default constructor
~AliTrack(); // Destructor
+ AliTrack(AliTrack& t); // Copy constructor
void Reset(); // Reset all values to 0
void Set4Momentum(Ali4Vector& p); // Set track 4-momentum
void Set3Momentum(Ali3Vector& p); // Set track 3-momentum
protected:
+ void Init(); // Initialisation of pointers etc...
Float_t fQ; // The charge of the particle
Int_t fNdec; // The number of decay products
TObjArray* fDecays; // The array of decay produced tracks
// 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...
+ AliJet::Init();
fNvmax=0;
fVertices=0;
fConnects=0;
fVertexCopy=0;
fNjmax=0;
fJets=0;
+ fJetTracks=0;
fJetCopy=0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliVertex::AliVertex(Int_t n)
+{
+// Create a vertex to hold initially a maximum of n tracks
+// All variables initialised to 0
+ Init();
Reset();
if (n > 0)
{
// 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;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliVertex::AliVertex(AliVertex& v)
+{
+// Copy constructor
+ Init();
+ Reset();
+ SetNtinit();
+ SetNvmax();
+ SetNjmax();
+ 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;
+ Int_t jetflag=0,connect=0;
+ AliTrack* tx2=0;
+ for (Int_t it=1; it<=v.GetNtracks(); 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;
+ }
}
///////////////////////////////////////////////////////////////////////////
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);
+ 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=new AliJet(j);
+
+ 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);
+ 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=new AliVertex(v);
+
+ 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);
+ 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);
}
}
return fJetCopy;
}
///////////////////////////////////////////////////////////////////////////
+Int_t AliVertex::IsConnectTrack(AliTrack* t)
+{
+// 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)
+{
+// 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;
+}
+///////////////////////////////////////////////////////////////////////////
AliVertex(); // Default constructor
AliVertex(Int_t n); // Create a vertex to hold initially n tracks
~AliVertex(); // Default destructor
+ AliVertex(AliVertex& v); // Copy constructor
void Reset(); // Reset all values and stored vertex and jet lists
void ResetVertices(); // Reset stored vertex list
void AddJet(AliJet& j,Int_t tracks=1); // Add a jet (and its tracks) to the vertex
void SetNjmax(Int_t n=2); // Set the initial max. number of jets
void SetJetCopy(Int_t j); // (De)activate creation of private copies in fJets
Int_t GetJetCopy(); // Provide JetCopy flag value
+ Int_t IsConnectTrack(AliTrack* t); // Indicate if track is created by vertex connection
+ Int_t IsJetTrack(AliTrack* t); // Indicate if track is resulting from jet addition
protected:
+ void Init(); // Initialisation of pointers etc...
Int_t fNvmax; // The maximum number of (secondary) vertices
Int_t fNvtx; // The number of (secondary) vertices
TObjArray* fVertices; // Array to hold the pointers to the (secondary) vertices
Int_t fNjmax; // The maximum number of jets
Int_t fNjets; // The number of jets
TObjArray* fJets; // Array to hold the pointers to the jets
+ TObjArray* fJetTracks;// Array to hold the pointers to tracks introduced by jet addition
Int_t fJetCopy; // Flag to denote creation of private copies in fJets
private:
#pragma link off all classes;
#pragma link off all functions;
- #pragma link C++ class AliMath;
- #pragma link C++ class AliSample;
- #pragma link C++ class AliRandom;
- #pragma link C++ class Ali3Vector;
- #pragma link C++ class Ali3VectorObj;
- #pragma link C++ class Ali4Vector;
- #pragma link C++ class Ali4VectorObj;
- #pragma link C++ class AliBoost;
- #pragma link C++ class AliPosition;
- #pragma link C++ class AliPositionObj;
- #pragma link C++ class AliSignal;
- #pragma link C++ class AliCalorimeter;
- #pragma link C++ class AliCalmodule;
- #pragma link C++ class AliCalcluster;
- #pragma link C++ class AliTrack;
- #pragma link C++ class AliJet;
- #pragma link C++ class AliVertex;
- #pragma link C++ class AliInvmass;
- #pragma link C++ class AliEvent;
+ #pragma link C++ class AliMath+;
+ #pragma link C++ class AliSample+;
+ #pragma link C++ class AliRandom+;
+ #pragma link C++ class Ali3Vector+;
+ #pragma link C++ class Ali3VectorObj+;
+ #pragma link C++ class Ali4Vector+;
+ #pragma link C++ class Ali4VectorObj+;
+ #pragma link C++ class AliBoost+;
+ #pragma link C++ class AliPosition+;
+ #pragma link C++ class AliPositionObj+;
+ #pragma link C++ class AliSignal+;
+ #pragma link C++ class AliCalorimeter+;
+ #pragma link C++ class AliCalmodule+;
+ #pragma link C++ class AliCalcluster+;
+ #pragma link C++ class AliTrack+;
+ #pragma link C++ class AliJet+;
+ #pragma link C++ class AliVertex+;
+ #pragma link C++ class AliInvmass+;
+ #pragma link C++ class AliEvent+;
#endif
12-jul-2001 NvE Memberfunction GetDistance() introduced for AliPosition and support for
point of closest approach introduced in AliTrack.
24-jul-2001 NvE Support for Chi2 and NDF information of track fit introduced in AliTrack.
+01-dec-2001 NvE SetOwner() introduced for certain TObjArray's in AliCalcluster, AliEvent,
+ AliInvmass, AliJet, AliTrack and AliVertex to adapt to the new memory
+ management of ROOT 3.01 (and later) in case of reading trees.
+06-dec-2001 NvE Memory usage optimised for AliVertex & co. and memory leak due to
+ cloning solved.
+07-dec-2001 NvE ClassDef() and ClassImp() statements introduced for AliSample.
+17-dec-2001 NvE Copy constructor and Init() memberfunction introduced for AliTrack & co.
+14-jan-2002 NvE New schema evolution activated via the "+" behind the classnames
+ in RALICELinkDef.h. Note that the new schema evolution only works
+ correctly for ROOT version 3.02/07 and later.
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff