NcDevice.cxx

Go to the documentation of this file.

// By default private copies of the recorded hits will be made.
// This implies that by default the device will own the registered hits.
// See the SetHitCopy() memberfunction for further details.
// An NcDevice object itself has (in addition to hit storage) also the
// complete functionality of the class NcSignal.
//
// Example :
// =========
//
// NcDevice m;
// // Set user defined status word to indicate e.g. readout electronics version 
// m.SetStatus(100201);
// m.SetHitCopy(1);
// m.SetName("OM123");
//
// Float_t pos[3]={1,2,3};
// m.SetPosition(pos,"car");
//
// NcSignal s;
//
// s.Reset(1);
// s.SetName("OM123 Hit 1");
// s.SetSlotName("ADC");
// s.SetSignal(10);
// s.SetSlotName("LE",2);
// s.SetSignal(-100,2);
// s.SetSlotName("TOT",3);
// s.SetSignal(-1000,3);
// m.AddHit(s);
//
// s.Reset(1);
// s.SetName("OM123 Hit 2");
// s.SetSlotName("ADC");
// s.SetSignal(11);
// s.SetSlotName("LE",2);
// s.SetSignal(-101,2);
// s.SetSlotName("TOT",3);
// s.SetSignal(1001,3);
// m.AddHit(s);
//
// s.Reset(1);
// s.SetName("OM123 Hit 3");
// s.SetSlotName("ADC");
// s.SetSignal(12);
// s.SetSlotName("LE",2);
// s.SetSignal(-102,2);
// s.SetSlotName("TOT",3);
// s.SetSignal(-1002,3);
// m.AddHit(s);
//
// TObjArray* ordered=m.SortHits("TOT");
// nhits=ordered->GetEntries();
// for (Int_t i=0; i<nhits; i++)
// {
//  NcSignal* sx=(NcSignal*)ordered->At(i);
//  if (sx) sx->Data();
// }
//
//--- Author: Nick van Eijndhoven 23-jun-2004 Utrecht University
//- Modified: Nick van Eijndhoven, IIHE-VUB, Brussel, July 1, 2021  09:27Z
~~~
**/
 
#include "NcDevice.h"
#include "Riostream.h"
 
ClassImp(NcDevice); // Class implementation to enable ROOT I/O
 
NcDevice::NcDevice(const char* name,const char* title) : NcSignal(name,title)
{
 
 fStatus=0;
 fHitCopy=1;
 fHits=0;
 fOrdered=0;
 fMarkers=0;
}

NcDevice::~NcDevice()
{
 
 // Remove backward links to this device from the hits which were not owned by it.
 // Note : If a hit has been deleted in the meantime the NcSignal destructor has already
 //        automatically removed the corresponding pointer from the storage of this device.
 if (!fHitCopy)
 {
  for (Int_t ih=1; ih<=GetNhits(); ih++)
  {
   NcSignal* sx=GetHit(ih);
   if (sx) sx->ResetLinks(this);
  }
 }
 
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 
 if (fMarkers)
 {
  delete fMarkers;
  fMarkers=0;
 }
}

NcDevice::NcDevice(const NcDevice& dev) : NcSignal(dev)
{
 
 fHits=0;
 fOrdered=0;
 fMarkers=0;
 
 fStatus=dev.GetStatus();
 fHitCopy=dev.GetHitCopy();
 
 Int_t nhits=dev.GetNhits();
 if (nhits)
 {
  fHits=new TObjArray(nhits);
  if (fHitCopy) fHits->SetOwner();
  NcSignal* sx=0;
  for (Int_t ih=1; ih<=nhits; ih++)
  {
   sx=dev.GetHit(ih);
 
   if (!sx) continue;
 
   if (fHitCopy)
   {
    fHits->Add(sx->Clone());
    NcSignal* s=(NcSignal*)fHits->Last();
    s->ResetLinks((NcDevice*)&dev);
    s->fDevset=kTRUE;
    s->SetDevice(this);
    s->fDevset=kFALSE;
   }
   else
   {
    TArrayI js;
    TArrayI ks;
    Int_t nlinks=sx->GetIndices((NcDevice*)&dev,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);
     sx->SetLink(this,j,k);
    }
    fHits->Add(sx);
   }
  }
 }
}

