IceEvent.cxx

Go to the documentation of this file.

 
#include "IceEvent.h"
#include "Riostream.h"
 
ClassImp(IceEvent); // Class implementation to enable ROOT I/O
 
IceEvent::IceEvent() : NcEvent()
{
 
 fStrings=0;
}

IceEvent::~IceEvent()
{
 
 if (fStrings)
 {
  delete fStrings;
  fStrings=0;
 }
}

IceEvent::IceEvent(const IceEvent& evt) : NcEvent(evt)
{
 
 fStrings=0;
}

void IceEvent::Reset()
{
 
 NcEvent::Reset();
 
 if (fStrings)
 {
  delete fStrings;
  fStrings=0;
 }
}

Int_t IceEvent::GetNstrings(TString classname)
{
 
 // Fetch all fired modules of the specified class for this event
 TObjArray* mods=GetDevices(classname);
 if (!mods) return 0;
 Int_t nmods=mods->GetEntries();
 if (!nmods) return 0;
 
 // Check for the string ids of the good fired modules
 if (!fStrings) fStrings=new TArrayI(200);
 fStrings->Reset();
 Int_t idxmax=0;
 Int_t nstrings=0;
 Int_t jstring=0;
 Int_t match=0;
 for (Int_t imod=0; imod<nmods; imod++)
 {
  IceGOM* omx=(IceGOM*)mods->At(imod);
  if (!omx) continue;
  if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
 
  // Update the number of fired strings
  jstring=omx->GetString();
  match=0;
  idxmax=nstrings;
  for (Int_t idx=0; idx<idxmax; idx++)
  {
   if (jstring==fStrings->At(idx))
   {
    match=1;
    break;
   }
  } 
  if (!match) // String number was not present in array
  {
   nstrings++;
   fStrings->AddAt(jstring,nstrings-1);
  }
 }
 
 return nstrings; 
}

Int_t IceEvent::GetNstrings(NcTrack& t,TString classname)
{
 
 // Fetch all associated signals for this track
 Int_t nh=t.GetNsignals();
 if (!nh) return 0;
 
 // Check for the string ids of the associated good fired modules of the specified class
 if (!fStrings) fStrings=new TArrayI(200);
 fStrings->Reset();
 Int_t idxmax=0;
 Int_t nstrings=0;
 Int_t jstring=0;
 Int_t match=0;
 for (Int_t ih=1; ih<=nh; ih++)
 {
  NcSignal* sx=t.GetSignal(ih);
  if (!sx) continue;
  NcDevice* dev=sx->GetDevice();
  if (!dev) continue;
  if (!(dev->InheritsFrom(classname.Data()))) continue;
  IceGOM* omx=(IceGOM*)dev;
 
  // Update the number of fired strings
  jstring=omx->GetString();
  match=0;
  idxmax=nstrings;
  for (Int_t idx=0; idx<idxmax; idx++)
  {
   if (jstring==fStrings->At(idx))
   {
    match=1;
    break;
   }
  } 
  if (!match) // String number was not present in array
  {
   nstrings++;
   fStrings->AddAt(jstring,nstrings-1);
  }
 }
 
 return nstrings; 
}

