1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////
20 // Generic handling of (extrapolated) detector signals.
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).
37 // Signal positions (r) and reference frames (f) are specified via
38 // SetPosition(r,f) under the following conventions :
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)
44 // The same holds for SetPositionErrors().
46 // All angles are in radians.
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;
59 // s.SetPosition(pos,"car");
60 // s.SetPositionErrors(err,"car");
61 // s.SetSignal(signal);
62 // s.SetSignalError(error);
63 // s.SetOffset(offset);
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();
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
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
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
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");
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);
108 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
109 //- Modified: NvE $Date$ UU-SAP Utrecht
110 ///////////////////////////////////////////////////////////////////////////
112 #include "AliSignal.h"
113 #include "AliTrack.h"
114 #include "Riostream.h"
116 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
118 AliSignal::AliSignal() : TNamed(),AliPosition(),AliAttrib()
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.
130 ///////////////////////////////////////////////////////////////////////////
131 AliSignal::~AliSignal()
133 // Destructor to delete dynamically allocated memory
151 // Remove this signal from all related tracks
152 for (Int_t i=1; i<=fLinks->GetNobjects(); i++)
154 TObject* obj=fLinks->GetObject(i);
156 if (obj->InheritsFrom("AliTrack"))
158 AliTrack* tx=(AliTrack*)obj;
159 tx->RemoveSignal(*this);
166 ///////////////////////////////////////////////////////////////////////////
167 AliSignal::AliSignal(const AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
175 // Don't copy the owning device pointer for the copy
178 Int_t n=s.GetNvalues();
180 for (Int_t i=1; i<=n; i++)
187 for (Int_t j=1; j<=n; j++)
189 val=s.GetSignalError(j);
190 SetSignalError(val,j);
194 for (Int_t k=1; k<=n; k++)
196 TH1F* hist=s.GetWaveform(k);
197 if (hist) SetWaveform(hist,k);
203 n=s.GetIndices(dum,slotarr,posarr);
205 for (Int_t idx=0; idx<n; idx++)
207 slot=slotarr.At(idx);
209 TObject* obj=s.GetLink(slot,pos);
210 if (obj) SetLink(obj,slot,pos);
213 ///////////////////////////////////////////////////////////////////////////
214 void AliSignal::Reset(Int_t mode)
216 // Reset all signal and position values and errors to 0.
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.
224 // The default when invoking Reset() corresponds to mode=0.
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.
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.
239 // For more specific actions see ResetPosition(), ResetSignals(),
240 // DeleteSignals(), ResetGain(), ResetOffset(), ResetLink(), ResetWaveform(),
241 // DeleteWaveform() and DeleteCalibrations().
244 if (mode<0 || mode>1)
246 cout << " *AliSignal::Reset* Invalid argument mode = " << mode << endl;
247 cout << " Default mode=0 will be used." << endl;
259 DeleteCalibrations();
262 if (fLinks) fLinks->Reset();
265 ///////////////////////////////////////////////////////////////////////////
266 void AliSignal::ResetSignals(Int_t mode)
268 // Reset various signal data according to user selection.
270 // mode = 0 Reset all signal values and their errors to 0.
271 // 1 Reset only signal values
272 // 2 Reset only signal errors
274 // The default when invoking ResetSignals() corresponds to mode=0.
276 // Irrespective of the mode, the waveform histograms are reset.
278 if (mode<0 || mode>2)
280 cout << " *AliSignal::ResetSignals* Invalid argument mode = " << mode << endl;
281 cout << " Default mode=0 will be used." << endl;
285 if (fSignals && (mode==0 || mode==1))
287 for (Int_t i=0; i<fSignals->GetSize(); i++)
289 fSignals->AddAt(0,i);
293 if (fDsignals && (mode==0 || mode==2))
295 for (Int_t j=0; j<fDsignals->GetSize(); j++)
297 fDsignals->AddAt(0,j);
303 ///////////////////////////////////////////////////////////////////////////
304 void AliSignal::DeleteSignals(Int_t mode)
306 // Delete storage arrays of various signal data according to user selection.
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
312 // The default when invoking DeleteSignals() corresponds to mode=0.
314 // Irrespective of the mode, the waveform histograms are deleted.
316 if (mode<0 || mode>2)
318 cout << " *AliSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
319 cout << " Default mode=0 will be used." << endl;
323 if (fSignals && (mode==0 || mode==1))
329 if (fDsignals && (mode==0 || mode==2))
337 ///////////////////////////////////////////////////////////////////////////
338 void AliSignal::SetSignal(Double_t sig,Int_t j)
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.
348 fSignals=new TArrayF(j);
352 Int_t size=fSignals->GetSize();
359 fSignals->AddAt(float(sig),j-1);
361 ///////////////////////////////////////////////////////////////////////////
362 void AliSignal::SetSignal(Double_t sig,TString name)
364 // Store signal value for the name-specified slot.
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().
372 Int_t j=GetSlotIndex(name);
373 if (j>0) SetSignal(sig,j);
375 ///////////////////////////////////////////////////////////////////////////
376 void AliSignal::AddSignal(Double_t sig,Int_t j)
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.
386 fSignals=new TArrayF(j);
390 Int_t size=fSignals->GetSize();
397 Float_t sum=(fSignals->At(j-1))+sig;
398 fSignals->AddAt(sum,j-1);
400 ///////////////////////////////////////////////////////////////////////////
401 void AliSignal::AddSignal(Double_t sig,TString name)
403 // Add value to the signal of the name-specified slot.
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().
411 Int_t j=GetSlotIndex(name);
412 if (j>0) AddSignal(sig,j);
414 ///////////////////////////////////////////////////////////////////////////
415 Float_t AliSignal::GetSignal(Int_t j,Int_t mode) const
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).
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 // The corresponding AliDevice slot is obtained via matching of
433 // the slotnames. In case this fails, the slotindex "j" of the
434 // input argument will be used.
435 // In case this AliSignal object has no parent AliDevice, just
436 // the j-th signal is returned (like with mode=0).
437 // 3 : The j-th signal is corrected using the corresponding calibration
439 // In case the j-th slot was marked dead, 0 is returned.
440 // In case no calibration function is present, just the j-th signal
441 // is returned (like with mode=0).
442 // 4 : Same as mode=3 but the calibration function and dead flag are
443 // taken from the AliDevice which owns this AliSignal object.
444 // The corresponding AliDevice slot is obtained via matching of
445 // the slotnames. In case this fails, the slotindex "j" of the
446 // input argument will be used.
447 // 5 : Same as mode=2 but in case no parent AliDevice is present
448 // an automatic switch to mode=1 will be made.
449 // 6 : Same as mode=4 but in case no parent AliDevice is present
450 // an automatic switch to mode=3 will be made.
451 // 7 : Same as mode=3 but in case no calibration function is present
452 // an automatic switch to mode=4 will be made.
453 // 8 : Same as mode=7 but also the corresponding dead flag of the
454 // parent device (if any) will be checked.
455 // If either the dead flag of the requested signal slot of this
456 // AliSignal object or the corresponding parent device slot is
457 // set, 0 is returned.
459 // <0 : The corresponding de-correction or de-calibration is performed
461 // The corrected signal (sigc) is determined as follows :
463 // sigc=(signal/gain)-offset
465 // The de-corrected signal is determined as follows :
467 // signal=(sigc+offset)*gain
469 // The default is mode=0.
471 if (abs(mode)>8) return 0;
478 // Get the corresponding slot index (and dead flag) of the parent device
481 AliSignal* parent=(AliSignal*)GetDevice();
482 if ((abs(mode)==2 || abs(mode)>=4) && parent)
484 TString name=GetSlotName(j);
485 if (strlen(name.Data())) pj=parent->GetSlotIndex(name);
486 if (abs(mode)==8 && pj) pdead=parent->GetDeadValue(pj);
489 if (mode==-8) mode=-7;
491 AliSignal* sx=(AliSignal*)this;
496 f=sx->GetCalFunction(jcal);
508 f=sx->GetDecalFunction(jcal);
519 if (abs(mode)==2 || abs(mode)>=4)
521 sx=(AliSignal*)GetDevice();
524 if (!sx && abs(mode)>=5) sx=(AliSignal*)this;
526 if (mode==-5) mode=-2;
528 if (mode==-6) mode=-3;
532 if (j>0 && j<=(fSignals->GetSize()))
534 sig=fSignals->At(j-1);
536 if (mode==0 || !sx) return sig;
538 // Check for the dead flag setting
539 if (sx->GetDeadValue(jcal) || pdead) return 0;
541 // (De)correct the signal for the gain and offset
542 if (abs(mode)==1 || abs(mode)==2)
544 if (sx->GetGainFlag(jcal)) gain=sx->GetGain(jcal);
545 if (sx->GetOffsetFlag(jcal)) offset=sx->GetOffset(jcal);
549 if (mode>0) sig=(sig/gain)-offset; // Gain and offset correction
550 if (mode<0) sig=(sig+offset)*gain; // Gain and offset de-correction
559 // (De)calibrate the signal with the corresponding (de)calibration function
560 if (abs(mode)==3 || abs(mode)==4)
562 f=sx->GetCalFunction(jcal);
563 if (mode<0) f=sx->GetDecalFunction(jcal);
564 if (f) sig=f->Eval(sig);
570 cout << " *AliSignal::GetSignal* Index j = " << j << " invalid." << endl;
575 ///////////////////////////////////////////////////////////////////////////
576 Float_t AliSignal::GetSignal(TString name,Int_t mode) const
578 // Provide signal value of the name-specified slot.
579 // In case no signal is present, 0 is returned.
580 // The parameter "mode" allows for automatic (de)calibration of the signal
581 // (e.g. gain etc... correction or via explicit (de)calibration functions).
582 // For further details about the (de)calibration modes, please refer to the
583 // corresponding slot-index based memberfunction.
585 // The default is mode=0.
587 // This procedure involves a slot-index search based on the specified name
588 // at each invokation. This may become slow in case many slots have been
589 // defined and/or when this procedure is invoked many times.
590 // In such cases it is preferable to use indexed addressing in the user code
591 // either directly or via a few invokations of GetSlotIndex().
593 Int_t j=GetSlotIndex(name);
595 if (j>0) val=GetSignal(j,mode);
598 ///////////////////////////////////////////////////////////////////////////
599 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
601 // Store error on the signal for the j-th (default j=1) slot.
602 // Note : The first signal slot is at j=1.
603 // In case the value of the index j exceeds the maximum number of reserved
604 // slots for signal error values, the number of reserved slots for the
605 // signal errors is increased automatically.
609 fDsignals=new TArrayF(j);
613 Int_t size=fDsignals->GetSize();
620 fDsignals->AddAt(float(dsig),j-1);
622 ///////////////////////////////////////////////////////////////////////////
623 void AliSignal::SetSignalError(Double_t dsig,TString name)
625 // Store error on the signal for the name-specified slot.
627 // This procedure involves a slot-index search based on the specified name
628 // at each invokation. This may become slow in case many slots have been
629 // defined and/or when this procedure is invoked many times.
630 // In such cases it is preferable to use indexed addressing in the user code
631 // either directly or via a few invokations of GetSlotIndex().
633 Int_t j=GetSlotIndex(name);
634 if (j>0) SetSignalError(dsig,j);
636 ///////////////////////////////////////////////////////////////////////////
637 Float_t AliSignal::GetSignalError(Int_t j) const
639 // Provide error on the signal of the j-th (default j=1) slot.
640 // Note : The first signal slot is at j=1.
641 // In case no signal is present or the argument j is invalid, 0 is returned.
645 if (j>0 && j<=(fDsignals->GetSize()))
647 err=fDsignals->At(j-1);
651 cout << " *AliSignal::GetSignalError* Index j = " << j << " invalid." << endl;
656 ///////////////////////////////////////////////////////////////////////////
657 Float_t AliSignal::GetSignalError(TString name) const
659 // Provide error on the signal of the name-specified slot.
661 // This procedure involves a slot-index search based on the specified name
662 // at each invokation. This may become slow in case many slots have been
663 // defined and/or when this procedure is invoked many times.
664 // In such cases it is preferable to use indexed addressing in the user code
665 // either directly or via a few invokations of GetSlotIndex().
667 Int_t j=GetSlotIndex(name);
669 if (j>0) val=GetSignalError(j);
672 ///////////////////////////////////////////////////////////////////////////
673 void AliSignal::Data(TString f,TString u) const
675 // Provide all signal information within the coordinate frame f.
677 // The string argument "u" allows to choose between different angular units
678 // in case e.g. a spherical frame is selected.
679 // u = "rad" : angles provided in radians
680 // "deg" : angles provided in degrees
682 // The defaults are f="car" and u="rad".
684 const char* name=GetName();
685 const char* title=GetTitle();
687 cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
688 if (strlen(name)) cout << " Name : " << name;
689 if (strlen(title)) cout << " Title : " << title;
692 AliPosition::Data(f,u);
695 const char* devname=fDevice->GetName();
696 const char* devtitle=fDevice->GetTitle();
697 cout << " Owned by device : " << fDevice->ClassName()
698 << " Id : " << fDevice->GetUniqueID();
699 if (strlen(devname)) cout << " Name : " << devname;
700 if (strlen(devtitle)) cout << " Title : " << devtitle;
704 // Provide an overview of the stored waveforms
707 // Provide an overview of all the data and attribute slots
710 ///////////////////////////////////////////////////////////////////////////
711 void AliSignal::List(Int_t j) const
713 // Provide signal information for the j-th slot.
714 // The first slot is at j=1.
715 // In case j=0 (default) the data of all slots will be listed.
716 // In case j=-1 the data of all slots will be listed, but the header
717 // information will be suppressed.
721 cout << " *AliSignal::List* Invalid argument j = " << j << endl;
727 const char* name=GetName();
728 const char* title=GetTitle();
730 cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
731 if (strlen(name)) cout << " Name : " << name;
732 if (strlen(title)) cout << " Title : " << title;
736 const char* devname=fDevice->GetName();
737 const char* devtitle=fDevice->GetTitle();
738 cout << " Owned by device : " << fDevice->ClassName();
739 if (strlen(devname)) cout << " Name : " << devname;
740 if (strlen(devtitle)) cout << " Title : " << devtitle;
745 Int_t nvalues=GetNvalues();
746 Int_t nerrors=GetNerrors();
748 if (fLinks) nlinkslots=fLinks->GetMaxColumn();
749 Int_t ncalibs=GetNcalflags();
750 Int_t ncalfuncs=GetNcalfuncs();
751 Int_t ndecalfuncs=GetNdecalfuncs();
754 if (nerrors>n) n=nerrors;
755 if (nlinkslots>n) n=nlinkslots;
756 if (InheritsFrom("AliDevice"))
758 if (ncalibs>n) n=ncalibs;
759 if (ncalfuncs>n) n=ncalfuncs;
760 if (ndecalfuncs>n) n=ndecalfuncs;
770 for (Int_t i=1; i<=n; i++)
772 cout << " Slot : " << i;
773 if (i<=nvalues) cout << " Signal value : " << GetSignal(i);
774 if (i<=nerrors) cout << " error : " << GetSignalError(i);
778 nrefs=GetIndices(obj,i,posarr);
779 for (Int_t k=0; k<nrefs; k++)
785 cout << " Link at position " << pos << " to : " << obj->ClassName();
786 if (obj->InheritsFrom("TNamed"))
788 const char* lname=obj->GetName();
789 const char* ltitle=obj->GetTitle();
790 if (strlen(lname)) cout << " Name : " << lname;
791 if (strlen(ltitle)) cout << " Title : " << ltitle;
802 cout << " Slot : " << j;
803 if (j<=nvalues) cout << " Signal value : " << GetSignal(j);
804 if (j<=nerrors) cout << " error : " << GetSignalError(j);
808 nrefs=GetIndices(obj,j,posarr);
809 for (Int_t kj=0; kj<nrefs; kj++)
815 cout << " Link at position " << pos << " to : " << obj->ClassName();
816 if (obj->InheritsFrom("TNamed"))
818 const char* lnamej=obj->GetName();
819 const char* ltitlej=obj->GetTitle();
820 if (strlen(lnamej)) cout << " Name : " << lnamej;
821 if (strlen(ltitlej)) cout << " Title : " << ltitlej;
829 ///////////////////////////////////////////////////////////////////////////
830 void AliSignal::List(TString name) const
832 // Provide signal information for the name-specified slot.
834 // This procedure involves a slot-index search based on the specified name
835 // at each invokation. This may become slow in case many slots have been
836 // defined and/or when this procedure is invoked many times.
837 // In such cases it is preferable to use indexed addressing in the user code
838 // either directly or via a few invokations of GetSlotIndex().
840 Int_t j=GetSlotIndex(name);
843 ///////////////////////////////////////////////////////////////////////////
844 void AliSignal::ListWaveform(Int_t j) const
846 // Provide information for the j-th waveform.
847 // The first waveform is at j=1.
848 // In case j=0 (default) the info of all waveforms will be listed.
849 // In case j=-1 the info of all waveforms will be listed, but the header
850 // information will be suppressed.
854 cout << " *AliSignal::ListWaveform* Invalid argument j = " << j << endl;
860 const char* name=GetName();
861 const char* title=GetTitle();
863 cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
864 if (strlen(name)) cout << " Name : " << name;
865 if (strlen(title)) cout << " Title : " << title;
869 const char* devname=fDevice->GetName();
870 const char* devtitle=fDevice->GetTitle();
871 cout << " Owned by device : " << fDevice->ClassName();
872 if (strlen(devname)) cout << " Name : " << devname;
873 if (strlen(devtitle)) cout << " Title : " << devtitle;
878 Int_t n=GetNwaveforms();
883 for (Int_t i=1; i<=n; i++)
888 const char* wfname=obj->GetName();
889 const char* wftitle=obj->GetTitle();
890 cout << " Waveform " << i << " : " << obj->ClassName();
891 if (strlen(wfname)) cout << " Name : " << wfname;
892 if (strlen(wftitle)) cout << " Title : " << wftitle;
904 const char* wfnamej=obj->GetName();
905 const char* wftitlej=obj->GetTitle();
906 cout << " Waveform " << j << " : " << obj->ClassName();
907 if (strlen(wfnamej)) cout << " Name : " << wfnamej;
908 if (strlen(wftitlej)) cout << " Title : " << wftitlej;
914 ///////////////////////////////////////////////////////////////////////////
915 Int_t AliSignal::GetNvalues() const
917 // Provide the number of values for this signal.
919 if (fSignals) n=fSignals->GetSize();
922 ///////////////////////////////////////////////////////////////////////////
923 Int_t AliSignal::GetNerrors() const
925 // Provide the number specified errors on the values for this signal.
927 if (fDsignals) n=fDsignals->GetSize();
930 ///////////////////////////////////////////////////////////////////////////
931 Int_t AliSignal::GetNwaveforms() const
933 // Provide the number of specified waveforms for this signal.
934 // Actually the return value is the highest index of the stored waveforms.
935 // This allows an index dependent meaning of waveform info (e.g. waveforms
936 // with various gain values).
937 // So, when all waveforms are stored in consequetive positions (e.g. 1,2,3),
938 // this memberfunction returns 3, being both the highest filled position
939 // and the actual number of waveforms.
940 // In case only waveforms are stored at positions 1,2,5,7 this memberfunction
941 // returns a value 7 whereas only 4 actual waveforms are present.
942 // This implies that when looping over the various waveform slots, one
943 // always has to check whether the returned pointer value is non-zero
944 // (which is a good practice anyhow).
946 if (fWaveforms) n=fWaveforms->GetLast();
949 ///////////////////////////////////////////////////////////////////////////
950 TH1F* AliSignal::GetWaveform(Int_t j) const
952 // Provide pointer to the j-th waveform histogram.
954 if (j <= GetNwaveforms()) waveform=(TH1F*)fWaveforms->At(j-1);
957 ///////////////////////////////////////////////////////////////////////////
958 TH1F* AliSignal::GetWaveform(TString name) const
960 // Provide pointer to the waveform histogram with the specified name.
961 // In case no match is found, zero is returned.
962 Int_t n=GetNwaveforms();
964 for (Int_t i=1; i<=n; i++)
966 TH1F* waveform=GetWaveform(i);
969 str=waveform->GetName();
970 if (str == name) return waveform;
973 return 0; // No match found
975 ///////////////////////////////////////////////////////////////////////////
976 Int_t AliSignal::GetWaveformIndex(TString name) const
978 // Provide index to the waveform histogram with the specified name.
979 // In case no match is found, zero is returned.
980 Int_t n=GetNwaveforms();
982 for (Int_t i=1; i<=n; i++)
984 TH1F* waveform=GetWaveform(i);
987 str=waveform->GetName();
988 if (str == name) return i;
991 return 0; // No match found
993 ///////////////////////////////////////////////////////////////////////////
994 void AliSignal::SetWaveform(TH1F* waveform,Int_t j)
996 // Set the 1D waveform histogram for the j-th waveform.
999 // The first waveform position at j=1.
1000 // j=1 is the default value.
1002 // In case the value of the index j exceeds the maximum number of reserved
1003 // positions for the waveforms, the number of reserved positions for the waveforms
1004 // is increased automatically.
1006 // In case the histo pointer argument has the same value as the current waveform
1007 // histogram pointer value, no action is taken since the user has already
1008 // modified the actual histogram.
1010 // In case the histo pointer argument is zero, the current waveform histogram
1011 // is deleted and the pointer set to zero.
1013 // In all other cases the current waveform histogram is deleted and a new
1014 // copy of the input histogram is created which becomes the current waveform
1021 fWaveforms=new TObjArray(j);
1022 fWaveforms->SetOwner();
1025 if (j > fWaveforms->GetSize()) fWaveforms->Expand(j);
1027 TH1F* hcur=(TH1F*)fWaveforms->At(j-1);
1028 if (waveform != hcur)
1032 fWaveforms->Remove(hcur);
1038 hcur=new TH1F(*waveform);
1039 fWaveforms->AddAt(hcur,j-1);
1043 ///////////////////////////////////////////////////////////////////////////
1044 void AliSignal::ResetWaveform(Int_t j)
1046 // Reset the histogram of the j-th (default j=1) waveform.
1047 // This memberfunction invokes TH1F::Reset() for the corresponding waveform(s).
1048 // To actually delete the histograms from memory, use DeleteWaveform().
1049 // Notes : The first position is at j=1.
1050 // j=0 ==> All waveforms will be reset.
1052 if (!fWaveforms) return;
1054 Int_t size=fWaveforms->GetSize();
1056 if ((j>=0) && (j<=size))
1060 TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
1061 if (hwave) hwave->Reset();
1065 for (Int_t i=0; i<size; i++)
1067 TH1F* hwave=(TH1F*)fWaveforms->At(i);
1068 if (hwave) hwave->Reset();
1074 cout << " *AliSignal::ResetWaveform* Index j = " << j << " invalid." << endl;
1078 ///////////////////////////////////////////////////////////////////////////
1079 void AliSignal::ResetWaveform(TString name)
1081 // Reset the waveform with the specified name.
1082 Int_t j=GetWaveformIndex(name);
1083 if (j>0) ResetWaveform(j);
1085 ///////////////////////////////////////////////////////////////////////////
1086 void AliSignal::DeleteWaveform(Int_t j)
1088 // Delete the histogram of the j-th (default j=1) waveform.
1089 // Notes : The first position is at j=1.
1090 // j=0 ==> All waveforms will be deleted.
1092 if (!fWaveforms) return;
1094 Int_t size=fWaveforms->GetSize();
1096 if ((j>=0) && (j<=size))
1100 TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
1103 fWaveforms->Remove(hwave);
1115 cout << " *AliSignal::DeleteWaveform* Index j = " << j << " invalid." << endl;
1119 ///////////////////////////////////////////////////////////////////////////
1120 void AliSignal::DeleteWaveform(TString name)
1122 // Delete the waveform with the specified name.
1123 Int_t j=GetWaveformIndex(name);
1124 if (j>0) DeleteWaveform(j);
1126 ///////////////////////////////////////////////////////////////////////////
1127 Int_t AliSignal::GetNlinks(TObject* obj,Int_t j) const
1129 // Provide the number of links to the specified object for the j-th slot.
1130 // If j=0 (default) all slots will be scanned for the specified object.
1131 // If obj=0 (default) all encountered objects for the specified slot will be counted.
1132 // So, invokation of the default GetNlinks() will return the total number of
1133 // all references to all sorts of stored objects.
1136 cout << " *AliSignal::GetNlinks* Index j = " << j << " invalid." << endl;
1143 if (fLinks) n=fLinks->GetNrefs(obj);
1148 n=GetIndices(obj,j,posarr);
1152 ///////////////////////////////////////////////////////////////////////////
1153 Int_t AliSignal::GetNlinks(TObject* obj,TString name) const
1155 // Provide the number of links to the specified object for the name-spec. slot.
1156 // If obj=0 all encountered objects for the specified slot will be counted.
1158 // This procedure involves a slot-index search based on the specified name
1159 // at each invokation. This may become slow in case many slots have been
1160 // defined and/or when this procedure is invoked many times.
1161 // In such cases it is preferable to use indexed addressing in the user code
1162 // either directly or via a few invokations of GetSlotIndex().
1164 Int_t j=GetSlotIndex(name);
1166 if (j>0) n=GetNlinks(obj,j);
1169 ///////////////////////////////////////////////////////////////////////////
1170 TObject* AliSignal::GetLink(Int_t j,Int_t k) const
1172 // Provide pointer of the object linked to the j-th slot at position k.
1175 // Note : In the internal storage matrix slots=columns positions=rows
1176 if (fLinks) obj=fLinks->GetObject(k,j);
1179 ///////////////////////////////////////////////////////////////////////////
1180 TObject* AliSignal::GetLink(TString name,Int_t k) const
1182 // Provide pointer of the object linked to the name-spec. slot at position k.
1184 // This procedure involves a slot-index search based on the specified name
1185 // at each invokation. This may become slow in case many slots have been
1186 // defined and/or when this procedure is invoked many times.
1187 // In such cases it is preferable to use indexed addressing in the user code
1188 // either directly or via a few invokations of GetSlotIndex().
1190 Int_t j=GetSlotIndex(name);
1192 if (j>0) obj=GetLink(j,k);
1195 ///////////////////////////////////////////////////////////////////////////
1196 void AliSignal::SetLink(TObject* obj,Int_t j,Int_t k)
1198 // Introduce a link (=pointer) to an object for the j-th slot at position k.
1199 // Only the pointer values are stored for (backward) reference, meaning
1200 // that the objects of which the pointers are stored are NOT owned
1201 // by the AliSignal object.
1204 // The first slot is at j=1 and the first position is at k=1.
1205 // j=1 and k=1 are the default values.
1207 // If needed, the storage area for the links is increased automatically.
1209 // In case the pointer argument is zero, indeed a value of zero will be
1210 // stored at the specified position (k) for the specified slot (j).
1212 // In principle any object derived from TObject can be referred to by this
1214 // However, this "linking back" facility was introduced to enable AliSignal slots
1215 // to refer directly to the various AliTracks to which the AliSignal object itself
1216 // is related (see AliTrack::AddSignal).
1217 // Therefore, in case the input argument "obj" points to an AliTrack (or derived)
1218 // object, the current signal is automatically related to this AliTrack
1219 // (or derived) object.
1221 // Please also have a look at the docs of the memberfunction ResetLink()
1222 // to prevent the situation of stored pointers to non-existent object.
1224 if (!fLinks && obj) fLinks=new AliObjMatrix();
1226 if (!fLinks) return;
1228 // Note : In the internal storage matrix slots=columns positions=rows
1229 fLinks->EnterObject(k,j,obj);
1232 if (obj->InheritsFrom("AliTrack"))
1234 AliTrack* t=(AliTrack*)obj;
1235 t->AddSignal(*this);
1239 ///////////////////////////////////////////////////////////////////////////
1240 void AliSignal::SetLink(TObject* obj,TString name,Int_t k)
1242 // Introduce a link (=pointer) to an object for the name-spec. slot at position k.
1243 // Only the pointer values are stored for (backward) reference, meaning
1244 // that the objects of which the pointers are stored are NOT owned
1245 // by the AliSignal object.
1247 // This procedure involves a slot-index search based on the specified name
1248 // at each invokation. This may become slow in case many slots have been
1249 // defined and/or when this procedure is invoked many times.
1250 // In such cases it is preferable to use indexed addressing in the user code
1251 // either directly or via a few invokations of GetSlotIndex().
1253 Int_t j=GetSlotIndex(name);
1254 if (j>0) SetLink(obj,j,k);
1256 ///////////////////////////////////////////////////////////////////////////
1257 void AliSignal::AddLink(TObject* obj,Int_t j)
1259 // Introduce a link (=pointer) to an object for the j-th slot at the first
1261 // Only the pointer values are stored for (backward) reference, meaning
1262 // that the objects of which the pointers are stored are NOT owned
1263 // by the AliSignal object.
1266 // The first slot is at j=1 and the first position is at k=1.
1267 // j=1 is the default value.
1269 // If needed, the storage area for the links is increased automatically.
1271 // In case the pointer argument is zero, no link will be added.
1273 // In principle any object derived from TObject can be referred to by this
1275 // However, this "linking back" facility was introduced to enable AliSignal slots
1276 // to refer directly to the various AliTracks to which the AliSignal object itself
1277 // is related (see AliTrack::AddSignal).
1278 // Therefore, in case the input argument "obj" points to an AliTrack (or derived)
1279 // object, the current signal is automatically related to this AliTrack
1280 // (or derived) object.
1282 // Please also have a look at the docs of the memberfunction ResetLink()
1283 // to prevent the situation of stored pointers to non-existent object.
1285 if (!obj || j<=0) return;
1287 if (!fLinks) fLinks=new AliObjMatrix();
1290 Int_t n=GetNlinks(dum,j);
1292 for (Int_t k=1; k<=n; k++)
1301 ///////////////////////////////////////////////////////////////////////////
1302 void AliSignal::AddLink(TObject* obj,TString name)
1304 // Introduce a link (=pointer) to an object for the name-spec slot at the first
1306 // Only the pointer values are stored for (backward) reference, meaning
1307 // that the objects of which the pointers are stored are NOT owned
1308 // by the AliSignal object.
1310 // This procedure involves a slot-index search based on the specified name
1311 // at each invokation. This may become slow in case many slots have been
1312 // defined and/or when this procedure is invoked many times.
1313 // In such cases it is preferable to use indexed addressing in the user code
1314 // either directly or via a few invokations of GetSlotIndex().
1316 Int_t j=GetSlotIndex(name);
1317 if (j>0) AddLink(obj,j);
1319 ///////////////////////////////////////////////////////////////////////////
1320 void AliSignal::ResetLink(Int_t j,Int_t k)
1322 // Reset the link of the j-th slot at position k.
1325 // The first slot is at j=1 and the first position is at k=1.
1326 // j=1 and k=1 are the default values.
1328 // This memberfunction is intended to reset only 1 specified link location.
1329 // For extended functionality, please refer to the memberfuction ResetLinks().
1331 // In general the user should take care of properly clearing the corresponding
1332 // pointer here when the referred object is deleted.
1333 // However, this "linking back" facility was introduced to enable AliSignal slots
1334 // to refer directly to the various AliTracks to which the AliSignal object itself
1335 // is related (see AliTrack::AddSignal).
1336 // As such, the AliTrack destructor already takes care of clearing the corresponding
1337 // links from the various AliSignal slots for all the AliSignal objects that were
1338 // related to that AliTrack.
1339 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
1340 // the user doesn't have to worry about clearing the corresponding AliTrack link from
1341 // the AliSignal object when the corresponding AliTrack object is deleted.
1343 // Note : In the internal storage matrix slots=columns positions=rows
1344 if (fLinks) fLinks->RemoveObject(k,j);
1346 ///////////////////////////////////////////////////////////////////////////
1347 void AliSignal::ResetLink(TString name,Int_t k)
1349 // Reset the link of the name-specified slot at position k.
1351 // This memberfunction is intended to reset only 1 specified link location.
1352 // For extended functionality, please refer to the memberfuction ResetLinks().
1354 // This procedure involves a slot-index search based on the specified name
1355 // at each invokation. This may become slow in case many slots have been
1356 // defined and/or when this procedure is invoked many times.
1357 // In such cases it is preferable to use indexed addressing in the user code
1358 // either directly or via a few invokations of GetSlotIndex().
1360 Int_t j=GetSlotIndex(name);
1361 if (j>0) ResetLink(j,k);
1363 ///////////////////////////////////////////////////////////////////////////
1364 void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
1366 // Reset single or multiple link(s) according to user specified selections.
1368 // A link is only reset if the stored reference matches the argument "obj".
1369 // In case obj=0 no check on the matching of the stored reference is performed
1370 // and the stored link is always reset in accordance with the other
1371 // selection criteria.
1373 // In case the slot argument "j" is specified, only the links from that
1374 // specified slot will be deleted.
1375 // In case j=0 (default) no checking on the slot index is performed.
1377 // In case the position argument "k" is specified, only the links from that
1378 // specified position will be deleted.
1379 // In case k=0 (default) no checking on the position index is performed.
1381 // So, invokation of ResetLinks(obj) will remove all references to the
1382 // object "obj" from the total AliSignal, whereas ResetLinks(obj,j)
1383 // will remove all references to the object "obj" only from slot "j".
1387 // The first slot is indicated as j=1, whereas the first position is at k=1.
1389 // Invokation of ResetLinks(0,row,col) is equivalent to invoking the
1390 // memberfunction ResetLink(row,col).
1391 // Invoking the latter directly is slightly faster.
1393 // Invokation of ResetLinks(0) will reset all stored references in this AliSignal.
1395 // In general the user should take care of properly clearing the corresponding
1396 // pointer here when the referred object is deleted.
1397 // However, this "linking back" facility was introduced to enable AliSignal slots
1398 // to refer directly to the various AliTracks to which the AliSignal object itself
1399 // is related (see AliTrack::AddSignal).
1400 // As such, the AliTrack destructor already takes care of clearing the corresponding
1401 // links from the various AliSignal slots for all the AliSignal objects that were
1402 // related to that AliTrack.
1403 // So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
1404 // the user doesn't have to worry about clearing the corresponding AliTrack link from
1405 // the AliSignal object when the corresponding AliTrack object is deleted.
1407 if (!fLinks) return;
1409 if (!obj && !j && !k)
1415 // Note : In the internal storage matrix slots=columns positions=rows
1416 fLinks->RemoveObjects(obj,k,j);
1419 ///////////////////////////////////////////////////////////////////////////
1420 void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
1422 // Reset single or multiple link(s) according to user specified selections.
1424 // A link is only reset if the stored reference matches the argument "obj".
1425 // In case obj=0 no check on the matching of the stored reference is performed
1426 // and the stored link is always reset in accordance with the other
1427 // selection criteria.
1429 // In case the position argument "k" is specified, only the links from that
1430 // specified position will be deleted.
1431 // In case k=0 (default) no checking on the position index is performed.
1433 // This procedure involves a slot-index search based on the specified name
1434 // at each invokation. This may become slow in case many slots have been
1435 // defined and/or when this procedure is invoked many times.
1436 // In such cases it is preferable to use indexed addressing in the user code
1437 // either directly or via a few invokations of GetSlotIndex().
1439 Int_t j=GetSlotIndex(name);
1440 if (j>0) ResetLinks(obj,j,k);
1442 ///////////////////////////////////////////////////////////////////////////
1443 Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,TArrayI& ks) const
1445 // Provide the slot and position indices of all the storage locations
1446 // of the specified object.
1447 // The slot (j) and pos. (k) indices are returned in the two separate TArrayI arrays
1448 // from which the (j,k) pairs can be obtained from the corresponding
1449 // array indices like (j,k)=(js.At(i),ks.At(i)).
1450 // The integer return argument represents the number of (j,k) pairs which
1451 // were encountered for the specified object.
1453 // If obj=0 no object selection is performed and all (j,k) indices
1454 // of the stored references for all objects are returned.
1458 // As usual the convention is that slot and position numbering starts at 1.
1460 // This memberfunction always resets the two TArrayI arrays at the start.
1462 // This memberfunction can only be used to obtain the (j,k) indices
1463 // of the object as stored via the SetLink() or AddLink() memberfunction.
1464 // This means that in case the user has entered a TObjArray as object
1465 // (to increase the dimension of the resulting structure), the (j,k)
1466 // indices of that TObjArray are obtained and NOT the indices of the
1467 // actual objects contained in that TObjArray structure.
1472 // Note : In the internal storage matrix slots=columns positions=rows
1473 if (fLinks) nrefs=fLinks->GetIndices(obj,ks,js);
1476 ///////////////////////////////////////////////////////////////////////////
1477 Int_t AliSignal::GetIndices(TObject* obj,Int_t j,TArrayI& ks) const
1479 // Provide the position indices of all the storage locations of the
1480 // specified object in the j-th slot of this AliSignal.
1481 // The position indices are returned in the TArrayI array.
1482 // The integer return argument represents the number of storage locations which
1483 // were encountered for the specified object in the j-th slot.
1485 // If obj=0 no object selection is performed and all position indices
1486 // of the stored references for all objects of the j-th slot are returned.
1488 // If j=0 all slots will be scanned and all position indices matching the
1489 // object selection are returned.
1490 // Note that in this case multiple appearances of the same position index
1491 // will only be recorded once in the returned TArrayI array.
1495 // As usual the convention is that slot and position numbering starts at 1.
1497 // This memberfunction always resets the TArrayI array at the start.
1499 // This memberfunction can only be used to obtain the position indices
1500 // of the object as stored via the SetLink() or AddLink() memberfunction.
1501 // This means that in case the user has entered a TObjArray as object
1502 // (to increase the dimension of the resulting structure), the position
1503 // indices of that TObjArray are obtained and NOT the indices of the
1504 // actual objects contained in that TObjArray structure.
1508 // Note : In the internal storage matrix slots=columns positions=rows
1509 if (fLinks) nrefs=fLinks->GetIndices(obj,ks,j);
1512 ///////////////////////////////////////////////////////////////////////////
1513 Int_t AliSignal::GetIndices(TObject* obj,TString name,TArrayI& ks) const
1515 // Provide the position indices of all the storage locations of the
1516 // specified object in the name-specified slot of this AliSignal.
1517 // The position indices are returned in the TArrayI array.
1518 // The integer return argument represents the number of storage locations which
1519 // were encountered for the specified object in the j-th slot.
1521 // If obj=0 no object selection is performed and all position indices
1522 // of the stored references for all objects of the j-th slot are returned.
1524 // This procedure involves a slot-index search based on the specified name
1525 // at each invokation. This may become slow in case many slots have been
1526 // defined and/or when this procedure is invoked many times.
1527 // In such cases it is preferable to use indexed addressing in the user code
1528 // either directly or via a few invokations of GetSlotIndex().
1530 Int_t j=GetSlotIndex(name);
1532 if (j>0) n=GetIndices(obj,j,ks);
1535 ///////////////////////////////////////////////////////////////////////////
1536 Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,Int_t k) const
1538 // Provide the slot indices of all the storage locations of the
1539 // specified object for the k-th position in this AliSignal.
1540 // The slot indices are returned in the TArrayI array.
1541 // The integer return argument represents the number of storage locations which
1542 // were encountered for the specified object in the k-th position.
1544 // If obj=0 no object selection is performed and all slot indices
1545 // of the stored references for all objects in the k-th position are returned.
1547 // If k=0 all positions will be scanned and all slot indices matching the
1548 // object selection are returned.
1549 // Note that in this case multiple appearances of the same slot index
1550 // will only be recorded once in the returned TArrayI array.
1554 // As usual the convention is that slot and position numbering starts at 1.
1556 // This memberfunction always resets the TArrayI array at the start.
1558 // This memberfunction can only be used to obtain the slot indices
1559 // of the object as stored via the SetLink() or AddLink() memberfunction.
1560 // This means that in case the user has entered a TObjArray as object
1561 // (to increase the dimension of the resulting structure), the slot
1562 // indices of that TObjArray are obtained and NOT the indices of the
1563 // actual objects contained in that TObjArray structure.
1567 // Note : In the internal storage matrix slots=columns positions=rows
1568 if (fLinks) nrefs=fLinks->GetIndices(obj,k,js);
1571 ///////////////////////////////////////////////////////////////////////////
1572 void AliSignal::SetSwapMode(Int_t swap)
1574 // Set swapmode flag for the internal link storage.
1575 // In case for the stored links the maximum slot number differs considerably
1576 // from the maximum position number, it might be more efficient
1577 // (w.r.t. memory usage and/or output file size) to internally store the
1578 // link reference matrix with the rows and colums swapped.
1579 // This swapping is only related with the internal storage and as such
1580 // is completely hidden for the user.
1581 // At invokation of this memberfunction the default argument is swap=1.
1583 // Note : The swap mode can only be set as long as no links are
1584 // stored in the AliSignal (i.e. a new instance of AliSignal
1585 // or after invokation of the Reset() or ResetLinks() function).
1587 if (!fLinks) fLinks=new AliObjMatrix();
1588 fLinks->SetSwapMode(swap);
1590 ///////////////////////////////////////////////////////////////////////////
1591 Int_t AliSignal::GetSwapMode() const
1593 // Provide swapmode flag of the link storage.
1595 if (fLinks) swap=fLinks->GetSwapMode();
1598 ///////////////////////////////////////////////////////////////////////////
1599 void AliSignal::SetDevice(TObject* dev)
1601 // Store the pointer to the device which owns this AliSignal object.
1602 // This memberfunction is meant for internal use in AliDevice.
1605 ///////////////////////////////////////////////////////////////////////////
1606 AliDevice* AliSignal::GetDevice() const
1608 // Provide the pointer to the device which owns this AliSignal object.
1609 return (AliDevice*)fDevice;
1611 ///////////////////////////////////////////////////////////////////////////
1612 TObject* AliSignal::Clone(const char* name) const
1614 // Make a deep copy of the current object and provide the pointer to the copy.
1615 // This memberfunction enables automatic creation of new objects of the
1616 // correct type depending on the object type, a feature which may be very useful
1617 // for containers when adding objects in case the container owns the objects.
1618 // This feature allows e.g. AliTrack to store either AliSignal objects or
1619 // objects derived from AliSignal via the AddSignal memberfunction, provided
1620 // these derived classes also have a proper Clone memberfunction.
1622 AliSignal* sig=new AliSignal(*this);
1625 if (strlen(name)) sig->SetName(name);
1629 ///////////////////////////////////////////////////////////////////////////