]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - RALICE/AliAttrib.cxx
Removed classes not included in compilation
[u/mrichter/AliRoot.git] / RALICE / AliAttrib.cxx
index 2226aa340fe942301804eb095582f80e2965d493..1a8f9b082d58c8ed912f0a8fe275105108209c8c 100644 (file)
 // Example :
 // ---------
 // AliAttrib a;
-// a.SetGain(250.7);
 // a.SetSlotName("PMT amplitude in Volt");
-// a.SetGain(1340,3);
+// a.SetGain(250.7);
+// a.SetSlotName("Time of flight in ns",2);
+// a.SetOffset(-22.5,2);
 // a.SetSlotName("PMT amplitude in ADC",3);
+// a.SetGain(1340,3);
+// a.SetSlotName("TDC",4);
+// a.SetOffset(10.75,"TDC");
 // a.SetEdgeOn(3);
-// a.SetOffset(-22.5,2);
-// a.SetSlotName("Time of flight in ns",2);
 // a.SetDead(1);
 // a.List();
 //
@@ -55,6 +57,8 @@ AliAttrib::AliAttrib()
  fOffsets=0;
  fCalflags=0;
  fNames=0;
+ fCalfuncs=0;
+ fDecalfuncs=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliAttrib::~AliAttrib()
@@ -80,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)
@@ -89,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;
@@ -111,6 +127,7 @@ AliAttrib::AliAttrib(const AliAttrib& a)
  for (Int_t ic=1; ic<=n; ic++)
  {
   SetEdgeValue(a.GetEdgeValue(ic),ic);
+  if (a.GetLockValue(ic)) Lock(ic);
   if (a.GetDeadValue(ic)) SetDead(ic);
  }
 
