01-dec-2001 NvE SetOwner() introduced for certain TObjArray's in AliCalcluster, AliEvent,
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Jan 2002 08:46:59 +0000 (08:46 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Jan 2002 08:46:59 +0000 (08:46 +0000)
                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.

14 files changed:
RALICE/AliCalcluster.cxx
RALICE/AliCalorimeter.cxx
RALICE/AliEvent.cxx
RALICE/AliInvmass.cxx
RALICE/AliJet.cxx
RALICE/AliJet.h
RALICE/AliSample.cxx
RALICE/AliSample.h
RALICE/AliTrack.cxx
RALICE/AliTrack.h
RALICE/AliVertex.cxx
RALICE/AliVertex.h
RALICE/RALICELinkDef.h
RALICE/history.txt

index 297cf1a46e5c4b95e336b18db692e8cb73f28156..9bba932a2fd8352b1a034e4db043f0cf46c83ab2 100644 (file)
@@ -52,7 +52,6 @@ AliCalcluster::~AliCalcluster()
 // Destructor to delete dynamically allocated memory
  if (fVetos)
  {
-  fVetos->Delete();
   delete fVetos;
   fVetos=0;
  }
@@ -259,6 +258,7 @@ void AliCalcluster::AddVetoSignal(Float_t* r,TString f,Float_t s)
  {
   fNvetos=0;
   fVetos=new TObjArray();
+  fVetos->SetOwner();
  } 
 
  fVetos->Add(new AliSignal(1));
@@ -278,17 +278,23 @@ AliSignal* AliCalcluster::GetVetoSignal(Int_t i)
 {
 // 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;
+  }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
index bc7218ae0fa55a1f047ff2781f2cdf41a376f5c1..7ab5b1f36e99f6c25555f9f1216aabbb443844d8 100644 (file)
@@ -178,6 +178,7 @@ AliCalorimeter::AliCalorimeter(Int_t nrow,Int_t ncol)
  }
  
  fModules=new TObjArray();  // Default size, expanded automatically
+ fModules->SetOwner();
  
  fHmodules=0;
  fHclusters=0;
@@ -732,6 +733,7 @@ void AliCalorimeter::Group(Int_t n)
    fClusters=0;
   }
   fClusters=new TObjArray();
+  fClusters->SetOwner();
   fNclusters=0;
   Int_t row=0;
   Int_t col=0;
@@ -1064,6 +1066,7 @@ void AliCalorimeter::AddVetoSignal(Float_t* r,TString f,Float_t s)
  {
   fNvetos=0;
   fVetos=new TObjArray();
+  fVetos->SetOwner();
  } 
 
  fVetos->Add(new AliSignal);
index ba0dc900f255d5f14f073287159933f4aca9da10..5f4b8a6bdb8d37fc097e3bcb12fdcfff1be73ae3 100644 (file)
@@ -13,7 +13,7 @@
  * 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"
@@ -223,7 +223,6 @@ AliEvent::~AliEvent()
 // Default destructor
  if (fCalorimeters)
  {
-  if (fCalCopy) fCalorimeters->Delete();
   delete fCalorimeters;
   fCalorimeters=0;
  }
@@ -241,7 +240,6 @@ void AliEvent::Reset()
  fNcals=0;
  if (fCalorimeters)
  {
-  if (fCalCopy) fCalorimeters->Delete();
   delete fCalorimeters;
   fCalorimeters=0;
  }
@@ -325,13 +323,17 @@ Int_t AliEvent::GetNcalorimeters()
 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
  {
index a68812965baf925841681d3b8535070ec2a05e78..ecd0d0c6b8bf7403f26f9da86e633f2ee2ac2f59 100644 (file)
@@ -123,14 +123,12 @@ AliInvmass::~AliInvmass()
 // Destructor to delete dynamically allocated memory
  if (fMinv)
  {
-  fMinv->Delete();
   delete fMinv;
   fMinv=0;
  }
 
  if (fMbkg)
  {
-  fMbkg->Delete();
   delete fMbkg;
   fMbkg=0;
  }
@@ -206,14 +204,12 @@ void AliInvmass::Combine(TObjArray* a1,TObjArray* a2)
  
  if ((!fBkg || fMode==1) && fMinv)
  {
-  fMinv->Delete();
   delete fMinv;
   fMinv=0;
  }
  
  if (fBkg && (fMode !=1) && fMbkg)
  {
-  fMbkg->Delete();
   delete fMbkg;
   fMbkg=0;
  }
@@ -298,12 +294,20 @@ void AliInvmass::Combine(TObjArray* a1,TObjArray* a2)
     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);
     }
    }
