05-dec-2003 NvE Memberfunction SetStable introduced in AliCollider for the user's...
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Dec 2003 09:28:06 +0000 (09:28 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Dec 2003 09:28:06 +0000 (09:28 +0000)
08-dec-2003 NvE AliTrack derived from TNamed to enhance labeling flexibility and also specific
                Clone memberfunction introduced to enable storage of derived objects in AliJet & co.
                Also specific Clone memberfunctions introduced for AliJet, AliVertex and AliEvent and
                for the already existing specific Clone memberfunctions the default argument was set
                to the empty string "".
15-dec-2003 NvE Datamembers fNdec and fNsig removed from AliTrack since these data are now retrieved
                directly from the corresponding arrays.
                Support for hypothesis probability introduced in AliTrack and old mass hypothesis
                machinery extended to provide now full track hypotheses.
18-dec-2003 NvE Support for object references from the various signal slots introduced in AliSignal.
                Since this is mainly intended for "backward references" to AliTrack objects,
                the AliTrack class has been slightly updated for this to provide pointer consistency
                in case the corresponding AliTrack object is deleted.

16 files changed:
RALICE/AliAttribObj.h
RALICE/AliCalmodule.h
RALICE/AliCalorimeter.h
RALICE/AliCollider.cxx
RALICE/AliCollider.h
RALICE/AliEvent.cxx
RALICE/AliEvent.h
RALICE/AliJet.cxx
RALICE/AliJet.h
RALICE/AliSignal.cxx
RALICE/AliSignal.h
RALICE/AliTrack.cxx
RALICE/AliTrack.h
RALICE/AliVertex.cxx
RALICE/AliVertex.h
RALICE/history.txt

index 029426acc86b6648a230736f771e6a84c159ed75..0cdc2fbd4dc555ddc79ca4b64aa822fc815b2ca3 100644 (file)
@@ -16,7 +16,7 @@ class AliAttribObj : public TObject,public AliAttrib
   AliAttribObj(AliAttrib& a);                      // Constructor
   virtual ~AliAttribObj();                         // Destructor
   AliAttribObj(AliAttribObj& a);                   // Copy constructor
-  virtual TObject* Clone(char* name);              // Make a deep copy and provide its pointer
+  virtual TObject* Clone(char* name="");           // Make a deep copy and provide its pointer
 
  ClassDef(AliAttribObj,2) // Generic handling of detector signal (calibration) attributes.
 };
index 64c11167af5b596defc26b8339e527850bd8cd38..b728f9461dff22086ddd359738ce38f1c23abcec 100644 (file)
@@ -14,7 +14,7 @@ class AliCalmodule : public AliSignal
   virtual ~AliCalmodule();                                 // Default destructor
   AliCalmodule(AliCalmodule& m);                           // Copy constructor
   AliCalmodule(Int_t row,Int_t col,Double_t sig);          // Create a module and initialise data
-  virtual TObject* Clone(char* name);                      // Make a deep copy and provide its pointer
+  virtual TObject* Clone(char* name="");                   // Make a deep copy and provide its pointer
   virtual void SetSignal(Double_t sig,Int_t j=1);          // Set or change data for certain module
   virtual void AddSignal(Double_t sig,Int_t j=1);          // Add signal to a certain module
   void SetRow(Int_t i);                                    // Set the row number of the module
index c8d0b48352c9f35b61046ea6c1b1f0d77ddc44b8..8bac7621ec393592bebfcb6680c5a38937d269ce 100644 (file)
@@ -26,7 +26,7 @@ class AliCalorimeter : public TNamed
   AliCalorimeter(Int_t nrow,Int_t ncol);           // Create a calorimeter matrix
   virtual ~AliCalorimeter();                       // Destructor
   AliCalorimeter(AliCalorimeter& c);               // Copy constructor
-  virtual TObject* Clone(char* name);              // Make a deep copy and provide pointer of the copy
+  virtual TObject* Clone(char* name="");           // Make a deep copy and provide pointer of the copy
   Int_t GetNrows();                                // Return number of rows of the matrix
   Int_t GetNcolumns();                             // Return number of columns of the matrix
   void SetSignal(Int_t row,Int_t col,Float_t s);   // Set signal for a certain module
index 4c31b3cc36c2aa3f3b8c65fb1bc011f914ab2549..4f1bcea2fc073411ba49f21eb767d961a9044177 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// $Id: AliCollider.cxx,v 1.6 2003/08/29 09:05:11 nick Exp $
+// $Id: AliCollider.cxx,v 1.7 2003/10/26 14:53:44 nick Exp $
 
 ///////////////////////////////////////////////////////////////////////////
 // Class AliCollider
 //
 //
 //--- Author: Nick van Eijndhoven 22-nov-2002 Utrecht University
-//- Modified: NvE $Date: 2003/08/29 09:05:11 $ Utrecht University
+//- Modified: NvE $Date: 2003/10/26 14:53:44 $ Utrecht University
 ///////////////////////////////////////////////////////////////////////////
 
 #include "AliCollider.h"
