Commit dc8a8988 authored by Atlas-Software Librarian's avatar Atlas-Software Librarian Committed by Graeme Stewart
Browse files

'CMakeLists.txt' (TrkDeterministicAnnealingFilter-01-00-04)

parent 8306f9ff
################################################################################
# Package: TrkDeterministicAnnealingFilter
################################################################################
# Declare the package name:
atlas_subdir( TrkDeterministicAnnealingFilter )
# Declare the package's dependencies:
atlas_depends_on_subdirs( PUBLIC
Control/AthenaBaseComps
GaudiKernel
Tracking/TrkEvent/TrkCompetingRIOsOnTrack
Tracking/TrkEvent/TrkEventPrimitives
Tracking/TrkEvent/TrkEventUtils
Tracking/TrkEvent/TrkParameters
Tracking/TrkFitter/TrkFitterInterfaces
Tracking/TrkFitter/TrkFitterUtils
Tracking/TrkTools/TrkToolInterfaces
PRIVATE
DetectorDescription/AtlasDetDescr
Tracking/TrkDetDescr/TrkSurfaces
Tracking/TrkEvent/TrkMeasurementBase
Tracking/TrkEvent/TrkPrepRawData
Tracking/TrkEvent/TrkRIO_OnTrack
Tracking/TrkEvent/TrkTrack
Tracking/TrkExtrapolation/TrkExInterfaces
Tracking/TrkValidation/TrkValInterfaces )
# Component(s) in the package:
atlas_add_component( TrkDeterministicAnnealingFilter
src/*.cxx
src/components/*.cxx
LINK_LIBRARIES AthenaBaseComps GaudiKernel TrkCompetingRIOsOnTrack TrkEventPrimitives TrkEventUtils TrkParameters TrkFitterInterfaces TrkFitterUtils TrkToolInterfaces AtlasDetDescr TrkSurfaces TrkMeasurementBase TrkPrepRawData TrkRIO_OnTrack TrkTrack TrkExInterfaces TrkValInterfaces )
# Install files from the package:
atlas_install_headers( TrkDeterministicAnnealingFilter )
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//////////////////////////////////////////////////////////////////
// DAF_SimpleWeightCalculator.h
// Header file for DAF WeightCalculator
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Sebastian.Fleischmann@cern.ch
///////////////////////////////////////////////////////////////////
#ifndef TRK_DAF_SIMPLEWEIGHTCALCULATOR_H
#define TRK_DAF_SIMPLEWEIGHTCALCULATOR_H
#include "TrkToolInterfaces/IWeightCalculator.h"
#include "AthenaBaseComps/AthAlgTool.h"
//#include "CLHEP/Matrix/Vector.h"
//#include "CLHEP/Matrix/Matrix.h"
#include "TrkParameters/TrackParameters.h" // typedef
// just needed for assignProb typedef till now:
#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
namespace Trk {
class RIO_OnTrack;
/** Deterministic Annealing Filter implementation to calculate the assignmentProbabilities of
competing measurements to a track.
The following formulas are used to calculate the assignment probabilities, which are
proportional to a multivariate Gaussian distribution:
@f$ \phi_i = \exp \left( \frac{1}{2 \beta} (m_i - Hx)^T G_i (m_i - Hx) \right) @f$
(@f$ G = V^{-1} @f$)
for the non-normalized probabilities (@f$ \beta @f$ is the so-called annealing factor)
and
@f$ p_i = \frac{\phi_i}{ \phi^{cut} + \sum_j (\phi_j)) } @f$
for the normalization where
@f$ \phi^{cut} = \exp( \frac{1}{2} \frac{c}{\beta} ) @f$.
@f$ n @f$ is the dimension of the measurement vector (localParameters of the ROT) and
@f$ c @f$ is a cut-off parameter which might be detector dependend.
The annealing factor @f$ \beta @f$ is needed to increase the variances of the measurements
in the beginning of the annealing process and is lowered to 1 in this process.
The main difference to the Trk::DAF_WeightCalculator is the missing factor @f$ n= @f$ number of competing
measurements in the Trk::CompetingRIOsOnTrack in front of the cut parameter @f$ \phi^{cut} @f$ in
the normalization (this formulation was introduced here and is not described in the referenced papers).
Additionally potentially different covariances of the measurements within the
Trk::CompetingRIOsOnTrack are neglected.
*/
class DAF_SimpleWeightCalculator : virtual public IWeightCalculator, public AthAlgTool {
public:
// standard AlgToolmethods
DAF_SimpleWeightCalculator(const std::string&,const std::string&,const IInterface*);
~DAF_SimpleWeightCalculator();
// standard Athena methods
StatusCode initialize();
StatusCode finalize();
// /** calculate the assignment probabilities (assignment weights) for a collection of measurements:
// if doNormalization==true the AssignmentProbs will be normalized using the given cutValue*/
// virtual const std::vector< AssignmentProb >* calculateWeights (
// const TrackParameters&,
// const std::vector< const RIO_OnTrack* >*,
// const double cutValue,
// const bool doNormalization=true ) const;
/** calculate the assignment probabilities (assignment weights) for a collection of measurements:
if doNormalization==true the AssignmentProbs will be normalized using the given cutValue
use vector of TrackParameters to avoid transformations to local frame
(TrackParameters must be given on the associated surface of the particular ROT)*/
virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* calculateWeights (
const std::vector< const TrackParameters* >*,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue,
const bool doNormalization=true ) const;
/** calculate the assignment probability (assignment weight) for a single measurement (no normalization can be done in this case)*/
virtual Trk::CompetingRIOsOnTrack::AssignmentProb calculateWeight (
const TrackParameters&,
const RIO_OnTrack&,
const AnnealingFactor ) const;
/** normalize given assignment probabilities (assignment weights) using a given cutValue and annealing factor*/
virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* normalize (
const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >*,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue ) const;
/** normalize given assignment probabilities (assignment weights) using a given cutValue and annealing factor*/
virtual void normalize (
std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >&,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue ) const;
private:
};
} // end of namespace
#endif // TRK_DAF_SIMPLEWEIGHTCALCULATOR_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//////////////////////////////////////////////////////////////////
// DAF_WeightCalculator.h
// Header file for DAF WeightCalculator
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Sebastian.Fleischmann@cern.ch
///////////////////////////////////////////////////////////////////
#ifndef TRK_DAF_WEIGHTCALCULATOR_H
#define TRK_DAF_WEIGHTCALCULATOR_H
#include "TrkToolInterfaces/IWeightCalculator.h"
#include "AthenaBaseComps/AthAlgTool.h"
//#include "CLHEP/Matrix/Vector.h"
//#include "CLHEP/Matrix/Matrix.h"
#include "TrkParameters/TrackParameters.h"
// just needed for assignProb typedef till now:
#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
namespace Trk {
class RIO_OnTrack;
/** Deterministic Annealing Filter implementation to calculate the assignmentProbabilities of
competing measurements to a track.
The following formulas are used to calculate the assignment probabilities, which are
proportional to a multivariate Gaussian distribution:
@f$ \phi_i = \frac{1}{(2\pi)^{\frac{n}{2}} \sqrt{\beta det V_i}} \exp \left( \frac{1}{2 \beta} (m_i - Hx)^T G_i (m_i - Hx) \right) @f$
(@f$ G = V^{-1} @f$)
for the non-normalized probabilities (@f$ \beta @f$ is the so-called annealing factor)
and
@f$ p_i = \frac{\phi_i}{ \sum_j (\phi_j + \phi_j^{cut}) } @f$
for the normalization where
@f$ \phi_j^{cut} = \frac{1}{(2\pi)^{\frac{n}{2}} \sqrt{\beta det V_j}} \cdot \exp( \frac{1}{2} \frac{c}{\beta} ) @f$.
@f$ n @f$ is the dimension of the measurement vector (localParameters of the ROT) and
@f$ c @f$ is a cut-off parameter which might be detector dependend.
The annealing factor @f$ \beta @f$ is needed to increase the variances of the measurements
in the beginning of the annealing process and is lowered to 1 in this process.
*/
class DAF_WeightCalculator : virtual public IWeightCalculator, public AthAlgTool {
public:
// standard AlgToolmethods
DAF_WeightCalculator(const std::string&,const std::string&,const IInterface*);
~DAF_WeightCalculator();
// standard Athena methods
StatusCode initialize();
StatusCode finalize();
// /** calculate the assignment probabilities (assignment weights) for a collection of measurements:
// if doNormalization==true the AssignmentProbs will be normalized using the given cutValue*/
// virtual const std::vector< AssignmentProb >* calculateWeights (
// const TrackParameters&,
// const std::vector< const RIO_OnTrack* >*,
// const double cutValue,
// const bool doNormalization=true ) const;
/** calculate the assignment probabilities (assignment weights) for a collection of measurements:
if doNormalization==true the AssignmentProbs will be normalized using the given cutValue
use vector of TrackParameters to avoid transformations to local frame
(TrackParameters must be given on the associated surface of the particular ROT)*/
virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* calculateWeights (
const std::vector< const TrackParameters* >*,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue,
const bool doNormalization=true ) const;
/** calculate the assignment probability (assignment weight) for a single measurement (no normalization can be done in this case)*/
virtual Trk::CompetingRIOsOnTrack::AssignmentProb calculateWeight (
const TrackParameters&,
const RIO_OnTrack&,
const AnnealingFactor ) const;
/** normalize given assignment probabilities (assignment weights) using a given cutValue and annealing factor*/
virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* normalize (
const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >*,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue ) const;
/** normalize given assignment probabilities (assignment weights) using a given cutValue and annealing factor*/
virtual void normalize (
std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >&,
const std::vector< const RIO_OnTrack* >*,
const AnnealingFactor,
const double cutValue ) const;
private:
};
} // end of namespace
#endif // TRK_DAF_WEIGHTCALCULATOR_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//////////////////////////////////////////////////////////////////
// DeterministicAnnealingFilter.h
// Header file for class DeterministicAnnealingFilter
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
// Sebastian.Fleischmann@cern.ch
///////////////////////////////////////////////////////////////////
#ifndef TRK_DETERMINISTICANNEALINGFILTER_H
#define TRK_DETERMINISTICANNEALINGFILTER_H
#include "TrkFitterUtils/FitterTypes.h" // typedefs
#include "TrkFitterInterfaces/ITrackFitter.h"
#include "GaudiKernel/ToolHandle.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "TrkFitterUtils/FitterStatusCode.h" // needed for Trk::FitterStatusCode::Success
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkParameters/TrackParameters.h" // typedef
#include "TrkEventUtils/TrkParametersComparisonFunction.h" // typedef
class IAlgTool;
namespace Trk {
class Track; // ATLAS standard track class
class FitQuality;
class PerigeeSurface;
class IDynamicNoiseAdjustor;
class IExtrapolator; // Extrapolation Tool
class IUpdator; // If class for Estimator updating
class ICompetingRIOsOnTrackTool; // Interface for creation of compROT
// class ITrackFitter; // Interface class for track fitters
class IValidationNtupleTool;
//class IWeightCalculator;
class IForwardKalmanFitter; // Forward kalman fit for fitter
class IKalmanSmoother; // smoother logic for fitter
// class KalmanOutlierLogic; // Outlier logic for fitter
class ProtoTrajectoryUtility; // helper to analyse current trajectory
// class TrackFitInputPreparator; // helper to fill internal trajectories
//class FitterStatusCode;
class ProtoTrackStateOnSurface;
typedef std::vector<Trk::ProtoTrackStateOnSurface> Trajectory;
/** Main Fitter tool providing the implementation for the different
* fitting, extension and refitting use cases. It manages and calls
* the other tools.
*
* There are two modes of operation: One can use a general Trk::ITrackFitter as underlying
* track fitting tool or use the Kalman fitter sub-tools directly. The second method
* is the standard (and prefered) mode, because it avoids extensive deep-copies of tracks
* and is therefore much faster than using the general ITrackFitter interface.
*/
class DeterministicAnnealingFilter : virtual public ITrackFitter, public AthAlgTool {
public:
// standard AlgTool methods
DeterministicAnnealingFilter(const std::string&,const std::string&,const IInterface*);
DeterministicAnnealingFilter();
~DeterministicAnnealingFilter();
// standard Athena methods
StatusCode initialize();
StatusCode finalize();
/** refit a track (the main method; it uses most information from pattern recognition):
This function should normally be called with tracks containing
Trk::CompetingRIOsOnTrack.
If non CompetingRIOsOnTrack are given it might include the creation of
Trk::CompetingRIOsOnTrack depending on the jobOptions.
runOutlier has no meaning in all of the DAF's fitting methods */
virtual Track* fit (const Track&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** refit a track adding a PrepRawDataSet: Trk::ICompetingRIOsOnTrackCreator is used
to create Trk::CompetingRIOsOnTrack out of the additional PrepRawData first.
Be careful: The dicision which PrepRawData should compete against each other can
not be done here.
- NOT IMPLEMENTED YET!!! */
virtual Track* fit(const Track&,
const PrepRawDataSet&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** fit a track to a PrepRawDataSet: Trk::ICompetingRIOsOnTrackCreator is used
to create Trk::CompetingRIOsOnTrack out of the additional PrepRawData first.
Be careful: The dicision which PrepRawData should compete against each other can
not be done here.
- NOT IMPLEMENTED YET!!! */
virtual Track* fit(const PrepRawDataSet&,
const TrackParameters&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** re-fit a track, adding a fittable measurement set:
This function should normally be called with a MeasurementSet containing
Trk::CompetingRIOsOnTrack
- NOT IMPLEMENTED YET!!!*/
virtual Track* fit(const Track&,
const MeasurementSet&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** fit a track to a set of measurementBase.
This function should normally be called with a MeasurementSet containing
Trk::CompetingRIOsOnTrack.
The TrackParameters is a first estimate for the track.
If non Trk::CompetingRIOsOnTrack are given the TrackParameters are
used for computing the initial assignment probabilities.*/
virtual Track* fit(const MeasurementSet&,
const TrackParameters&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** not implemented: makes no sense for the DAF (always returns a NULL pointer) */
virtual Track* fit(const SpacePointSet&,
const TrackParameters&,
const RunOutlierRemoval runOutlier=false,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** combined track fit:
- NOT implemented yet!!!*/
virtual Track* fit(const Track&,
const Track&,
const RunOutlierRemoval,
const ParticleHypothesis) const;
///////////////////////////////////////////////////////////////////
// Private methods:
///////////////////////////////////////////////////////////////////
private:
// StatusCode myGetTool(IToolSvc*&,
// const std::string&,
// IAlgTool*&); //!< makes tool retrieving nicer
///////////////////////////////////////////////////////////////////
// Private data:
///////////////////////////////////////////////////////////////////
ToolHandle< IExtrapolator > m_extrapolator; //!< extrapolator used to calc initial assignment probs and used by Kalman sub-tools
//std::string m_option_ExtrapTool; //!< jobOption: name and instance of Extrapolator Tool
ToolHandle< IUpdator > m_updator; //!< measurement updator used by the Kalman forward filter and backward smoother
//std::string m_option_UpdatingTool; //!< jobOption: name and instance of Measurement Updator Tool
ToolHandle< ICompetingRIOsOnTrackTool > m_compROTcreator; //!< CompetingRIOsOnTrackTool to recalc assignment probabilities and to create CompetingRIOsOnTrack
//std::string m_option_compROTcreator; //!< jobOption: name and instance of CompetingRIOsOnTrackTool
//ToolHandle< const ITrackFitter* > m_ITrackFitter; //!< pointer to ITrack Fitter
//std::string m_option_KalmanFitter; //!< jobOption: DEACTIVATED IN THE CURRENT VERSION! Name and instance of the ITrackFitter. Default and best choice: "none". If set to "none", the Kalman Forward Filter and Backward Smoother are used directly (recommended for speed reasons).
ToolHandle< IForwardKalmanFitter > m_forwardFitter; //!< the tool handle for the Kalman forward filter
//std::string m_option_FwFilterInstance; //!< jobOption: instance of the Kalman forward filter
ToolHandle< IKalmanSmoother > m_smoother; //!< the tool handle for the Kalman backward smoother
//std::string m_option_SmootherInstance; //!< jobOption: instance of the Kalman backward smoother
ToolHandle <IDynamicNoiseAdjustor> m_dna;
ToolHandle< IValidationNtupleTool > m_FitterValidationTool; //!< Validation tool
mutable bool m_doValidation; //!< call validation tool after the current iteration of the fit
bool m_haveValidationTool; //!< validation tool given (checking the m_FitterValidationTool pointer provokes the ToolHandle to try to retrieve())?
bool m_option_callValidationToolForFailedFitsOnly; //!< Validation tool is called for failed fits only
TrkParametersComparisonFunction* m_tparScaleSetter;
ProtoTrajectoryUtility* m_utility; //!< ProtoTrajectoryUtility for debug output of trajectory
// TrackFitInputPreparator* m_inputPreparator; //!< input preparator to ease implementation of all fit() routines
std::vector<double> m_option_sortingRefPoint; //!< jobOption: reference point for measurement sorting
std::vector<double> m_option_annealingScheme; //!< jobOption: annealing scheme to be used in the annealing process
bool m_option_doHitSorting; //!< jobOption: sort measurements?
bool m_option_generatePerigee; //!< jobOption: generate Perigee parameters
double m_option_OutlierCut; //!< jobOption: cut on assignment probability: flag a measurement as outlier, if sum of assignment probabilties of a Trk::CompetingRIOsOnTrack is below this value (BUT: all measurements are used in the fit according to their assignment probabilities). Set to 0. to deactivate the cut
double m_option_DropOutlierCut; //!< jobOption: cut on assignment probability: drop a measurement from the track at the end of the annealing procedure, if sum of assignment probabilties of a Trk::CompetingRIOsOnTrack is below this value. Set to 0. to deactivate the cut
mutable Trajectory m_trajectory; //!< trajectory of Trk::ProtoTrackStateOnSurface
Trk::PropDirection m_directionToPerigee;
enum FitStatusCodes {Call, Success, BadInput, ExtrapolationFailure, ForwardFilterFailure, SmootherFailure, OutlierFailure, PerigeeMakingFailure, NoTrkParsToUpdateCompROT, nFitStatusCodes};
mutable std::vector< std::vector<int> > m_fitStatistics;
mutable std::vector< std::vector<int> > m_failuresByIteration;
enum StatIndex {iAll = 0, iBarrel = 1, iTransi = 2, iEndcap = 3, nStatIndex = 4};
std::vector<float> m_etabounds;
///////////////////////////////////////////////////////////////////
// Private functions:
///////////////////////////////////////////////////////////////////
// Track* doDAFfitWithIFitter(
// const MeasurementSet&,
// const TrackParameters&,
// const ParticleHypothesis matEffects=Trk::nonInteracting) const;
Track* doDAFfitWithKalman(
const TrackParameters&,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** method to create a track from internal trajectory which is common to all interfaces */
Track* makeTrack(const ParticleHypothesis) const;
// /** special method to build Perigee parameters from the track */
// const TrackStateOnSurface* makePerigee(const SmoothedTrajectory*,
// const PerigeeSurface&,
// const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** special method to build Perigee parameters from the internal KF trajectory */
const TrackStateOnSurface* internallyMakePerigee(const PerigeeSurface&,
const ParticleHypothesis matEffects=Trk::nonInteracting) const;
/** add a measurement (from input track or input measurement set) to internal trajectory */
void addToTrajectory(const MeasurementBase*,
const TrackParameters*,
const bool& isOutlier,
const int& istate) const;
/** create a Trk::TrackStateOnSurface from Trk::ProtoTrackStateOnSurface*/
const Trk::TrackStateOnSurface* createStateFromProtoState(Trk::ProtoTrackStateOnSurface&) const;
/** do statistics on track fits*/
void monitorTrackFits(FitStatusCodes, const double& eta, int iteration=0) const;
/** call the validation tool */
void callValidation(int iterationIndex,
const Trk::ParticleHypothesis matEffects,
FitterStatusCode fitStatCode=Trk::FitterStatusCode::Success ) const;
};
} // end of namespace
#endif // TRK_DETERMINISTICANNEALINGFILTER_H
package TrkDeterministicAnnealingFilter
author Sebastian Fleischmann <Sebastian.Fleischmann@cern.ch>
use AtlasPolicy AtlasPolicy-*
use AthenaBaseComps AthenaBaseComps-* Control
use GaudiInterface GaudiInterface-* External
use TrkEventPrimitives TrkEventPrimitives-* Tracking/TrkEvent
use TrkEventUtils TrkEventUtils-* Tracking/TrkEvent
use TrkParameters TrkParameters-* Tracking/TrkEvent
use TrkFitterUtils TrkFitterUtils-* Tracking/TrkFitter
use TrkFitterInterfaces TrkFitterInterfaces-* Tracking/TrkFitter
use TrkToolInterfaces TrkToolInterfaces-* Tracking/TrkTools
use TrkCompetingRIOsOnTrack TrkCompetingRIOsOnTrack-* Tracking/TrkEvent
private
use TrkPrepRawData TrkPrepRawData-* Tracking/TrkEvent
use TrkRIO_OnTrack TrkRIO_OnTrack-* Tracking/TrkEvent
use TrkMeasurementBase TrkMeasurementBase-* Tracking/TrkEvent
use TrkTrack TrkTrack-* Tracking/TrkEvent
use TrkSurfaces TrkSurfaces-* Tracking/TrkDetDescr
use TrkExInterfaces TrkExInterfaces-* Tracking/TrkExtrapolation
use TrkValInterfaces TrkValInterfaces-* Tracking/TrkValidation
use AtlasDetDescr AtlasDetDescr-* DetectorDescription
public
library TrkDeterministicAnnealingFilter *.cxx components/*.cxx
apply_pattern component_library
private
macro DOXYGEN_IMAGE_PATH "../doc/images"
#macro cppdebugflags '$(cppdebugflags_s)'
#macro_remove componentshr_linkopts "-Wl,-s"
<
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
/**
@mainpage The TrkDeterministicAnnealingFilter package
The Deterministic Annealing Filter (DAF) implementation.
@author Sebastian.Fleischmann@cern.ch
@section introductionTrkDeterministicAnnealingFilter Introduction
The TrkDeterministicAnnealingFilter package implements the deterministic annealing filtering
technique for track fitting, as proposed by Fr&uuml;hwirth and Strandlie in 1999 [1].
This package contains the high-level steering algorithms of the DAF. The actual calculations
are performed by several other packages which depend in many cases on detector-dependend knowledge.
@image html CantGetEnough.jpg
@section TrkDeterministicAnnealingFilterOverview Class Overview
The TrkDeterministicAnnealingFilter package contains the following classes:
- Trk::DeterministicAnnealingFilter : DAF steering algorithm, prepares the fit and performs the annealing iterations
- Trk::DAF_WeightCalculator : Tool for calculating the assignment probabilities according to the DAF formulae
- Trk::DAF_SimpleWeightCalculator : Tool for calculating the assignment probabilities according to the DAF formulae with simplified normalization (modification to formulas in [1])
@section TrkDeterministicAnnealingFilterDocReferences References
[1] R. Fr&uuml;hwirth, A. Strandlie, <i>Track fitting with ambiguities and noise:
a study of elastic tracking and non-linear filters</i>, Computer Physics Communications (1999) vol. 120, no. 2-3, pp. 197-214.
@section ExtrasTrkDeterministicAnnealingFilter Extra Pages
- @ref UsedTrkDeterministicAnnealingFilter