NcSignal.cxx

Go to the documentation of this file.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

///////////////////////////////////////////////////////////////////////////

 
#include "NcSignal.h"
#include "NcTrack.h"
#include "Riostream.h"
 
ClassImp(NcSignal); // Class implementation to enable ROOT I/O
 
NcSignal::NcSignal(const char* name,const char* title) : TNamed(name,title),NcPosition(),NcAttrib()
{
 
 fSignals=0;
 fDsignals=0;
 fSigflags=0;
 fWaveforms=0;
 fSamples=0;
 fLinks=0;
 fDevice=0;
 fTracks=0;
 fDevset=kFALSE;
}

NcSignal::~NcSignal()
{
 
 if (fLinks)
 {
  // Remove this signal from all related devices
  TArrayI js;
  TArrayI ks;
  Int_t nlinks=GetIndices(0,js,ks);
  Int_t j=0;
  Int_t k=0;
  for (Int_t il=0; il<nlinks; il++)
  {
   j=js.At(il);
   k=ks.At(il);
   TObject* obj=GetLink(j,k);
   if (!obj) continue;
   if (obj->InheritsFrom("NcDevice"))
   {
    NcDevice* dx=(NcDevice*)obj;
    dx->RemoveHit(this);
   }
  }
  delete fLinks;
  fLinks=0;
 }
 if (fSignals)
 {
  delete fSignals;
  fSignals=0;
 }
 if (fDsignals)
 {
  delete fDsignals;
  fDsignals=0;
 }
 if (fSigflags)
 {
  delete fSigflags;
  fSigflags=0;
 }
 if (fWaveforms)
 {
  delete fWaveforms;
  fWaveforms=0;
 }
 if (fSamples)
 {
  delete fSamples;
  fSamples=0;
 }
 if (fTracks)
 {
  // Remove this signal from all related tracks
  for (Int_t i=1; i<=GetNtracks(); i++)
  {
   NcTrack* tx=GetTrack(i);
   if (tx) tx->RemoveSignal(*this,0);
  }
  delete fTracks;
  fTracks=0;
 }
}

NcSignal::NcSignal(const NcSignal& s) : TNamed(s),NcPosition(s),NcAttrib(s)
{
 
 fSignals=0;
 fDsignals=0;
 fSigflags=0;
 fWaveforms=0;
 fSamples=0;
 fLinks=0;
 fTracks=0;
 
 fDevset=kFALSE;
 
 // Don't copy the owning device pointer for the copy
 fDevice=0;
 
 Int_t n=s.GetNvalues();
 Double_t val;
 Int_t lock;
 for (Int_t i=1; i<=n; i++)
 {
  if (s.GetSignalFlag(i))
  {
   val=s.GetSignal(i);
   lock=s.GetLockValue();
   if (lock) Unlock();
   SetSignal(val,i);
   if (lock) Lock();
  }
 } 
 
 n=s.GetNerrors();
 for (Int_t j=1; j<=n; j++)
 {
  if (s.GetErrorFlag(j))
  {
   val=s.GetSignalError(j);
   lock=s.GetLockValue();
   if (lock) Unlock();
   SetSignalError(val,j);
   if (lock) Lock();
  }
 }
 
 n=s.GetNwaveforms();
 for (Int_t k=1; k<=n; k++)
 {
  TH1F* hist=s.GetWaveform(k);
  if (hist) SetWaveform(hist,k); 
 }
 
 n=s.GetNsamples();
 for (Int_t m=1; m<=n; m++)
 {
  NcSample* sample=s.GetSample(m);
  if (sample) SetSample(sample,m); 
 }
 
 TArrayI slotarr;
 TArrayI posarr;
 TObject* dum=0;
 n=s.GetIndices(dum,slotarr,posarr);
 Int_t slot,pos;
 for (Int_t idx=0; idx<n; idx++)
 {
  slot=slotarr.At(idx);
  pos=posarr.At(idx);
  TObject* obj=s.GetLink(slot,pos);
  if (obj) SetLink(obj,slot,pos); 
 }
 
 Int_t ntk=s.GetNtracks();
 if (ntk)
 {
  fTracks=new TObjArray(ntk);
  for (Int_t it=1; it<=ntk; it++)
  {
   NcTrack* tx=s.GetTrack(it);
   fTracks->Add(tx);
  }
 }
}

void NcSignal::Reset(Int_t mode)
{
 
 if (mode<0 || mode>1)
 {
  cout << " *NcSignal::Reset* Invalid argument mode = " << mode << endl;
  cout << " Default mode=0 will be used." << endl;
  mode=0;
 }
 
 ResetPosition();
 if (!mode)
 {
  ResetSignals();
 }
 else
 {
  DeleteSignals();
  DeleteCalibrations();
 }
 
 if (fLinks) fLinks->Reset();
 
 if (fTracks)
 {
  delete fTracks;
  fTracks=0;
 }
}

