NcDetectorUnit.cxx

Go to the documentation of this file.

 
#include "NcDetectorUnit.h"
#include "Riostream.h"
 
ClassImp(NcDetectorUnit); // Class implementation to enable ROOT I/O
 
NcDetectorUnit::NcDetectorUnit(const char* name,const char* title) : NcDevice(name,title)
{
 
 fDevices=0;
 fDevCopy=1;
 fDevs=0;
 fThits=0;
 fOrdered=0;
 fDisplay=0;
}

NcDetectorUnit::~NcDetectorUnit()
{
 
 if (fDevices)
 {
  delete fDevices;
  fDevices=0;
 }
 if (fDevs)
 {
  delete fDevs;
  fDevs=0;
 }
 if (fThits)
 {
  delete fThits;
  fThits=0;
 }
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
}

NcDetectorUnit::NcDetectorUnit(const NcDetectorUnit& q) : NcDevice(q)
{
 
 fDevCopy=q.fDevCopy;
 
 fDevs=0;
 fThits=0;
 fOrdered=0;
 fDisplay=0;
 
 fDevices=0;
 Int_t ndevs=0;
 if (q.fDevices) ndevs=q.fDevices->GetEntries();
 if (ndevs)
 {
  fDevices=new TObjArray(ndevs);
  if (fDevCopy) fDevices->SetOwner();
  for (Int_t i=1; i<=ndevs; i++)
  {
   NcDevice* dev=q.GetDevice(i);
   if (dev)
   {
    if (fDevCopy)
    {
     fDevices->Add(dev->Clone());
    }
    else
    {
     fDevices->Add(dev);
    }
   }
  }
 }
}

void NcDetectorUnit::SetDevCopy(Int_t j)
{
 
 if (!fDevices)
 {
  if (j==0 || j==1)
  {
   fDevCopy=j;
  }
  else
  {
   cout << " *" << ClassName() << "::SetDevCopy* Invalid argument : " << j << endl;
  }
 }
 else
 {
  cout << " *" << ClassName() << "::SetDevCopy* Storage already contained devices."
       << "  ==> DevCopy mode not changed." << endl; 
 }
}

Int_t NcDetectorUnit::GetDevCopy() const
{
 
 return fDevCopy;
}

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

void NcDetectorUnit::Reset(Int_t mode)
{
 
 NcDevice::Reset(mode);
 
 if (fDevices)
 {
  delete fDevices;
  fDevices=0;
 }
 if (fThits)
 {
  delete fThits;
  fThits=0;
 }
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 if (fDevs)
 {
  delete fDevs;
  fDevs=0;
 }
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
}

void NcDetectorUnit::AddDevice(NcDevice& d)
{
 
 if (!fDevices)
 {
  fDevices=new TObjArray();
  if (fDevCopy) fDevices->SetOwner();
 }
 
 // Add the device to this detector unit
 if (fDevCopy)
 {
  fDevices->Add(d.Clone());
 }
 else
 {
  fDevices->Add(&d);
 }
}

void NcDetectorUnit::RemoveDevice(NcDevice* d)
{
 
 if (!fDevices || !d) return;
 
 TObject* obj=fDevices->Remove(d);
 if (obj)
 {
  if (fDevCopy) delete obj;
  fDevices->Compress();
 }
}

Int_t NcDetectorUnit::GetNdevices(Bool_t follow)
{
 
 Int_t ndevs=0;
 
 if (!follow)
 {
  if (fDevices) ndevs=fDevices->GetEntries();
 }
 else
 {
  TObjArray devs;
  LoadDevices("*",follow,&devs);
  ndevs=devs.GetEntries();
 }
 
 return ndevs;
} 

Int_t NcDetectorUnit::GetNdevices(TString classname,Bool_t follow,TObjArray* hits)
{
 
 if (classname=="*") classname="NcDevice";
 
 Int_t ndevs=0;
 
 if (!hits) // Investigate the stored devices
 {
  TObjArray devs;
  LoadDevices(classname,follow,&devs);
  ndevs=devs.GetEntries();
 }
 else // Investigate the provided hit array
 {
  Int_t nh=hits->GetEntries();
  if (!nh) return 0;
 
  // Check for the encountered unique device identifiers of the specified class
  TArrayI devids(nh);
  Int_t idxmax=0;
  Int_t jdev=0;
  Int_t match=0;
  for (Int_t ih=0; ih<nh; ih++)
  {
   TObject* obj=hits->At(ih);
   if (!obj) continue;
 
   NcSignal* sx=0;
   if (obj->InheritsFrom("NcSignal")) sx=(NcSignal*)obj;
   if (!sx) continue;
 
   NcDevice* dev=sx->GetDevice();
   if (!dev) continue;
   if (!(dev->InheritsFrom(classname))) continue;
 
   // Update the number of devices
   jdev=dev->GetUniqueID();
   match=0;
   idxmax=ndevs;
   for (Int_t idx=0; idx<idxmax; idx++)
   {
    if (jdev==devids.At(idx))
    {
     match=1;
     break;
    }
   } 
   if (!match) // Device number was not present in array
   {
    ndevs++;
    devids.AddAt(jdev,ndevs-1);
   }
  }
 }
 
 return ndevs;
} 

