///////////////////////////////////////////////////////////////////////////
// Class AliSignal
-// Handling of ALICE (extrapolated) signals.
+// Generic handling of (extrapolated) detector signals.
//
// Note :
// ------
// Float_t adc=s.GetSignal();
// Float_t sigma=s.GetSignalError();
//
-// AliSignal q(3); // q can store 3 signal values with their errors
+// AliSignal q(3); // q can store initially 3 signal values with their errors
// // In the example below a signal contains the
// // following data : timing, ADC and dE/dx
// q.SetName("TOF hit");
AliSignal::AliSignal(Int_t n)
{
// Creation of an AliSignal object and initialisation of parameters.
-// A total of n (default n=1) values (with errors) can be stored.
- fNvalues=n;
+// Initially a total of n (default n=1) values (with errors) can be stored.
+// If needed, the storage for values (and errors) will be expanded automatically
+// when entering values and/or errors.
fSignal=0;
fDsignal=0;
- fName=" ";
+ fName="Unspecified";
}
///////////////////////////////////////////////////////////////////////////
AliSignal::~AliSignal()
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::Reset()
+AliSignal::AliSignal(AliSignal& s)
+{
+// Copy constructor
+ fSignal=0;
+ fDsignal=0;
+ fName=s.GetName();
+
+ SetPosition((Ali3Vector&)s);
+
+ Int_t nvalues=s.GetNvalues();
+ Double_t sig;
+ for (Int_t i=1; i<=nvalues; i++)
+ {
+ sig=s.GetSignal(i);
+ SetSignal(sig,i);
+ }
+
+ Int_t nerrors=s.GetNerrors();
+ Double_t err;
+ for (Int_t j=1; j<=nerrors; j++)
+ {
+ err=s.GetSignalError(j);
+ SetSignalError(err,j);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::Reset(Int_t mode)
{
// Reset all signal and position values and errors to 0.
-// The data arrays are also created if not already existing.
+//
+// mode = 0 Reset position and all signal values and their errors to 0.
+// 1 Reset position and delete the signal and error storage arrays.
+//
+// The default when invoking Reset() corresponds to mode=0.
+//
+// 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)
+// in case the various signals always contain the same number of values.
+// The usage of mode=1 is slower, but allows a more efficient memory
+// occupation (and smaller output file size) in case the different
+// signals have a variable number of values.
+//
+// For more specific actions see ResetPosition(), ResetSignals()
+// and DeleteSignals().
- if (!fSignal) fSignal=new TArrayF(fNvalues);
- if (!fDsignal) fDsignal=new TArrayF(fNvalues);
+ if (mode<0 || mode>1)
+ {
+ cout << " *AliSignal::Reset* Invalid argument mode = " << mode << endl;
+ cout << " Default mode=0 will be used." << endl;
+ mode=0;
+ }
- Double_t r[3]={0,0,0};
- SetPosition(r,"sph");
- SetErrors(r,"car");
- for (Int_t i=0; i<fSignal->GetSize(); i++)
+ ResetPosition();
+ if (!mode)
+ {
+ ResetSignals();
+ }
+ else
+ {
+ DeleteSignals();
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::ResetSignals(Int_t mode)
+{
+// Reset various signal data according to user selection.
+//
+// mode = 0 Reset all signal values and their errors to 0.
+// 1 Reset only signal values
+// 2 Reset only signal errors
+//
+// The default when invoking ResetSignals() corresponds to mode=0.
+
+ if (mode<0 || mode>2)
+ {
+ cout << " *AliSignal::ResetSignals* Invalid argument mode = " << mode << endl;
+ cout << " Default mode=0 will be used." << endl;
+ mode=0;
+ }
+
+ if (fSignal && (mode==0 || mode==1))
+ {
+ for (Int_t i=0; i<fSignal->GetSize(); i++)
+ {
+ fSignal->AddAt(0,i);
+ }
+ }
+
+ if (fDsignal && (mode==0 || mode==2))
{
- fSignal->AddAt(0,i);
- fDsignal->AddAt(0,i);
+ for (Int_t j=0; j<fDsignal->GetSize(); j++)
+ {
+ fDsignal->AddAt(0,j);
+ }
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::ResetSignals()
+void AliSignal::DeleteSignals(Int_t mode)
{
-// Reset all signal values and errors to 0.
-// The data arrays are also created if not already existing.
+// Delete storage arrays of various signal data according to user selection.
+//
+// mode = 0 Delete arrays of both signal values and their errors.
+// 1 Delete only signal values array
+// 2 Delete only signal errors array
+//
+// The default when invoking DeleteSignals() corresponds to mode=0.
+
+ if (mode<0 || mode>2)
+ {
+ cout << " *AliSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
+ cout << " Default mode=0 will be used." << endl;
+ mode=0;
+ }
- if (!fSignal) fSignal=new TArrayF(fNvalues);
- if (!fDsignal) fDsignal=new TArrayF(fNvalues);
+ if (fSignal && (mode==0 || mode==1))
+ {
+ delete fSignal;
+ fSignal=0;
+ }
- for (Int_t i=0; i<fSignal->GetSize(); i++)
+ if (fDsignal && (mode==0 || mode==2))
{
- fSignal->AddAt(0,i);
- fDsignal->AddAt(0,i);
+ delete fDsignal;
+ fDsignal=0;
}
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::ResetPosition()
{
-// Reset position and errors to 0.
+// Reset the position and corresponding errors to 0.
Double_t r[3]={0,0,0};
SetPosition(r,"sph");
SetErrors(r,"car");
{
// Store j-th (default j=1) signal value.
// Note : The first signal value 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
+// signal values is increased automatically.
- if (!fSignal) ResetSignals();
-
- Int_t size=fSignal->GetSize();
- if (j<=size)
+ if (!fSignal)
{
- fSignal->AddAt(float(sig),j-1);
+ fSignal=new TArrayF(j);
+ ResetSignals(1);
}
- else
+
+ Int_t size=fSignal->GetSize();
+
+ if (j>size)
{
- cout << "*AliSignal::SetSignal* Index mismatch j : " << j
- << " size : " << size << endl;
+ fSignal->Set(j);
}
+
+ fSignal->AddAt(float(sig),j-1);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::AddSignal(Double_t sig,Int_t j)
{
// Add value to j-th (default j=1) signal value.
// Note : The first signal value 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
+// signal values is increased automatically.
- if (!fSignal) ResetSignals();
-
- Int_t size=fSignal->GetSize();
- if (j<=size)
+ if (!fSignal)
{
- Float_t sum=(fSignal->At(j-1))+sig;
- fSignal->AddAt(sum,j-1);
+ fSignal=new TArrayF(j);
+ ResetSignals(1);
}
- else
+
+ Int_t size=fSignal->GetSize();
+
+ if (j>size)
{
- cout << "*AliSignal::AddSignal* Index mismatch j : " << j
- << " size : " << size << endl;
+ fSignal->Set(j);
}
+
+ Float_t sum=(fSignal->At(j-1))+sig;
+ fSignal->AddAt(sum,j-1);
}
///////////////////////////////////////////////////////////////////////////
Float_t AliSignal::GetSignal(Int_t j)
{
// Provide j-th (default j=1) signal value.
// Note : The first signal value is at j=1.
+// In case no signal is present or the argument j is invalid, 0 is returned.
+ Float_t sig=0;
if (fSignal)
{
- return fSignal->At(j-1);
- }
- else
- {
- return 0;
+ if (j>0 && j<=(fSignal->GetSize()))
+ {
+ sig=fSignal->At(j-1);
+ }
+ else
+ {
+ cout << " *AliSignal::GetSignal* Index j = " << j << " invalid." << endl;
+ }
}
+ return sig;
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignalError(Double_t dsig,Int_t j)
{
// Store error on j-th (default j=1) signal value.
// Note : The error on the first signal value 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
+// signal errors is increased automatically.
- if (!fDsignal) ResetSignals();
-
- Int_t size=fDsignal->GetSize();
- if (j<=size)
+ if (!fDsignal)
{
- fDsignal->AddAt(float(dsig),j-1);
+ fDsignal=new TArrayF(j);
+ ResetSignals(2);
}
- else
+
+ Int_t size=fDsignal->GetSize();
+
+ if (j>size)
{
- cout << "*AliSignal::SetSignalError* Index mismatch j : " << j
- << " size : " << size << endl;
+ fDsignal->Set(j);
}
+
+ fDsignal->AddAt(float(dsig),j-1);
}
///////////////////////////////////////////////////////////////////////////
Float_t AliSignal::GetSignalError(Int_t j)
{
// Provide error on the j-th (default j=1) signal value.
// Note : The error on the first signal value is at j=1.
+// In case no signal is present or the argument j is invalid, 0 is returned.
+ Float_t err=0;
if (fDsignal)
{
- return fDsignal->At(j-1);
- }
- else
- {
- return 0;
+ if (j>0 && j<=(fDsignal->GetSize()))
+ {
+ err=fDsignal->At(j-1);
+ }
+ else
+ {
+ cout << " *AliSignal::GetSignalError* Index j = " << j << " invalid." << endl;
+ }
}
+ return err;
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::Info(TString f)
+void AliSignal::Data(TString f)
{
// Provide signal information within the coordinate frame f
- cout << " *AliSignal::Info* For signal of kind : " << fName << endl;
+ cout << " *AliSignal::Data* Signal of kind : " << fName << endl;
cout << " Position";
- Ali3Vector::Info(f);
-
- if (fSignal && fDsignal)
+ Ali3Vector::Data(f);
+
+ Int_t nvalues=GetNvalues();
+ Int_t nerrors=GetNerrors();
+
+ if (fSignal)
{
- for (Int_t i=0; i<fSignal->GetSize(); i++)
+ for (Int_t i=0; i<nvalues; i++)
{
- cout << " Signal value : " << fSignal->At(i)
- << " error : " << fDsignal->At(i) << endl;
+ cout << " Signal value : " << fSignal->At(i);
+ if (fDsignal && i<nerrors) cout << " error : " << fDsignal->At(i);
+ cout << endl;
}
}
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetName(TString name)
{
+// Set the name tag to indicate the kind of signal.
fName=name;
}
///////////////////////////////////////////////////////////////////////////
TString AliSignal::GetName()
{
+// Provide the name tag indicating the kind of signal.
return fName;
}
///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNvalues()
+{
+// Provide the number of values for this signal.
+ Int_t n=0;
+ if (fSignal) n=fSignal->GetSize();
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNerrors()
+{
+// Provide the number specified errors on the values for this signal.
+ Int_t n=0;
+ if (fDsignal) n=fDsignal->GetSize();
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff