02-aug-2005 NvE Support for explicit (de)calibration functions introduced in AliAttrib.
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 5 Aug 2005 07:53:09 +0000 (07:53 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 5 Aug 2005 07:53:09 +0000 (07:53 +0000)
03-aug-2005 NvE AliSignal::GetSignal has been extended to support various (de)calibration facilities.
                Printout is now also provided in AliSignal::List when only calibration data exist
                for AliDevice (or derived) objects.

RALICE/AliAttrib.cxx
RALICE/AliAttrib.h
RALICE/AliSignal.cxx
RALICE/history.txt

index bedbcc7c94932069dc3fb600609e81c504789aad..dd553320a7d392648691237c0df1cc6de7a54844 100644 (file)
@@ -57,6 +57,8 @@ AliAttrib::AliAttrib()
  fOffsets=0;
  fCalflags=0;
  fNames=0;
+ fCalfuncs=0;
+ fDecalfuncs=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliAttrib::~AliAttrib()
@@ -82,6 +84,16 @@ AliAttrib::~AliAttrib()
   delete fNames;
   fNames=0;
  }
+ if (fCalfuncs)
+ {
+  delete fCalfuncs;
+  fCalfuncs=0;
+ }
+ if (fDecalfuncs)
+ {
+  delete fDecalfuncs;
+  fDecalfuncs=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 AliAttrib::AliAttrib(const AliAttrib& a)
@@ -91,6 +103,8 @@ AliAttrib::AliAttrib(const AliAttrib& a)
  fOffsets=0;
  fCalflags=0;
  fNames=0;
+ fCalfuncs=0;
+ fDecalfuncs=0;
 
  Int_t n=0;
  Double_t val=0;
@@ -123,6 +137,20 @@ AliAttrib::AliAttrib(const AliAttrib& a)
   s=a.GetSlotName(in);
   if (s!="") SetSlotName(s,in);
  }
+
+ n=a.GetNcalfuncs();
+ for (Int_t icalf=1; icalf<=n; icalf++)
+ {
+  TF1* f=a.GetCalFunction(icalf);
+  if (f) SetCalFunction(f,icalf);
+ }
+
+ n=a.GetNdecalfuncs();
+ for (Int_t idecalf=1; idecalf<=n; idecalf++)
+ {
+  TF1* f=a.GetDecalFunction(idecalf);
+  if (f) SetDecalFunction(f,idecalf);
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetNgains() const
@@ -563,14 +591,17 @@ void AliAttrib::ResetOffset(TString name)
 void AliAttrib::DeleteCalibrations(Int_t mode)
 {
 // User selected delete of all gains and/or offsets.
-// mode = 0 : All attributes (names, gains, offsets, edge and dead values) are deleted.
+// mode = 0 : All attributes (names,gains,offsets,(de)calfuncs, edge and dead values) are deleted.
 //        1 : Only the gains are deleted.
 //        2 : Only the offsets are deleted.
-//        3 : Both gains and offsets are deleted, but names, edge and dead values are kept.
+//        3 : Gains, offsets and (de)calfuncs are deleted, but names, edge and dead values are kept.
+//        4 : Only the calib. functions are deleted.
+//        5 : Only the de-calib. functions are deleted.
+//        6 : Only the calib. and de-calib. functions are deleted.
 //
 // The default when invoking DeleteCalibrations() corresponds to mode=0.
 
- if (mode<0 || mode>3)
+ if (mode<0 || mode>6)
  {
   cout << " *AliAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
   cout << " Default mode=0 will be used." << endl;
@@ -601,6 +632,16 @@ void AliAttrib::DeleteCalibrations(Int_t mode)
    delete fNames;
    fNames=0;
   }
+  if (fCalfuncs)
+  {
+   delete fCalfuncs;
+   fCalfuncs=0;
+  }
+  if (fDecalfuncs)
+  {
+   delete fDecalfuncs;
+   fDecalfuncs=0;
+  }
   return;
  }
 
@@ -613,7 +654,8 @@ void AliAttrib::DeleteCalibrations(Int_t mode)
    fGains=0;
   }
  }
- else
+
+ if (mode==2)
  {
   ResetOffset(0);
   if (fOffsets)
@@ -622,6 +664,24 @@ void AliAttrib::DeleteCalibrations(Int_t mode)
    fOffsets=0;
   }
  }
