IceDwalk Class Reference

IceRecoBase derived TTask processor to perform (improved) direct walk reconstruction. More...

#include "IceDwalk.h"

Inheritance diagram for IceDwalk:

Detailed Description

IceRecoBase derived TTask processor to perform (improved) direct walk reconstruction.

Copyright(c) 2003, IceCube Experiment at the South Pole. All rights reserved.
 
Author: The IceCube NCFS-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.

// Class IceDwalk
// IceRecoBase derived TTask processor to perform direct walk track reconstruction.
//
// In case an event has been rejected by an NcEventSelector (based) processor,
// this task (and its sub-tasks) is not executed.
//
// Note : Amanda OMs, standard IceCube (IC), DeepCore (DC) and InIce (I) DOMs are treated
//        seperately, which means that for events with various OMs and/or DOMs firing,
//        several direct walk tracks may be produced. The various direct walk tracks can be
//        distinguished on basis of their name as explained below. 
//
// 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.
//
// A further extension of the original Amanda method is the separate treatment
// of the phase and group velocities as introduced in collaboration with
// George Japaridze (Clark Atlanta University, USA) which will provide more
// accurate time residuals due to the different velocities of the Cerenkov
// wave front (v_phase) and the actually detected photons (v_group).
// For details please refer to Astroparticle Physics 28 (2007) 456.
// This distinction between v_phase and v_group can be (de)activated via the
// memberfunction SetVgroupUsage(). By default the distinction between v_phase
// and v_group is activated in the constructor of this class.
//
// 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 SetMaxMod() and SetMinMod().
// This allows selection of events for processing with a certain maximum and/or
// minimum number of good (D)OMs firing.
// The maximum number of good HLC hits per (D)OM to be used for the reconstruction
// can be specified via the memberfunction SetMaxHits().
// Since for Amanda there is no concept of HLC hits, all Amanda hits are treated as HLC.
// Note that hits in Amanda OMs are ordered w.r.t. increasing hit time (LE), whereas
// hits in IceCube DOMs are ordered w.r.t. decreasing amplitude (ADC).
//
// By setting the maximum number of good HLC hits per (D)OM to "n", all good (HLC and SLC)
// hits of each (D)OM up to the nth HLC hit (incl.) are used.
//
// Note that when all the good hits of a (D)OM are used, this may lead to large
// processing time in case many noise and/or afterpulse signals are not
// recognised by the hit cleaning procedure.
// To cope with this, the user may specify an automatic switch to use only the good
// hits up to the first HLC hit for large events via the memberfunction SetSingleHit().
//
// The SetMaxHits() facility may also be used to select a specific detector
// configuration (e.g. "IC" and "DC" without "I") to be used for the reconstruction.
// This can be achieved by suppressing processing of e.g. the "I" configuration
// by setting the corresponding maximum number of hits to -1.
// Note that there is a subtle difference between "detector configuration" and
// "optimised reconstruction parameters" as outlined in the docs of SetConditionalReco().
// In case the labels "IC", "DC" and "I" only indicate the different reconstruction parameters,
// the settings for "IC" and "DC" of SetMaxHits() indeed only affect the specified DOMs
// but still all "IC", "DC" and "I" optimised reconstructions are performed.
// This means that in those cases the effect of e.g. SetMaxHits(-1,"DC") is that all reconstructions
// "IC", "I" and "DC" will be performed, but without using DeepCore hits.
// This allows to use less hits per DOM for noisy detector components. 
// Invokation of SetMaxHits() with argument "I" has no effect in those cases.
//
// Another facility to (automatically) select reconstruction of specific detector
// configurations, reconstruction parameters and/or save CPU time is the so-called
// conditional processing mode.
// For further details please refer to the docs of the memberfunction SetConditionalReco(). 
//
// All reconstructed tracks will be stored in the IceEvent structure with as
// default the Classname of the producing processor as the basename of the track.
// A suffix "A" for an Amanda (OM) track, "IC" for a standard IceCube InIce track,
// "I" for a hybrid InIce (IC+DC) track or "DC" for a DeepCore track will be
// added to the basename automatically.
// For further details concerning the meaning of the suffix "A", "IC", "I" or "DC"
// please refer to the docs of the memberfunction SetConditionalReco(). 
// The track basename 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.
// Note that a suffix "A", "IC", "I" or "DC" will always be generated automatically.
//
// The track 3-momentum is set to the reconstructed direction, normalised to 1 GeV.
// The mass and charge of the track are left 0, since no distinction can
// be made between positive or negative tracks and also no mass can be determined.
// However, the user can define the track charge by invokation of the
// memberfunction SetCharge().
// This facility may be used to distinguish tracks produced by the
// various reconstruction algorithms in a (3D) colour display
// (see the class NcHelix for further details).  
// The r0 and t0 can be obtained from the reference point of the track,
// whereas the t0 is also available from the track timestamp .
//
// Information about the actual parameter settings can be found in the event
// structure itself via the device named "IceDwalk".
// All default parameter settings can be seen from the default constructor of this class.
//
// The various reconstruction steps are summarised as follows :
//
// 1) Construction of track elements (TE's).
//    A track element is a straight line connecting two HLC hits that
//    appeared at some minimum distance dmin and within some time interval dt
//    around the expected tgeo, according to eq. (20) of the NIM article.
//    The minimum distance can be specified via the memberfunction SetDmin().
//    The ideal time difference is given by tgeo=(hit distance)/c but an additional
//    time margin may be specified via the memberfunction SetDtmarg().    
//    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 NcTimestamp facilities (supporting upto picosecond
//    precision when available).
//    The TE direction is given by the relative position of the two hits.
//
//    Note : For the construction of TE's only HLC hits are used.
//
// 2) Each TE will obtain so called associated hits.
//    A hit is associated to a TE when it fulfills both the conditions
//
//      dtmin < tres < dtmax
//      dhit/lambda < F
//
//    tres   : time residual (in ns)
//             Difference between the observed hit time and the time expected
//             for a direct photon hit.     
//    dhit   : Distance (in m) traveled by the cherenkov photon from the track to the hit position
//    lambda : Effective photon scattering length in ice (in meter)
//
//    The time difference intervals may be specified via the memberfunction SetDthit().
//    The effective scattering length (in meter) for various detector locations may be specified
//    via the memberfunction SetScatteringLength().
//    The value of the parameter F may be specified via the memberfunction SetMaxDhit().
//
//    Note : For IceCube hits the user may select whether or not to allow SLC hits to be
//           associated via the memberfunction SetSLChitUsage().
//
// 3) Construction of track candidates (TC's).
//    These are TE's that fulfill both the conditions
//
//     nax > 0
//     qtc >= 0.8*qtcmax
//
//    where we have defined :
//
//    nax    : Associated hits and/or strings value for the specific TE.
//             For details see the docs of the memberfunction SetAsType().
//    qtc    : The track quality number (see hereafter).
//    qtcmax : Maximum quality number encountered for the TE's.
//
//    Notes :
//    -------
//    1) In case qtcmax<=0 no track candidate will be formed.
//    2) The selection to use the number of associated hits and/or strings
//       for the track quality number can be performed via the
//       memberfunction SetAsType().
//
//    The track quality number qtc is defined as follows :
//
//     qtc=nax*(term1+term2)-term3-term4-term5
//
//    here we have defined :
//
//    term1=2*spread/span
//    term2=2*spreadL/spanL
//    term3=|spread-expspread|/spread
//    term4=|spreadL-expspreadL|/spreadL
//    term5=|medianT|/spreadT
//
//    The central observables here are the projected positions X on the track
//    of the various associated hits w.r.t. the track reference point r0.
//    Note that X can be negative as well as positive.
//    Therefore we also introduce XL=|X|. 
//
//    span       : max(X)-min(X)
//    spanL      : max(XL)-min(XL)
//    Xmedian    : median of X
//    XmedianL   : median of XL
//    spread     : < |X-Xmedian| >
//    spreadL    : < |XL-XmedianL| >
//    expspread  : expected spread in X for a flat distribution of nah hits over span
//    expspreadL : expected spread in XL for a flat distribution of nah hits over spanL
//    medianT    : median of tres
//    spreadT    : < |tres-medianT| >
//
//    However, if |Xmedian| > span/2 we set qtc=0 in order to always require
//    projected hits to appear on both sides of r0 on the track.
//
//    Note : The qtc quality number is used to define the norm of the momentum
//           of the track candidate. As such it serves as a weight for the jet
//           momentum (direction) after clustering of the TC's and lateron
//           merging of the jets (see hereafter).
//
// 4) The remaining track candidates are clustered into jets when their directions
//    are within a certain maximum opening angle.
//    In addition a track candidate must be within a certain maximum distance
//    of the jet starting TC in order to get clustered. 
//    The latter criterion prevents clustering of (nearly) parallel track candidates
//    crossing the detector a very different locations (e.g. muon bundles).
//    The maximum track opening angle may be specified via the SetTangmax() memberfunction.
//    The maximum track distance may be specified via the SetTdistmax() memberfunction.
//    This memberfunction also allows to specify whether the distance is determined within
//    the detector volume or not.
//
//    The average of all the r0 and t0 values of the constituent TC's
//    of the jet will provide the r0 and t0 (i.e. reference point) of the jet.
//
//    The jet total momentum consists of the vector sum of the momenta of the
//    constituent TC's. This implies that the qtc quality numbers of the various
//    TC's define a weight for each track in the construction of the jet direction.
//    In addition it means that the total jet momentum represents the sum of the
//    qtc quality numbers of the constituent TC's weighted by the opening angles
//    between the various TC's.  
//    As such each jet is given an absolute quality indicator defined as :
//
//      avqtc=|jet momentum|/ntracks 
//
//    This jet quality indicator is further refined using also the number of hits and (D)OMs
//    associated to the jet as :
//
//      qvalue=avqtc/qtcmax+nam/nammax+nah/nahmax+nahlc/nahlcmax
//
//    where we have defined :
//
//    nam      : Number of associated modules, i.e. (D)OMs, for the specific jet.
//    nammax   : Maximum number of associated modules encountered for the jets.
//    nah      : Number of associated hits for the specific jet.
//    nahmax   : Maximum number of associated hits encountered for the jets.
//    nahhlc   : Number of associated HLC hits for the specific jet.
//    nahlcmax : Maximum number of associated HLC hits encountered for the jets.
//
//    With this definition the qvalue always lies in the range <0,4] which provides
//    an absolute quality scale.
//
//    The jet qvalue is then used to order the various jets w.r.t.
//    decreasing qvalue quality number.
//
//    Note : The jet qvalue is stored as "energy" of the jet, such that
//           it is always available for each jet and can also be used for
//           ordering the jets according to this value using the generic
//           NcEvent::SortJets() facility. 
//
// 5) The jets (after having been ordered w.r.t. decreasing jet qvalue)
//    are merged when their directions are within a certain maximum opening angle.
//    In addition a jet must be within a certain maximum distance of the starting jet
//    in order to get merged. 
//    The latter criterion prevents merging of (nearly) parallel tracks/jets
//    crossing the detector a very different locations (e.g. muon bundles).
//    The jet ordering before the merging process is essential, since the starting jet
//    will "eat up" the jets that will be merged into it. 
//    The jet ordering ensures that the jet with the highest quality number will
//    always initiate the merging process.
//    The default maximum opening angle is half the TC maximum opening angle,
//    but can be modified via the SetJangmax() memberfunction. This memberfunction
//    also allows to specify whether jet merging will be performed iteratively or not.
//    In case iteration has been activated, the jet ordering is performed after each
//    iteration step. This has to be done because the quality numbers of the
//    resulting merged jets have been automatically updated in the merging process.
//    
//    The maximum jet distance may be specified via the SetJdistmax() memberfunction.
//    This memberfunction also allows to specify whether the distance is determined
//    within the detector volume or not.
//
//    Note : Setting the maximum jet opening angle to <=0 will prevent
//           the merging of jets.
//
//    The average of all the r0 and t0 values of the merged jets will provide
//    the r0 and t0 (i.e. reference point) of the final jet.
//
// 6) The remaining (merged) jets are ordered w.r.t. decreasing jet qvalue.
//    As such the jet with the highest qvalue (Qmax) will be the first one in the list,
//    which will result in the fact that the final tracks are also ordered
//    w.r.t. decreasing qvalue.
//    Each remaining jet will provide the parameters (e.g. direction)
//    for a reconstructed track.
//    However, a reconstructed track will only be provided if it has sufficient associated hits.
//    The minimum number of associated hits for a reconstructed track to be produced 
//    can be specified via the memberfunction SetMinHits().
//    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 reference point data of the jet will provide the r0 and t0
//    (i.e. reference point) of the track.
//    The final track quality number and the various contributing parameters
//    are stored as fit details for the corresponding track(s) and can be retrieved
//    afterwards for each reconstructed track.  
//
// 7) The direction of a track is reversed in case a the track has a polar angle
//    theta<"thetatrk" and the (time ordered) hit pattern reflects a direction with
//    polar angle theta>"thetahits", where "thetatrk" and "thetahits" indicate angular thresholds.
//    This allows an additional reduction of the background for upgoing tracks
//    due to mis-reconstructed downgoing muons.
//
//    The polar angle thresholds "thetatrk" and "thetahits" (in degrees) may be set by the user
//    via the member function SetFlipAngles(), where the convention is that theta=0 indicates a
//    straight upgoing track.
//
//    Note : The flipping of the track direction may be de-activated by
//           setting thetatrk<0 and/or thetahits>180.
//
//    The default values thetatrk=-999 and thetahits=999 are set in the constructor of this class
//    which implies that the flipping of the tracks direction is de-activated by default.
//    Based on simulated data it was seen that with thetatrk=90 and thetahits=100 the direction flipping
//    did a good job in reducing downgoing Corsika events, but it eliminated too many upgoing signal events.
//    Maybe further fine tuning can make this facility useful in the future.
//
//    All reconstructed tracks with qvalue>=qcut*Qmax will be stored in the IceEvent structure
//    using the naming conventions outlined above.
//    The value of the parameter "qcut" may be specified via the member function SetQvalueCut().
//
//    Note : In case the maximum jet opening angle was specified <0,
//           only the jet with the highest quality number will appear
//           as a reconstructed track in the IceEvent structure.
//           This will allow comparison with the old Amanda (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 and
//        cross talk corrected (Amanda).
//        Due to the built-in causality requirements, the data do not need to be
//        cleaned from noise hits etc. (see the processor IceCleanHits).
//
//--- Author: Nick van Eijndhoven 07-oct-2005 Utrecht University
//- Modified: NvE $Date: 2013-03-15 16:22:45 +0100 (Fri, 15 Mar 2013) $ IIHE-VUB, Brussels