void NcDevice::Reset(Int_t mode)
{
 
 RemoveHits();
 NcSignal::Reset(mode);
}

void NcDevice::SetHitCopy(Int_t j)
{
 
 if (!fHits)
 {
  if (j==0 || j==1)
  {
   fHitCopy=j;
  }
  else
  {
   cout << "*NcDevice::SetHitCopy* Invalid argument : " << j << endl;
  }
 }
 else
 {
  cout << "*NcDevice::SetHitCopy* Storage already contained hits."
       << "  ==> HitCopy mode not changed." << endl; 
 }
}

Int_t NcDevice::GetHitCopy() const
{
 
 return fHitCopy;
}

void NcDevice::SetOwner(Bool_t own)
{
 
 Int_t mode=1;
 if (!own) mode=0;
 if (fHits) fHits->SetOwner(own);
 fHitCopy=mode;
}

void NcDevice::SetStatus(Int_t word)
{
 
 fStatus=word;
}

Int_t NcDevice::GetStatus() const
{
 
 return fStatus;
}

void NcDevice::AddHit(NcSignal& s)
{
 
 if (!fHits)
 {
  fHits=new TObjArray(1);
  if (fHitCopy) fHits->SetOwner();
 }
 
 // Check if this signal is already stored for this device.
 Int_t nhits=GetNhits();
 for (Int_t i=0; i<nhits; i++)
 {
  if (&s==fHits->At(i)) return; 
 }
 
 // Check for existing (backward) link to this device.
 Int_t nlinks=s.GetNlinks(this);
 
 if (fHitCopy)
 {
  fHits->Add(s.Clone());
  // Remove unnecessary backward link(s) from the various slots
  // and set the owning link to this device
  NcSignal* sx=(NcSignal*)fHits->Last();
  if (nlinks) sx->ResetLinks(this);
  sx->fDevset=kTRUE;
  sx->SetDevice(this);
  sx->fDevset=kFALSE;
 }
 else
 {
  fHits->Add(&s);
  // Set (backward) link to this device
  if (!nlinks) s.AddLink(this);
 }
}

void NcDevice::RemoveHit(NcSignal& s)
{
 
 if (fHits)
 {
  NcSignal* test=(NcSignal*)fHits->Remove(&s);
  if (test)
  {
   fHits->Compress();
   if (fHitCopy) delete test;
  }
 }
 if (fOrdered)
 {
  NcSignal* test=(NcSignal*)fOrdered->Remove(&s);
  if (test) fOrdered->Compress();
 }
}

void NcDevice::RemoveHits()
{
 
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 if (fMarkers)
 {
  delete fMarkers;
  fMarkers=0;
 }
}

Int_t NcDevice::GetNhits() const
{
 
 Int_t nhits=0;
 if (fHits) nhits=fHits->GetEntries();
 return nhits;
}

Int_t NcDevice::GetNhits(TString name,Int_t mode,Int_t opt) const
{
 
 if (!fHits) return 0;
 
 Int_t nfound=0;
 TString hitname;
 Int_t nhits=GetNhits();
 Int_t flag=0;
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)fHits->At(i);
  if (sx)
  {
   flag=0;
   hitname=sx->GetName();
   if ((!opt && hitname==name) || (opt && hitname.Contains(name.Data()))) flag=1;
   if (sx->GetSlotIndex(name,opt)) flag=2;
   if ((mode==0 && flag==1) || (mode==1 && flag==2) || (mode==2 && flag)) nfound++;
  }
 }
 
 return nfound;
}

NcSignal* NcDevice::GetHit(Int_t j) const
{
 
 if (!fHits) return 0;
 
 if ((j >= 1) && (j <= GetNhits()))
 {
  return (NcSignal*)fHits->At(j-1);
 }
 else
 {
  return 0;
 }
}

NcSignal* NcDevice::GetHit(TString name,Int_t mode,Int_t opt) const
{
 
 if (!fHits) return 0;
 
 TString hitname;
 Int_t nhits=GetNhits();
 Int_t flag=0;
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)fHits->At(i);
  if (sx)
  {
   flag=0;
   hitname=sx->GetName();
   if ((!opt && hitname==name) || (opt && hitname.Contains(name.Data()))) flag=1;
   if (sx->GetSlotIndex(name,opt)) flag=2;
   if ((mode==0 && flag==1) || (mode==1 && flag==2) || (mode==2 && flag)) return sx;
  }
 }
 
 return 0; // No matching name found
}