void NcSignal::ResetSignals(Int_t mode)
{
 
 if (abs(mode)>2)
 {
  cout << " *NcSignal::ResetSignals* Invalid argument mode = " << mode << endl;
  cout << " Default mode=0 will be used." << endl;
  mode=0;
 }
 
 Int_t sflag=0;
 Int_t eflag=0;
 
 if (fSignals && (abs(mode)==0 || abs(mode)==1))
 {
  for (Int_t i=1; i<=fSignals->GetSize(); i++)
  {
   fSignals->AddAt(0,i-1);
   eflag=GetErrorFlag(i);
   SetSigFlags(0,eflag,i);
  }
 }
 
 if (fDsignals && (abs(mode)==0 || abs(mode)==2))
 {
  for (Int_t j=1; j<=fDsignals->GetSize(); j++)
  {
   fDsignals->AddAt(0,j-1);
   sflag=GetSignalFlag(j);
   SetSigFlags(sflag,0,j);
  }
 }
 
 if (mode>=0)
 {
  ResetWaveform(0);
  ResetSample(0);
 }
}

void NcSignal::DeleteSignals(Int_t mode)
{
 
 if (abs(mode)>2)
 {
  cout << " *NcSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
  cout << " Default mode=0 will be used." << endl;
  mode=0;
 }
 
 if (fSignals && (abs(mode)==0 || abs(mode)==1))
 {
  delete fSignals;
  fSignals=0;
 }
 
 if (fDsignals && (abs(mode)==0 || abs(mode)==2))
 {
  delete fDsignals;
  fDsignals=0;
 }
 
 Int_t sflag=0;
 Int_t eflag=0;
 
 if (mode==0)
 {
  delete fSigflags;
  fSigflags=0;
 }
 else if (abs(mode)==1)
 {
  for (Int_t i=1; i<=fSigflags->GetSize(); i++)
  {
   eflag=GetErrorFlag(i);
   SetSigFlags(0,eflag,i);
  }
 }
 else if (abs(mode)==2)
 {
  for (Int_t j=1; j<=fSigflags->GetSize(); j++)
  {
   sflag=GetSignalFlag(j);
   SetSigFlags(sflag,0,j);
  }
 }
 
 if (mode>=0)
 {
  DeleteWaveform(0);
  DeleteSample(0);
 }
}

void NcSignal::SetSignal(Double_t sig,Int_t j)
{
 
 if (GetLockValue(j)) return;
 
 if (!fSignals)
 {
  fSignals=new TArrayF(j);
  ResetSignals(-1);
 }
 
 Int_t size=fSignals->GetSize();
 
 if (j>size)
 {
  fSignals->Set(j);
 }
 
 fSignals->AddAt(float(sig),j-1);
 
 Int_t eflag=GetErrorFlag(j);
 SetSigFlags(1,eflag,j);
}

void NcSignal::SetSignal(Double_t sig,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0)
 {
  if (!GetLockValue(j)) SetSignal(sig,j);
 }
}

void NcSignal::AddSignal(Double_t sig,Int_t j)
{
 
 if (GetLockValue(j)) return;
 
 if (!fSignals)
 {
  fSignals=new TArrayF(j);
  ResetSignals(1);
 }
 
 Int_t size=fSignals->GetSize();
 
 if (j>size)
 {
  fSignals->Set(j);
 }
 
 Float_t sum=(fSignals->At(j-1))+sig;
 fSignals->AddAt(sum,j-1);
 
 Int_t eflag=GetErrorFlag(j);
 SetSigFlags(1,eflag,j);
}

void NcSignal::AddSignal(Double_t sig,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0)
 {
  if (!GetLockValue(j)) AddSignal(sig,j);
 }
}


Float_t NcSignal::GetSignal(Int_t j,Int_t mode) const
{
 
 if (abs(mode)>8) return 0;
 
 Int_t jcal=j;
 Float_t sig=0;
 Float_t gain=1;
 Float_t offset=0;
 
 // Get the corresponding slot index (and dead flag) of the parent device
 Int_t pj=0;
 Int_t pdead=0;
 NcSignal* parent=(NcSignal*)GetDevice();
 if ((abs(mode)==2 || abs(mode)>=4) && parent)
 {
   TString name=GetSlotName(j);
   if (strlen(name.Data())) pj=parent->GetSlotIndex(name);
   if (abs(mode)==8 && pj) pdead=parent->GetDeadValue(pj);
 }
 if (mode==8) mode=7;
 if (mode==-8) mode=-7;
 
 NcSignal* sx=(NcSignal*)this;
 
 TF1* f=0;
 if (mode==7)
 {
  f=sx->GetCalFunction(jcal);
  if (f)
  {
   mode=3;
  }
  else
  {
   mode=4;
  } 
 }
 if (mode==-7)
 {
  f=sx->GetDecalFunction(jcal);
  if (f)
  {
   mode=-3;
  }
  else
  {
   mode=-4;
  } 
 }
 
 if (abs(mode)==2 || abs(mode)>=4)
 {
  sx=(NcSignal*)GetDevice();
  if (pj) jcal=pj;
 }
 if (!sx && abs(mode)>=5) sx=(NcSignal*)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 || !sx) return sig;
 
   // Check for the dead flag setting
   if (sx->GetDeadValue(jcal) || pdead) return 0;
 
   // (De)correct the signal for the gain and offset
   if (abs(mode)==1 || abs(mode)==2)
   {
    if (sx->GetGainFlag(jcal)) gain=sx->GetGain(jcal);
    if (sx->GetOffsetFlag(jcal)) offset=sx->GetOffset(jcal);
 
    if (fabs(gain)>0.)
    {
     if (mode>0) sig=(sig/gain)-offset; // Gain and offset correction
     if (mode<0) sig=(sig+offset)*gain; // Gain and offset de-correction
    }
    else
    {
     sig=0;
    }
    return sig;
   }
 
   // (De)calibrate the signal with the corresponding (de)calibration function
   if (abs(mode)==3 || abs(mode)==4)
   {
    f=sx->GetCalFunction(jcal);
    if (mode<0) f=sx->GetDecalFunction(jcal);
    if (f) sig=f->Eval(sig);
    return sig;
   }
  }
  else
  {
   cout << " *NcSignal::GetSignal* Index j = " << j << " invalid." << endl;
  } 
 }
 return sig;
}