Definition at line 15 of file IceDwalk.h.

Public Member Functions
	IceDwalk (const char *name="IceDwalk", const char *title="Direct walk reconstruction")
virtual	~IceDwalk ()
virtual void	Exec (Option_t *opt)
void	SetAsType (Int_t flag, TString s, Float_t w=-1)
void	SetConditionalReco (Int_t flag)
void	SetDmin (Float_t d, TString s)
void	SetDthit (Float_t dtmin, Float_t dtmax, TString s)
void	SetDtmarg (Int_t dt, TString s)
void	SetHitWeight (Float_t w)
void	SetJangmax (Float_t ang, TString s, Int_t iter=1)
void	SetJdistmax (Float_t d, TString s, Int_t invol=1)
void	SetMaxDhit (Float_t d, TString s)
void	SetQvalueCut (Float_t qcut)
void	SetTangmax (Float_t ang, TString s)
void	SetTdistmax (Float_t d, TString s, Int_t invol=1)
Public Member Functions inherited from IceRecoBase
	IceRecoBase (const char *name="IceRecoBase", const char *title="Base class for IceCube reconstruction tasks")
virtual	~IceRecoBase ()
void	SetAbsorptionLength (Float_t lambda, TString s)
void	SetCharge (Float_t charge)
void	SetCleaned (Int_t flag, TString s)
void	SetFlipAngles (Float_t thetatrk, Float_t thetahits)
void	SetMaxHits (Int_t nmax, TString s)
void	SetMaxMod (Int_t nmax, TString s)
void	SetMinAhits (Int_t nmin, TString s)
void	SetMinAmods (Int_t nmin, TString s)
void	SetMinMod (Int_t nmin, TString s)
void	SetScatteringLength (Float_t lambda, TString s)
void	SetSingleHit (Int_t ndoms, TString s, Int_t ndoms1=0)
void	SetSLChitUsage (Int_t flag, TString s)
void	SetTimeJitter (Float_t sigma, TString s)
void	SetTrackName (TString s)
void	SetVgroupUsage (Int_t flag, TString s)
void	UseTracks (TString classname, Int_t n=-1)