@@ -715,3 +715,47 @@ void AliCollider::EndRun()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliCollider::SetStable(Int_t id,Int_t mode)
+{
+// Declare whether a particle must be regarded as stable or not.
+// The parameter "id" indicates the Pythia KF particle code, which
+// basically is the PDG particle identifier code.
+// The parameter "mode" indicates the action to be taken.
+//
+// mode = 0 : Particle will be able to decay
+//        1 : Particle will be regarded as stable.
+//
+// In case the user does NOT explicitly invoke this function, the standard
+// Pythia settings for the decay tables are used.
+//
+// When this function is invoked without the "mode" argument, then the
+// default of mode=1 will be used for the specified particle.
+//
+// Notes :
+// -------
+// 1) This function should be invoked after the initialisation call
+//    to AliCollider::Init.
+// 2) Due to the internals of Pythia, there is no need to specify particles
+//    and their corresponding anti-particles separately as (un)stable.
+//    Once a particle has been declared (un)stable, the corresponding 
+//    anti-particle will be treated in the same way.
+
+ if (mode==0 || mode==1)
+ {
+  Int_t kc=Pycomp(id);
+  Int_t decay=1-mode;
+  if (kc>0)
+  {
+   SetMDCY(kc,1,decay);
+  }
+  else 
+  {
+   cout << " *AliCollider::SetStable* Unknown particle code. id = " << id << endl;
+  }
+ }
+ else
+ {
+  cout << " *AliCollider::SetStable* Invalid parameter. mode = " << mode << endl;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
index 42cd03555039de8491095f3606d358dcffee37d8..968e4e1f9301d32123ddb21c5dfce35cecab2af9 100644 (file)
@@ -3,7 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// $Id: AliCollider.h,v 1.4 2003/08/29 09:05:11 nick Exp $
+// $Id: AliCollider.h,v 1.5 2003/10/26 14:53:44 nick Exp $
 
 #include "TPythia6.h"
 #include "TString.h"
@@ -29,6 +29,7 @@ class AliCollider : public TPythia6
   Int_t GetPrintFreq();                                 // Provide the print frequency
   void Init(char* frame,char* beam,char* target,Float_t win); // Standard Pythia initialisation
   void Init(char* frame,Int_t zp,Int_t ap,Int_t zt,Int_t at,Float_t win); // Nucl-Nucl initialisation
+  void SetStable(Int_t id,Int_t mode=1);                // Declare a certain particle as stable or not
   void MakeEvent(Int_t npt=0,Int_t mlist=-1,Int_t medit=1);// Generate a single event with npt participant nucleons
   void EndRun();                                        // Properly close all buffers and output file
   AliEvent* GetEvent();                                 // Provide pointer to the generated event structure
@@ -58,6 +59,6 @@ class AliCollider : public TPythia6
 
   void GetFractions(Float_t zp,Float_t ap,Float_t zt,Float_t at); // Determine various N-N collision fractions
 
- ClassDef(AliCollider,4) // Pythia based universal physics event generator
+ ClassDef(AliCollider,5) // Pythia based universal physics event generator
 };
 #endif
index 20ff1ff80433f8ae43a17cb41a59d66231e932ad..375b1f8f991b54ce79528f4f4bf33dce70c8caa0 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// $Id: AliEvent.cxx,v 1.15 2003/11/21 14:20:10 nick Exp $
+// $Id: AliEvent.cxx,v 1.16 2003/12/03 14:30:26 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: 2003/11/21 14:20:10 $ UU-SAP Utrecht
+//- Modified: NvE $Date: 2003/12/03 14:30:26 $ UU-SAP Utrecht
 ///////////////////////////////////////////////////////////////////////////
 
 #include "AliEvent.h"
@@ -670,4 +670,22 @@ void AliEvent::ShowDevices()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+TObject* AliEvent::Clone(char* name)
+{
+// 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 to store either AliEvent objects or objects derived from
+// AliEvent via some generic AddEvent memberfunction, provided these derived
+// classes also have a proper Clone memberfunction. 
+
+ AliEvent* evt=new AliEvent(*this);
+ if (name)
+ {
+  if (strlen(name)) evt->SetName(name);
+ }
+ return evt;
+}
+///////////////////////////////////////////////////////////////////////////
 
index cf284f61d464101788d4cf35783573ee0bc9dee6..b743043231eea9b599e9facf808cac87a70049d8 100644 (file)
@@ -3,7 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// $Id: AliEvent.h,v 1.11 2003/10/26 14:53:44 nick Exp $
+// $Id: AliEvent.h,v 1.12 2003/11/21 14:20:10 nick Exp $
 
 #include <math.h>
  
@@ -21,6 +21,7 @@ class AliEvent : public AliVertex
   AliEvent(Int_t n);                      // Create an event to hold initially n tracks
   virtual ~AliEvent();                    // Default destructor
   AliEvent(AliEvent& evt);                // Copy constructor
+  virtual TObject* Clone(char* name="");  // Make a deep copy and provide its pointer
   virtual void SetOwner(Bool_t own=kTRUE);// Set ownership of all added objects
   void SetDayTime(TTimeStamp& stamp);     // Set the date and time stamp exactly as specified (1 ns accuracy)
   void SetDayTime(TDatime& stamp);        // Set date and time stamp interpreted as local time (1 s accuracy)
@@ -66,6 +67,6 @@ class AliEvent : public AliVertex
   TObjArray* fDevices;      // Array to hold the pointers to the various devices
   Int_t fDevCopy;           // Flag to denote creation of private copies of the devices
 
- ClassDef(AliEvent,10) // Creation and investigation of an Alice physics event.
+ ClassDef(AliEvent,11) // Creation and investigation of an Alice physics event.
 };
 #endif
index 3bf4840b38929168a50e30bd5fd9095a34f85e3f..2e0251a1087a3c96081e7ee66911d755b17ff3ef 100644 (file)
@@ -103,8 +103,6 @@ AliJet::AliJet() : TNamed(),Ali4Vector()
  Init();
  Reset();
  SetNtinit();
- SetName("Unspecified");
- SetTitle("Unspecified");
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliJet::Init()
@@ -133,8 +131,6 @@ AliJet::AliJet(Int_t n) : TNamed(),Ali4Vector()
   cout << endl;
   SetNtinit();
  }
- SetName("Unspecified");
- SetTitle("Unspecified");
 }
 ///////////////////////////////////////////////////////////////////////////
 AliJet::~AliJet()
@@ -196,7 +192,7 @@ AliJet::AliJet(AliJet& j) : TNamed(j),Ali4Vector(j)
   AliTrack* tx=j.GetTrack(i);
   if (fTrackCopy)
   {
-   fTracks->Add(new AliTrack(*tx));
+   fTracks->Add(tx->Clone());
   }
   else
   {
@@ -236,6 +232,16 @@ void AliJet::AddTrack(AliTrack& t)
 // 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);
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -250,6 +256,10 @@ void AliJet::AddTrack(AliTrack& t,Int_t copy)
 // 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);
@@ -265,7 +275,7 @@ void AliJet::AddTrack(AliTrack& t,Int_t copy)
  fNtrk++;
  if (fTrackCopy && copy)
  {
-  fTracks->Add(new AliTrack(t));
+  fTracks->Add(t.Clone());
  }
  else
  {
@@ -280,7 +290,13 @@ void AliJet::AddTrack(AliTrack& t,Int_t copy)
 void AliJet::Data(TString f)
 {
 // Provide jet information within the coordinate frame f
- cout << " *AliJet::Data* Name : " << GetName() << " Title : " << GetTitle() << endl;
+ 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;
 
@@ -570,3 +586,21 @@ Int_t AliJet::GetId()
  return fUserId;
 }
 ///////////////////////////////////////////////////////////////////////////
+TObject* AliJet::Clone(char* name)
+{
+// 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;
+}
+///////////////////////////////////////////////////////////////////////////
index e52c9900dd9da39d28d37a24a6388c9ce443867d..8470178f0587584f95d90dbb2c17d53c3d9322b2 100644 (file)
@@ -20,6 +20,7 @@ class AliJet : public TNamed,public Ali4Vector
   AliJet(Int_t n);                         // Create a Jet to hold initially n Tracks
   virtual ~AliJet();                       // Default destructor
   AliJet(AliJet& j);                       // Copy constructor
+  virtual TObject* Clone(char* name="");   // Make a deep copy and provide its pointer
   virtual void SetOwner(Bool_t own=kTRUE); // Set ownership of all added objects
   virtual void Reset();                    // Reset all values
   void AddTrack(AliTrack& t);              // Add a track to the jet
@@ -59,6 +60,6 @@ class AliJet : public TNamed,public Ali4Vector
   Int_t fTrackCopy;                      // Flag to denote creation of private copies in fTracks
   Int_t fUserId;                         // The user defined identifier
  
- ClassDef(AliJet,6) // Creation and investigation of a jet of particle tracks.
+ ClassDef(AliJet,7) // Creation and investigation of a jet of particle tracks.
 };
 #endif
index c37ad9a9e070b01a68129f650f16ce211522c159..4048a0fc4525ec0891c558f26860447cc27a9027 100644 (file)
@@ -86,6 +86,7 @@
 ///////////////////////////////////////////////////////////////////////////
 
 #include "AliSignal.h"
+#include "AliTrack.h"
 #include "Riostream.h"
  
 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
@@ -99,8 +100,7 @@ AliSignal::AliSignal() : TNamed(),AliPosition(),AliAttrib()
  fSignals=0;
  fDsignals=0;
  fWaveforms=0;
- SetName("Unspecified");
- SetTitle("Unspecified");
+ fLinks=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliSignal::~AliSignal()
@@ -121,6 +121,11 @@ AliSignal::~AliSignal()
   delete fWaveforms;
   fWaveforms=0;
  }