NcSignal* NcDevice::GetIdHit(Int_t id) const
{
 
 if (!fHits || id<0) return 0;
 
 NcSignal* sx=0;
 Int_t sid=0;
 for (Int_t i=0; i<GetNhits(); i++)
 {
  sx=(NcSignal*)fHits->At(i);
  if (sx)
  {
   sid=sx->GetUniqueID();
   if (id==sid) return sx;
  }
 }
 return 0; // No matching id found
}

TObjArray* NcDevice::GetHits()
{
 
 return fHits;
}

void NcDevice::GetHits(TObjArray& selected,TString name,Int_t mode,Int_t opt,TObjArray* hits) const
{
 
 selected.Clear();
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 Int_t nhits=0;
 if (ahits) nhits=ahits->GetEntries();
 
 if (!ahits || !nhits) return;
 
 TString hitname;
 Int_t idx=0;
 Int_t flag=0; // 0=no match 1=hit name match 2=slot name match 3=both hit and slot name match
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)ahits->At(i);
 
  if (!sx) continue;
 
  flag=0;
  hitname=sx->GetName();
  idx=sx->GetSlotIndex(name,opt);
 
  if ((!opt && hitname==name) || (opt && hitname.Contains(name.Data()))) flag=1;
 
  if (idx)
  {
   if (sx->GetSignalFlag(idx))
   {
    if (!flag)
    {
     flag=2;
    }
    else
    {
     flag=3;
    }
   }
  }
  if ((mode==0 && (flag==1 || flag==3)) || (mode==1 && flag>1) || (mode==2 && flag)) selected.Add(sx);
  if ((mode==-1 && (flag==0 || flag==2)) || (mode==-2 && flag<2) || (mode==-3 && !flag)) selected.Add(sx);
 }
}

void NcDevice::ShowHit(Int_t j,TString f,TString u) const
{
 
 if (!j)
 {
  Int_t nhits=GetNhits();
  for (Int_t ih=1; ih<=nhits; ih++)
  {
   NcSignal* sx=GetHit(ih);
   if (sx) sx->Data(f,u);
  }
 }
 else
 {
  NcSignal* s=GetHit(j);
  if (s) s->Data(f,u);
 }
}

void NcDevice::Data(TString f,TString u) const
{
 
 NcSignal::Data(f,u);
 Int_t nhits=GetNhits();
 if (nhits)
 {
  cout << " The following " << nhits << " hits are registered : " << endl;
  ShowHit(0,f,u);
 }
 else
 {
  cout << " No hits have been registered for this device." << endl;
 }
}

void NcDevice::GetExtremes(Float_t& vmin,Float_t& vmax,Int_t idx,TObjArray* hits,Int_t mode,Int_t deadcheck) const
{
 
 vmin=0;
 vmax=0;
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 if (idx<=0 || !ahits) return;
 
 // Take the stored signal value "as is" to ensure identical treatment of dead and alive signals
 if (!deadcheck) mode=0;
 
 Int_t nhits=ahits->GetEntries();
 
 Float_t sig=0;
 TObject* obj=0;
 NcSignal* sx=0;
 for (Int_t i=0; i<nhits; i++)
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  sx=(NcSignal*)obj;
 
  if (idx > sx->GetNvalues()) continue; // User specified slotindex out of range for this signal
  if (deadcheck && sx->GetDeadValue(idx)) continue;  // Only take alive signals
 
  sig=sx->GetSignal(idx,mode);
  if (i==0)
  {
   vmin=sig;
   vmax=sig;
  }
  else
  {
   if (sig<vmin) vmin=sig;
   if (sig>vmax) vmax=sig;
  }
 }
}