NcDevice* NcDetectorUnit::GetDevice(Int_t i) const
{
 
 if (!fDevices)
 {
  return 0;
 }
 else
 {
  Int_t ndevs=fDevices->GetEntries();
  if (i<=0 || i>ndevs)
  {
   cout << " *" << ClassName() << "::GetDevice* Invalid argument i : " << i
        << " ndevs = " << ndevs << endl;
   return 0;
  }
  else
  {
   return (NcDevice*)fDevices->At(i-1);
  }
 }
}

NcDevice* NcDetectorUnit::GetDevice(TString name,Bool_t follow)
{
 
 if (!fDevices)
 {
  return 0;
 }
 else
 {
  TString s;
  TObjArray devs;
  LoadDevices("NcDevice",follow,&devs);
  Int_t ndevs=devs.GetEntries();
  for (Int_t i=0; i<ndevs; i++)
  {
   NcDevice* dev=(NcDevice*)devs.At(i);
   if (dev)
   {
    s=dev->GetName();
    if (s==name) return dev;
   }
  }
 
  return 0; // No matching name found
 }
}

NcDevice* NcDetectorUnit::GetIdDevice(Int_t id,Bool_t follow,TObjArray* devs)
{
 
 TObjArray temp;
 
 TObjArray* arr=devs;
 if (!arr)
 {
  if (!follow)
  {
   arr=fDevices;
  }
  else
  {
   arr=&temp;
   LoadDevices("NcDevice",follow,arr);
  }
 }
 
 if (!arr || id<0) return 0;
 
 Int_t idx=0;
 for (Int_t i=0; i<arr->GetSize(); i++)
 {
  TObject* obj=arr->At(i);
 
  if (!obj) continue;
 
  NcDevice* dev=0;
  if (obj->InheritsFrom("NcDevice")) dev=(NcDevice*)obj;
  if (dev)
  {
   idx=dev->GetUniqueID();
   if (idx==id) return dev;
  }
 }
 return 0; // No matching id found
}

NcDevice* NcDetectorUnit::GetIdDevice(Int_t id,TString classname,Bool_t follow)
{
 
 if (!fDevices || id<0) return 0;
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray temp;
 
 TObjArray* arr=fDevices;
 if (follow)
 {
  arr=&temp;
  LoadDevices(classname,follow,arr);
 }
 
 Int_t idx=0;
 for (Int_t i=0; i<arr->GetEntries(); i++)
 {
  NcDevice* dev=(NcDevice*)arr->At(i);
  if (dev)
  {
   idx=dev->GetUniqueID();
   if (idx==id && dev->InheritsFrom(classname)) return dev;
  }
 }
 return 0; // No matching id found for the specified class
}

TObjArray* NcDetectorUnit::GetDevices(TString classname,Bool_t follow,TObjArray* devices)
{
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray* arr=0;
 
 if (devices)
 {
  devices->Clear();
  arr=devices;
 }
 else
 {
  if (fDevs)
  {
   fDevs->Clear();
  }
  else
  {
   fDevs=new TObjArray();
  }
  arr=fDevs;
 }
 
 LoadDevices(classname,follow,arr);
 
 if (devices)
 {
  return 0;
 }
 else
 {
  return fDevs;
 }
}

NcDetectorUnit* NcDetectorUnit::GetDetectorUnit(TString name,Bool_t follow)
{
 
 if (!fDevices)
 {
  return 0;
 }
 else
 {
  TString s;
  TObjArray devs;
  LoadDevices("NcDetectorUnit",follow,&devs);
  Int_t ndevs=devs.GetEntries();
  for (Int_t i=0; i<ndevs; i++)
  {
   NcDevice* dev=(NcDevice*)devs.At(i);
   if (dev)
   {
    if (!(dev->InheritsFrom("NcDetectorUnit"))) continue;
    s=dev->GetName();
    if (s==name) return (NcDetectorUnit*)dev;
   }
  }
 
  return 0; // No matching name found
 }
}