+ if (fLinks)
+ {
+  delete fLinks;
+  fLinks=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 AliSignal::AliSignal(AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
@@ -129,6 +134,7 @@ AliSignal::AliSignal(AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
  fSignals=0;
  fDsignals=0;
  fWaveforms=0;
+ fLinks=0;
 
  Int_t n=s.GetNvalues();
  Double_t val;
@@ -151,6 +157,13 @@ AliSignal::AliSignal(AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
   TH1F* hist=s.GetWaveform(k);
   if (hist) SetWaveform(hist,k); 
  }
+
+ n=s.GetNlinks();
+ for (Int_t il=1; il<=n; il++)
+ {
+  TObject* obj=s.GetLink(il);
+  if (obj) SetLink(obj,il); 
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::Reset(Int_t mode)
@@ -165,6 +178,9 @@ void AliSignal::Reset(Int_t mode)
 //
 // The default when invoking Reset() corresponds to mode=0.
 //
+// Note : In all cases the storage of the various links will be cleared
+//        and the container itself will be deleted to recover the memory.
+//
 // The usage of mode=0 allows to re-use the allocated memory for new
 // signal (and error) values. This behaviour is preferable (i.e. faster)
 // in case the various signals always contain the same number of values
@@ -194,6 +210,12 @@ void AliSignal::Reset(Int_t mode)
   DeleteSignals();
   DeleteCalibrations();
  }
+
+ if (fLinks)
+ {
+  delete fLinks;
+  fLinks=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::ResetSignals(Int_t mode)
@@ -419,8 +441,13 @@ void AliSignal::Data(TString f)
 {
 // Provide all signal information within the coordinate frame f.
 
- cout << " *" << ClassName() << "::Data* Name : " << GetName()
-      << " Title : " << GetTitle() << endl;
+ const char* name=GetName();
+ const char* title=GetTitle();
+
+ cout << " *" << ClassName() << "::Data*";
+ if (strlen(name))  cout << " Name : " << name;
+ if (strlen(title)) cout << " Title : " << title;
+ cout << endl;
  cout << " Position";
  Ali3Vector::Data(f);
 
@@ -441,15 +468,27 @@ void AliSignal::List(Int_t j)
   return;
  }
 
- if (j != -1) cout << " *" << ClassName() << "::List* Name : " << GetName()
-                   << " Title : " << GetTitle() << endl;
+ if (j != -1)
+ {
+  const char* name=GetName();
+  const char* title=GetTitle();
+
+  cout << " *" << ClassName() << "::Data*";
+  if (strlen(name))  cout << " Name : " << name;
+  if (strlen(title)) cout << " Title : " << title;
+  cout << endl;
+ }
 
  Int_t nvalues=GetNvalues();
  Int_t nerrors=GetNerrors();
  Int_t nwforms=GetNwaveforms();
+ Int_t nlinks=GetNlinks();
  Int_t n=nvalues;
  if (nerrors>n) n=nerrors;
  if (nwforms>n) n=nwforms;
+ if (nlinks>n) n=nlinks;
+
+ TObject* obj=0;
 
  if (j<=0)
  {
@@ -460,8 +499,26 @@ void AliSignal::List(Int_t j)
    if (i<=nerrors) cout << " error : " << GetSignalError(i);
    AliAttrib::List(i);
    cout << endl;
-   if (GetWaveform(i)) cout << "    Waveform : " << GetWaveform(i)->ClassName()
-                            << " " << GetWaveform(i)->GetTitle() << endl;
+   obj=GetWaveform(i);
+   if (obj)
+   {
+    const char* wfname=obj->GetName();
+    const char* wftitle=obj->GetTitle();
+    cout << "    Waveform : " << obj->ClassName();
+    if (strlen(wfname))  cout << " Name : " << wfname;
+    if (strlen(wftitle)) cout << " Title : " << wftitle;
+    cout << endl;
+   }
+   obj=GetLink(i);
+   if (obj)
+   {
+    const char* lname=obj->GetName();
+    const char* ltitle=obj->GetTitle();
+    cout << "    Link to : " << obj->ClassName();
+    if (strlen(lname))  cout << " Name : " << lname;
+    if (strlen(ltitle)) cout << " Title : " << ltitle;
+    cout << endl;
+   }
   }
  }
  else
@@ -473,8 +530,26 @@ void AliSignal::List(Int_t j)
    if (j<=nerrors) cout << " error : " << GetSignalError(j);
    AliAttrib::List(j);
    cout << endl;
-   if (GetWaveform(j)) cout << "    Waveform : " << GetWaveform(j)->ClassName()
-                            << " " << GetWaveform(j)->GetTitle() << endl;
+   obj=GetWaveform(j);
+   if (obj)
+   {
+    const char* wfnamej=obj->GetName();
+    const char* wftitlej=obj->GetTitle();
+    cout << "    Waveform : " << obj->ClassName();
+    if (strlen(wfnamej))  cout << " Name : " << wfnamej;
+    if (strlen(wftitlej)) cout << " Title : " << wftitlej;
+    cout << endl;
+   }
+   obj=GetLink(j);
+   if (obj)
+   {
+    const char* lnamej=obj->GetName();
+    const char* ltitlej=obj->GetTitle();
+    cout << "    Link to : " << obj->ClassName();
+    if (strlen(lnamej))  cout << " Name : " << lnamej;
+    if (strlen(ltitlej)) cout << " Title : " << ltitlej;
+    cout << endl;
+   }
   }
  }
 } 