void NcDevice::GetExtremes(Float_t& vmin,Float_t& vmax,TString name,TObjArray* hits,Int_t mode,Int_t deadcheck) const
{
 
 vmin=0;
 vmax=0;
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 if (!ahits) return;
 
 // Take the stored signal value "as is" to ensure identical treatment of dead and alive signals
 if (!deadcheck) mode=0;
 
 Int_t nhits=ahits->GetEntries();
 
 Int_t idx=0; // The signal slotindex to perform the sorting on
 
 Float_t sig=0;
 TObject* obj=0;
 NcSignal* sx=0;
 Bool_t first=kTRUE;
 for (Int_t i=0; i<nhits; i++)
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  sx=(NcSignal*)obj;
 
  // Obtain the slotindex corresponding to the user selection
  idx=sx->GetSlotIndex(name);
  if (!idx) continue;
 
  if (deadcheck && sx->GetDeadValue(idx)) continue; // Only take alive signals
 
  sig=sx->GetSignal(idx,mode);
  if (first)
  {
   vmin=sig;
   vmax=sig;
   first=kFALSE;
  }
  else
  {
   if (sig<vmin) vmin=sig;
   if (sig>vmax) vmax=sig;
  }
 }
}

TObjArray* NcDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (ordered) ordered->Clear();
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 Int_t nhits=0;
 if (ahits) nhits=ahits->GetEntries();
 
 if (idx<=0 || abs(mode)!=1 || !ahits || !nhits) return 0;
 
 if (ordered)
 {
  ordered->Expand(nhits);
 }
 else
 {
  if (fOrdered) delete fOrdered;
  fOrdered=new TObjArray(nhits);
 }
 
 // Take the stored signal value "as is" to ensure identical treatment of dead and alive signals
 if (!deadcheck) mcal=0;
 
 TObjArray* arr=0;   // Generic sorted array pointer to be used in the logic below
 
 if (ordered)
 {
  arr=ordered;
 }
 else
 {
  arr=fOrdered;
 }
 
 TObject* obj=0;
 NcSignal* s=0;
 Int_t nord=0;
 for (Int_t i=0; i<nhits; i++) // Loop over all hits of the array
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  s=(NcSignal*)obj;
 
  if (!s) continue;
 
  if (idx > s->GetNvalues()) continue; // User specified slotindex out of range for this signal
  if (deadcheck && s->GetDeadValue(idx)) continue;  // Only take alive signals
 
  if (nord == 0) // store the first hit with a signal at the first ordered position
  {
   nord++;
   arr->AddAt(s,nord-1);
   continue;
  }
 
  for (Int_t j=0; j<=nord; j++) // put hit in the right ordered position
  {
   if (j == nord) // module has smallest (mode=-1) or largest (mode=1) signal seen so far
   {
    nord++;
    arr->AddAt(s,j); // add hit at the end
    break; // go for next hit
   }
 
   if (mode==-1 && s->GetSignal(idx,mcal) <= ((NcSignal*)arr->At(j))->GetSignal(idx,mcal)) continue;
   if (mode==1 && s->GetSignal(idx,mcal) >= ((NcSignal*)arr->At(j))->GetSignal(idx,mcal)) continue;
 
   nord++;
   for (Int_t k=nord-1; k>j; k--) // create empty position
   {
    arr->AddAt(arr->At(k-1),k);
   }
   arr->AddAt(s,j); // put hit at empty position
   break; // go for next hit
  }
 }
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return fOrdered;
 }
}


