ef4d7d80b3a34d8f64e3c62ee1043e2321960eda
[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 // The user can decide to store either calibrated or uncalibrated signals.
23 // Via the specification of a gain and offset or/and an explicit
24 // (de)calibration function both calibrated and uncalibrated signals
25 // can always be obtained. For details see the documentation of the
26 // memberfunction GetSignal() and the class AliAttrib.
27 // The explicit specification of a (de)calibration function offers the
28 // maximum flexibility and also allows automatic indication whether
29 // calibrated or uncalibrated data has been stored.
30 // The latter can be achieved by only specifying a calibration function
31 // (and no de-calibration function) in case uncalibrated data is stored,
32 // whereas in case of stored calibrated data the user should only
33 // provide a de-calibration function (and no calibration function).
34 //
35 // Note :
36 // ------
37 // Signal positions (r) and reference frames (f) are specified via
38 // SetPosition(r,f) under the following conventions :
39 //
40 // f="car" ==> r is Cartesian   (x,y,z)
41 // f="sph" ==> r is Spherical   (r,theta,phi)
42 // f="cyl" ==> r is Cylindrical (rho,phi,z)
43 //
44 // The same holds for SetPositionErrors().
45 //
46 // All angles are in radians.
47 //
48 // Example :
49 // ---------
50 //
51 // AliSignal s;
52 // s.SetName("Start counter");
53 // Float_t pos[3]={-1,25,7};
54 // Float_t err[3]={0.03,0.7,0.18};
55 // Float_t signal=120.8;
56 // Float_t error=1.73;
57 // Float_t offset=-12.78;
58 // Float_t gain=250;
59 // s.SetPosition(pos,"car");
60 // s.SetPositionErrors(err,"car");
61 // s.SetSignal(signal);
62 // s.SetSignalError(error);
63 // s.SetOffset(offset);
64 // s.SetGain(gain);
65 // Float_t loc[3],dr[3],sigma;
66 // s.GetPosition(loc,"sph");
67 // s.GetPositionErrors(dr,"sph");
68 // Float_t adc=s.GetSignal();
69 // Float_t sigma=s.GetSignalError();
70 //
71 // AliSignal q;    // In the example below a signal contains the
72 //                 // following data : timing, ADC and dE/dx
73 // q.SetNameTitle("Hybrid","Test for multiple signal data");
74 // q.SetPosition(pos,"car");
75 // q.SetPositionErrors(err,"car");
76 // signal=82.5; // e.g. signal time in ns
77 // error=2.01;
78 // offset=0.003;
79 // q.SetSlotName("TOF",1);
80 // q.SetSignal(signal,1);
81 // q.SetSignalError(error,1);
82 // q.SetOffset(offset,1);
83 // signal=268.1; // e.g. ADC value of signal
84 // error=3.75;
85 // gain=120.78;
86 // offset=1.5732;
87 // // Addressing via name specification instead of index 
88 // q.SetSlotName("ADC",2);
89 // q.SetSignal(signal,"ADC");
90 // q.SetSignalError(error,"ADC");
91 // q.SetGain(gain,"ADC");
92 // q.SetOffset(offset,"ADC");
93 // signal=23.7; // e.g. corresponding dE/dx value
94 // error=0.48;
95 // TF1 f=("calib","[0]*pow(x,2)+[1]"); // dE/dx calib. function
96 // f.SetParameter(0,3.285);
97 // f.SetParameter(1,-18.67);
98 // q.SetSlotName("dE/dx",3);
99 // q.SetCalFunction(&f,"dE/dx");
100 // q.SetSignal(signal,"dE/dx");
101 // q.SetSignalError(error,"dE/dx");
102 //
103 // // Signal retrieval with various (de)calibration modes
104 // Float_t tof=q.GetSignal("TOF");
105 // Float_t adc=q.GetSignal("ADC",1);
106 // Float_t dedx=q.GetSignal("dE/dx",3);
107 //
108 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
109 //- Modified: NvE $Date$ UU-SAP Utrecht
110 ///////////////////////////////////////////////////////////////////////////
111
112 #include "AliSignal.h"
113 #include "AliTrack.h"
114 #include "Riostream.h"
115  
116 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
117  
118 AliSignal::AliSignal() : TNamed(),AliPosition(),AliAttrib()
119 {
120 // Creation of an AliSignal object and initialisation of parameters.
121 // Several signal values (with errors) can be stored in different slots.
122 // If needed, the storage for values (and errors) will be expanded automatically
123 // when entering values and/or errors.
124  fSignals=0;
125  fDsignals=0;
126  fWaveforms=0;
127  fLinks=0;
128  fDevice=0;
129 }
130 ///////////////////////////////////////////////////////////////////////////
131 AliSignal::~AliSignal()
132 {
133 // Destructor to delete dynamically allocated memory
134  if (fSignals)
135  {
136   delete fSignals;
137   fSignals=0;
138  }
139  if (fDsignals)
140  {
141   delete fDsignals;
142   fDsignals=0;
143  }
144  if (fWaveforms)
145  {
146   delete fWaveforms;
147   fWaveforms=0;
148  }
149  if (fLinks)
150  {
151   // Remove this signal from all related tracks
152   for (Int_t i=1; i<=fLinks->GetNobjects(); i++)
153   {
154    TObject* obj=fLinks->GetObject(i);
155    if (!obj) continue;
156    if (obj->InheritsFrom("AliTrack"))
157    {
158     AliTrack* tx=(AliTrack*)obj;
159     tx->RemoveSignal(*this);
160    }
161   }
162   delete fLinks;
163   fLinks=0;
164  }
165 }
166 ///////////////////////////////////////////////////////////////////////////
167 AliSignal::AliSignal(const AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
168 {
169 // Copy constructor
170  fSignals=0;
171  fDsignals=0;
172  fWaveforms=0;
173  fLinks=0;
174
175  // Don't copy the owning device pointer for the copy
176  fDevice=0;
177
178  Int_t n=s.GetNvalues();
179  Double_t val;
180  for (Int_t i=1; i<=n; i++)
181  {
182   val=s.GetSignal(i);
183   SetSignal(val,i);
184  } 
185
186  n=s.GetNerrors();
187  for (Int_t j=1; j<=n; j++)
188  {
189   val=s.GetSignalError(j);
190   SetSignalError(val,j);
191  }
192
193  n=s.GetNwaveforms();
194  for (Int_t k=1; k<=n; k++)
195  {
196   TH1F* hist=s.GetWaveform(k);
197   if (hist) SetWaveform(hist,k); 
198  }
199
200  TArrayI slotarr;
201  TArrayI posarr;
202  TObject* dum=0;
203  n=s.GetIndices(dum,slotarr,posarr);
204  Int_t slot,pos;
205  for (Int_t idx=0; idx<n; idx++)
206  {
207   slot=slotarr.At(idx);
208   pos=posarr.At(idx);
209   TObject* obj=s.GetLink(slot,pos);
210   if (obj) SetLink(obj,slot,pos); 
211  }
212 }
213 ///////////////////////////////////////////////////////////////////////////
214 void AliSignal::Reset(Int_t mode)
215 {
216 // Reset all signal and position values and errors to 0.
217 //
218 // mode = 0 Reset position and all signal values and their errors to 0.
219 //          The waveform histograms are reset, but the calibration
220 //          constants (i.e. gains and offsets) are kept.
221 //        1 Reset position and delete the signal and error storage arrays.
222 //          Also the waveform histograms, gains and offset arrays are deleted.
223 //
224 // The default when invoking Reset() corresponds to mode=0.
225 //
226 // Note : In all cases the storage of the various links will be reset.
227 //        The UniqueID, name and title will NOT be reset.
228 //        In case the user wants to reset these attributes, this has to
229 //        be done explicitly via the SET facilities. 
230 //
231 // The usage of mode=0 allows to re-use the allocated memory for new
232 // signal (and error) values. This behaviour is preferable (i.e. faster)
233 // in case the various signals always contain the same number of values
234 // and have the same calibration constants.
235 // The usage of mode=1 is slower, but allows a more efficient memory
236 // occupation (and smaller output file size) in case the different
237 // signals have a variable number of values.
238 //
239 // For more specific actions see ResetPosition(), ResetSignals(),
240 // DeleteSignals(), ResetGain(), ResetOffset(), ResetLink(), ResetWaveform(),
241 // DeleteWaveform() and DeleteCalibrations().
242 //
243
244  if (mode<0 || mode>1)
245  {
246   cout << " *AliSignal::Reset* Invalid argument mode = " << mode << endl;
247   cout << " Default mode=0 will be used." << endl;
248   mode=0;
249  }
250
251  ResetPosition();
252  if (!mode)
253  {
254   ResetSignals();
255  }
256  else
257  {
258   DeleteSignals();
259   DeleteCalibrations();
260  }
261
262  if (fLinks) fLinks->Reset();
263  fDevice=0;
264 }
265 ///////////////////////////////////////////////////////////////////////////
266 void AliSignal::ResetSignals(Int_t mode)
267 {
268 // Reset various signal data according to user selection.
269 //
270 // mode = 0 Reset all signal values and their errors to 0.
271 //        1 Reset only signal values
272 //        2 Reset only signal errors
273 //
274 // The default when invoking ResetSignals() corresponds to mode=0.
275 //
276 // Irrespective of the mode, the waveform histograms are reset.
277
278  if (mode<0 || mode>2)
279  {
280   cout << " *AliSignal::ResetSignals* Invalid argument mode = " << mode << endl;
281   cout << " Default mode=0 will be used." << endl;
282   mode=0;
283  }
284
285  if (fSignals && (mode==0 || mode==1))
286  {
287   for (Int_t i=0; i<fSignals->GetSize(); i++)
288   {
289    fSignals->AddAt(0,i);
290   }
291  }
292
293  if (fDsignals && (mode==0 || mode==2))
294  {
295   for (Int_t j=0; j<fDsignals->GetSize(); j++)
296   {
297    fDsignals->AddAt(0,j);
298   }
299  }
300
301  ResetWaveform(0);
302 }
303 ///////////////////////////////////////////////////////////////////////////
304 void AliSignal::DeleteSignals(Int_t mode)
305 {
306 // Delete storage arrays of various signal data according to user selection.
307 //
308 // mode = 0 Delete arrays of both signal values and their errors.
309 //        1 Delete only signal values array
310 //        2 Delete only signal errors array
311 //
312 // The default when invoking DeleteSignals() corresponds to mode=0.
313 //
314 // Irrespective of the mode, the waveform histograms are deleted.
315
316  if (mode<0 || mode>2)
317  {
318   cout << " *AliSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
319   cout << " Default mode=0 will be used." << endl;
320   mode=0;
321  }
322
323  if (fSignals && (mode==0 || mode==1))
324  {
325   delete fSignals;
326   fSignals=0;
327  }
328
329  if (fDsignals && (mode==0 || mode==2))
330  {
331   delete fDsignals;
332   fDsignals=0;
333  }
334
335  DeleteWaveform(0);
336 }
337 ///////////////////////////////////////////////////////////////////////////
338 void AliSignal::SetSignal(Double_t sig,Int_t j)
339 {
340 // Store signal value for the j-th (default j=1) slot.
341 // Note : The first signal slot is at j=1.
342 // In case the value of the index j exceeds the maximum number of reserved
343 // slots for signal values, the number of reserved slots for the
344 // signal values is increased automatically.
345
346  if (!fSignals)
347  {
348   fSignals=new TArrayF(j);
349   ResetSignals(1);
350  }
351
352  Int_t size=fSignals->GetSize();
353
354  if (j>size)
355  {
356   fSignals->Set(j);
357  }
358
359  fSignals->AddAt(float(sig),j-1);
360 }
361 ///////////////////////////////////////////////////////////////////////////
362 void AliSignal::SetSignal(Double_t sig,TString name)
363 {
364 // Store signal value for the name-specified slot.
365 //
366 // This procedure involves a slot-index search based on the specified name
367 // at each invokation. This may become slow in case many slots have been
368 // defined and/or when this procedure is invoked many times.
369 // In such cases it is preferable to use indexed addressing in the user code
370 // either directly or via a few invokations of GetSlotIndex().
371
372  Int_t j=GetSlotIndex(name);
373  if (j>0) SetSignal(sig,j);
374 }
375 ///////////////////////////////////////////////////////////////////////////
376 void AliSignal::AddSignal(Double_t sig,Int_t j)
377 {
378 // Add value to the signal of the j-th (default j=1) slot.
379 // Note : The first signal slot is at j=1.
380 // In case the value of the index j exceeds the maximum number of reserved
381 // slots for signal values, the number of reserved slots for the
382 // signal values is increased automatically.
383
384  if (!fSignals)
385  {
386   fSignals=new TArrayF(j);
387   ResetSignals(1);
388  }
389
390  Int_t size=fSignals->GetSize();
391
392  if (j>size)
393  {
394   fSignals->Set(j);
395  }
396
397  Float_t sum=(fSignals->At(j-1))+sig;
398  fSignals->AddAt(sum,j-1);
399 }
400 ///////////////////////////////////////////////////////////////////////////
401 void AliSignal::AddSignal(Double_t sig,TString name)
402 {
403 // Add value to the signal of the name-specified slot.
404 //
405 // This procedure involves a slot-index search based on the specified name
406 // at each invokation. This may become slow in case many slots have been
407 // defined and/or when this procedure is invoked many times.
408 // In such cases it is preferable to use indexed addressing in the user code
409 // either directly or via a few invokations of GetSlotIndex().
410
411  Int_t j=GetSlotIndex(name);
412  if (j>0) AddSignal(sig,j);
413 }
414 ///////////////////////////////////////////////////////////////////////////
415 Float_t AliSignal::GetSignal(Int_t j,Int_t mode) const
416 {
417 // Provide signal value of the j-th (default j=1) slot.
418 // Note : The first signal slot is at j=1.
419 // In case no signal is present or the input argument "j" or "mode" is invalid,
420 // the value 0 is returned.
421 // The parameter "mode" allows for automatic (de)calibration of the signal
422 // (e.g. gain etc... correction or via explicit (de)calibration functions).
423 //
424 // mode = 0 : Just the j-th signal is returned.
425 //        1 : The j-th signal is corrected for the gain, offset, dead flag etc...
426 //            In case the j-th slot was marked dead, 0 is returned.
427 //            In case the gain value was not set, gain=1 will be assumed.
428 //            In case the gain value was 0, a signal value of 0 is returned.
429 //            In case the offset value was not set, offset=0 will be assumed.
430 //        2 : Same as mode=1 but gain, offset dead flag etc... are taken from
431 //            the AliDevice which owns this AliSignal object.
432 //            In case this AliSignal object has no parent AliDevice, just
433 //            the j-th signal is returned (like with mode=0).
434 //        3 : The j-th signal is corrected using the corresponding calibration
435 //            function.
436 //            In case the j-th slot was marked dead, 0 is returned.
437 //            In case no calibration function is present, just the j-th signal
438 //            is returned (like with mode=0).
439 //        4 : Same as mode=3 but the calibration function is taken from
440 //            the AliDevice which owns this AliSignal object.
441 //        5 : Same as mode=2 but in case no parent AliDevice is present
442 //            an automatic switch to mode=1 will be made.
443 //        6 : Same as mode=4 but in case no parent AliDevice is present
444 //            an automatic switch to mode=3 will be made.
445 //
446 //       <0 : The corresponding de-correction or de-calibration is performed
447 //
448 // The corrected signal (sigc) is determined as follows :
449 //
450 //              sigc=(signal/gain)-offset 
451 //
452 // The de-corrected signal is determined as follows :
453 //
454 //              signal=(sigc+offset)*gain 
455 //
456 // The default is mode=0.
457
458  if (abs(mode)>6) return 0;
459
460  Float_t sig=0;
461  Float_t gain=1;
462  Float_t offset=0;
463
464  AliSignal* sx=(AliSignal*)this;
465  if (abs(mode)==2 || abs(mode)>=4) sx=(AliSignal*)GetDevice();
466  if (!sx && abs(mode)>=5) sx=(AliSignal*)this;
467  if (mode==5) mode=2;
468  if (mode==-5) mode=-2;
469  if (mode==6) mode=3;
470  if (mode==-6) mode=-3;
471
472  if (fSignals)
473  {
474   if (j>0 && j<=(fSignals->GetSize()))
475   {
476    sig=fSignals->At(j-1);
477
478    if (mode==0 || !sx) return sig;
479
480    // Check for the dead flag setting
481    if (sx->GetDeadValue(j)) return 0;
482
483    // (De)correct the signal for the gain and offset
484    if (abs(mode)==1 || abs(mode)==2)
485    {
486     if (sx->GetGainFlag(j)) gain=sx->GetGain(j);
487     if (sx->GetOffsetFlag(j)) offset=sx->GetOffset(j);
488
489     if (fabs(gain)>0.)
490     {
491      if (mode>0) sig=(sig/gain)-offset; // Gain and offset correction
492      if (mode<0) sig=(sig+offset)*gain; // Gain and offset de-correction
493     }
494     else
495     {
496      sig=0;
497     }
498     return sig;
499    }
500
501    // (De)calibrate the signal with the corresponding (de)calibration function
502    if (abs(mode)==3 || abs(mode)==4)
503    {
504     TF1* f=sx->GetCalFunction(j);
505     if (mode<0) f=sx->GetDecalFunction(j);
506     if (f) sig=f->Eval(sig);
507     return sig;
508    }
509   }
510   else
511   {
512    cout << " *AliSignal::GetSignal* Index j = " << j << " invalid." << endl;
513   } 
514  }
515  return sig;
516 }
517 ///////////////////////////////////////////////////////////////////////////
518 Float_t AliSignal::GetSignal(TString name,Int_t mode) const
519 {
520 // Provide signal value of the name-specified slot.
521 // In case no signal is present, 0 is returned.
522 // The parameter "mode" allows for automatic gain etc... correction of the signal.
523 //
524 // mode = 0 : Just the j-th signal is returned.
525 //        1 : The j-th signal is corrected for the gain, offset, dead flag etc...
526 //            In case the gain value was not set, gain=1 will be assumed.
527 //            In case the gain value was 0, a signal value of 0 is returned.
528 //            In case the offset value was not set, offset=0 will be assumed.
529 //            In case the j-th slot was marked dead, 0 is returned.
530 //
531 // The corrected signal (sigc) is determined as follows :
532 //
533 //              sigc=(signal/gain)-offset 
534 //
535 // The default is mode=0.
536 //
537 // This procedure involves a slot-index search based on the specified name
538 // at each invokation. This may become slow in case many slots have been
539 // defined and/or when this procedure is invoked many times.
540 // In such cases it is preferable to use indexed addressing in the user code
541 // either directly or via a few invokations of GetSlotIndex().
542
543  Int_t j=GetSlotIndex(name);
544  Float_t val=0;
545  if (j>0) val=GetSignal(j,mode);
546  return val;
547 }
548 ///////////////////////////////////////////////////////////////////////////
549 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
550 {
551 // Store error on the signal for the j-th (default j=1) slot.
552 // Note : The first signal slot is at j=1.
553 // In case the value of the index j exceeds the maximum number of reserved
554 // slots for signal error values, the number of reserved slots for the
555 // signal errors is increased automatically.
556
557  if (!fDsignals)
558  {
559   fDsignals=new TArrayF(j);
560   ResetSignals(2);
561  }
562
563  Int_t size=fDsignals->GetSize();
564
565  if (j>size)
566  {
567   fDsignals->Set(j);
568  }
569
570  fDsignals->AddAt(float(dsig),j-1);
571 }
572 ///////////////////////////////////////////////////////////////////////////
573 void AliSignal::SetSignalError(Double_t dsig,TString name)
574 {
575 // Store error on the signal for the name-specified slot.
576 //
577 // This procedure involves a slot-index search based on the specified name
578 // at each invokation. This may become slow in case many slots have been
579 // defined and/or when this procedure is invoked many times.
580 // In such cases it is preferable to use indexed addressing in the user code
581 // either directly or via a few invokations of GetSlotIndex().
582
583  Int_t j=GetSlotIndex(name);
584  if (j>0) SetSignalError(dsig,j);
585 }
586 ///////////////////////////////////////////////////////////////////////////
587 Float_t AliSignal::GetSignalError(Int_t j) const
588 {
589 // Provide error on the signal of the j-th (default j=1) slot.
590 // Note : The first signal slot is at j=1.
591 // In case no signal is present or the argument j is invalid, 0 is returned.
592  Float_t err=0;
593  if (fDsignals)
594  {
595   if (j>0 && j<=(fDsignals->GetSize()))
596   {
597    err=fDsignals->At(j-1);
598   }
599   else
600   {
601    cout << " *AliSignal::GetSignalError* Index j = " << j << " invalid." << endl;
602   } 
603  }
604  return err;
605 }
606 ///////////////////////////////////////////////////////////////////////////
607 Float_t AliSignal::GetSignalError(TString name) const
608 {
609 // Provide error on the signal of the name-specified slot.
610 //
611 // This procedure involves a slot-index search based on the specified name
612 // at each invokation. This may become slow in case many slots have been
613 // defined and/or when this procedure is invoked many times.
614 // In such cases it is preferable to use indexed addressing in the user code
615 // either directly or via a few invokations of GetSlotIndex().
616
617  Int_t j=GetSlotIndex(name);
618  Float_t val=0;
619  if (j>0) val=GetSignalError(j);
620  return val;
621 }
622 ///////////////////////////////////////////////////////////////////////////
623 void AliSignal::Data(TString f) const
624 {
625 // Provide all signal information within the coordinate frame f.
626
627  const char* name=GetName();
628  const char* title=GetTitle();
629
630  cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
631  if (strlen(name))  cout << " Name : " << name;
632  if (strlen(title)) cout << " Title : " << title;
633  cout << endl;
634  cout << "   Position";
635  AliPosition::Data(f);
636  if (fDevice)
637  {
638   const char* devname=fDevice->GetName();
639   const char* devtitle=fDevice->GetTitle();
640   cout << "   Owned by device : " << fDevice->ClassName()
641        << " Id : " << fDevice->GetUniqueID();
642   if (strlen(devname))  cout << " Name : " << devname;
643   if (strlen(devtitle)) cout << " Title : " << devtitle;
644   cout << endl;
645  }
646
647  // Provide an overview of the stored waveforms
648  ListWaveform(-1);
649
650  // Provide an overview of all the data and attribute slots
651  List(-1);
652
653 ///////////////////////////////////////////////////////////////////////////
654 void AliSignal::List(Int_t j) const
655 {
656 // Provide signal information for the j-th slot.
657 // The first slot is at j=1.
658 // In case j=0 (default) the data of all slots will be listed.
659 // In case j=-1 the data of all slots will be listed, but the header
660 // information will be suppressed.
661
662  if (j<-1) 
663  {
664   cout << " *AliSignal::List* Invalid argument j = " << j << endl;
665   return;
666  }
667
668  if (j != -1)
669  {
670   const char* name=GetName();
671   const char* title=GetTitle();
672
673   cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
674   if (strlen(name))  cout << " Name : " << name;
675   if (strlen(title)) cout << " Title : " << title;
676   cout << endl;
677   if (fDevice)
678   {
679    const char* devname=fDevice->GetName();
680    const char* devtitle=fDevice->GetTitle();
681    cout << "   Owned by device : " << fDevice->ClassName();
682    if (strlen(devname))  cout << " Name : " << devname;
683    if (strlen(devtitle)) cout << " Title : " << devtitle;
684    cout << endl;
685   }
686  }
687
688  Int_t nvalues=GetNvalues();
689  Int_t nerrors=GetNerrors();
690  Int_t nlinkslots=0;
691  if (fLinks) nlinkslots=fLinks->GetMaxColumn();
692  Int_t ncalibs=GetNcalflags();
693  Int_t ncalfuncs=GetNcalfuncs();
694  Int_t ndecalfuncs=GetNdecalfuncs();
695
696  Int_t n=nvalues;
697  if (nerrors>n) n=nerrors;
698  if (nlinkslots>n) n=nlinkslots;
699  if (InheritsFrom("AliDevice"))
700  {
701   if (ncalibs>n) n=ncalibs;
702   if (ncalfuncs>n) n=ncalfuncs;
703   if (ndecalfuncs>n) n=ndecalfuncs;
704  }
705  
706  TObject* obj=0;
707  Int_t nrefs=0;
708  TArrayI posarr;
709  Int_t pos;
710
711  if (j<=0)
712  {
713   for (Int_t i=1; i<=n; i++)
714   {
715    cout << "   Slot : " << i;
716    if (i<=nvalues) cout << " Signal value : " << GetSignal(i);
717    if (i<=nerrors) cout << " error : " << GetSignalError(i);
718    AliAttrib::List(i);
719    cout << endl;
720    obj=0;
721    nrefs=GetIndices(obj,i,posarr);
722    for (Int_t k=0; k<nrefs; k++)
723    {
724     pos=posarr.At(k);
725     obj=GetLink(i,pos);
726     if (obj)
727     {
728      cout << "    Link at position " << pos << " to : " << obj->ClassName();
729      if (obj->InheritsFrom("TNamed"))
730      {
731       const char* lname=obj->GetName();
732       const char* ltitle=obj->GetTitle();
733       if (strlen(lname))  cout << " Name : " << lname;
734       if (strlen(ltitle)) cout << " Title : " << ltitle;
735      }
736      cout << endl;
737     }
738    }
739   }
740  }
741  else
742  {
743   if (j<=n)
744   {
745    cout << "   Slot : " << j;
746    if (j<=nvalues) cout << " Signal value : " << GetSignal(j);
747    if (j<=nerrors) cout << " error : " << GetSignalError(j);
748    AliAttrib::List(j);
749    cout << endl;
750    obj=0;
751    nrefs=GetIndices(obj,j,posarr);
752    for (Int_t kj=0; kj<nrefs; kj++)
753    {
754     pos=posarr.At(kj);
755     obj=GetLink(j,pos);
756     if (obj)
757     {
758      cout << "    Link at position " << pos << " to : " << obj->ClassName();
759      if (obj->InheritsFrom("TNamed"))
760      {
761       const char* lnamej=obj->GetName();
762       const char* ltitlej=obj->GetTitle();
763       if (strlen(lnamej))  cout << " Name : " << lnamej;
764       if (strlen(ltitlej)) cout << " Title : " << ltitlej;
765      }
766      cout << endl;
767     }
768    }
769   }
770  }
771
772 ///////////////////////////////////////////////////////////////////////////
773 void AliSignal::List(TString name) const
774 {
775 // Provide signal information for the name-specified slot.
776 //
777 // This procedure involves a slot-index search based on the specified name
778 // at each invokation. This may become slow in case many slots have been
779 // defined and/or when this procedure is invoked many times.
780 // In such cases it is preferable to use indexed addressing in the user code
781 // either directly or via a few invokations of GetSlotIndex().
782
783  Int_t j=GetSlotIndex(name);
784  if (j>0) List(j);
785 }
786 ///////////////////////////////////////////////////////////////////////////
787 void AliSignal::ListWaveform(Int_t j) const
788 {
789 // Provide information for the j-th waveform.
790 // The first waveform is at j=1.
791 // In case j=0 (default) the info of all waveforms will be listed.
792 // In case j=-1 the info of all waveforms will be listed, but the header
793 // information will be suppressed.
794
795  if (j<-1) 
796  {
797   cout << " *AliSignal::ListWaveform* Invalid argument j = " << j << endl;
798   return;
799  }
800
801  if (j != -1)
802  {
803   const char* name=GetName();
804   const char* title=GetTitle();
805
806   cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
807   if (strlen(name))  cout << " Name : " << name;
808   if (strlen(title)) cout << " Title : " << title;
809   cout << endl;
810   if (fDevice)
811   {
812    const char* devname=fDevice->GetName();
813    const char* devtitle=fDevice->GetTitle();
814    cout << "   Owned by device : " << fDevice->ClassName();
815    if (strlen(devname))  cout << " Name : " << devname;
816    if (strlen(devtitle)) cout << " Title : " << devtitle;
817    cout << endl;
818   }
819  }
820
821  Int_t n=GetNwaveforms();
822  TObject* obj=0;
823
824  if (j<=0)
825  {
826   for (Int_t i=1; i<=n; i++)
827   {
828    obj=GetWaveform(i);
829    if (obj)
830    {
831     const char* wfname=obj->GetName();
832     const char* wftitle=obj->GetTitle();
833     cout << "    Waveform " << i << " : " << obj->ClassName();
834     if (strlen(wfname))  cout << " Name : " << wfname;
835     if (strlen(wftitle)) cout << " Title : " << wftitle;
836     cout << endl;
837    }
838   }
839  }
840  else
841  {
842   if (j<=n)
843   {
844    obj=GetWaveform(j);
845    if (obj)
846    {
847     const char* wfnamej=obj->GetName();
848     const char* wftitlej=obj->GetTitle();
849     cout << "    Waveform " << j << " : " << obj->ClassName();
850     if (strlen(wfnamej))  cout << " Name : " << wfnamej;
851     if (strlen(wftitlej)) cout << " Title : " << wftitlej;
852     cout << endl;
853    }
854   }
855  }
856 }
857 ///////////////////////////////////////////////////////////////////////////
858 Int_t AliSignal::GetNvalues() const
859 {
860 // Provide the number of values for this signal.
861  Int_t n=0;
862  if (fSignals) n=fSignals->GetSize();
863  return n;
864 }
865 ///////////////////////////////////////////////////////////////////////////
866 Int_t AliSignal::GetNerrors() const
867 {
868 // Provide the number specified errors on the values for this signal.
869  Int_t n=0;
870  if (fDsignals) n=fDsignals->GetSize();
871  return n;
872 }
873 ///////////////////////////////////////////////////////////////////////////
874 Int_t AliSignal::GetNwaveforms() const
875 {
876 // Provide the number of specified waveforms for this signal.
877 // Actually the return value is the highest index of the stored waveforms.
878 // This allows an index dependent meaning of waveform info (e.g. waveforms
879 // with various gain values).
880 // So, when all waveforms are stored in consequetive positions (e.g. 1,2,3),
881 // this memberfunction returns 3, being both the highest filled position
882 // and the actual number of waveforms.
883 // In case only waveforms are stored at positions 1,2,5,7 this memberfunction
884 // returns a value 7 whereas only 4 actual waveforms are present.
885 // This implies that when looping over the various waveform slots, one
886 // always has to check whether the returned pointer value is non-zero
887 // (which is a good practice anyhow).
888  Int_t n=-1;
889  if (fWaveforms) n=fWaveforms->GetLast();
890  return (n+1);
891 }
892 ///////////////////////////////////////////////////////////////////////////
893 TH1F* AliSignal::GetWaveform(Int_t j) const
894 {
895 // Provide pointer to the j-th waveform histogram.
896  TH1F* waveform=0;
897  if (j <= GetNwaveforms()) waveform=(TH1F*)fWaveforms->At(j-1);
898  return waveform;
899 }
900 ///////////////////////////////////////////////////////////////////////////
901 TH1F* AliSignal::GetWaveform(TString name) const
902 {
903 // Provide pointer to the waveform histogram with the specified name.
904 // In case no match is found, zero is returned.
905  Int_t n=GetNwaveforms();
906  TString str;
907  for (Int_t i=1; i<=n; i++)
908  {
909   TH1F* waveform=GetWaveform(i);
910   if (waveform)
911   {
912    str=waveform->GetName();
913    if (str == name) return waveform;
914   }
915  }
916  return 0; // No match found
917 }
918 ///////////////////////////////////////////////////////////////////////////
919 Int_t AliSignal::GetWaveformIndex(TString name) const
920 {
921 // Provide index to the waveform histogram with the specified name.
922 // In case no match is found, zero is returned.
923  Int_t n=GetNwaveforms();
924  TString str;
925  for (Int_t i=1; i<=n; i++)
926  {
927   TH1F* waveform=GetWaveform(i);
928   if (waveform)
929   {
930    str=waveform->GetName();
931    if (str == name) return i;
932   }
933  }
934  return 0; // No match found
935 }
936 ///////////////////////////////////////////////////////////////////////////
937 void AliSignal::SetWaveform(TH1F* waveform,Int_t j)
938 {
939 // Set the 1D waveform histogram for the j-th waveform.
940 //
941 // Notes :
942 //  The first waveform position at j=1.
943 //  j=1 is the default value.
944 //
945 // In case the value of the index j exceeds the maximum number of reserved
946 // positions for the waveforms, the number of reserved positions for the waveforms
947 // is increased automatically.
948 //
949 // In case the histo pointer argument has the same value as the current waveform
950 // histogram pointer value, no action is taken since the user has already
951 // modified the actual histogram.
952 //
953 // In case the histo pointer argument is zero, the current waveform histogram
954 // is deleted and the pointer set to zero.
955 //
956 // In all other cases the current waveform histogram is deleted and a new
957 // copy of the input histogram is created which becomes the current waveform
958 // histogram.
959
960  if (j<1) return;
961
962  if (!fWaveforms)
963  {
964   fWaveforms=new TObjArray(j);
965   fWaveforms->SetOwner();
966  }
967
968  if (j > fWaveforms->GetSize()) fWaveforms->Expand(j);
969
970  TH1F* hcur=(TH1F*)fWaveforms->At(j-1);
971  if (waveform != hcur)
972  {
973   if (hcur)
974   {
975    fWaveforms->Remove(hcur);
976    delete hcur;
977    hcur=0;
978   }
979   if (waveform)
980   {
981    hcur=new TH1F(*waveform);
982    fWaveforms->AddAt(hcur,j-1);
983   }
984  } 
985 }
986 ///////////////////////////////////////////////////////////////////////////
987 void AliSignal::ResetWaveform(Int_t j)
988 {
989 // Reset the histogram of the j-th (default j=1) waveform.
990 // This memberfunction invokes TH1F::Reset() for the corresponding waveform(s).
991 // To actually delete the histograms from memory, use DeleteWaveform().
992 // Notes : The first position is at j=1.
993 //         j=0 ==> All waveforms will be reset.
994  
995  if (!fWaveforms) return;
996
997  Int_t size=fWaveforms->GetSize();
998
999  if ((j>=0) && (j<=size))
1000  {
1001   if (j)
1002   {
1003    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
1004    if (hwave) hwave->Reset();
1005   }
1006   else
1007   {
1008    for (Int_t i=0; i<size; i++)
1009    {
1010     TH1F* hwave=(TH1F*)fWaveforms->At(i);
1011     if (hwave) hwave->Reset();
1012    }
1013   }
1014  }
1015  else
1016  {
1017   cout << " *AliSignal::ResetWaveform* Index j = " << j << " invalid." << endl;
1018   return;
1019  }
1020 }
1021 ///////////////////////////////////////////////////////////////////////////
1022 void AliSignal::ResetWaveform(TString name)
1023 {
1024 // Reset the waveform with the specified name.
1025  Int_t j=GetWaveformIndex(name);
1026  if (j>0) ResetWaveform(j);
1027 }
1028 ///////////////////////////////////////////////////////////////////////////
1029 void AliSignal::DeleteWaveform(Int_t j)
1030 {
1031 // Delete the histogram of the j-th (default j=1) waveform.
1032 // Notes : The first position is at j=1.
1033 //         j=0 ==> All waveforms will be deleted.
1034  
1035  if (!fWaveforms) return;
1036
1037  Int_t size=fWaveforms->GetSize();
1038
1039  if ((j>=0) && (j<=size))
1040  {
1041   if (j)
1042   {
1043    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
1044    if (hwave)
1045    {
1046     fWaveforms->Remove(hwave);
1047     delete hwave;
1048    }
1049   }
1050   else
1051   {
1052    delete fWaveforms;
1053    fWaveforms=0;
1054   }
1055  }
1056  else
1057  {
1058   cout << " *AliSignal::DeleteWaveform* Index j = " << j << " invalid." << endl;
1059   return;
1060  }
1061 }
1062 ///////////////////////////////////////////////////////////////////////////
1063 void AliSignal::DeleteWaveform(TString name)
1064 {
1065 // Delete the waveform with the specified name.
1066  Int_t j=GetWaveformIndex(name);
1067  if (j>0) DeleteWaveform(j);
1068 }
1069 ///////////////////////////////////////////////////////////////////////////
1070 Int_t AliSignal::GetNlinks(TObject* obj,Int_t j) const
1071 {
1072 // Provide the number of links to the specified object for the j-th slot.
1073 // If j=0 (default) all slots will be scanned for the specified object.
1074 // If obj=0 (default) all encountered objects for the specified slot will be counted.
1075 // So, invokation of the default GetNlinks() will return the total number of
1076 // all references to all sorts of stored objects.
1077  if (j<0)
1078  {
1079   cout << " *AliSignal::GetNlinks* Index j = " << j << " invalid." << endl;
1080   return 0;
1081  }
1082
1083  Int_t n=0;
1084  if (!j)
1085  {
1086   if (fLinks) n=fLinks->GetNrefs(obj);
1087  }
1088  else
1089  {
1090   TArrayI posarr;
1091   n=GetIndices(obj,j,posarr);
1092  }
1093  return n;
1094 }
1095 ///////////////////////////////////////////////////////////////////////////
1096 Int_t AliSignal::GetNlinks(TObject* obj,TString name) const
1097 {
1098 // Provide the number of links to the specified object for the name-spec. slot.
1099 // If obj=0 all encountered objects for the specified slot will be counted.
1100 //
1101 // This procedure involves a slot-index search based on the specified name
1102 // at each invokation. This may become slow in case many slots have been
1103 // defined and/or when this procedure is invoked many times.
1104 // In such cases it is preferable to use indexed addressing in the user code
1105 // either directly or via a few invokations of GetSlotIndex().
1106
1107  Int_t j=GetSlotIndex(name);
1108  Int_t n=0;
1109  if (j>0) n=GetNlinks(obj,j);
1110  return n;
1111 }
1112 ///////////////////////////////////////////////////////////////////////////
1113 TObject* AliSignal::GetLink(Int_t j,Int_t k) const
1114 {
1115 // Provide pointer of the object linked to the j-th slot at position k.
1116
1117  TObject* obj=0;
1118  // Note : In the internal storage matrix slots=columns positions=rows 
1119  if (fLinks) obj=fLinks->GetObject(k,j);
1120  return obj;
1121 }
1122 ///////////////////////////////////////////////////////////////////////////
1123 TObject* AliSignal::GetLink(TString name,Int_t k) const
1124 {
1125 // Provide pointer of the object linked to the name-spec. slot at position k.
1126 //
1127 // This procedure involves a slot-index search based on the specified name
1128 // at each invokation. This may become slow in case many slots have been
1129 // defined and/or when this procedure is invoked many times.
1130 // In such cases it is preferable to use indexed addressing in the user code
1131 // either directly or via a few invokations of GetSlotIndex().
1132
1133  Int_t j=GetSlotIndex(name);
1134  TObject* obj=0;
1135  if (j>0) obj=GetLink(j,k);
1136  return obj;
1137 }
1138 ///////////////////////////////////////////////////////////////////////////
1139 void AliSignal::SetLink(TObject* obj,Int_t j,Int_t k)
1140 {
1141 // Introduce a link (=pointer) to an object for the j-th slot at position k.
1142 // Only the pointer values are stored for (backward) reference, meaning
1143 // that the objects of which the pointers are stored are NOT owned
1144 // by the AliSignal object.
1145 //
1146 // Notes :
1147 //  The first slot is at j=1 and the first position is at k=1.
1148 //  j=1 and k=1 are the default values.
1149 //
1150 // If needed, the storage area for the links is increased automatically.
1151 //
1152 // In case the pointer argument is zero, indeed a value of zero will be
1153 // stored at the specified position (k) for the specified slot (j).
1154 //
1155 // In principle any object derived from TObject can be referred to by this
1156 // mechanism.
1157 // However, this "linking back" facility was introduced to enable AliSignal slots
1158 // to refer directly to the various AliTracks to which the AliSignal object itself
1159 // is related (see AliTrack::AddSignal).
1160 // Therefore, in case the input argument "obj" points to an AliTrack (or derived)
1161 // object, the current signal is automatically related to this AliTrack
1162 // (or derived) object.
1163 // 
1164 // Please also have a look at the docs of the memberfunction ResetLink()
1165 // to prevent the situation of stored pointers to non-existent object. 
1166
1167  if (!fLinks && obj) fLinks=new AliObjMatrix();
1168
1169  if (!fLinks) return;
1170
1171  // Note : In the internal storage matrix slots=columns positions=rows 
1172  fLinks->EnterObject(k,j,obj);
1173  if (obj) 
1174  {
1175   if (obj->InheritsFrom("AliTrack"))
1176   {
1177    AliTrack* t=(AliTrack*)obj;
1178    t->AddSignal(*this);
1179   }
1180  }
1181 }
1182 ///////////////////////////////////////////////////////////////////////////
1183 void AliSignal::SetLink(TObject* obj,TString name,Int_t k)
1184 {
1185 // Introduce a link (=pointer) to an object for the name-spec. slot at position k.
1186 // Only the pointer values are stored for (backward) reference, meaning
1187 // that the objects of which the pointers are stored are NOT owned
1188 // by the AliSignal object.
1189 //
1190 // This procedure involves a slot-index search based on the specified name
1191 // at each invokation. This may become slow in case many slots have been
1192 // defined and/or when this procedure is invoked many times.
1193 // In such cases it is preferable to use indexed addressing in the user code
1194 // either directly or via a few invokations of GetSlotIndex().
1195
1196  Int_t j=GetSlotIndex(name);
1197  if (j>0) SetLink(obj,j,k);
1198 }
1199 ///////////////////////////////////////////////////////////////////////////
1200 void AliSignal::AddLink(TObject* obj,Int_t j)
1201 {
1202 // Introduce a link (=pointer) to an object for the j-th slot at the first
1203 // free position.
1204 // Only the pointer values are stored for (backward) reference, meaning
1205 // that the objects of which the pointers are stored are NOT owned
1206 // by the AliSignal object.
1207 //
1208 // Notes :
1209 //  The first slot is at j=1 and the first position is at k=1.
1210 //  j=1 is the default value.
1211 //
1212 // If needed, the storage area for the links is increased automatically.
1213 //
1214 // In case the pointer argument is zero, no link will be added.
1215 //
1216 // In principle any object derived from TObject can be referred to by this
1217 // mechanism.
1218 // However, this "linking back" facility was introduced to enable AliSignal slots
1219 // to refer directly to the various AliTracks to which the AliSignal object itself
1220 // is related (see AliTrack::AddSignal).
1221 // Therefore, in case the input argument "obj" points to an AliTrack (or derived)
1222 // object, the current signal is automatically related to this AliTrack
1223 // (or derived) object.
1224 // 
1225 // Please also have a look at the docs of the memberfunction ResetLink()
1226 // to prevent the situation of stored pointers to non-existent object. 
1227
1228  if (!obj || j<=0) return;
1229
1230  if (!fLinks) fLinks=new AliObjMatrix();
1231
1232  TObject* dum=0;
1233  Int_t n=GetNlinks(dum,j);
1234  Int_t pos=1;
1235  for (Int_t k=1; k<=n; k++)
1236  {
1237   dum=GetLink(j,k);
1238   if (!dum) break;
1239   pos++;
1240  }
1241
1242  SetLink(obj,j,pos);
1243 }
1244 ///////////////////////////////////////////////////////////////////////////
1245 void AliSignal::AddLink(TObject* obj,TString name)
1246 {
1247 // Introduce a link (=pointer) to an object for the name-spec slot at the first
1248 // free position.
1249 // Only the pointer values are stored for (backward) reference, meaning
1250 // that the objects of which the pointers are stored are NOT owned
1251 // by the AliSignal object.
1252 //
1253 // This procedure involves a slot-index search based on the specified name
1254 // at each invokation. This may become slow in case many slots have been
1255 // defined and/or when this procedure is invoked many times.
1256 // In such cases it is preferable to use indexed addressing in the user code
1257 // either directly or via a few invokations of GetSlotIndex().
1258
1259  Int_t j=GetSlotIndex(name);
1260  if (j>0) AddLink(obj,j);
1261 }
1262 ///////////////////////////////////////////////////////////////////////////
1263 void AliSignal::ResetLink(Int_t j,Int_t k)
1264 {
1265 // Reset the link of the j-th slot at position k.
1266 //
1267 // Notes :
1268 //  The first slot is at j=1 and the first position is at k=1.
1269 //  j=1 and k=1 are the default values.
1270 //
1271 //  This memberfunction is intended to reset only 1 specified link location.
1272 //  For extended functionality, please refer to the memberfuction ResetLinks().
1273 //
1274 // In general the user should take care of properly clearing the corresponding
1275 // pointer here when the referred object is deleted.
1276 // However, this "linking back" facility was introduced to enable AliSignal slots
1277 // to refer directly to the various AliTracks to which the AliSignal object itself
1278 // is related (see AliTrack::AddSignal).
1279 // As such, the AliTrack destructor already takes care of clearing the corresponding
1280 // links from the various AliSignal slots for all the AliSignal objects that were
1281 // related to that AliTrack. 
1282 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
1283 // the user doesn't have to worry about clearing the corresponding AliTrack link from
1284 // the AliSignal object when the corresponding AliTrack object is deleted.
1285  
1286  // Note : In the internal storage matrix slots=columns positions=rows 
1287  if (fLinks) fLinks->RemoveObject(k,j);
1288 }
1289 ///////////////////////////////////////////////////////////////////////////
1290 void AliSignal::ResetLink(TString name,Int_t k)
1291 {
1292 // Reset the link of the name-specified slot at position k.
1293 //
1294 // This memberfunction is intended to reset only 1 specified link location.
1295 // For extended functionality, please refer to the memberfuction ResetLinks().
1296 //
1297 // This procedure involves a slot-index search based on the specified name
1298 // at each invokation. This may become slow in case many slots have been
1299 // defined and/or when this procedure is invoked many times.
1300 // In such cases it is preferable to use indexed addressing in the user code
1301 // either directly or via a few invokations of GetSlotIndex().
1302
1303  Int_t j=GetSlotIndex(name);
1304  if (j>0) ResetLink(j,k);
1305 }
1306 ///////////////////////////////////////////////////////////////////////////
1307 void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
1308 {
1309 // Reset single or multiple link(s) according to user specified selections.
1310 //
1311 // A link is only reset if the stored reference matches the argument "obj".
1312 // In case obj=0 no check on the matching of the stored reference is performed
1313 // and the stored link is always reset in accordance with the other
1314 // selection criteria.
1315 //
1316 // In case the slot argument "j" is specified, only the links from that
1317 // specified slot will be deleted.
1318 // In case j=0 (default) no checking on the slot index is performed.
1319 //
1320 // In case the position argument "k" is specified, only the links from that
1321 // specified position will be deleted.
1322 // In case k=0 (default) no checking on the position index is performed.
1323 //
1324 // So, invokation of ResetLinks(obj) will remove all references to the
1325 // object "obj" from the total AliSignal, whereas ResetLinks(obj,j)
1326 // will remove all references to the object "obj" only from slot "j".
1327 //
1328 // Notes :
1329 // -------
1330 // The first slot is indicated as j=1, whereas the first position is at k=1.
1331 //
1332 // Invokation of ResetLinks(0,row,col) is equivalent to invoking the
1333 // memberfunction ResetLink(row,col).
1334 // Invoking the latter directly is slightly faster.
1335 //
1336 // Invokation of ResetLinks(0) will reset all stored references in this AliSignal.
1337 //
1338 // In general the user should take care of properly clearing the corresponding
1339 // pointer here when the referred object is deleted.
1340 // However, this "linking back" facility was introduced to enable AliSignal slots
1341 // to refer directly to the various AliTracks to which the AliSignal object itself
1342 // is related (see AliTrack::AddSignal).
1343 // As such, the AliTrack destructor already takes care of clearing the corresponding
1344 // links from the various AliSignal slots for all the AliSignal objects that were
1345 // related to that AliTrack. 
1346 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
1347 // the user doesn't have to worry about clearing the corresponding AliTrack link from
1348 // the AliSignal object when the corresponding AliTrack object is deleted.
1349  
1350  if (!fLinks) return;
1351
1352  if (!obj && !j && !k)
1353  {
1354   fLinks->Reset();
1355  }
1356  else
1357  {
1358   // Note : In the internal storage matrix slots=columns positions=rows 
1359   fLinks->RemoveObjects(obj,k,j);
1360  }
1361 }
1362 ///////////////////////////////////////////////////////////////////////////
1363 void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
1364 {
1365 // Reset single or multiple link(s) according to user specified selections.
1366 //
1367 // A link is only reset if the stored reference matches the argument "obj".
1368 // In case obj=0 no check on the matching of the stored reference is performed
1369 // and the stored link is always reset in accordance with the other
1370 // selection criteria.
1371 //
1372 // In case the position argument "k" is specified, only the links from that
1373 // specified position will be deleted.
1374 // In case k=0 (default) no checking on the position index is performed.
1375 //
1376 // This procedure involves a slot-index search based on the specified name
1377 // at each invokation. This may become slow in case many slots have been
1378 // defined and/or when this procedure is invoked many times.
1379 // In such cases it is preferable to use indexed addressing in the user code
1380 // either directly or via a few invokations of GetSlotIndex().
1381
1382  Int_t j=GetSlotIndex(name);
1383  if (j>0) ResetLinks(obj,j,k);
1384 }
1385 ///////////////////////////////////////////////////////////////////////////
1386 Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,TArrayI& ks) const
1387 {
1388 // Provide the slot and position indices of all the storage locations
1389 // of the specified object.
1390 // The slot (j) and pos. (k) indices are returned in the two separate TArrayI arrays
1391 // from which the (j,k) pairs can be obtained from the corresponding
1392 // array indices like (j,k)=(js.At(i),ks.At(i)).
1393 // The integer return argument represents the number of (j,k) pairs which
1394 // were encountered for the specified object.
1395 //
1396 // If obj=0 no object selection is performed and all (j,k) indices
1397 // of the stored references for all objects are returned.
1398 //
1399 // Notes :
1400 // -------
1401 // As usual the convention is that slot and position numbering starts at 1.
1402 // 
1403 // This memberfunction always resets the two TArrayI arrays at the start.
1404 //
1405 // This memberfunction can only be used to obtain the (j,k) indices
1406 // of the object as stored via the SetLink() or AddLink() memberfunction.
1407 // This means that in case the user has entered a TObjArray as object
1408 // (to increase the dimension of the resulting structure), the (j,k)
1409 // indices of that TObjArray are obtained and NOT the indices of the
1410 // actual objects contained in that TObjArray structure.
1411 //
1412  Int_t nrefs=0;
1413  js.Reset();
1414  ks.Reset();
1415  // Note : In the internal storage matrix slots=columns positions=rows 
1416  if (fLinks) nrefs=fLinks->GetIndices(obj,ks,js);
1417  return nrefs;
1418 }
1419 ///////////////////////////////////////////////////////////////////////////
1420 Int_t AliSignal::GetIndices(TObject* obj,Int_t j,TArrayI& ks) const
1421 {
1422 // Provide the position indices of all the storage locations of the
1423 // specified object in the j-th slot of this AliSignal.
1424 // The position indices are returned in the TArrayI array.
1425 // The integer return argument represents the number of storage locations which
1426 // were encountered for the specified object in the j-th slot.
1427 //
1428 // If obj=0 no object selection is performed and all position indices
1429 // of the stored references for all objects of the j-th slot are returned.
1430 //
1431 // If j=0 all slots will be scanned and all position indices matching the
1432 // object selection are returned.
1433 // Note that in this case multiple appearances of the same position index
1434 // will only be recorded once in the returned TArrayI array.
1435 //
1436 // Notes :
1437 // -------
1438 // As usual the convention is that slot and position numbering starts at 1.
1439 // 
1440 // This memberfunction always resets the TArrayI array at the start.
1441 //
1442 // This memberfunction can only be used to obtain the position indices
1443 // of the object as stored via the SetLink() or AddLink() memberfunction.
1444 // This means that in case the user has entered a TObjArray as object
1445 // (to increase the dimension of the resulting structure), the position
1446 // indices of that TObjArray are obtained and NOT the indices of the
1447 // actual objects contained in that TObjArray structure.
1448 //
1449  Int_t nrefs=0;
1450  ks.Reset();
1451  // Note : In the internal storage matrix slots=columns positions=rows 
1452  if (fLinks) nrefs=fLinks->GetIndices(obj,ks,j);
1453  return nrefs;
1454 }
1455 ///////////////////////////////////////////////////////////////////////////
1456 Int_t AliSignal::GetIndices(TObject* obj,TString name,TArrayI& ks) const
1457 {
1458 // Provide the position indices of all the storage locations of the
1459 // specified object in the name-specified slot of this AliSignal.
1460 // The position indices are returned in the TArrayI array.
1461 // The integer return argument represents the number of storage locations which
1462 // were encountered for the specified object in the j-th slot.
1463 //
1464 // If obj=0 no object selection is performed and all position indices
1465 // of the stored references for all objects of the j-th slot are returned.
1466 //
1467 // This procedure involves a slot-index search based on the specified name
1468 // at each invokation. This may become slow in case many slots have been
1469 // defined and/or when this procedure is invoked many times.
1470 // In such cases it is preferable to use indexed addressing in the user code
1471 // either directly or via a few invokations of GetSlotIndex().
1472
1473  Int_t j=GetSlotIndex(name);
1474  Int_t n=0;
1475  if (j>0) n=GetIndices(obj,j,ks);
1476  return n;
1477 }
1478 ///////////////////////////////////////////////////////////////////////////
1479 Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,Int_t k) const
1480 {
1481 // Provide the slot indices of all the storage locations of the
1482 // specified object for the k-th position in this AliSignal.
1483 // The slot indices are returned in the TArrayI array.
1484 // The integer return argument represents the number of storage locations which
1485 // were encountered for the specified object in the k-th position.
1486 //
1487 // If obj=0 no object selection is performed and all slot indices
1488 // of the stored references for all objects in the k-th position are returned.
1489 //
1490 // If k=0 all positions will be scanned and all slot indices matching the
1491 // object selection are returned.
1492 // Note that in this case multiple appearances of the same slot index
1493 // will only be recorded once in the returned TArrayI array.
1494 //
1495 // Notes :
1496 // -------
1497 // As usual the convention is that slot and position numbering starts at 1.
1498 // 
1499 // This memberfunction always resets the TArrayI array at the start.
1500 //
1501 // This memberfunction can only be used to obtain the slot indices
1502 // of the object as stored via the SetLink() or AddLink() memberfunction.
1503 // This means that in case the user has entered a TObjArray as object
1504 // (to increase the dimension of the resulting structure), the slot
1505 // indices of that TObjArray are obtained and NOT the indices of the
1506 // actual objects contained in that TObjArray structure.
1507 //
1508  Int_t nrefs=0;
1509  js.Reset();
1510  // Note : In the internal storage matrix slots=columns positions=rows 
1511  if (fLinks) nrefs=fLinks->GetIndices(obj,k,js);
1512  return nrefs;
1513 }
1514 ///////////////////////////////////////////////////////////////////////////
1515 void AliSignal::SetSwapMode(Int_t swap)
1516 {
1517 // Set swapmode flag for the internal link storage.
1518 // In case for the stored links the maximum slot number differs considerably
1519 // from the maximum position number, it might be more efficient
1520 // (w.r.t. memory usage and/or output file size) to internally store the
1521 // link reference matrix with the rows and colums swapped.
1522 // This swapping is only related with the internal storage and as such
1523 // is completely hidden for the user.
1524 // At invokation of this memberfunction the default argument is swap=1.
1525 //
1526 // Note : The swap mode can only be set as long as no links are
1527 //        stored in the AliSignal (i.e. a new instance of AliSignal
1528 //        or after invokation of the Reset() or ResetLinks() function).
1529  
1530  if (!fLinks) fLinks=new AliObjMatrix();
1531  fLinks->SetSwapMode(swap);
1532 }
1533 ///////////////////////////////////////////////////////////////////////////
1534 Int_t AliSignal::GetSwapMode() const
1535 {
1536 // Provide swapmode flag of the link storage.
1537  Int_t swap=0; 
1538  if (fLinks) swap=fLinks->GetSwapMode();
1539  return swap;
1540 }
1541 ///////////////////////////////////////////////////////////////////////////
1542 void AliSignal::SetDevice(TObject* dev)
1543 {
1544 // Store the pointer to the device which owns this AliSignal object.
1545 // This memberfunction is meant for internal use in AliDevice.
1546  fDevice=dev;
1547 }
1548 ///////////////////////////////////////////////////////////////////////////
1549 AliDevice* AliSignal::GetDevice() const
1550 {
1551 // Provide the pointer to the device which owns this AliSignal object.
1552  return (AliDevice*)fDevice;
1553 }
1554 ///////////////////////////////////////////////////////////////////////////
1555 TObject* AliSignal::Clone(const char* name) const
1556 {
1557 // Make a deep copy of the current object and provide the pointer to the copy.
1558 // This memberfunction enables automatic creation of new objects of the
1559 // correct type depending on the object type, a feature which may be very useful
1560 // for containers when adding objects in case the container owns the objects.
1561 // This feature allows e.g. AliTrack to store either AliSignal objects or
1562 // objects derived from AliSignal via the AddSignal memberfunction, provided
1563 // these derived classes also have a proper Clone memberfunction. 
1564
1565  AliSignal* sig=new AliSignal(*this);
1566  if (name)
1567  {
1568   if (strlen(name)) sig->SetName(name);
1569  }
1570  return sig;
1571 }
1572 ///////////////////////////////////////////////////////////////////////////