NcEvent.cxx

Go to the documentation of this file.

 
#include "NcEvent.h"
#include "Riostream.h"
 
ClassImp(NcEvent); // Class implementation to enable ROOT I/O
 
NcEvent::NcEvent() : NcVertex(),NcTimestamp()
{
 
 fRun=0;
 fEvent=0;
 fWeight=1;
 fSelectLevel=0;
 fDetector=0;
 fDevices=0;
 fDevCopy=0;
 fHits=0;
 fOrdered=0;
 fDisplay=0;
 fDevs=0;
}

NcEvent::NcEvent(Int_t n) : NcVertex(n),NcTimestamp()
{
 
 if (n<=0)
 {
  cout << " *** This NcVertex initialisation was invoked via the NcEvent ctor." << endl;
 }
 fRun=0;
 fEvent=0;
 fWeight=1;
 fSelectLevel=0;
 fDetector=0;
 fDevices=0;
 fDevCopy=0;
 fHits=0;
 fOrdered=0;
 fDisplay=0;
 fDevs=0;
}

NcEvent::~NcEvent()
{
 
 if (fDetector)
 {
  if (fDevCopy) delete fDetector;
  fDetector=0;
 }
 
 if (fDevices)
 {
  delete fDevices;
  fDevices=0;
 }
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
 if (fDevs)
 {
  delete fDevs;
  fDevs=0;
 }
}

NcEvent::NcEvent(const NcEvent& evt) : NcVertex(evt),NcTimestamp(evt)
{
 
 fRun=evt.fRun;
 fEvent=evt.fEvent;
 fWeight=evt.fWeight;
 fSelectLevel=evt.fSelectLevel;
 fDevCopy=evt.fDevCopy;
 
 fHits=0;
 fOrdered=0;
 fDisplay=0;
 fDevs=0;
 
 fDetector=0;
 NcDetector* dx=evt.fDetector;
 if (dx)
 {
  if (fDevCopy)
  {
   fDetector=(NcDetector*)dx->Clone();
  }
  else
  {
   fDetector=dx;
  }
 }
 
 fDevices=0;
 Int_t ndevs=0;
 if (evt.fDevices) ndevs=(evt.fDevices)->GetEntries();
 if (ndevs)
 {
  fDevices=new TObjArray(ndevs);
  if (fDevCopy) fDevices->SetOwner();
  for (Int_t i=1; i<=ndevs; i++)
  {
   NcDevice* dev=evt.GetDevice(i);
   if (dev)
   {
    if (fDevCopy)
    {
     fDevices->Add(dev->Clone());
    }
    else
    {
     fDevices->Add(dev);
    }
   }
  }
 }
}

void NcEvent::Reset()
{
 
 NcVertex::Reset();
 
 SetSystemTime();
 fRun=0;
 fEvent=0;
 fWeight=1;
 fSelectLevel=0;
 
 if (fDetector)
 {
  if (fDevCopy) delete fDetector;
  fDetector=0;
 }
 
 if (fDevices)
 {
  delete fDevices;
  fDevices=0;
 }
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (fOrdered)
 {
  delete fOrdered;
  fOrdered=0;
 }
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
 if (fDevs)
 {
  delete fDevs;
  fDevs=0;
 }
}

void NcEvent::SetOwner(Bool_t own)
{
 
 Int_t mode=1;
 if (!own) mode=0;
 if (fDetector) fDetector->SetDevCopy(mode);
 if (fDevices) fDevices->SetOwner(own);
 fDevCopy=mode;
 
 NcVertex::SetOwner(own);
}

void NcEvent::SetDayTime(TTimeStamp& stamp)
{
 
 Set(stamp.GetDate(),stamp.GetTime(),0,kTRUE,0);
}

void NcEvent::SetDayTime(TDatime& stamp)
{
 
 Set(stamp.GetDate(),stamp.GetTime(),0,kFALSE,0);
}