Int_t IceEvent::GetNstrings(NcJet& j,TString classname)
{
 
 Int_t ntk=j.GetNtracks();
 if (!ntk) return 0;
 
 if (!fStrings) fStrings=new TArrayI(200);
 fStrings->Reset();
 Int_t idxmax=0;
 Int_t nstrings=0;
 Int_t jstring=0;
 Int_t match=0;
 Int_t nh=0;
 for (Int_t itk=1; itk<=ntk; itk++)
 {
  NcTrack* tx=j.GetTrack(itk);
  if (!tx) continue;
 
  // Fetch all associated signals for this track
  nh=tx->GetNsignals();
  if (!nh) return 0;
 
  // Check for the string ids of the associated good fired modules of the specified class
  for (Int_t ih=1; ih<=nh; ih++)
  {
   NcSignal* sx=tx->GetSignal(ih);
   if (!sx) continue;
   NcDevice* dev=sx->GetDevice();
   if (!dev) continue;
   if (!(dev->InheritsFrom(classname.Data()))) continue;
   IceGOM* omx=(IceGOM*)dev;
 
   // Update the number of fired strings
   jstring=omx->GetString();
   match=0;
   idxmax=nstrings;
   for (Int_t idx=0; idx<idxmax; idx++)
   {
    if (jstring==fStrings->At(idx))
    {
     match=1;
     break;
    }
   } 
   if (!match) // String number was not present in array
   {
    nstrings++;
    fStrings->AddAt(jstring,nstrings-1);
   }
  } // End of loop over the track hits
 } // End of loop over the tracks
 
 return nstrings; 
}

Int_t IceEvent::GetNmodules(NcTrack& t,TString classname)
{
 
 TObjArray* hits=t.GetSignals(classname,1);
 if (!hits) return 0;
 
 Int_t nmods=GetNdevices(classname.Data(),hits);
 return nmods;
}

Int_t IceEvent::GetNmodules(NcJet& j,TString classname)
{
 
 TObjArray* hits=j.GetSignals(classname,1);
 if (!hits) return 0;
 
 Int_t nmods=GetNdevices(classname.Data(),hits);
 return nmods;
}

Int_t IceEvent::GetStringMax(TString classname,Int_t* id,Float_t* x,Float_t* y)
{
 
 // Reset the values of the return arguments
 if (id) *id=0;
 if (x) *x=0;
 if (y) *y=0;
 
 // Fetch all fired modules of the specified class for this event
 TObjArray* mods=GetDevices(classname);
 if (!mods) return 0;
 Int_t nmods=mods->GetEntries();
 if (!nmods) return 0;
 
 // Array for the string ids of the good fired modules
 if (!fStrings) fStrings=new TArrayI(200);
 fStrings->Reset();
 
 Int_t ncount=0;
 Int_t nmax=0;
 Int_t idmax=0;
 Float_t xmax=0;
 Float_t ymax=0;
 Float_t scale=0;
 Int_t jstring=0;
 for (Int_t imod=0; imod<nmods; imod++)
 {
  IceGOM* omx=(IceGOM*)mods->At(imod);
  if (!omx) continue;
  if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
 
  // Update the count for the corresponding string
  jstring=omx->GetString();
  ncount=fStrings->At(jstring);
  ncount++;
  fStrings->AddAt(ncount,jstring);
  if (ncount>nmax)
  {
   idmax=jstring;
   scale=omx->GetUnitScale();
   xmax=float(omx->GetX(1,"car"))*scale;
   ymax=float(omx->GetX(2,"car"))*scale;
   nmax=ncount;
   fStrings->AddAt(nmax,0);
  }
 }
 
 if (id) *id=idmax;
 if (x) *x=xmax;
 if (y) *y=ymax;
 
 return nmax; 
}

