// Class AliSignal
// Generic handling of (extrapolated) detector signals.
//
+// The user can decide to store either calibrated or uncalibrated signals.
+// Via the specification of a gain and offset or/and an explicit
+// (de)calibration function both calibrated and uncalibrated signals
+// can always be obtained. For details see the documentation of the
+// memberfunction GetSignal() and the class AliAttrib.
+// The explicit specification of a (de)calibration function offers the
+// maximum flexibility and also allows automatic indication whether
+// calibrated or uncalibrated data has been stored.
+// The latter can be achieved by only specifying a calibration function
+// (and no de-calibration function) in case uncalibrated data is stored,
+// whereas in case of stored calibrated data the user should only
+// provide a de-calibration function (and no calibration function).
+//
// Note :
// ------
// Signal positions (r) and reference frames (f) are specified via
//
// AliSignal q; // In the example below a signal contains the
// // following data : timing, ADC and dE/dx
-// q.SetName("TOF hit");
+// q.SetNameTitle("Hybrid","Test for multiple signal data");
// q.SetPosition(pos,"car");
// q.SetPositionErrors(err,"car");
// signal=82.5; // e.g. signal time in ns
// error=2.01;
// offset=0.003;
+// q.SetSlotName("TOF",1);
// q.SetSignal(signal,1);
// q.SetSignalError(error,1);
// q.SetOffset(offset,1);
// signal=268.1; // e.g. ADC value of signal
// error=3.75;
// gain=120.78;
-// q.SetSignal(signal,2);
-// q.SetSignalError(error,2);
-// q.SetGain(gain,2);
+// offset=1.5732;
+// // Addressing via name specification instead of index
+// q.SetSlotName("ADC",2);
+// q.SetSignal(signal,"ADC");
+// q.SetSignalError(error,"ADC");
+// q.SetGain(gain,"ADC");
+// q.SetOffset(offset,"ADC");
// signal=23.7; // e.g. corresponding dE/dx value
// error=0.48;
-// offset=0.2;
-// gain=150;
-// q.SetSignal(signal,3);
-// q.SetSignalError(error,3);
-// q.SetOffset(offset,3);
-// q.SetGain(gain,3);
+// TF1 f=("calib","[0]*pow(x,2)+[1]"); // dE/dx calib. function
+// f.SetParameter(0,3.285);
+// f.SetParameter(1,-18.67);
+// q.SetSlotName("dE/dx",3);
+// q.SetCalFunction(&f,"dE/dx");
+// q.SetSignal(signal,"dE/dx");
+// q.SetSignalError(error,"dE/dx");
+//
+// // Signal retrieval with various (de)calibration modes
+// Float_t tof=q.GetSignal("TOF");
+// Float_t adc=q.GetSignal("ADC",1);
+// Float_t dedx=q.GetSignal("dE/dx",3);
//
//--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
fDsignals=0;
fWaveforms=0;
fLinks=0;
+ fDevice=0;
}
///////////////////////////////////////////////////////////////////////////
AliSignal::~AliSignal()
}
if (fLinks)
{
+ // Remove this signal from all related tracks
+ for (Int_t i=1; i<=fLinks->GetNobjects(); i++)
+ {
+ TObject* obj=fLinks->GetObject(i);
+ if (!obj) continue;
+ if (obj->InheritsFrom("AliTrack"))
+ {
+ AliTrack* tx=(AliTrack*)obj;
+ tx->RemoveSignal(*this);
+ }
+ }
delete fLinks;
fLinks=0;
}
}
///////////////////////////////////////////////////////////////////////////
-AliSignal::AliSignal(AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
+AliSignal::AliSignal(const AliSignal& s) : TNamed(s),AliPosition(s),AliAttrib(s)
{
// Copy constructor
fSignals=0;
fWaveforms=0;
fLinks=0;
+ // Don't copy the owning device pointer for the copy
+ fDevice=0;
+
Int_t n=s.GetNvalues();
Double_t val;
for (Int_t i=1; i<=n; i++)
if (hist) SetWaveform(hist,k);
}
- n=s.GetNlinks();
- for (Int_t il=1; il<=n; il++)
+ TArrayI slotarr;
+ TArrayI posarr;
+ TObject* dum=0;
+ n=s.GetIndices(dum,slotarr,posarr);
+ Int_t slot,pos;
+ for (Int_t idx=0; idx<n; idx++)
{
- TObject* obj=s.GetLink(il);
- if (obj) SetLink(obj,il);
+ slot=slotarr.At(idx);
+ pos=posarr.At(idx);
+ TObject* obj=s.GetLink(slot,pos);
+ if (obj) SetLink(obj,slot,pos);
}
}
///////////////////////////////////////////////////////////////////////////
//
// The default when invoking Reset() corresponds to mode=0.
//
-// Note : In all cases the storage of the various links will be cleared
-// and the container itself will be deleted to recover the memory.
+// Note : In all cases the storage of the various links will be reset.
+// The UniqueID, name and title will NOT be reset.
+// In case the user wants to reset these attributes, this has to
+// be done explicitly via the SET facilities.
//
// The usage of mode=0 allows to re-use the allocated memory for new
// signal (and error) values. This behaviour is preferable (i.e. faster)
// signals have a variable number of values.
//
// For more specific actions see ResetPosition(), ResetSignals(),
-// DeleteSignals(), ResetGain(), ResetOffset() and DeleteCalibrations().
+// DeleteSignals(), ResetGain(), ResetOffset(), ResetLink(), ResetWaveform(),
+// DeleteWaveform() and DeleteCalibrations().
//
if (mode<0 || mode>1)
DeleteCalibrations();
}
- if (fLinks)
- {
- delete fLinks;
- fLinks=0;
- }
+ if (fLinks) fLinks->Reset();
+ fDevice=0;
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetSignals(Int_t mode)
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignal(Double_t sig,Int_t j)
{
-// Store value in the j-th (default j=1) signal slot.
+// Store signal value for the j-th (default j=1) slot.
// Note : The first signal slot is at j=1.
// In case the value of the index j exceeds the maximum number of reserved
// slots for signal values, the number of reserved slots for the
fSignals->AddAt(float(sig),j-1);
}
///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetSignal(Double_t sig,TString name)
+{
+// Store signal value for the name-specified slot.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) SetSignal(sig,j);
+}
+///////////////////////////////////////////////////////////////////////////
void AliSignal::AddSignal(Double_t sig,Int_t j)
{
-// Add value to the j-th (default j=1) signal slot.
+// Add value to the signal of the j-th (default j=1) slot.
// Note : The first signal slot is at j=1.
// In case the value of the index j exceeds the maximum number of reserved
// slots for signal values, the number of reserved slots for the
fSignals->AddAt(sum,j-1);
}
///////////////////////////////////////////////////////////////////////////
-Float_t AliSignal::GetSignal(Int_t j,Int_t mode)
+void AliSignal::AddSignal(Double_t sig,TString name)
+{
+// Add value to the signal of the name-specified slot.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) AddSignal(sig,j);
+}
+///////////////////////////////////////////////////////////////////////////
+Float_t AliSignal::GetSignal(Int_t j,Int_t mode) const
{
-// Provide value of the j-th (default j=1) signal slot.
+// Provide signal value of the j-th (default j=1) slot.
// Note : The first signal slot is at j=1.
-// In case no signal is present or the argument j is invalid, 0 is returned.
-// The parameter "mode" allows for automatic gain etc... correction of the signal.
+// In case no signal is present or the input argument "j" or "mode" is invalid,
+// the value 0 is returned.
+// The parameter "mode" allows for automatic (de)calibration of the signal
+// (e.g. gain etc... correction or via explicit (de)calibration functions).
//
// mode = 0 : Just the j-th signal is returned.
// 1 : The j-th signal is corrected for the gain, offset, dead flag etc...
+// In case the j-th slot was marked dead, 0 is returned.
// In case the gain value was not set, gain=1 will be assumed.
// In case the gain value was 0, a signal value of 0 is returned.
// In case the offset value was not set, offset=0 will be assumed.
+// 2 : Same as mode=1 but gain, offset dead flag etc... are taken from
+// the AliDevice which owns this AliSignal object.
+// The corresponding AliDevice slot is obtained via matching of
+// the slotnames. In case this fails, the slotindex "j" of the
+// input argument will be used.
+// In case this AliSignal object has no parent AliDevice, just
+// the j-th signal is returned (like with mode=0).
+// 3 : The j-th signal is corrected using the corresponding calibration
+// function.
// In case the j-th slot was marked dead, 0 is returned.
+// In case no calibration function is present, just the j-th signal
+// is returned (like with mode=0).
+// 4 : Same as mode=3 but the calibration function and dead flag are
+// taken from the AliDevice which owns this AliSignal object.
+// The corresponding AliDevice slot is obtained via matching of
+// the slotnames. In case this fails, the slotindex "j" of the
+// input argument will be used.
+// 5 : Same as mode=2 but in case no parent AliDevice is present
+// an automatic switch to mode=1 will be made.
+// 6 : Same as mode=4 but in case no parent AliDevice is present
+// an automatic switch to mode=3 will be made.
+// 7 : Same as mode=3 but in case no calibration function is present
+// an automatic switch to mode=4 will be made.
+// 8 : Same as mode=7 but also the corresponding dead flag of the
+// parent device (if any) will be checked.
+// If either the dead flag of the requested signal slot of this
+// AliSignal object or the corresponding parent device slot is
+// set, 0 is returned.
+//
+// <0 : The corresponding de-correction or de-calibration is performed
//
// The corrected signal (sigc) is determined as follows :
//
// sigc=(signal/gain)-offset
//
+// The de-corrected signal is determined as follows :
+//
+// signal=(sigc+offset)*gain
+//
// The default is mode=0.
+ if (abs(mode)>8) return 0;
+
+ Int_t jcal=j;
Float_t sig=0;
Float_t gain=1;
Float_t offset=0;
+
+ // Get the corresponding slot index (and dead flag) of the parent device
+ Int_t pj=0;
+ Int_t pdead=0;
+ AliSignal* parent=(AliSignal*)GetDevice();
+ if ((abs(mode)==2 || abs(mode)>=4) && parent)
+ {
+ TString name=GetSlotName(j);
+ if (strlen(name.Data())) pj=parent->GetSlotIndex(name);
+ if (abs(mode)==8 && pj) pdead=parent->GetDeadValue(pj);
+ }
+ if (mode==8) mode=7;
+ if (mode==-8) mode=-7;
+
+ AliSignal* sx=(AliSignal*)this;
+
+ TF1* f=0;
+ if (mode==7)
+ {
+ f=sx->GetCalFunction(jcal);
+ if (f)
+ {
+ mode=3;
+ }
+ else
+ {
+ mode=4;
+ }
+ }
+ if (mode==-7)
+ {
+ f=sx->GetDecalFunction(jcal);
+ if (f)
+ {
+ mode=-3;
+ }
+ else
+ {
+ mode=-4;
+ }
+ }
+
+ if (abs(mode)==2 || abs(mode)>=4)
+ {
+ sx=(AliSignal*)GetDevice();
+ if (pj) jcal=pj;
+ }
+ if (!sx && abs(mode)>=5) sx=(AliSignal*)this;
+ if (mode==5) mode=2;
+ if (mode==-5) mode=-2;
+ if (mode==6) mode=3;
+ if (mode==-6) mode=-3;
+
if (fSignals)
{
if (j>0 && j<=(fSignals->GetSize()))
{
sig=fSignals->At(j-1);
- if (mode==0) return sig;
-
- // Correct the signal for the gain, offset, dead flag etc...
- if (GetDeadValue(j)) return 0;
+ if (mode==0 || !sx) return sig;
- if (GetGainFlag(j)) gain=GetGain(j);
- if (GetOffsetFlag(j)) offset=GetOffset(j);
+ // Check for the dead flag setting
+ if (sx->GetDeadValue(jcal) || pdead) return 0;
- if (fabs(gain)>0.)
+ // (De)correct the signal for the gain and offset
+ if (abs(mode)==1 || abs(mode)==2)
{
- sig=(sig/gain)-offset;
+ if (sx->GetGainFlag(jcal)) gain=sx->GetGain(jcal);
+ if (sx->GetOffsetFlag(jcal)) offset=sx->GetOffset(jcal);
+
+ if (fabs(gain)>0.)
+ {
+ if (mode>0) sig=(sig/gain)-offset; // Gain and offset correction
+ if (mode<0) sig=(sig+offset)*gain; // Gain and offset de-correction
+ }
+ else
+ {
+ sig=0;
+ }
+ return sig;
}
- else
+
+ // (De)calibrate the signal with the corresponding (de)calibration function
+ if (abs(mode)==3 || abs(mode)==4)
{
- sig=0;
+ f=sx->GetCalFunction(jcal);
+ if (mode<0) f=sx->GetDecalFunction(jcal);
+ if (f) sig=f->Eval(sig);
+ return sig;
}
}
else
return sig;
}
///////////////////////////////////////////////////////////////////////////
+Float_t AliSignal::GetSignal(TString name,Int_t mode) const
+{
+// Provide signal value of the name-specified slot.
+// In case no signal is present, 0 is returned.
+// The parameter "mode" allows for automatic (de)calibration of the signal
+// (e.g. gain etc... correction or via explicit (de)calibration functions).
+// For further details about the (de)calibration modes, please refer to the
+// corresponding slot-index based memberfunction.
+//
+// The default is mode=0.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Float_t val=0;
+ if (j>0) val=GetSignal(j,mode);
+ return val;
+}
+///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignalError(Double_t dsig,Int_t j)
{
-// Store error for the j-th (default j=1) signal slot.
+// Store error on the signal for the j-th (default j=1) slot.
// Note : The first signal slot is at j=1.
// In case the value of the index j exceeds the maximum number of reserved
// slots for signal error values, the number of reserved slots for the
fDsignals->AddAt(float(dsig),j-1);
}
///////////////////////////////////////////////////////////////////////////
-Float_t AliSignal::GetSignalError(Int_t j)
+void AliSignal::SetSignalError(Double_t dsig,TString name)
{
-// Provide error of the j-th (default j=1) signal slot.
+// Store error on the signal for the name-specified slot.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) SetSignalError(dsig,j);
+}
+///////////////////////////////////////////////////////////////////////////
+Float_t AliSignal::GetSignalError(Int_t j) const
+{
+// Provide error on the signal of the j-th (default j=1) slot.
// Note : The first signal slot is at j=1.
// In case no signal is present or the argument j is invalid, 0 is returned.
Float_t err=0;
return err;
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::Data(TString f)
+Float_t AliSignal::GetSignalError(TString name) const
+{
+// Provide error on the signal of the name-specified slot.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Float_t val=0;
+ if (j>0) val=GetSignalError(j);
+ return val;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::Data(TString f,TString u) const
{
// Provide all signal information within the coordinate frame f.
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The defaults are f="car" and u="rad".
const char* name=GetName();
const char* title=GetTitle();
- cout << " *" << ClassName() << "::Data*";
+ cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
if (strlen(name)) cout << " Name : " << name;
if (strlen(title)) cout << " Title : " << title;
cout << endl;
- cout << " Position";
- Ali3Vector::Data(f);
+ cout << " Position";
+ AliPosition::Data(f,u);
+ if (fDevice)
+ {
+ const char* devname=fDevice->GetName();
+ const char* devtitle=fDevice->GetTitle();
+ cout << " Owned by device : " << fDevice->ClassName()
+ << " Id : " << fDevice->GetUniqueID();
+ if (strlen(devname)) cout << " Name : " << devname;
+ if (strlen(devtitle)) cout << " Title : " << devtitle;
+ cout << endl;
+ }
+
+ // Provide an overview of the stored waveforms
+ ListWaveform(-1);
+ // Provide an overview of all the data and attribute slots
List(-1);
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::List(Int_t j)
+void AliSignal::List(Int_t j) const
{
// Provide signal information for the j-th slot.
// The first slot is at j=1.
const char* name=GetName();
const char* title=GetTitle();
- cout << " *" << ClassName() << "::Data*";
+ cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
if (strlen(name)) cout << " Name : " << name;
if (strlen(title)) cout << " Title : " << title;
cout << endl;
+ if (fDevice)
+ {
+ const char* devname=fDevice->GetName();
+ const char* devtitle=fDevice->GetTitle();
+ cout << " Owned by device : " << fDevice->ClassName();
+ if (strlen(devname)) cout << " Name : " << devname;
+ if (strlen(devtitle)) cout << " Title : " << devtitle;
+ cout << endl;
+ }
}
Int_t nvalues=GetNvalues();
Int_t nerrors=GetNerrors();
- Int_t nwforms=GetNwaveforms();
- Int_t nlinks=GetNlinks();
+ Int_t nlinkslots=0;
+ if (fLinks) nlinkslots=fLinks->GetMaxColumn();
+ Int_t ncalibs=GetNcalflags();
+ Int_t ncalfuncs=GetNcalfuncs();
+ Int_t ndecalfuncs=GetNdecalfuncs();
+
Int_t n=nvalues;
if (nerrors>n) n=nerrors;
- if (nwforms>n) n=nwforms;
- if (nlinks>n) n=nlinks;
-
+ if (nlinkslots>n) n=nlinkslots;
+ if (InheritsFrom("AliDevice"))
+ {
+ if (ncalibs>n) n=ncalibs;
+ if (ncalfuncs>n) n=ncalfuncs;
+ if (ndecalfuncs>n) n=ndecalfuncs;
+ }
+
TObject* obj=0;
+ Int_t nrefs=0;
+ TArrayI posarr;
+ Int_t pos;
if (j<=0)
{
for (Int_t i=1; i<=n; i++)
{
- cout << " Signal";
- if (i<=nvalues) cout << " value : " << GetSignal(i);
+ cout << " Slot : " << i;
+ if (i<=nvalues) cout << " Signal value : " << GetSignal(i);
if (i<=nerrors) cout << " error : " << GetSignalError(i);
AliAttrib::List(i);
cout << endl;
+ obj=0;
+ nrefs=GetIndices(obj,i,posarr);
+ for (Int_t k=0; k<nrefs; k++)
+ {
+ pos=posarr.At(k);
+ obj=GetLink(i,pos);
+ if (obj)
+ {
+ cout << " Link at position " << pos << " to : " << obj->ClassName();
+ if (obj->InheritsFrom("TNamed"))
+ {
+ const char* lname=obj->GetName();
+ const char* ltitle=obj->GetTitle();
+ if (strlen(lname)) cout << " Name : " << lname;
+ if (strlen(ltitle)) cout << " Title : " << ltitle;
+ }
+ cout << endl;
+ }
+ }
+ }
+ }
+ else
+ {
+ if (j<=n)
+ {
+ cout << " Slot : " << j;
+ if (j<=nvalues) cout << " Signal value : " << GetSignal(j);
+ if (j<=nerrors) cout << " error : " << GetSignalError(j);
+ AliAttrib::List(j);
+ cout << endl;
+ obj=0;
+ nrefs=GetIndices(obj,j,posarr);
+ for (Int_t kj=0; kj<nrefs; kj++)
+ {
+ pos=posarr.At(kj);
+ obj=GetLink(j,pos);
+ if (obj)
+ {
+ cout << " Link at position " << pos << " to : " << obj->ClassName();
+ if (obj->InheritsFrom("TNamed"))
+ {
+ const char* lnamej=obj->GetName();
+ const char* ltitlej=obj->GetTitle();
+ if (strlen(lnamej)) cout << " Name : " << lnamej;
+ if (strlen(ltitlej)) cout << " Title : " << ltitlej;
+ }
+ cout << endl;
+ }
+ }
+ }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::List(TString name) const
+{
+// Provide signal information for the name-specified slot.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) List(j);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ListWaveform(Int_t j) const
+{
+// Provide information for the j-th waveform.
+// The first waveform is at j=1.
+// In case j=0 (default) the info of all waveforms will be listed.
+// In case j=-1 the info of all waveforms will be listed, but the header
+// information will be suppressed.
+
+ if (j<-1)
+ {
+ cout << " *AliSignal::ListWaveform* Invalid argument j = " << j << endl;
+ return;
+ }
+
+ if (j != -1)
+ {
+ const char* name=GetName();
+ const char* title=GetTitle();
+
+ cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
+ if (strlen(name)) cout << " Name : " << name;
+ if (strlen(title)) cout << " Title : " << title;
+ cout << endl;
+ if (fDevice)
+ {
+ const char* devname=fDevice->GetName();
+ const char* devtitle=fDevice->GetTitle();
+ cout << " Owned by device : " << fDevice->ClassName();
+ if (strlen(devname)) cout << " Name : " << devname;
+ if (strlen(devtitle)) cout << " Title : " << devtitle;
+ cout << endl;
+ }
+ }
+
+ Int_t n=GetNwaveforms();
+ TObject* obj=0;
+
+ if (j<=0)
+ {
+ for (Int_t i=1; i<=n; i++)
+ {
obj=GetWaveform(i);
if (obj)
{
const char* wfname=obj->GetName();
const char* wftitle=obj->GetTitle();
- cout << " Waveform : " << obj->ClassName();
+ cout << " Waveform " << i << " : " << obj->ClassName();
if (strlen(wfname)) cout << " Name : " << wfname;
if (strlen(wftitle)) cout << " Title : " << wftitle;
cout << endl;
}
- obj=GetLink(i);
- if (obj)
- {
- cout << " Link to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
- {
- const char* lname=obj->GetName();
- const char* ltitle=obj->GetTitle();
- if (strlen(lname)) cout << " Name : " << lname;
- if (strlen(ltitle)) cout << " Title : " << ltitle;
- }
- cout << endl;
- }
}
}
else
{
if (j<=n)
{
- cout << " Signal";
- if (j<=nvalues) cout << " value : " << GetSignal(j);
- if (j<=nerrors) cout << " error : " << GetSignalError(j);
- AliAttrib::List(j);
- cout << endl;
obj=GetWaveform(j);
if (obj)
{
const char* wfnamej=obj->GetName();
const char* wftitlej=obj->GetTitle();
- cout << " Waveform : " << obj->ClassName();
+ cout << " Waveform " << j << " : " << obj->ClassName();
if (strlen(wfnamej)) cout << " Name : " << wfnamej;
if (strlen(wftitlej)) cout << " Title : " << wftitlej;
cout << endl;
}
- obj=GetLink(j);
- if (obj)
- {
- cout << " Link to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
- {
- const char* lnamej=obj->GetName();
- const char* ltitlej=obj->GetTitle();
- if (strlen(lnamej)) cout << " Name : " << lnamej;
- if (strlen(ltitlej)) cout << " Title : " << ltitlej;
- }
- cout << endl;
- }
}
}
-}
+}
///////////////////////////////////////////////////////////////////////////
-Int_t AliSignal::GetNvalues()
+Int_t AliSignal::GetNvalues() const
{
// Provide the number of values for this signal.
Int_t n=0;
return n;
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliSignal::GetNerrors()
+Int_t AliSignal::GetNerrors() const
{
// Provide the number specified errors on the values for this signal.
Int_t n=0;
return n;
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliSignal::GetNwaveforms()
+Int_t AliSignal::GetNwaveforms() const
{
-// Provide the number specified waveforms for this signal.
- Int_t n=0;
- if (fWaveforms) n=fWaveforms->GetSize();
- return n;
+// Provide the number of specified waveforms for this signal.
+// Actually the return value is the highest index of the stored waveforms.
+// This allows an index dependent meaning of waveform info (e.g. waveforms
+// with various gain values).
+// So, when all waveforms are stored in consequetive positions (e.g. 1,2,3),
+// this memberfunction returns 3, being both the highest filled position
+// and the actual number of waveforms.
+// In case only waveforms are stored at positions 1,2,5,7 this memberfunction
+// returns a value 7 whereas only 4 actual waveforms are present.
+// This implies that when looping over the various waveform slots, one
+// always has to check whether the returned pointer value is non-zero
+// (which is a good practice anyhow).
+ Int_t n=-1;
+ if (fWaveforms) n=fWaveforms->GetLast();
+ return (n+1);
}
///////////////////////////////////////////////////////////////////////////
-TH1F* AliSignal::GetWaveform(Int_t j)
+TH1F* AliSignal::GetWaveform(Int_t j) const
{
// Provide pointer to the j-th waveform histogram.
TH1F* waveform=0;
return waveform;
}
///////////////////////////////////////////////////////////////////////////
+TH1F* AliSignal::GetWaveform(TString name) const
+{
+// Provide pointer to the waveform histogram with the specified name.
+// In case no match is found, zero is returned.
+ Int_t n=GetNwaveforms();
+ TString str;
+ for (Int_t i=1; i<=n; i++)
+ {
+ TH1F* waveform=GetWaveform(i);
+ if (waveform)
+ {
+ str=waveform->GetName();
+ if (str == name) return waveform;
+ }
+ }
+ return 0; // No match found
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetWaveformIndex(TString name) const
+{
+// Provide index to the waveform histogram with the specified name.
+// In case no match is found, zero is returned.
+ Int_t n=GetNwaveforms();
+ TString str;
+ for (Int_t i=1; i<=n; i++)
+ {
+ TH1F* waveform=GetWaveform(i);
+ if (waveform)
+ {
+ str=waveform->GetName();
+ if (str == name) return i;
+ }
+ }
+ return 0; // No match found
+}
+///////////////////////////////////////////////////////////////////////////
void AliSignal::SetWaveform(TH1F* waveform,Int_t j)
{
-// Set the 1D waveform histogram corresponding to the j-th signal value.
+// Set the 1D waveform histogram for the j-th waveform.
//
// Notes :
-// The waveform of the first signal value is at j=1.
+// The first waveform position at j=1.
// j=1 is the default value.
//
// In case the value of the index j exceeds the maximum number of reserved
-// slots for the waveforms, the number of reserved slots for the waveforms
+// positions for the waveforms, the number of reserved positions for the waveforms
// is increased automatically.
//
// In case the histo pointer argument has the same value as the current waveform
// copy of the input histogram is created which becomes the current waveform
// histogram.
+ if (j<1) return;
+
if (!fWaveforms)
{
fWaveforms=new TObjArray(j);
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetWaveform(Int_t j)
{
-// Reset the waveform of the j-th (default j=1) signal value.
+// Reset the histogram of the j-th (default j=1) waveform.
// This memberfunction invokes TH1F::Reset() for the corresponding waveform(s).
// To actually delete the histograms from memory, use DeleteWaveform().
-// Notes : The first signal value is at j=1.
+// Notes : The first position is at j=1.
// j=0 ==> All waveforms will be reset.
if (!fWaveforms) return;
}
}
///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetWaveform(TString name)
+{
+// Reset the waveform with the specified name.
+ Int_t j=GetWaveformIndex(name);
+ if (j>0) ResetWaveform(j);
+}
+///////////////////////////////////////////////////////////////////////////
void AliSignal::DeleteWaveform(Int_t j)
{
-// Delete the waveform of the j-th (default j=1) signal value.
-// Notes : The first signal value is at j=1.
+// Delete the histogram of the j-th (default j=1) waveform.
+// Notes : The first position is at j=1.
// j=0 ==> All waveforms will be deleted.
if (!fWaveforms) return;
}
}
///////////////////////////////////////////////////////////////////////////
-Int_t AliSignal::GetNlinks()
+void AliSignal::DeleteWaveform(TString name)
+{
+// Delete the waveform with the specified name.
+ Int_t j=GetWaveformIndex(name);
+ if (j>0) DeleteWaveform(j);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNlinks(TObject* obj,Int_t j) const
+{
+// Provide the number of links to the specified object for the j-th slot.
+// If j=0 (default) all slots will be scanned for the specified object.
+// If obj=0 (default) all encountered objects for the specified slot will be counted.
+// So, invokation of the default GetNlinks() will return the total number of
+// all references to all sorts of stored objects.
+ if (j<0)
+ {
+ cout << " *AliSignal::GetNlinks* Index j = " << j << " invalid." << endl;
+ return 0;
+ }
+
+ Int_t n=0;
+ if (!j)
+ {
+ if (fLinks) n=fLinks->GetNrefs(obj);
+ }
+ else
+ {
+ TArrayI posarr;
+ n=GetIndices(obj,j,posarr);
+ }
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNlinks(TObject* obj,TString name) const
{
-// Provide the highest slot number with a specified link for this signal.
+// Provide the number of links to the specified object for the name-spec. slot.
+// If obj=0 all encountered objects for the specified slot will be counted.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
Int_t n=0;
- if (fLinks) n=fLinks->GetSize();
+ if (j>0) n=GetNlinks(obj,j);
return n;
}
///////////////////////////////////////////////////////////////////////////
-TObject* AliSignal::GetLink(Int_t j)
+TObject* AliSignal::GetLink(Int_t j,Int_t k) const
+{
+// Provide pointer of the object linked to the j-th slot at position k.
+
+ TObject* obj=0;
+ // Note : In the internal storage matrix slots=columns positions=rows
+ if (fLinks) obj=fLinks->GetObject(k,j);
+ return obj;
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliSignal::GetLink(TString name,Int_t k) const
{
-// Provide pointer of the object linked to the j-th slot.
+// Provide pointer of the object linked to the name-spec. slot at position k.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
TObject* obj=0;
- if (j <= GetNlinks()) obj=fLinks->At(j-1);
+ if (j>0) obj=GetLink(j,k);
return obj;
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::SetLink(TObject* obj,Int_t j)
+void AliSignal::SetLink(TObject* obj,Int_t j,Int_t k)
{
-// Introduce a link (=pointer) to an object for the j-th slot.
+// Introduce a link (=pointer) to an object for the j-th slot at position k.
// Only the pointer values are stored for (backward) reference, meaning
// that the objects of which the pointers are stored are NOT owned
// by the AliSignal object.
//
// Notes :
-// The link of the first slot is at j=1.
-// j=1 is the default value.
+// The first slot is at j=1 and the first position is at k=1.
+// j=1 and k=1 are the default values.
//
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the links, the number of reserved slots for the links
-// is increased automatically (unless the pointer argument is zero).
+// If needed, the storage area for the links is increased automatically.
//
// In case the pointer argument is zero, indeed a value of zero will be
-// stored for the specified slot (unless j exceeds the current maximum).
+// stored at the specified position (k) for the specified slot (j).
//
// In principle any object derived from TObject can be referred to by this
// mechanism.
// Please also have a look at the docs of the memberfunction ResetLink()
// to prevent the situation of stored pointers to non-existent object.
- if (!fLinks && obj)
- {
- fLinks=new TObjArray(j);
- }
+ if (!fLinks && obj) fLinks=new AliObjMatrix();
- if (j>fLinks->GetSize() && obj) fLinks->Expand(j);
+ if (!fLinks) return;
- if (j<=fLinks->GetSize())
+ // Note : In the internal storage matrix slots=columns positions=rows
+ fLinks->EnterObject(k,j,obj);
+ if (obj)
{
- fLinks->AddAt(obj,j-1);
- if (obj)
+ if (obj->InheritsFrom("AliTrack"))
{
- if (obj->InheritsFrom("AliTrack"))
- {
- AliTrack* t=(AliTrack*)obj;
- t->AddSignal(*this);
- }
+ AliTrack* t=(AliTrack*)obj;
+ t->AddSignal(*this);
}
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::ResetLink(Int_t j)
+void AliSignal::SetLink(TObject* obj,TString name,Int_t k)
+{
+// Introduce a link (=pointer) to an object for the name-spec. slot at position k.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the objects of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) SetLink(obj,j,k);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::AddLink(TObject* obj,Int_t j)
+{
+// Introduce a link (=pointer) to an object for the j-th slot at the first
+// free position.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the objects of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// Notes :
+// The first slot is at j=1 and the first position is at k=1.
+// j=1 is the default value.
+//
+// If needed, the storage area for the links is increased automatically.
+//
+// In case the pointer argument is zero, no link will be added.
+//
+// In principle any object derived from TObject can be referred to by this
+// mechanism.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
+// object, the current signal is automatically related to this AliTrack
+// (or derived) object.
+//
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object.
+
+ if (!obj || j<=0) return;
+
+ if (!fLinks) fLinks=new AliObjMatrix();
+
+ TObject* dum=0;
+ Int_t n=GetNlinks(dum,j);
+ Int_t pos=1;
+ for (Int_t k=1; k<=n; k++)
+ {
+ dum=GetLink(j,k);
+ if (!dum) break;
+ pos++;
+ }
+
+ SetLink(obj,j,pos);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::AddLink(TObject* obj,TString name)
+{
+// Introduce a link (=pointer) to an object for the name-spec slot at the first
+// free position.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the objects of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) AddLink(obj,j);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetLink(Int_t j,Int_t k)
{
-// Reset the link of the j-th (default j=1) slot.
-// Notes : The first link position is at j=1.
-// j=0 ==> All links will be reset and the storage array deleted.
+// Reset the link of the j-th slot at position k.
+//
+// Notes :
+// The first slot is at j=1 and the first position is at k=1.
+// j=1 and k=1 are the default values.
+//
+// This memberfunction is intended to reset only 1 specified link location.
+// For extended functionality, please refer to the memberfuction ResetLinks().
//
// In general the user should take care of properly clearing the corresponding
// pointer here when the referred object is deleted.
// the user doesn't have to worry about clearing the corresponding AliTrack link from
// the AliSignal object when the corresponding AliTrack object is deleted.
- if (!fLinks || j<0) return;
-
- TObject* obj=0;
+ // Note : In the internal storage matrix slots=columns positions=rows
+ if (fLinks) fLinks->RemoveObject(k,j);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetLink(TString name,Int_t k)
+{
+// Reset the link of the name-specified slot at position k.
+//
+// This memberfunction is intended to reset only 1 specified link location.
+// For extended functionality, please refer to the memberfuction ResetLinks().
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
- if (j)
- {
- SetLink(obj,j);
- }
- else
- {
- delete fLinks;
- fLinks=0;
- }
+ Int_t j=GetSlotIndex(name);
+ if (j>0) ResetLink(j,k);
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::ResetLink(TObject* obj)
+void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
{
-// Reset the link of the all the slots referring to the specified object.
+// Reset single or multiple link(s) according to user specified selections.
+//
+// A link is only reset if the stored reference matches the argument "obj".
+// In case obj=0 no check on the matching of the stored reference is performed
+// and the stored link is always reset in accordance with the other
+// selection criteria.
+//
+// In case the slot argument "j" is specified, only the links from that
+// specified slot will be deleted.
+// In case j=0 (default) no checking on the slot index is performed.
+//
+// In case the position argument "k" is specified, only the links from that
+// specified position will be deleted.
+// In case k=0 (default) no checking on the position index is performed.
+//
+// So, invokation of ResetLinks(obj) will remove all references to the
+// object "obj" from the total AliSignal, whereas ResetLinks(obj,j)
+// will remove all references to the object "obj" only from slot "j".
+//
+// Notes :
+// -------
+// The first slot is indicated as j=1, whereas the first position is at k=1.
+//
+// Invokation of ResetLinks(0,row,col) is equivalent to invoking the
+// memberfunction ResetLink(row,col).
+// Invoking the latter directly is slightly faster.
+//
+// Invokation of ResetLinks(0) will reset all stored references in this AliSignal.
//
// In general the user should take care of properly clearing the corresponding
// pointer here when the referred object is deleted.
// the user doesn't have to worry about clearing the corresponding AliTrack link from
// the AliSignal object when the corresponding AliTrack object is deleted.
- if (!fLinks || !obj) return;
+ if (!fLinks) return;
- Int_t nlinks=GetNlinks();
- for (Int_t i=1; i<=nlinks; i++)
+ if (!obj && !j && !k)
{
- TObject* obj2=GetLink(i);
- if (obj2==obj) ResetLink(i);
+ fLinks->Reset();
}
+ else
+ {
+ // Note : In the internal storage matrix slots=columns positions=rows
+ fLinks->RemoveObjects(obj,k,j);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
+{
+// Reset single or multiple link(s) according to user specified selections.
+//
+// A link is only reset if the stored reference matches the argument "obj".
+// In case obj=0 no check on the matching of the stored reference is performed
+// and the stored link is always reset in accordance with the other
+// selection criteria.
+//
+// In case the position argument "k" is specified, only the links from that
+// specified position will be deleted.
+// In case k=0 (default) no checking on the position index is performed.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) ResetLinks(obj,j,k);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,TArrayI& ks) const
+{
+// Provide the slot and position indices of all the storage locations
+// of the specified object.
+// The slot (j) and pos. (k) indices are returned in the two separate TArrayI arrays
+// from which the (j,k) pairs can be obtained from the corresponding
+// array indices like (j,k)=(js.At(i),ks.At(i)).
+// The integer return argument represents the number of (j,k) pairs which
+// were encountered for the specified object.
+//
+// If obj=0 no object selection is performed and all (j,k) indices
+// of the stored references for all objects are returned.
+//
+// Notes :
+// -------
+// As usual the convention is that slot and position numbering starts at 1.
+//
+// This memberfunction always resets the two TArrayI arrays at the start.
+//
+// This memberfunction can only be used to obtain the (j,k) indices
+// of the object as stored via the SetLink() or AddLink() memberfunction.
+// This means that in case the user has entered a TObjArray as object
+// (to increase the dimension of the resulting structure), the (j,k)
+// indices of that TObjArray are obtained and NOT the indices of the
+// actual objects contained in that TObjArray structure.
+//
+ Int_t nrefs=0;
+ js.Reset();
+ ks.Reset();
+ // Note : In the internal storage matrix slots=columns positions=rows
+ if (fLinks) nrefs=fLinks->GetIndices(obj,ks,js);
+ return nrefs;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetIndices(TObject* obj,Int_t j,TArrayI& ks) const
+{
+// Provide the position indices of all the storage locations of the
+// specified object in the j-th slot of this AliSignal.
+// The position indices are returned in the TArrayI array.
+// The integer return argument represents the number of storage locations which
+// were encountered for the specified object in the j-th slot.
+//
+// If obj=0 no object selection is performed and all position indices
+// of the stored references for all objects of the j-th slot are returned.
+//
+// If j=0 all slots will be scanned and all position indices matching the
+// object selection are returned.
+// Note that in this case multiple appearances of the same position index
+// will only be recorded once in the returned TArrayI array.
+//
+// Notes :
+// -------
+// As usual the convention is that slot and position numbering starts at 1.
+//
+// This memberfunction always resets the TArrayI array at the start.
+//
+// This memberfunction can only be used to obtain the position indices
+// of the object as stored via the SetLink() or AddLink() memberfunction.
+// This means that in case the user has entered a TObjArray as object
+// (to increase the dimension of the resulting structure), the position
+// indices of that TObjArray are obtained and NOT the indices of the
+// actual objects contained in that TObjArray structure.
+//
+ Int_t nrefs=0;
+ ks.Reset();
+ // Note : In the internal storage matrix slots=columns positions=rows
+ if (fLinks) nrefs=fLinks->GetIndices(obj,ks,j);
+ return nrefs;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetIndices(TObject* obj,TString name,TArrayI& ks) const
+{
+// Provide the position indices of all the storage locations of the
+// specified object in the name-specified slot of this AliSignal.
+// The position indices are returned in the TArrayI array.
+// The integer return argument represents the number of storage locations which
+// were encountered for the specified object in the j-th slot.
+//
+// If obj=0 no object selection is performed and all position indices
+// of the stored references for all objects of the j-th slot are returned.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Int_t n=0;
+ if (j>0) n=GetIndices(obj,j,ks);
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetIndices(TObject* obj,TArrayI& js,Int_t k) const
+{
+// Provide the slot indices of all the storage locations of the
+// specified object for the k-th position in this AliSignal.
+// The slot indices are returned in the TArrayI array.
+// The integer return argument represents the number of storage locations which
+// were encountered for the specified object in the k-th position.
+//
+// If obj=0 no object selection is performed and all slot indices
+// of the stored references for all objects in the k-th position are returned.
+//
+// If k=0 all positions will be scanned and all slot indices matching the
+// object selection are returned.
+// Note that in this case multiple appearances of the same slot index
+// will only be recorded once in the returned TArrayI array.
+//
+// Notes :
+// -------
+// As usual the convention is that slot and position numbering starts at 1.
+//
+// This memberfunction always resets the TArrayI array at the start.
+//
+// This memberfunction can only be used to obtain the slot indices
+// of the object as stored via the SetLink() or AddLink() memberfunction.
+// This means that in case the user has entered a TObjArray as object
+// (to increase the dimension of the resulting structure), the slot
+// indices of that TObjArray are obtained and NOT the indices of the
+// actual objects contained in that TObjArray structure.
+//
+ Int_t nrefs=0;
+ js.Reset();
+ // Note : In the internal storage matrix slots=columns positions=rows
+ if (fLinks) nrefs=fLinks->GetIndices(obj,k,js);
+ return nrefs;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetSwapMode(Int_t swap)
+{
+// Set swapmode flag for the internal link storage.
+// In case for the stored links the maximum slot number differs considerably
+// from the maximum position number, it might be more efficient
+// (w.r.t. memory usage and/or output file size) to internally store the
+// link reference matrix with the rows and colums swapped.
+// This swapping is only related with the internal storage and as such
+// is completely hidden for the user.
+// At invokation of this memberfunction the default argument is swap=1.
+//
+// Note : The swap mode can only be set as long as no links are
+// stored in the AliSignal (i.e. a new instance of AliSignal
+// or after invokation of the Reset() or ResetLinks() function).
+
+ if (!fLinks) fLinks=new AliObjMatrix();
+ fLinks->SetSwapMode(swap);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetSwapMode() const
+{
+// Provide swapmode flag of the link storage.
+ Int_t swap=0;
+ if (fLinks) swap=fLinks->GetSwapMode();
+ return swap;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetDevice(TObject* dev)
+{
+// Store the pointer to the device which owns this AliSignal object.
+// This memberfunction is meant for internal use in AliDevice.
+ fDevice=dev;
+}
+///////////////////////////////////////////////////////////////////////////
+AliDevice* AliSignal::GetDevice() const
+{
+// Provide the pointer to the device which owns this AliSignal object.
+ return (AliDevice*)fDevice;
}
///////////////////////////////////////////////////////////////////////////
-TObject* AliSignal::Clone(char* name)
+TObject* AliSignal::Clone(const char* name) const
{
// Make a deep copy of the current object and provide the pointer to the copy.
// This memberfunction enables automatic creation of new objects of the