void NcEvent::SetRunNumber(Int_t run)
{
 
 fRun=run;
}

void NcEvent::SetEventNumber(Int_t evt)
{
 
 fEvent=evt;
}

void NcEvent::SetWeight(Double_t weight)
{
 
 fWeight=weight;
}

void NcEvent::SetSelectLevel(Int_t level)
{
 
 fSelectLevel=level;
}

TTimeStamp NcEvent::GetDayTime() const
{
 
 return (TTimeStamp)(*this);
}

Int_t NcEvent::GetRunNumber() const
{
 
 return fRun;
}

Int_t NcEvent::GetEventNumber() const
{
 
 return fEvent;
}

Double_t NcEvent::GetWeight() const
{
 
 return fWeight;
}

Int_t NcEvent::GetSelectLevel() const
{
 
 return fSelectLevel;
}

void NcEvent::SetProjectile(Int_t a,Int_t z,Double_t pnuc,Int_t id)
{
 
 Int_t newdev=0;
 
 NcDevice* beam=GetDevice("Beam");
 
 if (!beam)
 {
  beam=new NcDevice();
  beam->SetNameTitle("Beam","Beam and target specifications");
  newdev=1;
 }
 
 if (a || z)
 {
  beam->AddNamedSlot("Aproj");
  beam->SetSignal(a,"Aproj");
  beam->AddNamedSlot("Zproj");
  beam->SetSignal(z,"Zproj");
 }
 beam->AddNamedSlot("Pnucproj");
 beam->SetSignal(pnuc,"Pnucproj");
 if (id)
 {
  beam->AddNamedSlot("Idproj");
  beam->SetSignal(id,"Idproj");
 }
 
 if (newdev)
 {
  AddDevice(beam);
  if (fDevCopy) delete beam;
 }
}

void NcEvent::SetProjectile(Int_t a,Int_t z,Nc3Vector& p,Int_t id)
{
 
 Int_t newdev=0;
 
 NcDevice* beam=GetDevice("Beam");
 
 if (!beam)
 {
  beam=new NcDevice();
  beam->SetNameTitle("Beam","Beam and target specifications");
  newdev=1;
 }
 
 Double_t px=p.GetX(1,"car");
 Double_t py=p.GetX(2,"car");
 Double_t pz=p.GetX(3,"car");
 Double_t pnuc=p.GetNorm();
 
 if (a || z)
 {
  beam->AddNamedSlot("Aproj");
  beam->SetSignal(a,"Aproj");
  beam->AddNamedSlot("Zproj");
  beam->SetSignal(z,"Zproj");
 }
 beam->AddNamedSlot("Pnucproj");
 beam->SetSignal(pnuc,"Pnucproj");
 beam->AddNamedSlot("Pxnucproj");
 beam->SetSignal(px,"Pxnucproj");
 beam->AddNamedSlot("Pynucproj");
 beam->SetSignal(py,"Pynucproj");
 beam->AddNamedSlot("Pznucproj");
 beam->SetSignal(pz,"Pznucproj");
 if (id)
 {
  beam->AddNamedSlot("Idproj");
  beam->SetSignal(id,"Idproj");
 }
 
 if (newdev)
 {
  AddDevice(beam);
  if (fDevCopy) delete beam;
 }
}

Int_t NcEvent::GetProjectileA() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Aproj"));
 return val;
}

Int_t NcEvent::GetProjectileZ() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Zproj"));
 return val;
}

Double_t NcEvent::GetProjectilePnuc() const
{
 
 Double_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=beam->GetSignal("Pnucproj");
 return val;
}

Int_t NcEvent::GetProjectileId() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Idproj"));
 return val;
}

