22-jun-2006 NvE Linear track storage facility introduced in AliSignal to enable
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Jun 2006 15:09:34 +0000 (15:09 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Jun 2006 15:09:34 +0000 (15:09 +0000)
                a lightweight signal <-> track backward linking facility instead of
                the elaborate signal slot related links.
                Also the functionality of AliTrack::AddSignal extended with specific modes.
                Double_t replaced by Double32_t in Ali3Vector.h, Ali4Vector.h and AliBoost.h
                and fDresult suppressed for I/O streaming. This will reduce the produced
                output filesize.
22-jun-2006 NvE Bi-directional links for signals <-> tracks set via the new lightweight
                AliSignal::AddTrack facility instead of AddLink in IceF2k.
                Also default split level set to 0 in IceF2k to minimise file size and
                I/O time.
23-jun-2006 NvE New lightweight AliSignal::AddTrack facility used in IceLinefit and IceDwalk.

13 files changed:
RALICE/Ali3Vector.h
RALICE/Ali4Vector.h
RALICE/AliBoost.h
RALICE/AliSignal.cxx
RALICE/AliSignal.h
RALICE/AliTrack.cxx
RALICE/AliTrack.h
RALICE/history.txt
RALICE/icepack/IceDwalk.cxx
RALICE/icepack/IceLinefit.cxx
RALICE/icepack/history.txt
RALICE/icepack/iceconvert/IceF2k.cxx
RALICE/icepack/iceconvert/history.txt

index 6a22586..8fcfabd 100644 (file)
@@ -49,10 +49,10 @@ class Ali3Vector
   virtual Double_t GetOpeningAngle(Ali3Vector& q,TString u="rad"); // Provide opening angle with q in units u
 
  protected:
-  Double_t fV,fTheta,fPhi;    // Vector in spherical coordinates
-  Double_t fDx,fDy,fDz;       // Errors on Cartesian coordinates
-  Double_t fDresult;          // Error on scalar result (e.g. norm or dotproduct)
+  Double32_t fV,fTheta,fPhi;    // Vector in spherical coordinates
+  Double32_t fDx,fDy,fDz;       // Errors on Cartesian coordinates
+  Double32_t fDresult;          //! Error on scalar result (e.g. norm or dotproduct)
 
- ClassDef(Ali3Vector,10) // Handling of 3-vectors in various reference frames.
+ ClassDef(Ali3Vector,11) // Handling of 3-vectors in various reference frames.
 };
 #endif
index db238a9..ea10191 100644 (file)
@@ -59,16 +59,16 @@ class Ali4Vector
   virtual Double_t GetOpeningAngle(Ali3Vector& q,TString u="rad"); // Opening angle with 3-vector q in units u
 
  protected:
-  Double_t fV2;      // The Lorentz invariant (v^i*v_i)
-  Double_t fV0;      // The scalar part
-  Ali3Vector fV;     // The 3-vector part
-  Double_t fDv2;     // The error on the Lorentz invariant
-  Double_t fDv0;     // The error on the scalar part
-  Double_t fDresult; // The error on the scalar result of an operation (e.g. dotproduct) 
-  Int_t fScalar;     // Flag denoting scalar mode
+  Double32_t fV2;      // The Lorentz invariant (v^i*v_i)
+  Double32_t fV0;      // The scalar part
+  Ali3Vector fV;       // The 3-vector part
+  Double32_t fDv2;     // The error on the Lorentz invariant
+  Double32_t fDv0;     // The error on the scalar part
+  Double32_t fDresult; //! The error on the scalar result of an operation (e.g. dotproduct) 
+  Int_t fScalar;       // Flag denoting scalar mode
   Double_t GetScaTrans(); // Provide "transverse value" of scalar part w.r.t. z-axis
   Double_t GetScaLong();  // Provide "longitudinal value" of scalar part w.r.t. z-axis
 
- ClassDef(Ali4Vector,10) // Handling of Lorentz 4-vectors in various reference frames.
+ ClassDef(Ali4Vector,11) // Handling of Lorentz 4-vectors in various reference frames.
 };
 #endif
index e23f935..dfe442e 100644 (file)
@@ -28,11 +28,11 @@ class AliBoost : public TObject
   Double_t GetResultError() const;        // Provide error on scalar result
  
  protected:
-  Ali3Vector fBeta;  // The beta 3-vector
-  Double_t fGamma;   // The gamma factor
-  Double_t fDgamma;  // Error on the gamma value
-  Double_t fDresult; // Error on scalar result
+  Ali3Vector fBeta;    // The beta 3-vector
+  Double32_t fGamma;   // The gamma factor
+  Double32_t fDgamma;  // Error on the gamma value
+  Double32_t fDresult; //! Error on scalar result
  
- ClassDef(AliBoost,4) // Perform various Lorentz transformations.
+ ClassDef(AliBoost,5) // Perform various Lorentz transformations.
 };
 #endif
index 7c11df7..f96b192 100644 (file)
@@ -126,6 +126,7 @@ AliSignal::AliSignal() : TNamed(),AliPosition(),AliAttrib()
  fWaveforms=0;
  fLinks=0;
  fDevice=0;
+ fTracks=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliSignal::~AliSignal()
@@ -148,19 +149,19 @@ AliSignal::~AliSignal()
  }
  if (fLinks)
  {
+  delete fLinks;
+  fLinks=0;
+ }
+ if (fTracks)
+ {
   // Remove this signal from all related tracks
-  for (Int_t i=1; i<=fLinks->GetNobjects(); i++)
+  for (Int_t i=1; i<=GetNtracks(); i++)
   {
-   TObject* obj=fLinks->GetObject(i);
-   if (!obj) continue;
-   if (obj->InheritsFrom("AliTrack"))
-   {
-    AliTrack* tx=(AliTrack*)obj;
-    tx->RemoveSignal(*this);
-   }
+   AliTrack* tx=GetTrack(i);
+   if (tx) tx->RemoveSignal(*this,0);
   }
-  delete fLinks;
-  fLinks=0;
+  delete fTracks;
+  fTracks=0;
  }
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -171,6 +172,7 @@ AliSignal::AliSignal(const AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
  fDsignals=0;
  fWaveforms=0;
  fLinks=0;
+ fTracks=0;
 
  // Don't copy the owning device pointer for the copy
  fDevice=0;
@@ -209,6 +211,17 @@ AliSignal::AliSignal(const AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
   TObject* obj=s.GetLink(slot,pos);
   if (obj) SetLink(obj,slot,pos); 
  }
+
+ Int_t ntk=s.GetNtracks();
+ if (ntk)
+ {
+  fTracks=new TObjArray(ntk);
+  for (Int_t it=1; it<=ntk; it++)
+  {
+   AliTrack* tx=s.GetTrack(it);
+   fTracks->Add(tx);
+  }
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::Reset(Int_t mode)
@@ -261,6 +274,12 @@ void AliSignal::Reset(Int_t mode)
 
  if (fLinks) fLinks->Reset();
  fDevice=0;
+
+ if (fTracks)
+ {
+  delete fTracks;
+  fTracks=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::ResetSignals(Int_t mode)
@@ -704,6 +723,9 @@ void AliSignal::Data(TString f,TString u) const
  // Provide an overview of the stored waveforms
  ListWaveform(-1);
 
+ // Provide an overview of the associated tracks
+ ListTrack(-1);
+
  // Provide an overview of all the data and attribute slots
  List(-1);
 } 
@@ -745,7 +767,7 @@ void AliSignal::List(Int_t j) const
  Int_t nvalues=GetNvalues();
  Int_t nerrors=GetNerrors();
  Int_t nlinkslots=0;
- if (fLinks) nlinkslots=fLinks->GetMaxColumn();
+ if (GetNlinks()) nlinkslots=fLinks->GetMaxColumn();
  Int_t ncalibs=GetNcalflags();
  Int_t ncalfuncs=GetNcalfuncs();
  Int_t ndecalfuncs=GetNdecalfuncs();
@@ -912,6 +934,77 @@ void AliSignal::ListWaveform(Int_t j) const
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliSignal::ListTrack(Int_t j) const
+{
+// Provide information for the j-th associated track.
+// The first associated track is at j=1.
+// In case j=0 (default) the info of all associated tracks will be listed.
+// In case j=-1 the info of all tracks will be listed, but the header
+// information will be suppressed.
+
+ if (j<-1) 
+ {
+  cout << " *AliSignal::ListTrack* Invalid argument j = " << j << endl;
+  return;
+ }
+
+ if (j != -1)
+ {
+  const char* name=GetName();
+  const char* title=GetTitle();
+
+  cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
+  if (strlen(name))  cout << " Name : " << name;
+  if (strlen(title)) cout << " Title : " << title;
+  cout << endl;
+  if (fDevice)
+  {
+   const char* devname=fDevice->GetName();
+   const char* devtitle=fDevice->GetTitle();
+   cout << "   Owned by device : " << fDevice->ClassName();
+   if (strlen(devname))  cout << " Name : " << devname;
+   if (strlen(devtitle)) cout << " Title : " << devtitle;
+   cout << endl;
+  }
+ }
+
+ Int_t n=GetNtracks();
+ AliTrack* tx=0;
+
+ if (j<=0)
+ {
+  for (Int_t i=1; i<=n; i++)
+  {
+   tx=GetTrack(i);
+   if (tx)
+   {
+    const char* txname=tx->GetName();
+    const char* txtitle=tx->GetTitle();
+    cout << "    Track " << i << " : " << tx->ClassName() << " Id : " << tx->GetId();
+    if (strlen(txname))  cout << " Name : " << txname;
+    if (strlen(txtitle)) cout << " Title : " << txtitle;
+    cout << endl;
+   }
+  }
+ }
+ else
+ {
+  if (j<=n)
+  {
+   tx=GetTrack(j);
+   if (tx)
+   {
+    const char* txnamej=tx->GetName();
+    const char* txtitlej=tx->GetTitle();
+    cout << "    Track " << j << " : " << tx->ClassName() << " Id : " << tx->GetId();
+    if (strlen(txnamej))  cout << " Name : " << txnamej;
+    if (strlen(txtitlej)) cout << " Title : " << txtitlej;
+    cout << endl;
+   }
+  }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
 Int_t AliSignal::GetNvalues() const
 {
 // Provide the number of values for this signal.
@@ -1137,10 +1230,12 @@ Int_t AliSignal::GetNlinks(TObject* obj,Int_t j) const
   return 0;
  }
 
+ if (!fLinks) return 0;
+
  Int_t n=0;
  if (!j)
  {
-  if (fLinks) n=fLinks->GetNrefs(obj);
+  n=fLinks->GetNrefs(obj);
  }
  else
  {
@@ -1217,6 +1312,14 @@ void AliSignal::SetLink(TObject* obj,Int_t j,Int_t k)
 // 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.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
 // 
 // Please also have a look at the docs of the memberfunction ResetLink()
 // to prevent the situation of stored pointers to non-existent object. 
@@ -1232,7 +1335,7 @@ void AliSignal::SetLink(TObject* obj,Int_t j,Int_t k)
   if (obj->InheritsFrom("AliTrack"))
   {
    AliTrack* t=(AliTrack*)obj;
-   t->AddSignal(*this);
+   AddTrack(*t,1);
   }
  }
 }
@@ -1249,6 +1352,29 @@ void AliSignal::SetLink(TObject* obj,TString name,Int_t k)
 // defined and/or when this procedure is invoked many times.
 // In such cases it is preferable to use indexed addressing in the user code
 // either directly or via a few invokations of GetSlotIndex().
+//
+// In case the pointer argument is zero, indeed a value of zero will be
+// stored at the specified position (k) for the specified slotname.
+//
+// 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.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
+// 
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object. 
 
  Int_t j=GetSlotIndex(name);
  if (j>0) SetLink(obj,j,k);
@@ -1278,6 +1404,14 @@ void AliSignal::AddLink(TObject* obj,Int_t j)
 // 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.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
 // 
 // Please also have a look at the docs of the memberfunction ResetLink()
 // to prevent the situation of stored pointers to non-existent object. 
@@ -1312,6 +1446,29 @@ void AliSignal::AddLink(TObject* obj,TString name)
 // defined and/or when this procedure is invoked many times.
 // In such cases it is preferable to use indexed addressing in the user code
 // either directly or via a few invokations of GetSlotIndex().
+//
+// In case the pointer argument is zero, indeed a value of zero will be
+// stored at the first free position of the specified slotname.
+//
+// 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.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
+// 
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object. 
 
  Int_t j=GetSlotIndex(name);
  if (j>0) AddLink(obj,j);
@@ -1363,7 +1520,14 @@ void AliSignal::ResetLink(TString name,Int_t k)
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
 {
-// Reset single or multiple link(s) according to user specified selections.
+// Reset single or multiple slot link(s) according to user specified selections.
+//
+// IMPORTANT NOTE :
+// ----------------
+// This facility only acts on the slot related links.
+// The global track reference list will not be affected.
+// To remove all references to AliTrack (or derived) objects, please
+// use the RemoveTrack() of RemoveTracks() memberfunctions.
 //
 // A link is only reset if the stored reference matches the argument "obj".
 // In case obj=0 no check on the matching of the stored reference is performed
@@ -1419,7 +1583,14 @@ void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
 ///////////////////////////////////////////////////////////////////////////
 void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
 {
-// Reset single or multiple link(s) according to user specified selections.
+// Reset single or multiple slot link(s) according to user specified selections.
+//
+// IMPORTANT NOTE :
+// ----------------
+// This facility only acts on the slot related links.
+// The global track reference list will not be affected.
+// To remove all references to AliTrack (or derived) objects, please
+// use the RemoveTrack() of RemoveTracks() memberfunctions.
 //
 // A link is only reset if the stored reference matches the argument "obj".
 // In case obj=0 no check on the matching of the stored reference is performed
@@ -1435,6 +1606,18 @@ void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
 // defined and/or when this procedure is invoked many times.
 // In such cases it is preferable to use indexed addressing in the user code
 // either directly or via a few invokations of GetSlotIndex().
+//
+// 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.
 
  Int_t j=GetSlotIndex(name);
  if (j>0) ResetLinks(obj,j,k);
@@ -1609,6 +1792,149 @@ AliDevice* AliSignal::GetDevice() const
  return (AliDevice*)fDevice;
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliSignal::AddTrack(AliTrack& t,Int_t mode)
+{
+// Relate an AliTrack object to this signal.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the tracks of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// mode = 0 : Only the reference to the specified track is stored in
+//            the current signal, without storing the (backward) reference
+//            to this signal into the AliTrack structure. 
+//        1 : The (backward) reference to the current signal is also automatically
+//            stored into the AliTrack (or derived) object specified in the
+//            input argument.
+//
+// The default is mode=1.
+
+ if (!fTracks) fTracks=new TObjArray(1);
+
+ // Check if this track is already stored for this signal
+ Int_t ntk=GetNtracks();
+ for (Int_t i=0; i<ntk; i++)
+ {
+  if (&t==fTracks->At(i)) return; 
+ }
+
+ fTracks->Add(&t);
+ if (mode==1) t.AddSignal(*this,0);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::RemoveTrack(AliTrack& t,Int_t mode)
+{
+// Remove related AliTrack object from this signal.
+// Also all references (if any) to this track in the slot links area
+// are removed.
+//
+// mode = 0 : All references to the specified track are removed from
+//            the current signal, without removing the (backward) reference
+//            to this signal from the AliTrack structure. 
+//        1 : The (backward) reference to the current signal is also automatically
+//            removed from the AliTrack (or derived) object specified in the
+//            input argument.
+//
+// The default is mode=1.
+
+ if (fTracks)
+ {
+  AliTrack* test=(AliTrack*)fTracks->Remove(&t);
+  if (test) fTracks->Compress();
+ }
+
+ ResetLinks(&t);
+
+ if (mode==1) t.RemoveSignal(*this,0);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::RemoveTracks(Int_t mode)
+{
+// Remove all related AliTrack objects from this signal.
+// Also all references (if any) to the related tracks in the slot links area
+// are removed.
+//
+// mode = 0 : All track references are removed from the current signal,
+//            without removing the (backward) references to this signal from
+//            the corresponding AliTrack objects. 
+//        1 : The (backward) references to the current signal are also automatically
+//            removed from the corresponding AliTrack (or derived) objects.
+//
+// The default is mode=1.
+ if (!fTracks) return;
+
+ Int_t ntk=GetNtracks();
+ for (Int_t i=0; i<ntk; i++)
+ {
+  AliTrack* tx=(AliTrack*)fTracks->At(i);
+  if (tx)
+  {
+   ResetLinks(tx);
+   if (mode==1) tx->RemoveSignal(*this,0);
+  }
+ }
+
+ delete fTracks;
+ fTracks=0;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNtracks(AliTrack* t) const
+{
+// Provide the number of related AliTracks.
+// In case an AliTrack pointer is specified as input argument,
+// the number returned will be the number of occurrences (i.e. 0 or 1)
+// for that specified track.
+// By default t=0, which implies that just the number of all associated
+// tracks will be returned.
+
+ if (!fTracks) return 0;
+
+ Int_t ntk=fTracks->GetEntries();
+
+ if (!t) return ntk;
+
+ for (Int_t i=0; i<ntk; i++)
+ {
+  AliTrack* tx=(AliTrack*)fTracks->At(i);
+  if (tx==t) return 1;
+ }
+
+ return 0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliTrack* AliSignal::GetTrack(Int_t j) const
+{
+// Provide the related AliTrack number j.
+// Note : j=1 denotes the first track.
+
+ if (!fTracks) return 0;
+
+ if ((j >= 1) && (j <= GetNtracks()))
+ {
+  return (AliTrack*)fTracks->At(j-1);
+ }
+ else
+ {
+  cout << " *AliSignal* track number : " << j << " out of range."
+       << " Ntk = " << GetNtracks() << endl;
+  return 0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliTrack* AliSignal::GetIdTrack(Int_t id) const
+{
+// Return the track with user identifier "id" of this signal
+ if (!fTracks) return 0;
+
+ AliTrack* tx=0;
+ for (Int_t i=0; i<GetNtracks(); i++)
+ {
+  tx=(AliTrack*)fTracks->At(i);
+  if (id == tx->GetId()) return tx;
+ }
+ return 0; // No matching id found
+}
+///////////////////////////////////////////////////////////////////////////
 TObject* AliSignal::Clone(const char* name) const
 {
 // Make a deep copy of the current object and provide the pointer to the copy.
index 6d7f77e..bfa126a 100644 (file)
@@ -16,6 +16,7 @@
 #include "AliObjMatrix.h"
 
 class AliDevice;
+class AliTrack;
 
 class AliSignal : public TNamed,public AliPosition,public AliAttrib
 {
@@ -41,6 +42,7 @@ class AliSignal : public TNamed,public AliPosition,public AliAttrib
   virtual void List(Int_t j=0) const;                           // Print signal info for the j-th (all) slot(s)
   virtual void List(TString name) const;                        // Print signal info for the name-specified slot
   void ListWaveform(Int_t j=0) const;                           // Print info for the j-th (all) waveform(s)
+  void ListTrack(Int_t j=0) const;                              // Print info for the j-th (all) assoc. track(s)
   Int_t GetNvalues() const;                                     // Provide the number of signal values
   Int_t GetNerrors() const;                                     // Provide the number of specified errors
   Int_t GetNwaveforms() const;                                  // Provide the number of specified waveforms
@@ -72,6 +74,12 @@ class AliSignal : public TNamed,public AliPosition,public AliAttrib
   Int_t GetSwapMode() const;                                    // Provide swapmode flag for the link storage
   void SetDevice(TObject* dev);                                 // Store pointer to the device that owns this signal
   AliDevice* GetDevice() const;                                 // Provide pointer to the owning device 
+  void AddTrack(AliTrack& t,Int_t mode=1);                      // Relate an AliTrack to this signal
+  void RemoveTrack(AliTrack& t,Int_t mode=1);                   // Remove related AliTrack from this signal
+  void RemoveTracks(Int_t mode=1);                              // Remove all related AliTracks from this signal
+  Int_t GetNtracks(AliTrack* t=0) const;                        // Provide number of related AliTracks
+  AliTrack* GetTrack(Int_t j) const;                            // Access to the related AliTrack number j
+  AliTrack* GetIdTrack(Int_t id) const;                         // Access to the related AliTrack with ID=id
 
  protected:
   TArrayF* fSignals;                           // Signal values
@@ -79,7 +87,8 @@ class AliSignal : public TNamed,public AliPosition,public AliAttrib
   TObjArray* fWaveforms;                       // The 1D histograms containing the signal waveforms
   AliObjMatrix* fLinks;                        // Pointers of objects related to the various slots
   TObject* fDevice;                            // Pointer to the device that owns this signal
+  TObjArray* fTracks;                          // Pointers to associated tracks
 
- ClassDef(AliSignal,14) // Generic handling of (extrapolated) detector signals.
+ ClassDef(AliSignal,15) // Generic handling of (extrapolated) detector signals.
 };
 #endif
index 08caaae..a3d112a 100644 (file)
@@ -123,13 +123,13 @@ void AliTrack::Init()
 AliTrack::~AliTrack()
 {
 // 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.
+// This destructor automatically cleares all references to this AliTrack
+// from all the related AliSignal objects.
  Int_t nsig=GetNsignals();
  for (Int_t i=1; i<=nsig; i++)
  {
   AliSignal* s=GetSignal(i);
-  if (s) s->ResetLinks(this);
+  if (s) s->RemoveTrack(*this,0);
  }
  
  if (fDecays)
@@ -139,7 +139,6 @@ AliTrack::~AliTrack()
  }
  if (fSignals)
  {
-  fSignals->Clear();
   delete fSignals;
   fSignals=0;
  }
@@ -272,7 +271,6 @@ void AliTrack::Reset()
  }
  if (fSignals)
  {
-  fSignals->Clear();
   delete fSignals;
   fSignals=0;
  }
@@ -718,9 +716,19 @@ void AliTrack::RemoveDecays()
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::AddSignal(AliSignal& s)
+void AliTrack::AddSignal(AliSignal& s,Int_t mode)
 {
 // Relate an AliSignal object to this track.
+//
+// mode = 0 : Only the reference to the specified signal is stored in
+//            the current track, without storing the (backward) reference
+//            to this track into the AliSignal structure. 
+//        1 : The (backward) reference to the current track is also automatically
+//            stored into the AliSignal (or derived) object specified in the
+//            input argument.
+//
+// The default is mode=0.
+
  if (!fSignals) fSignals=new TObjArray(1);
 
  // Check if this signal is already stored for this track
@@ -731,27 +739,53 @@ void AliTrack::AddSignal(AliSignal& s)
  }
 
  fSignals->Add(&s);
+ if (mode==1) s.AddTrack(*this,0);
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::RemoveSignal(AliSignal& s)
+void AliTrack::RemoveSignal(AliSignal& s,Int_t mode)
 {
 // Remove related AliSignal object from this track.
+//
+// mode = 0 : Only the reference to the specified signal is removed from
+//            the current track, without removing the (backward) reference(s)
+//            to this track from the AliSignal structure. 
+//        1 : The (backward) reference(s) to the current track are also automatically
+//            removed from the AliSignal (or derived) object specified in the
+//            input argument.
+//
+// The default is mode=1.
+
  if (fSignals)
  {
   AliSignal* test=(AliSignal*)fSignals->Remove(&s);
   if (test) fSignals->Compress();
  }
+ if (mode==1) s.RemoveTrack(*this,0);
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliTrack::RemoveSignals()
+void AliTrack::RemoveSignals(Int_t mode)
 {
 // Remove all related AliSignal objects from this track.
- if (fSignals)
+//
+// mode = 0 : All signal references are removed from the current track,
+//            without removing the (backward) references to this track from
+//            the corresponding AliSignal objects.
+//        1 : The (backward) references to the current track are also automatically
+//            removed from the corresponding AliSignal (or derived) objects.
+//
+// The default is mode=1.
+
+ if (!fSignals) return;
+
+ Int_t ns=GetNsignals();
+ for (Int_t i=0; i<ns; i++)
  {
-  fSignals->Clear();
-  delete fSignals;
-  fSignals=0;
+  AliSignal* sx=(AliSignal*)fSignals->At(i);
+  if (sx && mode==1) sx->RemoveTrack(*this,0);
  }
+
+ delete fSignals;
+ fSignals=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliTrack::GetNsignals() const
index 7e687e9..b34c03a 100644 (file)
@@ -42,9 +42,9 @@ class AliTrack : public TNamed,public Ali4Vector
   Int_t GetNdecay() const;                // Provide number of decay products
   AliTrack* GetDecayTrack(Int_t j) const; // 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
+  void AddSignal(AliSignal& s,Int_t mode=0);    // Relate an AliSignal to this track
+  void RemoveSignal(AliSignal& s,Int_t mode=1); // Remove related AliSignal from this track
+  void RemoveSignals(Int_t mode=1);             // Remove all related AliSignals from this track
   Int_t GetNsignals() const;              // Provide number of related AliSignals
   AliSignal* GetSignal(Int_t j) const;    // Access to the related AliSignal number j
   void SetBeginPoint(AliPosition& p);     // Set the track begin-point
@@ -117,6 +117,6 @@ class AliTrack : public TNamed,public Ali4Vector
  private:
   void Dumps(AliTrack* t,Int_t n,TString f,TString u); // Recursively print all decay levels
  
- ClassDef(AliTrack,17) // Handling of the attributes of a reconstructed particle track.
+ ClassDef(AliTrack,18) // Handling of the attributes of a reconstructed particle track.
 };
 #endif
index c15a983..23a5881 100644 (file)
                 AliTrack and AliJet.
                 Also compiler warnings activated for overloaded virtuals in installation
                 script for AMD Athlon in the /scripts sub-directory.
+22-jun-2006 NvE Linear track storage facility introduced in AliSignal to enable
+                a lightweight signal <-> track backward linking facility instead of
+                the elaborate signal slot related links. 
+                Also the functionality of AliTrack::AddSignal extended with specific modes.
+                Double_t replaced by Double32_t in Ali3Vector.h, Ali4Vector.h and AliBoost.h
+                and fDresult suppressed for I/O streaming. This will reduce the produced
+                output filesize.
index 093f3c4..9da005a 100644 (file)
@@ -801,7 +801,7 @@ void IceDwalk::Exec(Option_t* opt)
    for (Int_t is=1; is<=tx->GetNsignals(); is++)
    {
     sx1=tx->GetSignal(is);
-    if (sx1) sx1->AddLink(trk);
+    if (sx1) sx1->AddTrack(*trk);
    }
   }
 
index 03775e2..6ee1191 100644 (file)
@@ -227,7 +227,7 @@ void IceLinefit::Exec(Option_t* opt)
  for (Int_t i=0; i<nused; i++)
  {
   sx=(AliSignal*)hits.At(i);
-  if (sx) sx->AddLink(trk);
+  if (sx) sx->AddTrack(*trk);
  } 
 }
 ///////////////////////////////////////////////////////////////////////////
index 805dc6a..859b86c 100644 (file)
@@ -67,3 +67,4 @@
                 compiler error with new ROOT 5.11 version.
 10-may-2006 NvE Compiler warnings activated for overloaded virtuals in installation
                 script for AMD Athlon in the /scripts sub-directory.
+23-jun-2006 NvE New lightweight AliSignal::AddTrack facility used in IceLinefit and IceDwalk.
index 6979f0d..6e36e2c 100644 (file)
@@ -77,7 +77,7 @@
 // q.SetPrintFreq(1);
 //
 // // Split level for the output structures
-// q.SetSplitLevel(2);
+// q.SetSplitLevel(0);
 //
 // // Buffer size for the output structures
 // q.SetBufferSize(32000);
@@ -143,9 +143,9 @@ ClassImp(IceF2k) // Class implementation to enable ROOT I/O
 IceF2k::IceF2k(const char* name,const char* title) : AliJob(name,title)
 {
 // Default constructor.
-// By default maxevent=-1, split=99, bsize=32000, printfreq=1.
+// By default maxevent=-1, split=0, bsize=32000, printfreq=1.
 
- fSplit=99;
+ fSplit=0;
  fBsize=32000;
  fMaxevt=-1;
  fPrintfreq=1;
@@ -214,7 +214,7 @@ void IceF2k::SetPrintFreq(Int_t f)
 void IceF2k::SetSplitLevel(Int_t split)
 {
 // Set the split level for the ROOT data file.
-// split=99 is the default initialisation in the constructor.
+// split=0 is the default initialisation in the constructor.
  if (split>=0) fSplit=split;
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -1137,7 +1137,7 @@ void IceF2k::PutHits()
   {
    tx=evt->GetIdTrack(tid); // Reco tracks
    if (!tx) tx=evt->GetIdTrack(-tid); // MC tracks
-   if (tx) sx->AddLink(tx);
+   if (tx) sx->AddTrack(*tx);
   }
   else
   {
@@ -1221,7 +1221,7 @@ void IceF2k::PutHits()
     if (fEvent.fit_uses[k].useid != hypx->GetId()) continue;
     hid=fEvent.fit_uses[k].hitid;
     sx=evt->GetIdHit(hid,"IceAOM");
-    if (sx) sx->AddLink(hypx);
+    if (sx) sx->AddTrack(*hypx);
    }
   }
  }
index b82132e..1de41de 100644 (file)
                 the ATWD histograms.
                 Also modification made in IceF2k::PutHits() to correctly obtain the ADC values
                 for secondary etc... hits in the same OM.
+22-jun-2006 NvE Bi-directional links for signals <-> tracks set via the new lightweight
+                AliSignal::AddTrack facility instead of AddLink in IceF2k. 
+                Also default split level set to 0 in IceF2k to minimise file size and
+                I/O time.
                  
 
+