NcDetectorUnit* NcDetectorUnit::GetIdDetectorUnit(Int_t id,Bool_t follow,TObjArray* devs)
{
 
 TObjArray temp;
 
 TObjArray* arr=devs;
 if (!arr)
 {
  if (!follow)
  {
   arr=fDevices;
  }
  else
  {
   arr=&temp;
   LoadDevices("NcDetectorUnit",follow,arr);
  }
 }
 
 if (!arr || id<0) return 0;
 
 Int_t idx=0;
 for (Int_t i=0; i<arr->GetSize(); i++)
 {
  TObject* obj=arr->At(i);
 
  if (!obj) continue;
 
  NcDetectorUnit* dev=0;
  if (obj->InheritsFrom("NcDetectorUnit")) dev=(NcDetectorUnit*)obj;
  if (dev)
  {
   idx=dev->GetUniqueID();
   if (idx==id) return dev;
  }
 }
 return 0; // No matching id found
}

NcDetectorUnit* NcDetectorUnit::GetIdDetectorUnit(Int_t id,TString classname,Bool_t follow)
{
 
 if (!fDevices || id<0) return 0;
 
 if (classname=="*") classname="NcDetectorUnit";
 
 TObjArray temp;
 
 TObjArray* arr=fDevices;
 if (follow)
 {
  arr=&temp;
  LoadDevices(classname,follow,arr);
 }
 
 Int_t idx=0;
 for (Int_t i=0; i<arr->GetEntries(); i++)
 {
  NcDevice* dev=(NcDevice*)arr->At(i);
  if (dev)
  {
   if (!(dev->InheritsFrom("NcDetectorUnit"))) continue;
   idx=dev->GetUniqueID();
   if (idx==id && dev->InheritsFrom(classname)) return (NcDetectorUnit*)dev;
  }
 }
 return 0; // No matching id found for the specified class
}

void NcDetectorUnit::Data(TString f,TString u)
{
 
 const char* name=GetName();
 const char* title=GetTitle();
 cout << " *" << ClassName() << "::Data* Id : " << GetUniqueID();
 if (strlen(name))  cout << " Name : " << GetName();
 if (strlen(title)) cout << " Title : " << GetTitle();
 cout << endl;
 
 // Provide an overview of the stored devices
 ShowDevices(0);
 if (GetNdevices(kFALSE))
 {
  cout << " More detailed info may be obtained by invokation of ShowDevices()." << endl;
  cout << " For the data of these contained devices, please use the corresponding investigation tools." << endl;
 }
 
 cout << " === Data of the current detector unit object ===" << 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);
 
 // Provide an overview of the stored hits
 Int_t nhits=GetNhits();
 if (nhits)
 {
  cout << " The following " << nhits << " hits are registered for this object : " << endl;
  ShowHit(0,f,u);
 }
 else
 {
  cout << " No hits have been registered for this object." << endl;
 }
} 

void NcDetectorUnit::ShowDevices(Int_t mode,Bool_t header)
{
 
 ShowDevices("*",mode,header);
}

void NcDetectorUnit::ShowDevices(TString classname,Int_t mode,Bool_t header)
{
 
 Bool_t follow=kFALSE;
 if (mode==2) follow=kTRUE;
 
 Int_t ndevs=GetNdevices(classname,follow);
 
 if (header)
 {
  cout << " *" << ClassName() <<"::ShowDevices* For mode=" << mode << " there are in total " << ndevs;
  if (classname!="*") cout << " " << classname << " (derived)";
  cout << " devices found." << endl;
 }
 
 if (classname=="*") classname="NcDevice";
 
 ShowDevicesTree(classname,mode);
}