Protected Member Functions
Int_t	Amanda ()
void	AssociateHits (TObjArray &tes, TObjArray &hits, Int_t astype, Float_t ws, Float_t dtmin, Float_t dtmax, Float_t maxdhit, Int_t vgroup, Int_t cln, Int_t slc, Float_t &qmax)
void	ClusterTracks (TObjArray &tes, TObjArray &jets, Float_t tangmax, Int_t tinvol, Float_t tdistmax, Float_t qmax)
Int_t	DeepCore (TObjArray &hits)
Int_t	IceCube (TObjArray &hits)
Int_t	InIce (TObjArray &hits)
Int_t	MakeTEs (Int_t cln, Int_t maxhits, Float_t dmin, Float_t dtmarg, Float_t dtmin, Float_t dtmax, TString domclass, TObjArray &tes, TObjArray &hits, Int_t gethits)
void	MergeJets (TObjArray &jets, Float_t jangmax, Float_t jdistmax, Int_t jinvol, Int_t jiterate, Float_t qmax)
void	SelectQvalue (TObjArray &tes, Float_t qmax)
Int_t	StoreTracks (TObjArray &jets, Int_t minahits, Int_t minamods, Float_t jangmax, TString name, TString title, TObjArray &hits)
Protected Member Functions inherited from IceRecoBase
virtual void	FlipTrack (NcTrack *t) const