TObjArray* NcDevice::SortHits(TString name,Int_t mode,TObjArray* hits,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (ordered) ordered->Clear();
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 Int_t nhits=0;
 if (ahits) nhits=ahits->GetEntries();
 
 if (abs(mode)!=1 || !ahits || !nhits) return 0;
 
 if (ordered)
 {
  ordered->Expand(nhits);
 }
 else
 {
  if (fOrdered) delete fOrdered;
  fOrdered=new TObjArray(nhits);
 }
 
 Int_t idx=0; // The signal slotindex to perform the sorting on
 
 // Take the stored signal value "as is" to ensure identical treatment of dead and alive signals
 if (!deadcheck) mcal=0;
 
 
 TObjArray* arr=0;   // Generic sorted array pointer to be used in the logic below
 
 if (ordered)
 {
  arr=ordered;
 }
 else
 {
  arr=fOrdered;
 }
 
 TObject* obj=0;
 NcSignal* s=0;
 Int_t nord=0;
 for (Int_t i=0; i<nhits; i++) // loop over all hits of the array
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  s=(NcSignal*)obj;
 
  if (!s) continue;
 
  // Obtain the slotindex corresponding to the user selection
  idx=s->GetSlotIndex(name);
  if (!idx) continue;
 
  if (deadcheck && s->GetDeadValue(idx)) continue; // only take alive signals
 
  if (nord == 0) // store the first hit with a signal at the first ordered position
  {
   nord++;
   arr->AddAt(s,nord-1);
   continue;
  }
 
  for (Int_t j=0; j<=nord; j++) // put hit in the right ordered position
  {
   if (j == nord) // module has smallest (mode=-1) or largest (mode=1) signal seen so far
   {
    nord++;
    arr->AddAt(s,j); // add hit at the end
    break; // go for next hit
   }
 
   if (mode==-1 && s->GetSignal(idx,mcal) <= ((NcSignal*)arr->At(j))->GetSignal(idx,mcal)) continue;
   if (mode==1 && s->GetSignal(idx,mcal) >= ((NcSignal*)arr->At(j))->GetSignal(idx,mcal)) continue;
 
   nord++;
   for (Int_t k=nord-1; k>j; k--) // create empty position
   {
    arr->AddAt(arr->At(k-1),k);
   }
   arr->AddAt(s,j); // put hit at empty position
   break; // go for next hit
  }
 }
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return fOrdered;
 }
}


void NcDevice::DisplayHits(Int_t idx,Float_t scale,TObjArray* hits,Int_t dp,Int_t mode,Int_t mcol)
{
 
 Int_t thisdev=0; // Indicate whether this is the owning device or not 
 TObjArray* ahits=hits;
 if (!ahits)
 {
  ahits=fHits;
  thisdev=1;
 }
 
 if (idx<=0 || !ahits) return;
 
 Int_t nhits=ahits->GetEntries();
 if (!nhits) return;
 
 Float_t sigmax=fabs(scale);
 if (scale<0)
 {
  Float_t vmin,vmax;
  GetExtremes(vmin,vmax,idx,ahits,mode);
  sigmax=fabs(vmax);
  if (fabs(vmin)>sigmax) sigmax=fabs(vmin);
 }
 
 if (sigmax <=0) return;
 
 if (fMarkers)
 {
  delete fMarkers;
  fMarkers=0;
 }
 fMarkers=new TObjArray(nhits);
 fMarkers->SetOwner();
 
 Float_t pos[3];
 GetPosition(pos,"car");
 
 Float_t sig=0;
 TObject* obj=0;
 NcSignal* sx=0;
 for (Int_t ih=0; ih<nhits; ih++)
 {
  obj=ahits->At(ih);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  sx=(NcSignal*)obj;
 
  if (!dp)
  {
   sx->GetPosition(pos,"car");
  }
  else
  {
   if (!thisdev)
   {
    NcDevice* dev=sx->GetDevice();
    if (dev) dev->GetPosition(pos,"car");
   }
  }
  sig=sx->GetSignal(idx,mode);
 
  // Skip dead signals
  if (fabs(sig) <= 0.) continue;
 
  TPolyMarker3D* m=new TPolyMarker3D();
  m->SetMarkerStyle(8);
  m->SetMarkerColor(mcol);
  m->SetMarkerSize(100.*fabs(sig)/sigmax);
  m->SetPoint(0,pos[0],pos[1],pos[2]);
  fMarkers->Add(m);
  m->Draw();
 }
}