void NcDetectorUnit::ShowDevicesTree(TString classname,Int_t mode,NcDetectorUnit* unit)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (!unit) unit=this;
 
 TObjArray units;
 
 TString name=unit->GetName();
 
 TString type="NcDetectorUnit";
 if (unit->InheritsFrom("NcDetector")) type="NcDetector";
 
 Int_t ndevs=unit->GetNdevices(kFALSE);
 if (!ndevs)
 {
  cout << " No devices present for " << type << " : " << name << endl;
  return;
 }
 
 Int_t ndevs2=unit->GetNdevices(classname,kFALSE);
 
 if (mode<2)
 {
  cout << " There are " << ndevs2;
  if (classname!="NcDevice") cout << " " << classname << " (derived)";
  cout << " devices available for the " << type << " : " << name << endl;
  if (!mode) return;
 }
 
 if (ndevs2)
 {
  cout << " === The following " << ndevs2;
  if (classname!="NcDevice") cout << " " << classname << " (derived)";
  cout << " devices are available for the " << type << " : " << name << endl;
 }
 
 Int_t nd=0;
 Int_t nh=0;
 Int_t nw=0;
 Int_t ns=0;
 NcDevice* dev=0;
 NcDetectorUnit* du=0;
 for (Int_t i=1; i<=ndevs; i++)
 {
  dev=unit->GetDevice(i);
 
  if (!dev) continue;
 
  if (dev->InheritsFrom(classname))
  {
   type="NcDevice";
   if (dev->InheritsFrom("NcDetectorUnit")) type="NcDetectorUnit";
   if (dev->InheritsFrom("NcDetector")) type="NcDetector";
   name=dev->GetName();
   cout << " Device number : " << i;
   cout << " Class : " << dev->ClassName();
   if (type!=(dev->ClassName())) cout << " (" << type << ")";
   cout << " Id : " << dev->GetUniqueID();
   if (name!="") cout << " Name : " << name;
   du=0;
   if (dev->InheritsFrom("NcDetectorUnit"))
   {
    du=(NcDetectorUnit*)dev;
    nd=du->GetNdevices(kFALSE);
    if (nd) cout << " Ndevices : " << nd;
   }
   nh=dev->GetNhits();
   if (nh) cout << " Nhits : " << nh;
   nw=dev->GetNwaveforms();
   if (nw) cout << " Nwaveforms : " << nw;
   ns=dev->GetNsamples();
   if (ns) cout << " Nsamples : " << ns;
   cout << endl;
  }
 
  if (mode==2 && dev->InheritsFrom("NcDetectorUnit")) units.Add(dev);
 }
 
 // Recursive invokation of the encountered detector units
 for (Int_t i=0; i<units.GetEntries(); i++)
 {
  du=(NcDetectorUnit*)units.At(i);
  if (du) ShowDevicesTree(classname,mode,du);
 }
}

Int_t NcDetectorUnit::GetNhitsDevices(TString classname,Bool_t follow,Bool_t inc)
{
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 GetHitsDevices(classname,follow,inc,&hits);
 Int_t nhits=hits.GetEntries();
 return nhits;
}

TObjArray* NcDetectorUnit::GetHitsDevices(TString classname,Bool_t follow,Bool_t inc,TObjArray* hits,TString name,Int_t mode,Int_t opt)
{
 
 if (classname=="*") classname="NcDevice";
 
 LoadHits(classname,follow,inc,hits);
 
 // Check for further hit selection criteria
 if (name!="none")
 {
  TObjArray* selected=hits;
  if (!selected) selected=fThits;
  TObjArray ahits(*selected);
  GetHits(*selected,name,mode,opt,&ahits);
 }
 
 if (hits)
 {
  return 0;
 }
 else
 {
  return fThits;
 }
}

NcSignal* NcDetectorUnit::GetIdHit(Int_t id,TString classname,Bool_t follow,Bool_t inc)
{
 
 if (id<0) return 0;
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 LoadHits(classname,follow,inc,&hits);
 
 Int_t nhits=hits.GetEntries();
 
 if (!nhits) return 0;
 
 NcSignal* sx=0;
 Int_t sid=0;
 for (Int_t i=0; i<nhits; i++)
 {
  sx=(NcSignal*)hits.At(i);
  if (sx)
  {
   sid=sx->GetUniqueID();
   if (id==sid) return sx;
  }
 }
 return 0; // No matching id found
}

void NcDetectorUnit::ShowHits(TString classname,Bool_t follow,Bool_t inc,Int_t mode,TString f,TString u)
{
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 LoadHits(classname,follow,inc,&hits);
 
 Int_t nhits=hits.GetEntries();
 
 cout << " *" << ClassName() << "::ShowHits* There are " << nhits
      << " hits recorded for device class " << classname << endl;
 
 if (!nhits || !mode) return;
 
 NcPosition r;
 for (Int_t i=0; i<hits.GetEntries(); i++)
 {
  NcSignal* sx=(NcSignal*)hits.At(i);
  if (sx) sx->Data(f,u);
  if (mode==2)
  {
   NcDevice* dev=(NcDevice*)sx->GetDevice();
   if (!dev) continue;
   r=dev->GetPosition();
   cout << "   Device Position";
   r.Data(f,u);
  }
 }
}