Protected Attributes
Int_t	fAsTypeA
Int_t	fAsTypeDC
Int_t	fAsTypeI
Int_t	fAsTypeIC
Int_t	fConditional
Float_t	fDminA
Float_t	fDminDC
Float_t	fDminI
Float_t	fDminIC
Int_t	fDtmargA
Int_t	fDtmargDC
Int_t	fDtmargI
Int_t	fDtmargIC
Float_t	fDtmaxA
Float_t	fDtmaxDC
Float_t	fDtmaxI
Float_t	fDtmaxIC
Float_t	fDtminA
Float_t	fDtminDC
Float_t	fDtminI
Float_t	fDtminIC
Float_t	fHitweight
Float_t	fJangmaxA
Float_t	fJangmaxDC
Float_t	fJangmaxI
Float_t	fJangmaxIC
Float_t	fJdistmaxA
Float_t	fJdistmaxDC
Float_t	fJdistmaxI
Float_t	fJdistmaxIC
Int_t	fJinvolA
Int_t	fJinvolDC
Int_t	fJinvolI
Int_t	fJinvolIC
Int_t	fJiterateA
Int_t	fJiterateDC
Int_t	fJiterateI
Int_t	fJiterateIC
Float_t	fMaxdhitA
Float_t	fMaxdhitDC
Float_t	fMaxdhitI
Float_t	fMaxdhitIC
Float_t	fQcut
Float_t	fTangmaxA
Float_t	fTangmaxDC
Float_t	fTangmaxI
Float_t	fTangmaxIC
Float_t	fTdistmaxA
Float_t	fTdistmaxDC
Float_t	fTdistmaxI
Float_t	fTdistmaxIC
Int_t	fTinvolA
Int_t	fTinvolDC
Int_t	fTinvolI
Int_t	fTinvolIC
Float_t	fWstringA
Float_t	fWstringDC
Float_t	fWstringI
Float_t	fWstringIC
Protected Attributes inherited from IceRecoBase
Float_t	fCharge
Int_t	fCleanA
Int_t	fCleanDC
Int_t	fCleanI
Int_t	fCleanIC
IceEvent *	fEvt
Int_t	fFirst
Float_t	fLabsA
Float_t	fLabsDL
Float_t	fLabsLD
Float_t	fLabsUD
Float_t	fLambdaA
Float_t	fLambdaDL
Float_t	fLambdaLD
Float_t	fLambdaUD
Int_t	fMaxhitsA
Int_t	fMaxhitsDC
Int_t	fMaxhitsI
Int_t	fMaxhitsIC
Int_t	fMaxmodA
Int_t	fMaxmodDC
Int_t	fMaxmodI
Int_t	fMaxmodIC
Int_t	fMinahitsA
Int_t	fMinahitsDC
Int_t	fMinahitsI
Int_t	fMinahitsIC
Int_t	fMinamodsA
Int_t	fMinamodsDC
Int_t	fMinamodsI
Int_t	fMinamodsIC
Int_t	fMinmodA
Int_t	fMinmodDC
Int_t	fMinmodI
Int_t	fMinmodIC
NcDevice	fParams
Int_t	fSingle1A
Int_t	fSingle1DC
Int_t	fSingle1I
Int_t	fSingle1IC
Int_t	fSingleA
Int_t	fSingleDC
Int_t	fSingleI
Int_t	fSingleIC
Int_t	fSlcDC
Int_t	fSlcI
Int_t	fSlcIC
Float_t	fThetahits
Float_t	fThetatrk
TString	fTrackname
Float_t	fTsigmaA
Float_t	fTsigmaDC
Float_t	fTsigmaIC
TObjArray *	fUseNames
TArrayI *	fUseNtk
Int_t	fVgroupA
Int_t	fVgroupDC
Int_t	fVgroupI
Int_t	fVgroupIC

Constructor & Destructor Documentation

IceDwalk()

IceDwalk::IceDwalk	(	const char *	name = "IceDwalk",
		const char *	title = "Direct walk reconstruction" )

// Default constructor.
// The various reconstruction parameters are initialised to the values
// as mentioned in the general documentation of this class.
// The angular separation parameter for jet merging is initialised as half
// the value of the angular separation parameter for track candidate clustering.    

Definition at line 355 of file IceDwalk.cxx.

~IceDwalk()

IceDwalk::~IceDwalk ( )

virtual

// Default destructor.

Definition at line 470 of file IceDwalk.cxx.

Member Function Documentation

Amanda()