+
+ if (mode==4 || mode==6)
+ {
+  if (fCalfuncs)
+  {
+   delete fCalfuncs;
+   fCalfuncs=0;
+  }
+ }
+
+ if (mode==5 || mode==6)
+ {
+  if (fDecalfuncs)
+  {
+   delete fDecalfuncs;
+   fDecalfuncs=0;
+  }
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetDead(Int_t j)
@@ -1076,6 +1136,8 @@ void AliAttrib::List(Int_t j) const
   if (GetOffsetFlag(j)) cout << " offset : " << GetOffset(j);
   if (GetEdgeValue(j)) cout << " edge : " << GetEdgeValue(j);
   if (GetDeadValue(j)) cout << " dead : " << GetDeadValue(j);
+  if (GetCalFunction(j)) cout << " *Fcalib*";
+  if (GetDecalFunction(j)) cout << " *Fdecalib*";
   TString s=GetSlotName(j);
   if (s!="") cout << " name : " << s.Data();
  }
@@ -1095,10 +1157,12 @@ void AliAttrib::List(Int_t j) const
   for (Int_t i=1; i<=n; i++)
   {
    printf=0;
-   if (GetGainFlag(i))   {cout << " gain : " << GetGain(i); printf=1;}
-   if (GetOffsetFlag(i)) {cout << " offset : " << GetOffset(i); printf=1;}
-   if (GetEdgeValue(i))  {cout << " edge : " << GetEdgeValue(i); printf=1;}
-   if (GetDeadValue(i))  {cout << " dead : " << GetDeadValue(i); printf=1;}
+   if (GetGainFlag(i))      {cout << " gain : " << GetGain(i); printf=1;}
+   if (GetOffsetFlag(i))    {cout << " offset : " << GetOffset(i); printf=1;}
+   if (GetEdgeValue(i))     {cout << " edge : " << GetEdgeValue(i); printf=1;}
+   if (GetDeadValue(i))     {cout << " dead : " << GetDeadValue(i); printf=1;}
+   if (GetCalFunction(i))   {cout << " *Fcalib*"; printf=1;}
+   if (GetDecalFunction(i)) {cout << " *Fdecalib*"; printf=1;}
    s=GetSlotName(i);
    if (s!="") {cout << " name : " << s.Data(); printf=1;}
    if (printf) cout << endl;
@@ -1176,13 +1240,23 @@ void AliAttrib::Load(AliAttrib& a,Int_t j)
    }
   }
   n=a.GetNnames();
+  TString s;
+  for (Int_t in=1; in<=n; in++)
   {
-   TString s;
-   for (Int_t in=1; in<=n; in++)
-   {
-    s=a.GetSlotName(in);
-    if (s!="") SetSlotName(s,in);
-   }
+   s=a.GetSlotName(in);
+   SetSlotName(s,in);
+  }
+  n=a.GetNcalfuncs();
+  for (Int_t icalf=1; icalf<=n; icalf++)
+  {
+   TF1* f=a.GetCalFunction(icalf);
+   SetCalFunction(f,icalf);
+  }
+  n=a.GetNdecalfuncs();
+  for (Int_t idecalf=1; idecalf<=n; idecalf++)
+  {
+   TF1* f=a.GetDecalFunction(idecalf);
+   SetDecalFunction(f,idecalf);
   }
  }
  else // load attributes for specified j-th slot only
@@ -1225,13 +1299,23 @@ void AliAttrib::Load(AliAttrib& a,Int_t j)
    }
   }
   n=a.GetNnames();
+  TString s;
+  if (j<=n)
   {
-   TString s;
-   if (j<=n)
-   {
-    s=a.GetSlotName(j);
-    if (s!="") SetSlotName(s,j);
-   }
+   s=a.GetSlotName(j);
+   SetSlotName(s,j);
+  }
+  n=a.GetNcalfuncs();
+  if (j<=n)
+  {
+   TF1* f=a.GetCalFunction(j);
+   SetCalFunction(f,j);
+  }
+  n=a.GetNdecalfuncs();
+  if (j<=n)
+  {
+   TF1* f=a.GetDecalFunction(j);
+   SetDecalFunction(f,j);
   }
  }
 }
