10-mar-2006 NvE Xtalk ADC correction value stored as ADC offset in IceXtalk processing.
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Mar 2006 15:25:29 +0000 (15:25 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Mar 2006 15:25:29 +0000 (15:25 +0000)
                This will allow easy investigation of Xtalk corrected hits and also
                enable successive Xtalk processing to investigate (systematic) effects
                of various criteria. See the IceXtalk docs for further details.
                Also specification of minimum number of good fired modules for events to
                be processed introduced in IceDwalk.
                New class IceLinefit introduced.

RALICE/icepack/ICEHeaders.h
RALICE/icepack/ICELinkDef.h
RALICE/icepack/IceDwalk.cxx
RALICE/icepack/IceDwalk.h
RALICE/icepack/IceLinefit.cxx [new file with mode: 0644]
RALICE/icepack/IceLinefit.h [new file with mode: 0644]
RALICE/icepack/IceXtalk.cxx
RALICE/icepack/history.txt

index e0ba615..2d95d1e 100644 (file)
@@ -19,4 +19,5 @@
 #include "IceCleanHits.h"
 #include "IceDwalk.h"
 #include "IcePandel.h"
+#include "IceLinefit.h"
 
index 1c48fd0..35d99d4 100644 (file)
@@ -24,5 +24,6 @@
  #pragma link C++ class IceCleanHits+;
  #pragma link C++ class IceDwalk+;
  #pragma link C++ class IcePandel+;
+ #pragma link C++ class IceLinefit+;
 #endif
  
index a748e2c..df66aab 100644 (file)
 // muons hitting the top and bottom parts of the detector.
 // To prevent waisting CPU time in trying to reconstruct (high-energy) cascade
 // events, or to select specifically reconstruction of low multiplicity events,
-// the user may invoke the memberfunction SetMaxModA(). This allows selection
-// of events for processing with a certain maximum number of good Amanda OMs
-// firing. By default this maximum is set to 999 in the constructor, which
-// implies no multiplicity selection. 
+// the user may invoke the memberfunctions SetMaxModA() and SetMinModA().
+// This allows selection of events for processing with a certain maximum and/or
+// minimum number of good Amanda OMs firing.
+// By default the minimum and maximum are set to 0 and 999, respectively,
+// in the constructor, which implies no multiplicity selection. 
 // The various reconstruction steps are summarised as follows :
 //
 // 1) Construction of track elements (TE's).
@@ -171,6 +172,7 @@ IceDwalk::IceDwalk(const char* name,const char* title) : TTask(name,title)
  fRjangmax=fRtangmax;
  fRjdmax=fDmin;
  fMaxmodA=999;
+ fMinmodA=0;
  fTrackname="IceDwalk";
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -305,10 +307,22 @@ void IceDwalk::SetMaxModA(Int_t nmax)
 // in which tracking doesn't make sense anyhow.
 // Furthermore it allows selection of low multiplicity events for processing.
 // By default the maximum number of Amanda modules is set to 999 in the ctor,
-// which implies no selection on module multiplicity.
+// which implies no selection on maximum module multiplicity.
+// See also the memberfunction SetMinModA().
  fMaxmodA=nmax;
 }
 ///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetMinModA(Int_t nmin)