Float_t NcSignal::GetSignal(TString name,Int_t mode) const
{
 
 if (!fSignals) return 0;
 
 Int_t j=GetSlotIndex(name);
 Float_t val=0;
 if (j>0 && j<=(fSignals->GetSize())) val=GetSignal(j,mode);
 return val;
}

void NcSignal::SetSignalError(Double_t dsig,Int_t j)
{
 
 if (GetLockValue(j)) return;
 
 if (!fDsignals)
 {
  fDsignals=new TArrayF(j);
  ResetSignals(-2);
 }
 
 Int_t size=fDsignals->GetSize();
 
 if (j>size)
 {
  fDsignals->Set(j);
 }
 
 fDsignals->AddAt(float(dsig),j-1);
 
 Int_t sflag=GetSignalFlag(j);
 SetSigFlags(sflag,1,j);
}

void NcSignal::SetSignalError(Double_t dsig,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0)
 {
  if (!GetLockValue(j)) SetSignalError(dsig,j);
 }
}

Float_t NcSignal::GetSignalError(Int_t j) const
{
 
 Float_t err=0;
 if (fDsignals)
 {
  if (j>0 && j<=(fDsignals->GetSize()))
  {
   err=fDsignals->At(j-1);
  }
  else
  {
   cout << " *NcSignal::GetSignalError* Index j = " << j << " invalid." << endl;
  } 
 }
 return err;
}

Float_t NcSignal::GetSignalError(TString name) const
{
 
 if (!fDsignals) return 0;
 
 Int_t j=GetSlotIndex(name);
 Float_t val=0;
 if (j>0 && j<=(fDsignals->GetSize())) val=GetSignalError(j);
 return val;
}

void NcSignal::Data(TString f,TString u) const
{
 
 const char* name=GetName();
 const char* title=GetTitle();
 
 cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
 if (strlen(name))  cout << " Name : " << name;
 if (strlen(title)) cout << " Title : " << title;
 cout << endl;
 if (fNv)
 {
  cout << "   Position";
  NcPosition::Data(f,u);
 }
 if (fDevice)
 {
  const char* devname=fDevice->GetName();
  const char* devtitle=fDevice->GetTitle();
  cout << "   Owned by device : " << fDevice->ClassName() << " Id : " << fDevice->GetUniqueID();
  if (strlen(devname))  cout << " Name : " << devname;
  if (strlen(devtitle)) cout << " Title : " << devtitle;
  cout << endl;
 }
 
 // Provide an overview of the stored waveforms
 ListWaveform(-1);
 
 // Provide an overview of the stored samples
 ListSample(-1);
 
 // Provide an overview of the associated tracks
 ListTrack(-1);
 
 // Provide an overview of all the data and attribute slots
 List(-1);
} 

