X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=RALICE%2FAliJet.cxx;h=95195241a2481157903183d5af859a10044566ac;hb=3cb5c01332e27f49cedeaf329d5d9d2f101ba679;hp=b094b84031fe3b750c80153da1fae4ccf78bacd3;hpb=c1f25d1dcc851b2f7b14efd54955756e58981cc4;p=u%2Fmrichter%2FAliRoot.git

diff --git a/RALICE/AliJet.cxx b/RALICE/AliJet.cxx
index b094b84031f..95195241a24 100644
--- a/RALICE/AliJet.cxx
+++ b/RALICE/AliJet.cxx
@@ -30,8 +30,11 @@
 //    in an AliEvent.  
 //    In this way the AliJet just represents a 'logical structure' for the
 //    physics analysis which can be embedded in e.g. an AliEvent or AliVertex.
+//
+//    Note :
 //    Modifications made to the original tracks also affect the AliTrack objects
 //    which are stored in the AliJet. 
+//
 // b) SetTrackCopy(1).
 //    Of every 'added' track a private copy will be made of which the pointer
 //    will be stored.
@@ -42,6 +45,8 @@
 //    creating only one AliTrack instance in the main programme and using the
 //    AliTrack::Reset() and AliTrack parameter setting memberfunctions.
 //
+// See also the documentation provided for the memberfunction SetOwner(). 
+//
 // Coding example to make 2 jets j1 and j2.
 // ----------------------------------------
 // j1 contains the AliTracks t1 and t2
@@ -67,8 +72,8 @@
 //  tx->Reset();
 // }
 //
-// j1.Info();
-// j2.Info("sph");
+// j1.Data();
+// j2.Data("sph");
 //
 // Float_t e1=j1.GetEnergy();
 // Float_t pnorm=j1->GetMomentum();
@@ -86,28 +91,33 @@
 ///////////////////////////////////////////////////////////////////////////
 
 #include "AliJet.h"
+#include "Riostream.h"
  
 ClassImp(AliJet) // Class implementation to enable ROOT I/O
  
-AliJet::AliJet()
+AliJet::AliJet() : TNamed(),Ali4Vector()
 {
 // Default constructor
 // All variables initialised to 0
 // Initial maximum number of tracks is set to the default value
- fTracks=0;
- fNtinit=0;
- fTrackCopy=0;
+ Init();
  Reset();
  SetNtinit();
 }
 ///////////////////////////////////////////////////////////////////////////