Int_t IceDwalk::Amanda ( )

protected

// The direct walk track reconstruction for Amanda OM signals.

Definition at line 1165 of file IceDwalk.cxx.

AssociateHits()

void IceDwalk::AssociateHits ( TObjArray & tes, TObjArray & hits, Int_t astype, Float_t ws, Float_t dtmin, Float_t dtmax, Float_t maxdhit, Int_t vgroup, Int_t cln, Int_t slc, Float_t & qmax )

protected

// Association of hits to the various track elements.

Definition at line 1845 of file IceDwalk.cxx.

ClusterTracks()

void IceDwalk::ClusterTracks ( TObjArray & tes, TObjArray & jets, Float_t tangmax, Int_t tinvol, Float_t tdistmax, Float_t qmax )

protected

// Cluster track candidates within a certain opening angle into jets.
// Also the track should be within a certain maximum distance of the
// starting track in order to get clustered.
// The latter prevents clustering of (nearly) parallel track candidates
// crossing the detector a very different locations (e.g. muon bundles).
// The average r0 and t0 of the constituent tracks will be taken as the
// jet reference point. 

Definition at line 2136 of file IceDwalk.cxx.

DeepCore()

Int_t IceDwalk::DeepCore ( TObjArray & hits )

protected

// The direct walk track reconstruction for the DeepCore DOM signals c.q. criteria.
// The procedure here is optimised to provide a direct walk track with the
// lowest possible energy threshold at the expense of having a worse than average
// pointing accuracy at these low energies.
// The reconstruction details are steered via the various parameters and the choice of
// (un)conditional processing.
//
// The return argument indicates whether or not a track has been found

Definition at line 1512 of file IceDwalk.cxx.

Exec()

void IceDwalk::Exec ( Option_t * opt )

virtual

// Implementation of the direct walk track reconstruction.

Reimplemented from IceRecoBase.

Definition at line 1117 of file IceDwalk.cxx.

IceCube()

Int_t IceDwalk::IceCube ( TObjArray & hits )

protected

// The direct walk track reconstruction for the standard IceCube InIce DOM signals c.q. criteria.
// The procedure here is optimised to provide a direct walk track with better than average
// pointing accuracy (i.e. slightly higher energy threshold) on the expense of sometimes
// not making a reco track at all.
// The reconstruction details are steered via the various parameters and the choice of
// (un)conditional processing.
//
// The return argument indicates whether or not a track has been found

Definition at line 1387 of file IceDwalk.cxx.

InIce()

Int_t IceDwalk::InIce ( TObjArray & hits )

protected

// The direct walk track reconstruction for all InIce DOM signals c.q. criteria.
// The procedure here is optimised to provide at least one direct walk track
// in most of the events (i.e. opt for somewhat lower energy threshold) at the
// expense of having a pointing accuracy slightly worse than average. 
// The reconstruction details are steered via the various parameters and the choice of
// (un)conditional processing.
//
// The return argument indicates whether or not a track has been found

Definition at line 1450 of file IceDwalk.cxx.

MakeTEs()

Int_t IceDwalk::MakeTEs ( Int_t cln, Int_t maxhits, Float_t dmin, Float_t dtmarg, Float_t dtmin, Float_t dtmax, TString domclass, TObjArray & tes, TObjArray & hits, Int_t gethits )

protected

// Creation of Track Elements (TEs) which (via hit association) may form track candidates (TCs).
// The TE selection criteria (reflecting IC, I or DC parameters) are steered via "maxhits", "dmin", "dtmarg",
// "dtmin" and "dtmax", whereas the DOMs to be used are specified independently via "domclass". 
// The created TEs are returned via the array "tes".
// Also the hits for further processing are selected and returned via the array "hits".
// In case the input argument "gethits" is set to 1, the array "hits" will be newly filled with the hits
// recorded by the DOMs corresponding to "domclass".
// However, when gethits=0, the existing hits in the array "hits" will be used.
// The latter case allows to remove hits from the existing list in subsequent processing steps
// (e.g. remove hits which were already associated to tracks reconstructed previously with other criteria).

Definition at line 1579 of file IceDwalk.cxx.

MergeJets()

void IceDwalk::MergeJets ( TObjArray & jets, Float_t jangmax, Float_t jdistmax, Int_t jinvol, Int_t jiterate, Float_t qmax )

protected

// Merge jets within a certain opening to provide the final track(s).
// Also the jet should be within a certain maximum distance of the
// starting jet in order to get merged.
// The latter prevents merging of (nearly) parallel jets/tracks
// crossing the detector a very different locations (e.g. muon bundles).
// The average r0 and t0 of the constituent jets will be taken as the
// final reference point. 

Definition at line 2367 of file IceDwalk.cxx.

SelectQvalue()

void IceDwalk::SelectQvalue ( TObjArray & tes, Float_t qmax )

protected

// Perform selection on Q value in case of multiple track candidates

Definition at line 2093 of file IceDwalk.cxx.

SetAsType()

void IceDwalk::SetAsType	(	Int_t	flag,
		TString	s,
		Float_t	w = -1 )

// Select number of associated hits and/or strings as quality indicator
// for each Track Candidate (TC).
//
// flag =  1 : Weighted number of associated hits (nah) is used as quality indicator
//      =  2 : Number of associated strings (nas) is used as quality indicator
//      =  3 : nah*nas is used as quality indicator
//      =  4 : nah+nahlc/nah+w*(nas-1)/nas is used as quality indicator
//      = -1 : Number of associated modules (nam) and strings is used as (nam+w*nas) quality indicator
//      = -2 : nam+nah/nam is used as quality indicator
//      = -3 : nam*nas is used as quality indicator
//      = -4 : nam+nahlc/nah+w*(nas-1)/nas is used as quality indicator
//      = -5 : nam+nah+nahlc/nah+w*(nas-1)/nas is used as quality indicator
//
// where nahlc is the weighted number of associated HLC hits and w is the weight
// of the string count w.r.t. the hit or module count in the quality indicator.
//
// Each associated hit is counted with a value=hitweight*lambda/d, where lambda is the scattering length
// and d is the distance traveled by a cherenkov photon to the fired module.
// Hits with d<lambda are given a value=1.
// For details about the hitweight please refer to the memberfunction SetHitWeight().
//
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction
//
// In case the input argument "w" is not provided, the current weight will not
// be modified. 
//
// For default values please refer to the default constructor of this class.