@@ -121,37 +138,79 @@ 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
 {
 // Provide the number of specified gains for this attribute.
+
+ if (!fGains) return 0;
+
  Int_t n=0;
- if (fGains) n=fGains->GetSize();
+ for (Int_t i=1; i<=fGains->GetSize(); i++)
+ {
+  if (GetGainFlag(i)) n=i;
+ }
+
  return n;
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetNoffsets() const
 {
 // Provide the number of specified offsets for this attribute.
+
+ if (!fOffsets) return 0;
+
  Int_t n=0;
- if (fOffsets) n=fOffsets->GetSize();
+ for (Int_t i=1; i<=fOffsets->GetSize(); i++)
+ {
+  if (GetOffsetFlag(i)) n=i;
+ }
+
  return n;
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetNcalflags() const
 {
 // Provide the number of specified calib. flags for this attribute.
+
+ if (!fCalflags) return 0;
+
  Int_t n=0;
- if (fCalflags) n=fCalflags->GetSize();
+ for (Int_t i=1; i<=fCalflags->GetSize(); i++)
+ {
+  if (fCalflags->At(i-1)) n=i;
+ }
+
  return n;
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetNnames() const
 {
 // Provide the maximum number of specified names for this attribute.
+
+ if (!fNames) return 0;
+
  Int_t n=0;
- if (fNames) n=fNames->GetSize();
+ for (Int_t i=1; i<=fNames->GetSize(); i++)
+ {
+  if (fNames->At(i-1)) n=i;
+ }
+
  return n;
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -188,6 +247,20 @@ void AliAttrib::SetGain(Double_t gain,Int_t j)
  SetCalFlags(1,oflag,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetGain(Double_t gain,TString name)
+{
+// Store gain value of the name-specified attribute 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) SetGain(gain,j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetOffset(Double_t off,Int_t j)
 {
 // Store offset value of the j-th (default j=1) attribute slot.
@@ -221,6 +294,20 @@ void AliAttrib::SetOffset(Double_t off,Int_t j)
  SetCalFlags(gflag,1,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetOffset(Double_t off,TString name)
+{
+// Store offset value of the name-specified attribute 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) SetOffset(off,j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
 {
 // Store calibration flags of the j-th (default j=1) attribute slot.
@@ -228,7 +315,7 @@ void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
 // In case the value of the index j exceeds the maximum number of reserved
 // slots for the calib. flags, the number of reserved slots for the calib.
 // flags is increased automatically.
-// The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge +1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -249,9 +336,10 @@ void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
  }
 
  Int_t edge=GetEdgeValue(j);
+ Int_t lock=GetLockValue(j);
  Int_t dead=GetDeadValue(j);
 
- Int_t word=1000*edge+100*dead+10*gainflag+offsetflag;
+ Int_t word=10000*edge+1000*lock+100*dead+10*gainflag+offsetflag;
  
  fCalflags->AddAt(word,j-1);
 }
@@ -284,6 +372,26 @@ Int_t AliAttrib::GetGainFlag(Int_t j) const
  return gflag;
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetGainFlag(TString name) const
+{
+// Provide gain flag of the name-specified attribute slot.
+//
+// flag = 1 : Gain was set
+//        0 : Gain 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=GetGainFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetOffsetFlag(Int_t j) const
 {
 // Provide offset flag of the j-th (default j=1) attribute slot.
@@ -312,6 +420,65 @@ Int_t AliAttrib::GetOffsetFlag(Int_t j) const
  return oflag;
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetOffsetFlag(TString name) const
+{
+// Provide ofset flag of the name-specified attribute slot.
+//
+// flag = 1 : Offset was set
+//        0 : Offset 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=GetOffsetFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetCalWord(Int_t j) const
+{
+// Provide calib. word of the j-th (default j=1) attribute slot.
+// The word value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1) 
+ {
+  cout << " *AliAttrib::GetCalWord* Invalid argument j = " << j << endl;
+  return 0;
+ }
+
+ Int_t word=0;
+ if (fCalflags)
+ {
+  if (j>0 && j<=(fCalflags->GetSize())) word=fCalflags->At(j-1);
+ }
+ return word;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetCalWord(TString name) const
+{
+// Provide calib. word of the name-specified attribute slot.
+// The word value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
+//
+// 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 word=0;
+ if (j>0) word=GetCalWord(j);
+ return word;
+}
+///////////////////////////////////////////////////////////////////////////
 Float_t AliAttrib::GetGain(Int_t j) const
 {
 // Provide gain value of the j-th (default j=1) attribute slot.
@@ -336,6 +503,22 @@ Float_t AliAttrib::GetGain(Int_t j) const
  return gain;
 }
 ///////////////////////////////////////////////////////////////////////////
+Float_t AliAttrib::GetGain(TString name) const
+{
+// Provide gain value of the name-specified attribute 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 gain=0;
+ if (j>0) gain=GetGain(j);
+ return gain;
+}
+///////////////////////////////////////////////////////////////////////////
 Float_t AliAttrib::GetOffset(Int_t j) const
 {
 // Provide offset value of the j-th (default j=1) attribute slot.
@@ -360,6 +543,22 @@ Float_t AliAttrib::GetOffset(Int_t j) const
  return offset;
 }
 ///////////////////////////////////////////////////////////////////////////
+Float_t AliAttrib::GetOffset(TString name) const
+{
+// Provide offset value of the name-specified attribute 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 offset=0;
+ if (j>0) offset=GetOffset(j);
+ return offset;
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::ResetGain(Int_t j)
 {
 // Reset the gain value of the j-th (default j=1) attribute slot.
@@ -395,6 +594,20 @@ void AliAttrib::ResetGain(Int_t j)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::ResetGain(TString name)
+{
+// Reset the gain value of the name-specified attribute 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) ResetGain(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::ResetOffset(Int_t j)
 {
 // Reset the offset value of the j-th (default j=1) attribute slot.
@@ -430,17 +643,34 @@ void AliAttrib::ResetOffset(Int_t j)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::ResetOffset(TString name)
+{
+// Reset the offset value of the name-specified attribute 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) ResetOffset(j);
+}
+///////////////////////////////////////////////////////////////////////////
 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;
@@ -471,6 +701,16 @@ void AliAttrib::DeleteCalibrations(Int_t mode)
    delete fNames;
    fNames=0;
   }
+  if (fCalfuncs)
+  {
+   delete fCalfuncs;
+   fCalfuncs=0;
+  }
+  if (fDecalfuncs)
+  {
+   delete fDecalfuncs;
+   fDecalfuncs=0;
+  }
   return;
  }
 
@@ -483,7 +723,8 @@ void AliAttrib::DeleteCalibrations(Int_t mode)
    fGains=0;
   }
  }
- else
+
+ if (mode==2)
  {
   ResetOffset(0);
   if (fOffsets)
@@ -492,6 +733,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)
@@ -501,7 +760,7 @@ void AliAttrib::SetDead(Int_t j)
 // 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 : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -524,20 +783,35 @@ void AliAttrib::SetDead(Int_t j)
  Int_t dead=1;
  Int_t oflag=GetOffsetFlag(j);
  Int_t gflag=GetGainFlag(j);
+ Int_t lock=GetLockValue(j);
  Int_t edge=GetEdgeValue(j);
 
- Int_t word=1000*edge+100*dead+10*gflag+oflag;
+ Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
  
  fCalflags->AddAt(word,j-1);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetDead(TString name)
+{
+// Set the dead flag to 1 for the name-specified attribute 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) SetDead(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetAlive(Int_t j)
 {
 // Set the dead flag to 0 for the j-th (default j=1) attribute slot.
 // Note : The first attribute slot is at j=1.
 // In case the value of the index j exceeds the maximum number of reserved
 // slots for the flags, no action is taken since by default the dead flag is 0.
-// The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -550,13 +824,121 @@ void AliAttrib::SetAlive(Int_t j)
  Int_t dead=0;
  Int_t oflag=GetOffsetFlag(j);
  Int_t gflag=GetGainFlag(j);
+ Int_t lock=GetLockValue(j);
  Int_t edge=GetEdgeValue(j);
 
- Int_t word=1000*edge+100*dead+10*gflag+oflag;
+ Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
  
  fCalflags->AddAt(word,j-1);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetAlive(TString name)
+{
+// Set the dead flag to 0 for the name-specified attribute 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) SetAlive(j);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::Lock(Int_t j)
+{
+// Set the lock flag to 1 for the j-th (default j=1) attribute slot.
+// Note : The first attribute 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 : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
+
+ if (j<1) 
+ {
+  cout << " *AliAttrib::Lock* Invalid argument j = " << j << endl;
+  return;
+ }
+
+ if (!fCalflags)
+ {
+  fCalflags=new TArrayI(j);
+ }
+
+ Int_t size=fCalflags->GetSize();
+
+ if (j>size)
+ {
+  fCalflags->Set(j);
+ }
+
+ Int_t lock=1;
+ Int_t dead=GetDeadValue(j);
+ Int_t oflag=GetOffsetFlag(j);
+ Int_t gflag=GetGainFlag(j);
+ Int_t edge=GetEdgeValue(j);
+
+ Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
+ fCalflags->AddAt(word,j-1);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::Lock(TString name)
+{
+// Set the lock flag to 1 for the name-specified attribute 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) Lock(j);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::Unlock(Int_t j)
+{
+// Set the lock flag to 0 for the j-th (default j=1) attribute slot.
+// Note : The first attribute slot is at j=1.
+// In case the value of the index j exceeds the maximum number of reserved
+// slots for the flags, no action is taken since by default the dead flag is 0.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
+
+ if (j<1) 
+ {
+  cout << " *AliAttrib::Unlock* Invalid argument j = " << j << endl;
+  return;
+ }
+
+ if (!fCalflags || j>fCalflags->GetSize()) return;
+
+ Int_t lock=0;
+ Int_t dead=GetDeadValue();
+ Int_t oflag=GetOffsetFlag(j);
+ Int_t gflag=GetGainFlag(j);
+ Int_t edge=GetEdgeValue(j);
+
+ Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
+ fCalflags->AddAt(word,j-1);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::Unlock(TString name)
+{
+// Set the lock flag to 0 for the name-specified attribute 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) Unlock(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetEdgeOn(Int_t j)
 {
 // Set the edge value to 1 for the j-th (default j=1) attribute slot.
@@ -564,7 +946,7 @@ void AliAttrib::SetEdgeOn(Int_t j)
 // 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 : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -575,13 +957,27 @@ void AliAttrib::SetEdgeOn(Int_t j)
  SetEdgeValue(1,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetEdgeOn(TString name)
+{
+// Set the edge value to 1 for the name-specified attribute 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) SetEdgeOn(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetEdgeOff(Int_t j)
 {
 // Set the edge value to 0 for the j-th (default j=1) attribute slot.
 // Note : The first attribute slot is at j=1.
 // In case the value of the index j exceeds the maximum number of reserved
 // slots for the flags, no action is taken since by default the edge flag is 0.
-// The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -594,6 +990,20 @@ void AliAttrib::SetEdgeOff(Int_t j)
  SetEdgeValue(0,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetEdgeOff(TString name)
+{
+// Set the edge value to 0 for the name-specified attribute 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) SetEdgeOff(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
 {
 // Set the edge value to "val" for the j-th (default j=1) attribute slot.
@@ -601,7 +1011,7 @@ void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
 // 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 : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -622,15 +1032,30 @@ void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
  }
 
  Int_t edge=val;
+ Int_t lock=GetLockValue(j);
  Int_t dead=GetDeadValue(j);
  Int_t gflag=GetGainFlag(j);
  Int_t oflag=GetOffsetFlag(j);
 
- Int_t word=1000*edge+100*dead+10*gflag+oflag;
+ Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
  
  fCalflags->AddAt(word,j-1);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::SetEdgeValue(Int_t val,TString name)
+{
+// Set the edge value to "val" for the name-specified attribute 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) SetEdgeValue(val,j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::IncreaseEdgeValue(Int_t j)
 {
 // Increase the edge value by 1 for the j-th (default j=1) attribute slot.
@@ -638,7 +1063,7 @@ void AliAttrib::IncreaseEdgeValue(Int_t j)
 // 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 : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -650,6 +1075,20 @@ void AliAttrib::IncreaseEdgeValue(Int_t j)
  SetEdgeValue(edge+1,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::IncreaseEdgeValue(TString name)
+{
+// Increase the edge value by 1 for the name-specified attribute 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) IncreaseEdgeValue(j);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::DecreaseEdgeValue(Int_t j)
 {
 // Decrease the edge value by 1 for the j-th (default j=1) attribute slot.
@@ -657,7 +1096,7 @@ void AliAttrib::DecreaseEdgeValue(Int_t j)
 // 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 : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
 
  if (j<1) 
  {
@@ -669,6 +1108,20 @@ void AliAttrib::DecreaseEdgeValue(Int_t j)
  SetEdgeValue(edge-1,j);
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::DecreaseEdgeValue(TString name)
+{
+// Decrease the edge value by 1 for the name-specified attribute 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) DecreaseEdgeValue(j);
+}
+///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetEdgeValue(Int_t j) const
 {
 // Provide edge value of the j-th (default j=1) attribute slot.
@@ -687,12 +1140,28 @@ Int_t AliAttrib::GetEdgeValue(Int_t j) const
   if (j>0 && j<=(fCalflags->GetSize()))
   {
    Int_t word=fCalflags->At(j-1);
-   edge=word/1000;
+   edge=word/10000;
   }
  }
  return edge;
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetEdgeValue(TString name) const
+{
+// Provide edge value of the name-specified attribute 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);
+ Int_t val=0;
+ if (j>0) val=GetEdgeValue(j);
+ return val;
+}
+///////////////////////////////////////////////////////////////////////////
 Int_t AliAttrib::GetDeadValue(Int_t j) const
 {
 // Provide dead value of the j-th (default j=1) attribute slot.
@@ -718,10 +1187,96 @@ Int_t AliAttrib::GetDeadValue(Int_t j) const
  return dead;
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetDeadValue(TString name) const
+{
+// Provide dead value of the name-specified attribute 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);
+ Int_t val=0;
+ if (j>0) val=GetDeadValue(j);
+ return val;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetLockValue(Int_t j) const
+{
+// Provide lock value of the j-th (default j=1) attribute slot.
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1) 
+ {
+  cout << " *AliAttrib::GetLockValue* Invalid argument j = " << j << endl;
+  return 0;
+ }
+
+ Int_t lock=0;
+ if (fCalflags)
+ {
+  if (j>0 && j<=(fCalflags->GetSize()))
+  {
+   Int_t word=fCalflags->At(j-1);
+   word=word%10000;
+   lock=word/1000;
+  }
+ }
+ return lock;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetLockValue(TString name) const
+{
+// Provide lock value of the name-specified attribute 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);
+ Int_t val=0;
+ if (j>0) val=GetLockValue(j);
+ return val;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNslots() const
+{
+// Provide the number of existing slots.
+
+  Int_t n=GetNcalflags();
+  Int_t nn=GetNnames();
+  Int_t ncalf=GetNcalfuncs();
+  Int_t ndecalf=GetNdecalfuncs();
+  if (n<nn) n=nn;
+  if (n<ncalf) n=ncalf;
+  if (n<ndecalf) n=ndecalf;
+
+  return n;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::AddNamedSlot(TString s)
+{
+// Add a new slot with the specified name.
+// In case a slot with the specified name already exists, no action is taken.
+
+ if (GetSlotIndex(s)) return;
+
+ Int_t n=GetNslots();
+ SetSlotName(s,n+1);
+}
+///////////////////////////////////////////////////////////////////////////
 void AliAttrib::SetSlotName(TString s,Int_t j)
 {
 // Set a user defined name for 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
+// slots for the names, the number of reserved slots for the names
+// is increased automatically to the corresponding value.
 
  if (j<1) 
  {
@@ -788,7 +1343,11 @@ Int_t AliAttrib::GetSlotIndex(TString name) const
   {
    TObjString* so=(TObjString*)fNames->At(i);
    if (so) s=so->GetString();
-   if (s==name) index=i+1;
+   if (s==name)
+   {
+    index=i+1;
+    break;
+   }
   }
  }
  return index;
@@ -812,6 +1371,9 @@ 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 (GetLockValue(j)) cout << " lock : " << GetLockValue(j);
+  if (GetCalFunction(j)) cout << " *Fcalib*";
+  if (GetDecalFunction(j)) cout << " *Fdecalib*";
   TString s=GetSlotName(j);
   if (s!="") cout << " name : " << s.Data();
  }
@@ -831,10 +1393,13 @@ 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 (GetLockValue(i))     {cout << " lock : " << GetLockValue(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;
@@ -842,6 +1407,20 @@ void AliAttrib::List(Int_t j) const
  }
 } 
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::List(TString name) const
+{
+// Provide attribute 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 AliAttrib::Load(AliAttrib& a,Int_t j)
 {
 // Load attributes of the j-th slot of the input AliAttrib into this AliAttrib object.
@@ -888,6 +1467,14 @@ void AliAttrib::Load(AliAttrib& a,Int_t j)
   for (Int_t ic=1; ic<=n; ic++)
   {
    SetEdgeValue(a.GetEdgeValue(ic),ic);
+   if (a.GetLockValue(ic))
+   {
+    Lock(ic);
+   }
+   else
+   {
+    Unlock(ic);
+   }
    if (a.GetDeadValue(ic))
    {
     SetDead(ic);
@@ -898,13 +1485,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
@@ -937,6 +1534,14 @@ void AliAttrib::Load(AliAttrib& a,Int_t j)
   if (j<=n)
   {
    SetEdgeValue(a.GetEdgeValue(j),j);
+   if (a.GetLockValue(j))
+   {
+    Lock(j);
+   }
+   else
+   {
+    Unlock(j);
+   }
    if (a.GetDeadValue(j))
    {
     SetDead(j);
@@ -947,14 +1552,237 @@ 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);
   }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliAttrib::Load(AliAttrib& a,TString name)
+{
+// Load attributes of the name-specified slot of the input AliAttrib into
+// this AliAttrib 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) Load(a,j);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNcalfuncs() const
+{
+// Provide the number of specified calib. functions for this attribute.
+
+ if (!fCalfuncs) return 0;
+
+ Int_t n=0;
+ for (Int_t i=1; i<=fCalfuncs->GetSize(); i++)
+ {
+  if (fCalfuncs->At(i-1)) n=i;
+ }
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNdecalfuncs() const
+{
+// Provide the number of specified de-calib. functions for this attribute.
+
+ if (!fDecalfuncs) return 0;
+
+ Int_t n=0;
+ for (Int_t i=1; i<=fDecalfuncs->GetSize(); i++)
+ {
+  if (fDecalfuncs->At(i-1)) n=i;
+ }
+ 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) f=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) f=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);
+}
+///////////////////////////////////////////////////////////////////////////