index ae492ff4c675005c70a29f16d813f48fdbf8932c..a59e90e736f499009eafd50b6d3985d19fe1c8db 100644 (file)
@@ -97,20 +97,24 @@ AliJet::AliJet()
 // 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)
  {
@@ -131,12 +135,28 @@ AliJet::~AliJet()
 // 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
@@ -144,7 +164,6 @@ void AliJet::SetNtinit(Int_t n)
  fNtmax=n;
  if (fTracks)
  {
-  if (fTrackCopy) fTracks->Delete();
   delete fTracks;
   fTracks=0;
  }
@@ -162,15 +181,18 @@ void AliJet::Reset()
  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;
@@ -179,9 +201,9 @@ void AliJet::AddTrack(AliTrack& t)
  
  // Add the track to this jet
  fNtrk++;
- if (fTrackCopy)
+ if (fTrackCopy && copy)
  {
-  fTracks->Add(t.Clone());
+  fTracks->Add(new AliTrack(t));
  }
  else
  {
index 43d191059f75d9ccd523f98b1459ea29d353147a..a1ff2a96f14c16023b9f1eaf5701932c14483070 100644 (file)
@@ -20,9 +20,10 @@ class AliJet : public TObject,public Ali4Vector
   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
@@ -46,6 +47,7 @@ class AliJet : public TObject,public Ali4Vector
   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
index 2670a940aed490604a5d2127950cb11a4542ea46..9a591e24815da196325baad6c958e9b547207a32 100644 (file)
@@ -17,7 +17,7 @@
 
 ///////////////////////////////////////////////////////////////////////////
 // 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
@@ -44,6 +44,8 @@
 
 #include "AliSample.h"
  
+ClassImp(AliSample) // Class implementation to enable ROOT I/O
 AliSample::AliSample()
 {
 // Creation of an Aliample object and resetting the statistics values
index 66bdd118d9a82ef703acf666402759fbc195e933..1f30c3405ac9254fcf84e71abfb69a9dcc549232 100644 (file)
@@ -47,5 +47,7 @@ class AliSample
   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
index c38721eb21a8e46c798ce39d044c86a721145a4b..4a64ec553fda46e23c0ca3b08589991f7a263eeb 100644 (file)
@@ -97,12 +97,18 @@ AliTrack::AliTrack()
 {
 // 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()
@@ -110,7 +116,6 @@ AliTrack::~AliTrack()
 // Destructor to delete memory allocated for decay tracks array
  if (fDecays)
  {
-  fDecays->Delete();
   delete fDecays;
   fDecays=0;
  }
@@ -122,6 +127,67 @@ AliTrack::~AliTrack()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+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.
@@ -136,7 +202,6 @@ void AliTrack::Reset()
  SetVector(a,"sph");
  if (fDecays)
  {
-  fDecays->Delete();
   delete fDecays;
   fDecays=0;
  }
@@ -407,10 +472,11 @@ void AliTrack::Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms)
  // 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);
@@ -430,15 +496,23 @@ AliTrack* AliTrack::GetDecayTrack(Int_t j)
 {
 // 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;  
+  }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -474,15 +548,23 @@ AliSignal* AliTrack::GetSignal(Int_t j)
 {
 // 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;
+  }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
index 77f8298b61ddfff086e76a2c5b3b919d437af4a3..09c8445b31fee09a7adbd01d44847ae5fd3428c0 100644 (file)
@@ -20,6 +20,7 @@ class AliTrack : public TObject,public Ali4Vector
  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
@@ -70,6 +71,7 @@ class AliTrack : public TObject,public Ali4Vector
 
  
  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
index 8ee85692029d9a2fea94cac72c848f75e271a2ab..b8d1bc7442ebecbc9a57edeb6c290648a45c625a 100644 (file)
@@ -151,30 +151,32 @@ AliVertex::AliVertex()
 // 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)
  {
@@ -197,22 +199,97 @@ AliVertex::~AliVertex()
 // 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)
@@ -228,7 +305,6 @@ void AliVertex::SetNvmax(Int_t n)
  }
  if (fVertices)
  {
-  if (fVertexCopy) fVertices->Delete();
   delete fVertices;
   fVertices=0;
  }
@@ -247,7 +323,6 @@ void AliVertex::SetNjmax(Int_t n)
  }
  if (fJets)
  {
-  if (fJetCopy) fJets->Delete();
   delete fJets;
   fJets=0;
  }
@@ -270,13 +345,17 @@ void AliVertex::Reset()
  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()
@@ -298,6 +377,7 @@ void AliVertex::ResetVertices()
     fNtrk--;
     (Ali4Vector&)(*this)-=(Ali4Vector&)(*t);
     fQ-=t->GetCharge();
+    if (fTrackCopy) delete t;
    }
   }
   fTracks->Compress();
@@ -307,7 +387,6 @@ void AliVertex::ResetVertices()
  if (fNvmax>0) SetNvmax(fNvmax);
  if (fConnects)
  {
-  fConnects->Delete();
   delete fConnects;
   fConnects=0;
  }
@@ -326,7 +405,11 @@ void AliVertex::AddJet(AliJet& j,Int_t tracks)
 //        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++;
@@ -334,24 +417,32 @@ void AliVertex::AddJet(AliJet& j,Int_t tracks)
  }
 
  // 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);
+   }
   }
  }
 }
@@ -372,7 +463,11 @@ void AliVertex::AddVertex(AliVertex& v,Int_t connect)
 //        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++;
@@ -380,36 +475,31 @@ void AliVertex::AddVertex(AliVertex& v,Int_t connect)
  }
 
  // 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);
  }
 }
@@ -707,3 +797,31 @@ Int_t AliVertex::GetJetCopy()
  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;
+}
+///////////////////////////////////////////////////////////////////////////
index 57507546b1a37af8e79a0a05a1c07aa78044eb3f..779882e39a8f8f0316cd3d09cc2cd79ad64b9969 100644 (file)
@@ -20,6 +20,7 @@ class AliVertex : public AliJet,public AliPosition
   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
@@ -41,8 +42,11 @@ class AliVertex : public AliJet,public AliPosition
   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
@@ -51,6 +55,7 @@ class AliVertex : public AliJet,public AliPosition
   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:
index dbe623429a122b3e908ec1395e004a429371c9c7..f00c8ee124a0dbfcf17c1b10cfc11e730ed46abf 100644 (file)
  #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
  
index 07cd44e5d2d703aea8f61368a52ac25583d09937..5b043f2b53a701b595cdb651f0ea88acced0a564 100644 (file)
 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.