NCFS-Pack
A generic (astro)particle physics analysis framework
 
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
IceDwalkx Class Reference

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

#include "IceDwalkx.h"

Inheritance diagram for IceDwalkx:
IceLinefit IceRecoBase

Detailed Description

TTask derived class 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.
IceDwalkx::IceCube
virtual Int_t IceCube()
Definition IceDwalkx.cxx:1345
// Class IceDwalkx
// TTask derived class 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).
// 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.
// By default the minimum and maximum are set to 0 and 999999, respectively,
// in the constructor, which implies no multiplicity selection.
// The maximum number of good hits per (D)OM to be used for the reconstruction
// can be specified via the memberfunction SetMaxHits().
// By default only the first good hit of each (D)OM is used but the user may want
// to extend this number to the first n hits of each (D)OM to account for possible
// noise and/or afterpulse signals that are not recognised by the hit cleaning procedure.
// 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.
//
// 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.
//
// Another facility to (automatically) select reconstruction of specific detector
// configurations 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 name of the track.
// A suffix "A" for an Amanda (OM) track, "IC" for a standard IceCube InIce (DOM) track,
// "I" for a hybrid InIce (DOM) track or "DC" for a DeepCore (DOM) track will be
// added to the name automatically.
// 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.
// 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 ia also available from the track timestamp .
//
// Information about the actual parameter settings can be found in the event
// structure itself via the device named "IceDwalkx".
//
// 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, according to eq. (20) of the NIM article.
// The default value for d is 75 (A), 120 (IC), 60 (I) and 50 (DC) meter,
// but this can be modified via the memberfunction SetDmin().
// By default dt=(hit distance)/c but an additional time margin
// (set to 0 by default) 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.
//
// 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/lambda < F
//
// tres : time residual
// Difference between the observed hit time and the time expected
// for a direct photon hit.
// dhit : Distance traveled by the cherenkov photon from the track to the hit position
// lambda : Photon scattering length in ice
//
// The default values of the scattering length are 33.3 (A), 30 (IC), 33 (I) and 35 (DC) meter,
// but this can be modified via the memberfunction SetScatteringLength().
// By default F is set to 3.07126 (A) and 3 (IC, I, DC), but this can be modified via
// the memberfunction SetMaxDhit().
//
// 3) Construction of track candidates (TC's).
// These are TE's that fulfill both the conditions
//
// nax >= 1
// qtc >= 0.8*qtcmax
//
// where we have defined :
//
// nax : Associated hits and/or strings value for the specific TE.
// qtc : The track quality number (see hereafter).
// qtcmax : Maximum quality number encountered for the TE's.
//
// Note : 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 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 default maximum track opening angle is 15 degrees, but can be modified
// via the SetTangmax memberfunction.
// The default maximum track distance is 20 meters, but can be modified
// 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 number defined as :
//
// qtcjet=|jet momentum|/ntracks
//
// This jet quality number is refined on basis of the number of hits
// associated to the jet as :
//
// qtcjet=qtcjet+0.2*(nax-naxmax)
//
// where we have defined :
//
// nax : Associated hits and/or strings value for the specific jet.
// naxmax : Maximum number of associated hits (or strings) encountered for the jets.
//
// This qtcjet value is then used to order the various jets w.r.t.
// decreasing qtcjet quality number.
//
// Note : The qtcjet value 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 qtcjet value)
// are merged when their directions are within a certain maximum opening angle.
// In addition a jet must 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 since the quality numbers of the
// resulting merged jets have been automatically updated in the merging process.
//
// The default maximum jet distance is 30 meters, but can be modified
// 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 quality number.
// As such the jet with the highest quality number 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 quality number, as outlined hereafter.
// 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 reference point data of the jet will provide the r0 and t0
// (i.e. reference point) of the track.
//
// All these reconstructed tracks will be stored in the IceEvent structure
// using the naming conventions outlined above.
//
// 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,
// cross talk corrected (Amanda) and cleaned from noise hits etc. (IceCleanHits).
//
//--- Author: Nick van Eijndhoven 07-oct-2005 Utrecht University
//- Modified: NvE $Date: 2012-07-13 16:17:43 +0200 (Fri, 13 Jul 2012) $ NCFS

Definition at line 15 of file IceDwalkx.h.

