// 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
// signal=82.5; // e.g. signal time in ns
// error=2.01;
// offset=0.003;
-// q.SetSlotName("TOF");
+// 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;
+// offset=1.5732;
// // Addressing via name specification instead of index
-// q.SetSlotName("ADC");
+// 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.SetSlotName("dE/dx");
-// q.SetSignal(signal,3);
-// q.SetSignalError(error,3);
-// q.SetOffset(offset,3);
-// q.SetGain(gain,3);
-//
-// Float_t dedx=q.GetSignal("dE/dx");
+// 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
// when entering values and/or errors.
fSignals=0;
fDsignals=0;
+ fSigflags=0;
fWaveforms=0;
fLinks=0;
fDevice=0;
+ fTracks=0;
}
///////////////////////////////////////////////////////////////////////////
AliSignal::~AliSignal()
delete fDsignals;
fDsignals=0;
}
+ if (fSigflags)
+ {
+ delete fSigflags;
+ fSigflags=0;
+ }
if (fWaveforms)
{
delete fWaveforms;
fWaveforms=0;
}
if (fLinks)
+ {
+ delete fLinks;
+ fLinks=0;
+ }
+ if (fTracks)
{
// Remove this signal from all related tracks
- for (Int_t i=1; i<=fLinks->GetNobjects(); i++)
+ for (Int_t i=1; i<=GetNtracks(); i++)
{
- TObject* obj=fLinks->GetObject(i);
- if (!obj) continue;
- if (obj->InheritsFrom("AliTrack"))
- {
- AliTrack* tx=(AliTrack*)obj;
- tx->RemoveSignal(*this);
- }
+ AliTrack* tx=GetTrack(i);
+ if (tx) tx->RemoveSignal(*this,0);
}
- delete fLinks;
- fLinks=0;
+ delete fTracks;
+ fTracks=0;
}
}
///////////////////////////////////////////////////////////////////////////
// Copy constructor
fSignals=0;
fDsignals=0;
+ fSigflags=0;
fWaveforms=0;
fLinks=0;
+ fTracks=0;
// Don't copy the owning device pointer for the copy
fDevice=0;
Double_t val;
for (Int_t i=1; i<=n; i++)
{
- val=s.GetSignal(i);
- SetSignal(val,i);
+ if (s.GetSignalFlag(i))
+ {
+ val=s.GetSignal(i);
+ SetSignal(val,i);
+ }
}
n=s.GetNerrors();
for (Int_t j=1; j<=n; j++)
{
- val=s.GetSignalError(j);
- SetSignalError(val,j);
+ if (s.GetErrorFlag(j))
+ {
+ val=s.GetSignalError(j);
+ SetSignalError(val,j);
+ }
}
n=s.GetNwaveforms();
TObject* obj=s.GetLink(slot,pos);
if (obj) SetLink(obj,slot,pos);
}
+
+ Int_t ntk=s.GetNtracks();
+ if (ntk)
+ {
+ fTracks=new TObjArray(ntk);
+ for (Int_t it=1; it<=ntk; it++)
+ {
+ AliTrack* tx=s.GetTrack(it);
+ fTracks->Add(tx);
+ }
+ }
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::Reset(Int_t mode)
if (fLinks) fLinks->Reset();
fDevice=0;
+
+ if (fTracks)
+ {
+ delete fTracks;
+ fTracks=0;
+ }
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetSignals(Int_t mode)
mode=0;
}
+ Int_t sflag=0;
+ Int_t eflag=0;
+
if (fSignals && (mode==0 || mode==1))
{
- for (Int_t i=0; i<fSignals->GetSize(); i++)
+ for (Int_t i=1; i<=fSignals->GetSize(); i++)
{
- fSignals->AddAt(0,i);
+ fSignals->AddAt(0,i-1);
+ eflag=GetErrorFlag(i);
+ SetSigFlags(0,eflag,i);
}
}
if (fDsignals && (mode==0 || mode==2))
{
- for (Int_t j=0; j<fDsignals->GetSize(); j++)
+ for (Int_t j=1; j<=fDsignals->GetSize(); j++)
{
- fDsignals->AddAt(0,j);
+ fDsignals->AddAt(0,j-1);
+ sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,0,j);
}
}
fDsignals=0;
}
+ Int_t sflag=0;
+ Int_t eflag=0;
+
+ if (mode==0)
+ {
+ delete fSigflags;
+ fSigflags=0;
+ }
+ else if (mode==1)
+ {
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ eflag=GetErrorFlag(i);
+ SetSigFlags(0,eflag,i);
+ }
+ }
+ else if (mode==2)
+ {
+ for (Int_t j=1; j<=fSigflags->GetSize(); j++)
+ {
+ sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,0,j);
+ }
+ }
+
DeleteWaveform(0);
}
///////////////////////////////////////////////////////////////////////////
}
fSignals->AddAt(float(sig),j-1);
+
+ Int_t eflag=GetErrorFlag(j);
+ SetSigFlags(1,eflag,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignal(Double_t sig,TString name)
Float_t sum=(fSignals->At(j-1))+sig;
fSignals->AddAt(sum,j-1);
+
+ Int_t eflag=GetErrorFlag(j);
+ SetSigFlags(1,eflag,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::AddSignal(Double_t sig,TString name)
{
// 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
{
// Provide signal value of the name-specified slot.
// In case no signal is present, 0 is returned.
-// The parameter "mode" allows for automatic gain etc... correction of the signal.
-//
-// 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 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.
-// In case the j-th slot was marked dead, 0 is returned.
-//
-// The corrected signal (sigc) is determined as follows :
-//
-// sigc=(signal/gain)-offset
+// 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.
//
}
fDsignals->AddAt(float(dsig),j-1);
+
+ Int_t sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,1,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignalError(Double_t dsig,TString name)
return val;
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::Data(TString f) const
+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();
if (strlen(title)) cout << " Title : " << title;
cout << endl;
cout << " Position";
- Ali3Vector::Data(f);
+ AliPosition::Data(f,u);
if (fDevice)
{
const char* devname=fDevice->GetName();
// Provide an overview of the stored waveforms
ListWaveform(-1);
+ // Provide an overview of the associated tracks
+ ListTrack(-1);
+
// Provide an overview of all the data and attribute slots
List(-1);
}
}
}
- Int_t nvalues=GetNvalues();
- Int_t nerrors=GetNerrors();
+ Int_t n=GetNslots();
Int_t nlinkslots=0;
- if (fLinks) nlinkslots=fLinks->GetMaxColumn();
- Int_t n=nvalues;
- if (nerrors>n) n=nerrors;
+ if (GetNlinks()) nlinkslots=fLinks->GetMaxColumn();
if (nlinkslots>n) n=nlinkslots;
-
+
TObject* obj=0;
Int_t nrefs=0;
TArrayI posarr;
{
for (Int_t i=1; i<=n; 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++)
+
+ if (GetSignalFlag(i) || GetErrorFlag(i) || GetCalFunction(i) || GetDecalFunction(i) || GetCalWord(i) || nrefs)
{
- pos=posarr.At(k);
- obj=GetLink(i,pos);
- if (obj)
+ cout << " Slot : " << i;
+ if (GetSignalFlag(i)) cout << " Signal value : " << GetSignal(i);
+ if (GetErrorFlag(i)) cout << " error : " << GetSignalError(i);
+ AliAttrib::List(i);
+ cout << endl;
+
+ for (Int_t k=0; k<nrefs; k++)
{
- cout << " Link at position " << pos << " to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
+ pos=posarr.At(k);
+ obj=GetLink(i,pos);
+ if (obj)
{
- const char* lname=obj->GetName();
- const char* ltitle=obj->GetTitle();
- if (strlen(lname)) cout << " Name : " << lname;
- if (strlen(ltitle)) cout << " Title : " << ltitle;
+ 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;
}
- cout << endl;
}
}
}
{
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++)
+
+ if (GetSignalFlag(j) || GetErrorFlag(j) || GetCalFunction(j) || GetDecalFunction(j) || GetCalWord(j) || nrefs)
{
- pos=posarr.At(kj);
- obj=GetLink(j,pos);
- if (obj)
+ cout << " Slot : " << j;
+ if (GetSignalFlag(j)) cout << " Signal value : " << GetSignal(j);
+ if (GetErrorFlag(j)) cout << " error : " << GetSignalError(j);
+ AliAttrib::List(j);
+ cout << endl;
+
+ for (Int_t kj=0; kj<nrefs; kj++)
{
- cout << " Link at position " << pos << " to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
+ pos=posarr.At(kj);
+ obj=GetLink(j,pos);
+ if (obj)
{
- const char* lnamej=obj->GetName();
- const char* ltitlej=obj->GetTitle();
- if (strlen(lnamej)) cout << " Name : " << lnamej;
- if (strlen(ltitlej)) cout << " Title : " << ltitlej;
+ 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;
}
- cout << endl;
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////
+void AliSignal::ListTrack(Int_t j) const
+{
+// Provide information for the j-th associated track.
+// The first associated track is at j=1.
+// In case j=0 (default) the info of all associated tracks will be listed.
+// In case j=-1 the info of all tracks will be listed, but the header
+// information will be suppressed.
+
+ if (j<-1)
+ {
+ cout << " *AliSignal::ListTrack* Invalid argument j = " << j << endl;
+ return;
+ }
+
+ if (j != -1)
+ {
+ const char* name=GetName();
+ const char* title=GetTitle();
+
+ cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
+ if (strlen(name)) cout << " Name : " << name;
+ if (strlen(title)) cout << " Title : " << title;
+ cout << endl;
+ if (fDevice)
+ {
+ const char* devname=fDevice->GetName();
+ const char* devtitle=fDevice->GetTitle();
+ cout << " Owned by device : " << fDevice->ClassName();
+ if (strlen(devname)) cout << " Name : " << devname;
+ if (strlen(devtitle)) cout << " Title : " << devtitle;
+ cout << endl;
+ }
+ }
+
+ Int_t n=GetNtracks();
+ AliTrack* tx=0;
+
+ if (j<=0)
+ {
+ for (Int_t i=1; i<=n; i++)
+ {
+ tx=GetTrack(i);
+ if (tx)
+ {
+ const char* txname=tx->GetName();
+ const char* txtitle=tx->GetTitle();
+ cout << " Track " << i << " : " << tx->ClassName() << " Id : " << tx->GetId();
+ if (strlen(txname)) cout << " Name : " << txname;
+ if (strlen(txtitle)) cout << " Title : " << txtitle;
+ cout << endl;
+ }
+ }
+ }
+ else
+ {
+ if (j<=n)
+ {
+ tx=GetTrack(j);
+ if (tx)
+ {
+ const char* txnamej=tx->GetName();
+ const char* txtitlej=tx->GetTitle();
+ cout << " Track " << j << " : " << tx->ClassName() << " Id : " << tx->GetId();
+ if (strlen(txnamej)) cout << " Name : " << txnamej;
+ if (strlen(txtitlej)) cout << " Title : " << txtitlej;
+ cout << endl;
+ }
+ }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
Int_t AliSignal::GetNvalues() const
{
// Provide the number of values for this signal.
+
+ if (!fSignals) return 0;
+
Int_t n=0;
- if (fSignals) n=fSignals->GetSize();
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ if (GetSignalFlag(i)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t AliSignal::GetNerrors() const
{
// Provide the number specified errors on the values for this signal.
+
+ if (!fDsignals) return 0;
+
Int_t n=0;
- if (fDsignals) n=fDsignals->GetSize();
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ if (GetErrorFlag(i)) n=i;
+ }
+
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetSigFlags(Int_t is,Int_t ie,Int_t j)
+{
+// Store signal and/or error value flags of the j-th (default j=1) slot.
+// Note : The first slot is at j=1.
+// In case the value of the index j exceeds the maximum number of reserved
+// slots for the flags, the number of reserved slots for the flags is
+// increased automatically.
+// The value stored is : 10*signalflag + errorflag.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::SetSigFlags* Invalid argument j = " << j << endl;
+ return;
+ }
+
+ if (!fSigflags)
+ {
+ fSigflags=new TArrayI(j);
+ }
+
+ Int_t size=fSigflags->GetSize();
+
+ if (j>size)
+ {
+ fSigflags->Set(j);
+ }
+
+ Int_t word=10*is+ie;
+
+ fSigflags->AddAt(word,j-1);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetSignalFlag(Int_t j) const
+{
+// Provide signal value flag of the j-th (default j=1) slot.
+//
+// flag = 1 : Signal value was set
+// 0 : Signal value was not set
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::GetSignalFlag* Invalid argument j = " << j << endl;
+ return 0;
+ }
+ Int_t flag=0;
+ if (fSigflags)
+ {
+ if (j>0 && j<=(fSigflags->GetSize()))
+ {
+ Int_t word=fSigflags->At(j-1);
+ flag=word/10;
+ }
+ }
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetSignalFlag(TString name) const
+{
+// Provide signal value flag of the name-specified slot.
+//
+// flag = 1 : Signal value was set
+// 0 : Signal value was not set
+//
+//
+// 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 flag=0;
+ if (j>0) flag=GetSignalFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetErrorFlag(Int_t j) const
+{
+// Provide error value flag of the j-th (default j=1) slot.
+//
+// flag = 1 : Error value was set
+// 0 : Error value was not set
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::GetErrorFlag* Invalid argument j = " << j << endl;
+ return 0;
+ }
+ Int_t flag=0;
+ if (fSigflags)
+ {
+ if (j>0 && j<=(fSigflags->GetSize()))
+ {
+ Int_t word=fSigflags->At(j-1);
+ flag=word%10;
+ }
+ }
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetErrorFlag(TString name) const
+{
+// Provide error value flag of the name-specified slot.
+//
+// flag = 1 : Error value was set
+// 0 : Error value was not set
+//
+//
+// 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 flag=0;
+ if (j>0) flag=GetErrorFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNslots() const
+{
+// Provide the number of existing slots.
+
+ Int_t n=AliAttrib::GetNslots();
+
+ if (!fSigflags) return n;
+
+ Int_t nflags=0;
+ for (Int_t i=0; i<fSigflags->GetSize(); i++)
+ {
+ if (fSigflags->At(i)) nflags=i+1;
+ }
+
+ if (n<nflags) n=nflags;
+
return n;
}
///////////////////////////////////////////////////////////////////////////
return 0;
}
+ if (!fLinks) return 0;
+
Int_t n=0;
if (!j)
{
- if (fLinks) n=fLinks->GetNrefs(obj);
+ n=fLinks->GetNrefs(obj);
}
else
{
// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
// object, the current signal is automatically related to this AliTrack
// (or derived) object.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
//
// Please also have a look at the docs of the memberfunction ResetLink()
// to prevent the situation of stored pointers to non-existent object.
if (obj->InheritsFrom("AliTrack"))
{
AliTrack* t=(AliTrack*)obj;
- t->AddSignal(*this);
+ AddTrack(*t,1);
}
}
}
// defined and/or when this procedure is invoked many times.
// In such cases it is preferable to use indexed addressing in the user code
// either directly or via a few invokations of GetSlotIndex().
+//
+// In case the pointer argument is zero, indeed a value of zero will be
+// stored at the specified position (k) for the specified slotname.
+//
+// In principle any object derived from TObject can be referred to by this
+// mechanism.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
+// object, the current signal is automatically related to this AliTrack
+// (or derived) object.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
+//
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object.
Int_t j=GetSlotIndex(name);
if (j>0) SetLink(obj,j,k);
// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
// object, the current signal is automatically related to this AliTrack
// (or derived) object.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
//
// Please also have a look at the docs of the memberfunction ResetLink()
// to prevent the situation of stored pointers to non-existent object.
// defined and/or when this procedure is invoked many times.
// In such cases it is preferable to use indexed addressing in the user code
// either directly or via a few invokations of GetSlotIndex().
+//
+// In case the pointer argument is zero, indeed a value of zero will be
+// stored at the first free position of the specified slotname.
+//
+// In principle any object derived from TObject can be referred to by this
+// mechanism.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// Therefore, in case the input argument "obj" points to an AliTrack (or derived)
+// object, the current signal is automatically related to this AliTrack
+// (or derived) object.
+// Also a global link to this AliTrack (or derived) object will be stored
+// via the AddTrack() facility.
+//
+// IMPORTANT NOTE :
+// ----------------
+// In case one just wants to relate the current AliSignal to a certain AliTrack
+// without a specific signal slot association, it is much more efficient
+// (both memory and CPU wise) to use the memberfunction AddTrack() instead.
+//
+// Please also have a look at the docs of the memberfunction ResetLink()
+// to prevent the situation of stored pointers to non-existent object.
Int_t j=GetSlotIndex(name);
if (j>0) AddLink(obj,j);
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
{
-// Reset single or multiple link(s) according to user specified selections.
+// Reset single or multiple slot link(s) according to user specified selections.
+//
+// IMPORTANT NOTE :
+// ----------------
+// This facility only acts on the slot related links.
+// The global track reference list will not be affected.
+// To remove all references to AliTrack (or derived) objects, please
+// use the RemoveTrack() of RemoveTracks() memberfunctions.
//
// A link is only reset if the stored reference matches the argument "obj".
// In case obj=0 no check on the matching of the stored reference is performed
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetLinks(TObject* obj,TString name,Int_t k)
{
-// Reset single or multiple link(s) according to user specified selections.
+// Reset single or multiple slot link(s) according to user specified selections.
+//
+// IMPORTANT NOTE :
+// ----------------
+// This facility only acts on the slot related links.
+// The global track reference list will not be affected.
+// To remove all references to AliTrack (or derived) objects, please
+// use the RemoveTrack() of RemoveTracks() memberfunctions.
//
// A link is only reset if the stored reference matches the argument "obj".
// In case obj=0 no check on the matching of the stored reference is performed
// defined and/or when this procedure is invoked many times.
// In such cases it is preferable to use indexed addressing in the user code
// either directly or via a few invokations of GetSlotIndex().
+//
+// In general the user should take care of properly clearing the corresponding
+// pointer here when the referred object is deleted.
+// However, this "linking back" facility was introduced to enable AliSignal slots
+// to refer directly to the various AliTracks to which the AliSignal object itself
+// is related (see AliTrack::AddSignal).
+// As such, the AliTrack destructor already takes care of clearing the corresponding
+// links from the various AliSignal slots for all the AliSignal objects that were
+// related to that AliTrack.
+// So, in case the link introduced via SetLink() is the pointer of an AliTrack object,
+// the user doesn't have to worry about clearing the corresponding AliTrack link from
+// the AliSignal object when the corresponding AliTrack object is deleted.
Int_t j=GetSlotIndex(name);
if (j>0) ResetLinks(obj,j,k);
return (AliDevice*)fDevice;
}
///////////////////////////////////////////////////////////////////////////
+void AliSignal::AddTrack(AliTrack& t,Int_t mode)
+{
+// Relate an AliTrack object to this signal.
+// Only the pointer values are stored for (backward) reference, meaning
+// that the tracks of which the pointers are stored are NOT owned
+// by the AliSignal object.
+//
+// mode = 0 : Only the reference to the specified track is stored in
+// the current signal, without storing the (backward) reference
+// to this signal into the AliTrack structure.
+// 1 : The (backward) reference to the current signal is also automatically
+// stored into the AliTrack (or derived) object specified in the
+// input argument.
+//
+// The default is mode=1.
+
+ if (!fTracks) fTracks=new TObjArray(1);
+
+ // Check if this track is already stored for this signal
+ Int_t ntk=GetNtracks();
+ for (Int_t i=0; i<ntk; i++)
+ {
+ if (&t==fTracks->At(i)) return;
+ }
+
+ fTracks->Add(&t);
+ if (mode==1) t.AddSignal(*this,0);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::RemoveTrack(AliTrack& t,Int_t mode)
+{
+// Remove related AliTrack object from this signal.
+// Also all references (if any) to this track in the slot links area
+// are removed.
+//
+// mode = 0 : All references to the specified track are removed from
+// the current signal, without removing the (backward) reference
+// to this signal from the AliTrack structure.
+// 1 : The (backward) reference to the current signal is also automatically
+// removed from the AliTrack (or derived) object specified in the
+// input argument.
+//
+// The default is mode=1.
+
+ if (fTracks)
+ {
+ AliTrack* test=(AliTrack*)fTracks->Remove(&t);
+ if (test) fTracks->Compress();
+ }
+
+ ResetLinks(&t);
+
+ if (mode==1) t.RemoveSignal(*this,0);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::RemoveTracks(Int_t mode)
+{
+// Remove all related AliTrack objects from this signal.
+// Also all references (if any) to the related tracks in the slot links area
+// are removed.
+//
+// mode = 0 : All track references are removed from the current signal,
+// without removing the (backward) references to this signal from
+// the corresponding AliTrack objects.
+// 1 : The (backward) references to the current signal are also automatically
+// removed from the corresponding AliTrack (or derived) objects.
+//
+// The default is mode=1.
+
+ if (!fTracks) return;
+
+ Int_t ntk=GetNtracks();
+ for (Int_t i=0; i<ntk; i++)
+ {
+ AliTrack* tx=(AliTrack*)fTracks->At(i);
+ if (tx)
+ {
+ ResetLinks(tx);
+ if (mode==1) tx->RemoveSignal(*this,0);
+ }
+ }
+
+ delete fTracks;
+ fTracks=0;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNtracks(AliTrack* t) const
+{
+// Provide the number of related AliTracks.
+// In case an AliTrack pointer is specified as input argument,
+// the number returned will be the number of occurrences (i.e. 0 or 1)
+// for that specified track.
+// By default t=0, which implies that just the number of all associated
+// tracks will be returned.
+
+ if (!fTracks) return 0;
+
+ Int_t ntk=fTracks->GetEntries();
+
+ if (!t) return ntk;
+
+ for (Int_t i=0; i<ntk; i++)
+ {
+ AliTrack* tx=(AliTrack*)fTracks->At(i);
+ if (tx==t) return 1;
+ }
+
+ return 0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliTrack* AliSignal::GetTrack(Int_t j) const
+{
+// Provide the related AliTrack number j.
+// Note : j=1 denotes the first track.
+
+ if (!fTracks) return 0;
+
+ if ((j >= 1) && (j <= GetNtracks()))
+ {
+ return (AliTrack*)fTracks->At(j-1);
+ }
+ else
+ {
+ cout << " *AliSignal* track number : " << j << " out of range."
+ << " Ntk = " << GetNtracks() << endl;
+ return 0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliTrack* AliSignal::GetIdTrack(Int_t id) const
+{
+// Return the track with user identifier "id" of this signal
+ if (!fTracks) return 0;
+
+ AliTrack* tx=0;
+ for (Int_t i=0; i<GetNtracks(); i++)
+ {
+ tx=(AliTrack*)fTracks->At(i);
+ if (id == tx->GetId()) return tx;
+ }
+ return 0; // No matching id found
+}
+///////////////////////////////////////////////////////////////////////////
TObject* AliSignal::Clone(const char* name) const
{
// Make a deep copy of the current object and provide the pointer to the copy.