TObjArray* NcDetectorUnit::SortHits(TString classname,Bool_t follow,Bool_t inc,Int_t idx,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (ordered) ordered->Clear();
 
 if (idx<=0 || abs(mode)!=1) return 0;
 
 TObjArray hits;
 LoadHits(classname,follow,inc,&hits);
 
 TObjArray* arr=SortHits(idx,mode,&hits,mcal,deadcheck,ordered);
 
 if (ordered) return 0;
 
 if (fThits)
 {
  delete fThits;
  fThits=0;
 }
 if (arr) fThits=new TObjArray(*arr);
 return fThits;
}

TObjArray* NcDetectorUnit::SortHits(TString classname,Bool_t follow,Bool_t inc,TString name,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (ordered) ordered->Clear();
 
 if (abs(mode)!=1) return 0;
 
 TObjArray hits;
 LoadHits(classname,follow,inc,&hits);
 
 TObjArray* arr=SortHits(name,mode,&hits,mcal,deadcheck,ordered);
 
 if (ordered) return 0;
 
 if (fThits)
 {
  delete fThits;
  fThits=0;
 }
 if (arr) fThits=new TObjArray(*arr);
 return fThits;
}

void NcDetectorUnit::DisplayHits(TString classname,Bool_t follow,Bool_t inc,Int_t idx,Float_t scale,Int_t dp,Int_t mode,Int_t mcol)
{
 
 if (idx<=0) return;
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 GetHitsDevices(classname,follow,inc,&hits);
 
 NcDevice* dev=new NcDevice();
 dev->DisplayHits(idx,scale,&hits,dp,mode,mcol);
 
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
 fDisplay=dev;
}

void NcDetectorUnit::DisplayHits(TString classname,Bool_t follow,Bool_t inc,TString name,Float_t scale,Int_t dp,Int_t mode,Int_t mcol)
{
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 GetHitsDevices(classname,follow,inc,&hits,name,1);
 
 NcDevice* dev=new NcDevice();
 dev->DisplayHits(name,scale,&hits,dp,mode,mcol);
 
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
 fDisplay=dev;
}

TObjArray* NcDetectorUnit::SortDevices(TString classname,Bool_t follow,Bool_t inc,TString name,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (ordered) ordered->Clear();
 
 TObjArray hits;
 SortHits(classname,follow,inc,name,mode,mcal,deadcheck,&hits);
 
 TObjArray* devs=SortDevices(&hits,"*",0,mcal,deadcheck,ordered);
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return devs;
 }
}

TObjArray* NcDetectorUnit::SortDevices(TString classname,Bool_t follow,Bool_t inc,Int_t idx,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (ordered) ordered->Clear();
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 SortHits(classname,follow,inc,idx,mode,mcal,deadcheck,&hits);
 
 TObjArray* devs=SortDevices(&hits,0,0,mcal,deadcheck,ordered);
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return devs;
 }
}

TObjArray* NcDetectorUnit::SortDevices(TObjArray* hits,TString name,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (ordered)
 {
  ordered->Clear();
 }
 else
 {
  if (fOrdered)
  {
   fOrdered->Clear();
  }
  else
  {
   fOrdered=new TObjArray();
  }
 }
 
 if (!hits) return 0;
 
 TObjArray* sorthits=new TObjArray(*hits);
 if (mode) SortHits(name,mode,hits,mcal,deadcheck,sorthits);
 
 TObjArray* arr=0; // Generic array pointer to be used in the logic below
 
 if (ordered)
 {
  arr=ordered;
 }
 else
 {
  arr=fOrdered;
 } 
 
 Int_t nhits=sorthits->GetEntries();
 Int_t exist=0;
 for (Int_t ih=0; ih<nhits; ih++)
 {
  NcSignal* sx=(NcSignal*)sorthits->At(ih);
  if (!sx) continue;
  NcDevice* dx=sx->GetDevice();
  exist=0;
  for (Int_t id=0; id<arr->GetEntries(); id++)
  {
   NcDevice* odx=(NcDevice*)arr->At(id);
   if (dx==odx)
   {
    exist=1;
    break;
   }
  }
  if (!exist) arr->Add(dx);
 }
 
 delete sorthits;
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return fOrdered;
 }
}