void NcEvent::SetTarget(Int_t a,Int_t z,Double_t pnuc,Int_t id)
{
 
 Int_t newdev=0;
 
 NcDevice* beam=GetDevice("Beam");
 
 if (!beam)
 {
  beam=new NcDevice();
  beam->SetNameTitle("Beam","Beam and target specifications");
  newdev=1;
 }
 
 if (a || z)
 {
  beam->AddNamedSlot("Atarg");
  beam->SetSignal(a,"Atarg");
  beam->AddNamedSlot("Ztarg");
  beam->SetSignal(z,"Ztarg");
 }
 beam->AddNamedSlot("Pnuctarg");
 beam->SetSignal(pnuc,"Pnuctarg");
 if (id)
 {
  beam->AddNamedSlot("Idtarg");
  beam->SetSignal(id,"Idtarg");
 }
 
 if (newdev)
 {
  AddDevice(beam);
  if (fDevCopy) delete beam;
 }
}

void NcEvent::SetTarget(Int_t a,Int_t z,Nc3Vector& p,Int_t id)
{
 
 Int_t newdev=0;
 
 NcDevice* beam=GetDevice("Beam");
 
 if (!beam)
 {
  beam=new NcDevice();
  beam->SetNameTitle("Beam","Beam and target specifications");
  newdev=1;
 }
 
 Double_t px=p.GetX(1,"car");
 Double_t py=p.GetX(2,"car");
 Double_t pz=p.GetX(3,"car");
 Double_t pnuc=p.GetNorm();
 
 if (a || z)
 {
  beam->AddNamedSlot("Atarg");
  beam->SetSignal(a,"Atarg");
  beam->AddNamedSlot("Ztarg");
  beam->SetSignal(z,"Ztarg");
 }
 beam->AddNamedSlot("Pnuctarg");
 beam->SetSignal(pnuc,"Pnuctarg");
 beam->AddNamedSlot("Pxnuctarg");
 beam->SetSignal(px,"Pxnuctarg");
 beam->AddNamedSlot("Pynuctarg");
 beam->SetSignal(py,"Pynuctarg");
 beam->AddNamedSlot("Pznuctarg");
 beam->SetSignal(pz,"Pznuctarg");
 if (id)
 {
  beam->AddNamedSlot("Idtarg");
  beam->SetSignal(id,"Idtarg");
 }
 
 if (newdev)
 {
  AddDevice(beam);
  if (fDevCopy) delete beam;
 }
}

Int_t NcEvent::GetTargetA() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Atarg"));
 return val;
}

Int_t NcEvent::GetTargetZ() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Ztarg"));
 return val;
}

Double_t NcEvent::GetTargetPnuc() const
{
 
 Double_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=beam->GetSignal("Pnuctarg");
 return val;
}

Int_t NcEvent::GetTargetId() const
{
 
 Int_t val=0;
 NcDevice* beam=GetDevice("Beam");
 if (beam) val=int(beam->GetSignal("Idtarg"));
 return val;
}

void NcEvent::HeaderData()
{
 
 const char* name=GetName();
 const char* title=GetTitle();
 cout << " *" << ClassName() << "::Data*";
 if (strlen(name))  cout << " Name : " << GetName();
 if (strlen(title)) cout << " Title : " << GetTitle();
 cout << endl;
 Date(1);
 cout << "  Run : " << fRun << " Event : " << fEvent
      << " Weight : " << fWeight << " SelectLevel : " << fSelectLevel << endl;
 ShowDevices(0,kFALSE);
 ShowTracks(0);
}

void NcEvent::Data(TString f,TString u)
{
 
 HeaderData();
 NcVertex::Data(f,u);
} 

void NcEvent::SetDetector(NcDetector d)
{
 
 if (fDetector)
 {
  cout << " *" << ClassName() << "::SetDetector* A detector structure is already present --> No action taken." << endl;
  return;
 }
 
 if (fDevices)
 {
  cout << " *" << ClassName() << "::SetDetector* Internal storage already contains devices --> No action taken." << endl;
  return;
 }
 
 // Store this detector structure
 if (fDevCopy)
 {
  fDetector=(NcDetector*)d.Clone();
 }
 else
 {
  fDetector=&d;
 }
} 