Float_t IceEvent::GetTriggerTime(TString trigname,TObjArray* arr,Int_t slc,TArrayF* peaks) const
{
 
 NcSample times;
 times.SetStoreMode(1);
 TString tname;
 Float_t ttime=0;
 NcSignal* sx=0;
 IceGOM* omx=0;
 TObjArray* oms=0;
 TObjArray* hits=0;
 Float_t time=0;
 Float_t tfirst=999999;
 Float_t tlast=-999999;
 Float_t tlow=0;
 Float_t tup=0;
 Float_t dtbin=500; // Bin size in ns for peak search histo
 Int_t nbins=0;
 
 // Detect from inheritance whether "arr" contains optical modules or hits
 if (arr)
 {
  TObject* obj=arr->At(0);
  if (obj)
  {
   if (obj->InheritsFrom("IceGOM"))
   {
    oms=arr;
   }
   else
   {
    hits=arr;
   }
  }
 }
 
 if (!arr) // Trigger time derived from trigger data
 {
  NcDevice* tdev=(NcDevice*)GetDevice("Trigger");
  if (!tdev) return 0;
 
  if (trigname=="Average") // Take median triggertime
  {
   for (Int_t itrig=1; itrig<=tdev->GetNhits(); itrig++)
   {
    NcSignal* trig=tdev->GetHit(itrig);
    ttime=0;
    if (trig)
    {
     // Don't take the GLOBAL triggers into account.
     // They are just there for administrative purposes.
     tname=trig->GetName();
     if (tname.Contains("GLOBAL")) continue;
 
     ttime=trig->GetSignal("trig_pulse_le");
     times.Enter(ttime);
    } 
   }
  ttime=times.GetMedian(1); 
  }
  else // Take triggertime from the specified trigger
  {
   NcSignal* trig=tdev->GetHit(trigname);
   if (trig) ttime=trig->GetSignal("trig_pulse_le");
  }
 }
 
 if (oms) // Trigger time from array of optical modules via (median of) recorded hit times
 {
  for (Int_t iom=0; iom<oms->GetEntries(); iom++)
  {
   omx=(IceGOM*)oms->At(iom);
   if (!omx) continue;
   for (Int_t ih=1; ih<=omx->GetNhits(); ih++)
   {
    sx=omx->GetHit(ih);
    if (!sx) continue;
    if (sx->GetDeadValue("LE")) continue;
 
    ttime=sx->GetSignal("LE",7);
    if (ttime<tfirst) tfirst=ttime;
    if (ttime>tlast) tlast=ttime;
 
    if (!slc && sx->GetSignal("SLC")>0.5) continue;
 
    times.Enter(ttime);
   }
  }
  ttime=times.GetMedian(1);
 }
 
 if (hits) // Trigger time from array of hits via (median of) recorded hit times
 {
  for (Int_t ih=0; ih<hits->GetEntries(); ih++)
  {
   sx=(NcSignal*)hits->At(ih);
   if (!sx) continue;
   if (sx->GetDeadValue("LE")) continue;
 
   ttime=sx->GetSignal("LE",7);
   if (ttime<tfirst) tfirst=ttime;
   if (ttime>tlast) tlast=ttime;
 
   if (!slc && sx->GetSignal("SLC")>0.5) continue;
 
   times.Enter(ttime);
  }
  ttime=times.GetMedian(1);
 }
 
 if (peaks)
 {
  peaks->Set(1);
  peaks->AddAt(ttime,0);
 }
 
 Int_t ntimes=times.GetN();
 if (peaks && tlast>tfirst && ntimes>1)
 {
  tlow=tfirst-dtbin;
  tup=tlast+dtbin;
  nbins=int((tup-tlow)/dtbin);
  TH1F thist("thist","hit times",nbins,tlow,tup);
  for (Int_t it=1; it<=ntimes; it++)
  {
   time=times.GetEntry(it,1);
   thist.Fill(time);
  }
// Next line modified because of an incompatible change in ROOT6
//@@@  TSpectrum spec;
  NcSpectrum spec;
  spec.SetDeconIterations(100);
  Int_t oldlevel=gErrorIgnoreLevel;
  gErrorIgnoreLevel=kFatal; // Suppress all (TSpectrum c.q. NcSpectrum) error and warning messages
  Int_t npeaks=spec.Search(&thist,1,"goff",0.3);
  gErrorIgnoreLevel=oldlevel; // Re-activate previous info level
  if (npeaks)
  {
   peaks->Set(npeaks);
   Float_t* specarr=spec.GetPositionX();
   for (Int_t ip=0; ip<npeaks; ip++)
   {
    peaks->AddAt(specarr[ip],ip);
   }
  }
 }
 
 return ttime;
}

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