-AliJet::AliJet(Int_t n)
+void AliJet::Init()
 {
-// Create a jet to hold initially a maximum of n tracks
-// All variables initialised to 0
+// Initialisation of pointers etc...
  fTracks=0;
  fNtinit=0;
  fTrackCopy=0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliJet::AliJet(Int_t n) : TNamed(),Ali4Vector()
+{
+// Create a jet to hold initially a maximum of n tracks
+// All variables initialised to 0
+ Init();
  Reset();
  if (n > 0)
  {
@@ -128,23 +138,79 @@ AliJet::~AliJet()
 // Default destructor
  if (fTracks)
  {
-  if (fTrackCopy) fTracks->Delete();
   delete fTracks;
   fTracks=0;
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliJet::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 (fTracks) fTracks->SetOwner(own);
+ fTrackCopy=mode;
+}
+///////////////////////////////////////////////////////////////////////////
+AliJet::AliJet(const AliJet& j) : TNamed(j),Ali4Vector(j)
+{
+// Copy constructor
+ fNtinit=j.fNtinit;
+ fNtmax=j.fNtmax;
+ fQ=j.fQ;
+ fNtrk=j.fNtrk;
+ fTrackCopy=j.fTrackCopy;
+ fUserId=j.fUserId;
+
+ fTracks=0;
+ if (fNtrk)
+ {
+  fTracks=new TObjArray(fNtmax);
+  if (fTrackCopy) fTracks->SetOwner();
+ }
+
+ for (Int_t i=1; i<=fNtrk; i++)
+ {
+  AliTrack* tx=j.GetTrack(i);
+  if (fTrackCopy)
+  {
+   fTracks->Add(tx->Clone());
+  }
+  else
+  {
+   fTracks->Add(tx);
+  }
+ } 
+}
+///////////////////////////////////////////////////////////////////////////
 void AliJet::SetNtinit(Int_t n)
 {
 // Set the initial maximum number of tracks for this jet
  fNtinit=n;
  fNtmax=n;
+ if (fTracks)
  {
-  if (fTrackCopy) fTracks->Delete();
   delete fTracks;
   fTracks=0;
  }
- if (fTracks) delete fTracks;
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliJet::Reset()
@@ -153,6 +219,7 @@ void AliJet::Reset()
 // The max. number of tracks is set to the initial value again
  fNtrk=0;
  fQ=0;
+ fUserId=0;
  Double_t a[4]={0,0,0,0};
  SetVector(a,"sph");
  if (fNtinit > 0) SetNtinit(fNtinit);
@@ -160,11 +227,44 @@ void AliJet::Reset()
 ///////////////////////////////////////////////////////////////////////////
 void AliJet::AddTrack(AliTrack& t)
 {
-// Add a track to the jet
+// Add a track to the jet.
+// 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.
+// See SetTrackCopy() to tailor the functionality of the stored structures.
+//
+// Note :
+// In case a private copy is made, this is performed via the Clone() memberfunction.
+// All AliTrack 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 AliTrack.   
+
+ AddTrack(t,1);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliJet::AddTrack(AliTrack& t,Int_t copy)
+{
+// Internal memberfunction to actually add a track to the jet.
 // 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);
+// was initially reserved.
+//
+// If copy=0 NO copy of the track will be made, irrespective of the setting
+// of the TrackCopy flag.
+// This allows a proper treatment of automatically generated connecting
+// tracks between vertices.
+//
+// Note :
+// In case a private copy is made, this is performed via the Clone() memberfunction.
+
+ if (!fTracks)
+ {
+  fTracks=new TObjArray(fNtmax);
+  if (fTrackCopy) fTracks->SetOwner();
+ }
  if (fNtrk == fNtmax) // Check if maximum track number is reached
  {
   fNtmax+=fNtinit;
@@ -173,33 +273,41 @@ void AliJet::AddTrack(AliTrack& t)
  
  // Add the track to this jet
  fNtrk++;
- if (fTrackCopy)
+ if (fTrackCopy && copy)
  {
-  AliTrack* tx=new AliTrack(t);
-  fTracks->Add(tx);
+  fTracks->Add(t.Clone());
  }
  else
  {
   fTracks->Add(&t);
  }
+
  (*this)+=(Ali4Vector&)t;
  fQ+=t.GetCharge();
+
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliJet::Info(TString f)
+void AliJet::Data(TString f)
 {
 // Provide jet information within the coordinate frame f
- cout << " *AliJet::Info* Invmass : " << GetInvmass() << " Charge : " << fQ
+ const char* name=GetName();
+ const char* title=GetTitle();
+
+ cout << " *AliJet::Data*";
+ if (strlen(name))  cout << " Name : " << GetName();
+ if (strlen(title)) cout << " Title : " << GetTitle();
+ cout << endl;
+ cout << " Id : " << fUserId << " Invmass : " << GetInvmass() << " Charge : " << fQ
       << " Momentum : " << GetMomentum() << " Ntracks : " << fNtrk << endl;
- cout << " ";
- Ali4Vector::Info(f); 
+
+ Ali4Vector::Data(f); 
 } 
 ///////////////////////////////////////////////////////////////////////////
 void AliJet::List(TString f)
 {
 // Provide jet and primary track information within the coordinate frame f
 
- Info(f); // Information of the current jet
+ Data(f); // Information of the current jet
 
  // The tracks of this jet
  AliTrack* t; 
@@ -210,7 +318,7 @@ void AliJet::List(TString f)
   {
    cout << "  ---Track no. " << it << endl;
    cout << " ";
-   t->Info(f); 
+   t->Data(f); 
   }
   else
   {
@@ -223,7 +331,7 @@ void AliJet::ListAll(TString f)
 {
 // Provide jet and prim.+sec. track information within the coordinate frame f
 
- Info(f); // Information of the current jet
+ Data(f); // Information of the current jet
 
  // The tracks of this jet
  AliTrack* t; 
@@ -243,7 +351,7 @@ void AliJet::ListAll(TString f)
  }
 } 
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliJet::GetNtracks()
+Int_t AliJet::GetNtracks() const
 {
 // Return the current number of tracks of this jet
  return fNtrk;
@@ -265,7 +373,7 @@ Double_t AliJet::GetMomentum()
  return norm;
 }
 ///////////////////////////////////////////////////////////////////////////
-Ali3Vector AliJet::Get3Momentum()
+Ali3Vector AliJet::Get3Momentum() const
 {
 // Return the the total jet 3-momentum
  Ali3Vector p=Get3Vector();
@@ -286,16 +394,47 @@ Double_t AliJet::GetInvmass()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-Float_t AliJet::GetCharge()
+Float_t AliJet::GetCharge() const
 {
 // Return the total charge of the jet
  return fQ;
 }
 ///////////////////////////////////////////////////////////////////////////
-AliTrack* AliJet::GetTrack(Int_t i)
+AliTrack* AliJet::GetTrack(Int_t i) const
 {
 // Return the i-th track of this jet
- return (AliTrack*)fTracks->At(i-1);
+ if (!fTracks)
+ {
+  cout << " *AliJet*::GetTrack* No tracks present." << endl;
+  return 0;
+ }
+ else
+ {
+  if (i<=0 || i>fNtrk)
+  {
+   cout << " *AliJet*::GetTrack* Invalid argument i : " << i
+        << " Ntrk = " << fNtrk << endl;
+   return 0;
+  }
+  else
+  {
+   return (AliTrack*)fTracks->At(i-1);
+  }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliTrack* AliJet::GetIdTrack(Int_t id) const
+{
+// Return the track with user identifier "id" of this jet
+ if (!fTracks) return 0;
+
+ AliTrack* tx=0;
+ for (Int_t i=0; i<fNtrk; i++)
+ {
+  tx=(AliTrack*)fTracks->At(i);
+  if (id == tx->GetId()) return tx;
+ }
+ return 0; // No matching id found
 }
 ///////////////////////////////////////////////////////////////////////////
 Double_t AliJet::GetPt()
@@ -420,7 +559,7 @@ void AliJet::SetTrackCopy(Int_t j)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliJet::GetTrackCopy()
+Int_t AliJet::GetTrackCopy() const
 {
 // Provide value of the TrackCopy mode.
 // 0 ==> No private copies are made; pointers of original tracks are stored.
@@ -428,3 +567,33 @@ Int_t AliJet::GetTrackCopy()
  return fTrackCopy;
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliJet::SetId(Int_t id)
+{
+// Set a user defined identifier for this jet.
+ fUserId=id;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliJet::GetId() const
+{
+// Provide the user defined identifier of this jet.
+ return fUserId;
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliJet::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. AliVertex to store either AliJet objects or
+// objects derived from AliJet via the AddJet memberfunction, provided
+// these derived classes also have a proper Clone memberfunction. 
+
+ AliJet* jet=new AliJet(*this);
+ if (name)
+ {
+  if (strlen(name)) jet->SetName(name);
+ }
+ return jet;
+}
+///////////////////////////////////////////////////////////////////////////