void NcSignal::List(Int_t j) const
{
 
 if (j<-1) 
 {
  cout << " *NcSignal::List* Invalid argument j = " << j << endl;
  return;
 }
 
 if (j != -1)
 {
  const char* name=GetName();
  const char* title=GetTitle();
 
  cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
  if (strlen(name))  cout << " Name : " << name;
  if (strlen(title)) cout << " Title : " << title;
  cout << endl;
  if (fDevice)
  {
   const char* devname=fDevice->GetName();
   const char* devtitle=fDevice->GetTitle();
   cout << "   Owned by device : " << fDevice->ClassName();
   if (strlen(devname))  cout << " Name : " << devname;
   if (strlen(devtitle)) cout << " Title : " << devtitle;
   cout << endl;
  }
 }
 
 Int_t n=GetNslots();
 Int_t nlinkslots=0;
 if (GetNlinks()) nlinkslots=fLinks->GetMaxColumn();
 if (nlinkslots>n) n=nlinkslots;
 
 TObject* obj=0;
 Int_t nrefs=0;
 TArrayI posarr;
 Int_t pos;
 
 if (j<=0)
 {
  for (Int_t i=1; i<=n; i++)
  {
   obj=0;
   nrefs=GetIndices(obj,i,posarr);
 
   if (GetSignalFlag(i) || GetErrorFlag(i) || GetCalFunction(i) || GetDecalFunction(i) || GetCalWord(i) || nrefs)
   {
    cout << "   Slot : " << i;
    if (GetSignalFlag(i)) cout << " Signal value : " << GetSignal(i);
    if (GetErrorFlag(i))  cout << " error : " << GetSignalError(i);
    NcAttrib::List(i);
    cout << endl;
 
    for (Int_t k=0; k<nrefs; k++)
    {
     pos=posarr.At(k);
     obj=GetLink(i,pos);
     if (obj)
     {
      cout << "    Link at position " << pos << " to : " << obj->ClassName();
      if (obj->InheritsFrom("TNamed"))
      {
       const char* lname=obj->GetName();
       const char* ltitle=obj->GetTitle();
       if (strlen(lname))  cout << " Name : " << lname;
       if (strlen(ltitle)) cout << " Title : " << ltitle;
      }
      cout << endl;
     }
    }
   }
  }
 }
 else
 {
  if (j<=n)
  {
   obj=0;
   nrefs=GetIndices(obj,j,posarr);
 
   if (GetSignalFlag(j) || GetErrorFlag(j) || GetCalFunction(j) || GetDecalFunction(j) || GetCalWord(j) || nrefs)
   {
    cout << "   Slot : " << j;
    if (GetSignalFlag(j)) cout << " Signal value : " << GetSignal(j);
    if (GetErrorFlag(j))  cout << " error : " << GetSignalError(j);
    NcAttrib::List(j);
    cout << endl;
 
    for (Int_t kj=0; kj<nrefs; kj++)
    {
     pos=posarr.At(kj);
     obj=GetLink(j,pos);
     if (obj)
     {
      cout << "    Link at position " << pos << " to : " << obj->ClassName();
      if (obj->InheritsFrom("TNamed"))
      {
       const char* lnamej=obj->GetName();
       const char* ltitlej=obj->GetTitle();
       if (strlen(lnamej))  cout << " Name : " << lnamej;
       if (strlen(ltitlej)) cout << " Title : " << ltitlej;
      }
      cout << endl;
     }
    }
   }
  }
 }
} 

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

void NcSignal::ListWaveform(Int_t j) const
{
 
 if (j<-1) 
 {
  cout << " *NcSignal::ListWaveform* Invalid argument j = " << j << endl;
  return;
 }
 
 if (j != -1)
 {
  const char* name=GetName();
  const char* title=GetTitle();
 
  cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
  if (strlen(name))  cout << " Name : " << name;
  if (strlen(title)) cout << " Title : " << title;
  cout << endl;
  if (fDevice)
  {
   const char* devname=fDevice->GetName();
   const char* devtitle=fDevice->GetTitle();
   cout << "   Owned by device : " << fDevice->ClassName();
   if (strlen(devname))  cout << " Name : " << devname;
   if (strlen(devtitle)) cout << " Title : " << devtitle;
   cout << endl;
  }
 }
 
 Int_t n=GetNwaveforms();
 TObject* obj=0;
 
 if (j<=0)
 {
  for (Int_t i=1; i<=n; i++)
  {
   obj=GetWaveform(i);
   if (obj)
   {
    const char* wfname=obj->GetName();
    const char* wftitle=obj->GetTitle();
    cout << "    Waveform " << i << " : " << obj->ClassName();
    if (strlen(wfname))  cout << " Name : " << wfname;
    if (strlen(wftitle)) cout << " Title : " << wftitle;
    cout << endl;
   }
  }
 }
 else
 {
  if (j<=n)
  {
   obj=GetWaveform(j);
   if (obj)
   {
    const char* wfnamej=obj->GetName();
    const char* wftitlej=obj->GetTitle();
    cout << "    Waveform " << j << " : " << obj->ClassName();
    if (strlen(wfnamej))  cout << " Name : " << wfnamej;
    if (strlen(wftitlej)) cout << " Title : " << wftitlej;
    cout << endl;
   }
  }
 }
}

