NcAttrib.cxx

Go to the documentation of this file.

 
#include "NcAttrib.h"
#include "Riostream.h"
 
ClassImp(NcAttrib); // Class implementation to enable ROOT I/O
 
NcAttrib::NcAttrib()
{
 
 fGains=0;
 fOffsets=0;
 fCalflags=0;
 fNames=0;
 fCalfuncs=0;
 fDecalfuncs=0;
}

NcAttrib::~NcAttrib()
{
 
 if (fGains)
 {
  delete fGains;
  fGains=0;
 }
 if (fOffsets)
 {
  delete fOffsets;
  fOffsets=0;
 }
 if (fCalflags)
 {
  delete fCalflags;
  fCalflags=0;
 }
 if (fNames)
 {
  delete fNames;
  fNames=0;
 }
 if (fCalfuncs)
 {
  delete fCalfuncs;
  fCalfuncs=0;
 }
 if (fDecalfuncs)
 {
  delete fDecalfuncs;
  fDecalfuncs=0;
 }
}

NcAttrib::NcAttrib(const NcAttrib& a)
{
 
 fGains=0;
 fOffsets=0;
 fCalflags=0;
 fNames=0;
 fCalfuncs=0;
 fDecalfuncs=0;
 
 Int_t n=0;
 Double_t val=0;
 
 n=a.GetNgains();
 for (Int_t ig=1; ig<=n; ig++)
 {
  val=a.GetGain(ig);
  if (a.GetGainFlag(ig)) SetGain(val,ig);
 }
 
 n=a.GetNoffsets();
 for (Int_t io=1; io<=n; io++)
 {
  val=a.GetOffset(io);
  if (a.GetOffsetFlag(io)) SetOffset(val,io);
 }
 
 n=a.GetNcalflags();
 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);
 }
 
 n=a.GetNnames();
 TString s;
 for (Int_t in=1; in<=n; in++)
 {
  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 NcAttrib::GetNgains() const
{
 
 if (!fGains) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fGains->GetSize(); i++)
 {
  if (GetGainFlag(i)) n=i;
 }
 
 return n;
}

Int_t NcAttrib::GetNoffsets() const
{
 
 if (!fOffsets) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fOffsets->GetSize(); i++)
 {
  if (GetOffsetFlag(i)) n=i;
 }
 
 return n;
}

Int_t NcAttrib::GetNcalflags() const
{
 
 if (!fCalflags) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fCalflags->GetSize(); i++)
 {
  if (fCalflags->At(i-1)) n=i;
 }
 
 return n;
}

Int_t NcAttrib::GetNnames() const
{
 
 if (!fNames) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fNames->GetSize(); i++)
 {
  if (fNames->At(i-1)) n=i;
 }
 
 return n;
}

void NcAttrib::SetGain(Double_t gain,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetGain* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fGains)
 {
  fGains=new TArrayF(j);
 }
 
 Int_t size=fGains->GetSize();
 
 if (j>size)
 {
  fGains->Set(j);
 }
 
 fGains->AddAt(float(gain),j-1);
 
 Int_t oflag=GetOffsetFlag(j);
 
 SetCalFlags(1,oflag,j);
}

void NcAttrib::SetGain(Double_t gain,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetGain(gain,j);
}

void NcAttrib::SetOffset(Double_t off,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetOffset* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fOffsets)
 {
  fOffsets=new TArrayF(j);
 }
 
 Int_t size=fOffsets->GetSize();
 
 if (j>size)
 {
  fOffsets->Set(j);
 }
 
 fOffsets->AddAt(float(off),j-1);
 
 Int_t gflag=GetGainFlag(j);
 
 SetCalFlags(gflag,1,j);
}

void NcAttrib::SetOffset(Double_t off,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetOffset(off,j);
}

void NcAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetCalFlags* 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 edge=GetEdgeValue(j);
 Int_t lock=GetLockValue(j);
 Int_t dead=GetDeadValue(j);
 
 Int_t word=10000*edge+1000*lock+100*dead+10*gainflag+offsetflag;
 
 fCalflags->AddAt(word,j-1);
}

Int_t NcAttrib::GetGainFlag(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetGainFlag* Invalid argument j = " << j << endl;
  return 0;
 }
 Int_t gflag=0;
 if (fCalflags)
 {
  if (j>0 && j<=(fCalflags->GetSize()))
  {
   Int_t word=fCalflags->At(j-1);
   word=word%100;
   gflag=word/10;
  }
 }
 return gflag;
}

Int_t NcAttrib::GetGainFlag(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t flag=0;
 if (j>0) flag=GetGainFlag(j);
 return flag;
}