+{
+// Set the minimum number of good Amanda modules that must have fired
+// in order to process this event.
+// This allows selection of a minimal multiplicity for events to be processed.
+// By default the minimum number of Amanda modules is set to 0 in the ctor,
+// which implies no selection on minimum module multiplicity.
+// See also the memberfunction SetMaxModA().
+ fMinmodA=nmin;
+}
+///////////////////////////////////////////////////////////////////////////
 void IceDwalk::SetTrackName(TString s)
 {
 // Set (alternative) name identifier for the produced first guess tracks.
@@ -336,7 +350,7 @@ void IceDwalk::Exec(Option_t* opt)
  Int_t naoms=aoms->GetEntries();
  if (!naoms) return;
 
- // Check for the maximum number of good fired Amanda OMs
+ // Check for the minimum and/or maximum number of good fired Amanda OMs
  Int_t ngood=0;
  for (Int_t iom=0; iom<naoms; iom++)
  {
@@ -345,7 +359,7 @@ void IceDwalk::Exec(Option_t* opt)
   if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
   ngood++;
  } 
- if (ngood>fMaxmodA) return;
+ if (ngood<fMinmodA || ngood>fMaxmodA) return;
 
  const Float_t c=0.3;                // Light speed in vacuum in meters per ns
  const Float_t nice=1.33;            // Refractive index of ice
index 1dff443..93ee0b4 100644 (file)
@@ -30,7 +30,8 @@ class IceDwalk : public TTask
   void SetJangmax(Float_t ang);  // Set max. angular separation for jet merging into 1 single track
   void SetRjangmax(Float_t ang); // Set max. angular separation for relative r0 direction for jet merging
   void SetRjdmax(Float_t d);     // Set maximum r0 distance for jet merging
-  void SetMaxModA(Int_t nmax);   // Set maximum number of good fired Amanda modules for event processing
+  void SetMaxModA(Int_t nmax);   // Set max. number of good fired Amanda modules for events to be processed
+  void SetMinModA(Int_t nmin);   // Set min. number of good fired Amanda modules for events to be processed
   void SetTrackName(TString s);  // Set (alternative) name for the produced first guess tracks
 
  protected :
@@ -42,9 +43,10 @@ class IceDwalk : public TTask
   Float_t fJangmax;  // Angular separation (in deg) within which jets are merged into 1 single track
   Float_t fRjangmax; // Relative r0 angular separation (in deg) for jet clustering
   Float_t fRjdmax;   // Maximum r0 distance (in m) for jet merging
-  Int_t fMaxmodA;    // The max. number of good fired Amanda modules for event processing
+  Int_t fMaxmodA;    // The max. number of good fired Amanda modules for events to be processed
+  Int_t fMinmodA;    // The min. number of good fired Amanda modules for events to be processed
   TString fTrackname;// The name identifier for the produced first guess tracks
 
- ClassDef(IceDwalk,3) // TTask derived class to perform direct walk reconstruction
+ ClassDef(IceDwalk,4) // TTask derived class to perform direct walk reconstruction
 };
 #endif