NcDetector* NcEvent::GetDetector() const
{
 
 return fDetector;
} 

void NcEvent::CreateDetector()
{
 
 NcDetector* d=new NcDetector("Detector","Default detector structure");
 if (fDevCopy) d->SetDevCopy(1);
 fDevCopy=1;
 fDetector=d;
}

Int_t NcEvent::GetNdevices() const
{
 
 Int_t ndevs=0;
 
 // Investigate the detector structure (if present)
 if (fDetector)
 {
  ndevs=fDetector->GetNdevices(kTRUE);
  return ndevs;
 }
 
 // Investigate the internal storage array (if present)
 // for backward compatibility with old data files
 if (fDevices) ndevs=fDevices->GetEntries();
 return ndevs;
} 

Int_t NcEvent::GetNdevices(TString classname,TObjArray* hits) const
{
 
 Int_t ndevs=0;
 
 // Investigate the detector structure (if present)
 if (fDetector)
 {
  ndevs=fDetector->GetNdevices(classname,kTRUE,hits);
  return ndevs;
 }
 
 // Investigate the internal storage array (if present)
 // for backward compatibility with old data files
 
 if (!hits) // Investigate the stored devices
 {
  for (Int_t idev=1; idev<=GetNdevices(); idev++)
  {
   NcDevice* dev=GetDevice(idev);
   if (!dev) continue;
   if (dev->InheritsFrom(classname)) ndevs++;
  }
 }
 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;
} 

void NcEvent::AddDevice(NcDevice& d)
{
 
 if (d.InheritsFrom("NcDetector"))
 {
  if (fDetector)
  {
   cout << " *" << ClassName() << "::AddDevice* A detector structure is already present --> No action taken." << endl;
  }
  else
  {
   NcDetector* dx=(NcDetector*)&d;
   SetDetector(*dx);
  }
  return;
 }
 
 // Create a default detector structure if needed
 if (!fDetector && !fDevices) CreateDetector();
 
 if (fDevices && d.InheritsFrom("NcDetectorUnit"))
 {
  cout << " *" << ClassName() << "::AddDevice* Storage of NcDetectorUnit not supported in backward compatibility mode." << endl;
  return;
 }
 
 // Use the NcDetector structure to store all devices
 if (fDetector)
 {
  fDetector->AddDevice(d);
  return;
 }
 
 // Use the old internal device storage for backward compatiblity
 if (!fDevices)
 {
  cout << " *" << ClassName() << "::AddDevice* Internal storage array created for backward compatibility." << endl;
  fDevices=new TObjArray();
  if (fDevCopy) fDevices->SetOwner();
 }
 
 // Add the device to the internal storage of this event
 if (fDevCopy)
 {
  fDevices->Add(d.Clone());
 }
 else
 {
  fDevices->Add(&d);
 }
}

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

void NcEvent::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 NcEvent::GetDevCopy() const
{
 
 return fDevCopy;
}

NcDevice* NcEvent::GetDevice(Int_t i) const
{
 
 if (fDetector)
 {
  return fDetector->GetDevice(i);
 }
 
 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* NcEvent::GetDevice(TString name) const
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  return fDetector->GetDevice(name,kTRUE);
 }
 
 // Investigate the internal storage array
 if (!fDevices)
 {
  return 0;
 }
 else
 {
  TString s;
  Int_t ndevs=fDevices->GetEntries();
  for (Int_t i=0; i<ndevs; i++)
  {
   NcDevice* dev=(NcDevice*)fDevices->At(i);
   if (dev)
   {
    s=dev->GetName();
    if (s == name) return dev;
   }
  }
 
  return 0; // No matching name found
 }
}