Public Member Functions

 IceDwalkx (const char *name="IceDwalkx", const char *title="Direct walk reconstruction")
 
virtual ~IceDwalkx ()
 
virtual void Exec (Option_t *opt)
 
void SetAsType (Int_t flag, TString s)
 
void SetConditionalReco (Int_t flag)
 
void SetDmin (Float_t d, TString s)
 
void SetDtmarg (Int_t dt, TString s)
 
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 SetScatteringLength (Float_t lambda, TString s)
 
void SetTangmax (Float_t ang, TString s)
 
void SetTdistmax (Float_t d, TString s, Int_t invol=1)
 
void SetVgroupUsage (Int_t flag, TString s)
 
- Public Member Functions inherited from IceLinefit
 IceLinefit (const char *name="IceLinefit", const char *title="Linefit reconstruction")
 
virtual ~IceLinefit ()
 
- 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

virtual void Amanda ()
 
virtual void AssociateHits (TObjArray &tes, TObjArray &hits, Int_t vgroup, Float_t maxdhit, Int_t astype, Float_t &qmax, Float_t lambda)
 
virtual void ClusterTracks (TObjArray &tes, TObjArray &jets, Float_t tangmax, Int_t tinvol, Float_t tdistmax, Int_t astype, Float_t qmax)
 
virtual Int_t DeepCore ()
 
virtual Int_t IceCube ()
 
virtual Int_t InIce ()
 
virtual void MergeJets (TObjArray &jets, Float_t jangmax, Float_t jdistmax, Int_t jinvol, Int_t jiterate, Int_t astype)
 
virtual void SelectQvalue (TObjArray &tes, Int_t astype, Float_t qmax)
 
virtual void StoreTracks (TObjArray &jets, Float_t jangmax, TString name, TString title)
 
- Protected Member Functions inherited from IceLinefit
Int_t Amanda ()
 
Int_t DeepCore ()
 
Int_t IceCube ()
 
Int_t InIce ()
 
NcTrack * Reconstruct (TObjArray *doms, Int_t cln, Int_t minmod, Int_t maxmod, Int_t maxhits, Int_t minahits, Int_t minamods, Int_t slc)
 
Int_t Tracks ()
 
- 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
 
IceEvent * fEvt
 
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 fLambdaA
 
Float_t fLambdaDC
 
Float_t fLambdaI
 
Float_t fLambdaIC
 
Float_t fMaxdhitA
 
Float_t fMaxdhitDC
 
Float_t fMaxdhitI
 
Float_t fMaxdhitIC
 
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
 
Int_t fVgroupA
 
Int_t fVgroupDC
 
Int_t fVgroupI
 
Int_t fVgroupIC
 
- 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

◆ IceDwalkx()