Int_t NcAttrib::GetOffsetFlag(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetOffsetFlag* Invalid argument j = " << j << endl;
  return 0;
 }
 
 Int_t oflag=0;
 if (fCalflags)
 {
  if (j>0 && j<=(fCalflags->GetSize()))
  {
   Int_t word=fCalflags->At(j-1);
   oflag=word%10;
  }
 }
 return oflag;
}

Int_t NcAttrib::GetOffsetFlag(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t flag=0;
 if (j>0) flag=GetOffsetFlag(j);
 return flag;
}

Int_t NcAttrib::GetCalWord(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::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 NcAttrib::GetCalWord(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t word=0;
 if (j>0) word=GetCalWord(j);
 return word;
}

Float_t NcAttrib::GetGain(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetGain* Invalid argument j = " << j << endl;
  return 0;
 }
 
 Float_t gain=0;
 if (fGains)
 {
  if (j>0 && j<=(fGains->GetSize()))
  {
   if (GetGainFlag(j)) gain=fGains->At(j-1);
  }
 }
 return gain;
}

Float_t NcAttrib::GetGain(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Float_t gain=0;
 if (j>0) gain=GetGain(j);
 return gain;
}

Float_t NcAttrib::GetOffset(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetOffset* Invalid argument j = " << j << endl;
  return 0;
 }
 
 Float_t offset=0;
 if (fOffsets)
 {
  if (j>0 && j<=(fOffsets->GetSize()))
  {
   if (GetOffsetFlag(j)) offset=fOffsets->At(j-1);
  }
 }
 return offset;
}

Float_t NcAttrib::GetOffset(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Float_t offset=0;
 if (j>0) offset=GetOffset(j);
 return offset;
}

void NcAttrib::ResetGain(Int_t j)
{
 
 if (!fGains) return;
 
 Int_t size=fGains->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   fGains->AddAt(0,j-1);
   Int_t oflag=GetOffsetFlag(j);
   SetCalFlags(0,oflag,j);
  }
  else
  {
   for (Int_t i=0; i<size; i++)
   {
    fGains->AddAt(0,i);
    Int_t oflag=GetOffsetFlag(i);
    SetCalFlags(0,oflag,i);
   }
  }
 }
 else
 {
  cout << " *NcAttrib::ResetGain* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcAttrib::ResetGain(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) ResetGain(j);
}

void NcAttrib::ResetOffset(Int_t j)
{
 
 if (!fOffsets) return;
 
 Int_t size=fOffsets->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   fOffsets->AddAt(0,j-1);
   Int_t gflag=GetGainFlag(j);
   SetCalFlags(gflag,0,j);
  }
  else
  {
   for (Int_t i=0; i<size; i++)
   {
    fOffsets->AddAt(0,i);
    Int_t gflag=GetGainFlag(i);
    SetCalFlags(gflag,0,i);
   }
  }
 }
 else
 {
  cout << " *NcAttrib::ResetOffset* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcAttrib::ResetOffset(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) ResetOffset(j);
}

void NcAttrib::DeleteCalibrations(Int_t mode)
{
 
 if (mode<0 || mode>6)
 {
  cout << " *NcAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
  cout << " Default mode=0 will be used." << endl;
  mode=0;
 }
 
 if (mode==0 || mode==3)
 {
  ResetGain(0);
  if (fGains)
  {
   delete fGains;
   fGains=0;
  }
  ResetOffset(0);
  if (fOffsets)
  {
   delete fOffsets;
   fOffsets=0;
  }
  if (fCalflags && mode==0)
  {
   delete fCalflags;
   fCalflags=0;
  }
  if (fNames && mode==0)
  {
   delete fNames;
   fNames=0;
  }
  if (fCalfuncs)
  {
   delete fCalfuncs;
   fCalfuncs=0;
  }
  if (fDecalfuncs)
  {
   delete fDecalfuncs;
   fDecalfuncs=0;
  }
  return;
 }
 
 if (mode==1)
 {
  ResetGain(0);
  if (fGains)
  {
   delete fGains;
   fGains=0;
  }
 }
 
 if (mode==2)
 {
  ResetOffset(0);
  if (fOffsets)
  {
   delete fOffsets;
   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 NcAttrib::SetDead(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetDead* 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 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=10000*edge+1000*lock+100*dead+10*gflag+oflag;
 
 fCalflags->AddAt(word,j-1);
}

void NcAttrib::SetDead(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetDead(j);
}

void NcAttrib::SetAlive(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetAlive* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fCalflags || j>fCalflags->GetSize()) return;
 
 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=10000*edge+1000*lock+100*dead+10*gflag+oflag;
 
 fCalflags->AddAt(word,j-1);
}

void NcAttrib::SetAlive(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetAlive(j);
}

void NcAttrib::Lock(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::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 NcAttrib::Lock(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) Lock(j);
}

void NcAttrib::Unlock(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::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 NcAttrib::Unlock(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) Unlock(j);
}

void NcAttrib::SetEdgeOn(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetEdgeOn* Invalid argument j = " << j << endl;
  return;
 }
 
 SetEdgeValue(1,j);
}

void NcAttrib::SetEdgeOn(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetEdgeOn(j);
}

void NcAttrib::SetEdgeOff(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetEdgeOff* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fCalflags || j>fCalflags->GetSize()) return;
 
 SetEdgeValue(0,j);
}