void NcSignal::ListSample(Int_t j) const
{
 
 if (j<-1) 
 {
  cout << " *NcSignal::ListSample* Invalid argument j = " << j << endl;
  return;
 }
 
 if (j != -1)
 {
  const char* name=GetName();
  const char* title=GetTitle();
 
  cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
  if (strlen(name))  cout << " Name : " << name;
  if (strlen(title)) cout << " Title : " << title;
  cout << endl;
  if (fDevice)
  {
   const char* devname=fDevice->GetName();
   const char* devtitle=fDevice->GetTitle();
   cout << "   Owned by device : " << fDevice->ClassName();
   if (strlen(devname))  cout << " Name : " << devname;
   if (strlen(devtitle)) cout << " Title : " << devtitle;
   cout << endl;
  }
 }
 
 Int_t n=GetNsamples();
 TObject* obj=0;
 
 if (j<=0)
 {
  for (Int_t i=1; i<=n; i++)
  {
   obj=GetSample(i);
   if (obj)
   {
    const char* sname=obj->GetName();
    const char* stitle=obj->GetTitle();
    cout << "    Sample " << i << " : " << obj->ClassName();
    if (strlen(sname))  cout << " Name : " << sname;
    if (strlen(stitle)) cout << " Title : " << stitle;
    cout << endl;
   }
  }
 }
 else
 {
  if (j<=n)
  {
   obj=GetSample(j);
   if (obj)
   {
    const char* snamej=obj->GetName();
    const char* stitlej=obj->GetTitle();
    cout << "    Sample " << j << " : " << obj->ClassName();
    if (strlen(snamej))  cout << " Name : " << snamej;
    if (strlen(stitlej)) cout << " Title : " << stitlej;
    cout << endl;
   }
  }
 }
}

void NcSignal::ListTrack(Int_t j) const
{
 
 if (j<-1) 
 {
  cout << " *NcSignal::ListTrack* Invalid argument j = " << j << endl;
  return;
 }
 
 if (j != -1)
 {
  const char* name=GetName();
  const char* title=GetTitle();
 
  cout << " *" << ClassName() << "::Data* Id :" << GetUniqueID();
  if (strlen(name))  cout << " Name : " << name;
  if (strlen(title)) cout << " Title : " << title;
  cout << endl;
  if (fDevice)
  {
   const char* devname=fDevice->GetName();
   const char* devtitle=fDevice->GetTitle();
   cout << "   Owned by device : " << fDevice->ClassName();
   if (strlen(devname))  cout << " Name : " << devname;
   if (strlen(devtitle)) cout << " Title : " << devtitle;
   cout << endl;
  }
 }
 
 Int_t n=GetNtracks();
 NcTrack* tx=0;
 
 if (j<=0)
 {
  for (Int_t i=1; i<=n; i++)
  {
   tx=GetTrack(i);
   if (tx)
   {
    const char* txname=tx->GetName();
    const char* txtitle=tx->GetTitle();
    cout << "    Track " << i << " : " << tx->ClassName() << " Id : " << tx->GetId();
    if (strlen(txname))  cout << " Name : " << txname;
    if (strlen(txtitle)) cout << " Title : " << txtitle;
    cout << endl;
   }
  }
 }
 else
 {
  if (j<=n)
  {
   tx=GetTrack(j);
   if (tx)
   {
    const char* txnamej=tx->GetName();
    const char* txtitlej=tx->GetTitle();
    cout << "    Track " << j << " : " << tx->ClassName() << " Id : " << tx->GetId();
    if (strlen(txnamej))  cout << " Name : " << txnamej;
    if (strlen(txtitlej)) cout << " Title : " << txtitlej;
    cout << endl;
   }
  }
 }
}

Int_t NcSignal::GetNvalues() const
{
 
 if (!fSignals) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fSigflags->GetSize(); i++)
 {
  if (GetSignalFlag(i)) n=i;
 }
 
 return n;
}

Int_t NcSignal::GetNerrors() const
{
 
 if (!fDsignals) return 0;
 
 Int_t n=0;
 for (Int_t i=1; i<=fSigflags->GetSize(); i++)
 {
  if (GetErrorFlag(i)) n=i;
 }
 
 return n;
}

void NcSignal::SetSigFlags(Int_t is,Int_t ie,Int_t j)
{
 
 if (j<1) 
 {
  cout << " *NcSignal::SetSigFlags* Invalid argument j = " << j << endl;
  return;
 }
 
 if (!fSigflags)
 {
  fSigflags=new TArrayI(j);
 }
 
 Int_t size=fSigflags->GetSize();
 
 if (j>size)
 {
  fSigflags->Set(j);
 }
 
 Int_t word=10*is+ie;
 
 fSigflags->AddAt(word,j-1);
}

Int_t NcSignal::GetSignalFlag(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcSignal::GetSignalFlag* Invalid argument j = " << j << endl;
  return 0;
 }
 Int_t flag=0;
 if (fSigflags)
 {
  if (j>0 && j<=(fSigflags->GetSize()))
  {
   Int_t word=fSigflags->At(j-1);
   flag=word/10;
  }
 }
 return flag;
}

Int_t NcSignal::GetSignalFlag(TString name) const
{
 
 if (!fSigflags) return 0;
 
 Int_t j=GetSlotIndex(name);
 Int_t flag=0;
 if (j>0) flag=GetSignalFlag(j);
 return flag;
}

Int_t NcSignal::GetErrorFlag(Int_t j) const
{
 
 if (j<1) 
 {
  cout << " *NcSignal::GetErrorFlag* Invalid argument j = " << j << endl;
  return 0;
 }
 Int_t flag=0;
 if (fSigflags)
 {
  if (j>0 && j<=(fSigflags->GetSize()))
  {
   Int_t word=fSigflags->At(j-1);
   flag=word%10;
  }
 }
 return flag;
}