Definition at line 938 of file IceDwalk.cxx.

SetConditionalReco()

void IceDwalk::SetConditionalReco

(

Int_t

flag

)

// Set flag for conditional reconstruction of the various detector combinations.
// This will allow to save considerably on cpu time, especially for large events.
//
// flag :  0 ==> Invoke all the various reconstructions in the order "IC", "I" and "DC"
//               by using only the hits belonging to the corresponding detector (combination).
//         1 ==> Same as flag=0 but no "I" reconstruction in case at least one "IC" track was found.
//         2 ==> Same as flag=1 but also no "DC" reconstruction in case at least one "IC" or "I" track was found.
//         3 ==> Invoke all the various reconstructions in the order "IC", "I" and "DC"
//               by using all the InIce hits.
//         4 ==> Same as flag=3 but no "I" reconstruction in case at least one "IC" track was found.
//         5 ==> Same as flag=4 but also no "DC" reconstruction in case at least one "IC" or "I" track was found.
//         6 ==> Invoke all the various reconstructions in the order "IC", "I" and "DC"
//               by using all the InIce hits and removing all the hits associated to tracks of a previous
//               reconstruction before the next reconstruction is invoked.
//         7 ==> Same as flag=6 but no "I" reconstruction in case at least one "IC" track was found.
//         8 ==> Same as flag=7 but also no "DC" reconstruction in case at least one "IC" or "I" track was found.
//
// For the default value please refer to the default constructor of this class.
//
// Notes :
// -------
// 1) In case of inconsistent input the current setting will not be modified.
// 2) For flag<=2 the indications "IC", "I" and "DC" reflect both the used hits and the reconstruction parameters,
//    whereas for flag>=3 these labels only reflect the used reconstruction parameters. 
//    The various reconstruction parameters are tuned as follows :
//    "IC" : The procedure is optimised to provide a direct walk track with better than average
//           pointing accuracy (i.e. slightly higher energy threshold) on the expense of sometimes
//           not making a reco track at all.
//    "I"  : The procedure is optimised to provide at least one direct walk track
//           in most of the events (i.e. opt for somewhat lower energy threshold) at the
//           expense of having a pointing accuracy slightly worse than average. 
//    "DC" : The procedure is optimised to provide a direct walk track with the
//           lowest possible energy threshold at the expense of having a worse than average
//           pointing accuracy at these low energies.
// 3) Invokation of the SetMaxHits memberfunction with a negative number will de-activate
//    the "IC", "I" or "DC" detector configuration for reconstruction if flag<=2, but for flag>=3
//    it will only de-activate the "IC", "I" or "DC" selection criteria while keeping all InIce hits.

Definition at line 1050 of file IceDwalk.cxx.

SetDmin()

void IceDwalk::SetDmin	(	Float_t	d,
		TString	s )

// Set minimum hit distance (in m) to form a track element.
// For default values please refer to the default constructor of this class.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction

Definition at line 479 of file IceDwalk.cxx.

SetDthit()

void IceDwalk::SetDthit	(	Float_t	dtmin,
		Float_t	dtmax,
		TString	s )

// Set time interval [dtmin,dtmax] (in ns) around the expected hit time (t=0)
// for a hit to get associated.
// By the definition of t=0 for the expected hit time, this just means that
// the time residual (tres) has to fall within [dtmin,dtmax].
//
// Note : dtmin may be negative to account for early arrival times due to
//        jitter in the (D)OM electronics.
//
// For default values please refer to the default constructor of this class.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction

Definition at line 606 of file IceDwalk.cxx.

SetDtmarg()

void IceDwalk::SetDtmarg	(	Int_t	dt,
		TString	s )

// Set maximum hit time residual margin (in ns) for track elements w.r.t.
// the expected hit time difference based on a particle traveling at c between
// the two corresponding DOMs. This will guarantee causality for the track elements.
// Specification of dt<0 will result in using the same time window as for
// hit association (see memberfunction SetDthit).
// For default values please refer to the default constructor of this class.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction

Definition at line 520 of file IceDwalk.cxx.

SetHitWeight()

void IceDwalk::SetHitWeight

(

Float_t

w

)

// Set weight for associated hit counting.
// Every associated hit will contribute to the quality of a track candidate as :
//
// value=w*lambda/dist
//
// Here "lambda" is the average photon scattering length and "dist" is the
// distance traveled by a cherenkov photon to the fired (D)OM.
//
// The weighted number of associated hits (nah) is represented by the sum of all
// the above mentioned "value" contributions.
//
// Notes :
// -------
// 1) For dist<lambda the fraction lambda/dist will always be set to 1.
// 2) Setting w=0 will deactivate nah as track candidate quality indicator.
// 3) Setting w=-1 will result in value=1, so that nah represents an unweighted hit count.
// 3) Setting w=-2 will result in value=amp*lambda/dist, where "amp" is the hit amplitude in npe
//
// For default values please refer to the default constructor of this class.

Definition at line 1018 of file IceDwalk.cxx.

SetJangmax()

void IceDwalk::SetJangmax	(	Float_t	ang,
		TString	s,
		Int_t	iter = 1 )