void NcAttrib::SetEdgeOff(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetEdgeOff(j);
}

void NcAttrib::SetEdgeValue(Int_t val,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetEdgeValue* 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 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=10000*edge+1000*lock+100*dead+10*gflag+oflag;
 
 fCalflags->AddAt(word,j-1);
}

void NcAttrib::SetEdgeValue(Int_t val,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetEdgeValue(val,j);
}

void NcAttrib::IncreaseEdgeValue(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::IncreaseEdgeValue* Invalid argument j = " << j << endl;
  return;
 }
 
 Int_t edge=GetEdgeValue();
 SetEdgeValue(edge+1,j);
}

void NcAttrib::IncreaseEdgeValue(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) IncreaseEdgeValue(j);
}

void NcAttrib::DecreaseEdgeValue(Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::DecreaseEdgeValue* Invalid argument j = " << j << endl;
  return;
 }
 
 Int_t edge=GetEdgeValue();
 SetEdgeValue(edge-1,j);
}

void NcAttrib::DecreaseEdgeValue(TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) DecreaseEdgeValue(j);
}

Int_t NcAttrib::GetEdgeValue(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetEdgeValue* Invalid argument j = " << j << endl;
  return 0;
 }
 
 Int_t edge=0;
 if (fCalflags)
 {
  if (j>0 && j<=(fCalflags->GetSize()))
  {
   Int_t word=fCalflags->At(j-1);
   edge=word/10000;
  }
 }
 return edge;
}

Int_t NcAttrib::GetEdgeValue(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t val=0;
 if (j>0) val=GetEdgeValue(j);
 return val;
}

Int_t NcAttrib::GetDeadValue(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::GetDeadValue* Invalid argument j = " << j << endl;
  return 0;
 }
 
 Int_t dead=0;
 if (fCalflags)
 {
  if (j>0 && j<=(fCalflags->GetSize()))
  {
   Int_t word=fCalflags->At(j-1);
   word=word%1000;
   dead=word/100;
  }
 }
 return dead;
}

Int_t NcAttrib::GetDeadValue(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t val=0;
 if (j>0) val=GetDeadValue(j);
 return val;
}

Int_t NcAttrib::GetLockValue(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::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 NcAttrib::GetLockValue(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t val=0;
 if (j>0) val=GetLockValue(j);
 return val;
}

Int_t NcAttrib::GetNslots() const
{
 
  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 NcAttrib::AddNamedSlot(TString s)
{
 
 if (GetSlotIndex(s)) return;
 
 Int_t n=GetNslots();
 SetSlotName(s,n+1);
}

void NcAttrib::SetSlotName(TString s,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcAttrib::SetSlotName* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fNames)
 {
  fNames=new TObjArray(j);
  fNames->SetOwner();
 }
 
 if (j>fNames->GetSize()) fNames->Expand(j);
 
 TObjString* so=(TObjString*)fNames->At(j-1);
 if (!so)
 {
  so=new TObjString(s.Data());
  fNames->AddAt(so,j-1);
 }
 else
 {
  so->SetString(s);
 }
}

TString NcAttrib::GetSlotName(Int_t j) const
{
 
 TString s="";
 if (j<1) 
 {
  cout << " *NcAttrib::GetSlotName* Invalid argument j = " << j << endl;
  return s;
 }
 
 if (fNames)
 {
  if (j<=fNames->GetSize())
  {
   TObjString* so=(TObjString*)fNames->At(j-1);
   if (so) s=so->GetString();
  }
 }
 return s;
}

Int_t NcAttrib::GetSlotIndex(TString name,Int_t opt) const
{
 
 Int_t index=0;
 
 if (fNames)
 {
  TString s;
  Int_t size=fNames->GetSize();
  for (Int_t i=0; i<size; i++)
  {
   TObjString* so=(TObjString*)fNames->At(i);
   if (so) s=so->GetString();
   if ((!opt && s==name) || (opt && s.Contains(name.Data())))
   {
    index=i+1;
    break;
   }
  }
 }
 return index;
}

void NcAttrib::List(Int_t j) const
{
 
 if (j<0) 
 {
  cout << " *NcAttrib::Data* Invalid argument j = " << j << endl;
  return;
 }
 
 if (j>0)
 {
  if (GetGainFlag(j)) cout << " gain : " << GetGain(j);
  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();
 }
 else
 {
  Int_t ng=GetNgains();
  Int_t no=GetNoffsets();
  Int_t nf=0;
  if (fCalflags) nf=fCalflags->GetSize();
  Int_t nn=GetNnames();
  Int_t n=ng;
  if (n<no) n=no;
  if (n<nn) n=nn;
  if (n<nf) n=nf;
  Int_t printf=0;
  TString s;
  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 (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;
  }
 }
} 

void NcAttrib::List(TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) List(j);
}