diff --git a/RALICE/icepack/IceLinefit.cxx b/RALICE/icepack/IceLinefit.cxx
new file mode 100644 (file)
index 0000000..0c71912
--- /dev/null
@@ -0,0 +1,215 @@
+/*******************************************************************************
+ * 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 IceLinefit
+// TTask derived class to perform a linefit track reconstruction.
+// The procedure is based on the method described in the Amanda publication
+// in Nuclear Instruments and Methods A524 (2004) 179-180.
+// To prevent waisting CPU time in trying to reconstruct (high-energy) cascade
+// events, or to select specifically reconstruction of low multiplicity events,
+// the user may invoke the memberfunctions SetMaxModA() and SetMinModA.
+// This allows selection of events for processing with a certain maximum
+// and/or minimum number of good Amanda OMs firing.
+// By default the minimum and maximum are set to 0 and 999, respectively,
+// in the constructor, which implies no multiplicity selection. 
+//
+// The reconstructed track is stored in the IceEvent structure with as
+// default "IceLinefit" as the name of the track.
+// This track name identifier can be modified by the user via the
+// SetTrackName() memberfunction. This will allow unique identification
+// of tracks which are produced when re-processing existing data with
+// different criteria.
+// The track 3-momentum is set to the reconstructed velocity, normalised
+// to 1 GeV. The mass and charge of the track are left 0.
+// The r0 and t0 can be obtained from the reference point of the track,
+// whereas the t0 ia also available from the track timestamp .
+//
+// 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 10-mar-2006 Utrecht University
+//- Modified: NvE $Date$ Utrecht University
+///////////////////////////////////////////////////////////////////////////
+#include "IceLinefit.h"
+#include "Riostream.h"
+
+ClassImp(IceLinefit) // Class implementation to enable ROOT I/O
+
+IceLinefit::IceLinefit(const char* name,const char* title) : TTask(name,title)
+{
+// Default constructor.
+ fMaxmodA=999;
+ fMinmodA=0;
+ fTrackname="IceLinefit";
+}
+///////////////////////////////////////////////////////////////////////////
+IceLinefit::~IceLinefit()
+{
+// Default destructor.
+}
+///////////////////////////////////////////////////////////////////////////
+void IceLinefit::SetMaxModA(Int_t nmax)
+{
+// Set the maximum number of good Amanda modules that may have fired
+// in order to process this event.
+// This allows suppression of processing (high-energy) cascade events
+// with this linefit tracking to prevent waisting cpu time for cases
+// in which tracking doesn't make sense anyhow.
+// Furthermore it allows selection of low multiplicity events for processing.
+// By default the maximum number of Amanda modules is set to 999 in the ctor,
+// which implies no selection on maximum module multiplicity.
+// See also the memberfunction SetMinModA().
+ fMaxmodA=nmax;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceLinefit::SetMinModA(Int_t nmin)
+{
+// Set the minimum number of good Amanda modules that must have fired
+// in order to process this event.
+// This allows selection of a minimal multiplicity for events to be processed.
+// By default the minimum number of Amanda modules is set to 0 in the ctor,
+// which implies no selection on minimum module multiplicity.
+// See also the memberfunction SetMaxModA().
+ fMinmodA=nmin;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceLinefit::SetTrackName(TString s)
+{
+// Set (alternative) name identifier for the produced first guess tracks.
+// This allows unique identification of (newly) produced linefit tracks
+// in case of re-processing of existing data with different criteria.
+// By default the produced first guess tracks have the name "IceLinefit"
+// which is set in the constructor of this class.
+ fTrackname=s;
+}
+///////////////////////////////////////////////////////////////////////////
+void IceLinefit::Exec(Option_t* opt)
+{
+// Implementation of the linefit reconstruction.
+
+ TString name=opt;
+ AliJob* parent=(AliJob*)(gROOT->GetListOfTasks()->FindObject(name.Data()));
+
+ if (!parent) return;
+
+ IceEvent* evt=(IceEvent*)parent->GetObject("IceEvent");
+ if (!evt) return;
+
+ // Fetch all fired Amanda OMs for this event
+ TObjArray* aoms=evt->GetDevices("IceAOM");
+ Int_t naoms=aoms->GetEntries();
+ if (!naoms) return;
+
+ // Check for the minimum and/or maximum number of good fired Amanda OMs
+ Int_t ngood=0;
+ for (Int_t iom=0; iom<naoms; iom++)
+ {
+  IceGOM* omx=(IceGOM*)aoms->At(iom);
+  if (!omx) continue;
+  if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
+  ngood++;
+ } 
+ if (ngood<fMinmodA || ngood>fMaxmodA) return;
+
+ AliSignal* sx=0;
+ Ali3Vector rom,sumr;
+ Ali3Vector rt,sumrt;
+ Float_t thit;
+ Float_t sumt=0,sumt2=0;
+ TObjArray hits;
+
+ // Loop over all OMs and hits to determine the linefit parameters.
+ // Also all the used hits are recorded for association with the track.
+ for (Int_t iom=0; iom<naoms; iom++)
+ {
+  IceGOM* omx=(IceGOM*)aoms->At(iom);
+  if (!omx) continue;
+  if (omx->GetDeadValue("LE")) continue;
+  rom=(Ali3Vector)omx->GetPosition();
+  // Use all the good hits of this OM
+  for (Int_t ih=1; ih<=omx->GetNhits(); ih++)
+  {
+   sx=omx->GetHit(ih);
+   if (!sx) continue;
+   if (sx->GetDeadValue("ADC") || sx->GetDeadValue("LE") || sx->GetDeadValue("TOT")) continue;
+
+   thit=sx->GetSignal("LE",7);
+   rt=rom*thit;
+   sumr+=rom;
+   sumrt+=rt;
+   sumt+=thit;
+   sumt2+=thit*thit;
+
+   // Record this hit for association with the track
+   hits.Add(sx);
+  }
+ }
+
+ Int_t nused=hits.GetEntries();
+ if (!nused) return;
+
+ sumr/=float(nused);
+ sumrt/=float(nused);
+ sumt/=float(nused);
+ sumt2/=float(nused);
+
+ Ali3Vector v;
+ Ali3Vector temp;
+ temp=sumr*sumt;
+ v=sumrt-temp;
+ Float_t dum=sumt2-(sumt*sumt);
+ if (dum) v/=dum;
+
+ Ali3Vector r;
+ temp=v*sumt;
+ r=sumr-temp;
+
+ AliTrack t; 
+ t.SetNameTitle(fTrackname.Data(),"IceLinefit linefit track");
+ evt->AddTrack(t);
+ AliTrack* trk=evt->GetTrack(evt->GetNtracks());
+ if (!trk) return;
+
+ Ali3Vector p;
+ Float_t vec[3];
+ v.GetVector(vec,"sph");
+ vec[0]=1;
+ p.SetVector(vec,"sph");
+
+ AliPosition r0;
+ r0.SetPosition(r);
+ r0.SetTimestamp((AliTimestamp&)*evt);
+ AliTimestamp* t0=r0.GetTimestamp();
+ t0->Add(0,0,(int)sumt);
+
+ trk->Set3Momentum(p);
+ trk->SetReferencePoint(r0);
+ trk->SetTimestamp(*t0);
+
+ // Link the used hits to the track (and vice versa)
+ for (Int_t i=0; i<nused; i++)
+ {
+  sx=(AliSignal*)hits.At(i);
+  if (sx) sx->AddLink(trk);
+ } 
+}
+///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/icepack/IceLinefit.h b/RALICE/icepack/IceLinefit.h
new file mode 100644 (file)
index 0000000..43f9b02
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef IceLinefit_h
+#define IceLinefit_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 "IceEvent.h"
+#include "IceGOM.h"
+
+class IceLinefit : public TTask
+{
+ public :
+  IceLinefit(const char* name="",const char* title=""); // Constructor
+  virtual ~IceLinefit();                                // Destructor
+  virtual void Exec(Option_t* opt);                     // Linefit reconstruction
+  void SetMaxModA(Int_t nmax);   // Set max. number of good fired Amanda modules for events to be processed
+  void SetMinModA(Int_t nmin);   // Set min. number of good fired Amanda modules for events to be processed
+  void SetTrackName(TString s);  // Set (alternative) name for the produced first guess tracks
+
+ protected :
+  Int_t fMaxmodA;    // The max. number of good fired Amanda modules for events to be processed
+  Int_t fMinmodA;    // The min. number of good fired Amanda modules for events to be processed
+  TString fTrackname;// The name identifier for the produced first guess tracks
+
+ ClassDef(IceLinefit,1) // TTask derived class to perform linefit reconstruction
+};
+#endif
index 237f073..ffe8294 100644 (file)
 // talk effects are expected to have negligible effects on the observed
 // large module signals.
 //
+// Note : The amount with which the ADC value was corrected is stored
+//        in the signal as an ADC offset. This will allow easy investigation
+//        of Xtalk corrected signals and also enables successive
+//        applications of this Xtalk processor to investigate (systematic)
+//        effects of various criteria.
+//        Example : In case an amount of 1 pe was subtracted from the ADC
+//                  value, the ADC offset will be set to 1. 
+//
 // The values of "pmin" and "pe" can be set by the user via the
 // SetMinProb() and SetXtalkPE() memberfunctions.
 // The default values are pmin=0.5 and pe=1.
@@ -180,6 +188,10 @@ void IceXtalk::Exec(Option_t* opt)
     AliSignal* st=omt->GetHit(ithit);
     if (!st) continue;
 
+    // Eliminate possible previous Xtalk correction
+    sigcor=st->GetOffset("ADC");
+    st->AddSignal(sigcor,"ADC");
+    st->ResetOffset("ADC");
     adct=st->GetSignal("ADC",-4); // Get uncalibrated amplitude
     dlemin=fxtalk->GetParameter("dLE-min");
     dlemax=fxtalk->GetParameter("dLE-max");
@@ -226,11 +238,15 @@ void IceXtalk::Exec(Option_t* opt)
  } // end of transmitter OM loop
  
  // Perform the Xtalk signal correction to the registered receiver hits
+ // The correction value is stored in the signal data as an offset value
  for (Int_t ix=0; ix<xhits.GetEntries(); ix++)
  {
   AliSignal* sx=(AliSignal*)xhits.At(ix);
   if (!sx) continue;
-  adcr=sx->GetSignal("ADC");
+
+  // Eliminate possible previous Xtalk correction
+  sigcor=sx->GetOffset("ADC");
+  adcr=sx->GetSignal("ADC")+sigcor;
   sigcor=fPe;
   // If stored ADC data is un-calibrated, convert fPe to raw ADC value 
   AliSignal* parent=(AliSignal*)sx->GetDevice();
@@ -247,6 +263,7 @@ void IceXtalk::Exec(Option_t* opt)
   }
   adcr=adcr-sigcor;
   sx->SetSignal(adcr,"ADC");
+  sx->SetOffset(sigcor,"ADC");
  }
 }
 ///////////////////////////////////////////////////////////////////////////
index f10cb70..371ea83 100644 (file)
                 the produced tracks via the memberfunction SetTrackName().
                 Also specification of maximum number of good fired modules for events to
                 be processed introduced in IceDwalk. 
-
+10-mar-2006 NvE Xtalk ADC correction value stored as ADC offset in IceXtalk processing.
+                This will allow easy investigation of Xtalk corrected hits and also
+                enable successive Xtalk processing to investigate (systematic) effects
+                of various criteria. See the IceXtalk docs for further details.
+                Also specification of minimum number of good fired modules for events to
+                be processed introduced in IceDwalk. 
+                New class IceLinefit introduced.