NcDevice* NcEvent::GetIdDevice(Int_t id,TObjArray* devs) const
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  return fDetector->GetIdDevice(id,kTRUE,devs);
 }
 
 // Investigate the internal storage aray
 TObjArray* arr=devs;
 if (!arr) arr=fDevices;
 
 if (!arr || id<0) return 0;
 
 Int_t idx=0;
 for (Int_t i=0; i<arr->GetSize(); i++)
 {
  TObject* obj=arr->At(i);
  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* NcEvent::GetIdDevice(Int_t id,TString classname) const
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  return fDetector->GetIdDevice(id,classname,kTRUE);
 }
 
 // Investigate the internal storage array
 if (!fDevices || id<0) return 0;
 
 if (classname=="*") classname="NcDevice";
 
 Int_t idx=0;
 for (Int_t i=0; i<fDevices->GetEntries(); i++)
 {
  NcDevice* dev=(NcDevice*)fDevices->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
}

void NcEvent::ShowDevices(Int_t mode,Bool_t header) const
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  fDetector->ShowDevices(mode,header);
  return;
 }
 
 // Investigate the internal device storage for backward compatiblity
 // with old data files
 Int_t ndevs=GetNdevices();
 if (ndevs)
 {
  if (!mode)
  {
   cout << " There are " << ndevs << " devices available." << endl; 
  }
  else
  {
   cout << " The following " << ndevs << " devices are available :" << endl; 
   Int_t nh=0;
   Int_t nw=0;
   Int_t ns=0;
   for (Int_t i=1; i<=ndevs; i++)
   {
    NcDevice* dev=GetDevice(i);
    if (dev)
    {
     const char* name=dev->GetName();
     cout << " Device number : " << i;
     cout << " Class : " << dev->ClassName() << " Id : " << dev->GetUniqueID();
     if (strlen(name)) cout << " Name : " << name;
     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;
    }
   }
  }
 }
 else
 {
  cout << " No devices present for this event." << endl;
 }
}

void NcEvent::ShowDevices(TString classname,Int_t mode,Bool_t header) const
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  fDetector->ShowDevices(classname,mode,header);
  return;
 }
 
 // Investigate the internal device storage for backward compatibility
 // with old data files
 if (classname=="*") classname="NcDevice";
 Int_t ndevs=GetNdevices();
 if (ndevs)
 {
  Int_t ndevs2=GetNdevices(classname);
  if (!mode || !ndevs2)
  {
   cout << " There are " << ndevs2 << " selected devices available." << endl; 
  }
  else
  {
   cout << " The following " << ndevs2 << " selected devices are available :" << endl; 
   Int_t nh=0,nw=0;
   for (Int_t i=1; i<=ndevs; i++)
   {
    NcDevice* dev=GetDevice(i);
    if (dev)
    {
     if (dev->InheritsFrom(classname))
     {
      const char* name=dev->GetName();
      cout << " Device number : " << i;
      cout << " Class : " << dev->ClassName() << " Id : " << dev->GetUniqueID();
      if (strlen(name)) cout << " Name : " << name;
      nh=dev->GetNhits();
      if (nh) cout << " Nhits : " << nh;
      nw=dev->GetNwaveforms();
      if (nw) cout << " Nwaveforms : " << nw;
      cout << endl;
     }
    }
   }
  }
 }
 else
 {
  cout << " No devices present for this event." << endl;
 }
}

TObjArray* NcEvent::GetDevices(TString classname,TObjArray* devices)
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  TObjArray* devs=fDetector->GetDevices(classname,1,devices);
  return devs;
 }
 
 // Investigate the internal device storage for backward compatibility
 // with old data files
 if (devices)
 {
  devices->Clear();
 }
 else
 {
  if (fDevs)
  {
   fDevs->Clear();
  }
  else
  {
   fDevs=new TObjArray();
  }
 }
 
 Int_t ndev=fDevices->GetEntries();
 for (Int_t idev=1; idev<=ndev; idev++)
 {
  NcDevice* dev=GetDevice(idev);
  if (!dev) continue;
 
  if (dev->InheritsFrom(classname))
  {
   if (devices)
   {
    devices->Add(dev);
   }
   else
   {
    fDevs->Add(dev);
   }
  }
 }
 
 if (devices)
 {
  return 0;
 }
 else
 {
  return fDevs;
 }
}