@@ -628,6 +703,132 @@ void AliSignal::DeleteWaveform(Int_t j)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNlinks()
+{
+// Provide the highest slot number with a specified link for this signal.
+ Int_t n=0;
+ if (fLinks) n=fLinks->GetSize();
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliSignal::GetLink(Int_t j)
+{
+// Provide pointer of the object linked to the j-th slot.
+ TObject* obj=0;
+ if (j <= GetNlinks()) obj=fLinks->At(j-1);
+ return obj;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetLink(TObject* obj,Int_t j)
+{
+// Introduce a link (=pointer) to an object for the j-th slot.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the objects of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// Notes :
+//  The link of the first slot is at j=1.
+//  j=1 is the default value.
+//
+// In case the value of the index j exceeds the maximum number of reserved
+// slots for the links, the number of reserved slots for the links
+// is increased automatically (unless the pointer argument is zero).
+//
+// In case the pointer argument is zero, indeed a value of zero will be
+// stored for the specified slot (unless j exceeds the current maximum).
+//
+// In principle any object derived from TObject can be referred to by this
+// mechanism.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
+// object, the current signal is automatically related to this AliTrack
+// (or derived) object.
+// 
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object. 
+
+ if (!fLinks && obj)
+ {
+  fLinks=new TObjArray(j);
+ }
+
+ if (j>fLinks->GetSize() && obj) fLinks->Expand(j);
+
+ if (j<=fLinks->GetSize())
+ {
+  fLinks->AddAt(obj,j-1);
+  if (obj) 
+  {
+   if (obj->InheritsFrom("AliTrack"))
+   {
+    AliTrack* t=(AliTrack*)obj;
+    t->AddSignal(*this);
+   }
+  }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetLink(Int_t j)
+{
+// Reset the link of the j-th (default j=1) slot.
+// Notes : The first link position is at j=1.
+//         j=0 ==> All links will be reset and the storage array deleted.
+//
+// In general the user should take care of properly clearing the corresponding
+// pointer here when the referred object is deleted.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// As such, the AliTrack destructor already takes care of clearing the corresponding
+// links from the various AliSignal slots for all the AliSignal objects that were
+// related to that AliTrack. 
+// So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
+// the user doesn't have to worry about clearing the corresponding AliTrack link from
+// the AliSignal object when the corresponding AliTrack object is deleted.
+ if (!fLinks || j<0) return;
+
+ TObject* obj=0;
+
+ if (j)
+ {
+  SetLink(obj,j);
+ }
+ else
+ {
+  delete fLinks;
+  fLinks=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetLink(TObject* obj)
+{
+// Reset the link of the all the slots referring to the specified object.
+//
+// In general the user should take care of properly clearing the corresponding
+// pointer here when the referred object is deleted.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// As such, the AliTrack destructor already takes care of clearing the corresponding
+// links from the various AliSignal slots for all the AliSignal objects that were
+// related to that AliTrack. 
+// So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
+// the user doesn't have to worry about clearing the corresponding AliTrack link from
+// the AliSignal object when the corresponding AliTrack object is deleted.
+ if (!fLinks || !obj) return;
+
+ Int_t nlinks=GetNlinks();
+ for (Int_t i=1; i<=nlinks; i++)
+ {
+  TObject* obj2=GetLink(i);
+  if (obj2==obj) ResetLink(i);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
 TObject* AliSignal::Clone(char* name)
 {
 // Make a deep copy of the current object and provide the pointer to the copy.
index faea5fdf684e15d3ddbfa10d911a17580aba1060..18ef6b39219631d5910963b97069dfd397bed57a 100644 (file)
@@ -19,7 +19,7 @@ class AliSignal : public TNamed,public AliPosition,public AliAttrib
   AliSignal();                                          // Default constructor
   virtual ~AliSignal();                                 // Destructor
   AliSignal(AliSignal& s);                              // Copy constructor
-  virtual TObject* Clone(char* name);                   // Make a deep copy and provide its pointer
+  virtual TObject* Clone(char* name="");                // Make a deep copy and provide its pointer
   virtual void SetSignal(Double_t sig,Int_t j=1);       // Store j-th signal value
   virtual void AddSignal(Double_t sig,Int_t j=1);       // Add value to j-th signal value
   virtual Float_t GetSignal(Int_t j=1,Int_t mode=0);    // Provide j-th (corrected) signal value
@@ -37,11 +37,17 @@ class AliSignal : public TNamed,public AliPosition,public AliAttrib
   TH1F* GetWaveform(Int_t j=1);                         // Provide pointer of the j-th waveform histogram 
   void ResetWaveform(Int_t j=1);                        // Reset the j-th waveform histogram 
   void DeleteWaveform(Int_t j=1);                       // Delete the j-th waveform histogram 
+  Int_t GetNlinks();                                    // Provide the number of specified linked objects
+  void SetLink(TObject* obj,Int_t j=1);                 // Link object to the j-th slot
+  TObject* GetLink(Int_t j=1);                          // Provide pointer of the object linked to the j-th slot
+  void ResetLink(Int_t j=1);                            // Reset the link of the j-th slot
+  void ResetLink(TObject* obj);                         // Reset the link to the specified object in all slots
 
  protected:
   TArrayF* fSignals;                           // Signal values
   TArrayF* fDsignals;                          // Errors on signal values
   TObjArray* fWaveforms;                       // The 1D histograms containing the signal waveforms
+  TObjArray* fLinks;                           // Pointers of objects related to the various slots
 
  ClassDef(AliSignal,9) // Generic handling of (extrapolated) detector signals.
 };
index 39c6e7e134e954b667acd2abe0a94e845d15e6a5..e28171e397906feca9737532a945d282d08559d3 100644 (file)
@@ -94,7 +94,7 @@
  
 ClassImp(AliTrack) // Class implementation to enable ROOT I/O
  
-AliTrack::AliTrack() : TObject(),Ali4Vector()
+AliTrack::AliTrack() : TNamed(),Ali4Vector()
 {
 // Default constructor
 // All variables initialised to 0
@@ -107,9 +107,7 @@ void AliTrack::Init()
 // Initialisation of pointers etc...
  fDecays=0;
  fSignals=0;
- fMasses=0;
- fDmasses=0;
- fPmasses=0;
+ fHypotheses=0;
  fBegin=0;
  fEnd=0;
  fImpactXY=0;
@@ -121,7 +119,17 @@ void AliTrack::Init()
 ///////////////////////////////////////////////////////////////////////////
 AliTrack::~AliTrack()
 {
-// Destructor to delete memory allocated for decay tracks array
+// Destructor to delete memory allocated for decay tracks array.
+// This destructor automatically cleares the pointer of this AliTrack
+// from all the link slots of the related AliSignal objects.
+
+ Int_t nsig=GetNsignals();
+ for (Int_t i=1; i<=nsig; i++)
+ {
+  AliSignal* s=GetSignal(i);
+  if (s) s->ResetLink(this);
+ }
  if (fDecays)
  {
   delete fDecays;
@@ -133,20 +141,10 @@ AliTrack::~AliTrack()
   delete fSignals;
   fSignals=0;
  }
- if (fMasses)
- {
-  delete fMasses;
-  fMasses=0;
- }
- if (fDmasses)
+ if (fHypotheses)
  {
-  delete fDmasses;
-  fDmasses=0;
- }
- if (fPmasses)
- {
-  delete fPmasses;
-  fPmasses=0;
+  delete fHypotheses;
+  fHypotheses=0;
  }
  if (fBegin)
  {
@@ -180,21 +178,13 @@ AliTrack::~AliTrack()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-AliTrack::AliTrack(AliTrack& t) : TObject(t),Ali4Vector(t)
+AliTrack::AliTrack(AliTrack& t) : TNamed(t),Ali4Vector(t)
 {
 // Copy constructor
  Init();
 
  fQ=t.fQ;
- fNdec=t.fNdec;
- fNsig=t.fNsig;
- fNmasses=t.fNmasses;
- if (fNmasses)
- {
-  fMasses=new TArrayD(*(t.fMasses));
-  fDmasses=new TArrayD(*(t.fDmasses));
-  fPmasses=new TArrayD(*(t.fPmasses));
- }
+ fProb=t.fProb;
  if (t.fBegin) fBegin=new AliPositionObj(*(t.fBegin));
  if (t.fEnd) fEnd=new AliPositionObj(*(t.fEnd));
  if (t.fImpactXY) fImpactXY=new AliPositionObj(*(t.fImpactXY));
@@ -207,26 +197,40 @@ AliTrack::AliTrack(AliTrack& t) : TObject(t),Ali4Vector(t)
  fCode=t.fCode;
  fParent=t.fParent;
 
- if (fNdec)
+ Int_t ndec=t.GetNdecay();
+ if (ndec)
  {
-  fDecays=new TObjArray(fNdec);
+  fDecays=new TObjArray(ndec);
   fDecays->SetOwner();
-  for (Int_t it=1; it<=fNdec; it++)
+  for (Int_t it=1; it<=ndec; it++)
   {
    AliTrack* tx=t.GetDecayTrack(it);
    fDecays->Add(new AliTrack(*tx));
   }
  }
 
- if (fNsig)
+ Int_t nsig=t.GetNsignals();
+ if (nsig)
  {
-  fSignals=new TObjArray(fNsig);
-  for (Int_t is=1; is<=fNsig; is++)
+  fSignals=new TObjArray(nsig);
+  for (Int_t is=1; is<=nsig; is++)
   {
    AliSignal* sx=t.GetSignal(is);
    fSignals->Add(sx);
   }
  }
+
+ Int_t nhyp=t.GetNhypotheses();
+ if (nhyp)
+ {
+  fHypotheses=new TObjArray(nhyp);
+  fHypotheses->SetOwner();
+  for (Int_t ih=1; ih<=nhyp; ih++)
+  {
+   AliTrack* tx=t.GetTrackHypothesis(ih);
+   fHypotheses->Add(new AliTrack(*tx));
+  }
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliTrack::Reset()
@@ -237,9 +241,7 @@ void AliTrack::Reset()
  fNdf=0;
  fUserId=0;
  fCode=0;
- fNdec=0;
- fNsig=0;
- fNmasses=0;
+ fProb=0;
  Double_t a[4]={0,0,0,0};
  SetVector(a,"sph");
  fParent=0;
@@ -254,20 +256,10 @@ void AliTrack::Reset()
   delete fSignals;
   fSignals=0;
  }
- if (fMasses)
- {
-  delete fMasses;
-  fMasses=0;
- }
- if (fDmasses)
- {
-  delete fDmasses;
-  fDmasses=0;
- }
- if (fPmasses)
+ if (fHypotheses)
  {
-  delete fPmasses;
-  fPmasses=0;
+  delete fHypotheses;
+  fHypotheses=0;
  }
  if (fBegin)
  {
@@ -337,16 +329,18 @@ void AliTrack::Data(TString f)
 // Provide track information within the coordinate frame f
  Double_t m=GetMass();
  Double_t dm=GetResultError();
- cout << " *AliTrack::Data* Id : " << fUserId << " Code : " << fCode
-      << " Mass : " << m << " error : " << dm << " Charge : " << fQ
-      << " Momentum : " << GetMomentum() << " Nmass hyp. : " << fNmasses
-      << " Ntracks : " << fNdec << " Nsignals : " << fNsig << endl;
- for (Int_t i=0; i<fNmasses; i++)
- {
-  cout << " Mass hypothesis " << (i+1) << " Mass : " << fMasses->At(i)
-       << " error : " << fDmasses->At(i) << " prob. : " << fPmasses->At(i)
-       << endl;
- }
+ const char* name=GetName();
+ const char* title=GetTitle();
+
+ cout << " *" << ClassName() << "::Data*";
+ if (strlen(name))  cout << " Name : " << GetName();
+ if (strlen(title)) cout << " Title : " << GetTitle();
+ cout << endl;
+ cout << " Id : " << fUserId << " Code : " << fCode
+      << " m : " << m << " dm : " << dm << " Charge : " << fQ
+      << " p : " << GetMomentum() << endl;
+ cout << " Nhypotheses : " << GetNhypotheses() << " Ndecay-tracks : " << GetNdecay()
+      << " Nsignals : " << GetNsignals() << endl;
  Ali4Vector::Data(f); 
 } 
 ///////////////////////////////////////////////////////////////////////////
@@ -358,7 +352,7 @@ void AliTrack::List(TString f)
 
  // Decay products of this track
  AliTrack* td; 
- for (Int_t id=1; id<=fNdec; id++)
+ for (Int_t id=1; id<=GetNdecay(); id++)
  {
   td=GetDecayTrack(id);
   if (td)
@@ -368,7 +362,7 @@ void AliTrack::List(TString f)
   }
   else
   {
-   cout << " *AliTrack::List* Error : No decay track present." << endl; 
+   cout << " *AliTrack::List* Error : Empty decay track slot." << endl; 
   }
  }
 } 
@@ -380,9 +374,27 @@ void AliTrack::ListAll(TString f)
  Data(f); // Information of the current track
  if (fBegin) { cout << " Begin-point :"; fBegin->Data(f); }
  if (fEnd)   { cout << " End-point   :"; fEnd->Data(f); }
- for (Int_t is=1; is<=GetNsignals(); is++)
+
+ Int_t nhyp=GetNhypotheses();
+ if (nhyp)
+ {
+  cout << " List of the " << nhyp << " track hypotheses : " << endl;
+  for (Int_t ih=1; ih<=nhyp; ih++)
+  {
+   AliTrack* tx=GetTrackHypothesis(ih);
+   if (tx) tx->Data(f);
+  }
+ }
+
+ Int_t nsig=GetNsignals();
+ if (nsig)
  {
-  ((AliSignal*)GetSignal(is))->Data(f);
+  cout << " List of the " << nsig << " related signals : " << endl;
+  for (Int_t is=1; is<=nsig; is++)
+  {
+   AliSignal* sx=GetSignal(is);
+   if (sx) sx->Data(f);
+  }
  }
 
  AliTrack* t=this;
@@ -400,9 +412,27 @@ void AliTrack::Dumps(AliTrack* t,Int_t n,TString f)
   {
    cout << "  ---Level " << n << " sec. track no. " << id << endl;
    td->Data(f); 
-   for (Int_t is=1; is<=td->GetNsignals(); is++)
+
+   Int_t nhyp=td->GetNhypotheses();
+   if (nhyp)
+   {
+    cout << " List of the " << nhyp << " track hypotheses : " << endl;
+    for (Int_t ih=1; ih<=nhyp; ih++)
+    {
+     AliTrack* tx=td->GetTrackHypothesis(ih);
+     if (tx) tx->Data(f);
+    }
+   }
+
+   Int_t nsig=td->GetNsignals();
+   if (nsig)
    {
-    ((AliSignal*)td->GetSignal(is))->Data(f);
+    cout << " List of the " << nsig << " related signals : " << endl;
+    for (Int_t is=1; is<=nsig; is++)
+    {
+     AliSignal* sx=td->GetSignal(is);
+     if (sx) sx->Data(f);
+    }
    }
 
    // Go for next decay level of this decay track recursively
@@ -410,7 +440,7 @@ void AliTrack::Dumps(AliTrack* t,Int_t n,TString f)
   }
   else
   {
-   cout << " *AliTrack::Dumps* Error : No decay track present." << endl; 
+   cout << " *AliTrack::Dumps* Error : Empty decay track slot." << endl; 
   }
  }
 } 
@@ -487,8 +517,6 @@ void AliTrack::Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms)
 // thcms  : cms theta decay angle (in rad.) of m1
 // phicms : cms phi decay angle (in rad.) of m1
  
- fNdec=2; // it's a 2-body decay
-
  Double_t M=GetMass();
  
 // Compute the 4-momenta of the decay products in the cms
@@ -541,7 +569,7 @@ void AliTrack::Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms)
   delete fDecays;
   fDecays=0;
  }
- fDecays=new TObjArray();
+ fDecays=new TObjArray(2);
  fDecays->SetOwner();
 
  fDecays->Add(new AliTrack);
@@ -555,7 +583,9 @@ void AliTrack::Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms)
 Int_t AliTrack::GetNdecay()
 {
 // Provide the number of decay produced tracks
- return fNdec;
+ Int_t ndec=0;
+ if (fDecays) ndec=fDecays->GetEntries();
+ return ndec;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliTrack* AliTrack::GetDecayTrack(Int_t j)
@@ -569,45 +599,71 @@ AliTrack* AliTrack::GetDecayTrack(Int_t j)
  }
  else
  {
-  if ((j >= 1) && (j <= fNdec))
+  if ((j >= 1) && (j <= GetNdecay()))
   {
    return (AliTrack*)fDecays->At(j-1);
   }
   else
   {
    cout << " *AliTrack* decay track number : " << j << " out of range."
-        << " Ndec = " << fNdec << endl;
+        << " Ndec = " << GetNdecay() << endl;
    return 0;  
   }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliTrack::RemoveDecays()
+{
+// Remove all decay tracks from this track.
+ if (fDecays)
+ {
+  delete fDecays;
+  fDecays=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
 void AliTrack::AddSignal(AliSignal& s)
 {
 // Relate an AliSignal object to this track.
- if (!fSignals) fSignals=new TObjArray();
- fNsig++;
+ if (!fSignals) fSignals=new TObjArray(1);
+
+ // Check if this signal is already stored for this track
+ Int_t nsig=GetNsignals();
+ for (Int_t i=0; i<nsig; i++)
+ {
+  if (&s==fSignals->At(i)) return; 
+ }
+
  fSignals->Add(&s);
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliTrack::RemoveSignal(AliSignal& s)
 {
-// Remove related AliSignal object to this track.
+// Remove related AliSignal object from this track.
  if (fSignals)
  {
   AliSignal* test=(AliSignal*)fSignals->Remove(&s);
-  if (test)
-  {
-   fNsig--;
-   fSignals->Compress();
-  }
+  if (test) fSignals->Compress();
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliTrack::RemoveSignals()
+{
+// Remove all related AliSignal objects from this track.
+ if (fSignals)
+ {
+  fSignals->Clear();
+  delete fSignals;
+  fSignals=0;
  }
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliTrack::GetNsignals()
 {
 // Provide the number of related AliSignals.
- return fNsig;
+ Int_t nsig=0;
+ if (fSignals) nsig=fSignals->GetEntries();
+ return nsig;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliSignal* AliTrack::GetSignal(Int_t j)
@@ -621,216 +677,179 @@ AliSignal* AliTrack::GetSignal(Int_t j)
  }
  else
  {
-  if ((j >= 1) && (j <= fNsig))
+  if ((j >= 1) && (j <= GetNsignals()))
   {
    return (AliSignal*)fSignals->At(j-1);
   }
   else
   {
    cout << " *AliTrack* signal number : " << j << " out of range."
-        << " Nsig = " << fNsig << endl;
+        << " Nsig = " << GetNsignals() << endl;
    return 0;
   }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::SetBeginPoint(AliPosition& p)
+void AliTrack::AddTrackHypothesis(AliTrack& t)
 {
-// Store the position of the track begin-point.
- if (!fBegin)
- {
-  fBegin=new AliPositionObj(p);
- }
- else
+// Relate a track hypothesis to this track.
+// Note : a private copy of the input track will be made via the Clone()
+//        facility.
+ if (!fHypotheses)
  {
-  fBegin->Load(p);
+  fHypotheses=new TObjArray(1);
+  fHypotheses->SetOwner();
  }
+ fHypotheses->Add(t.Clone());
 }
 ///////////////////////////////////////////////////////////////////////////
-AliPosition* AliTrack::GetBeginPoint()
+void AliTrack::AddTrackHypothesis(Double_t prob,Double_t m,Double_t dm)
 {
-// Provide the position of the track begin-point.
- return fBegin;
+// Add a track hypothesis by explicitly setting the mass and probability.
+// This will affect e.g. the hypothesis track's energy, since the momentum
+// and all other attributes will be copied from the current track.
+//
+// Input arguments :
+// ----------------- 
+// prob=probalility  m=mass value  dm=error on the mass value.
+// The default value for the mass error dm is 0.
+
+ AliTrack t(*this);
+ t.RemoveDecays();
+ t.RemoveTrackHypotheses();
+ t.RemoveSignals();
+ t.SetTitle("Mass hypothesis");
+ t.SetMass(m,dm);
+ t.SetProb(prob);
+ AddTrackHypothesis(t);
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::SetEndPoint(AliPosition& p)
+void AliTrack::RemoveTrackHypothesis(AliTrack& t)
 {
-// Store the position of the track end-point.
- if (!fEnd)
+// Remove the specified track hypothesis from this track.
+ if (fHypotheses)
  {
-  fEnd=new AliPositionObj(p);
- }
- else
- {
-  fEnd->Load(p);
+  AliTrack* test=(AliTrack*)fHypotheses->Remove(&t);
+  if (test) fHypotheses->Compress();
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-AliPosition* AliTrack::GetEndPoint()
+void AliTrack::RemoveTrackHypotheses()
 {
-// Provide the position of the track end-point.
- return fEnd;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliTrack::AddMassHypothesis(Double_t prob,Double_t m,Double_t dm)
-{
-// Add a mass hypothesis for this current track.
-// prob=probalility  m=mass value  dm=error on the mass value.
-// The default value for the mass error dm is 0.
- if (!fMasses) fMasses=new TArrayD();
- if (!fDmasses) fDmasses=new TArrayD();
- if (!fPmasses) fPmasses=new TArrayD();
-
- fNmasses++;
- fMasses->Set(fNmasses);
- fDmasses->Set(fNmasses);
- fPmasses->Set(fNmasses);
-
- fMasses->AddAt(m,fNmasses-1);
- fDmasses->AddAt(dm,fNmasses-1);
- fPmasses->AddAt(prob,fNmasses-1);
+// Remove all track hypotheses from this track.
+ if (fHypotheses)
+ {
+  delete fHypotheses;
+  fHypotheses=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliTrack::GetNMassHypotheses()
+Int_t AliTrack::GetNhypotheses()
 {
-// Provide the number of mass hypotheses for this track.
- return fNmasses;
+// Provide the number of track hypotheses.
+ Int_t nhyp=0;
+ if (fHypotheses) nhyp=fHypotheses->GetEntries();
+ return nhyp;
 }
 ///////////////////////////////////////////////////////////////////////////
-Double_t AliTrack::GetMassHypothesis(Int_t j)
+AliTrack* AliTrack::GetTrackHypothesis(Int_t j)
 {
-// Provide the mass of the jth hypothesis for this track.
-// Note : the first hypothesis is indicated by j=1.
+// Provide the j-th track hypothesis.
+// Note : j=1 denotes the first hypothesis.
 // Default : j=0 ==> Hypothesis with highest probability.
-// The error on the mass can be obtained by invoking GetResultError()
-// after invokation of GetMassHypothesis(j).
 
- Double_t m=0,dm=0,prob=0;
+ if (!fHypotheses) return 0;
+
+ Int_t nhyp=GetNhypotheses();
 
  // Check validity of index j
- if (j<0 || j>fNmasses)
+ if (j<0 || j>nhyp)
  {
-  cout << " *AliTrack::GetMassHypothesis* Invalid index j : " << j
-       << " Number of mass hypotheses : " << fNmasses << endl;
-  fDresult=0;
-  return 0;
- }
+   cout << " *AliTrack* hypothesis number : " << j << " out of range."
+        << " Nhyp = " << nhyp << endl;
+   return 0;
+ } 
 
- // Select mass hypothesis with highest probability
- if (j==0) 
+ AliTrack* t=0;
+
+ if (j==0) // Provide track hypothesis with highest probability
  {
-  if (fNmasses) 
+  Float_t prob=0;   
+  t=(AliTrack*)fHypotheses->At(0);
+  if (t) prob=t->GetProb();
+  Float_t probx=0;
+  for (Int_t ih=1; ih<nhyp; ih++)
   {
-   m=fMasses->At(0);
-   dm=fDmasses->At(0);
-   prob=fPmasses->At(0);
-   for (Int_t i=1; i<fNmasses; i++)
+   AliTrack* tx=(AliTrack*)fHypotheses->At(ih);
+   if (tx)
    {
-    if (fPmasses->At(i)>prob)
-    {
-     m=fMasses->At(i);
-     dm=fDmasses->At(i);
-    }
+    probx=tx->GetProb();
+    if (probx > prob) t=tx; 
    }
   }
-  fDresult=dm;
-  return m;  
+  return t;
+ }
+ else // Provide requested j-th track hypothesis
+ {
+  return (AliTrack*)fHypotheses->At(j-1);
  }
-
- // Provide data of requested mass hypothesis
- m=fMasses->At(j-1);
- fDresult=fDmasses->At(j-1);
- return m;
 }
 ///////////////////////////////////////////////////////////////////////////
-Double_t AliTrack::GetMassHypothesisProb(Int_t j)
+void AliTrack::SetBeginPoint(AliPosition& p)
 {
-// Provide the probability of the jth hypothesis for this track.
-// Note : the first hypothesis is indicated by j=1.
-// Default : j=0 ==> Hypothesis with highest probability.
-
- Double_t prob=0;
-
- // Check validity of index j
- if (j<0 || j>fNmasses)
+// Store the position of the track begin-point.
+ if (!fBegin)
  {
-  cout << " *AliTrack::GetMassHypothesisProb* Invalid index j : " << j
-       << " Number of mass hypotheses : " << fNmasses << endl;
-  return 0;
+  fBegin=new AliPositionObj(p);
  }
-
- // Select mass hypothesis with highest probability
- if (j==0) 
+ else
  {
-  if (fNmasses) 
-  {
-   prob=fPmasses->At(0);
-   for (Int_t i=1; i<fNmasses; i++)
-   {
-    if (fPmasses->At(i)>prob) prob=fPmasses->At(i);
-   }
-  }
-  return prob;  
+  fBegin->Load(p);
  }
-
- // Provide probability of requested mass hypothesis
- prob=fPmasses->At(j-1);
- return prob;
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::SetMass()
+AliPosition* AliTrack::GetBeginPoint()
 {
-// Set the mass and error to the value of the hypothesis with highest prob.
-
- Double_t m=0,dm=0,prob=0;
-
- // Select mass hypothesis with highest probability
- if (fNmasses) 
+// Provide the position of the track begin-point.
+ return fBegin;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliTrack::SetEndPoint(AliPosition& p)
+{
+// Store the position of the track end-point.
+ if (!fEnd)
  {
-  m=fMasses->At(0);
-  dm=fDmasses->At(0);
-  prob=fPmasses->At(0);
-  for (Int_t i=1; i<fNmasses; i++)
-  {
-   if (fPmasses->At(i)>prob)
-   {
-    m=fMasses->At(i);
-    dm=fDmasses->At(i);
-   }
-  }
-  SetMass(m,dm);
+  fEnd=new AliPositionObj(p);
  }
  else
  {
-  cout << " *AliTrack::SetMass()* No hypothesis present => No action." << endl;
+  fEnd->Load(p);
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::RemoveMassHypothesis(Int_t j)
+AliPosition* AliTrack::GetEndPoint()
+{
+// Provide the position of the track end-point.
+ return fEnd;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliTrack::SetMass()
 {
-// Remove the jth mass hypothesis for this track.
-// Note : the first hypothesis is indicated by j=1.
+// Set the mass and error to the value of the hypothesis with highest prob.
 
- if (j<=0 || j>fNmasses) // Check validity of index j
+ Double_t m=0,dm=0;
+
+ // Select mass hypothesis with highest probability
+ AliTrack* t=GetTrackHypothesis(0);
+ if (t) 
  {
-  cout << " *AliTrack::RemoveMassHypothesis* Invalid index j : " << j
-       << " Number of mass hypotheses : " << fNmasses << endl;
+  m=t->GetMass();
+  dm=t->GetResultError();
+  SetMass(m,dm);
  }
  else
  {
-  if (j != fNmasses)
-  {
-   fMasses->AddAt(fMasses->At(fNmasses-1),j-1);
-   fDmasses->AddAt(fDmasses->At(fNmasses-1),j-1);
-   fPmasses->AddAt(fPmasses->At(fNmasses-1),j-1);
-  }
-  fMasses->AddAt(0,fNmasses-1);
-  fDmasses->AddAt(0,fNmasses-1);
-  fPmasses->AddAt(0,fNmasses-1);
-  fNmasses--;
-  fMasses->Set(fNmasses);
-  fDmasses->Set(fNmasses);
-  fPmasses->Set(fNmasses);
+  cout << " *AliTrack::SetMass()* No hypothesis present => No action." << endl;
  }
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -905,26 +924,6 @@ Double_t AliTrack::GetMt()
  return mt;
 }
 ///////////////////////////////////////////////////////////////////////////
-Double_t AliTrack::GetMt(Int_t j)
-{
-// Provide transverse mass value w.r.t. z-axis and jth mass hypothesis.
-// Note : the first hypothesis is indicated by j=1.
-//        j=0 ==> Hypothesis with highest probability.
-// The error on the value can be obtained by GetResultError()
-// after invokation of GetMt(j).
- Double_t pt=GetPt();
- Double_t dpt=GetResultError();
- Double_t m=GetMassHypothesis(j);
- Double_t dm=GetResultError();
-
- Double_t mt=sqrt(pt*pt+m*m);
- Double_t dmt2=0;
- if (mt) dmt2=(pow((pt*dpt),2)+pow((m*dm),2))/(mt*mt);
-
- fDresult=sqrt(dmt2);
- return mt;
-}
-///////////////////////////////////////////////////////////////////////////
 Double_t AliTrack::GetRapidity()
 {
 // Provide rapidity value w.r.t. z-axis.
@@ -1123,3 +1122,33 @@ AliTrack* AliTrack::GetParentTrack()
  return fParent;
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliTrack::SetProb(Double_t prob)
+{
+// Set hypothesis probability for this track.
+ fProb=prob;
+}
+///////////////////////////////////////////////////////////////////////////
+Float_t AliTrack::GetProb()
+{
+// Provide the hypothesis probability for this track.
+ return fProb;
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliTrack::Clone(char* name)
+{
+// 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. AliJet to store either AliTrack objects or
+// objects derived from AliTrack via the AddTrack memberfunction, provided
+// these derived classes also have a proper Clone memberfunction. 
+
+ AliTrack* trk=new AliTrack(*this);
+ if (name)
+ {
+  if (strlen(name)) trk->SetName(name);
+ }
+ return trk;
+}
+///////////////////////////////////////////////////////////////////////////
index c913aecd1a4a458351e7ed5a0f66330b3a37d2ca..5276b5bc3a176599dbb6454b60fdf39db69bab5d 100644 (file)
 #include "AliBoost.h"
 #include "AliPositionObj.h"
  
-class AliTrack : public TObject,public Ali4Vector
+class AliTrack : public TNamed,public Ali4Vector
 {
  public:
   AliTrack();                           // Default constructor
   virtual ~AliTrack();                  // Destructor
   AliTrack(AliTrack& t);                // Copy constructor
+  virtual TObject* Clone(char* name="");// Make a deep copy and provide its pointer
   virtual void Reset();                 // Reset all values to 0
   void Set4Momentum(Ali4Vector& p);     // Set track 4-momentum
   void Set3Momentum(Ali3Vector& p);     // Set track 3-momentum
   void SetMass(Double_t m,Double_t dm=0); // Set particle mass and error
-  void SetMass();                       // Set mass and error to mass hypothesis with highest prob.
+  void SetMass();                       // Set mass and error to the values of the hypothesis with highest prob.
   void SetCharge(Float_t q);            // Set particle charge
   virtual void Data(TString f="car");   // Print track information for coord. frame f
   virtual void List(TString f="car");   // Print track and decay level 1 information for coord. frame f
@@ -38,25 +39,27 @@ class AliTrack : public TObject,public Ali4Vector
   void Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms); // Perform 2-body decay
   Int_t GetNdecay();                    // Provide number of decay products
   AliTrack* GetDecayTrack(Int_t j);     // Access to decay produced track number j
+  void RemoveDecays();                  // Remove all the decay products of this track
   void AddSignal(AliSignal& s);         // Relate an AliSignal to this track
   void RemoveSignal(AliSignal& s);      // Remove related AliSignal from this track
+  void RemoveSignals();                 // Remove all related AliSignals from this track
   Int_t GetNsignals();                  // Provide number of related AliSignals
   AliSignal* GetSignal(Int_t j);        // Access to the related AliSignal number j
   void SetBeginPoint(AliPosition& p);   // Set the track begin-point
   AliPosition* GetBeginPoint();         // Provide the track begin-point
   void SetEndPoint(AliPosition& p);     // Set the track end-point
   AliPosition* GetEndPoint();           // Provide the track end-point
-  void AddMassHypothesis(Double_t prob,Double_t m,Double_t dm=0); // Add mass hypothesis data
-  Int_t GetNMassHypotheses();                // Provide number of mass hypotheses
-  Double_t GetMassHypothesis(Int_t j=0);     // Provide mass of jth hypothesis 
-  Double_t GetMassHypothesisProb(Int_t j=0); // Provide prob. of jth mass hypothesis 
-  void RemoveMassHypothesis(Int_t j);        // Remove the jth mass hypothesis 
+  void AddTrackHypothesis(AliTrack& t); // Add track hypothesis
+  void AddTrackHypothesis(Double_t prob,Double_t m,Double_t dm=0); // Add track hypothesis with mass data
+  Int_t GetNhypotheses();               // Provide number of track hypotheses
+  AliTrack* GetTrackHypothesis(Int_t j=0);  // Provide the j-th track hypothesis 
+  void RemoveTrackHypothesis(AliTrack& t);  // Remove the specified track hypothesis 
+  void RemoveTrackHypotheses();         // Remove all track hypotheses 
   Double_t GetPt();                     // Provide trans. momentum w.r.t. z-axis
   Double_t GetPl();                     // Provide long. momentum w.r.t. z-axis
   Double_t GetEt();                     // Provide trans. energy w.r.t. z-axis
   Double_t GetEl();                     // Provide long. energy w.r.t. z-axis
   Double_t GetMt();                     // Provide trans. mass w.r.t. z-axis
-  Double_t GetMt(Int_t j);              // Provide trans. mass w.r.t. z-axis and jth mass hypothesis
   Double_t GetRapidity();               // Provide rapidity value w.r.t. z-axis
   void SetImpactPoint(AliPosition& p,TString q); // Set the impact-point in plane "q=0"
   AliPosition* GetImpactPoint(TString q);        // Provide the impact-point in plane "q=0"
@@ -72,21 +75,18 @@ class AliTrack : public TObject,public Ali4Vector
   Int_t GetParticleCode();              // Provide the user defined particle id code
   void SetParentTrack(AliTrack* t);     // Set pointer to the parent track
   AliTrack* GetParentTrack();           // Provide pointer to the parent track
+  void SetProb(Double_t prob);          // Set the hypothesis probability for this track
+  Float_t GetProb();                    // Provide the hypothesis probability for this track
 
  
  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
-  Int_t fNsig;               // The number of related AliSignals
   TObjArray* fSignals;       // The array of related AliSignals
+  TObjArray* fHypotheses;    // The array of track hypotheses
   AliPositionObj* fBegin;    // The begin-point of the track 
   AliPositionObj* fEnd;      // The end-point of the track 
-  Int_t fNmasses;            // The number of mass hypotheses
-  TArrayD* fMasses;          // The various mass hypotheses
-  TArrayD* fDmasses;         // The errors on the various masses
-  TArrayD* fPmasses;         // The probabilities of the various mass hypotheses
   AliPositionObj* fImpactXY; // The (extrapolated) impact-point in the plane z=0
   AliPositionObj* fImpactXZ; // The (extrapolated) impact-point in the plane y=0
   AliPositionObj* fImpactYZ; // The (extrapolated) impact-point in the plane x=0
@@ -96,10 +96,11 @@ class AliTrack : public TObject,public Ali4Vector
   Int_t fNdf;                // The number of degrees of freedom of the track fit
   Int_t fCode;               // The user defined particle id code
   AliTrack* fParent;         // Pointer to the parent track
+  Float_t fProb;             // Probability for this track as a hypothesis
 
  private:
   void Dumps(AliTrack* t,Int_t n,TString f); // Recursively print all decay levels
  
- ClassDef(AliTrack,7) // Handling of the attributes of a reconstructed particle track.
+ ClassDef(AliTrack,8) // Handling of the attributes of a reconstructed particle track.
 };
 #endif
index 7dedc41c101c7b7ee4faa77d9d9bedf2f7586016..e202dc9eb892f6206060b6b0314298a938ff6356 100644 (file)
@@ -440,6 +440,15 @@ 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. 
+//
+// 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);
@@ -453,7 +462,7 @@ void AliVertex::AddJet(AliJet& j,Int_t tracks)
 
  // Add the jet to the list 
  AliJet* jx=&j;
- if (fJetCopy) jx=new AliJet(j);
+ if (fJetCopy) jx=(AliJet*)j.Clone();
 
  if (jx)
  {
@@ -498,6 +507,14 @@ 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.
 //
+// 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);
@@ -511,7 +528,7 @@ void AliVertex::AddVertex(AliVertex& v,Int_t connect)
 
  // 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)
  {
@@ -970,3 +987,21 @@ void AliVertex::Draw(Int_t secs,Int_t cons,Int_t jets)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+TObject* AliVertex::Clone(char* name)
+{
+// 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;
+}
+///////////////////////////////////////////////////////////////////////////
index 5a69170badd5dd7210bccece3b25ca4ec0f5d9d3..7355c21761f1fd77e6b96e89219574e215519b62 100644 (file)
@@ -21,6 +21,7 @@ class AliVertex : public AliJet,public AliPosition
   AliVertex(Int_t n);                     // Create a vertex to hold initially n tracks
   virtual ~AliVertex();                   // Default destructor
   AliVertex(AliVertex& v);                // Copy constructor
+  virtual TObject* Clone(char* name="");  // Make a deep copy and provide its pointer
   virtual void SetOwner(Bool_t own=kTRUE);// Set ownership of all added objects
   virtual void Reset();                   // Reset all values and stored vertex and jet lists
   void ResetVertices();                   // Reset stored vertex list
@@ -65,6 +66,6 @@ class AliVertex : public AliJet,public AliPosition
  private:
   void Dumps(AliVertex* v,Int_t n,TString f); // Recursively print all sec. vertices
  
- ClassDef(AliVertex,6) // Creation and investigation of an AliVertex.
+ ClassDef(AliVertex,7) // Creation and investigation of an AliVertex.
 };
 #endif
index 3bf42749fbc2daacddbbd10002b809e1d7f43f10..e77c159580b4847298f0195f8f87d7d51775bd3e 100644 (file)
 22-nov-2003 NvE Support for various computation modes introduced in AliMath::Prob.
 23-nov-2003 NvE New memberfunctions GetBetaVector(), GetBeta() and GetGamma() introduced in Ali4Vector.
 03-dec-2003 NvE Message removed from AliEvent::GetDevice in case there are no devices present.
+05-dec-2003 NvE Memberfunction SetStable introduced in AliCollider for the user's convenience.
+08-dec-2003 NvE AliTrack derived from TNamed to enhance labeling flexibility and also specific
+                Clone memberfunction introduced to enable storage of derived objects in AliJet & co.
+                Also specific Clone memberfunctions introduced for AliJet, AliVertex and AliEvent and
+                for the already existing specific Clone memberfunctions the default argument was set
+                to the empty string "".
+15-dec-2003 NvE Datamembers fNdec and fNsig removed from AliTrack since these data are now retrieved
+                directly from the corresponding arrays.
+                Support for hypothesis probability introduced in AliTrack and old mass hypothesis
+                machinery extended to provide now full track hypotheses.
+18-dec-2003 NvE Support for object references from the various signal slots introduced in AliSignal.
+                Since this is mainly intended for "backward references" to AliTrack objects,
+                the AliTrack class has been slightly updated for this to provide pointer consistency
+                in case the corresponding AliTrack object is deleted.