Int_t NcSignal::GetErrorFlag(TString name) const
{
 
 if (!fSigflags) return 0;
 
 Int_t j=GetSlotIndex(name);
 Int_t flag=0;
 if (j>0) flag=GetErrorFlag(j);
 return flag;
}

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

Int_t NcSignal::GetNwaveforms() const
{
 
 Int_t n=-1;
 if (fWaveforms) n=fWaveforms->GetLast();
 return (n+1);
}

TH1F* NcSignal::GetWaveform(Int_t j) const
{
 
 TH1F* waveform=0;
 if (j>0 && j<=GetNwaveforms()) waveform=(TH1F*)fWaveforms->At(j-1);
 return waveform;
}

TH1F* NcSignal::GetWaveform(TString name) const
{
 
 Int_t n=GetNwaveforms();
 TString str;
 for (Int_t i=1; i<=n; i++)
 {
  TH1F* waveform=GetWaveform(i);
  if (waveform)
  {
   str=waveform->GetName();
   if (str.Contains(name)) return waveform;
  }
 }
 return 0; // No match found
}

Int_t NcSignal::GetWaveformIndex(TString name) const
{
 
 Int_t n=GetNwaveforms();
 TString str;
 for (Int_t i=1; i<=n; i++)
 {
  TH1F* waveform=GetWaveform(i);
  if (waveform)
  {
   str=waveform->GetName();
   if (str.Contains(name)) return i;
  }
 }
 return 0; // No match found
}

void NcSignal::SetWaveform(TH1F* waveform,Int_t j)
{
 
 if (j<1) return;
 
 if (!fWaveforms)
 {
  fWaveforms=new TObjArray(j);
  fWaveforms->SetOwner();
 }
 
 if (j > fWaveforms->GetSize()) fWaveforms->Expand(j);
 
 TH1F* hcur=(TH1F*)fWaveforms->At(j-1);
 if (waveform != hcur)
 {
  if (hcur)
  {
   fWaveforms->Remove(hcur);
   delete hcur;
   hcur=0;
  }
  if (waveform)
  {
   hcur=new TH1F(*waveform);
   fWaveforms->AddAt(hcur,j-1);
  }
 } 
}

void NcSignal::ResetWaveform(Int_t j)
{
 
 if (!fWaveforms) return;
 
 Int_t size=fWaveforms->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
   if (hwave) hwave->Reset();
  }
  else
  {
   for (Int_t i=0; i<size; i++)
   {
    TH1F* hwave=(TH1F*)fWaveforms->At(i);
    if (hwave) hwave->Reset();
   }
  }
 }
 else
 {
  cout << " *NcSignal::ResetWaveform* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcSignal::ResetWaveform(TString name)
{
 
 Int_t j=GetWaveformIndex(name);
 if (j>0) ResetWaveform(j);
}

void NcSignal::DeleteWaveform(Int_t j)
{
 
 if (!fWaveforms) return;
 
 Int_t size=fWaveforms->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
   if (hwave)
   {
    fWaveforms->Remove(hwave);
    delete hwave;
   }
  }
  else
  {
   delete fWaveforms;
   fWaveforms=0;
  }
 }
 else
 {
  cout << " *NcSignal::DeleteWaveform* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcSignal::DeleteWaveform(TString name)
{
 
 Int_t j=GetWaveformIndex(name);
 if (j>0) DeleteWaveform(j);
}

Int_t NcSignal::GetNsamples() const
{
 
 Int_t n=-1;
 if (fSamples) n=fSamples->GetLast();
 return (n+1);
}

NcSample* NcSignal::GetSample(Int_t j) const
{
 
 NcSample* sample=0;
 if (j>0 && j<=GetNsamples()) sample=(NcSample*)fSamples->At(j-1);
 return sample;
}

NcSample* NcSignal::GetSample(TString name) const
{
 
 Int_t n=GetNsamples();
 TString str;
 for (Int_t i=1; i<=n; i++)
 {
  NcSample* sample=GetSample(i);
  if (sample)
  {
   str=sample->GetName();
   if (str.Contains(name)) return sample;
  }
 }
 return 0; // No match found
}

Int_t NcSignal::GetSampleIndex(TString name) const
{
 
 Int_t n=GetNsamples();
 TString str;
 for (Int_t i=1; i<=n; i++)
 {
  NcSample* sample=GetSample(i);
  if (sample)
  {
   str=sample->GetName();
   if (str.Contains(name)) return i;
  }
 }
 return 0; // No match found
}

void NcSignal::SetSample(NcSample* sample,Int_t j)
{
 
 if (j<1) return;
 
 if (!fSamples)
 {
  fSamples=new TObjArray(j);
  fSamples->SetOwner();
 }
 
 if (j > fSamples->GetSize()) fSamples->Expand(j);
 
 NcSample* hcur=(NcSample*)fSamples->At(j-1);
 if (sample != hcur)
 {
  if (hcur)
  {
   fSamples->Remove(hcur);
   delete hcur;
   hcur=0;
  }
  if (sample)
  {
   hcur=new NcSample(*sample);
   fSamples->AddAt(hcur,j-1);
  }
 } 
}

void NcSignal::ResetSample(Int_t j)
{
 
 if (!fSamples) return;
 
 Int_t size=fSamples->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   NcSample* sample=(NcSample*)fSamples->At(j-1);
   if (sample) sample->Reset();
  }
  else
  {
   for (Int_t i=0; i<size; i++)
   {
    NcSample* sample=(NcSample*)fSamples->At(i);
    if (sample) sample->Reset();
   }
  }
 }
 else
 {
  cout << " *NcSignal::ResetSample* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcSignal::ResetSample(TString name)
{
 
 Int_t j=GetSampleIndex(name);
 if (j>0) ResetSample(j);
}

void NcSignal::DeleteSample(Int_t j)
{
 
 if (!fSamples) return;
 
 Int_t size=fSamples->GetSize();
 
 if ((j>=0) && (j<=size))
 {
  if (j)
  {
   NcSample* sample=(NcSample*)fSamples->At(j-1);
   if (sample)
   {
    fSamples->Remove(sample);
    delete sample;
   }
  }
  else
  {
   delete fSamples;
   fSamples=0;
  }
 }
 else
 {
  cout << " *NcSignal::DeleteSample* Index j = " << j << " invalid." << endl;
  return;
 }
}

void NcSignal::DeleteSample(TString name)
{
 
 Int_t j=GetSampleIndex(name);
 if (j>0) DeleteSample(j);
}

Int_t NcSignal::GetNlinks(TObject* obj,Int_t j) const
{
 
 if (j<0)
 {
  cout << " *NcSignal::GetNlinks* Index j = " << j << " invalid." << endl;
  return 0;
 }
 
 if (!fLinks) return 0;
 
 Int_t n=0;
 if (!j)
 {
  n=fLinks->GetNrefs(obj);
 }
 else
 {
  TArrayI posarr;
  n=GetIndices(obj,j,posarr);
 }
 return n;
}

Int_t NcSignal::GetNlinks(TObject* obj,TString name) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t n=0;
 if (j>0) n=GetNlinks(obj,j);
 return n;
}