Int_t NcEvent::GetNhits(TString classname)
{
 
 Int_t nhits=0;
 
 // Investigate the detector structure
 if (fDetector)
 {
  nhits=fDetector->GetNhitsDevices(classname,kTRUE,kTRUE);
  return nhits;
 }
 
 // Investigate the internal storage for backward compatibility
 // with old data files
 if (classname=="*") classname="NcDevice";
 TObjArray hits;
 GetHits(classname,&hits);
 nhits=hits.GetEntries();
 return nhits;
}

TObjArray* NcEvent::GetHits(TString classname,TObjArray* hits,TString name,Int_t mode,Int_t opt)
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  TObjArray* arr;
  arr=fDetector->GetHitsDevices(classname,kTRUE,kTRUE,hits,name,mode,opt);
  return arr;
 }
 
 // Investigate the internal storage for backward compatibility
 // with old data files
 if (classname=="*") classname="NcDevice";
 
 LoadHits(classname,hits);
 
 // Check for further hit selection criteria
 if (name!="none")
 {
  NcDevice selector;
  TObjArray* selected=hits;
  if (!selected) selected=fHits;
  TObjArray ahits(*selected);
  selector.GetHits(*selected,name,mode,opt,&ahits);
 }
 
 if (hits)
 {
  return 0;
 }
 else
 {
  return fHits;
 }
}

NcSignal* NcEvent::GetIdHit(Int_t id,TString classname)
{
 
 if (id<0) return 0;
 
 NcSignal* sx=0;
 
 // Investigate the detector structure
 if (fDetector)
 {
  sx=fDetector->GetIdHit(id,classname,kTRUE,kTRUE);
  return sx;
 }
 
 // Investigate the internal storage array for backward compatibility
 // with old data files 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 LoadHits(classname,&hits);
 
 Int_t nhits=hits.GetEntries();
 
 if (!nhits) return 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 NcEvent::LoadHits(TString classname,TObjArray* hits)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (hits)
 {
  hits->Clear();
 }
 else
 {
  if (fHits)
  {
   fHits->Clear();
  }
  else
  {
   fHits=new TObjArray();
  }
 }
 
 for (Int_t idev=1; idev<=fDevices->GetEntries(); idev++)
 {
  NcDevice* dev=GetDevice(idev);
  if (!dev) continue;
 
  if (!(dev->InheritsFrom(classname))) continue;
  
  for (Int_t ih=1; ih<=dev->GetNhits(); ih++)
  {
   NcSignal* sx=dev->GetHit(ih);
   if (!sx) continue;
   if (hits)
   {
    hits->Add(sx);
   }
   else
   {
    fHits->Add(sx);
   }
  }
 }
}

TObjArray* NcEvent::SortHits(TString classname,Int_t idx,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  TObjArray* arr=fDetector->SortHits(classname,kTRUE,kTRUE,idx,mode,mcal,deadcheck,ordered);
  return arr;
 }
 
 // Investigate the internal storage array for backward compatibility
 // with old data files
 if (classname=="*") classname="NcDevice";
 
 if (ordered) ordered->Clear();
 
 if (idx<=0 || abs(mode)!=1) return 0;
 
 TObjArray hits;
 LoadHits(classname,&hits);
 
 NcDevice dev;
 TObjArray* arr=dev.SortHits(idx,mode,&hits,mcal,deadcheck,ordered);
 
 if (ordered) return 0;
 
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (arr) fHits=new TObjArray(*arr);
 return fHits;
}

