Also first (prototype) version of class IceDwalk introduced to perform
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 31 Oct 2005 15:32:38 +0000 (15:32 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 31 Oct 2005 15:32:38 +0000 (15:32 +0000)
                direct walk reconstruction. In the /macros directory an example job
                icedwalk.cc has been introduced.

RALICE/icepack/ICEHeaders.h
RALICE/icepack/ICELinkDef.h
RALICE/icepack/IceDwalk.cxx [new file with mode: 0644]
RALICE/icepack/IceDwalk.h [new file with mode: 0644]
RALICE/icepack/history.txt
RALICE/icepack/macros/icedwalk.cc [new file with mode: 0644]

index f1338b6..66e016b 100644 (file)
@@ -17,4 +17,5 @@
 #include "IceXtalk.h"
 #include "IceCalibrate.h"
 #include "IceCleanHits.h"
+#include "IceDwalk.h"
 
index bcf797e..b13d40e 100644 (file)
@@ -22,5 +22,6 @@
  #pragma link C++ class IceXtalk+;
  #pragma link C++ class IceCalibrate+;
  #pragma link C++ class IceCleanHits+;
+ #pragma link C++ class IceDwalk+;
 #endif
  
diff --git a/RALICE/icepack/IceDwalk.cxx b/RALICE/icepack/IceDwalk.cxx
new file mode 100644 (file)
index 0000000..338fad2
--- /dev/null
@@ -0,0 +1,541 @@
+/*******************************************************************************
+ * Copyright(c) 2003, IceCube Experiment at the South Pole. All rights reserved.
+ *
+ * Author: The IceCube RALICE-based Offline Project.
+ * Contributors are mentioned in the code where appropriate.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation strictly for non-commercial purposes is hereby granted
+ * without fee, provided that the above copyright notice appears in all
+ * copies and that both the copyright notice and this permission notice
+ * appear in the supporting documentation.
+ * The authors make no claims about the suitability of this software for
+ * any purpose. It is provided "as is" without express or implied warranty.
+ *******************************************************************************/
+
+// $Id$
+
+///////////////////////////////////////////////////////////////////////////
+// Class IceDwalk
+// TTask derived class to perform direct walk track reconstruction.
+// The procedure is based on the method described in the Amanda publication
+// in Nuclear Instruments and Methods A524 (2004) 179-180.
+// However, the Amanda method has been extended with the intention to
+// take also multiple (muon) tracks within 1 event into account.
+// This will not only provide a means to reconstruct muon bundles and
+// multiple track events in IceCube, but will also allow to reduce the
+// background of faked upgoing muons as a result of multiple downgoing
+// muons hitting the top and bottom parts of the detector. 
+// The various reconstruction steps are summarised as follows :
+//
+// 1) Construction of track elements (TE's).
+//    A track element is a straight line connecting two hits that
+//    appeared at some minimum distance d and within some maximum
+//    time difference dt.
+//    The default values for d and dt are given in eq. (20) of the
+//    NIM article, but can be modified by the appropriate Set functions.
+//    For dt a default margin of 30 ns is used (according to eq. (20)),
+//    but also this margin may be modified via the appropriate Set function.    
+//    The reference point r0 of the TE is taken as the center between
+//    the two hit positions and the TE timestamp t0 at the position r0
+//    is taken as the IceEvent timestamp increased by the average of the
+//    two hit times. So, all timestamps contain the overall IceEvent
+//    timestamp as a basis. This means that time differences can be
+//    obtained via the AliTimestamp facilities (supporting upto picosecond
+//    precision when available).
+//    The TE direction is given by the relative position of the two hits.
+//
+// 2) Each TE will obtain so called associated hits.
+//    A hit is associated to a TE when it fulfills both the conditions
+//
+//      -30 < tres < 300 ns
+//      dhit < 25*(tres+30)^(1/4) meter
+//
+//    tres : time residual
+//           Difference between the observed hit time and the time expected
+//           for a direct photon hit.     
+//    dhit : Distance between the hit and the TE
+//
+// 3) Construction of track candidates (TC's).
+//    These are TE's that fulfill both the conditions
+//
+//      nah >= 10
+//      sigmal >= 20 meter
+// 
+//    nah    : Number of associated hits.
+//    sigmal : rms variance of the distances between r0 and the point on
+//             the track which is closest to the various associated hits. 
+//
+// 4) Only track candidates are kept which fulfill the quality criterion
+//    (see eq. (21) in the NIM article)
+//
+//     qtc >= 0.7*qtcmax
+//
+//     qtc=min(nah,0.3*sigmal+7)
+//     qtcmax=max(qtc)
+//
+// 5) The surviving track candidates are clustered into jets when
+//    their directions are within a certain maximum opening angle.
+//    The default maximum opening angle is 15 degrees, but can be modified
+//    via the SetTangsep memberfunction.
+//
+// 6) The jets are merged when their directions are within
+//    a certain maximum opening angle. 
+//    The default maximum opening angle is half the TC maximum opening angle,
+//    but can be modified via the SetJangsep memberfunction.
+//    Note : Setting the maximum jet opening angle to <=0 will prevent
+//           the merging of jets.
+//
+// 7) The remaining jets are ordered w.r.t. decreasing number of tracks.
+//    Each remaining jet will provide the parameters (e.g. direction)
+//    for a reconstructed track.
+//    The track 3-momentum is set to the total jet 3-momentum, normalised
+//    to 1 GeV. The mass and charge of the track are left 0.
+//    The average of all the r0 and t0 values of the constituent TC's
+//    of the jet will provide the r0 and t0 of the track.
+//    All these tracks will be stored in the IceEvent structure with "IceDwalk"
+//    as the name of the track.
+//    Note : In case the maximum jet opening angle was specified <0,
+//           only the jet with the maximum number of tracks will appear
+//           as a reconstructed track in the IceEvent structure.
+//           This will allow comparison with the standard Sieglinde
+//           single track direct walk reconstruction results. 
+//    
+// For further details the user is referred to NIM A524 (2004) 169.
+//
+// Note : This algorithm works best on data which has been calibrated
+//        (IceCalibrate), cross talk corrected (IceXtalk) and cleaned
+//        from noise hits etc. (IceCleanHits).
+//
+//--- Author: Nick van Eijndhoven 07-oct-2005 Utrecht University
+//- Modified: NvE $Date$ Utrecht University
+///////////////////////////////////////////////////////////////////////////
+#include "IceDwalk.h"
+#include "Riostream.h"
+
+ClassImp(IceDwalk) // Class implementation to enable ROOT I/O
+
+IceDwalk::IceDwalk(const char* name,const char* title) : TTask(name,title)
+{
+// Default constructor.
+// The various reconstruction parameters are initialised to the values
+// as mentioned in NIM A524 (2004) 179-180.
+// The newly introduced angular separation parameter for jet merging
+// is initialised as half the value of the angular separation parameter
+// for track candidate clustering.    
+ fDmin=50;
+ fDtmarg=30;
+ fTangsep=15;
+ fJangsep=fTangsep/2.;
+}
+///////////////////////////////////////////////////////////////////////////
+IceDwalk::~IceDwalk()
+{
+// Default destructor.
+}
+///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetDmin(Float_t d)
+{
+// Set minimum hit distance (in m) to form a track element.
+// In the constructor the default has been set to 50 meter, in accordance
+// to eq.(20) of NIM A524 (2004) 179.
+ fDmin=d;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetDtmarg(Int_t dt)
+{
+// Set maximum hit time difference margin (in ns) for track elements.
+// In the constructor the default has been set to 30 ns, in accordance
+// to eq.(20) of NIM A524 (2004) 179.
+ fDtmarg=dt;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetTangsep(Float_t ang)
+{
+// Set angular separation (in deg) within which track candidates are
+// clustered into jets.
+// In the constructor the default has been set to 15 deg, in accordance
+// to NIM A524 (2004) 180.
+//
+// Note : This function also sets automatically the value of the angular
+//        separation within which jets are merged into 1 single track
+//        to ang/2.
+//        In order to specify a different jet merging separation angle,
+//        one has to invoke the memberfunction SetJangsep afterwards.
+ fTangsep=ang;
+ fJangsep=ang/2.;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetJangsep(Float_t ang)
+{
+// Set angular separation (in deg) within which jets are merged into 1
+// single track.
+// In the constructor the default has been set 7.5 deg, being half of the
+// value of the default track candidate clustering separation angle. 
+//
+// Notes :
+// -------
+// 1)  Setting ang=0 will prevent jet merging.
+//     Consequently, every jet will appear as a separate track in the
+//     reconstruction result.  
+// 2)  Setting ang<0 will prevent jet merging.
+//     In addition, only the jet with the maximum number of tracks will
+//     appear as a track in the reconstruction result.
+//     This situation resembles the standard Sieglinde direct walk processing
+//     and as such can be used to perform comparison studies.
+
+ fJangsep=ang;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceDwalk::Exec(Option_t* opt)
+{
+// Implementation of the direct walk track reconstruction.
+
+ TString name=opt;
+ AliJob* parent=(AliJob*)(gROOT->GetListOfTasks()->FindObject(name.Data()));
+
+ if (!parent) return;
+
+ IceEvent* evt=(IceEvent*)parent->GetObject("IceEvent");
+ if (!evt) return;
+
+ Float_t c=0.3;                // Light speed in vacuum in meters per ns
+ Float_t nice=1.33;            // Refractive index of ice
+ Float_t thetac=acos(1./nice); // Cherenkov angle (in radians)
+
+ // Storage of track elements with various time difference margins.
+ // temap(i,j) holds the i-th track element (TE) with a time difference margin
+ // of j*3 nanoseconds. Currently we use a maximum margin of 30 ns.
+ TObjArray tes;
+ tes.SetOwner();
+ AliObjMatrix temap;
+
+ Int_t* ntes=new Int_t[fDtmarg/3]; // Counter of TEs for each 3 ns margin slot
+ for (Int_t i=0; i<fDtmarg/3; i++)
+ {
+  ntes[i]=0;
+ }  
+
+ AliPosition r1;
+ AliPosition r2;
+ Ali3Vector r12;
+ AliPosition r0;
+ TObjArray hits1;
+ TObjArray hits2;
+ Int_t nh1,nh2;
+ AliSignal* sx1=0;
+ AliSignal* sx2=0;
+ Float_t dist=0;
+ Float_t t1,t2,dt,t0;
+ Float_t dtmax,dttest;
+ TObjArray hits;
+
+ // Check the hits of Amanda OM pairs for posible track elements.
+ // Also all the good hits are stored in the meantime (to save CPU time)
+ // for hit association with the various track elements lateron.
+ TObjArray* aoms=evt->GetDevices("IceAOM");
+ Int_t naoms=aoms->GetEntries();
+ AliTrack* te=0;
+ Int_t ite=0;
+ for (Int_t i1=0; i1<naoms; i1++) // First OM of the pair
+ {
+  IceGOM* omx1=(IceGOM*)aoms->At(i1);
+  if (!omx1) continue;
+  if (omx1->GetDeadValue("LE")) continue;
+  r1=omx1->GetPosition();
+  // Select all the good hits of this first OM
+  hits1.Clear();
+  for (Int_t j1=1; j1<=omx1->GetNhits(); j1++)
+  {
+   sx1=omx1->GetHit(j1);
+   if (!sx1) continue;
+   if (sx1->GetDeadValue("ADC") || sx1->GetDeadValue("LE") || sx1->GetDeadValue("TOT")) continue;
+   hits1.Add(sx1);
+   // Also store all good hits in the total hit array
+   hits.Add(sx1);
+  }
+
+  // No further pair to be formed with the last OM in the list 
+  if (i1==(naoms-1)) break;
+
+  nh1=hits1.GetEntries();
+  if (!nh1) continue;
+
+  for (Int_t i2=i1+1; i2<naoms; i2++) // Second OM of the pair
+  {
+   IceGOM* omx2=(IceGOM*)aoms->At(i2);
+   if (!omx2) continue;
+   if (omx2->GetDeadValue("LE")) continue;
+   r2=omx2->GetPosition();
+   r12=r2-r1;
+   dist=r12.GetNorm();
+   dtmax=dist/c+float(fDtmarg);
+   if (dist<=fDmin) continue;
+   // Select all the good hits of this second OM
+   hits2.Clear();
+   for (Int_t j2=1; j2<=omx2->GetNhits(); j2++)
+   {
+    sx2=omx2->GetHit(j2);
+    if (!sx2) continue;
+    if (sx2->GetDeadValue("ADC") || sx2->GetDeadValue("LE") || sx2->GetDeadValue("TOT")) continue;
+    hits2.Add(sx2);
+   }
+   nh2=hits2.GetEntries();
+   if (!nh2) continue;
+
+   // Check all hit pair combinations of these two OMs for possible track elements  
+   for (Int_t ih1=0; ih1<nh1; ih1++) // Hits of first OM
+   {
+    sx1=(AliSignal*)hits1.At(ih1);
+    if (!sx1) continue;
+    for (Int_t ih2=0; ih2<nh2; ih2++) // Hits of second OM
+    {
+     sx2=(AliSignal*)hits2.At(ih2);
+     if (!sx2) continue;
+     t1=sx1->GetSignal("LE",7);
+     t2=sx2->GetSignal("LE",7);
+     dt=t2-t1;
+     t0=(t1+t2)/2.;
+     if (dt && fabs(dt)<dtmax)
+     {
+      te=new AliTrack();
+      tes.Add(te);
+      ite++;
+      if (dt<0) r12*=-1.;
+      r0.SetPosition((r1+r2)/2.);
+      te->SetReferencePoint(r0);
+      te->SetTimestamp((AliTimestamp)*evt);
+      AliTimestamp* tsx=te->GetTimestamp();
+      tsx->Add(0,0,t0);
+      r12/=r12.GetNorm();
+      te->Set3Momentum(r12);
+      dttest=dtmax;
+      for (Int_t jt=fDtmarg/3; jt>0; jt--)
+      {
+       if (fabs(dt)>=dttest) break;
+       temap.EnterObject(ite,jt,te);
+       ntes[jt-1]++;
+       dttest-=3.;
+      }
+     }
+    }
+   }
+  } // end of loop over the second OM of the pair
+ } // end of loop over first OM of the pair
+
+ // Association of hits to the various track elements
+ // For the time being all track elements will be treated,
+ // but in a later stage one could select only the TE's of a certain
+ // 3 ns margin slot in the TE map to save CPU time.
+ Int_t nte=tes.GetEntries();
+ Int_t nh=hits.GetEntries();
+ Float_t d=0;
+ Ali3Vector p;
+ Float_t tgeo,tres;
+ AliSample levers;  // Statistics of the assoc. hit lever arms
+ AliSignal fit;     // Storage of Q value etc... for each track candidate
+ fit.SetSlotName("QTC",1);
+ fit.SetSlotName("SIGMAL",2);
+ Float_t qtc=0,qmax=0;
+ Int_t nah;      // Number of associated hits for a certain TE
+ Float_t sigmal; // The mean lever arm of the various associated hits
+ for (Int_t jte=0; jte<nte; jte++)
+ {
+  te=(AliTrack*)tes.At(jte);
+  if (!te) continue;
+  p=te->Get3Momentum();
+  AliTimestamp* tt0=te->GetTimestamp();
+  t0=evt->GetDifference(tt0,"ns");
+  AliPosition* tr0=te->GetReferencePoint();
+  levers.Reset();
+  for (Int_t jh=0; jh<nh; jh++)
+  {
+   sx1=(AliSignal*)hits.At(jh);
+   if (!sx1) continue;
+   IceGOM* omx=(IceGOM*)sx1->GetDevice();
+   if (!omx) continue;
+   r1=omx->GetPosition();
+   d=tr0->GetDistance(r1);
+   d*=sin(thetac);
+   r12=r1-(*tr0);
+   dist=p.Dot(r12)+d*tan(thetac);
+   tgeo=t0+dist/c;
+   t1=sx1->GetSignal("LE",7);
+   tres=t1-tgeo;
+
+   if (tres<-30 || tres>300 || d>25.*pow(tres+30.,0.25)) continue;
+
+   // Associate this hit to the TE
+   te->AddSignal(*sx1);
+   levers.Enter(d/tan(thetac));
+  }
+  // Quality check of the various TE's.
+  // Survivors will be called track candidates (TC's)
+  // and their Q quality value will be determined.
+  nah=te->GetNsignals();
+  sigmal=levers.GetSigma(1);
+  if (nah<10 || sigmal<20)  // Remove the TE's of poor quality
+  {
+   temap.RemoveObjects(te);
+   tes.RemoveAt(jte);
+   delete te;
+  }
+  else // Specify the Q factor for this TC
+  {
+   qtc=0.3*sigmal+7.;
+   if (qtc>nah) qtc=nah;
+   fit.SetSignal(qtc,"QTC");
+   fit.SetSignal(sigmal,"SIGMAL");
+   te->SetFitDetails(fit);
+   if (qtc>qmax) qmax=qtc;
+  }
+ }
+ tes.Compress();
+ nte=tes.GetEntries();
+
+ // Perform selection on Q value in case of multiple track candidates
+ for (Int_t jtc=0; jtc<nte; jtc++)
+ {
+  te=(AliTrack*)tes.At(jtc);
+  if (!te) continue;
+  sx1=(AliSignal*)te->GetFitDetails();
+  if (!sx1) continue;
+  qtc=sx1->GetSignal("QTC");
+  if (qtc<0.7*qmax)
+  {
+   temap.RemoveObjects(te);
+   tes.RemoveAt(jtc);
+   delete te;
+  }
+ } 
+ tes.Compress();
+ nte=tes.GetEntries();
+
+ // Cluster track candidates within a certain opening angle into jets. 
+ TObjArray jets;
+ jets.SetOwner();
+ AliTrack* te2=0;
+ Float_t ang=0;
+ for (Int_t jtc1=0; jtc1<nte; jtc1++)
+ {
+  te=(AliTrack*)tes.At(jtc1);
+  if (!te) continue;
+  AliJet* jx=new AliJet();
+  jx->AddTrack(te);
+  jets.Add(jx);
+  for (Int_t jtc2=0; jtc2<nte; jtc2++)
+  {
+   te2=(AliTrack*)tes.At(jtc2);
+   if (!te2) continue;
+   ang=te->GetOpeningAngle(*te2,"deg");
+   if (ang<fTangsep) jx->AddTrack(te2);
+  }
+ }
+
+ // Order the jets w.r.t. decreasing number of tracks
+ TObjArray* ordered=evt->SortJets(-1,&jets);
+ TObjArray jets2(*ordered);
+ Int_t njets=jets2.GetEntries();
+
+ // Merge jets within a certain opening to provide the final track(s).
+ AliJet* jx1=0;
+ AliJet* jx2=0;
+ if (fJangsep>0)
+ {
+  for (Int_t jet1=0; jet1<njets; jet1++)
+  {
+   jx1=(AliJet*)jets2.At(jet1);
+   if (!jx1) continue;
+   for (Int_t jet2=jet1+1; jet2<njets; jet2++)
+   {
+    jx2=(AliJet*)jets2.At(jet2);
+    if (!jx2) continue;
+    ang=jx1->GetOpeningAngle(*jx2,"deg");
+    if (ang<fJangsep)
+    {
+     for (Int_t jtk=1; jtk<=jx2->GetNtracks(); jtk++)
+     {
+      te=jx2->GetTrack(jtk);
+      if (!te) continue;
+      jx1->AddTrack(te);
+     }
+     jets2.RemoveAt(jet2);    
+    }
+   }
+  }
+  jets2.Compress();
+  njets=jets2.GetEntries();
+ }
+
+ // Store every jet as a reconstructed track in the event structure.
+ // The jet 3-momentum (normalised to 1) and the average r0 and t0
+ // of the constituent tracks will make up the final track parameters.
+ // All the associated hits of all the constituent tracks of the jet
+ // will be associated to the final track.
+ // In case the jet angular separation was set <0, only the jet with
+ // the maximum number of tracks (i.e. the first one in the array)
+ // will be used to form a track. This will allow comparison with
+ // the standard Sieglinde processing.
+ AliSample pos;
+ AliSample time;
+ AliPosition* ref=0;
+ AliTrack t; 
+ t.SetNameTitle("IceDwalk","Direct walk track");
+ t.SetTimestamp((AliTimestamp)*evt);
+ Float_t vec[3],err[3];
+ for (Int_t jet=0; jet<njets; jet++)
+ {
+  AliJet* jx=(AliJet*)jets2.At(jet);
+  if (!jx) continue;
+  evt->AddTrack(t);
+  AliTrack* trk=evt->GetTrack(evt->GetNtracks());
+  if (!trk) continue;
+  trk->SetId(evt->GetNtracks(1)+1);
+  p=jx->Get3Momentum();
+  p/=p.GetNorm();
+  trk->Set3Momentum(p);
+  pos.Reset();
+  time.Reset();
+  for (Int_t jt=1; jt<=jx->GetNtracks(); jt++)
+  {
+   AliTrack* tx=jx->GetTrack(jt);
+   if (!tx) continue;
+   AliTimestamp* tsx=tx->GetTimestamp();
+   t0=evt->GetDifference(tsx,"ns");
+   time.Enter(t0);
+   ref=tx->GetReferencePoint();
+   if (ref)
+   {
+    ref->GetPosition(vec,"car");
+    pos.Enter(vec[0],vec[1],vec[2]);
+   }
+   for (Int_t is=1; is<=tx->GetNsignals(); is++)
+   {
+    sx1=tx->GetSignal(is);
+    if (sx1) sx1->AddLink(trk);
+   }
+  }
+  for (Int_t k=1; k<=3; k++)
+  {
+   vec[k-1]=pos.GetMean(k);
+   err[k-1]=pos.GetSigma(k);
+  }
+  r0.SetPosition(vec,"car");
+  r0.SetPositionErrors(err,"car");
+  t0=time.GetMean(1);
+  AliTimestamp* tt0=trk->GetTimestamp();
+  tt0->Add(0,0,t0);
+  trk->SetReferencePoint(r0);
+
+  // Only take the jet with the maximum number of tracks
+  // (i.e. the first jet in the list) when the user had selected
+  // this reconstruction mode.
+  if (fJangsep<0) break;
+ }
+
+ delete [] ntes;
+}
+///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/icepack/IceDwalk.h b/RALICE/icepack/IceDwalk.h
new file mode 100644 (file)
index 0000000..4346315
--- /dev/null
@@ -0,0 +1,37 @@
+#ifndef IceDwalk_h
+#define IceDwalk_h
+
+// Copyright(c) 2003, IceCube Experiment at the South Pole, All rights reserved.
+// See cxx source for full Copyright notice.
+
+// $Id$
+
+#include "TROOT.h"
+#include "TTask.h"
+#include "TString.h"
+
+#include "AliJob.h"
+#include "AliSample.h"
+#include "IceEvent.h"
+#include "IceGOM.h"
+
+class IceDwalk : public TTask
+{
+ public :
+  IceDwalk(const char* name="",const char* title=""); // Constructor
+  virtual ~IceDwalk();                                // Destructor
+  virtual void Exec(Option_t* opt);                   // Direct walk reconstruction
+  void SetDmin(Float_t d);      // Set minimum hit distance to form a track element
+  void SetDtmarg(Int_t dt);     // Set maximum hit time difference margin for track elements
+  void SetTangsep(Float_t ang); // Set angular separation within which track candidates are clustered in a jet
+  void SetJangsep(Float_t ang); // Set angular separation within which jets are merged into 1 single track
+
+ protected :
+  Float_t fDmin;    // Minimum hit distance (in m) to form a track element 
+  Int_t fDtmarg;    // Maximum hit time difference margin (in ns) for track elements
+  Float_t fTangsep; // Angular separation (in deg) within which track candidates are clustered in a jet
+  Float_t fJangsep; // Angular separation (in deg) within which jets are merged into 1 single track
+
+ ClassDef(IceDwalk,1) // TTask derived class to perform direct walk reconstruction
+};
+#endif
index 950519b..dec784e 100644 (file)
@@ -20,4 +20,7 @@
                 docs of IceCleanHits.
 31-oct-2005 NvE Slight correction in IceCalibrate.cxx and IceCleanhits.cxx to satisfy
                 the gcc compiler (thanks Dipo).
+                Also first (prototype) version of class IceDwalk introduced to perform
+                direct walk reconstruction. In the /macros directory an example job
+                icedwalk.cc has been introduced.
 
diff --git a/RALICE/icepack/macros/icedwalk.cc b/RALICE/icepack/macros/icedwalk.cc
new file mode 100644 (file)
index 0000000..849b7aa
--- /dev/null
@@ -0,0 +1,66 @@
+//////////////////////////////////////////////////////////
+// Example macro to demonstrate the usage of the IceDwalk
+// processor for direct walk reconstruction as a subtask
+// of an F2K conversion job. The macro also shows how one
+// can interactively invoke one or more subtasks
+// (i.e. IceXtalk and EvtAna.cxx) to be executed.
+// The latter is very convenient in testing/comparing
+// new reconstruction/analysis algorithms.
+//
+// To run this macro in batch, just do
+//
+// root -b -q icedwalk.cc
+//
+// For more details see the docs of class IceDwalk
+//
+// NvE 07-oct-2005 Utrecht University
+//////////////////////////////////////////////////////////
+{
+ gSystem->Load("ralice");
+ gSystem->Load("icepack");
+ gSystem->Load("iceconvert");
+
+ // Interactively compile and load the EvtAna.cxx code
+ gROOT->LoadMacro("EvtAna.cxx+");
+
+ // The database conversion job
+ IceCal2Root cal("IceCal2Root","Calibration format conversion");
+ cal.SetAmacalibFile("amacalib_amanda2_2003.txt");
+ cal.SetOutputFile("cal2003.root");
+ cal.ExecuteJob();
+
+ // The direct walk reconstruction task
+ IceDwalk dwalk("IceDwalk","Direct walk reconstruction");
+
+ // The calibration processor task
+ IceCalibrate calib("IceCalibrate","Signal calibration");
+ calib.SetCalibFile("cal2003.root");
+
+ // The Xtalk correction processor task
+ IceXtalk xtalk("IceXtalk","Cross talk correction");
+ xtalk.SetCalibFile("cal2003.root");
+ xtalk.SetMinProb(0.5);
+ xtalk.SetXtalkPE(1);
+
+ // The hit cleaning processor task
+ IceCleanHits clean("IceCleanHits","Hit cleaning");
+
+ // The event analysis task
+ EvtAna evtana("evtana","Event analysis");
+
+ // The F2K event data processing job
+ IceF2k q("IceF2k","Processing of the F2K event data");
+ q.SetMaxEvents(2);
+ q.SetPrintFreq(0);
+ q.SetInputFile("real-reco.f2k");
+
+ // Add the Xtalk and EvtAna processors as subtasks to the F2K job
+ q.Add(&calib);
+ q.Add(&xtalk);
+ q.Add(&clean);
+ q.Add(&dwalk);
+ q.Add(&evtana);
+
+ // Perform the conversion
+ q.ExecuteJob();
+}