TObjArray* NcDetectorUnit::SortDevices(TObjArray* hits,Int_t idx,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 if (ordered)
 {
  ordered->Clear();
 }
 else
 {
  if (fOrdered)
  {
   fOrdered->Clear();
  }
  else
  {
   fOrdered=new TObjArray();
  }
 }
 
 if (!hits) return 0;
 
 TObjArray* sorthits=new TObjArray(*hits);
 if (mode) SortHits(idx,mode,hits,mcal,deadcheck,sorthits);
 
 TObjArray* arr=0; // Generic array pointer to be used in the logic below
 
 if (ordered)
 {
  arr=ordered;
 }
 else
 {
  arr=fOrdered;
 } 
 
 Int_t nhits=sorthits->GetEntries();
 Int_t exist=0;
 for (Int_t ih=0; ih<nhits; ih++)
 {
  NcSignal* sx=(NcSignal*)sorthits->At(ih);
  if (!sx) continue;
  NcDevice* dx=sx->GetDevice();
  exist=0;
  for (Int_t id=0; id<arr->GetEntries(); id++)
  {
   NcDevice* odx=(NcDevice*)arr->At(id);
   if (dx==odx)
   {
    exist=1;
    break;
   }
  }
  if (!exist) arr->Add(dx);
 }
 
 delete sorthits;
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return fOrdered;
 }
}

void NcDetectorUnit::LoadHits(TString classname,Bool_t follow,Bool_t inc,TObjArray* hits,NcDetectorUnit* unit)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (!unit) // Direct invokation, not recursive
 {
  unit=this;
 
  if (hits)
  {
   hits->Clear();
  }
  else
  {
   if (fThits)
   {
    fThits->Clear();
   }
   else
   {
    fThits=new TObjArray();
   }
  }
 }
 
 NcSignal* sx=0;
 if (inc && unit->InheritsFrom(classname))
 {
  for (Int_t ih=1; ih<=unit->GetNhits(); ih++)
  {
   sx=unit->GetHit(ih);
   if (!sx) continue;
   if (hits)
   {
    hits->Add(sx);
   }
   else
   {
    fThits->Add(sx);
   }
  }
 }
 
 TObjArray units;
 
 NcDevice* dev=0;
 NcDetectorUnit* du=0;
 for (Int_t idev=1; idev<=unit->GetNdevices(kFALSE); idev++)
 {
  dev=unit->GetDevice(idev);
  if (!dev) continue;
 
  if (follow && dev->InheritsFrom("NcDetectorUnit")) units.Add(dev);
 
  if (!(unit->InheritsFrom(classname)) && !(dev->InheritsFrom(classname))) continue;
  
  for (Int_t ih=1; ih<=dev->GetNhits(); ih++)
  {
   sx=dev->GetHit(ih);
   if (!sx) continue;
   if (hits)
   {
    hits->Add(sx);
   }
   else
   {
    fThits->Add(sx);
   }
  }
 }
 
 // Recursive invokation of the encountered detector units
 for (Int_t i=0; i<units.GetEntries(); i++)
 {
  du=(NcDetectorUnit*)units.At(i);
  if (du) LoadHits(classname,follow,inc,hits,du);
 }
}

void NcDetectorUnit::LoadDevices(TString classname,Bool_t follow,TObjArray* devs,NcDetectorUnit* unit)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (!unit) // Direct invokation, not recursive
 {
  unit=this;
 
  if (devs)
  {
   devs->Clear();
  }
  else
  {
   if (fDevs)
   {
    fDevs->Clear();
   }
   else
   {
    fDevs=new TObjArray();
   }
  }
 }
 
 TObjArray units;
 
 Int_t ndevs=unit->GetNdevices(kFALSE);
 
 if (!ndevs) return;
 
 NcDevice* dev=0;
 NcDetectorUnit* du=0;
 for (Int_t i=1; i<=ndevs; i++)
 {
  dev=unit->GetDevice(i);
 
  if (!dev) continue;
 
  if (follow && dev->InheritsFrom("NcDetectorUnit")) units.Add(dev);
 
  if (dev->InheritsFrom(classname))
  {
   if (devs)
   {
    devs->Add(dev);
   }
   else
   {
    fDevs->Add(dev);
   }
  }
 }
 
 // Recursive invokation of the encountered detector units
 for (Int_t i=0; i<units.GetEntries(); i++)
 {
  du=(NcDetectorUnit*)units.At(i);
  if (du) LoadDevices(classname,follow,devs,du);
 }
}

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