TObjArray* NcEvent::SortHits(TString classname,TString name,Int_t mode,Int_t mcal,Int_t deadcheck,TObjArray* ordered)
{
 
 // Investigate the detector structure
 if (fDetector)
 {
  TObjArray* arr=fDetector->SortHits(classname,kTRUE,kTRUE,name,mode,mcal,deadcheck,ordered);
  return arr;
 }
 
 // Investigate the internal storage array for backward compatibility
 // with old data files
 if (classname=="*") classname="NcDevice";
 
 if (ordered) ordered->Clear();
 
 if (abs(mode)!=1) return 0;
 
 TObjArray hits;
 LoadHits(classname,&hits);
 
 NcDevice dev;
 TObjArray* arr=dev.SortHits(name,mode,&hits,mcal,deadcheck,ordered);
 
 if (ordered) return 0;
 
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (arr) fHits=new TObjArray(*arr);
 return fHits;
}

Nc3Vector NcEvent::GetHitPath(TObjArray* hits,Int_t pos) const
{
 
 NcDevice d;
 Nc3Vector v=d.GetHitPath(hits,pos);
 
 return v;
}

NcPosition NcEvent::GetCOG(TObjArray* hits,Int_t pos,TString slotname,Int_t mode) const
{
 
 NcDevice d;
 NcPosition cog=d.GetCOG(hits,pos,slotname,mode);
 
 return cog;
}

Double_t NcEvent::GetCVAL(TObjArray* hits,TString obsname,TString weightname,Int_t mode,Int_t type) const
{
 
 Double_t cval=0;
 
 NcDevice d;
 cval=d.GetCVAL(hits,obsname,weightname,mode,type);
 
 return cval;
}

void NcEvent::GetExtremes(TString classname,Float_t& vmin,Float_t& vmax,Int_t idx,Int_t mode,Int_t deadcheck)
{
 
 if (classname=="*") classname="NcDevice";
 
 if (idx<=0) return;
 
 TObjArray hits;
 GetHits(classname,&hits);
 
 NcDevice dev;
 dev.GetExtremes(vmin,vmax,idx,&hits,mode,deadcheck);
}

void NcEvent::GetExtremes(TString classname,Float_t& vmin,Float_t& vmax,TString name,Int_t mode,Int_t deadcheck)
{
 
 if (classname=="*") classname="NcDevice";
 
 TObjArray hits;
 GetHits(classname,&hits);
 
 NcDevice dev;
 dev.GetExtremes(vmin,vmax,name,&hits,mode,deadcheck);
}

void NcEvent::DisplayHits(TString classname,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;
 GetHits(classname,&hits);
 
 NcDevice* dev=new NcDevice();
 dev->DisplayHits(idx,scale,&hits,dp,mode,mcol);
 
 if (fDisplay)
 {
  delete fDisplay;
  fDisplay=0;
 }
 fDisplay=dev;
}

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

void NcEvent::ShowHits(TString classname,Int_t mode,TString f,TString u)
{
 
 if (classname=="*") classname="NcDevice";
 
 // Investigate the detector structure
 if (fDetector)
 {
  fDetector->ShowHits(classname,kTRUE,kTRUE,mode,f,u);
  return;
 }
 
 // Investigate the internal storage array for backward compatibility
 // with old data files
 TObjArray hits;
 GetHits(classname,&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* NcEvent::SortDevices(TString classname,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,name,mode,mcal,deadcheck,&hits);
 
 TObjArray* devs=SortDevices(&hits,"*",0,mcal,deadcheck,ordered);
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return devs;
 }
}

TObjArray* NcEvent::SortDevices(TString classname,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,idx,mode,mcal,deadcheck,&hits);
 
 TObjArray* devs=SortDevices(&hits,0,0,mcal,deadcheck,ordered);
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return devs;
 }
}

TObjArray* NcEvent::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);
 NcDevice dev;
 if (mode) dev.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* NcEvent::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);
 NcDevice dev;
 if (mode) dev.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;
 }
}

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