@@ -1251,3 +1335,191 @@ void AliAttrib::Load(AliAttrib& a,TString name)
  if (j>0) Load(a,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNcalfuncs() const
+{
+// Provide the number of specified calib. functions for this attribute.
+
+ Int_t n=0;
+ if (fCalfuncs) n=fCalfuncs->GetSize();
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNdecalfuncs() const
+{
+// Provide the number of specified de-calib. functions for this attribute.
+
+ Int_t n=0;
+ if (fDecalfuncs) n=fDecalfuncs->GetSize();
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+TF1* AliAttrib::GetCalFunction(Int_t j) const
+{
+// Provide pointer to the calib. function of the j-th (default j=1) slot.
+// Note : The first attribute slot is at j=1.
+
+ TF1* f=0;
+ if (j>0 && j<=GetNcalfuncs()) f=(TF1*)fCalfuncs->At(j-1);
+ return f;
+}
+///////////////////////////////////////////////////////////////////////////
+TF1* AliAttrib::GetCalFunction(TString name) const
+{
+// Provide pointer to the calib. function of the name-specified slot.
+// In case no match is found, zero is returned.
+
+ TF1* f=0;
+ Int_t j=GetSlotIndex(name);
+ if (j>0) GetCalFunction(j);
+ return f;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetCalFunction(TF1* f,Int_t j)
+{
+// Set the calib. function of the j-th (default j=1) slot.
+// Note : The first attribute slot is at j=1.
+//
+// In case the value of the index j exceeds the maximum number of reserved
+// positions for the functions, the number of reserved positions for the functions
+// is increased automatically.
+//
+// In case the function pointer argument has the same value as the current function
+// pointer value, no action is taken since the user has already modified the actual
+// function.
+//
+// In case the function pointer argument is zero, the current function
+// is deleted and the pointer set to zero.
+//
+// In all other cases the current function is deleted and a new
+// copy of the input function is created which becomes the current function.
+
+ if (j<1) return;
+
+ if (!fCalfuncs)
+ {
+  fCalfuncs=new TObjArray(j);
+  fCalfuncs->SetOwner();
+ }
+
+ if (j > fCalfuncs->GetSize()) fCalfuncs->Expand(j);
+
+ TF1* fcur=(TF1*)fCalfuncs->At(j-1);
+ if (f != fcur)
+ {
+  if (fcur)
+  {
+   fCalfuncs->Remove(fcur);
+   delete fcur;
+   fcur=0;
+  }
+  if (f)
+  {
+   fcur=new TF1(*f);
+   fCalfuncs->AddAt(fcur,j-1);
+  }
+ } 
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetCalFunction(TF1* f,TString name)
+{
+// Set the calib. function of the name-specified slot.
+//
+// In case the function pointer argument has the same value as the current function
+// pointer value, no action is taken since the user has already modified the actual
+// function.
+//
+// In case the function pointer argument is zero, the current function
+// is deleted and the pointer set to zero.
+//
+// In all other cases the current function is deleted and a new
+// copy of the input function is created which becomes the current function.
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) SetCalFunction(f,j);
+}
+///////////////////////////////////////////////////////////////////////////
+TF1* AliAttrib::GetDecalFunction(Int_t j) const
+{
+// Provide pointer to the de-calib. function of the j-th (default j=1) slot.
+// Note : The first attribute slot is at j=1.
+
+ TF1* f=0;
+ if (j>0 && j<=GetNdecalfuncs()) f=(TF1*)fDecalfuncs->At(j-1);
+ return f;
+}
+///////////////////////////////////////////////////////////////////////////
+TF1* AliAttrib::GetDecalFunction(TString name) const
+{
+// Provide pointer to the de-calib. function of the name-specified slot.
+// In case no match is found, zero is returned.
+
+ TF1* f=0;
+ Int_t j=GetSlotIndex(name);
+ if (j>0) GetDecalFunction(j);
+ return f;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetDecalFunction(TF1* f,Int_t j)
+{
+// Set the de-calib. function of the j-th (default j=1) slot.
+// Note : The first attribute slot is at j=1.
+//
+// In case the value of the index j exceeds the maximum number of reserved
+// positions for the functions, the number of reserved positions for the functions
+// is increased automatically.
+//
+// In case the function pointer argument has the same value as the current function
+// pointer value, no action is taken since the user has already modified the actual
+// function.
+//
+// In case the function pointer argument is zero, the current function
+// is deleted and the pointer set to zero.
+//
+// In all other cases the current function is deleted and a new
+// copy of the input function is created which becomes the current function.
+
+ if (j<1) return;
+
+ if (!fDecalfuncs)
+ {
+  fDecalfuncs=new TObjArray(j);
+  fDecalfuncs->SetOwner();
+ }
+
+ if (j > fDecalfuncs->GetSize()) fDecalfuncs->Expand(j);
+
+ TF1* fcur=(TF1*)fDecalfuncs->At(j-1);
+ if (f != fcur)
+ {
+  if (fcur)
+  {
+   fDecalfuncs->Remove(fcur);
+   delete fcur;
+   fcur=0;
+  }
+  if (f)
+  {
+   fcur=new TF1(*f);
+   fDecalfuncs->AddAt(fcur,j-1);
+  }
+ } 
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetDecalFunction(TF1* f,TString name)
+{
+// Set the de-calib. function of the name-specified slot.
+//
+// In case the function pointer argument has the same value as the current function
+// pointer value, no action is taken since the user has already modified the actual
+// function.
+//
+// In case the function pointer argument is zero, the current function
+// is deleted and the pointer set to zero.
+//
+// In all other cases the current function is deleted and a new
+// copy of the input function is created which becomes the current function.
+
+ Int_t j=GetSlotIndex(name);
+ if (j>0) SetDecalFunction(f,j);
+}
+///////////////////////////////////////////////////////////////////////////
index 5eac67e5ac85d53740e55f614a9a2b03d0686246..b18d91206bb9b1c07bbe61324a9e00f5a76a5efe 100644 (file)
@@ -10,6 +10,7 @@
 #include "TObjArray.h"
 #include "TObjString.h"
 #include "TString.h"
+#include "TF1.h"
 
 class AliAttrib
 {
@@ -63,6 +64,16 @@ class AliAttrib
   void SetSlotName(TString s,Int_t j=1);       // Set user defined name for the j-th slot
   TString GetSlotName(Int_t j=1) const;        // Provide user defined name for the j-th slot
   Int_t GetSlotIndex(TString name) const;      // Provide the slot index of the matching name
+  void SetCalFunction(TF1* f,Int_t j=1);       // Set calibration function of the j-th attribute slot
+  void SetCalFunction(TF1* f,TString name);    // Set calibration function of the name-specified attribute slot
+  void SetDecalFunction(TF1* f,Int_t j=1);     // Set de-calibration function of the j-th attribute slot
+  void SetDecalFunction(TF1* f,TString name);  // Set de-calibration function of the name-specified attribute slot
+  TF1* GetCalFunction(Int_t j=1) const;        // Get calibration function of the j-th attribute slot
+  TF1* GetCalFunction(TString name) const;     // Get calibration function of the name-specified attribute slot
+  TF1* GetDecalFunction(Int_t j=1) const;      // Get de-calibration function of the j-th attribute slot
+  TF1* GetDecalFunction(TString name) const;   // Get de-calibration function of the name-specified attribute slot
+  Int_t GetNcalfuncs() const;                  // Provide the number of calibration functions
+  Int_t GetNdecalfuncs() const;                // Provide the number of de-calibration functions
 
  protected:
   void SetCalFlags(Int_t gf,Int_t of,Int_t j); // Set flags for gain and/or offset settings
@@ -70,7 +81,9 @@ class AliAttrib
   TArrayF* fOffsets;                           // Offset values
   TArrayI* fCalflags;                          // Flags to mark dead, edge, and gain/offset calibrated signals
   TObjArray* fNames;                           // User defined names for the various slots
+  TObjArray* fCalfuncs;                        // Explicit signal calibration functions
+  TObjArray* fDecalfuncs;                      // Explicit signal de-calibration functions
 
- ClassDef(AliAttrib,3) // Generic handling of detector signal (calibration) attributes.
+ ClassDef(AliAttrib,4) // Generic handling of detector signal (calibration) attributes.
 };
 #endif
index a53f2d4e584b3e12910366c6386aacda25ab9f78..ef4d7d80b3a34d8f64e3c62ee1043e2321960eda 100644 (file)
 // 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
@@ -398,46 +416,95 @@ Float_t AliSignal::GetSignal(Int_t j,Int_t mode) const
 {
 // 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.
+//            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 is taken from
+//            the AliDevice which owns this AliSignal object.
+//        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.
+//
+//       <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)>6) return 0;
+
  Float_t sig=0;
  Float_t gain=1;
  Float_t offset=0;
+
+ AliSignal* sx=(AliSignal*)this;
+ if (abs(mode)==2 || abs(mode)>=4) sx=(AliSignal*)GetDevice();
+ 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(j)) 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(j)) gain=sx->GetGain(j);
+    if (sx->GetOffsetFlag(j)) offset=sx->GetOffset(j);
+
+    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;
+    TF1* f=sx->GetCalFunction(j);
+    if (mode<0) f=sx->GetDecalFunction(j);
+    if (f) sig=f->Eval(sig);
+    return sig;
    }
   }
   else
@@ -622,10 +689,20 @@ void AliSignal::List(Int_t j) const
  Int_t nerrors=GetNerrors();
  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 (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;
index b2cb1ea476604cd45f6b9f3bcc96c27923cc0ae1..2370a5680e23830bfabee35c9f3d0e52cc15c5f2 100644 (file)
 24-jun-2005 NvE Selection/overruling of specific job folder creation introduced in AliJob::ExecuteJob
                 and the AliJob (derived) instance explicitly removed from the ListOfTasks to prevent
                 ROOT crashing when closing after execution.
+02-aug-2005 NvE Support for explicit (de)calibration functions introduced in AliAttrib.
+03-aug-2005 NvE AliSignal::GetSignal has been extended to support various (de)calibration facilities.
+                Printout is now also provided in AliSignal::List when only calibration data exist
+                for AliDevice (or derived) objects.
                
                 
  
\ No newline at end of file