// Set angular separation (in deg) within which jets are merged into 1 single track.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction
//
// The merging process is a dynamic procedure and can be carried out by
// iteration (iter=1) until no further merging of the various jets occurs anymore.
// However, by specification of iter=0 the user can also select to go only
// once through all the jet combinations to check for mergers.
// For large events the latter will in general result in more track candidates.  
// At invokation of this memberfunction the default is iter=1.
// In the constructor the default angle has been set to half  of the value of the
// default track candidate clustering separation angle.
// For default values please refer to the default constructor of this class.
//
// 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.

Definition at line 797 of file IceDwalk.cxx.

SetJdistmax()

void IceDwalk::SetJdistmax	(	Float_t	d,
		TString	s,
		Int_t	invol = 1 )

// Set maximum distance (in m) of the two jets in the jet merging process.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction
//
// The distance between the two jets can be determined restricted to the
// detector volume (invol=1) or in the overall space (invol=0).  
// The former will prevent clustering of (nearly) parallel tracks which cross
// the detector volume at very different locations, whereas the latter will
// enable clustering of tracks with a common location of origin (e.g. muon
// bundles from an air shower) even if they cross the detector volume at
// very different locations. 
// At invokation of this memberfunction the default is invol=1.
// For default values please refer to the default constructor of this class.

Definition at line 873 of file IceDwalk.cxx.

SetMaxDhit()

void IceDwalk::SetMaxDhit	(	Float_t	d,
		TString	s )

// Set maximum distance (in scattering length) for a hit to get associated.
// For default values please refer to the default constructor of this class.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction

Definition at line 565 of file IceDwalk.cxx.

SetQvalueCut()

void IceDwalk::SetQvalueCut

(

Float_t

qcut

)

// Set threshold for final track Qvalue selection.
// Tracks with Qvalue<qcut*qmax will not be kept.
//
// For the default value please refer to the default constructor of this class.

Definition at line 1100 of file IceDwalk.cxx.

SetTangmax()

void IceDwalk::SetTangmax	(	Float_t	ang,
		TString	s )

// Set maximum angular separation (in deg) for track candidate clustering into jets.
// For the default value please refer to the default constructor of this class.
//
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction
//
// Note : This function also sets automatically the value of the maximum
//        angular separation for jet merging into 1 single track to ang/2.
//        In order to specify a different max. jet merging separation angle,
//        one has to invoke the memberfunction SetJangmax afterwards.

Definition at line 669 of file IceDwalk.cxx.

SetTdistmax()

void IceDwalk::SetTdistmax	(	Float_t	d,
		TString	s,
		Int_t	invol = 1 )

// Set maximum distance (in m) of the two track candidates in the track
// clustering process.
// The input argument "s" allows for detector specification.
//
// s = "A"  --> Amanda reconstruction
//     "IC" --> Standard IceCube optimised reconstruction
//     "DC" --> DeepCore optimised reconstruction
//     "I"  --> InIce (IC+DC hybrid) optimised reconstruction
//
// The distance between the two tracks can be determined restricted to the
// detector volume (invol=1) or in the overall space (invol=0).  
// The former will prevent clustering of (nearly) parallel tracks which cross
// the detector volume at very different locations, whereas the latter will
// enable clustering of tracks with a common location of origin (e.g. muon
// bundles from an air shower) even if they cross the detector volume at
// very different locations. 
// At invokation of this memberfunction the default is invol=1.
// For default values please refer to the default constructor of this class.

Definition at line 731 of file IceDwalk.cxx.

StoreTracks()

Int_t IceDwalk::StoreTracks ( TObjArray & jets, Int_t minahits, Int_t minamods, Float_t jangmax, TString name, TString title, TObjArray & hits )

protected

// Store every jet as a reconstructed track in the event structure,
// provided it has sufficient associated hits.
// The jet 3-momentum (normalised to 1) and reference point
// (i.e.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.

Definition at line 2574 of file IceDwalk.cxx.

Member Data Documentation

fAsTypeA

Int_t IceDwalk::fAsTypeA

protected

Definition at line 83 of file IceDwalk.h.

fAsTypeDC

Int_t IceDwalk::fAsTypeDC

protected

Definition at line 86 of file IceDwalk.h.

fAsTypeI

Int_t IceDwalk::fAsTypeI

protected

Definition at line 84 of file IceDwalk.h.

fAsTypeIC

Int_t IceDwalk::fAsTypeIC

protected

Definition at line 85 of file IceDwalk.h.

fConditional

Int_t IceDwalk::fConditional

protected

Definition at line 92 of file IceDwalk.h.

fDminA

Float_t IceDwalk::fDminA

protected

Definition at line 35 of file IceDwalk.h.

fDminDC

Float_t IceDwalk::fDminDC

protected

Definition at line 38 of file IceDwalk.h.

fDminI

Float_t IceDwalk::fDminI

protected

Definition at line 36 of file IceDwalk.h.

fDminIC

Float_t IceDwalk::fDminIC

protected

Definition at line 37 of file IceDwalk.h.

fDtmargA

Int_t IceDwalk::fDtmargA

protected

Definition at line 39 of file IceDwalk.h.

fDtmargDC

Int_t IceDwalk::fDtmargDC

protected

Definition at line 42 of file IceDwalk.h.

fDtmargI

Int_t IceDwalk::fDtmargI

protected

Definition at line 40 of file IceDwalk.h.

fDtmargIC

Int_t IceDwalk::fDtmargIC

protected

Definition at line 41 of file IceDwalk.h.

fDtmaxA

Float_t IceDwalk::fDtmaxA

protected

Definition at line 48 of file IceDwalk.h.

fDtmaxDC

