NvE Some cosmetics in the output of AliSignal::List.
[u/mrichter/AliRoot.git] / RALICE / AliSignal.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 // $Id$
17
18 ///////////////////////////////////////////////////////////////////////////
19 // Class AliSignal
20 // Generic handling of (extrapolated) detector signals.
21 //
22 // Note :
23 // ------
24 // Signal positions (r) and reference frames (f) are specified via
25 // SetPosition(r,f) under the following conventions :
26 //
27 // f="car" ==> r is Cartesian   (x,y,z)
28 // f="sph" ==> r is Spherical   (r,theta,phi)
29 // f="cyl" ==> r is Cylindrical (rho,phi,z)
30 //
31 // The same holds for SetPositionErrors().
32 //
33 // All angles are in radians.
34 //
35 // Example :
36 // ---------
37 //
38 // AliSignal s;
39 // s.SetName("Start counter");
40 // Float_t pos[3]={-1,25,7};
41 // Float_t err[3]={0.03,0.7,0.18};
42 // Float_t signal=120.8;
43 // Float_t error=1.73;
44 // Float_t offset=-12.78;
45 // Float_t gain=250;
46 // s.SetPosition(pos,"car");
47 // s.SetPositionErrors(err,"car");
48 // s.SetSignal(signal);
49 // s.SetSignalError(error);
50 // s.SetOffset(offset);
51 // s.SetGain(gain);
52 // Float_t loc[3],dr[3],sigma;
53 // s.GetPosition(loc,"sph");
54 // s.GetPositionErrors(dr,"sph");
55 // Float_t adc=s.GetSignal();
56 // Float_t sigma=s.GetSignalError();
57 //
58 // AliSignal q;    // In the example below a signal contains the
59 //                 // following data : timing, ADC and dE/dx
60 // q.SetName("TOF hit");
61 // q.SetPosition(pos,"car");
62 // q.SetPositionErrors(err,"car");
63 // signal=82.5; // e.g. signal time in ns
64 // error=2.01;
65 // offset=0.003;
66 // q.SetSignal(signal,1);
67 // q.SetSignalError(error,1);
68 // q.SetOffset(offset,1);
69 // signal=268.1; // e.g. ADC value of signal
70 // error=3.75;
71 // gain=120.78;
72 // q.SetSignal(signal,2);
73 // q.SetSignalError(error,2);
74 // q.SetGain(gain,2);
75 // signal=23.7; // e.g. corresponding dE/dx value
76 // error=0.48;
77 // offset=0.2;
78 // gain=150;
79 // q.SetSignal(signal,3);
80 // q.SetSignalError(error,3);
81 // q.SetOffset(offset,3);
82 // q.SetGain(gain,3);
83 //
84 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
85 //- Modified: NvE $Date$ UU-SAP Utrecht
86 ///////////////////////////////////////////////////////////////////////////
87
88 #include "AliSignal.h"
89 #include "AliTrack.h"
90 #include "Riostream.h"
91  
92 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
93  
94 AliSignal::AliSignal() : TNamed(),AliPosition(),AliAttrib()
95 {
96 // Creation of an AliSignal object and initialisation of parameters.
97 // Several signal values (with errors) can be stored in different slots.
98 // If needed, the storage for values (and errors) will be expanded automatically
99 // when entering values and/or errors.
100  fSignals=0;
101  fDsignals=0;
102  fWaveforms=0;
103  fLinks=0;
104 }
105 ///////////////////////////////////////////////////////////////////////////
106 AliSignal::~AliSignal()
107 {
108 // Destructor to delete dynamically allocated memory
109  if (fSignals)
110  {
111   delete fSignals;
112   fSignals=0;
113  }
114  if (fDsignals)
115  {
116   delete fDsignals;
117   fDsignals=0;
118  }
119  if (fWaveforms)
120  {
121   delete fWaveforms;
122   fWaveforms=0;
123  }
124  if (fLinks)
125  {
126   delete fLinks;
127   fLinks=0;
128  }
129 }
130 ///////////////////////////////////////////////////////////////////////////
131 AliSignal::AliSignal(AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
132 {
133 // Copy constructor
134  fSignals=0;
135  fDsignals=0;
136  fWaveforms=0;
137  fLinks=0;
138
139  Int_t n=s.GetNvalues();
140  Double_t val;
141  for (Int_t i=1; i<=n; i++)
142  {
143   val=s.GetSignal(i);
144   SetSignal(val,i);
145  } 
146
147  n=s.GetNerrors();
148  for (Int_t j=1; j<=n; j++)
149  {
150   val=s.GetSignalError(j);
151   SetSignalError(val,j);
152  }
153
154  n=s.GetNwaveforms();
155  for (Int_t k=1; k<=n; k++)
156  {
157   TH1F* hist=s.GetWaveform(k);
158   if (hist) SetWaveform(hist,k); 
159  }
160
161  n=s.GetNlinks();
162  for (Int_t il=1; il<=n; il++)
163  {
164   TObject* obj=s.GetLink(il);
165   if (obj) SetLink(obj,il); 
166  }
167 }
168 ///////////////////////////////////////////////////////////////////////////
169 void AliSignal::Reset(Int_t mode)
170 {
171 // Reset all signal and position values and errors to 0.
172 //
173 // mode = 0 Reset position and all signal values and their errors to 0.
174 //          The waveform histograms are reset, but the calibration
175 //          constants (i.e. gains and offsets) are kept.
176 //        1 Reset position and delete the signal and error storage arrays.
177 //          Also the waveform histograms, gains and offset arrays are deleted.
178 //
179 // The default when invoking Reset() corresponds to mode=0.
180 //
181 // Note : In all cases the storage of the various links will be cleared
182 //        and the container itself will be deleted to recover the memory.
183 //
184 // The usage of mode=0 allows to re-use the allocated memory for new
185 // signal (and error) values. This behaviour is preferable (i.e. faster)
186 // in case the various signals always contain the same number of values
187 // and have the same calibration constants.
188 // The usage of mode=1 is slower, but allows a more efficient memory
189 // occupation (and smaller output file size) in case the different
190 // signals have a variable number of values.
191 //
192 // For more specific actions see ResetPosition(), ResetSignals(),
193 // DeleteSignals(), ResetGain(), ResetOffset() and DeleteCalibrations().
194 //
195
196  if (mode<0 || mode>1)
197  {
198   cout << " *AliSignal::Reset* Invalid argument mode = " << mode << endl;
199   cout << " Default mode=0 will be used." << endl;
200   mode=0;
201  }
202
203  ResetPosition();
204  if (!mode)
205  {
206   ResetSignals();
207  }
208  else
209  {
210   DeleteSignals();
211   DeleteCalibrations();
212  }
213
214  if (fLinks)
215  {
216   delete fLinks;
217   fLinks=0;
218  }
219 }
220 ///////////////////////////////////////////////////////////////////////////
221 void AliSignal::ResetSignals(Int_t mode)
222 {
223 // Reset various signal data according to user selection.
224 //
225 // mode = 0 Reset all signal values and their errors to 0.
226 //        1 Reset only signal values
227 //        2 Reset only signal errors
228 //
229 // The default when invoking ResetSignals() corresponds to mode=0.
230 //
231 // Irrespective of the mode, the waveform histograms are reset.
232
233  if (mode<0 || mode>2)
234  {
235   cout << " *AliSignal::ResetSignals* Invalid argument mode = " << mode << endl;
236   cout << " Default mode=0 will be used." << endl;
237   mode=0;
238  }
239
240  if (fSignals && (mode==0 || mode==1))
241  {
242   for (Int_t i=0; i<fSignals->GetSize(); i++)
243   {
244    fSignals->AddAt(0,i);
245   }
246  }
247
248  if (fDsignals && (mode==0 || mode==2))
249  {
250   for (Int_t j=0; j<fDsignals->GetSize(); j++)
251   {
252    fDsignals->AddAt(0,j);
253   }
254  }
255
256  ResetWaveform(0);
257 }
258 ///////////////////////////////////////////////////////////////////////////
259 void AliSignal::DeleteSignals(Int_t mode)
260 {
261 // Delete storage arrays of various signal data according to user selection.
262 //
263 // mode = 0 Delete arrays of both signal values and their errors.
264 //        1 Delete only signal values array
265 //        2 Delete only signal errors array
266 //
267 // The default when invoking DeleteSignals() corresponds to mode=0.
268 //
269 // Irrespective of the mode, the waveform histograms are deleted.
270
271  if (mode<0 || mode>2)
272  {
273   cout << " *AliSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
274   cout << " Default mode=0 will be used." << endl;
275   mode=0;
276  }
277
278  if (fSignals && (mode==0 || mode==1))
279  {
280   delete fSignals;
281   fSignals=0;
282  }
283
284  if (fDsignals && (mode==0 || mode==2))
285  {
286   delete fDsignals;
287   fDsignals=0;
288  }
289
290  DeleteWaveform(0);
291 }
292 ///////////////////////////////////////////////////////////////////////////
293 void AliSignal::SetSignal(Double_t sig,Int_t j)
294 {
295 // Store value in the j-th (default j=1) signal slot.
296 // Note : The first signal slot is at j=1.
297 // In case the value of the index j exceeds the maximum number of reserved
298 // slots for signal values, the number of reserved slots for the
299 // signal values is increased automatically.
300
301  if (!fSignals)
302  {
303   fSignals=new TArrayF(j);
304   ResetSignals(1);
305  }
306
307  Int_t size=fSignals->GetSize();
308
309  if (j>size)
310  {
311   fSignals->Set(j);
312  }
313
314  fSignals->AddAt(float(sig),j-1);
315 }
316 ///////////////////////////////////////////////////////////////////////////
317 void AliSignal::AddSignal(Double_t sig,Int_t j)
318 {
319 // Add value to the j-th (default j=1) signal slot.
320 // Note : The first signal slot is at j=1.
321 // In case the value of the index j exceeds the maximum number of reserved
322 // slots for signal values, the number of reserved slots for the
323 // signal values is increased automatically.
324
325  if (!fSignals)
326  {
327   fSignals=new TArrayF(j);
328   ResetSignals(1);
329  }
330
331  Int_t size=fSignals->GetSize();
332
333  if (j>size)
334  {
335   fSignals->Set(j);
336  }
337
338  Float_t sum=(fSignals->At(j-1))+sig;
339  fSignals->AddAt(sum,j-1);
340 }
341 ///////////////////////////////////////////////////////////////////////////
342 Float_t AliSignal::GetSignal(Int_t j,Int_t mode)
343 {
344 // Provide value of the j-th (default j=1) signal slot.
345 // Note : The first signal slot is at j=1.
346 // In case no signal is present or the argument j is invalid, 0 is returned.
347 // The parameter "mode" allows for automatic gain etc... correction of the signal.
348 //
349 // mode = 0 : Just the j-th signal is returned.
350 //        1 : The j-th signal is corrected for the gain, offset, dead flag etc...
351 //            In case the gain value was not set, gain=1 will be assumed.
352 //            In case the gain value was 0, a signal value of 0 is returned.
353 //            In case the offset value was not set, offset=0 will be assumed.
354 //            In case the j-th slot was marked dead, 0 is returned.
355 //
356 // The corrected signal (sigc) is determined as follows :
357 //
358 //              sigc=(signal/gain)-offset 
359 //
360 // The default is mode=0.
361
362  Float_t sig=0;
363  Float_t gain=1;
364  Float_t offset=0;
365  if (fSignals)
366  {
367   if (j>0 && j<=(fSignals->GetSize()))
368   {
369    sig=fSignals->At(j-1);
370
371    if (mode==0) return sig;
372
373    // Correct the signal for the gain, offset, dead flag etc...
374    if (GetDeadValue(j)) return 0;
375
376    if (GetGainFlag(j)) gain=GetGain(j);
377    if (GetOffsetFlag(j)) offset=GetOffset(j);
378
379    if (fabs(gain)>0.)
380    {
381     sig=(sig/gain)-offset;
382    }
383    else
384    {
385     sig=0;
386    }
387   }
388   else
389   {
390    cout << " *AliSignal::GetSignal* Index j = " << j << " invalid." << endl;
391   } 
392  }
393  return sig;
394 }
395 ///////////////////////////////////////////////////////////////////////////
396 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
397 {
398 // Store error for the j-th (default j=1) signal slot.
399 // Note : The first signal slot is at j=1.
400 // In case the value of the index j exceeds the maximum number of reserved
401 // slots for signal error values, the number of reserved slots for the
402 // signal errors is increased automatically.
403
404  if (!fDsignals)
405  {
406   fDsignals=new TArrayF(j);
407   ResetSignals(2);
408  }
409
410  Int_t size=fDsignals->GetSize();
411
412  if (j>size)
413  {
414   fDsignals->Set(j);
415  }
416
417  fDsignals->AddAt(float(dsig),j-1);
418 }
419 ///////////////////////////////////////////////////////////////////////////
420 Float_t AliSignal::GetSignalError(Int_t j)
421 {
422 // Provide error of the j-th (default j=1) signal slot.
423 // Note : The first signal slot is at j=1.
424 // In case no signal is present or the argument j is invalid, 0 is returned.
425  Float_t err=0;
426  if (fDsignals)
427  {
428   if (j>0 && j<=(fDsignals->GetSize()))
429   {
430    err=fDsignals->At(j-1);
431   }
432   else
433   {
434    cout << " *AliSignal::GetSignalError* Index j = " << j << " invalid." << endl;
435   } 
436  }
437  return err;
438 }
439 ///////////////////////////////////////////////////////////////////////////
440 void AliSignal::Data(TString f)
441 {
442 // Provide all signal information within the coordinate frame f.
443
444  const char* name=GetName();
445  const char* title=GetTitle();
446
447  cout << " *" << ClassName() << "::Data*";
448  if (strlen(name))  cout << " Name : " << name;
449  if (strlen(title)) cout << " Title : " << title;
450  cout << endl;
451  cout << " Position";
452  Ali3Vector::Data(f);
453
454  List(-1);
455
456 ///////////////////////////////////////////////////////////////////////////
457 void AliSignal::List(Int_t j)
458 {
459 // Provide signal information for the j-th slot.
460 // The first slot is at j=1.
461 // In case j=0 (default) the data of all slots will be listed.
462 // In case j=-1 the data of all slots will be listed, but the header
463 // information will be suppressed.
464
465  if (j<-1) 
466  {
467   cout << " *AliSignal::List* Invalid argument j = " << j << endl;
468   return;
469  }
470
471  if (j != -1)
472  {
473   const char* name=GetName();
474   const char* title=GetTitle();
475
476   cout << " *" << ClassName() << "::Data*";
477   if (strlen(name))  cout << " Name : " << name;
478   if (strlen(title)) cout << " Title : " << title;
479   cout << endl;
480  }
481
482  Int_t nvalues=GetNvalues();
483  Int_t nerrors=GetNerrors();
484  Int_t nwforms=GetNwaveforms();
485  Int_t nlinks=GetNlinks();
486  Int_t n=nvalues;
487  if (nerrors>n) n=nerrors;
488  if (nwforms>n) n=nwforms;
489  if (nlinks>n) n=nlinks;
490
491  TObject* obj=0;
492
493  if (j<=0)
494  {
495   for (Int_t i=1; i<=n; i++)
496   {
497    cout << "   Signal";
498    if (i<=nvalues) cout << " value : " << GetSignal(i);
499    if (i<=nerrors) cout << " error : " << GetSignalError(i);
500    AliAttrib::List(i);
501    cout << endl;
502    obj=GetWaveform(i);
503    if (obj)
504    {
505     const char* wfname=obj->GetName();
506     const char* wftitle=obj->GetTitle();
507     cout << "    Waveform : " << obj->ClassName();
508     if (strlen(wfname))  cout << " Name : " << wfname;
509     if (strlen(wftitle)) cout << " Title : " << wftitle;
510     cout << endl;
511    }
512    obj=GetLink(i);
513    if (obj)
514    {
515     cout << "    Link to : " << obj->ClassName();
516     if (obj->InheritsFrom("TNamed"))
517     {
518      const char* lname=obj->GetName();
519      const char* ltitle=obj->GetTitle();
520      if (strlen(lname))  cout << " Name : " << lname;
521      if (strlen(ltitle)) cout << " Title : " << ltitle;
522     }
523     cout << endl;
524    }
525   }
526  }
527  else
528  {
529   if (j<=n)
530   {
531    cout << "   Signal";
532    if (j<=nvalues) cout << " value : " << GetSignal(j);
533    if (j<=nerrors) cout << " error : " << GetSignalError(j);
534    AliAttrib::List(j);
535    cout << endl;
536    obj=GetWaveform(j);
537    if (obj)
538    {
539     const char* wfnamej=obj->GetName();
540     const char* wftitlej=obj->GetTitle();
541     cout << "    Waveform : " << obj->ClassName();
542     if (strlen(wfnamej))  cout << " Name : " << wfnamej;
543     if (strlen(wftitlej)) cout << " Title : " << wftitlej;
544     cout << endl;
545    }
546    obj=GetLink(j);
547    if (obj)
548    {
549     cout << "    Link to : " << obj->ClassName();
550     if (obj->InheritsFrom("TNamed"))
551     {
552      const char* lnamej=obj->GetName();
553      const char* ltitlej=obj->GetTitle();
554      if (strlen(lnamej))  cout << " Name : " << lnamej;
555      if (strlen(ltitlej)) cout << " Title : " << ltitlej;
556     }
557     cout << endl;
558    }
559   }
560  }
561
562 ///////////////////////////////////////////////////////////////////////////
563 Int_t AliSignal::GetNvalues()
564 {
565 // Provide the number of values for this signal.
566  Int_t n=0;
567  if (fSignals) n=fSignals->GetSize();
568  return n;
569 }
570 ///////////////////////////////////////////////////////////////////////////
571 Int_t AliSignal::GetNerrors()
572 {
573 // Provide the number specified errors on the values for this signal.
574  Int_t n=0;
575  if (fDsignals) n=fDsignals->GetSize();
576  return n;
577 }
578 ///////////////////////////////////////////////////////////////////////////
579 Int_t AliSignal::GetNwaveforms()
580 {
581 // Provide the number specified waveforms for this signal.
582  Int_t n=0;
583  if (fWaveforms) n=fWaveforms->GetSize();
584  return n;
585 }
586 ///////////////////////////////////////////////////////////////////////////
587 TH1F* AliSignal::GetWaveform(Int_t j)
588 {
589 // Provide pointer to the j-th waveform histogram.
590  TH1F* waveform=0;
591  if (j <= GetNwaveforms()) waveform=(TH1F*)fWaveforms->At(j-1);
592  return waveform;
593 }
594 ///////////////////////////////////////////////////////////////////////////
595 void AliSignal::SetWaveform(TH1F* waveform,Int_t j)
596 {
597 // Set the 1D waveform histogram corresponding to the j-th signal value.
598 //
599 // Notes :
600 //  The waveform of the first signal value is at j=1.
601 //  j=1 is the default value.
602 //
603 // In case the value of the index j exceeds the maximum number of reserved
604 // slots for the waveforms, the number of reserved slots for the waveforms
605 // is increased automatically.
606 //
607 // In case the histo pointer argument has the same value as the current waveform
608 // histogram pointer value, no action is taken since the user has already
609 // modified the actual histogram.
610 //
611 // In case the histo pointer argument is zero, the current waveform histogram
612 // is deleted and the pointer set to zero.
613 //
614 // In all other cases the current waveform histogram is deleted and a new
615 // copy of the input histogram is created which becomes the current waveform
616 // histogram.
617
618  if (!fWaveforms)
619  {
620   fWaveforms=new TObjArray(j);
621   fWaveforms->SetOwner();
622  }
623
624  if (j > fWaveforms->GetSize()) fWaveforms->Expand(j);
625
626  TH1F* hcur=(TH1F*)fWaveforms->At(j-1);
627  if (waveform != hcur)
628  {
629   if (hcur)
630   {
631    fWaveforms->Remove(hcur);
632    delete hcur;
633    hcur=0;
634   }
635   if (waveform)
636   {
637    hcur=new TH1F(*waveform);
638    fWaveforms->AddAt(hcur,j-1);
639   }
640  } 
641 }
642 ///////////////////////////////////////////////////////////////////////////
643 void AliSignal::ResetWaveform(Int_t j)
644 {
645 // Reset the waveform of the j-th (default j=1) signal value.
646 // This memberfunction invokes TH1F::Reset() for the corresponding waveform(s).
647 // To actually delete the histograms from memory, use DeleteWaveform().
648 // Notes : The first signal value is at j=1.
649 //         j=0 ==> All waveforms will be reset.
650  
651  if (!fWaveforms) return;
652
653  Int_t size=fWaveforms->GetSize();
654
655  if ((j>=0) && (j<=size))
656  {
657   if (j)
658   {
659    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
660    if (hwave) hwave->Reset();
661   }
662   else
663   {
664    for (Int_t i=0; i<size; i++)
665    {
666     TH1F* hwave=(TH1F*)fWaveforms->At(i);
667     if (hwave) hwave->Reset();
668    }
669   }
670  }
671  else
672  {
673   cout << " *AliSignal::ResetWaveform* Index j = " << j << " invalid." << endl;
674   return;
675  }
676 }
677 ///////////////////////////////////////////////////////////////////////////
678 void AliSignal::DeleteWaveform(Int_t j)
679 {
680 // Delete the waveform of the j-th (default j=1) signal value.
681 // Notes : The first signal value is at j=1.
682 //         j=0 ==> All waveforms will be deleted.
683  
684  if (!fWaveforms) return;
685
686  Int_t size=fWaveforms->GetSize();
687
688  if ((j>=0) && (j<=size))
689  {
690   if (j)
691   {
692    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
693    if (hwave)
694    {
695     fWaveforms->Remove(hwave);
696     delete hwave;
697    }
698   }
699   else
700   {
701    delete fWaveforms;
702    fWaveforms=0;
703   }
704  }
705  else
706  {
707   cout << " *AliSignal::DeleteWaveform* Index j = " << j << " invalid." << endl;
708   return;
709  }
710 }
711 ///////////////////////////////////////////////////////////////////////////
712 Int_t AliSignal::GetNlinks()
713 {
714 // Provide the highest slot number with a specified link for this signal.
715  Int_t n=0;
716  if (fLinks) n=fLinks->GetSize();
717  return n;
718 }
719 ///////////////////////////////////////////////////////////////////////////
720 TObject* AliSignal::GetLink(Int_t j)
721 {
722 // Provide pointer of the object linked to the j-th slot.
723  TObject* obj=0;
724  if (j <= GetNlinks()) obj=fLinks->At(j-1);
725  return obj;
726 }
727 ///////////////////////////////////////////////////////////////////////////
728 void AliSignal::SetLink(TObject* obj,Int_t j)
729 {
730 // Introduce a link (=pointer) to an object for the j-th slot.
731 // Only the pointer values are stored for (backward) reference, meaning
732 // that the objects of which the pointers are stored are NOT owned
733 // by the AliSignal object.
734 //
735 // Notes :
736 //  The link of the first slot is at j=1.
737 //  j=1 is the default value.
738 //
739 // In case the value of the index j exceeds the maximum number of reserved
740 // slots for the links, the number of reserved slots for the links
741 // is increased automatically (unless the pointer argument is zero).
742 //
743 // In case the pointer argument is zero, indeed a value of zero will be
744 // stored for the specified slot (unless j exceeds the current maximum).
745 //
746 // In principle any object derived from TObject can be referred to by this
747 // mechanism.
748 // However, this "linking back" facility was introduced to enable AliSignal slots
749 // to refer directly to the various AliTracks to which the AliSignal object itself
750 // is related (see AliTrack::AddSignal).
751 // Therefore, in case the input argument "obj" points to an AliTrack (or derived)
752 // object, the current signal is automatically related to this AliTrack
753 // (or derived) object.
754 // 
755 // Please also have a look at the docs of the memberfunction ResetLink()
756 // to prevent the situation of stored pointers to non-existent object. 
757
758  if (!fLinks && obj)
759  {
760   fLinks=new TObjArray(j);
761  }
762
763  if (j>fLinks->GetSize() && obj) fLinks->Expand(j);
764
765  if (j<=fLinks->GetSize())
766  {
767   fLinks->AddAt(obj,j-1);
768   if (obj) 
769   {
770    if (obj->InheritsFrom("AliTrack"))
771    {
772     AliTrack* t=(AliTrack*)obj;
773     t->AddSignal(*this);
774    }
775   }
776  }
777 }
778 ///////////////////////////////////////////////////////////////////////////
779 void AliSignal::ResetLink(Int_t j)
780 {
781 // Reset the link of the j-th (default j=1) slot.
782 // Notes : The first link position is at j=1.
783 //         j=0 ==> All links will be reset and the storage array deleted.
784 //
785 // In general the user should take care of properly clearing the corresponding
786 // pointer here when the referred object is deleted.
787 // However, this "linking back" facility was introduced to enable AliSignal slots
788 // to refer directly to the various AliTracks to which the AliSignal object itself
789 // is related (see AliTrack::AddSignal).
790 // As such, the AliTrack destructor already takes care of clearing the corresponding
791 // links from the various AliSignal slots for all the AliSignal objects that were
792 // related to that AliTrack. 
793 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
794 // the user doesn't have to worry about clearing the corresponding AliTrack link from
795 // the AliSignal object when the corresponding AliTrack object is deleted.
796  
797  if (!fLinks || j<0) return;
798
799  TObject* obj=0;
800
801  if (j)
802  {
803   SetLink(obj,j);
804  }
805  else
806  {
807   delete fLinks;
808   fLinks=0;
809  }
810 }
811 ///////////////////////////////////////////////////////////////////////////
812 void AliSignal::ResetLink(TObject* obj)
813 {
814 // Reset the link of the all the slots referring to the specified object.
815 //
816 // In general the user should take care of properly clearing the corresponding
817 // pointer here when the referred object is deleted.
818 // However, this "linking back" facility was introduced to enable AliSignal slots
819 // to refer directly to the various AliTracks to which the AliSignal object itself
820 // is related (see AliTrack::AddSignal).
821 // As such, the AliTrack destructor already takes care of clearing the corresponding
822 // links from the various AliSignal slots for all the AliSignal objects that were
823 // related to that AliTrack. 
824 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
825 // the user doesn't have to worry about clearing the corresponding AliTrack link from
826 // the AliSignal object when the corresponding AliTrack object is deleted.
827  
828  if (!fLinks || !obj) return;
829
830  Int_t nlinks=GetNlinks();
831  for (Int_t i=1; i<=nlinks; i++)
832  {
833   TObject* obj2=GetLink(i);
834   if (obj2==obj) ResetLink(i);
835  }
836 }
837 ///////////////////////////////////////////////////////////////////////////
838 TObject* AliSignal::Clone(char* name)
839 {
840 // Make a deep copy of the current object and provide the pointer to the copy.
841 // This memberfunction enables automatic creation of new objects of the
842 // correct type depending on the object type, a feature which may be very useful
843 // for containers when adding objects in case the container owns the objects.
844 // This feature allows e.g. AliTrack to store either AliSignal objects or
845 // objects derived from AliSignal via the AddSignal memberfunction, provided
846 // these derived classes also have a proper Clone memberfunction. 
847
848  AliSignal* sig=new AliSignal(*this);
849  if (name)
850  {
851   if (strlen(name)) sig->SetName(name);
852  }
853  return sig;
854 }
855 ///////////////////////////////////////////////////////////////////////////