void NcDevice::DisplayHits(TString name,Float_t scale,TObjArray* hits,Int_t dp,Int_t mode,Int_t mcol)
{
 
 Int_t thisdev=0; // Indicate whether this is the owning device or not 
 TObjArray* ahits=hits;
 if (!ahits)
 {
  ahits=fHits;
  thisdev=1;
 }
 
 if (!ahits) return;
 
 Int_t nhits=ahits->GetEntries();
 
 if (!nhits) return;
 
 Float_t sigmax=fabs(scale);
 if (scale<0)
 {
  Float_t vmin,vmax;
  GetExtremes(vmin,vmax,name,ahits,mode);
  sigmax=fabs(vmax);
  if (fabs(vmin)>sigmax) sigmax=fabs(vmin);
 }
 
 if (sigmax <=0) return;
 
 if (fMarkers)
 {
  delete fMarkers;
  fMarkers=0;
 }
 fMarkers=new TObjArray(nhits);
 fMarkers->SetOwner();
 
 Float_t pos[3];
 GetPosition(pos,"car");
 
 Int_t idx=0; // The slot index corresponding to the user specified name
 Float_t sig=0;
 TObject* obj=0;
 NcSignal* sx=0;
 for (Int_t ih=0; ih<nhits; ih++)
 {
  obj=ahits->At(ih);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  sx=(NcSignal*)obj;
  idx=sx->GetSlotIndex(name);
  if (!idx) continue;
  if (!dp)
  {
   sx->GetPosition(pos,"car");
  }
  else
  {
   if (!thisdev)
   {
    NcDevice* dev=sx->GetDevice();
    if (dev) dev->GetPosition(pos,"car");
   }
  }
  sig=sx->GetSignal(idx,mode);
 
  // Skip dead signals
  if (fabs(sig) <= 0.) continue;
 
  TPolyMarker3D* m=new TPolyMarker3D();
  m->SetMarkerStyle(8);
  m->SetMarkerColor(mcol);
  m->SetMarkerSize(100.*fabs(sig)/sigmax);
  m->SetPoint(0,pos[0],pos[1],pos[2]);
  fMarkers->Add(m);
  m->Draw();
 }
}

Double_t NcDevice::SumSignals(Int_t idx,Int_t mode,TObjArray* hits)
{
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 Int_t nhits=0;
 if (ahits) nhits=ahits->GetEntries();
 
 if (idx<=0 || !ahits || !nhits) return 0;
 
 TObject* obj=0;
 NcSignal* s=0;
 Double_t sum=0;
 for (Int_t i=0; i<nhits; i++) // Loop over all hits of the array
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  s=(NcSignal*)obj;
 
  if (!s) continue;
 
  if (idx > s->GetNvalues()) continue; // User specified slotindex out of range for this signal
 
  sum+=s->GetSignal(idx,mode);
 }
 
 return sum;
}

Double_t NcDevice::SumSignals(TString name,Int_t mode,TObjArray* hits)
{
 
 TObjArray* ahits=hits;
 if (!ahits) ahits=fHits;
 
 Int_t nhits=0;
 if (ahits) nhits=ahits->GetEntries();
 
 if (!ahits || !nhits) return 0;
 
 TObject* obj=0;
 NcSignal* s=0;
 Double_t sum=0;
 for (Int_t i=0; i<nhits; i++) // Loop over all hits of the array
 {
  obj=ahits->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcSignal")) continue;
  s=(NcSignal*)obj;
 
  if (!s) continue;
 
  sum+=s->GetSignal(name,mode);
 }
 
 return sum;
}

Double_t NcDevice::SlideWindow(TObjArray* hits,Double_t thres,Double_t swin,TString sname,Int_t smode,TString wname,Int_t wmode,Int_t* i1,Int_t* i2) const
{
 
 Int_t nhits=0;
 if (hits) nhits=hits->GetEntries();
 
 if (!nhits) return 0;
 
 Double_t v1=0;
 Double_t v2=0;
 Double_t wsize=0;
 Double_t sum=0;
 Double_t w=1;
 Int_t wflag=1;
 if (wname=="none") wflag=0;
 Int_t ifirst=0;
 TObject* obj=0;
 NcSignal* sx1=0;
 NcSignal* sx2=0;
 while (ifirst<nhits)
 {
  obj=hits->At(ifirst);
  if (!(obj->InheritsFrom("NcSignal")))
  {
   ifirst++;
   continue;
  }
 
  // The starting signal of this window
  sx1=(NcSignal*)obj;
  v1=sx1->GetSignal(sname,smode);
  if (wflag) w=sx1->GetSignal(wname,wmode);
  sum=w;
  if (sum>=thres)
  {
   if (i1) *i1=ifirst;
   if (i2) *i2=ifirst;
   return v1;
  }
 
  // Scan the allowed window size 
  for (Int_t ilast=ifirst+1; ilast<nhits; ilast++)
  {
   obj=hits->At(ilast);
   if (!(obj->InheritsFrom("NcSignal"))) continue;
 
   sx2=(NcSignal*)obj;
   v2=sx2->GetSignal(sname,smode);
 
   wsize=fabs(v2-v1);
   if (wsize>swin) break;
 
   if (wflag) w=sx2->GetSignal(wname,wmode);
   sum+=w;   
   if (sum>=thres)
   {
    if (i1) *i1=ifirst;
    if (i2) *i2=ilast;
    return v2;
   }
 
  }  
  ifirst++;
  sum=0;
 }
 
 // No window found to match the selection criteria
 if (i1) *i1=-1;
 if (i2) *i2=-1;
 return 0;
}