IceDwalkx::IceDwalkx ( const char * name = "IceDwalkx",
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 295 of file IceDwalkx.cxx.

◆ ~IceDwalkx()

IceDwalkx::~IceDwalkx ( )
virtual
// Default destructor.

Definition at line 380 of file IceDwalkx.cxx.

Member Function Documentation

◆ Amanda()

void IceDwalkx::Amanda ( )
protectedvirtual
// The direct walk track reconstruction for Amanda OM signals.

Definition at line 944 of file IceDwalkx.cxx.

◆ AssociateHits()

void IceDwalkx::AssociateHits ( TObjArray & tes,
TObjArray & hits,
Int_t vgroup,
Float_t maxdhit,
Int_t astype,
Float_t & qmax,
Float_t lambda )
protectedvirtual
// Association of hits to the various track elements.

Definition at line 1755 of file IceDwalkx.cxx.

◆ ClusterTracks()

void IceDwalkx::ClusterTracks ( TObjArray & tes,
TObjArray & jets,
Float_t tangmax,
Int_t tinvol,
Float_t tdistmax,
Int_t astype,
Float_t qmax )
protectedvirtual
// 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 1987 of file IceDwalkx.cxx.

◆ DeepCore()

Int_t IceDwalkx::DeepCore ( )
protectedvirtual
// The direct walk track reconstruction for the DeepCore DOM signals.
// 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 return argument indicates whether or not a track has been found

Definition at line 1550 of file IceDwalkx.cxx.

◆ Exec()

void IceDwalkx::Exec ( Option_t * opt)
virtual
// Implementation of the direct walk track reconstruction.

Reimplemented from IceLinefit.

Definition at line 760 of file IceDwalkx.cxx.

◆ IceCube()

Int_t IceDwalkx::IceCube ( )
protectedvirtual
// The direct walk track reconstruction for the standard IceCube InIce DOM signals.
// 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 return argument indicates whether or not a track has been found

Definition at line 1345 of file IceDwalkx.cxx.

◆ InIce()

Int_t IceDwalkx::InIce ( )
protectedvirtual
// The direct walk track reconstruction for all InIce DOM signals.
// 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 return argument indicates whether or not a track has been found

Definition at line 1140 of file IceDwalkx.cxx.

◆ MergeJets()

void IceDwalkx::MergeJets ( TObjArray & jets,
Float_t jangmax,
Float_t jdistmax,
Int_t jinvol,
Int_t jiterate,
Int_t astype )
protectedvirtual
// 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 2134 of file IceDwalkx.cxx.

◆ SelectQvalue()

void IceDwalkx::SelectQvalue ( TObjArray & tes,
Int_t astype,
Float_t qmax )
protectedvirtual
// Perform selection on Q value in case of multiple track candidates

Definition at line 1937 of file IceDwalkx.cxx.

◆ SetAsType()

void IceDwalkx::SetAsType ( Int_t flag,
TString s )
// Select number of associated hits and/or strings as quality indicator.
//
// flag = 1 : 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
//
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// By default the flag value is set to 3 in the constructor of this class.

Definition at line 687 of file IceDwalkx.cxx.

◆ SetConditionalReco()

void IceDwalkx::SetConditionalReco ( Int_t flag)
// Set flag for conditional reconstruction of the various detector combinations.
// This will allow to save considerably on cpu time, especially on large events.
//
// flag : 0 ==> Always invoke all the various reconstructions
// 1 ==> No "I" reconstruction in case "IC" track was found
// 2 ==> Same as flag=1 but also no "DC" reconstruction in case "IC" or "I" track was found
//
// By default flag=1 is set in the constructor.
//
// Notes :
// -------
// 1) Reconstruction in a specific detector can always be de-activated by
// invokation of the SetMaxHits memberfunction.
// 2) In case of inconsistent input the current setting will not be modified.

Definition at line 736 of file IceDwalkx.cxx.

◆ SetDmin()

void IceDwalkx::SetDmin ( Float_t d,
TString s )
// Set minimum hit distance (in m) to form a track element.
// For default values please refer to the general documentation of this class.
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs

Definition at line 389 of file IceDwalkx.cxx.

◆ SetDtmarg()

void IceDwalkx::SetDtmarg ( Int_t dt,
TString s )
// Set maximum hit time difference margin (in ns) for track elements.
// For default values please refer to the general documentation of this class.
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs

Definition at line 410 of file IceDwalkx.cxx.

◆ SetJangmax()

void IceDwalkx::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 OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// 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 7.5 deg, being half
// of the value of the default track candidate clustering separation angle.
// The iteration flag was set to 1 in the constructor.
//
// 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 550 of file IceDwalkx.cxx.

◆ SetJdistmax()

void IceDwalkx::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 OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// 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.
// In the constructor the default has been set to 30 meter with invol=1.

Definition at line 611 of file IceDwalkx.cxx.

◆ SetMaxDhit()

void IceDwalkx::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 general documentation of this class.
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs

Definition at line 431 of file IceDwalkx.cxx.

◆ SetScatteringLength()

void IceDwalkx::SetScatteringLength ( Float_t lambda,
TString s )
// Set average photon scattering length in meter.
// For default values please refer to the general documentation of this class.
//
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs

Definition at line 714 of file IceDwalkx.cxx.

◆ SetTangmax()

void IceDwalkx::SetTangmax ( Float_t ang,
TString s )
// Set maximum angular separation (in deg) for track candidate clustering
// into jets.
// In the constructor the default has been set to 15 deg, in accordance
// to NIM A524 (2004) 180.
//
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// 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 452 of file IceDwalkx.cxx.

◆ SetTdistmax()

void IceDwalkx::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 OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// 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.
// In the constructor the default has been set to 20 meter with invol=1.

Definition at line 500 of file IceDwalkx.cxx.

◆ SetVgroupUsage()

void IceDwalkx::SetVgroupUsage ( Int_t flag,
TString s )
// (De)activate the distinction between v_phase and v_group of the Cherenkov light.
//
// flag = 0 : No distinction between v_phase and v_group
// = 1 : Separate treatment of v_phase and v_group
//
// The input argument "s" allows for detector specification.
//
// s = "A" --> Amanda OMs
// "I" --> InIce DOMs
// "IC" --> Standard IceCube InIce DOMs
// "DC" --> DeepCore DOMs
//
// By default the distinction between v_phase and v_group is activated
// in the constructor of this class.

Definition at line 660 of file IceDwalkx.cxx.

◆ StoreTracks()

void IceDwalkx::StoreTracks ( TObjArray & jets,
Float_t jangmax,
TString name,
TString title )
protectedvirtual
// Store every jet as a reconstructed track in the event structure.
// 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 2276 of file IceDwalkx.cxx.

Member Data Documentation

◆ fAsTypeA

Int_t IceDwalkx::fAsTypeA
protected

Definition at line 79 of file IceDwalkx.h.

◆ fAsTypeDC

Int_t IceDwalkx::fAsTypeDC
protected

Definition at line 82 of file IceDwalkx.h.

◆ fAsTypeI

Int_t IceDwalkx::fAsTypeI
protected

Definition at line 80 of file IceDwalkx.h.

◆ fAsTypeIC

Int_t IceDwalkx::fAsTypeIC
protected

Definition at line 81 of file IceDwalkx.h.

◆ fConditional

Int_t IceDwalkx::fConditional
protected

Definition at line 87 of file IceDwalkx.h.

◆ fDminA

Float_t IceDwalkx::fDminA
protected

Definition at line 35 of file IceDwalkx.h.

◆ fDminDC

Float_t IceDwalkx::fDminDC
protected

Definition at line 38 of file IceDwalkx.h.

◆ fDminI

Float_t IceDwalkx::fDminI
protected

Definition at line 36 of file IceDwalkx.h.

◆ fDminIC

Float_t IceDwalkx::fDminIC
protected

Definition at line 37 of file IceDwalkx.h.

◆ fDtmargA

Int_t IceDwalkx::fDtmargA
protected

Definition at line 39 of file IceDwalkx.h.

◆ fDtmargDC

Int_t IceDwalkx::fDtmargDC
protected

Definition at line 42 of file IceDwalkx.h.

◆ fDtmargI

Int_t IceDwalkx::fDtmargI
protected

Definition at line 40 of file IceDwalkx.h.

◆ fDtmargIC

Int_t IceDwalkx::fDtmargIC
protected

Definition at line 41 of file IceDwalkx.h.

◆ fEvt

IceEvent* IceDwalkx::fEvt
protected

Definition at line 34 of file IceDwalkx.h.

◆ fJangmaxA

Float_t IceDwalkx::fJangmaxA
protected

Definition at line 59 of file IceDwalkx.h.

◆ fJangmaxDC

Float_t IceDwalkx::fJangmaxDC
protected

Definition at line 62 of file IceDwalkx.h.

◆ fJangmaxI

Float_t IceDwalkx::fJangmaxI
protected

Definition at line 60 of file IceDwalkx.h.

◆ fJangmaxIC

Float_t IceDwalkx::fJangmaxIC
protected

Definition at line 61 of file IceDwalkx.h.

◆ fJdistmaxA

Float_t IceDwalkx::fJdistmaxA
protected

Definition at line 67 of file IceDwalkx.h.

◆ fJdistmaxDC

Float_t IceDwalkx::fJdistmaxDC
protected

Definition at line 70 of file IceDwalkx.h.

◆ fJdistmaxI

Float_t IceDwalkx::fJdistmaxI
protected

Definition at line 68 of file IceDwalkx.h.

◆ fJdistmaxIC

Float_t IceDwalkx::fJdistmaxIC
protected

Definition at line 69 of file IceDwalkx.h.

◆ fJinvolA

Int_t IceDwalkx::fJinvolA
protected

Definition at line 71 of file IceDwalkx.h.

◆ fJinvolDC

Int_t IceDwalkx::fJinvolDC
protected

Definition at line 74 of file IceDwalkx.h.

◆ fJinvolI

Int_t IceDwalkx::fJinvolI
protected

Definition at line 72 of file IceDwalkx.h.

◆ fJinvolIC

Int_t IceDwalkx::fJinvolIC
protected

Definition at line 73 of file IceDwalkx.h.

◆ fJiterateA

Int_t IceDwalkx::fJiterateA
protected

Definition at line 63 of file IceDwalkx.h.

◆ fJiterateDC

Int_t IceDwalkx::fJiterateDC
protected

Definition at line 66 of file IceDwalkx.h.

◆ fJiterateI

Int_t IceDwalkx::fJiterateI
protected

Definition at line 64 of file IceDwalkx.h.

◆ fJiterateIC

Int_t IceDwalkx::fJiterateIC
protected

Definition at line 65 of file IceDwalkx.h.

◆ fLambdaA

Float_t IceDwalkx::fLambdaA
protected

Definition at line 83 of file IceDwalkx.h.

◆ fLambdaDC

Float_t IceDwalkx::fLambdaDC
protected

Definition at line 86 of file IceDwalkx.h.

◆ fLambdaI

Float_t IceDwalkx::fLambdaI
protected

Definition at line 84 of file IceDwalkx.h.

◆ fLambdaIC

Float_t IceDwalkx::fLambdaIC
protected

Definition at line 85 of file IceDwalkx.h.

◆ fMaxdhitA

Float_t IceDwalkx::fMaxdhitA
protected

Definition at line 43 of file IceDwalkx.h.

◆ fMaxdhitDC

Float_t IceDwalkx::fMaxdhitDC
protected

Definition at line 46 of file IceDwalkx.h.

◆ fMaxdhitI

Float_t IceDwalkx::fMaxdhitI
protected

Definition at line 44 of file IceDwalkx.h.

◆ fMaxdhitIC

Float_t IceDwalkx::fMaxdhitIC
protected

Definition at line 45 of file IceDwalkx.h.

◆ fTangmaxA

Float_t IceDwalkx::fTangmaxA
protected

Definition at line 47 of file IceDwalkx.h.

◆ fTangmaxDC

Float_t IceDwalkx::fTangmaxDC
protected

Definition at line 50 of file IceDwalkx.h.

◆ fTangmaxI

Float_t IceDwalkx::fTangmaxI
protected

Definition at line 48 of file IceDwalkx.h.

◆ fTangmaxIC

Float_t IceDwalkx::fTangmaxIC
protected

Definition at line 49 of file IceDwalkx.h.

◆ fTdistmaxA

Float_t IceDwalkx::fTdistmaxA
protected

Definition at line 51 of file IceDwalkx.h.

◆ fTdistmaxDC

Float_t IceDwalkx::fTdistmaxDC
protected

Definition at line 54 of file IceDwalkx.h.

◆ fTdistmaxI

Float_t IceDwalkx::fTdistmaxI
protected

Definition at line 52 of file IceDwalkx.h.

◆ fTdistmaxIC

Float_t IceDwalkx::fTdistmaxIC
protected

Definition at line 53 of file IceDwalkx.h.

◆ fTinvolA

Int_t IceDwalkx::fTinvolA
protected

Definition at line 55 of file IceDwalkx.h.

◆ fTinvolDC

Int_t IceDwalkx::fTinvolDC
protected

Definition at line 58 of file IceDwalkx.h.

◆ fTinvolI

Int_t IceDwalkx::fTinvolI
protected

Definition at line 56 of file IceDwalkx.h.

◆ fTinvolIC

Int_t IceDwalkx::fTinvolIC
protected

Definition at line 57 of file IceDwalkx.h.

◆ fVgroupA

Int_t IceDwalkx::fVgroupA
protected

Definition at line 75 of file IceDwalkx.h.

◆ fVgroupDC

Int_t IceDwalkx::fVgroupDC
protected

Definition at line 78 of file IceDwalkx.h.

◆ fVgroupI

Int_t IceDwalkx::fVgroupI
protected

Definition at line 76 of file IceDwalkx.h.

◆ fVgroupIC

Int_t IceDwalkx::fVgroupIC
protected

Definition at line 77 of file IceDwalkx.h.

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