TObject* NcSignal::GetLink(Int_t j,Int_t k) const
{
 
 TObject* obj=0;
 // Note : In the internal storage matrix slots=columns positions=rows 
 if (fLinks) obj=fLinks->GetObject(k,j);
 return obj;
}

TObject* NcSignal::GetLink(TString name,Int_t k) const
{
 
 Int_t j=GetSlotIndex(name);
 TObject* obj=0;
 if (j>0) obj=GetLink(j,k);
 return obj;
}

void NcSignal::SetLink(TObject* obj,Int_t j,Int_t k)
{
 
 if (!fLinks && obj) fLinks=new NcObjMatrix();
 
 if (!fLinks) return;
 
 // Note : In the internal storage matrix slots=columns positions=rows 
 fLinks->EnterObject(k,j,obj);
 if (obj) 
 {
  if (obj->InheritsFrom("NcTrack"))
  {
   NcTrack* t=(NcTrack*)obj;
   AddTrack(*t,1);
  }
 }
}

void NcSignal::SetLink(TObject* obj,TString name,Int_t k)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) SetLink(obj,j,k);
}

void NcSignal::AddLink(TObject* obj,Int_t j)
{
 
 if (!obj || j<=0) return;
 
 if (!fLinks) fLinks=new NcObjMatrix();
 
 TObject* dum=0;
 Int_t n=GetNlinks(dum,j);
 Int_t pos=1;
 for (Int_t k=1; k<=n; k++)
 {
  dum=GetLink(j,k);
  if (!dum) break;
  pos++;
 }
 
 SetLink(obj,j,pos);
}

void NcSignal::AddLink(TObject* obj,TString name)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) AddLink(obj,j);
}

void NcSignal::ResetLink(Int_t j,Int_t k)
{
 
 // Note : In the internal storage matrix slots=columns positions=rows 
 if (fLinks) fLinks->RemoveObject(k,j);
}

void NcSignal::ResetLink(TString name,Int_t k)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) ResetLink(j,k);
}

void NcSignal::ResetLinks(TObject* obj,Int_t j,Int_t k)
{
 
 if (!fLinks) return;
 
 if (!obj && !j && !k)
 {
  fLinks->Reset();
 }
 else
 {
  // Note : In the internal storage matrix slots=columns positions=rows 
  fLinks->RemoveObjects(obj,k,j);
 }
}

void NcSignal::ResetLinks(TObject* obj,TString name,Int_t k)
{
 
 Int_t j=GetSlotIndex(name);
 if (j>0) ResetLinks(obj,j,k);
}

Int_t NcSignal::GetIndices(TObject* obj,TArrayI& js,TArrayI& ks) const
{
 
 Int_t nrefs=0;
 js.Reset();
 ks.Reset();
 // Note : In the internal storage matrix slots=columns positions=rows 
 if (fLinks) nrefs=fLinks->GetIndices(obj,ks,js);
 return nrefs;
}