Nc3Vector NcDevice::GetHitPath(TObjArray* hits,Int_t pos) const
{
 
 Nc3Vector v;
 
 if (!hits) return v;
 
 Int_t nh=hits->GetEntries();
 if (!nh) return v;
 
 NcSignal* s1=(NcSignal*)hits->At(0);
 if (!s1) return v;
 
 NcDevice* dev1=s1->GetDevice();
 if (pos && !dev1) return v;
 
 // Define the starting hit to be the origin
 Nc3Vector r1;
 r1.SetZero();
 
 Nc3Vector r2;
 Nc3Vector r12;
 for (Int_t ih=1; ih<nh; ih++)
 {
  NcSignal* s2=(NcSignal*)hits->At(ih);
  if (!s2) continue;
 
  NcDevice* dev2=s2->GetDevice();
  if (pos && !dev2) continue;
 
  if (!pos)
  {
   r2=(Nc3Vector)s2->GetPosition();
  }
  else
  {
   r2=(Nc3Vector)dev2->GetPosition();
  }
  r12=r2-r1;
  v+=r12;
 
  r1=r2;
 }
 
 return v;
}

NcPosition NcDevice::GetCOG(TObjArray* hits,Int_t pos,TString slotname,Int_t mode) const
{
 
 NcPosition cog;
 
 if (!hits) return cog;
 
 Int_t nh=hits->GetEntries();
 if (!nh) return cog;
 
 Nc3Vector rx;
 Nc3Vector rsum;
 Float_t w=1;
 Double_t wsum=0;
 for (Int_t ih=0; ih<nh; ih++)
 {
  NcSignal* sx=(NcSignal*)hits->At(ih);
  if (!sx) continue;
 
  NcDevice* devx=sx->GetDevice();
  if (pos && !devx) continue;
 
  if (!pos)
  {
   rx=(Nc3Vector)sx->GetPosition();
  }
  else
  {
   rx=(Nc3Vector)devx->GetPosition();
  }
 
  if (slotname != "none")
  {
   w=fabs(sx->GetSignal(slotname,mode));
   rx*=w;
  }
  rsum+=rx;
  wsum+=double(w);
 }
 
 if (wsum>0) rsum/=wsum;
 cog.SetPosition(rsum);
 return cog;
}

Double_t NcDevice::GetCVAL(TObjArray* hits,TString obsname,TString weightname,Int_t mode,Int_t type) const
{
 
 if (type!=1 && type!=2)
 {
  cout << " *" << ClassName() << "::GetCVAL* Unknown type : " << type << endl;
  return 0;
 }
 
 if (!hits) return 0;
 
 Int_t nh=hits->GetEntries();
 if (!nh) return 0;
 
 Double_t cval=0;
 
 Double_t val=0;
 Double_t w=1;
 Double_t wsum=0;
 NcSample stat;
 if (type==1) stat.SetStoreMode();
 Int_t iw=0;
 for (Int_t ih=0; ih<nh; ih++)
 {
  NcSignal* sx=(NcSignal*)hits->At(ih);
  if (!sx) continue;
 
  val=sx->GetSignal(obsname,mode);
 
  if (weightname != "none") w=fabs(sx->GetSignal(weightname,mode));
 
  if (type==1) // Weighted median
  {
   iw=TMath::Nint(w);
   if (iw<1) iw=1;
   for (Int_t i=0; i<iw; i++)
   {
    stat.Enter(val);
   }
  }
 
  if (type==2) // Weighted mean
  {
   val*=w;
   stat.Enter(val);
  }
  wsum+=w;
 }
 
 if (type==1) cval=stat.GetMedian(1);
 
 if (type==2)
 {
  if (wsum>0) cval=stat.GetSum(1)/wsum;
 }
 
 return cval;
}

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