void NcAttrib::Load(NcAttrib& a,Int_t j)
{
 
 if (j<0) 
 {
  cout << " *NcAttrib::Load* Invalid argument j = " << j << endl;
  return;
 }
 
 Int_t n=0;
 
 if (j==0) // load attributes for all slots
 {
  n=a.GetNgains();
  for (Int_t ig=1; ig<=n; ig++)
  {
   if (a.GetGainFlag(ig))
   {
    SetGain(a.GetGain(ig),ig);
   }
   else
   {
    ResetGain(ig);
   }
  }
  n=a.GetNoffsets();
  for (Int_t io=1; io<=n; io++)
  {
   if (a.GetOffsetFlag(io))
   {
    SetOffset(a.GetOffset(io),io);
   }
   else
   {
    ResetOffset(io);
   }
  }
  n=a.GetNcalflags();
  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);
   }
   else
   {
    SetAlive(ic);
   }
  }
  n=a.GetNnames();
  TString s;
  for (Int_t in=1; in<=n; 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
 {
  n=a.GetNgains();
  if (j<=n)
  {
   if (a.GetGainFlag(j))
   {
    SetGain(a.GetGain(j),j);
   }
   else
   {
    ResetGain(j);
   }
  }
  n=a.GetNoffsets();
  if (j<=n)
  {
   if (a.GetOffsetFlag(j))
   {
    SetOffset(a.GetOffset(j),j);
   }
   else
   {
    ResetOffset(j);
   } 
  }
  n=a.GetNcalflags();
  if (j<=n)
  {
   SetEdgeValue(a.GetEdgeValue(j),j);
   if (a.GetLockValue(j))
   {
    Lock(j);
   }
   else
   {
    Unlock(j);
   }
   if (a.GetDeadValue(j))
   {
    SetDead(j);
   }
   else
   {
    SetAlive(j);
   }
  }
  n=a.GetNnames();
  TString s;
  if (j<=n)
  {
   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 NcAttrib::Load(NcAttrib& a,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) Load(a,j);
}

Int_t NcAttrib::GetNcalfuncs() const
{
 
 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 NcAttrib::GetNdecalfuncs() const
{
 
 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* NcAttrib::GetCalFunction(Int_t j) const
{
 
 TF1* f=0;
 if (j>0 && j<=GetNcalfuncs()) f=(TF1*)fCalfuncs->At(j-1);
 return f;
}

TF1* NcAttrib::GetCalFunction(TString name) const
{
 
 TF1* f=0;
 Int_t j=GetSlotIndex(name);
 if (j>0) f=GetCalFunction(j);
 return f;
}

void NcAttrib::SetCalFunction(TF1* f,Int_t j)
{
 
 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 NcAttrib::SetCalFunction(TF1* f,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetCalFunction(f,j);
}

TF1* NcAttrib::GetDecalFunction(Int_t j) const
{
 
 TF1* f=0;
 if (j>0 && j<=GetNdecalfuncs()) f=(TF1*)fDecalfuncs->At(j-1);
 return f;
}

TF1* NcAttrib::GetDecalFunction(TString name) const
{
 
 TF1* f=0;
 Int_t j=GetSlotIndex(name);
 if (j>0) f=GetDecalFunction(j);
 return f;
}

void NcAttrib::SetDecalFunction(TF1* f,Int_t j)
{
 
 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 NcAttrib::SetDecalFunction(TF1* f,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetDecalFunction(f,j);
}