Float_t IceDwalk::fDtmaxDC

protected

Definition at line 54 of file IceDwalk.h.

fDtmaxI

Float_t IceDwalk::fDtmaxI

protected

Definition at line 50 of file IceDwalk.h.

fDtmaxIC

Float_t IceDwalk::fDtmaxIC

protected

Definition at line 52 of file IceDwalk.h.

fDtminA

Float_t IceDwalk::fDtminA

protected

Definition at line 47 of file IceDwalk.h.

fDtminDC

Float_t IceDwalk::fDtminDC

protected

Definition at line 53 of file IceDwalk.h.

fDtminI

Float_t IceDwalk::fDtminI

protected

Definition at line 49 of file IceDwalk.h.

fDtminIC

Float_t IceDwalk::fDtminIC

protected

Definition at line 51 of file IceDwalk.h.

fHitweight

Float_t IceDwalk::fHitweight

protected

Definition at line 91 of file IceDwalk.h.

fJangmaxA

Float_t IceDwalk::fJangmaxA

protected

Definition at line 67 of file IceDwalk.h.

fJangmaxDC

Float_t IceDwalk::fJangmaxDC

protected

Definition at line 70 of file IceDwalk.h.

fJangmaxI

Float_t IceDwalk::fJangmaxI

protected

Definition at line 68 of file IceDwalk.h.

fJangmaxIC

Float_t IceDwalk::fJangmaxIC

protected

Definition at line 69 of file IceDwalk.h.

fJdistmaxA

Float_t IceDwalk::fJdistmaxA

protected

Definition at line 75 of file IceDwalk.h.

fJdistmaxDC

Float_t IceDwalk::fJdistmaxDC

protected

Definition at line 78 of file IceDwalk.h.

fJdistmaxI

Float_t IceDwalk::fJdistmaxI

protected

Definition at line 76 of file IceDwalk.h.

fJdistmaxIC

Float_t IceDwalk::fJdistmaxIC

protected

Definition at line 77 of file IceDwalk.h.

fJinvolA

Int_t IceDwalk::fJinvolA

protected

Definition at line 79 of file IceDwalk.h.

fJinvolDC

Int_t IceDwalk::fJinvolDC

protected

Definition at line 82 of file IceDwalk.h.

fJinvolI

Int_t IceDwalk::fJinvolI

protected

Definition at line 80 of file IceDwalk.h.

fJinvolIC

Int_t IceDwalk::fJinvolIC

protected

Definition at line 81 of file IceDwalk.h.

fJiterateA

Int_t IceDwalk::fJiterateA

protected

Definition at line 71 of file IceDwalk.h.

fJiterateDC

Int_t IceDwalk::fJiterateDC

protected

Definition at line 74 of file IceDwalk.h.

fJiterateI

Int_t IceDwalk::fJiterateI

protected

Definition at line 72 of file IceDwalk.h.

fJiterateIC

Int_t IceDwalk::fJiterateIC

protected

Definition at line 73 of file IceDwalk.h.

fMaxdhitA

Float_t IceDwalk::fMaxdhitA

protected

Definition at line 43 of file IceDwalk.h.

fMaxdhitDC

Float_t IceDwalk::fMaxdhitDC

protected

Definition at line 46 of file IceDwalk.h.

fMaxdhitI

Float_t IceDwalk::fMaxdhitI

protected

Definition at line 44 of file IceDwalk.h.

fMaxdhitIC

Float_t IceDwalk::fMaxdhitIC

protected

Definition at line 45 of file IceDwalk.h.

fQcut

Float_t IceDwalk::fQcut

protected

Definition at line 93 of file IceDwalk.h.

fTangmaxA

Float_t IceDwalk::fTangmaxA

protected

Definition at line 55 of file IceDwalk.h.

fTangmaxDC

Float_t IceDwalk::fTangmaxDC

protected

Definition at line 58 of file IceDwalk.h.

fTangmaxI

Float_t IceDwalk::fTangmaxI

protected

Definition at line 56 of file IceDwalk.h.

fTangmaxIC

Float_t IceDwalk::fTangmaxIC

protected

Definition at line 57 of file IceDwalk.h.

fTdistmaxA

Float_t IceDwalk::fTdistmaxA

protected

Definition at line 59 of file IceDwalk.h.

fTdistmaxDC

Float_t IceDwalk::fTdistmaxDC

protected

Definition at line 62 of file IceDwalk.h.

fTdistmaxI

Float_t IceDwalk::fTdistmaxI

protected

Definition at line 60 of file IceDwalk.h.

fTdistmaxIC

Float_t IceDwalk::fTdistmaxIC

protected

Definition at line 61 of file IceDwalk.h.

fTinvolA

Int_t IceDwalk::fTinvolA

protected

Definition at line 63 of file IceDwalk.h.

fTinvolDC

Int_t IceDwalk::fTinvolDC

protected

Definition at line 66 of file IceDwalk.h.

fTinvolI

Int_t IceDwalk::fTinvolI

protected

Definition at line 64 of file IceDwalk.h.

fTinvolIC

Int_t IceDwalk::fTinvolIC

protected

Definition at line 65 of file IceDwalk.h.

fWstringA

Float_t IceDwalk::fWstringA

protected

Definition at line 87 of file IceDwalk.h.

fWstringDC

Float_t IceDwalk::fWstringDC

protected

Definition at line 90 of file IceDwalk.h.

fWstringI

Float_t IceDwalk::fWstringI

protected

Definition at line 88 of file IceDwalk.h.

fWstringIC

Float_t IceDwalk::fWstringIC

protected

Definition at line 89 of file IceDwalk.h.

---

The documentation for this class was generated from the following files:

• icepack/source/IceDwalk.h
• icepack/source/IceDwalk.cxx