Int_t NcSignal::GetIndices(TObject* obj,Int_t j,TArrayI& ks) const
{
 
 Int_t nrefs=0;
 ks.Reset();
 // Note : In the internal storage matrix slots=columns positions=rows 
 if (fLinks) nrefs=fLinks->GetIndices(obj,ks,j);
 return nrefs;
}

Int_t NcSignal::GetIndices(TObject* obj,TString name,TArrayI& ks) const
{
 
 Int_t j=GetSlotIndex(name);
 Int_t n=0;
 if (j>0) n=GetIndices(obj,j,ks);
 return n;
}

Int_t NcSignal::GetIndices(TObject* obj,TArrayI& js,Int_t k) const
{
 
 Int_t nrefs=0;
 js.Reset();
 // Note : In the internal storage matrix slots=columns positions=rows 
 if (fLinks) nrefs=fLinks->GetIndices(obj,k,js);
 return nrefs;
}

void NcSignal::SetSwapMode(Int_t swap)
{
 
 if (!fLinks) fLinks=new NcObjMatrix();
 fLinks->SetSwapMode(swap);
}

Int_t NcSignal::GetSwapMode() const
{
 
 Int_t swap=0; 
 if (fLinks) swap=fLinks->GetSwapMode();
 return swap;
}

void NcSignal::SetDevice(NcDevice* dev)
{
 
 if (fDevset)
 {
  fDevice=dev;
 }
 else
 {
  cout << " *" << ClassName() << "::SetDevice* Invokation by public users is not allowed." << endl;
 }
}

NcDevice* NcSignal::GetDevice() const
{
 
 return (NcDevice*)fDevice;
}

void NcSignal::AddTrack(NcTrack& t,Int_t mode)
{
 
 if (!fTracks) fTracks=new TObjArray(1);
 
 // Check if this track is already stored for this signal
 Int_t ntk=GetNtracks();
 for (Int_t i=0; i<ntk; i++)
 {
  if (&t==fTracks->At(i)) return; 
 }
 
 fTracks->Add(&t);
 if (mode==1) t.AddSignal(*this,0);
}

void NcSignal::RemoveTrack(NcTrack& t,Int_t mode)
{
 
 if (fTracks)
 {
  NcTrack* test=(NcTrack*)fTracks->Remove(&t);
  if (test) fTracks->Compress();
 }
 
 ResetLinks(&t);
 
 if (mode==1) t.RemoveSignal(*this,0);
}

void NcSignal::RemoveTracks(Int_t mode)
{
 
 if (!fTracks) return;
 
 Int_t ntk=GetNtracks();
 for (Int_t i=0; i<ntk; i++)
 {
  NcTrack* tx=(NcTrack*)fTracks->At(i);
  if (tx)
  {
   ResetLinks(tx);
   if (mode==1) tx->RemoveSignal(*this,0);
  }
 }
 
 delete fTracks;
 fTracks=0;
}

Int_t NcSignal::GetNtracks(NcTrack* t) const
{
 
 if (!fTracks) return 0;
 
 Int_t ntk=fTracks->GetEntries();
 
 if (!t) return ntk;
 
 for (Int_t i=0; i<ntk; i++)
 {
  NcTrack* tx=(NcTrack*)fTracks->At(i);
  if (tx==t) return 1;
 }
 
 return 0;
}

NcTrack* NcSignal::GetTrack(Int_t j) const
{
 
 if (!fTracks) return 0;
 
 if ((j >= 1) && (j <= GetNtracks()))
 {
  return (NcTrack*)fTracks->At(j-1);
 }
 else
 {
  cout << " *NcSignal* track number : " << j << " out of range."
       << " Ntk = " << GetNtracks() << endl;
  return 0;
 }
}

NcTrack* NcSignal::GetIdTrack(Int_t id) const
{
 
 if (!fTracks) return 0;
 
 NcTrack* tx=0;
 for (Int_t i=0; i<GetNtracks(); i++)
 {
  tx=(NcTrack*)fTracks->At(i);
  if (id == tx->GetId()) return tx;
 }
 return 0; // No matching id found
}

NcSample* NcSignal::DisplaySample(Int_t j,Int_t i) const
{
 
 if (j<1) return 0;
 
 TGraph gr;
 NcSample* sx=GetSample(i);
 Int_t ndim=0;
 if (sx)
 {
  ndim=sx->GetDimension();
  if (j<=ndim)
  {
   gr=sx->GetGraph(j);
   gr.DrawClone("AL");
  }
 }
 
 return sx;
}

NcSample* NcSignal::DisplaySample(TString name,Int_t i) const
{
 
 TGraph gr;
 NcSample* sx=GetSample(i);
 if (sx)
 {
  gr=sx->GetGraph(name);
  gr.SetTitle("aap");
  gr.DrawClone("AL");
 }
 
 return sx;
}

TObject* NcSignal::Clone(const char* name) const
{
 
 NcSignal* sig=new NcSignal(*this);
 if (name)
 {
  if (strlen(name)) sig->SetName(name);
 }
 return sig;
}