Trk Namespace Reference

Ensure that the ATLAS eigen extensions are properly loaded. More...

Namespaces
namespace	Error
namespace	GsfMeasurementUpdator
namespace	InvalidParam
namespace	MeasurementBaseType
namespace	MultiComponentStateAssembler
	Helper struct representing a cache of the Multicomponent state under assembly.
namespace	MultiComponentStateCombiner
namespace	MultiComponentStateHelpers
namespace	MultiComponentStateModeCalculator
namespace	ParticleMasses
namespace	ParticleSwitcher
namespace	RIO_OnTrackType
namespace	RungeKuttaUtils
namespace	TrackState
namespace	TruthClassification
namespace	TwoStateCombiner

Classes
class	AdaptiveMultiVertexFitter
class	AdaptiveMultiVertexFitterTestAlg
class	AdaptiveVertexFitter
class	AdaptiveVertexFitterTestAlg
class	AlignableTrackingVolume
	Base Class for a navigation object (active) in the Calo realm. More...
class	AlignAlg
class	AlignmentDeviation
	An object decorating a track and holding degrees of freedom reflecting alignment accuracy. More...
class	AlignmentEffectsOnTrack
	Class to represent misalignments or 'discontinuities' on tracks These have a surface where the z axis is aligned with the direction of the translation, and the angle of the rotation is with respect to this. More...
class	AlignModule
class	AlignModuleTool
class	AlignPar
class	AlignResidualCalculator
class	AlignTrack
class	AlignTrackCollSplitter
class	AlignTrackCreator
class	AlignTrackDresser
class	AlignTrackPreProcessor
class	AlignTSOS
class	AlignVertex
class	AlMat
	contains the implementation of the methods of class AlMat, for handling general NxM matrices More...
class	AlSpaMat
	contains the implementation for handling sparse matrices More...
class	AlSymMat
	contains the implementation for handling symmetric matrices in triangular representation More...
class	AlSymMatBase
	contains the base implementation for handling symmertic matrices More...
class	AlVec
class	AmbiguityProcessorBase
class	AnalyticalDerivCalcTool
class	AnnulusBounds
	Bounds for a annulus-like, planar Surface. More...
class	AnnulusBoundsPC
	Class that implements the asymmetric shape of the ITk strip endcap modules. More...
class	ApproachDescriptor
	Class to decide and return which approaching surface to be taken. More...
class	ApproachSurfaces
	just implement the delete on the objects More...
class	AreaExcluder
	Pure abstract base class. More...
class	AssociatedMaterial
	It is used in the Mapping process ( using MaterialSteps ), the validation and recostruction ( using MaterialProperties ) More...
class	AtaSurface_p1
class	baseMagFld
class	basePropagator
class	BasicTruthCollectionFilter
	BasicTruthCollectionFilter accepts all valid map entries, as determined by the isValid() call on the HepMcParticleLink. More...
class	BasicValTrkParticleNtupleTool
	This validation tool writes basic information about Trk::TrackParticleBase into an ntuple;. More...
class	BeamspotVertexPreProcessor
struct	BevelledBoundaryIntersector
class	BevelledCylinderVolumeBoundaryAccessors
	Different Accessor types for a cylindrical Volume, if returs accessors to the volume boundary surfaces to guarantee "best-guess" navigation, and follow-ups. More...
class	BevelledCylinderVolumeBounds
	Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a vector of up to 6 surfaces: More...
class	BinnedArray
	Binned Array for avoiding map searches/. More...
class	BinnedArray1D
	1-dimensional binned arry based on a sorting given by the BinUtitlity. More...
class	BinnedArray1D1D
	2D dimensional binned array, where the binning grid is not symmetric. More...
class	BinnedArray1D1D1D
	Avoiding a map search, the templated BinnedArray class can help ordering geometrical objects by providing a dedicated BinUtility. More...
class	BinnedArray2D
	Avoiding a map search, the templated BinnedArray class can help ordereing geometrical objects by providing a dedicated BinUtility. More...
class	BinnedArrayArray2D
class	BinnedLayerMaterial
	It extends the LayerMaterialProperties base class. More...
class	BinnedLayerMaterial_p1
class	BinnedLayerMaterialCreator
	LayerMaterialProperties creator for BinnedLayerMaterial. More...
class	BinnedMaterial
	for description of non-homogenous dense volumes More...
class	BinningData
	This class holds all the data necessary for the bin calculation. More...
class	BinUtility
	A generic symmetric BinUtility, for fully symmetric binning in terms of binning grid and binning type. More...
class	BinUtility_p1
class	BinUtilityTest
	Test calling the internal surface intersection methods. More...
class	BitField
	A class managing bits belonging to a range of bits. More...
class	BoundaryCheck
	The BoundaryCheck class allows to steer the way surface boundaries are used for inside/outside checks of parameters. More...
class	BoundaryCylinderSurface
	BoundaryCylinderSurface description inside the tracking realm, Extends the Surface description to make a surface being a boundary of a Trk::Volume. More...
class	BoundaryDiscSurface
	BoundaryDiscSurface description inside the tracking realm, it extends the DiscSurface description to make a surface being a boundary of a Trk::Volume (used for cylindrical shape). More...
class	BoundaryPlaneSurface
	BoundaryPlaneSurface description inside the tracking realm, it extends the PlaneSurface description to make a surface being a boundary of a volume. More...
class	BoundarySubtractedCylinderSurface
	BoundarySubtractedCylinderSurface description inside the tracking realm, it extends the Surface description to make a surface being a boundary of a Trk::Volume. More...
class	BoundarySubtractedPlaneSurface
	BoundarySubtractedPlaneSurface description inside the tracking realm, it extends the SubtractedPlaneSurface description to make a surface being a boundary of a volume,. More...
class	BoundarySurface
	Description of a BoundarySurface inside the tracking realm, it extends the Surface description to make a surface being a boundary of a Trk::Volume, Trk::TrackingVolume or a Trk::MagneticFieldVolume. More...
struct	BoundaryTrackParameters
class	BoundSurface_p1
class	BoundSurface_p2
class	BremPositionNtupleHelper
	Helper tool as module for the Trk::BasicValidationNtupleTool, writing information about track state with brem-like material effects. More...
struct	Cache
class	CaloCellSelectorLayerdR
class	CaloCellSelectorMinPerp
class	CaloCellSelectorNearestdR
class	CaloCellSelectorRoughdR
class	CaloCluster_OnTrack
	Class to handle Cluster On Tracks (ROT) for CaloClusters, it inherits from the common MeasurementBase. More...
class	CaloExtension
	Tracking class to hold the extrapolation through calorimeter Layers Both the caloEntryLayerIntersection and the muonEntryLayerIntersection can return nullptr if the particle failed to reach the layer. More...
class	CaloExtensionBuilderAlg
	This algorithm creates a calo extension collection and stores it in a Gaudi Gate named "ParticleCaloExtension" to be read by other algorithms. More...
class	CascadeEvent
struct	cascadeV
class	CETmaterial
	The ExtrapolatorTest Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to geometry outer boundary and back to perigee. More...
class	Charged
	Simple helper class for defining track parameters for charged particles. More...
class	Chi2TrackCompatibilityEstimator
	This object reweights the tracks according to a chi2 value constructed according to the distance to the vertex (the error of the vertex is not considered in constructing the chi squared, because this is an apriori probability which enters the fit) More...
struct	ClusterSplitProbability_p1
class	ClusterSplitProbabilityContainer
	Container to associate Cluster with cluster splitting probabilities. More...
class	ClusterSplitProbabilityContainer_p1
class	ClusterSplitProbabilityContainerCnv_p1
class	CollinearityConstraint
class	CombinedExtrapolatorTest
	The ExtrapolatorTest Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to geometry outer boundary and back to perigee. More...
class	CombinedVolumeBounds
	Bounds for a generic combined volume, the decomposeToSurfaces method creates a vector of n surfaces (n1+n2-nshared): More...
class	CommonTruthMatchWeights
class	CompactBinnedArray
	defines common utilities needed for implementation of binned material More...
class	CompactBinnedArray1D
	1-dimensional binned arry based on a sorting given by the BinUtitlity. More...
class	CompactBinnedArray2D
	2-dimensional binned array More...
class	CompareTwoTracks
class	ComparisonFunction
	this functor is used to find the closest objects: More...
class	CompetingRIOsOnTrack
	Base class for all CompetingRIOsOnTack implementations, extends the common MeasurementBase. More...
class	CompetingRIOsOnTrack_p1
struct	ComponentParameters
class	CompoundLayerMaterial
	It extends the LayerMaterialProperties base class, and has a intrinsic accuracy of about 0.5 % on the dynamic range from using unsigned char. More...
class	CompoundLayerMaterial_p1
class	CompoundLayerMaterialCreator
	LayerMaterialProperties creator for CompoundLayerMaterial (i.e. More...
class	CompressedLayerMaterial
	It extends the LayerMaterialProperties base class. More...
class	CompressedLayerMaterial_p1
class	CompressedLayerMaterialCreator
	LayerMaterialProperties creator for CompressedLayerMaterial. More...
class	ConeBounds
	Bounds for a conical Surface, the opening angle is stored in \( \tan(\alpha) \) and always positively defined. More...
class	ConeBounds_p1
class	ConeLayer
	Class to describe a cylindrical detector layer for tracking, it inhertis from both, Layer base class and ConeSurface class. More...
class	ConeSurface
	Class for a conical surface in the ATLAS detector. More...
class	ConstrainedTrackProvider
class	ConstSharedPtrSpan
struct	CovarianceMatrix
class	CrossDistancesSeedFinder
class	CuboidVolumeBounds
	Bounds for a cubical Volume, the decomposeToSurfaces method creates a vector of 6 surfaces: More...
class	CurvilinearParametersT
	The specialised class for charged and neutral track parameters in the curvilinear frame. More...
class	CurvilinearUVT
	simple class that constructs the curvilinear vectors curvU and curvV from a given momentum direction (must be unit vector). More...
class	CylinderBounds
	Bounds for a cylindrical Surface. More...
class	CylinderBounds_p1
struct	CylinderIntersector
class	CylinderLayer
	Class to describe a cylindrical detector layer for tracking, it inhertis from both, Layer base class and CylinderSurface class. More...
class	CylinderLayerAttemptsCalculator
	Simple helper class for CylinderLayer static array. More...
class	CylinderLayerSorterR
	Functor for CylinderLayer R-Sorting. More...
class	CylinderSurface
	Class for a CylinderSurface in the ATLAS detector. More...
class	CylinderVolumeBoundaryAccessors
	Different Accessor types for a cylindrical Volume, if returs accessors to the volume boundary surfaces to guarantee "best-guess" navigation, and follow-ups. More...
class	CylinderVolumeBounds
	Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a vector of up to 6 surfaces: More...
class	CylinderVolumeCreator
	The concrete implementation for cylindrical TrackingVolume objects of the ITrackingVolumeCreator interface. More...
class	DAF_ValidationNtupleHelper
	This validation tool writes information about Trk::CompetingRIOsOnTrack into an ntuple. More...
class	DecayInFlyTruthTrajectoryBuilder
class	DefParamPullPlots
class	DenseEnvironmentsAmbiguityProcessorTool
class	DenseEnvironmentsAmbiguityScoreProcessorTool
struct	DestBound
class	DetachedTrackingVolume
	Base Class for a navigation object (active/passive) in the Tracking realm. More...
class	DetailedHitInfo
class	DetailedMuonPatternTruthBuilder
struct	DetailedTrackTruth_p0
class	DetailedTrackTruth_p1
class	DetailedTrackTruth_p2
class	DetailedTrackTruth_p3
class	DetailedTrackTruth_p4
class	DetailedTrackTruthBuilder
class	DetailedTrackTruthCollection_p0
class	DetailedTrackTruthCollection_p1
class	DetailedTrackTruthCollection_p2
class	DetailedTrackTruthCollection_p3
class	DetailedTrackTruthCollection_p4
class	DetAnnealingMaker
	This class implements an annealing maker. More...
class	DetElementSurface
class	DetElementSurface_p1
class	DiamondBounds
	Bounds for a double trapezoidal ("diamond"), planar Surface. More...
class	DiamondBounds_p1
class	DigitizationModule
	Class that holds the surfaces for a planar digitization detector module. More...
struct	DigitizationStep
	handling More...
class	DirectTrackNtupleWriterTool
	This validation tool writes basic information about Trk::Track into an ntuple; it is also the steering tool for all Trk::IValidationNtupleTool. More...
class	DiscBounds
	Class to describe the bounds for a planar DiscSurface. More...
class	DiscBounds_p1
class	DiscLayer
	Class to describe a disc-like detector layer for tracking, it inhertis from both, Layer base class and DiscSurface class. More...
class	DiscLayerAttemptsCalculator
	Simple helper class for DiscLAyer static array. More...
class	DiscLayerSorterZ
	simple helper function to allow sorting of DiscLayers in z More...
class	DiscSurface
	Class for a DiscSurface in the ATLAS detector. More...
class	DiscTrapezoidalBounds
	Class to describe the bounds for a planar DiscSurface. More...
class	DistanceSolution
	Access to distance solutions. More...
class	DistributedKalmanFilter
class	DoubleTrapezoidVolumeBounds
	Bounds for a double trapezoidal shaped Volume, the decomposeToSurfaces method creates a vector of 8 surfaces: More...
class	DummyAnnealingMaker
	This class implements an annealing maker but it's a DUMMY one! More...
class	DummySeedFinder
class	DummyVertexSelectionTool
class	DummyVertexSmoother
struct	EdgeCross
class	EfficiencyPlots
class	ElasticTruthTrajectoryBuilder
class	ElectronCombinedMaterialEffects
class	ElectronMaterialMixtureConvolution
class	ElementFraction
class	ElementTable
class	ElementTable_p1
	elements & fractions as unsigned char - if filled More...
class	EllipseBounds
	Class to describe the bounds for a planar EllipseSurface, i.e. More...
class	EllipseBounds_p1
	Persistent representation of the transient Trk::EllipseBounds_p1 class. More...
class	EnergyLoss
	This class describes energy loss material effects in the ATLAS tracking EDM. More...
class	EnergyLoss_p1
	Persistent representation of class EnergyLoss.h. More...
class	EnergyLossExtrapolationValidation
	The EnergyLossExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to specific reference surfaces within the ATLAS Detector (user defined cylinder tubes which can be placed e.g. More...
class	EnergyLossMonitor
	This validation tool Energy states of partlices. More...
class	EnergyLossUpdator
	The mean Energy loss per unit length of a particle is calculated as. More...
class	ErrorMatrix
class	EstimatedBremOnTrack
	class holding information about momentum reduction and an additional noise term due to significant energy loss (bremsstrahlung) More...
class	EstimatedBremOnTrack_p1
	persistent representation of EstimatedBremOnTrack More...
class	EventCnvSuperTool
	Tool to handle TP conversions for Tracking EDM. More...
class	EventDataBase
	Base for a helper class to pass mutable storage to tools. More...
class	EventDataModelMonitor
	Prints the number of EDM objects currently in memory. More...
class	EventPropertyNtupleTool
class	EventToTrackLinkNtupleTool
class	ExtendedVxCandidate
	Extends the standard Trk::VxCandidate to store the full covariance matrix of a fitted vertex all participating tracks. More...
class	ExtendedVxCandidate_p1
class	ExtrapolationCache
class	ExtrapolationCell
	templated class as an input-output object of the extrapolation, only public members, since it is a container class More...
class	ExtrapolationCode
class	ExtrapolationConfig
class	ExtrapolationEngine
	Master extrapolation engine for extrapolation through the TrackingGeometry, it delegates the extrapolation to optimised engines, handing over the ExtrapolationCell as internal cache. More...
class	ExtrapolationEngineTest
	Test Algorithm to run test extrapolations with the new IExtrapolationEngine. More...
class	ExtrapolationMode
	enumeration to decode - for Extrapolation steering More...
class	ExtrapolationStep
	templated class to record the different possible entities during extrapolation More...
class	ExtrapolationValidation
	The ExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to randombly distributed reference surfcas within. More...
class	Extrapolator
	Extrapolation of track parameters and their associated covariances to destination surfaces. More...
class	ExtrapolatorComparisonTest
	The ExtrapolatorComparisonTest Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to reference surfcas within. More...
class	ExtrapolatorTest
	The ExtrapolatorTest Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to reference surfcas within. More...
class	ExtrLayerPlots
class	ExtrRegionPlots
struct	ExtrUniquePtrHolder
class	FastVertexFitter
	This class implements a fast vertex fitting algorithm as proposed by P. More...
class	FitMatrices
struct	fitMatrix
class	FitMeasurement
class	FitParameters
class	FitProcedure
class	FitProcedureQuality
class	FitQuality
	Class to represent and store fit qualities from track reconstruction in terms of \(\chi^2\) and number of degrees of freedom. More...
class	FitQuality_p1
class	FitQualityImpl
	simple/trivial Implemenation class for fit the fit quality. More...
class	FitQualityOnSurface
class	FitterStatusCode
	Status codes for track fitters. More...
struct	ForCFT
struct	ForVrtClose
class	FsmwMode1dFinder
	Algotool which calculates the mode of a unidimenensional distribution using the Fraction of Sample Mode with Weights algorithm, which is an iterative Least Median estimator. More...
class	FullIntersection
	Class extension to return the object, a represenation & the result. More...
class	FullLinearizedTrackFactory
	A concrete implementation of the linearized track factory. More...
class	FullVertexFitter
	This class implements a full vertex fitting algorithm as proposed by P. More...
class	GaussianDensityTestAlg
class	GaussianSumFitter
class	GaussianTrackDensity
	Implementation of IVertexTrackDensityEstimator modeling reconstructed tracks as two-dimensional Gaussian distributions in (d0, z0) space and sampling the aggregate density distribution at user-requested points along the beam axis. More...
class	GeantFollowerHelper
class	GeantFollowerMSHelper
class	GenParticleJet
	short class to organise MC generated particles as a jet. More...
class	GenParticleJetFinder
	Durham jet clustering algorithm for MC-truth tracks. More...
class	GeoMaterialConverter
	A Simple Helper Class that convertes the GeoMaterial object used in GeoModel full detector description to an appropriate Trk::ExtendedMaterialProperties object. More...
class	GeometryAsciiDumper
	The GeometryAsciiDumper writes geometrical information of the tracking geomtetry into an Ascii file for comparison. More...
class	GeometryBuilder
	The Trk::TrackingGeometry Builder for ATLAS Geometry. More...
class	GeometryBuilderCond
	The Trk::TrackingGeometry Builder for ATLAS Geometry. More...
class	GeometryJsonDumper
	The GeometryJsonDumper writes geometrical information of the tracking geomtetry into an Ascii file for comparison. More...
class	GeometryTTreeDumper
	The GeometryTTreeDumper writes geometrical information of the tracking geomtetry into a TTree for chekcs and comparisons. More...
class	GeoShapeConverter
	A Simple Helper Class that convertes the GeoShape object used in GeoModel full detector description to an appropriate Trk::VolumeBounds (factory type) object. More...
class	GlobalChi2AlignTool
class	GlobalChi2Fitter
class	GlueVolumesDescriptor
	Descriptor class to hold GlueVolumes of a TrackingGeometry object. More...
class	GMTreeBrowser
	A Helper Class that facilitates navigation through GeoModel tree. More...
class	GsfExtrapolator
class	GXFMaterialEffects
	class that is similar to MaterialEffectsOnTrack, but has 'set' methods for more flexibility during track fitting More...
class	GXFTrackState
class	GXFTrajectory
	Internal representation of the track, used in the track fit. More...
class	HepSymMatrix_p1
struct	HitInfo
class	HitPositionNtupleHelper
	This validation tool writes information about measurement positions and their surfaces. More...
class	HitResidualPlots
class	HitTypePlots
class	HomogeneousLayerMaterial
	It extends the LayerMaterialProperties base class. More...
class	HomogeneousLayerMaterial_p1
class	IAlignableSurfaceProvider
class	IAlignModuleTool
class	IAlignResidualCalculator
class	IAlignTool
class	IAlignTrackCreator
class	IAlignTrackDresser
class	IAlignTrackPreProcessor
class	IAmbiTrackSelectionTool
	Interface for building new tracks using information about shared and already associated hits. More...
class	IApproachDescriptor
	CVirtual class to decide and return which approaching surface to be taken. More...
class	IBoundaryCheckTool
class	ICaloCellSelector
	abstract class that judge if a calo cell is to be included in a collection More...
class	ICaloTrackingVolumeBuilder
	Interface class ICaloTrackingVolumeBuilders It inherits from IAlgTool. More...
struct	IdentifiedIntersection
class	IdentifierExtractor
	Small utility to get hit Identifiers out of MeasurementBase (either in a vector or single). More...
class	IDerivCalcTool
class	IDetachedTrackingVolumeBuilder
	Interface class IDetachedTrackingVolumeBuilder, the DetachedTrackingVolumeBuilder inherits from this one. More...
class	IDetachedTrackingVolumeBuilderCond
	Interface class IDetachedTrackingVolumeBuilderCond, the DetachedTrackingVolumeBuilder inherits from this one. More...
class	IDetailedMuonPatternTruthBuilder
	Provides interface for tool to return a "detailed" track truth map. More...
class	IDetailedTrackTruthBuilder
	Provides interface for tool to return a "detailed" track truth map. More...
class	IDetailedTrackTruthSimilarity
	Interface for track-truth match quality estimator tools. More...
class	IDHitPlots
class	IDirectTrackNtupleWriter
	Interface to set up and write a TrkValidation ntuple so that it can be called for validation action 'inside' any tracking tool. More...
class	IDynamicLayerCreator
	Interface class IDynamicLayerCreator It inherits from IAlgTool. More...
class	IEnergyLossMonitor
	Very simple helper Tool to record the eneryloss steps track, this works only for single track events. More...
class	IEnergyLossUpdator
	Interface class IEnergyLossUpdator. More...
class	IEventCnvSuperTool
class	IEventPropertyNtupleTool
	provides the interface for validation tools which write special information about the whole event into ntuples. More...
class	IExtendedTrackSummaryHelperTool
class	IExtendedTrackSummaryTool
	Interface for condensing Trk::Track properties and associated hits to a (non-fittable) foot print, the Trk::TrackSummary object. More...
class	IExtrapolationEngine
	Extrapolation engine interface for Charged and Neutral parameters, it serves as the Master extrapolation interface but also as the specialized extrapolation engine ones. More...
class	IExtrapolator
	Interface class for the extrapolation AlgTool, it inherits from IAlgTool Detailed information about private members and member functions can be found in the actual implementation class Extrapolator which inherits from this one. More...
class	IFillNtupleTool
class	IGeantFollowerHelper
class	IGeantFollowerMSHelper
class	IGenParticleJetFinder
	provides the interface for determining truth jets (inside Tracking validation framework) More...
class	IGenParticleSelector
	provides the interface for tools to select generated particles More...
class	IGeometryBuilder
	Interface class IGeometryBuilders, the GeometryBuilder inherits from this one. More...
class	IGeometryBuilderCond
	Interface class IGeometryBuilderCond, the GeometryBuilder inherits from this one. More...
class	IGeometryManagerTool
class	IGeometryProcessor
	Interface class IGeometryProcessors. More...
class	IGlobalTrackFitter
	provides additional abstract interfaces for information provided from global-least-squares track fit algorithms working in the ATLAS EDM. More...
class	IImpactPoint3dEstimator
class	IIntersector
	Base class for Intersector AlgTools. More...
class	IIsoTrackSelectorTool
	The abstract interface base class for track selector tools targeted at isoloation. More...
class	IJacobianManagerTool
class	IJetTruthNtupleTool
	provides the interface for validation tools which write special information about truth particles into ntuples. More...
class	IKinematicConstraint
class	ILayerArrayCreator
	Interface class ILayerArrayCreators It inherits from IAlgTool. More...
class	ILayerBuilder
	Interface class ILayerBuilders It inherits from IAlgTool. More...
class	ILayerBuilderCond
	Interface class ILayerBuilderConds It inherits from IAlgTool. More...
class	ILayerMaterialAnalyser
	Interface class for LayerMaterial analysis. More...
class	ILayerMaterialCreator
	Interface class for LayerMaterialCreator AlgTools to create LayerMaterial properties with different strategies. More...
class	ILayerMaterialManipulator
	Interface class for LayerMaterial manipulation, it creates new LayerMaterial. More...
class	ILayerProvider
	Interface class ILayerProviders it feeds into the StagedGeometryBuilder. More...
class	ILayerProviderCond
	Interface class ILayerProviderConds it feeds into the StagedGeometryBuilder. More...
class	IMaterialAllocator
	Base class for MaterialAllocator AlgTool. More...
class	IMaterialEffectsEngine
	Material effects engine interface for charged and neutral (fast track simulation) , the update is alwyas on the: More...
class	IMaterialEffectsOnTrackProvider
	Interface class IMaterialEffectsOnTrackProvider It inherits from IAlgTool. More...
class	IMaterialEffectsUpdator
	Interface class for the updater AlgTool, it inherits from IAlgTool. More...
class	IMaterialMapper
	Interface class IMaterialMapper. More...
class	IMaterialMixtureConvolution
class	IMatrixTool
class	IMode1dFinder
	Interface class for the algotool which calculates the mode of a unidimensional distribution. More...
class	IMode3dFinder
	Interface class for the algotool which calculates the mode of a threedimensional distribution. More...
class	IMode3dInfo
	Auxillary interface for getting back additional data. More...
class	IModuleStepper
	Interface class IModuleSteppers. More...
struct	ImpactParametersAndSigma
class	ImpactPlots
class	ImpactPoint3dEstimator
	This object calculates the point of minimum distance to the vertex in 3d. More...
class	IMultipleScatteringUpdator
	Interface class IMultipleScatteringUpdator. More...
class	IMultiStateExtrapolator
class	INavigationEngine
	Extrapolation engine interface for Charged and Neutral parameters, it serves as the Master extrapolation interface but also as the specialized extrapolation engine ones. More...
class	INavigator
	Interface class for the navigation AlgTool, it inherits from IAlgTool Detailed information about private members and member functions can be found in the actual implementation class Trk::Navigator which inherits from this one. More...
class	InDetHaloSelector
	select truth halo tracks More...
class	InDetPrimaryConversionSelector
	Modular concept to select truth particles for the truth tree filling and efficiency calculation, this one selects detectable tracks in the ID. More...
class	InDetReconstructableSelector
	Modular concept to select truth particles for the truth tree filling and efficiency calculation, this one selects detectable tracks in the ID. More...
class	InDetTrackSummary_p1
class	IndexedCrossDistancesSeedFinder
struct	IndexedMaterial
class	INeutralParticleParameterCalculator
	interface for tools taking a two-track vertex and creating a neutral track from it. More...
class	InputLayerMaterialProvider
	AlgTool that assigns LayerMaterial as specified to the TrackingGeometry. More...
struct	Intersection
class	IntersectorWrapper
class	IntVec
class	InvalidBounds
	Invalid Bounds object. More...
class	InverseMultiMap
	An InverseMultiMap object built from a generic map or multimap allows for quick lookup of original (multi)map's key by original mapped value. More...
class	IParticleCaloExtensionTool
	Interface for extending Particles with calo intersections. More...
class	iPatFitter
	Main Fitter tool providing the implementation for the different fitting, extension and refitting use cases. More...
class	iPatGlobalFitter
	GlobalTrackFitter tool providing methods used during alignment. More...
class	IPatternParametersPropagator
	interface for track parameter propagation through the magnetic field, using the Trk::PatternTrackParameters data model for fast, internal use. More...
class	IPatternParametersUpdator
	Interface for updating Trk::PatternTrackParameters, the fast internal representation of track parameters in the (inner detector) pattern recognition tools, with a measurement. More...
class	IPCMat
class	IPCMatrixTool
class	IPixelToTPIDTool
	abstract interface for identification of particles based on More...
class	IPositionMomentumWriter
	Very simple helper Tool to record track states at certain positions this works only for single track events. More...
class	IPRD_AssociationTool
	Interface for handling the mapping between Trk::Track and Trk::PrepRawData. More...
class	IPRD_Provider
	Simple interface that takes an identifier and find the associated PRD from an Identifyable container. More...
class	IPRD_TruthTrajectoryBuilder
	The interface for the truth PRD trajectory finder. More...
class	IPRD_TruthTrajectoryManipulator
	The interface for the truth PRD trajectory manipulator. More...
class	IPRD_TruthTrajectorySelector
	The interface for the truth PRD trajectory selector. More...
class	IPRDtoTrackMapTool
	Interface for handling the mapping between Trk::Track and Trk::PrepRawData. More...
class	IPropagationEngine
	A propagation engine wrapping the propagator algtool it respects the path limit to stop particles if needed. More...
class	IPropagator
	Interface class IPropagators It inherits from IAlgTool. More...
class	IPVTrackCompatibilityEstimator
class	IResidualPullCalculator
	provides the interface for tools which calculate residuals and pulls. More...
class	IRIO_OnTrackCreator
	Interface class for transforming Trk::PrepRawData to Trk::RIO_OnTrack using a local track hypothesis. More...
class	ISegmentConverterTool
	Interface for tool to convert a Trk::Segment object into a Trk::Track. More...
class	ISurfaceBuilder
	Interface class ISurfaceBuilders It inherits from IAlgTool. More...
class	ITimedExtrapolator
	Interface class for the extrapolation AlgTool, it inherits from IAlgTool Detailed information about private members and member functions can be found in the actual implementation class TimedExtrapolator which inherits from this one. More...
class	ITimedMatEffUpdator
	Interface class for the updater AlgTool, it inherits from IAlgTool Detailed information about private members and member functions can be found in the actual implementation class MaterialUpdator which inherits from this one. More...
class	ITrackAmbiguityProcessorTool
	Interface for resolving hit assoication ambiguities in a given track collection. More...
class	ITrackAmbiguityScoreProcessorTool
	Interface for resolving hit association ambiguities in a given track collection. More...
class	ITrackCollectionProvider
class	ITrackDiff
	provides the interface for a track diff tool More...
class	ITrackFitter
	Provides the abstract interface for track fitting in the common ATLAS Tracking EDM. More...
class	ITrackHoleSearchTool
	interface for searching, counting and adding holes on tracks anywhere in ATLAS. More...
class	ITrackingGeometrySvc
class	ITrackingVolumeArrayCreator
	Interface class ITrackingVolumeArrayCreators It inherits from IAlgTool. More...
class	ITrackingVolumeBuilder
	Interface class ITrackingVolumeBuilders It inherits from IAlgTool. More...
class	ITrackingVolumeCreator
	Interface class ITrackingVolumeCreators It inherits from IAlgTool. More...
class	ITrackingVolumeHelper
	Interface class ITrackingVolumeHelpers It inherits from IAlgTool. More...
class	ITrackingVolumesSvc
	Service which is used to create volumes enclosing various parts of ATLAS, and which can be used e.g. More...
class	ITrackLink
	An abstract class which is meant to represent an element link to the Trk::Track or Trk::TrackParticleBase. More...
class	ITrackMatchingTool
	The abstract interface base class for Track matching tools. More...
class	ITrackParticleCreatorTool
	Interface for constructing TrackParticles from complete tracks. More...
class	ITrackScoringTool
	Interface for tool to return a score from a given track. More...
class	ITrackSelectorTool
	The abstract interface base class for track selector tools. More...
class	ITrackSlimmingTool
	Interface for constructing 'slimmed' Tracks from complete tracks. More...
class	ITrackSummaryHelperTool
	Interface for structuring the summary creation into sub-detector specific tools. More...
class	ITrackSummaryTool
	Interface for condensing Trk::Track properties and associated hits to a (non-fittable) foot print, the Trk::TrackSummary object. More...
class	ITrackTimingTool
	Interface for providing time information for a track or track particle. More...
class	ITrackToVertexIPEstimator
class	ITrackTruthClassifier
	provides the interface for tools which classify gen particles More...
class	ITrackValidationNtupleTool
	provides the interface for validation tools which write special information about generated tracks into ntuples. More...
class	ITrkAlignDBTool
class	ITrkAlignmentDeviationTool
	Interface for tool to add alignmenties to a global chi2 fit. More...
class	ITrkDistanceFinder
	Interface class for the algotool which calculates the distance between two tracks. More...
class	ITrkEventCnvTool
class	ITrkMaterialProviderTool
	Interface for tool to add alignmenties to a global chi2 fit. More...
class	ITrkObserverTool
class	ITrkVKalVrtFitter
class	ITRT_ElectronPidTool
	abstract interface for identification of electrons based on information from the inner detector track (mainly TRT) More...
class	ITruthNtupleTool
	provides the interface for validation tools which write special information about truth particles into ntuples. More...
class	ITruthToTrack
	ITruthToTrack is an interface to create Trk::TrackParameters from a HepMC::GenParticle. More...
class	ITruthTrackBuilder
	The interface for the truth track finder. More...
class	ITruthTrajectoryBuilder
class	IUpdator
	Set of interfaces for methods operating on track states, mainly for Kalman filtering. More...
class	IValidationNtupleHelperTool
	provides the interface for validation helper tools which write special information about generated tracks. More...
class	IValidationNtupleTool
	provides the interface for validation tools which write special information about generated tracks into ntuples. More...
class	IVertexAnalyticSeedFinder
	An abstract base class for implementation of Linearization point finders. More...
class	IVertexAnnealingMaker
	Interface class responsible for an annealing process. More...
class	IVertexCascadeFitter
class	IVertexCollectionSortingTool
	Interface class for vertex Container Sorting. More...
class	IVertexFitter
	Interface class for vertex fitting AlgTools, for more detailed information, take a look at the header file of the actual implementation file. More...
class	IVertexLinearizedTrackFactory
	An Abstract Base Class for the LinearizedTrackFactories. More...
class	IVertexMapper
	Interface class IVertexMapper. More...
class	IVertexMergingTool
	Interface class for merging compatible vertices in a single collection. More...
class	IVertexSeedFinder
	An abstract base class for implementation of Linearization point finders. More...
class	IVertexSelectionTool
	Interface class for vertex Container Sorting. More...
class	IVertexSmoother
	An abstract base class for the vertex smoothers Update the tracks of type Trk::VxTrackAtVertex belonging to the Trk::VertexCandidate with the knowledge of the vertex position. More...
class	IVertexTrackCompatibilityEstimator
	An Abstract base class for estimators, calculating the compatibility of a track and a vertex. More...
class	IVertexTrackDensityEstimator
	An abstract base class for implementation of weight functions for seeding. More...
class	IVertexTrackUpdator
	An abstract base class for the vertex track updators Updates the track with the knowledge of the position of the production vertex. More...
class	IVertexUpdator
	An abstract base class for the vertex updators. More...
class	IVertexWeightCalculator
class	IVKalState
class	JacobianCartesianToPerigee
	Jacobian from cartesian parameters \( (p_x, p_y, p_z, E, x, y, z) \) to perigee parameters \( (d_0, z_0, \phi_0, \theta, q/p) \). More...
class	JacobianCartesianToPolar
	Jacobian for the transformation of cartesian parametes \((locX,locY,\phi,\theta, q/p)\) to polar parameters \( (locR,locPhi,\phi,\theta, q/p)\): More...
class	JacobianCotThetaPtToThetaP
	This is the 5x5 jacobian for the transformation of track parameters and errors having a momentum representation of \( (\phi, cot\theta, q/p_{T}) \) to the new standard representation of \( (\phi, \theta, q/p) \), while the first two variables that express the local position representation keep unchanged. More...
class	JacobianCurvilinearToLocal
	This class represents the jacobian for transforming from a curvilinear to a local frame. More...
class	JacobianLocalAnglesPhiTheta
	This jacobian transforms the local direction representation as given in the Trk::LocalDirection class into the corresponding polar and azimutal angle \( \phi, \theta \), therefor it is of dimension (2x2). More...
class	JacobianPerigeeToCartesian
	Jacobian for transforming perigee track parameters \((d_0, z_0, \phi_0, \theta, q/p)\) to the cartesian frame \((p_x,p_y,p_z,E,x,y,z)\). More...
class	JacobianPhiThetaLocalAngles
	This jacobian transforms the polar and azimutal angle \( \phi, \theta \) of a global momentum representation to a local momentum representation as given in the Trk::LocalMomentum class, therefor it is of dimension (2x2). More...
class	JacobianPhiThetaQoverPToPxyz
	Jacobian for the transformation of momentum in polar coordinates \( (\phi,\theta,qOverP)\) to momentum in Cartesian coordinates \((px, py, pz)\) : More...
class	JacobianPolarToCartesian
	Jacobian for the transformation of polar parameters \( (locR,locPhi,\phi,\theta, q/p)\) to cartesian parametes \((locX,locY,\phi,\theta, q/p)\) : More...
class	JacobianPxyzToPhiThetaQoverPcartesian
	Jacobian in cartesian coordinates for the transformation of momentum in Cartesian coordinates \( (px,py,pz,charge)\) to momentum in polar cordinates \((\phi,\theta,QoverP)\). More...
class	JacobianPxyzToPhiThetaQoverPspherical
	Jacobian in spherical coordinates for the transformation of momentum in Cartesian coordinates \( (px,py,pz,charge)\) to momentum in spherical cordinates \((\phi,\theta,QoverP)\). More...
class	JacobianThetaPToCotThetaPt
	This is the 5x5 jacobian for the transformation of track parameters and errors having the new standard momentum representation of \( (\phi, \theta, q/p) \) to the representation of \( (\phi, cot\theta, q/p_{T}) \), while the first two variables that express the local position representation keep unchanged. More...
class	JetFitterHelper
	Februar 2007 (c) Atlas Detector Reconstruction Software. More...
class	JetFitterInitializationHelper
	Februar 2007 (c) Atlas Detector Reconstruction Software. More...
class	JetFitterRoutines
	Februar 2007 (c) Atlas Detector Reconstruction Software. More...
class	JetRestrictedSumPtVertexWeightCalculator
class	JetTruthNtupleTool
	Tool to fill basic information about truth jets, establishing track-to-jet association indices with the truth ntuple tree. More...
struct	JetVtxParamDefsAccessor
	Simple struct to access the JetVtxParamDefs enum with ints. More...
struct	JetVtxParamDefsStrings
	Simple struct to access the strings of the JetVtxParamDefs enum names for output reasons. More...
class	KalmanUpdator
	Implementation of Trk::IUpdator based on gain formalism and Eigen. More...
class	KalmanUpdator_xk
	Trk::KalmanUpdator_xk is a set of tools for adding and removing measurements to/from the state vector using xKalman algorithms. More...
class	KalmanUpdatorSMatrix
	Implementation of Trk::IUpdator based on gain formalism and SMatrix mathlib. More...
class	KalmanVertexOnJetAxisSmoother
	ATLAS Reconstruction Software - (C) 2005 - 2007. More...
class	KalmanVertexOnJetAxisUpdator
	ATLAS Reconstruction Software - (C) 2005 - 2007. More...
class	KalmanVertexTrackUpdator
	A concrete implementation of the VertexTrackUpdator using the Kalman filter algorithm. More...
class	KalmanVertexUpdator
	A concrete implementation of the Vertex Updator using the Kalman filter algorithm. More...
struct	KDOP
class	Layer
	Base Class for a Detector Layer in the Tracking realm. More...
class	LayerArrayCreator
	The LayerArrayCreator is a simple Tool that helps to construct LayerArrays from std::vector of Trk::CylinderLayer, Trk::DiscLayer, Trk::PlaneLayer. More...
class	LayerAttemptsCalculator
	Simple helper class that allows to define different number of layer attempts in the extrapolation before throwing a veto. More...
class	LayerIndex
	LayerIndex for the identification of layers in a simplified detector geometry of Cylinders and Discs. More...
class	LayerMaterialAnalyser
	LayerMaterialProperties creator for CompoundLayerMaterial. More...
class	LayerMaterialConverter
	AlgTool that converts the layer material from one to another type. More...
class	LayerMaterialInspector
	This helper AlgTool can be called to record a dedicated tree that writes the LayerMaterialProperties into an ntuple. More...
class	LayerMaterialMap
	This class extends the DataVector<Trk::LayerMaterialProperties> by an elementTable;. More...
class	LayerMaterialMap_p1
class	LayerMaterialMap_tlp1
class	LayerMaterialProperties
	This virtual base class encapsulates the logics to build pre/post/full update material for Layer structures, it hosts 5 different MaterialProperties in the following order: More...
class	LayerMaterialProvider
	AlgTool that retrieves the LayerMaterial from COOL and loads it onto the geometry. More...
class	LayerMaterialRecord
	Helper Class to record the material during the GeantinoNtupleMappingProcess. More...
class	LayerProvider
	Wrapper around an ILayerBuilder to feed into the StagedGeometryBuilder. More...
class	LayerProviderCond
	Wrapper around an ILayerBuilderCond to feed into the StagedGeometryBuilderCond. More...
class	LayerProviderImpl
	Wrapper around an ILayerBuilderImpl to feed into the StagedGeometryBuilderImpl. More...
struct	LayerTreeObject
class	LinearizedTrack
struct	LineIntersection2D
class	LineSaggingDescriptor
	Fill in documentation. More...
class	LinkToTrack
	AUTO - An Undocumented Tracking Object. More...
class	LinkToTrackParticleBase
class	LinkToXAODNeutralParticle
	Element link to XAOD NeutralParticle. More...
class	LinkToXAODTrackParticle
	Element link to XAOD TrackParticle. More...
class	LocalDirection
	represents the three-dimensional global direction with respect to a planar surface frame. More...
class	LocalDirection_p1
class	LocalParameters
class	LocalParameters_p1
class	LocalPosition_p1
class	MagneticFieldProperties
	magnetic field properties to steer the behavior of the extrapolation More...
struct	MappedVertex
class	MappingTest
	Test to build the TrackingGeometry and try to map all points to layers. More...
class	MassConstraint
	Concrete implementation of Trk::IKinematicConstraint to formulate a mass constraint in kinematic vertex fits. More...
struct	MatchCompareByProbability
	This functor, used with TruthInverters, selects rec->mc truth map matches with higher associated probabilities. More...
class	Material
	A common object to be contained by. More...
class	Material_p1
	the persistent object is simply a std::vector<float> where More...
class	MaterialAllocator
	Main Fitter tool providing the implementation for the different fitting, extension and refitting use cases. More...
struct	MaterialComposition
class	MaterialEffectsBase
	base class to integrate material effects on Trk::Track in a flexible way. More...
class	MaterialEffectsBase_p1
class	MaterialEffectsEngine
	Material effects engine interface for charged and neutral (fast track simulation) , the update is alwyas on the: More...
class	MaterialEffectsOnTrack
	represents the full description of deflection and e-loss of a track in material. More...
class	MaterialEffectsOnTrack_p1
class	MaterialEffectsOnTrack_p2
	persistent representation v2 of MaterialEffectsOnTrack More...
class	MaterialEffectsUpdator
	Point-like (also called surface-based) update of TrackParameters and the associated covariance. More...
class	MaterialInteraction
	Collection of parametrizations used in the Tracking realm. More...
class	MaterialLayer
	A material layer is a simple helper class to attach material information to a boundary surface. More...
class	MaterialLayerNoOwnSurf
class	MaterialLayerOwnSurf
class	MaterialManipulation
	A simple algorithm that reads in the material maps and writes out a new file, allowing to manipulate the material maps. More...
class	MaterialMapper
	Implementation of the class MaterialMapper. More...
class	MaterialMapping
	A simple algorithm that throws random points through detector and associates them with the given/found layer. More...
class	MaterialOnTrackValidation
	This is for the Doxygen-Documentation. More...
class	MaterialProperties
	Material with information about thickness of material. More...
class	MaterialProperties_p1
	the persistent object is simply a std::vector<float> where More...
class	MaterialStep
	is needed for the recording of MaterialProperties from Geant4 and read them in with the mapping algorithm More...
class	MaterialStep_p1
	the persistent object is simply a std::vector<float> where More...
class	MaterialStepCollection_p1
class	MaterialValidation
struct	MatrixNtupleBranch
	This class provides a simple interface to write Matricis to a root tree The size of the Matrix cannot exceed COLMAX x ROWMAX. More...
class	MatrixTool
class	MCTrueSeedFinder
class	MeasuredAtaSurface_p1
class	MeasuredPerigee_p1
class	MeasurementBase
	This class is the pure abstract base class for all fittable tracking measurements. More...
class	MeasurementBaseComparisonFunction
	Class implementing a comparison function for sorting MeasurementBase objects. More...
class	MeasurementProcessor
class	MeasurementTypeID
	classifies a MeasurementBase into one of the known inherited flavours or one of the detector types for ROT/CompROT. More...
class	MeasurementVectorNtupleTool
	This validation tool writes basic information about Trk::Track into an ntuple; it is also the steering tool for all Trk::IValidationNtupleHelperTool. More...
class	MemoryLogger
	A small helper class looking at /proc/<PID>status. More...
class	Mode3dFromFsmw1dFinder
	modified from Mode3dFinder by Giaci.nosp@m.nto..nosp@m.Piacq.nosp@m.uadi.nosp@m.o@phy.nosp@m.sik..nosp@m.uni-f.nosp@m.reib.nosp@m.urg.d.nosp@m.e More...
class	Mode3dTo1dFinder
class	MSConstraintTracksProvider
class	MSHitDiffPlots
class	MSHitPlots
class	MultiComponentStateOnSurface
class	MultipleScatteringUpdator
	The Formula used is the highland formula for the projected scattering angle : More...
class	MuonTrackSummary
	Detailed track summary for the muon system Give access to hit counts per chamber. More...
class	MuonTrackSummary_p1
class	MuonTrackSummary_p2
class	MvfFitInfo
class	MVFVxCandidate
class	MVFVxCandidate_p1
class	MVFVxContainer_p1
class	MVFVxContainer_tlp1
class	MVFVxTrackAtVertex
class	MVFVxTrackAtVertex_p1
class	NavBinnedArray1D
	Avoiding a map search, the templated BinnedArray class can help ordereing geometrical objects by providing a dedicated BinUtility. More...
struct	NavigationCell
	useful struct for a single navigation cell More...
class	NavigationLayer
	Class to be used for gaps in Volumes as a navigational link. More...
class	Navigator
	Main AlgTool for Navigation in the TrkExtrapolation realm : It retrieves the TrackingGeometry from the DetectorStore as the reference Geometry. More...
class	NeuralNetworkToHistoTool
class	Neutral
	Simple helper class for defining track parameters for neutral particles. More...
class	NeutralParticleParameterCalculator
	Tool taking a two-track vertex and creating a neutral track from it. More...
class	NeutralTrack
class	NewtonTrkDistanceFinder
	AlgoTool which uses an iterative Newton method in two dimensions (the two points along the two tracks) in order to find their minimum distance. More...
class	NIMatEffUpdator
	Non-interacting timed material effects updator. More...
class	NoBounds
	Bounds object for a boundless surface (...) More...
class	NoiseOnSurface
class	ObjectAccessor
class	ObjectCounter
	Helper to enable counting number of instantiations in debug builds. More...
class	ObjectIntersection
	class extensions to return also the object More...
class	OverlapDescriptor
	BaseClass to be overloaded for describing overlaps and next-by elements for the sub-detector implementations. More...
class	PairOfVxVertexOnJetAxis
struct	ParamDefsAccessor
	Simple struct to access the ParamDefs enum with ints. More...
class	ParametersBase
	The base class for neutral and charged Track parameters. More...
class	ParametersCommon
	Common class for neutral, charged and Pattern Track Parameters. More...
struct	ParametersNextVolume
class	ParametersT
	Dummy class used to allow special convertors to be called for surfaces owned by a detector element. More...
class	ParamPlots
struct	ParamsNextVolume
struct	PartialMassConstraint
class	ParticleCaloExtensionTool
struct	PathLimit
class	PatternTrackParameters
class	PCutTruthCollectionFilter
	This functor accepts valid entries that have associated probability>=probabilityCut. More...
class	PdgToParticleHypothesis
	small converter from the (abs) PDG code to the particle hypothsis used in Tracking More...
class	Perigee_p1
class	Perigee_p2
class	PerigeeParametersNtupleTool
	Explain... More...
class	PerigeeSurface
	Class describing the Line to which the Perigee refers to. More...
class	PGraph
class	PlanarModuleStepper
	Module for fast, geometric. More...
class	PlaneLayer
	Class to describe a planar detector layer for tracking, it inhertis from both, Layer base class and PlaneSurface class. More...
class	PlaneLayerSorterX
	Functor for PlaneLayer X-Sorting. More...
class	PlaneLayerSorterY
	Functor for PlaneLayer Y-Sorting. More...
class	PlaneLayerSorterZ
	Functor for PlaneLayer Z-Sorting. More...
class	PlaneSurface
	Class for a planaer rectangular or trapezoidal surface in the ATLAS detector. More...
class	PointOnTrack
struct	PolygonCache
class	PositionMomentumWriter
	Position momentum writer. More...
class	PRD_AssociationTool
	Concrete Implementation of the IPRD_AssociationTool interface. More...
class	PRD_MultiTruthCollection_p1
class	PRD_MultiTruthCollection_p2
class	PRD_MultiTruthCollection_p3
class	PRD_MultiTruthCollection_p4
class	PRD_TruthTrajectory
	simple definitiion of a PRD_TruhtTrajectory More...
class	PRD_TruthTrajectoryBuilder
class	PRDtoTrackMap
class	PRDtoTrackMapTool
	Concrete Implementation of the IPRD_AssociationTool interface. More...
class	PrepRawData
class	PrepRawData_p1
class	PrepRawDataCollection
class	PrepRawDataCollectionCopyConstructorCalled
class	PrepRawDataComparisonFunction
	Class providing comparison function, or relational definition, for PrepRawData. More...
class	PrepRawDataContainer
class	PrepRawDataUndefinedVariable
	class thrown in the event of an variable not being defined. More...
class	PreselCaloExtensionBuilderAlg
	Build the calo extensions for a preselected collection of tracks. More...
class	PrimaryTruthClassifier
	modular concept to define certain categories of truth particles, this one labels primary, secondary and truncated tracks. More...
class	PrismVolumeBounds
	Bounds for the transcript of triangular prism. More...
class	ProjectionMatricesSet
	the matrices to access the variably-dimensioned local parameters and map them to the defined five track parameters. More...
class	PropagationEngine
	Wrapper around the IPropagator interface, the neutral propagation is solved by using the surface::straightLineIntersection mehtod. More...
class	PropResultRootWriterSvc
class	PseudoMeasurementOnTrack
	Class to handle pseudo-measurements in fitters and on track objects. More...
class	PseudoMeasurementOnTrack_p1
class	PseudoMeasurementOnTrack_p2
class	RandomSurfaceBuilder
	The RandomSurfaceBuilder is a simple Tool that helps to construct randomly poisitioned surfaces - mainly for validation studies. More...
struct	RealLinearEquation
	Mathematic struct for solving real linear equation. More...
struct	RealQuadraticEquation
class	RecMomentumQualityValidation
	This is for automatising the 100%, 50%, 20%, 10% tables for (indet) tracks. More...
class	RecoInfoPlots
class	RectangleBounds
	Bounds for a rectangular, planar surface. More...
class	RectangleBounds_p1
class	RectangularSegmentation
class	RecursiveGeometryProcessor
	Base class tool to step recursively through the Tracking Geometry, it starts from the TrackingGeometry, retrieves the highest volume and then processes all contained objects. More...
class	RecVertex
	Trk::RecVertex inherits from Trk::Vertex. More...
class	RecVertex_p1
class	RecVertex_p2
class	RecVertexPositions
class	ReFitTrack
	Algorithm using an instance of a ITrackFitter to refit the tracks of a given track collection. More...
class	ReFitTrackWithTruth
	Algorithm using an instance of a ITrackFitter to refit the tracks of a given pseudotrack collection after changing the cluster position to the truth particle position. More...
class	Residual
class	ResidualPull
	This class containes residual and pull information. More...
class	ResidualPullCalculator
	AlgTool to calculate the residual and pull of a measurement and the related track state independently of the detector type. More...
class	ResidualValidationNtupleHelper
	This validation helper tool writes residual data into the ntuple using the common Trk::ResidualPullCalculator. More...
class	ResolutionPlots
class	RiddersAlgorithm
	This is a test algorithm for evaluating the jacobians for the transport of Track Parameters. More...
class	RIO_OnTrack
	Class to handle RIO On Tracks ROT) for InDet and Muons, it inherits from the common MeasurementBase. More...
class	RIO_OnTrack_p1
class	RIO_OnTrack_p2
class	RIO_OnTrackCreator
	general tool to converts clusters or driftcircles (Trk::PrepRawData) to fully calibrated hits (Trk::RIO_OnTrack) further use in track fits. More...
class	RoT_Extractor
	Small utility to cast MeasurementBase (either in a vector or single) into RIO_OnTrack. More...
class	RotatedDiamondBounds
	Bounds for a double trapezoidal ("diamond"), planar Surface. More...
class	RotatedDiamondBounds_p1
class	RotatedTrapezoidBounds
	Bounds for a rotated trapezoidal, planar Surface. More...
class	RotatedTrapezoidBounds_p1
class	RungeKuttaIntersector
class	RungeKuttaPropagator
	Trk::RungeKuttaPropagator is an algorithm for track parameters propagation through magnetic field. More...
class	SaggedLineSurface
	The distorted surface itself is the nominal surface. More...
class	ScatteringAngleOnTrack_p1
class	ScatteringAngles
	represents a deflection of the track caused through multiple scattering in material. More...
class	SecVertexMergingTool
class	SeedNewtonTrkDistanceFinder
	Algotool which calculates the distance between the two tracks, using: the distance finder you specify, which is an object of type NewtonTrkDistanceFinderAlgo, and using a starting position on the tracks given by Trk2dDistanceSeeder. More...
class	Segment
	Base class for all TrackSegment implementations, extends the common MeasurementBase. More...
class	Segment_p1
class	Segmentation
	Segementation class for generic pixel, strixels and strip segmentations on a rectangle shape. More...
class	SegmentCollection_p1
class	SegmentCollection_tlp1
class	SegmentCollection_tlp2
class	SegmentCollection_tlp3
class	SegmentCollection_tlp4
class	SelectedTracksInJet
class	SelectEventNumber
class	SequentialVertexFitter
	An iterative vertex fitter, updating the vertex estimate with a single at the time. More...
class	SequentialVertexSmoother
	A concrete implementation of the Vertex smoother Takes the tracks from the VxCandidates and updates them with the knowledge of the reconstructed vertex position. More...
class	ShiftingDerivCalcTool
class	SimpleAmbiguityProcessorTool
class	SimplePolygonBrepVolumeBounds
	Bounds for the exact transcript of the GeoSimplePolygonBrep; volume defined by combination of symm.trapezoids. More...
struct	sincosCache
class	SingleTrackDiffAlg
	This Validation algorithm takes two track collections and performes a diff on one track of each collection. More...
class	SlidingCylinderSurface
	Class for a Calo CylinderSurface with variable depth in the ATLAS detector. More...
class	SlidingDiscSurface
	Class for a Calo DiscSurface with variable depth in the ATLAS detector. More...
class	SolenoidalIntersector
class	SolenoidParametrization
class	SolenoidParametrizationCondAlg
class	SpacePoint
class	SpaceTimePoint
	SpaceTimePoint. More...
class	SpaceTimePointBase
	SpaceTimePointBase. More...
class	StaticEngine
	Extrapolation engine for static layer & volume setup. More...
class	StaticNavigationEngine
class	StatTruthCollectionFilter
	Works like PCutTruthCollectionFilter, but also gathers some stats about the collections. More...
class	STEP_Propagator
	STEP (Simultaneous Track and Error Propagation ) is an algorithm for track parameters propagation through magnetic field. More...
class	StraightLineIntersector
class	StraightLineSurface
	Class for a StraightLineSurface in the ATLAS detector to describe dirft tube and straw like detectors. More...
class	SubDetHitStatistics_p0
class	SubtractedCylinderLayer
	Class to describe a cylindrical detector layer for tracking, with subtraction; it inhertis from both, Layer base class and SubtractedCylinderSurface class. More...
class	SubtractedCylinderSurface
	Class for a cylinder subtracted/shared surface in the ATLAS detector. More...
class	SubtractedDiscSurface
	Class for a planar subtracted/shared surface in the ATLAS detector. More...
class	SubtractedPlaneLayer
	Class to describe a planar detector layer for tracking, with subtraction. More...
class	SubtractedPlaneSurface
	Class for a planar subtracted/shared surface in the ATLAS detector. More...
class	SubtractedVolumeBounds
	Bounds for a generic subtracted volume, the decomposeToSurfaces method creates a vector of n surfaces (n1+n2-n_subtracted): More...
class	SumPtVertexWeightCalculator
class	Surface
	Abstract Base Class for tracking surfaces. More...
class	Surface_p1
class	Surface_p2
class	SurfaceBounds
	Abstract base class for surface bounds to be specified. More...
class	SurfaceDeleter
class	SurfaceIntersectionTest
struct	SurfaceNtupleBranch
	This class provides a simple interface to write Surfaces to a root tree. More...
class	SurfacePtrHolderImpl
class	SurfacePtrHolderImplDetEl
struct	SurfaceTreeObject
class	SurfaceUniqHolderImpl
class	temp
class	TimedExtrapolator
	The TimedExtrapolator is to be used for the simulation purposes. More...
struct	TimeLimit
class	Track
	The ATLAS Track class. More...
class	Track_p1
class	Track_p12
class	Track_p2
class	Track_p4
class	TrackCollection_p1
class	TrackCollection_tlp1
class	TrackCollection_tlp2
class	TrackCollection_tlp3
class	TrackCollection_tlp4
class	TrackCollection_tlp5
class	TrackCollection_tlp6
class	TrackCollection_tlp7
class	TrackCollectionMerger
	Class-algorithm for track collection merging and removalof potential duplicate tracks. More...
class	TrackCollectionProvider
class	TrackDensitySeedFinder
class	TrackDiff
	This validation tool writes the differences between two tracks into a ntuple. More...
class	TrackError
	class returned (by exception) in case of an error in Track More...
class	TrackInfo
	Contains information about the 'fitter' of this track. More...
class	TrackInfo_p1
class	TrackInformationNtupleTool
class	TrackingGeometry
	The TrackingGeometry class is the owner of the constructed TrackingVolumes. More...
class	TrackingGeometryCondAlg
class	TrackingGeometryCondAlgTest
class	TrackingGeometrySvc
	This service builds and registers the TrackingGeometry in the detector store. More...
class	TrackingGeometryTest
	Test to build the TrackingGeometry and process it with analizers, thosw are of type IGeometryProcessor. More...
class	TrackingVolume
	Full Volume description used in Tracking, it inherits from Volume to get the geometrical structure, such as from MaterialProperties and from MagneticFieldProperties. More...
class	TrackingVolumeArrayCreator
	The TrackingVolumeArrayCreator is a simple Tool that helps to construct binned arrays of TrackingVolumes for both, confinement in another volume and navigation issues. More...
class	TrackingVolumeDisplayer
	The TrackingVolumeDisplayer writes a root .C file which can be executed and used the OpenGL root viewer. More...
class	TrackingVolumeHelper
	The TrackingVolumeHelper is a simple Tool that helps to construct volumes mainly for gap regions in the fully connective geometry. More...
class	TrackingVolumeManipulator
	The only way to change BoundarySurfaces etc from Tracking Volumes. More...
class	TrackingVolumesSvc
class	TrackJet
	short class to organise reconstructed Trk::Track objects as a jet. More...
struct	TrackMatchingProperties
class	TrackParameters_p1
class	TrackParameters_p2
class	TrackParametersIdentificationHelper
	helper class to get the TrackParametersIdentifier from a TrackParameters More...
class	TrackParametersIdHelper
	helper class to encode and decode a TrackParametersIdentifier More...
class	TrackParticleBase
class	TrackParticleBase_p1
class	TrackParticleCreatorTool
class	TrackPositionNtupleHelper
	This validation tool writes information about track positions. More...
class	TrackPtr
class	TrackRoad
	Encapsulates the information required by the find() method of the muon segment makers. More...
class	TrackSegment
	Class for a generic track segment that holdes polymorphic Trk::MeasurementBase objects, it extends the Trk::Segment base class. More...
class	TrackSegment_p1
class	TrackSelectionProcessorTool
class	TrackSlimmer
	Simple algorithm to load tracks and use Trk::ITrackSlimmingTool to e.g. More...
class	TrackSlimmingTool
	A tool to produce 'slimmed' Tracks from a reference track. More...
class	TrackStateData
	Helper class for Trk::TrackDiff. More...
class	TrackStateOnSurface
	represents the track state (measurement, material, fit parameters and quality) at a surface. More...
class	TrackStateOnSurface_p1
class	TrackStateOnSurface_p2
class	TrackStateOnSurface_p3
class	TrackStateOnSurfaceComparisonFunction
	Class providing comparison function, or relational definition, for sorting MeasurementBase objects. More...
class	TrackSummary
	A summary of the information contained by a track. More...
class	TrackSummary_p1
class	TrackSummary_p2
class	TrackSummaryTool
class	TrackSurfaceIntersection
	An intersection with a Surface is given by. More...
class	TrackToVertexIPEstimator
	A class estimating the transverse impact parameter d0 and its error of a given track wrt to the reconstructed vertex. More...
class	TrackToVtxLink
class	TrackTruthCollection_p1
class	TrackTruthCollection_p2
class	TrackTruthCollection_p3
class	TrackTruthKey
struct	TrackTruthKey_p0
class	TrackValidationNtupleWriter
	Validation Algorithm to retrieve a Track Collection, loop over the tracks and write track information into ntuples using IValidationNtupleTool. More...
struct	TransformNtupleBranch
	This class provides a simple interface to write Transforms to a root tree. More...
class	TransportJacobian
	This class represents the jacobian for transforming initial track parameters to new track parameters after propagation to new surface. More...
class	TrapezoidBounds
	Bounds for a trapezoidal, planar Surface. More...
class	TrapezoidBounds_p1
class	TrapezoidSegmentation
class	TrapezoidVolumeBounds
	Bounds for a trapezoidal shaped Volume, the decomposeToSurfaces method creates a vector of 6 surfaces: More...
class	TriangleBounds
	Bounds for a triangular, planar surface. More...
class	TriangleBounds_p1
	Persisent representation of the transient TriangleBounds class. More...
class	Trk2DDistanceFinder
	Algotool which calculates the distance between the two tracks in 2d only, re-using the Trk2dDistanceSeeder tool, which is based on the analytic solution of the minimum distance between two circles. More...
class	Trk2dDistanceSeeder
	AlgoTool calculates the points of minimum distance between two tracks on the transverse plane, which is analytically well defined (intersection of two circles). More...
class	TrkAlignDBTool
class	TrkAmbiguityScore
class	TrkAmbiguitySolver
	Algorithm does ambiguity processing This algorithm uses the TrkAmbiguityProcessorTool AlgTool to resolve ambiguities in the passed tracks. More...
class	TrkBaseNode
class	TrkClusterNode
class	TrkCollectionAliasAlg
	This algorithm creates in StoreGate an alias name for the StoreGate container key given as property. More...
class	TrkDetDescrTPCnvTest
	Test the new TP Converter for writing and reading. More...
class	TrkDetDescrUnitTestBase
	Base class for all unit tests in the TrkDetDescr package, gives access to gaussian and flat random numbers. More...
class	TrkDetElementBase
	This is the base class for all tracking detector elements with read-out relevant information. More...
class	TrkDistanceFinderNeutralCharged
class	TrkDistanceFinderNeutralNeutral
class	TrkEndCapClusterNode
class	TrkExUnitTestBase
	Base class for all unit tests in the TrkEx package, gives access to gaussian and flat random numbers. More...
class	TrkFilteringNode1D
class	TrkFilteringNode2D
class	TrkMaterialProviderTool
class	TrkObserverTool
class	TrkPixelNode
class	TrkPlanarSurface
class	TrkPriVxPurity
	A prototype data class for primary vertex purity. More...
class	TrkPriVxPurityTool
	A tool estimating the purity of the reconstructed primary vertex. More...
class	TrkTrackDict_Dummy
class	TrkTrackState
class	TrkTrtNode
class	TrkV0VertexFitter
	This class implements a vertex fitting algorithm optimised for V0 finding. More...
class	TrkVKalVrtFitter
class	TrkVKalVrtFitterTestAlg
class	TrueVertexDistanceWeightCalculator
class	TruthInfoPlots
class	TruthMatchRatio
class	TruthMatchTanimoto
class	TruthNtupleTool
	Tool to fill basic information about the truth record. More...
class	TruthToTrack
class	TruthTrackBuilder
class	TruthTrackCreation
	Algorithm to convert PRD multi truth maps into a track collection. More...
class	TruthTrackRecordToTrack
	TruthTrackRecordToTrack is an AlgTool to create Trk::TrackParameters from a HepMC::GenParticle expressed at a "TrackRecordCollection" anywhere in ATLAS. More...
struct	TruthTrajectory_p0
class	TruthTrajectory_p1
class	TruthTrajectory_p2
class	TruthTrajectory_p3
class	TruthTrkExtrapolationPlots
class	TruthVertexSelectionTool
class	TwoTracks
class	TwoTrackVerticesInJet
class	TWRK
class	V0Candidate
class	V0Candidate_p1
class	V0Container_p1
class	V0Container_tlp1
class	V0Container_tlp2
class	V0Hypothesis
	An extension of Trk::ExtendedVxCandidate, to be used for constrained and unconstrained V0 candidates storage. More...
class	V0Hypothesis_p1
class	V0Tools
class	ValidationTrackTruthData
struct	ValueStore
struct	Vect3DF
struct	VectMOM
struct	VectorNtupleBranch
	This class provides a simple interface to write Vectors to a root tree The size of the vectors cannot exceed ROWMAX. More...
class	Vertex
	This class is a simplest representation of a vertex candidate. More...
class	Vertex_p1
class	VertexCollectionSortingTool
class	VertexMapper
	The vertex mapper transforms vertices from global coordinates into the local coordinate frame of the closest sensitive surface. More...
class	VertexMergingTool
class	VertexOnTrack
	Class to handle Vertex On Tracks, it inherits from the common MeasurementBase. More...
class	VertexOnTrack_p1
class	VertexPositions
	VertexPositions class to represent and store a vertex. More...
class	VertexSeedFinderTestAlg
class	VKalAtlasMagFld
class	VKalExtPropagator
class	vkalMagFld
class	vkalPropagator
class	VKalVrtControl
class	VKalVrtControlBase
class	VKConstraintBase
class	VKMassConstraint
class	VKPhiConstraint
class	VKPlaneConstraint
class	VKPointConstraint
class	VKRadiusConstraint
class	VKThetaConstraint
class	VKTrack
class	VKVertex
class	Volume
	Base class for all volumes inside the tracking realm, it defines the interface for inherited Volume classes regarding the geometrical information. More...
class	VolumeBounds
	Pure Absract Base Class for Volume bounds. More...
class	VolumeConverter
	A Simple Helper Class that collects methods for material simplification. More...
class	VolumeExcluder
	removes explicit dependence of Subtracted*Surface on TrkVolumes More...
struct	VolumeExit
class	VolumeIntersection
	A Simple Helper Class that collects methods for calculation of overlap of two geometrical objects. More...
class	VolumeLink
	LinkUtitlity for Volumes with update possibility. More...
struct	VolumePart
struct	VolumeSpan
struct	VolumeTreeObject
	-> simple helper struct for filling the Volume objects More...
class	VxCandidate
class	VxCandidate_p1
class	VxCascadeInfo
class	VxClusteringTable
class	VxContainer_p1
class	VxContainer_tlp1
class	VxContainer_tlp2
class	VxJetCandidate
class	VxJetFitterDebugInfo
class	VxJetFitterVertexInfo
class	VxSecVertexInfo
class	VxSecVKalVertexInfo
class	VxTrackAtVertex
	The VxTrackAtVertex is a common class for all present TrkVertexFitters The VxTrackAtVertex is designed to store the information about the trajectory fitted to the VxCandidate. More...
class	VxTrackAtVertex_p1
class	VxTrackAtVertex_p2
class	VxVertexOnJetAxis
	VxVertexOnJetAxis inherits from Vertex. More...
class	WeightMatrix_p1
class	Z0PVTrackCompatibilityEstimator
	Z0PVTrackCompatibilityEstimator.h. More...
class	ZScanSeedFinder

Typedefs
typedef std::pair< std::shared_ptr< Surface >, Amg::Vector3D >	SurfaceOrderPosition
using	TrackingVolumeOrderPosition
typedef std::pair< long int, long int >	indices
typedef std::map< indices, double >	datamap
typedef datamap::iterator	mapiterator
typedef datamap::const_iterator	const_mapiterator
typedef std::vector< AlignModule * >	AlignModuleList
typedef boost::multi_array< AlignPar *, 2 >	AlignParList
typedef boost::array< boost::multi_array_types::index, 2 >	AlignParListDims
typedef DataVector< AlignTSOS >	AlignTSOSCollection
typedef DataVector< AlignTSOS >::const_iterator	AlignTSOSIt
typedef std::pair< AlignModule *, std::vector< Amg::VectorX > >	AlignModuleDerivatives
typedef std::vector< AlignTrack ** >	AlignTrackCollection
typedef std::vector< AlignTrack ** >::const_iterator	AlignTrackIt
typedef std::pair< const AlignModule *, std::vector< Amg::VectorX > >	AlignModuleVertexDerivatives
typedef std::pair< Amg::Vector3D, const Trk::TrackingVolume * >	PositionAtBoundary
using	MaterialComponent = std::pair<Material, double>
using	VolumePartVec = std::vector<VolumePart>
typedef std::vector< std::vector< const MaterialProperties * > >	MaterialPropertiesMatrix
using	TrackingVolumeArray = BinnedArray<TrackingVolume>
	simply for the eye
typedef std::map< Trk::LayerIndex, int >	LayerIndexSampleMap
using	ThreeObjectsAccessor = std::array<ObjectAccessor::value_type, 3>
using	FourObjectsAccessor
using	FiveObjectsAccessor = std::array<ObjectAccessor::value_type, 5>
using	SixObjectsAccessor = std::array<ObjectAccessor::value_type, 6>
using	EightObjectsAccessor = std::array<ObjectAccessor::value_type, 8>
typedef std::pair< std::shared_ptr< Material >, int >	IdentifiedMaterial
typedef std::vector< unsigned char >	ValueVector
typedef std::vector< ValueVector >	ValueMatrix
typedef std::map< BoundarySurfaceFace, std::vector< TrackingVolume * > >::iterator	GlueVolumeIterator
typedef std::map< BoundarySurfaceFace, std::vector< TrackingVolume * > >::const_iterator	GlueVolumeConstIterator
typedef ObjectIntersection< Surface >	SurfaceIntersection
typedef BinnedArray< Surface >	SurfaceArray
typedef DataVector< Trk::LayerMaterialProperties >	LayerMaterialCollection
typedef std::vector< const MaterialProperties * >	MaterialPropertiesVector
	Useful typedefs.
typedef DataVector< Trk::MaterialStep >	MaterialStepCollection
typedef BinnedArray< Layer >	LayerArray
	simply for the eye
template<class T>
using	ArraySpan = std::span<T>
template<class T>
using	LayerIntersection = FullIntersection<Layer, Surface, T>
template<class T>
using	BoundaryIntersection
typedef SurfaceUniquePtrT< Trk::Surface >	SurfaceUniquePtr
typedef SurfaceUniquePtrT< const Trk::Surface >	ConstSurfaceUniquePtr
using	ConeSurfacePtrHolder = SurfacePtrHolderImpl<ConeSurface>
using	CylinderSurfacePtrHolder = SurfacePtrHolderImpl<CylinderSurface>
using	DiscSurfacePtrHolder = SurfacePtrHolderImpl<DiscSurface>
using	PerigeeSurfacePtrHolder = SurfacePtrHolderImpl<PerigeeSurface>
using	PlaneSurfacePtrHolder = SurfacePtrHolderImpl<PlaneSurface>
using	StraightLineSurfacePtrHolder = SurfacePtrHolderImpl<StraightLineSurface>
using	SurfacePtrHolder = SurfacePtrHolderImpl<Surface>
using	ConeSurfaceUniqHolder = SurfaceUniqHolderImpl<ConeSurface>
using	CylinderSurfaceUniqHolder = SurfaceUniqHolderImpl<CylinderSurface>
using	DiscSurfaceUniqHolder = SurfaceUniqHolderImpl<DiscSurface>
using	PerigeeSurfaceUniqHolder = SurfaceUniqHolderImpl<PerigeeSurface>
using	PlaneSurfaceUniqHolder = SurfaceUniqHolderImpl<PlaneSurface>
using	StraightLineSurfaceUniqHolder
using	SurfaceUniqHolder = SurfaceUniqHolderImpl<Surface>
using	SurfacePtrHolderDetEl = Trk::SurfacePtrHolderImplDetEl<Surface>
typedef std::pair< size_t, size_t >	DigitizationCell
typedef std::pair< double, ParamDefs >	DefinedParameter
	Typedef to of a std::pair<double, ParamDefs> to identify a passed-through double as a specific type of parameter.
template<class S>
using	SurfaceUniquePtrT = std::unique_ptr<S, SurfaceDeleter<S> >
typedef float	TrackScore
typedef std::multimap< const Trk::Track *, std::pair< const Trk::Track *, Trk::TrackMatchingProperties > >	TrackMatchMultiMap
typedef ComparisonFunction< TrackParameters >	TrkParametersComparisonFunction
using	NeutralParameters = ParametersBase<NeutralParametersDim, Neutral>
using	NeutralCurvilinearParameters = CurvilinearParametersT<NeutralParametersDim, Neutral, PlaneSurface>
using	NeutralAtaCone = ParametersT<NeutralParametersDim, Neutral, ConeSurface>
using	NeutralAtaCylinder = ParametersT<NeutralParametersDim, Neutral, CylinderSurface>
using	NeutralAtaDisc = ParametersT<NeutralParametersDim, Neutral, DiscSurface>
using	NeutralPerigee = ParametersT<NeutralParametersDim, Neutral, PerigeeSurface>
using	NeutralAtaPlane = ParametersT<NeutralParametersDim, Neutral, PlaneSurface>
using	NeutralAtaStraightLine = ParametersT<NeutralParametersDim, Neutral, StraightLineSurface>
using	MultiComponentState = std::vector<ComponentParameters>
using	BaseParameters = ParametersCommon<TrackParametersDim, Charged>
using	TrackParameters = ParametersBase<TrackParametersDim, Charged>
using	CurvilinearParameters = CurvilinearParametersT<TrackParametersDim, Charged, PlaneSurface>
using	AtaCone = ParametersT<TrackParametersDim, Charged, ConeSurface>
using	AtaCylinder = ParametersT<TrackParametersDim, Charged, CylinderSurface>
using	AtaDisc = ParametersT<TrackParametersDim, Charged, DiscSurface>
using	Perigee = ParametersT<TrackParametersDim, Charged, PerigeeSurface>
using	AtaPlane = ParametersT<TrackParametersDim, Charged, PlaneSurface>
using	AtaStraightLine = ParametersT<TrackParametersDim, Charged, StraightLineSurface>
typedef VertexType	TrackParticleOrigin
typedef DataVector< TrackParticleBase >	TrackParticleBaseCollection
typedef std::multimap< Trk::PrepRawData *, RIO_OnTrack * >	RIOtoROT_Multimap
typedef DataVector< Trk::TrackRoad >	TrackRoadCollection
typedef DataVector< Trk::Segment >	SegmentCollection
using	TrackStates = DataVector<const Trk::TrackStateOnSurface>
typedef std::multimap< const Trk::Track *, int >	TrackSeedMap
typedef DataVector< Trk::VxSecVertexInfo >	VxSecVertexInfoContainer
typedef FitQuality_p1	FitQualityOnSurface_p1
using	MeasuredPerigee = Perigee
typedef Surface_p1	PerigeeSurface_p1
typedef TrackTruthVector	TrackTruthCollection_p0
typedef ExtrapolationCell< TrackParameters >	ExCellCharged
typedef ExtrapolationCell< NeutralParameters >	ExCellNeutral
typedef std::pair< int, const NavigationCell * >	IdNavigationCell
typedef std::pair< const TrackParameters *, double >	TrackParametersWithPath
	typedef for return type TrackParameters, pathlength
using	DestSurf = std::pair<const Surface*, BoundaryCheck>
	typedef for input surfaces, boundary check
using	TrackParametersUVector = std::vector<std::unique_ptr<Trk::TrackParameters>>
template<typename T>
using	CacheOwnedPtr = T*
typedef std::pair< const NavigationCell *, const NavigationCell * >	NavigationPair
typedef std::vector< const Trk::TrackParameters * >	TrackParametersVector
typedef bool	RunOutlierRemoval
	switch to toggle quality processing after fit
using	PrepRawDataSet = std::vector<const PrepRawData*>
	vector of clusters and drift circles
using	MeasurementSet = std::vector<const MeasurementBase*>
	vector of fittable measurements
using	RIO_OnTrackSet = std::vector<const RIO_OnTrack*>
	vector of detector hits on a track
using	SpacePointSet = std::vector<const SpacePoint*>
	vector of space points
typedef std::vector< std::pair< const Track *, float > >	TracksScores
typedef Eigen::Matrix< double, 3, Eigen::Dynamic >	AmgMatrix3X
typedef std::pair< Amg::Vector3D, double >	PositionAndWeight
typedef std::pair< double, double >	DoubleAndWeight
typedef std::pair< PointOnTrack, PointOnTrack >	TwoPointOnTrack
typedef std::pair< Amg::Vector3D, Amg::Vector3D >	TwoPoints
typedef void(*	addrPropagator) (long int, long int, double *, double *, double *, double *, double *, double *)
template<class T>
using	noinit_vector = std::vector<T, boost::noinit_adaptor<std::allocator<T> > >
	A variant on std::vector which leaves its contents uninitialized by default.
typedef void(*	addrMagHandler) (double, double, double, double &, double &, double &)
typedef int	VertexID
typedef std::vector< double >	dvect

Enumerations
enum	ExtraLocalPosParam { distDepth = 2 }
enum	AlignModuleListType {   L0 =0 , L1 , L2 , L3 ,   L1_5 , L2_5 , ModulesOnTrack }
	Type of AlignModuleList (see description above). More...
enum	AlignResidualType { HitOnly , Unbiased }
enum	AlignMesType { Measurement , Scatterer , EnergyDeposit }
enum	LayerOrder { previous = -1 , next = 1 }
	This enum is used to declare Layers as previous/next in respect of a 1-dimensional binned array. More...
enum	BinningType { equidistant , biequidistant , arbitrary }
	, BinningOption & BinningAccess More...
enum	BinningOption { open , closed }
	enum BinValue More...
enum	BinningValue {   binX , binY , binZ , binR ,   binPhi , binRPhi , binH , binEta }
	how to take the global / local position More...
enum	GeometrySignature {   Global = 0 , ID = 1 , BeamPipe = 2 , Calo = 3 ,   MS = 4 , Cavern = 5 , HGTD = 6 , NumberOfSignatures = 7 ,   Unsigned = 99 }
enum	GeometryType {   Static = 0 , Dense = 1 , DenseWithLayers = 1 , Detached = 2 ,   Master = 3 , NumberOfGeometryTypes = 3 }
enum	MaterialAssociationType { EffectiveNumSteps = 0 , EffectiveNumAtoms = 1 , RadiationLength = 2 , StepLength = 4 }
enum class	DetectorElemType {   SolidState = 0 , Silicon = 1 , TRT = 2 , Csc = 3 ,   Mdt = 4 , Rpc = 5 , Tgc = 6 , sTgc = 7 ,   MM = 8 }
enum	LayerType { passive = 0 , active = 1 }
	For readability. More...
enum	MaterialConcentration { alongPre = 1 , split = 0 , oppositePre = -1 }
	Simple enum to identify when a material update on a non-structured layer should be done, options are alongPre and oppositePre. More...
enum	MagneticFieldMode { NoField = 0 , ConstantField = 1 , FastField = 2 , FullField = 3 }
	MagneticFieldMode describing the field setup within a volume. More...
enum	NavigationLevel { noNavigation = 0 , globalSearch = 1 , association = 2 }
	destinguishes an association TrackingGeometry with one for global search More...
enum	RQESolutionType {   none = 0 , one = 1 , two = 2 , none = 0 ,   one = 1 , two = 2 }
enum	SurfaceOwner { noOwn = 0 , TGOwn = 1 , DetElOwn = 2 , userOwn = 3 }
enum	BevelledCylinderAccessorType { BevelledCylinderZincrease = 0 , BevelledCylinderZdecrease = 1 , BevelledCylinderPositiveFace = 2 , BevelledCylinderNegativeFace = 3 }
enum	BevelledTubeAccessorType {   BevelledTubeRincreaseZincrease = 0 , BevelledTubeRincreaseZdecrease = 1 , BevelledTubeZincreaseRincrease = 2 , BevelledTubeZdecreaseRincrease = 3 ,   BevelledTubeRdecreaseZincrease = 4 , BevelledTubeRdecreaseZdecrease = 5 , BevelledTubeZincreaseRdecrease = 6 , BevelledTubeZdecreaseRdecrease = 7 ,   BevelledTubeOutsideRminRdecrease = 8 , BevelledTubeOutsideRmaxRincrease = 9 , BevelledTubeOutsideZminZdecrease = 10 , BevelledTubeOutsideZmaxZincrease = 11 }
enum	SectoralBevelledCylinderAccessorType { StandardSectoralBevelledCylinder = 0 }
enum	SectoralBevelledTubeAccessorType { StandardSectoralBevelledTube = 0 }
enum	BoundarySurfaceFace {   negativeFaceXY = 0 , positiveFaceXY = 1 , negativeFaceYZ = 2 , positiveFaceYZ = 3 ,   negativeFaceZX = 4 , positiveFaceZX = 5 , cylinderCover = 2 , tubeInnerCover = 3 ,   tubeOuterCover = 2 , tubeSectorNegativePhi = 4 , tubeSectorPositivePhi = 5 , tubeSectorInnerCover = 3 ,   tubeSectorOuterCover = 2 , trapezoidFaceAlpha = 2 , trapezoidFaceBeta = 3 , index0 = 0 ,   index1 = 1 , index2 = 2 , index3 = 3 , index4 = 4 ,   index5 = 5 , index6 = 6 , index7 = 7 , index8 = 8 ,   index9 = 9 , index10 = 10 , index11 = 11 , undefinedFace = 99 }
	Enum to describe the position of the BoundarySurface respectively to the frame orientatin of the volume, this is mainly ment for code readability. More...
enum	CylinderAccessorType { CylinderZincrease = 0 , CylinderZdecrease = 1 , CylinderPositiveFace = 2 , CylinderNegativeFace = 3 }
enum	TubeAccessorType {   TubeRincreaseZincrease = 0 , TubeRincreaseZdecrease = 1 , TubeZincreaseRincrease = 2 , TubeZdecreaseRincrease = 3 ,   TubeRdecreaseZincrease = 4 , TubeRdecreaseZdecrease = 5 , TubeZincreaseRdecrease = 6 , TubeZdecreaseRdecrease = 7 ,   TubeOutsideRminRdecrease = 8 , TubeOutsideRmaxRincrease = 9 , TubeOutsideZminZdecrease = 10 , TubeOutsideZmaxZincrease = 11 }
enum	SectoralCylinderAccessorType { StandardSectoralCylinder = 0 }
enum	SectoralTubeAccessorType { StandardSectoralTube = 0 }
enum	DriftCircleSide { NONE , LEFT , RIGHT }
	Enumerates the 'side' of the wire on which the tracks passed (i.e. More...
enum	DriftCircleStatus { DECIDED , UNDECIDED , CORRUPT , NODRIFTTIME }
	Enumerates the 'status' of the wire on which the tracks passed (based on the TRT_Side enum, from InDet::TRT_DriftCircleOnTrack, which this should eventually replace) More...
enum	ParamDefs {   loc1 = 0 , loc2 = 1 , locX = 0 , locY = 1 ,   locRPhi = 0 , locPhiR = 0 , locZ = 1 , locR = 0 ,   locPhi = 1 , iPhi = 0 , iEta = 1 , distPhi = 0 ,   distEta = 1 , driftRadius = 0 , x = 0 , y = 1 ,   z = 2 , px = 0 , py = 1 , pz = 2 ,   d0 = 0 , z0 = 1 , phi0 = 2 , theta = 3 ,   qOverP = 4 , phi = 2 , u = 0 , v = 1 ,   trkMass = 5 }
	This file defines the parameter enums in the Trk namespace. More...
enum	ParticleHypothesis {   nonInteracting = 0 , geantino = 0 , electron = 1 , muon = 2 ,   pion = 3 , kaon = 4 , proton = 5 , photon = 6 ,   neutron = 7 , pi0 = 8 , k0 = 9 , nonInteractingMuon = 10 ,   noHypothesis = 99 , undefined = 99 }
	Enumeration for Particle hypothesis respecting the interaction with material. More...
enum	PropDirection { alongMomentum = 1 , oppositeMomentum =-1 , anyDirection = 0 , mappingMode = 2 }
	PropDirection, enum for direction of the propagation. More...
enum	SearchDirection { outside =1 , inside =-1 , bothway =0 , undefinedDirection =0 }
enum	MaterialUpdateStage { preUpdate = -1 , fullUpdate = 0 , postUpdate = 1 }
	This is a steering enum to tell which material update stage: More...
enum class	SurfaceType {   Cone = 0 , Cylinder = 1 , Disc = 2 , Perigee = 3 ,   Plane = 4 , Line = 5 , Curvilinear = 6 , Other = 7 }
	This enumerator simplifies the persistency & calculations,. More...
enum	VertexType {   NoVtx = 0 , PriVtx = 1 , SecVtx = 2 , PileUp = 3 ,   ConvVtx = 4 , V0Vtx = 5 , KinkVtx = 6 , V0Lambda = 7 ,   V0LambdaBar = 8 , V0KShort = 9 , NotSpecified = -99 }
	This file defines the enums in the Trk namespace for the different vertex types. More...
enum	ParametersType { AtaSurface = 0 , Curvilinear = 1 , Pattern = 2 }
	Enum to avoid dynamic cast for different parameter types. More...
enum class	PrepRawDataType {   SiCluster , PixelCluster , SCT_Cluster , TRT_DriftCircle ,   HGTD_Cluster , PlanarCluster , MdtPrepData , CscStripPrepData ,   CscPrepData , MMPrepData , RpcPrepData , TgcPrepData ,   sTgcPrepData }
enum	SummaryType {   numberOfContribPixelLayers = 29 , numberOfBLayerHits = 0 , numberOfInnermostPixelLayerHits = 53 , numberOfNextToInnermostPixelLayerHits = 58 ,   numberOfPixelHits = 2 , numberOfPixelHoles = 1 , numberOfGangedPixels = 14 , numberOfGangedFlaggedFakes = 32 ,   numberOfPixelDeadSensors = 33 , numberOfPixelSpoiltHits = 35 , numberOfDBMHits = 63 , numberOfSCTHits = 3 ,   numberOfSCTHoles = 4 , numberOfSCTDoubleHoles = 28 , numberOfSCTDeadSensors = 34 , numberOfSCTSpoiltHits = 36 ,   numberOfTRTHits = 5 , numberOfTRTOutliers = 19 , numberOfTRTHoles = 40 , numberOfTRTHighThresholdHits = 6 ,   numberOfTRTHighThresholdHitsTotal = 64 , numberOfTRTHitsUsedFordEdx = 65 , numberOfTRTHighThresholdOutliers = 20 , numberOfTRTDeadStraws = 37 ,   numberOfTRTTubeHits = 38 , numberOfTRTXenonHits = 46 , numberOfMdtHits = 7 , numberOfTgcPhiHits = 8 ,   numberOfTgcEtaHits = 9 , numberOfCscPhiHits = 10 , numberOfCscEtaHits = 11 , numberOfRpcPhiHits = 12 ,   numberOfRpcEtaHits = 13 , numberOfCscEtaHoles = 21 , numberOfCscPhiHoles = 22 , numberOfRpcEtaHoles = 23 ,   numberOfRpcPhiHoles = 24 , numberOfMdtHoles = 25 , numberOfTgcEtaHoles = 26 , numberOfTgcPhiHoles = 27 ,   numberOfStgcEtaHits = 67 , numberOfStgcPhiHits = 68 , numberOfMmHits = 69 , numberOfStgcEtaHoles = 70 ,   numberOfStgcPhiHoles = 71 , numberOfMmHoles = 72 , numberOfCscUnspoiltEtaHits = 45 , numberOfGoodMdtHits = 66 ,   numberOfOutliersOnTrack = 15 , standardDeviationOfChi2OS = 30 , legacy_eProbabilityComb_res = 47 , legacy_eProbabilityHT_res = 48 ,   legacy_eProbabilityToT_res = 49 , legacy_eProbabilityBrem_res = 50 , legacy_pixeldEdx_res = 51 , legacy_eProbabilityNN_res = 73 ,   legacy_TRTTrackOccupancy_res = 74 , legacy_TRTdEdx_res = 75 , legacy_expectBLayerHit = 42 , legacy_expectInnermostPixelLayerHit = 52 ,   legacy_expectNextToInnermostPixelLayerHit = 57 , legacy_numberOfBLayerSharedHits = 16 , legacy_numberOfPixelSharedHits = 17 , legacy_numberOfSCTSharedHits = 18 ,   legacy_numberOfBLayerSplitHits = 43 , legacy_numberOfPixelSplitHits = 44 , legacy_numberOfInnermostPixelLayerSharedHits = 55 , legacy_numberOfInnermostLayerSplitHits = 56 ,   legacy_numberOfNextToInnermostPixelLayerSharedHits = 60 , legacy_numberOfNextToInnermostLayerSplitHits = 61 , legacy_numberOfTRTSharedHits = 62 , legacy_numberOfBLayerOutliers = 31 ,   legacy_numberOfInnermostPixelLayerOutliers = 54 , legacy_numberOfNextToInnermostPixelLayerOutliers = 59 , legacy_numberOfPixelOutliers = 41 , legacy_numberOfSCTOutliers = 39 ,   numberOfTrackSummaryTypes = 76 }
	enumerates the different types of information stored in Summary. More...
enum	eProbabilityType {   eProbabilityComb , eProbabilityHT , eProbabilityToT , eProbabilityBrem = 3 ,   eProbabilityNN = 4 , TRTTrackOccupancy = 5 , TRTdEdx = 6 , eProbabilityNumberOfTRTHitsUsedFordEdx ,   numberOfeProbabilityTypes = 8 }
enum	DetectorType {   pixelBarrel0 = 0 , pixelBarrel1 = 1 , pixelBarrel2 = 2 , pixelBarrel3 = 3 ,   pixelEndCap0 = 4 , pixelEndCap1 = 5 , pixelEndCap2 = 6 , sctBarrel0 = 7 ,   sctBarrel1 = 8 , sctBarrel2 = 9 , sctBarrel3 = 10 , sctEndCap0 = 11 ,   sctEndCap1 = 12 , sctEndCap2 = 13 , sctEndCap3 = 14 , sctEndCap4 = 15 ,   sctEndCap5 = 16 , sctEndCap6 = 17 , sctEndCap7 = 18 , sctEndCap8 = 19 ,   trtBarrel = 20 , trtEndCap = 21 , DBM0 = 22 , DBM1 = 23 ,   DBM2 = 24 , numberOfDetectorTypes = 25 }
	enumerates the various detector types currently accessible from the isHit() method. More...
enum	JetVtxParamDefs {   jet_xv =0 , jet_yv =1 , jet_zv =2 , jet_phi =3 ,   jet_theta =4 , jet_dist =5 }
enum	MaterialUpdateMode { addNoise = 1 , removeNoise = -1 }
	This is a steering enum to force the material update it can be: (1) addNoise (-1) removeNoise Second is mainly for vertex reconstruction, but potentially dangeraous. More...
enum	RQESolutionType {   none = 0 , one = 1 , two = 2 , none = 0 ,   one = 1 , two = 2 }
enum	ExtrapolationType {   FittedTrajectory , DeltaD0 , DeltaZ0 , DeltaPhi0 ,   DeltaTheta0 , DeltaQOverP0 , DeltaQOverP1 , ExtrapolationTypes }
enum	MeasurementType {   perigeeParameters , transverseVertex , vertex , pixelCluster ,   stripCluster , trapezoidCluster , driftCircle , pseudoMeasurement ,   barrelScatterer , endcapScatterer , calorimeterScatterer , barrelInert ,   endcapInert , energyDeposit , alignment , discontinuity ,   bremPoint , hole , materialDelimiter }
enum	ParameterType {   D0 , Z0 , Phi0 , Theta0 ,   QOverP0 , QOverP1 , ParameterTypes }
enum	RangeCheckDef { absoluteCheck = 0 , differentialCheck = 1 }
enum	DetectorRegion {   pixelBarrelFlat = 0 , pixelBarrelInclined = 1 , pixelEndcap = 2 , stripBarrel = 3 ,   stripEndcap = 4 }
enum class	BoundaryCheckResult {   Candidate , OnEdge , Insensitive , Outside ,   DeadElement , Error }
enum	TRT_ElectronPidProbability { Combined = 0 , HighThreshold = 1 , TimeOverThreshold = 2 , Bremsstrahlung = 3 }
enum class	VKConstraintType {   Mass , Phi , Theta , Point ,   Plane , Radius }
enum	{ NTrMaxVFit =200 }

Functions
void	decomposeTransform (const Amg::Transform3D &transform, double *values)
std::string	detTypeStr (AlignModule::DetectorType detType)
	returns the detector type
MsgStream &	operator<< (MsgStream &sl, const AlignModule &alignModule)
	overload of << operator for MsgStream for debug output
MsgStream &	operator<< (MsgStream &sl, const AlignPar &alignPar)
	overload of << operator for MsgStream for debug output
MsgStream &	operator<< (MsgStream &log, Trk::AlignMesType type)
MsgStream &	operator<< (MsgStream &log, Trk::AlignResidualType type)
ResidualPull::ResidualType	ResidualPullType (AlignResidualType type)
MsgStream &	operator<< (MsgStream &sl, const AlignTrack::AlignTrackType type)
std::ostream &	operator<< (std::ostream &sl, const AlignTrack::AlignTrackType type)
std::string	dumpAlignTrackType (const AlignTrack::AlignTrackType type)
MsgStream &	operator<< (MsgStream &sl, const AlignTSOS &atsos)
	Overload of << operator for MsgStream for debug output.
MsgStream &	operator<< (MsgStream &log, AlignResidualType type)
MsgStream &	operator<< (MsgStream &sl, AlignModuleTool &alignModTool)
MsgStream &	operator<< (MsgStream &sl, const BinUtility &bgen)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const BinUtility &bgen)
bool	operator< (const LayerIndex &one, const LayerIndex &two)
	Overload of operator< | <= | > | >= for the usage in a map.
bool	operator<= (const LayerIndex &one, const LayerIndex &two)
bool	operator> (const LayerIndex &one, const LayerIndex &two)
bool	operator>= (const LayerIndex &one, const LayerIndex &two)
MsgStream &	operator<< (MsgStream &sl, const LayerIndex &layx)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const LayerIndex &layx)
MsgStream &	operator<< (MsgStream &sl, const MemoryLogger &oac)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const MemoryLogger &oac)
MsgStream &	operator<< (MsgStream &sl, const ObjectAccessor &oac)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const ObjectAccessor &oac)
MsgStream &	operator<< (MsgStream &sl, const AssociatedMaterial &mstep)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const AssociatedMaterial &mstep)
MsgStream &	operator<< (MsgStream &sl, const ElementTable &etab)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const ElementTable &etab)
MsgStream &	operator<< (MsgStream &sl, GlueVolumesDescriptor &mprop)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, GlueVolumesDescriptor &mprop)
MsgStream &	operator<< (MsgStream &sl, const LayerMaterialProperties &mprop)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const LayerMaterialProperties &mprop)
MsgStream &	operator<< (MsgStream &sl, const MagneticFieldProperties &mprop)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const MagneticFieldProperties &mprop)
MsgStream &	operator<< (MsgStream &sl, const MaterialProperties &mprop)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const MaterialProperties &mprop)
MsgStream &	operator<< (MsgStream &sl, const MaterialStep &mstep)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const MaterialStep &mstep)
MsgStream &	operator<< (MsgStream &sl, const Surface &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Surface &sf)
MsgStream &	operator<< (MsgStream &sl, const SurfaceBounds &sb)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const SurfaceBounds &sb)
MsgStream &	operator<< (MsgStream &sl, const Volume &vol)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Volume &vol)
MsgStream &	operator<< (MsgStream &sl, const VolumeBounds &vb)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const VolumeBounds &vb)
MsgStream &	operator<< (MsgStream &sl, const Trk::LocalParameters &lp)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Trk::LocalParameters &lp)
MsgStream &	operator<< (MsgStream &sl, const CurvilinearUVT &uvt)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const CurvilinearUVT &uvt)
MsgStream &	operator<< (MsgStream &sl, const FitQualityImpl &fq)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const FitQualityImpl &fq)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const JacobianCurvilinearToLocal &jac)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const JacobianCurvilinearToLocal &jac)
MsgStream &	operator<< (MsgStream &sl, const LocalDirection &lomo)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const LocalDirection &lomo)
template<typename U>
bool	consistentSurfaces (U)
template<typename U, typename ... T>
bool	consistentSurfaces (U a, T...b)
MsgStream &	operator<< (MsgStream &sl, const TransportJacobian &jac)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const TransportJacobian &jac)
template<typename T>
std::unique_ptr< T >	unique_clone (const T *v)
template<typename T>
std::unique_ptr< T >	unique_clone (const std::unique_ptr< T > &v)
template<class OrigMap, class CmpT>
void	addToInverseMultiMap (InverseMultiMap< OrigMap, CmpT > *result, const OrigMap &rec2truth)
template<class OStream, class TruthCollection>
OStream &	operator<< (OStream &os, const BasicTruthCollectionFilter< TruthCollection > &f)
template<class OStream, class TruthCollection>
OStream &	operator<< (OStream &os, const PCutTruthCollectionFilter< TruthCollection > &f)
template<class OStream, class TruthCollection>
OStream &	operator<< (OStream &os, const StatTruthCollectionFilter< TruthCollection > &f)
MsgStream &	operator<< (MsgStream &sl, const EnergyLoss &eloss)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const EnergyLoss &eloss)
	Overload of << operator for std::ostream for debug outputstd::ostream&.
MsgStream &	operator<< (MsgStream &sl, const MaterialEffectsBase &meb)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const MaterialEffectsBase &meb)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const Trk::ScatteringAngles &saos)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Trk::ScatteringAngles &saos)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const Trk::MeasurementBase &mbase)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Trk::MeasurementBase &mbase)
	Overload of << operator for std::ostream for debug output.
template<int DIM, class T>
MsgStream &	operator<< (MsgStream &sl, const Trk::ParametersBase< DIM, T > &tp)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
template<int DIM, class T>
std::ostream &	operator<< (std::ostream &sl, const Trk::ParametersBase< DIM, T > &tp)
MsgStream &	operator<< (MsgStream &sl, const TrackParticleBase &trackParticleBase)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const TrackParticleBase &trackParticleBase)
	Overload of << operator for std::ostream for debug output.
std::ostream &	operator<< (std::ostream &, const NoiseOnSurface &)
MsgStream &	operator<< (MsgStream &, const NoiseOnSurface &)
std::ostream &	operator<< (std::ostream &, const PatternTrackParameters &)
MsgStream &	operator<< (MsgStream &, const PatternTrackParameters &)
MsgStream &	operator<< (MsgStream &stream, const PrepRawData &prd)
std::ostream &	operator<< (std::ostream &stream, const PrepRawData &prd)
template<typename T_res, typename T_src>
const T_res *	ErrorScalingCast (const T_src *src)
MsgStream &	operator<< (MsgStream &stream, const TrackRoad &tr)
	Dump the road into a message stream.
std::ostream &	operator<< (std::ostream &stream, const TrackRoad &tr)
	Dump the road into a standard output stream.
MsgStream &	operator<< (MsgStream &sl, const Trk::SpacePoint &spacePoint)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const SpacePoint &spacePoint)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const TrackStateOnSurface &tsos)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const TrackStateOnSurface &tsos)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const AlignmentEffectsOnTrack &tsos)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const AlignmentEffectsOnTrack &tsos)
	Overload of << operator for std::ostream for debug output.
	AmgSymMatrix (5) &GXFTrackState
MsgStream &	operator<< (MsgStream &, const MultiComponentStateOnSurface &)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &, const MultiComponentStateOnSurface &)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const Track &track)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Track &track)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &sl, const TrackInfo &track)
	Overload of << operator for MsgStream for debug output.
std::ostream &	operator<< (std::ostream &sl, const TrackInfo &track)
	Overload of << operator for std::ostream for debug output.
MsgStream &	operator<< (MsgStream &out, const MuonTrackSummary &trackSum)
	output.
std::ostream &	operator<< (std::ostream &out, const MuonTrackSummary &trackSum)
	output.
MsgStream &	operator<< (MsgStream &out, const TrackSummary &trackSum)
	output.
std::ostream &	operator<< (std::ostream &out, const TrackSummary &trackSum)
	output.
bool	operator< (const TrackTruthKey &a, const TrackTruthKey &b)
MsgStream &	operator<< (MsgStream &sl, const VertexPositions &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const VertexPositions &sf)
MsgStream &	operator<< (MsgStream &sl, const VxClusteringTable &sf)
std::ostream &	operator<< (std::ostream &sl, const VxClusteringTable &sf)
std::ostream &	operator<< (std::ostream &sl, const LinearizedTrack &sf)
const	AmgSymMatrix (3) &RecVertex
MsgStream &	operator<< (MsgStream &sl, const Vertex &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const Vertex &sf)
MsgStream &	operator<< (MsgStream &sl, const VxCandidate &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output; only needed in base class?
std::ostream &	operator<< (std::ostream &sl, const VxCandidate &sf)
MsgStream &	operator<< (MsgStream &sl, const VxTrackAtVertex &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output; only needed in base class?
std::ostream &	operator<< (std::ostream &sl, const VxTrackAtVertex &sf)
MsgStream &	operator<< (MsgStream &sl, const LinearizedTrack &sf)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
bool	operator< (const TrackTruthKey_p0 &a, const TrackTruthKey_p0 &b)
ATH_ALWAYS_INLINE void	propJacobian (double *ATH_RESTRICT P, const double *ATH_RESTRICT H0, const double *ATH_RESTRICT H1, const double *ATH_RESTRICT H2, const double *ATH_RESTRICT A, const double *ATH_RESTRICT A0, const double *ATH_RESTRICT A3, const double *ATH_RESTRICT A4, const double *ATH_RESTRICT A6, const double S3)
	This provides an inline helper function for updating the jacobian during Runge-Kutta propagation.
MsgStream &	operator<< (MsgStream &sl, const TrackSurfaceIntersection &tsfi)
	Overload of << operator for both, MsgStream and std::ostream for debug output.
std::ostream &	operator<< (std::ostream &sl, const TrackSurfaceIntersection &tsfi)
MsgStream &	operator<< (MsgStream &log, ExtrapolationType type)
MsgStream &	operator<< (MsgStream &log, MeasurementType type)
MsgStream &	operator<< (MsgStream &log, ParameterType type)
	AmgMatrix (3, 3) NeutralParticleParameterCalculator
int	makeCascade (VKalVrtControl &FitCONTROL, long int NTRK, const long int *ich, double *wm, double *inp_Trk5, double *inp_CovTrk5, const std::vector< std::vector< int > > &vertexDefinition, const std::vector< std::vector< int > > &cascadeDefinition, double definedCnstAccuracy)
int	setCascadeMassConstraint (CascadeEvent &cascadeEvent_, long int IV, double Mass)
int	setCascadeMassConstraint (CascadeEvent &cascadeEvent_, long int IV, std::vector< int > &trkInVrt, std::vector< int > &pseudoInVrt, double Mass)
int	fixPseudoTrackPt (long int NPar, double *fullMtx, double *LSide, CascadeEvent &cascadeEvent_)
VKTrack *	getCombinedVTrack (VKVertex *vk)
int	getCascadeNPar (CascadeEvent &cascadeEvent_, int Type)
void	setFittedParameters (const double *result, std::vector< int > &matrixPnt, CascadeEvent &cascadeEvent_)
void	setFittedMatrices (const double *COVFIT, long int MATRIXSIZE, std::vector< int > &matrixPnt, std::vector< std::vector< double > > &covarCascade, CascadeEvent &cascadeEvent_)
std::vector< double >	transformCovar (int NPar, double **Deriv, const std::vector< double > &covarI)
void	addCrossVertexDeriv (CascadeEvent &cascadeEvent_, double *ader, long int MATRIXSIZE, const std::vector< int > &matrixPnt)
void	copyFullMtx (const double *Input, long int IPar, long int IDIM, double *Target, long int TStart, long int TDIM)
void	getNewCov (const double *OldCov, const double *Der, double *Cov, long int DIM) noexcept
void	cferpr (const long int ich, double *par, double *ref, const double s0, double *errold, double *errnew)
void	cfimp (long int TrkID, long int ich, int IFL, double *par, const double *err, double *vrt, double *vcov, double *rimp, double *rcov, double *sign, VKalVrtControlBase *FitCONTROL)
void	cfimpc (long int TrkID, long int ich, int IFL, double *par, const double *err, double *vrt, double *vcov, double *rimp, double *rcov, double *sign, VKalVrtControlBase *FitCONTROL)
int	CFit (VKalVrtControl *FitCONTROL, int ifCovV0, int NTRK, long int *ich, double xyz0[3], double(*par0)[3], double(*inp_Trk5)[5], double(*inp_CovTrk5)[15], double xyzfit[3], double(*parfs)[3], double ptot[4], double covf[21], double &chi2, double *chi2tr)
int	setVTrackMass (VKVertex *vk)
long int	getVertexCharge (VKVertex *vk)
double	cascadeCnstRemnants (CascadeEvent &cascadeEvent_)
int	fitVertexCascade (VKVertex *vk, int Pointing)
int	processCascade (CascadeEvent &cascadeEvent_)
int	processCascadePV (CascadeEvent &cascadeEvent_, const double *primVrt, const double *primVrtCov)
int	processCascade (CascadeEvent &cascadeEvent_, const double *primVrt, const double *primVrtCov)
int	processCascade (CascadeEvent &cascadeEvent_, double *primVrt)
int	translateToFittedPos (CascadeEvent &cascadeEvent_, double Step)
int	restorePreviousPos (CascadeEvent &cascadeEvent_, std::vector< VKVertex > &SV)
void	getFittedCascade (CascadeEvent &cascadeEvent_, std::vector< Vect3DF > &cVertices, std::vector< std::vector< double > > &covVertices, std::vector< std::vector< VectMOM > > &fittedParticles, std::vector< std::vector< double > > &cascadeCovar, std::vector< double > &particleChi2, std::vector< double > &fullCovar)
void	rescaleVrtErrForPointing (double Div, CascadeEvent &cascadeEvent_)
int	fitVertexCascadeScale (VKVertex *vk, double &distToVertex)
int	processCascadeScale (CascadeEvent &cascadeEvent_)
void	cfmasserr (VKVertex *vk, const int *list, double *MASS, double *sigM)
void	vkPerigeeToP (const double *perig3, double *pp, double effectiveBMAG)
std::array< double, 4 >	getFitParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getFitParticleMom (const VKTrack *trk, double effectiveBMAG)
std::array< double, 4 >	getIniParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getIniParticleMom (const VKTrack *trk, double effectiveBMAG)
std::array< double, 4 >	getCnstParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getCnstParticleMom (const VKTrack *trk, double effectiveBMAG)
void	cfnewp (const long int ich, double *parold, double *ref, double *s, double *parnew, double *per)
void	cfnewpm (double *par, const double *xyzStart, double *xyzEnd, const double ustep, double *parn, double *closePoint, VKalVrtControlBase *CONTROL)
void	cfpest (int ntrk, double *xyz, long int *ich, double(*parst)[5], double(*parf)[3])
int	afterFit (VKVertex *vk, double *ader, double *dcv, double *ptot, double *VrtMomCov, const VKalVrtControlBase *CONTROL)
int	afterFitWithIniPar (VKVertex *vk, double *ader, double *dcv, double *ptot, double *VrtMomCov, const VKalVrtControlBase *CONTROL)
double	cfVrtDstSig (VKVertex *vk, bool UseTrkErr)
void	calcMassConstraint (VKMassConstraint *cnst)
void	calcPointConstraint (VKPointConstraint *cnst)
void	calcPhiConstraint (VKPhiConstraint *cnst)
void	calcThetaConstraint (VKThetaConstraint *cnst)
void	calcPlaneConstraint (VKPlaneConstraint *cnst)
void	calcRadiusConstraint (VKRadiusConstraint *cnst)
std::ostream &	operator<< (std::ostream &out, const VKConstraintBase &cnst)
std::ostream &	operator<< (std::ostream &out, const VKMassConstraint &cnst)
std::ostream &	operator<< (std::ostream &out, const VKPhiConstraint &cnst)
std::ostream &	operator<< (std::ostream &out, const VKThetaConstraint &cnst)
std::ostream &	operator<< (std::ostream &out, const VKPointConstraint &cnst)
std::ostream &	operator<< (std::ostream &out, const VKPlaneConstraint &cnst)
std::ostream &	operator<< (std::ostream &out, const VKRadiusConstraint &cnst)
void	FullMTXfill (VKVertex *vk, double *ader)
int	FullMCNSTfill (VKVertex *vk, double *ader, double *LSide)
double	cfSmallEigenvalue (double *cov, long int n)
int	cfInv5 (double *cov, double *wgt)
int	cfdinv (double *cov, double *wgt, long int NI)
void	dsinv (long int n, double *a, long int DIM, long int *ifail) noexcept
int	vkMSolve (double *a, double *b, long int n, double *ainv)
void	vkSVDCmp (double **a, int m, int n, double w[], double **v)
void	vkGetEigVal (const double ci[], double d[], int n)
void	vkGetEigVect (const double ci[], double d[], double vect[], int n)
void	robtest (VKVertex *vk, int ifl, int nIteration)
void	applyConstraints (VKVertex *vk)
std::ostream &	operator<< (std::ostream &out, const VKTrack &track)
double	cfchi2 (double *xyzt, const long int ich, double *part, const double *par0, double *wgt, double *rmnd)
double	cfchi2 (const double *vrtt, const double *part, VKTrack *trk)
double	finter (double y0, double y1, double y2, double x0, double x1, double x2)
void	tdasatVK (const double *Der, const double *CovI, double *CovF, long int M, long int N)
void	cfsetdiag (long int n, double *matr, double value) noexcept
void	abcCoef (double g1, double g2, double g3, double &a, double &b, double &c)
void	efdCoef (double Ga0, double Gamb, double Gab, double Gw0, double Gwb, double alf, double bet, double w, double &d, double &e, double &f)
void	ParaMin (double b, double c, double d, double e, double f, double &xmin, double &ymin)
void	cfTrkCovarCorr (double *cov)
void	vkgrkuta_ (const double charge, const double step, double *vect, double *vout, VKalVrtControlBase *CONTROL)
double	vkvFastV (double *p1, double *p2, const double *vRef, double dbmag, double *out)
int	vtcfit (VKVertex *vk)
int	vtcfitc (VKVertex *vk)
double	getCnstValues2 (VKVertex *vk) noexcept
int	getFullVrtCov (VKVertex *vk, double *ader, const double *dcv, double verr[6][6])
void	vpderiv (bool UseTrackErr, long int Charge, const double *pari0, double *covi, double *vrtref, double *covvrtref, double *drdpar, double *dwgt, double *rv0, VKalVrtControl *FitCONTROL)
void	xyztrp (const long int ich, double *vrt0, double *pv0, double *covi, double BMAG, double *paro, double *errt)
void	combinedTrack (long int ICH, double *pv0, double *covi, double BMAG, double *par, double *covo)
void	cfdcopy (double *source, double *target, int n)
double	cfddist3D (double *V1, double *V2)
double	d_sign (double value, double sign)
int	SymIndex (int it, int i, int j)

Variables
constexpr int	MAXNCHAMBERS =50
constexpr int	MAXNINDICES =50*6
template<typename T>
const auto	do_not_delete = [](T*) {}
constexpr size_t	NeutralParametersDim = 5
constexpr size_t	TrackParametersDim = 5

Detailed Description

Ensure that the ATLAS eigen extensions are properly loaded.

Author: V.Kostyukhin.

An abstract base class for algorithms estimating the transverse impact parameter d0 and its error of a given track wrt to the reconstructed vertex.

IPVTrackCompatibilityEstimator.h.

A namespace for all vertexing packages and related stuff.

A first concrete implementation of the IV0VertexFitter for the purposes of V0 fitting.

A track-truth match quality estimator tool.

Code that is common to several track-truth matching tools.

These headers, as well as other headers in the TrkGlobalChi2Fitter package use modern C++11 memory ownership semantics expressed through smart pointers.

Cache for the extrapolator to keep track of the total X0 traversed and the total extended energy loss (Eloss (error) ,Ionization (error), Radiation (error))

Special internal ptr caching.

Persistent representation of class VxVertex/VxTrackAtVertex.

Persistent representation of the VxVertex/Vertex class.

Persistent representation of the VxVertex/RecVertex class.

Persistent representation of the VxVertex/ExtendedVxCandidate class.

Persistent representation of class VxMultiVertex/MVFVxTrackAtVertex.

Persistent representation of class VxMultiVertex/MVFVxCandidate.

Persistent representation of the TrkV0Vertex/V0Hypothesis class.

Persistent representation of the TrkV0Vertex/V0Candidate class.

The standard namespace for VxVertexPositions.

< include headers from the base class

multimap to be used for TrackAmbiguity/Seed validation

A namespace to enclose the new Track class, and related tools.

A namespace to enclose the Tracking classes.

This typedef represents a multimap that holds the matching chi2 of two tracks from different track collections together with a boolean that indicatges if the matching was succesful.

Convenience Helper classes SurfacePtrHolder SurfaceUniqHolder also see SurfaceUniquePtrT.h.

standard namespace for Tracking

LayerIndexSampleMap.

Define statics for Geometry in Tracking.

ConstrainedTrackProvider.

Tool used to create a collection of AlignTracks from Tracks while the tracks are being refitted with a vertex/beam-spot constraint.

namespace for general tracking tools and interfaces

forward declarations

DATABASE INCLUDES.

Name : Neutrino.h Package : offline/PhysicsAnalysis/AnalysisCommon/ParticleEvent Author : Ketevi A.

An example algorithm that reads and writes objects from the event store using handles.

A tool to be used for track preselection in conversion vertex finding.

Forward declarations.

The InDetV0FinderTool reads in the TrackParticle container from StoreGate, if useorigin = True only tracks not associated to a primary vertex are used.

There are options to use silicon tracks only (default) or include Si+TRT and TRT+TRT.

Pairs of tracks passing pre-selection (using InDetTrackSelectorTool) are fitted to a common vertex using TrkV0Fitter or TrkVKalVrtFitter (useV0Fitter = False).

InDetV0FinderTool can take as input a vertex (or a collection of vertices) w.r.t which the V0s can be selected to minimise combinatorics.

• if such a vertex is provided, tracks are used if fabs(d0/sig_d0) > d0_cut (= 2.)
• if useVertexCollection = True all vertices in the collection are used
• if useVertexCollection = False
  • if trkSelPV = True either a primary vertex, if provided, or the beam spot are used
  • if trkSelPV = False (default) all track combinations are used.

The unconstrained vertex fit is attempted if the radius of the starting point is < maxsxy (= 1000 mm) and at least one invariant mass at the starting point is in the allowed range: uksmin < m(pipi) < uksmax or ulamin < m(ppi) < ulamax or ulamin < m(pip) < ulamax

V0s are kept if the cumulative chi2 probability of the unconstrained fit is > minVertProb (= 0.0001)

If doSimpleV0 = True all vertices that pass these cuts are stored in V0UnconstrVertices.

If doSimpleV0 = False (default) mass constrained fits are attempted if

• the invariant mass of the unconstrained V0 is in the allowed range: ksmin < m(pipi) < ksmax, lamin < m(ppi), m(pip) < lamax and the error on the invariant mass is < errmass (= 100 MeV)
• if an input vertex (collection) is provided the unconstrained V0 is required to have an impact parameter w.r.t the vertex < vert_a0xy_cut (= 3 mm) in xy and < vert_a0z_cut (= 15 mm) in z, the cosine of the angle between the V0 momentum and the direction from the input vertex to the V0 vertex is > 0, Lxy w.r.t the vertex is < vert_lxy_cut (= 500 mm) and Lxy/sigma(Lxy) > vert_lxy_sig (= 2)

Mass constrainedV0s are kept if the cumulative chi2 probability of the fit is > minVertProb (= 0.0001)

For successful mass constrained fits a conversion fit is also attempted and if successful, the corresponding unconstrained V0 is decorated with the invariant mass, its error and the vertex probability of the conversion fit.

The links between the unconstrained V0 and the successful mass constrained V0s are stored.

Thomas Koffas Thoma.nosp@m.s.Ko.nosp@m.ffas@.nosp@m.cern.nosp@m..ch June 2008

Assamagan Created : August 2004

DESCRIPTION: neutrino class for t -> bW -> b l nu construction the neutrino after solving the for the neutrino pz using the W mass constraint. There is a quadratic ambiguity leading to up to 2 solutions This class inherits from IParticle, I4Momentum and NavigableTerminalNode.

GEOMODEL INCLUDES CALORIMETER INCLUDES

The AlignTracks are filled into a collection of Tracks. The default control flow is like this: firstly do vertex constraint, if can't, then do beamspot again; if can't again, then do normal refit. if want to do vertex constraint only, set: doVertexConstraint = True and doBeamspotConstraint = False if want to do beamspot constraint only, set: doVertexConstraint = False and doBeamspotConstraint = True

Author

Jike Wang jwang.nosp@m.@cer.nosp@m.n.ch

Daniel Kollar danie.nosp@m.l.ko.nosp@m.llar@.nosp@m.cern.nosp@m..ch -> updated 2015 Matthias Danninger

Will provide a track coolection with momentum conatraint applied. A 2d histogram read and corrections (delta) are extracted as function of eta and phi. The momentum is scaled as corrected QoverP = original QoverP * (1.+ charge *pt *delta );

The strength of eth constraint can be varied as well.

instead of the CaloCell_ID (enum) a simple int is taken, so, implicit conversion is needed.

pos/neg endcap are distinguished by +/-

In the case of surfaces we do not want to take onwership when they are owned by the Tracking Geometry or a detector element.

In the other hand we want to take ownership if they are free.

As a result when we have classes with a m_associatedSurface member we need to repeat some boiler plate code.

These helpers try to make writing such code a bit easier and more uniform.

Under TrkDetDescr/TrkSurfaces :

The test : SurfaceHolder_test has a mock code on how we could use these for classes where we want to hold a ptr to a const Surface and manage it, based on if its free or owned.

The header : SurfaceHolder.h provides typedefs for most commom cases used by client code so as to hide some details of the implementation

Kirill Prokofiev Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

March 2007

Kirill Prokofiev Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

January 2006 Modified for the TP split version 2

Kirill Prokofiev Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

July 2006 January 2007 corrected for the new TP split schema

Kirill Prokofiev Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

July 2006

Kirill Prokofiev Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

July 2006 January 2006 Modified for the TP split version 2

During an extrapolation chain that we want to keep the parameters alive. We use a vector of unique_ptr. We can access the stored values as ptr during the extrapolation chains. By the end of the extrapolation chain they will go out of scope and get deleted. If we want to retain a ptr we need to take it before this happens

Author

Christos Anastopoulos

See GlobalChi2Fitter.h for more information.

Author

Andrei Gaponenko agapo.nosp@m.nenk.nosp@m.o@lbl.nosp@m..gov

Authors

: E. Bouhova-Thacker e.bou.nosp@m.hova.nosp@m.@cern.nosp@m..ch, R. Henderson Rob.H.nosp@m.ende.nosp@m.rson@.nosp@m.cern.nosp@m..ch

Date

: 14 December 2006

Abstract interface for tools estimating whether a given track originated from the primary vertex.

ruwie.nosp@m.del@.nosp@m.physi.nosp@m.k.un.nosp@m.i-bon.nosp@m.n.de Kiril.nosp@m.l.Pr.nosp@m.okofi.nosp@m.ev@c.nosp@m.ern.c.nosp@m.h

June 2009

---

Changes:

David Shope david.nosp@m..ric.nosp@m.hard..nosp@m.shop.nosp@m.e@cer.nosp@m.n.ch (2016-04-19)

EDM Migration to xAOD - Replace Trk::VxContainer with xAOD::VertexContainer

K.Prokofiev, C.Ruwiedel, June 2009.

Changes: G. Piacquadio, July 2009, add lifetime signs for b-tagging

David Shope david.nosp@m..ric.nosp@m.hard..nosp@m.shop.nosp@m.e@cer.nosp@m.n.ch (2016-04-19) EDM Migration to xAOD - Remove methods involving Trk::VxCandidate and Trk::RecVertex

Typedef Documentation

addrMagHandler

typedef void(* Trk::addrMagHandler) (double, double, double, double &, double &, double &)

Definition at line 23 of file VKalVrtBMag.h.

addrPropagator

typedef void(* Trk::addrPropagator) (long int, long int, double *, double *, double *, double *, double *, double *)

Definition at line 23 of file Propagator.h.

AlignModuleDerivatives

typedef std::pair<AlignModule*, std::vector<Amg::VectorX> > Trk::AlignModuleDerivatives

Definition at line 39 of file AlignTrack.h.

AlignModuleList

typedef std::vector<AlignModule*> Trk::AlignModuleList

Definition at line 37 of file AlignModuleList.h.

AlignModuleVertexDerivatives

typedef std::pair<const AlignModule*, std::vector<Amg::VectorX> > Trk::AlignModuleVertexDerivatives

Definition at line 37 of file AlignVertex.h.

AlignParList

typedef boost::multi_array<AlignPar*,2> Trk::AlignParList

Definition at line 12 of file AlignParList.h.

AlignParListDims

typedef boost::array<boost::multi_array_types::index, 2> Trk::AlignParListDims

Definition at line 13 of file AlignParList.h.

AlignTrackCollection

typedef std::vector<AlignTrack**> Trk::AlignTrackCollection

Definition at line 35 of file AlignVertex.h.

AlignTrackIt

typedef std::vector<AlignTrack**>::const_iterator Trk::AlignTrackIt

Definition at line 36 of file AlignVertex.h.

AlignTSOSCollection

typedef DataVector<AlignTSOS> Trk::AlignTSOSCollection

Definition at line 37 of file AlignTrack.h.

AlignTSOSIt

typedef DataVector<AlignTSOS>::const_iterator Trk::AlignTSOSIt

Definition at line 38 of file AlignTrack.h.

AmgMatrix3X

typedef Eigen::Matrix<double, 3, Eigen::Dynamic> Trk::AmgMatrix3X

Definition at line 49 of file KalmanVertexOnJetAxisUpdator.h.

ArraySpan

template<class T>

using Trk::ArraySpan = std::span<T>

Definition at line 59 of file TrackingVolume.h.

AtaCone

using Trk::AtaCone = ParametersT<TrackParametersDim, Charged, ConeSurface>

Definition at line 30 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

AtaCylinder

using Trk::AtaCylinder = ParametersT<TrackParametersDim, Charged, CylinderSurface>

Definition at line 31 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

AtaDisc

using Trk::AtaDisc = ParametersT<TrackParametersDim, Charged, DiscSurface>

Definition at line 32 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

AtaPlane

using Trk::AtaPlane = ParametersT<TrackParametersDim, Charged, PlaneSurface>

Definition at line 34 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

AtaStraightLine

using Trk::AtaStraightLine = ParametersT<TrackParametersDim, Charged, StraightLineSurface>

Definition at line 35 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

BaseParameters

using Trk::BaseParameters = ParametersCommon<TrackParametersDim, Charged>

Definition at line 25 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

BoundaryIntersection

template<class T>

using Trk::BoundaryIntersection

Initial value:

 
  FullIntersection<BoundarySurface<TrackingVolume>, Surface, T>

Definition at line 84 of file TrackingVolume.h.

CacheOwnedPtr

template<typename T>

using Trk::CacheOwnedPtr = T*

Definition at line 28 of file ExtrUniquePtrHolder.h.

ConeSurfacePtrHolder

using Trk::ConeSurfacePtrHolder = SurfacePtrHolderImpl<ConeSurface>

Definition at line 19 of file SurfaceHolders.h.

ConeSurfaceUniqHolder

using Trk::ConeSurfaceUniqHolder = SurfaceUniqHolderImpl<ConeSurface>

Definition at line 27 of file SurfaceHolders.h.

const_mapiterator

typedef datamap::const_iterator Trk::const_mapiterator

Definition at line 30 of file AlSymMatBase.h.

ConstSurfaceUniquePtr

typedef SurfaceUniquePtrT<const Trk::Surface> Trk::ConstSurfaceUniquePtr

Definition at line 468 of file Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h.

CurvilinearParameters

using Trk::CurvilinearParameters = CurvilinearParametersT<TrackParametersDim, Charged, PlaneSurface>

Definition at line 29 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

CylinderSurfacePtrHolder

using Trk::CylinderSurfacePtrHolder = SurfacePtrHolderImpl<CylinderSurface>

Definition at line 20 of file SurfaceHolders.h.

CylinderSurfaceUniqHolder

using Trk::CylinderSurfaceUniqHolder = SurfaceUniqHolderImpl<CylinderSurface>

Definition at line 28 of file SurfaceHolders.h.

datamap

typedef std::map<indices, double> Trk::datamap

Definition at line 28 of file AlSymMatBase.h.

DefinedParameter

typedef std::pair<double, ParamDefs> Trk::DefinedParameter

Typedef to of a std::pair<double, ParamDefs> to identify a passed-through double as a specific type of parameter.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 27 of file DefinedParameter.h.

DestSurf

typedef std::pair< const Surface *, BoundaryCheck > Trk::DestSurf = std::pair<const Surface*, BoundaryCheck>

typedef for input surfaces, boundary check

Definition at line 45 of file IPropagator.h.

DigitizationCell

typedef std::pair<size_t,size_t> Trk::DigitizationCell

Definition at line 18 of file DigitizationCell.h.

DiscSurfacePtrHolder

using Trk::DiscSurfacePtrHolder = SurfacePtrHolderImpl<DiscSurface>

Definition at line 21 of file SurfaceHolders.h.

DiscSurfaceUniqHolder

using Trk::DiscSurfaceUniqHolder = SurfaceUniqHolderImpl<DiscSurface>

Definition at line 29 of file SurfaceHolders.h.

DoubleAndWeight

typedef std::pair<double,double> Trk::DoubleAndWeight

Definition at line 18 of file SeedFinderParamDefs.h.

dvect

typedef std::vector<double> Trk::dvect

Definition at line 36 of file TrkVKalVrtFitter.h.

EightObjectsAccessor

using Trk::EightObjectsAccessor = std::array<ObjectAccessor::value_type, 8>

Definition at line 18 of file ObjectsAccessor.h.

ExCellCharged

typedef ExtrapolationCell< TrackParameters > Trk::ExCellCharged

Definition at line 24 of file IExtrapolationEngine.h.

ExCellNeutral

typedef ExtrapolationCell< NeutralParameters > Trk::ExCellNeutral

Definition at line 25 of file IExtrapolationEngine.h.

FitQualityOnSurface_p1

typedef FitQuality_p1 Trk::FitQualityOnSurface_p1

Definition at line 19 of file FitQualityOnSurface_p1.h.

FiveObjectsAccessor

using Trk::FiveObjectsAccessor = std::array<ObjectAccessor::value_type, 5>

Definition at line 16 of file ObjectsAccessor.h.

FourObjectsAccessor

using Trk::FourObjectsAccessor

Initial value:

 
  std::pair<std::array<ObjectAccessor::value_type, 4>, bool>

Definition at line 14 of file ObjectsAccessor.h.

GlueVolumeConstIterator

typedef std::map<BoundarySurfaceFace,std::vector<TrackingVolume*>>::const_iterator Trk::GlueVolumeConstIterator

Definition at line 30 of file GlueVolumesDescriptor.h.

GlueVolumeIterator

typedef std::map<BoundarySurfaceFace,std::vector<TrackingVolume*>>::iterator Trk::GlueVolumeIterator

Definition at line 27 of file GlueVolumesDescriptor.h.

IdentifiedMaterial

typedef std::pair<std::shared_ptr<Material>, int> Trk::IdentifiedMaterial

Definition at line 23 of file BinnedMaterial.h.

IdNavigationCell

typedef std::pair<int, const NavigationCell*> Trk::IdNavigationCell

Definition at line 54 of file INavigator.h.

indices

typedef std::pair<long int, long int> Trk::indices

Definition at line 27 of file AlSymMatBase.h.

LayerArray

typedef BinnedArray<Layer> Trk::LayerArray

simply for the eye

Definition at line 55 of file TrackingVolume.h.

LayerIndexSampleMap

typedef std::map<Trk::LayerIndex, int> Trk::LayerIndexSampleMap

Definition at line 29 of file LayerIndexSampleMap.h.

LayerIntersection

template<class T>

using Trk::LayerIntersection = FullIntersection<Layer, Surface, T>

Definition at line 82 of file TrackingVolume.h.

LayerMaterialCollection

typedef DataVector<Trk::LayerMaterialProperties> Trk::LayerMaterialCollection

Definition at line 19 of file LayerMaterialCollection.h.

mapiterator

typedef datamap::iterator Trk::mapiterator

Definition at line 29 of file AlSymMatBase.h.

MaterialComponent

using Trk::MaterialComponent = std::pair<Material, double>

Definition at line 31 of file VolumeConverter.h.

MaterialPropertiesMatrix

typedef std::vector< MaterialPropertiesVector > Trk::MaterialPropertiesMatrix

Definition at line 25 of file ILayerMaterialAnalyser.h.

MaterialPropertiesVector

typedef std::vector<const MaterialProperties*> Trk::MaterialPropertiesVector

Useful typedefs.

Definition at line 133 of file MaterialProperties.h.

MaterialStepCollection

typedef DataVector<Trk::MaterialStep> Trk::MaterialStepCollection

Definition at line 17 of file MaterialStepCollection.h.

MeasuredPerigee

using Trk::MeasuredPerigee = Perigee

Definition at line 23 of file MeasuredPerigeeCnv_p1.h.

MeasurementSet

using Trk::MeasurementSet = std::vector<const MeasurementBase*>

vector of fittable measurements

Definition at line 30 of file FitterTypes.h.

MultiComponentState

using Trk::MultiComponentState = std::vector<ComponentParameters>

Definition at line 27 of file ComponentParameters.h.

NavigationPair

typedef std::pair<const NavigationCell*,const NavigationCell*> Trk::NavigationPair

Definition at line 36 of file Navigator.h.

NeutralAtaCone

using Trk::NeutralAtaCone = ParametersT<NeutralParametersDim, Neutral, ConeSurface>

Definition at line 28 of file NeutralParameters.h.

NeutralAtaCylinder

using Trk::NeutralAtaCylinder = ParametersT<NeutralParametersDim, Neutral, CylinderSurface>

Definition at line 29 of file NeutralParameters.h.

NeutralAtaDisc

using Trk::NeutralAtaDisc = ParametersT<NeutralParametersDim, Neutral, DiscSurface>

Definition at line 30 of file NeutralParameters.h.

NeutralAtaPlane

using Trk::NeutralAtaPlane = ParametersT<NeutralParametersDim, Neutral, PlaneSurface>

Definition at line 32 of file NeutralParameters.h.

NeutralAtaStraightLine

using Trk::NeutralAtaStraightLine = ParametersT<NeutralParametersDim, Neutral, StraightLineSurface>

Definition at line 33 of file NeutralParameters.h.

NeutralCurvilinearParameters

using Trk::NeutralCurvilinearParameters = CurvilinearParametersT<NeutralParametersDim, Neutral, PlaneSurface>

Definition at line 27 of file NeutralParameters.h.

NeutralParameters

using Trk::NeutralParameters = ParametersBase<NeutralParametersDim, Neutral>

Definition at line 26 of file NeutralParameters.h.

NeutralPerigee

using Trk::NeutralPerigee = ParametersT<NeutralParametersDim, Neutral, PerigeeSurface>

Definition at line 31 of file NeutralParameters.h.

noinit_vector

template<class T>

using Trk::noinit_vector = std::vector<T, boost::noinit_adaptor<std::allocator<T> > >

A variant on std::vector which leaves its contents uninitialized by default.

Definition at line 50 of file TrkVKalUtils.h.

Perigee

using Trk::Perigee = ParametersT<TrackParametersDim, Charged, PerigeeSurface>

Definition at line 33 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

PerigeeSurface_p1

typedef Surface_p1 Trk::PerigeeSurface_p1

Definition at line 22 of file PerigeeSurfaceCnv_p1.h.

PerigeeSurfacePtrHolder

using Trk::PerigeeSurfacePtrHolder = SurfacePtrHolderImpl<PerigeeSurface>

Definition at line 22 of file SurfaceHolders.h.

PerigeeSurfaceUniqHolder

using Trk::PerigeeSurfaceUniqHolder = SurfaceUniqHolderImpl<PerigeeSurface>

Definition at line 30 of file SurfaceHolders.h.

PlaneSurfacePtrHolder

using Trk::PlaneSurfacePtrHolder = SurfacePtrHolderImpl<PlaneSurface>

Definition at line 23 of file SurfaceHolders.h.

PlaneSurfaceUniqHolder

using Trk::PlaneSurfaceUniqHolder = SurfaceUniqHolderImpl<PlaneSurface>

Definition at line 31 of file SurfaceHolders.h.

PositionAndWeight

typedef std::pair< Amg::Vector3D , double > Trk::PositionAndWeight

Definition at line 17 of file SeedFinderParamDefs.h.

PositionAtBoundary

typedef std::pair<Amg::Vector3D, const Trk::TrackingVolume*> Trk::PositionAtBoundary

Definition at line 28 of file MaterialValidation.h.

PrepRawDataSet

using Trk::PrepRawDataSet = std::vector<const PrepRawData*>

vector of clusters and drift circles

Definition at line 26 of file FitterTypes.h.

RIO_OnTrackSet

using Trk::RIO_OnTrackSet = std::vector<const RIO_OnTrack*>

vector of detector hits on a track

Definition at line 34 of file FitterTypes.h.

RIOtoROT_Multimap

typedef std::multimap<Trk::PrepRawData*, RIO_OnTrack*> Trk::RIOtoROT_Multimap

Definition at line 19 of file RIO_OnTrackMap.h.

RunOutlierRemoval

typedef bool Trk::RunOutlierRemoval

switch to toggle quality processing after fit

Definition at line 22 of file FitterTypes.h.

SegmentCollection

typedef DataVector< Trk::Segment > Trk::SegmentCollection

Definition at line 13 of file SegmentCollection.h.

SixObjectsAccessor

using Trk::SixObjectsAccessor = std::array<ObjectAccessor::value_type, 6>

Definition at line 17 of file ObjectsAccessor.h.

SpacePointSet

using Trk::SpacePointSet = std::vector<const SpacePoint*>

vector of space points

Definition at line 38 of file FitterTypes.h.

StraightLineSurfacePtrHolder

using Trk::StraightLineSurfacePtrHolder = SurfacePtrHolderImpl<StraightLineSurface>

Definition at line 24 of file SurfaceHolders.h.

StraightLineSurfaceUniqHolder

using Trk::StraightLineSurfaceUniqHolder

Initial value:

 
  SurfaceUniqHolderImpl<StraightLineSurface>

Definition at line 32 of file SurfaceHolders.h.

SurfaceArray

typedef BinnedArray<Surface> Trk::SurfaceArray

Definition at line 40 of file Layer.h.

SurfaceIntersection

typedef ObjectIntersection< Surface > Trk::SurfaceIntersection

Definition at line 39 of file Layer.h.

SurfaceOrderPosition

typedef std::pair< std::shared_ptr< Surface >, Amg::Vector3D > Trk::SurfaceOrderPosition

Definition at line 37 of file HGTD_LayerBuilderCond.h.

SurfacePtrHolder

using Trk::SurfacePtrHolder = SurfacePtrHolderImpl<Surface>

Definition at line 25 of file SurfaceHolders.h.

SurfacePtrHolderDetEl

using Trk::SurfacePtrHolderDetEl = Trk::SurfacePtrHolderImplDetEl<Surface>

Definition at line 36 of file SurfaceHolders.h.

SurfaceUniqHolder

using Trk::SurfaceUniqHolder = SurfaceUniqHolderImpl<Surface>

Definition at line 34 of file SurfaceHolders.h.

SurfaceUniquePtr

typedef SurfaceUniquePtrT<Trk::Surface> Trk::SurfaceUniquePtr

Definition at line 467 of file Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h.

SurfaceUniquePtrT

template<class S>

using Trk::SurfaceUniquePtrT = std::unique_ptr<S, SurfaceDeleter<S> >

Definition at line 32 of file SurfaceUniquePtrT.h.

ThreeObjectsAccessor

using Trk::ThreeObjectsAccessor = std::array<ObjectAccessor::value_type, 3>

Definition at line 13 of file ObjectsAccessor.h.

TrackingVolumeArray

typedef BinnedArray< TrackingVolume > Trk::TrackingVolumeArray = BinnedArray<TrackingVolume>

simply for the eye

Definition at line 27 of file ITrackingVolumeArrayCreator.h.

TrackingVolumeOrderPosition

using Trk::TrackingVolumeOrderPosition

Initial value:

 std::pair<std::shared_ptr<TrackingVolume>, 
                                              Amg::Vector3D>

Definition at line 34 of file MuonTrackingGeometryBuilderImpl.h.

TrackMatchMultiMap

typedef std::multimap<const Trk::Track*, std::pair<const Trk::Track*, Trk::TrackMatchingProperties> > Trk::TrackMatchMultiMap

Definition at line 25 of file TrackMatchingMultiMap.h.

TrackParameters

using Trk::TrackParameters = ParametersBase<TrackParametersDim, Charged>

Definition at line 27 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.

TrackParametersUVector

using Trk::TrackParametersUVector = std::vector<std::unique_ptr<Trk::TrackParameters>>

Definition at line 62 of file Extrapolator.h.

TrackParametersVector

typedef std::vector<const Trk::TrackParameters*> Trk::TrackParametersVector

Definition at line 55 of file TimedExtrapolator.h.

TrackParametersWithPath

typedef std::pair<const TrackParameters*, double> Trk::TrackParametersWithPath

typedef for return type TrackParameters, pathlength

Definition at line 42 of file IPropagator.h.

TrackParticleBaseCollection

typedef DataVector<TrackParticleBase> Trk::TrackParticleBaseCollection

Definition at line 14 of file TrackParticleBaseCollection.h.

TrackParticleOrigin

typedef VertexType Trk::TrackParticleOrigin

Definition at line 34 of file TrackParticleBase.h.

TrackRoadCollection

typedef DataVector<Trk::TrackRoad> Trk::TrackRoadCollection

Definition at line 14 of file TrackRoadCollection.h.

TrackScore

typedef float Trk::TrackScore

Definition at line 10 of file TrackScore.h.

TrackSeedMap

typedef std::multimap<const Trk::Track* , int> Trk::TrackSeedMap

Definition at line 14 of file TrackSeedMap.h.

TracksScores

typedef std::vector<std::pair<const Track*, float> > Trk::TracksScores

Definition at line 20 of file ITrackAmbiguityProcessorTool.h.

TrackStates

typedef DataVector< const Trk::TrackStateOnSurface > Trk::TrackStates = DataVector<const Trk::TrackStateOnSurface>

Definition at line 30 of file Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h.

TrackTruthCollection_p0

typedef TrackTruthVector Trk::TrackTruthCollection_p0

Definition at line 22 of file TrackTruthCollectionCnv_p0.h.

TrkParametersComparisonFunction

typedef ComparisonFunction<TrackParameters> Trk::TrkParametersComparisonFunction

Definition at line 26 of file TrkParametersComparisonFunction.h.

TwoPointOnTrack

typedef std::pair<PointOnTrack,PointOnTrack> Trk::TwoPointOnTrack

Definition at line 19 of file SeedFinderParamDefs.h.

TwoPoints

typedef std::pair<Amg::Vector3D,Amg::Vector3D> Trk::TwoPoints

Definition at line 20 of file SeedFinderParamDefs.h.

ValueMatrix

typedef std::vector<ValueVector> Trk::ValueMatrix

Definition at line 30 of file CompoundLayerMaterial.h.

ValueVector

typedef std::vector<unsigned char> Trk::ValueVector

Definition at line 29 of file CompoundLayerMaterial.h.

VertexID

typedef int Trk::VertexID

Definition at line 25 of file IVertexCascadeFitter.h.

VolumePartVec

using Trk::VolumePartVec = std::vector<VolumePart>

Definition at line 50 of file VolumeConverter.h.

VxSecVertexInfoContainer

typedef DataVector< Trk::VxSecVertexInfo > Trk::VxSecVertexInfoContainer

Definition at line 97 of file VxSecVertexInfo.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NTrMaxVFit

Definition at line 35 of file TrkVKalVrtFitter.h.

{ NTrMaxVFit=200 };

AlignMesType

enum Trk::AlignMesType

Enumerator
Measurement
Scatterer
EnergyDeposit

Definition at line 32 of file AlignResidualType.h.

                    {
    Measurement,
    Scatterer,
    EnergyDeposit
  };

AlignModuleListType

enum Trk::AlignModuleListType

Type of AlignModuleList (see description above).

Enumerator
L0
L1
L2
L3
L1_5
L2_5
ModulesOnTrack

Definition at line 32 of file AlignModuleList.h.

                           { L0=0,L1,L2,L3,
                 L1_5,L2_5,
                 ModulesOnTrack
  };

AlignResidualType

enum Trk::AlignResidualType

Enumerator
HitOnly
Unbiased

Definition at line 26 of file AlignResidualType.h.

                         {
    HitOnly,
    Unbiased
//    DCA
  };

BevelledCylinderAccessorType

enum Trk::BevelledCylinderAccessorType

Enumerator
BevelledCylinderZincrease	Cylinder hit, then pos. Z face
BevelledCylinderZdecrease	Cylinder hit, the neg. Z face
BevelledCylinderPositiveFace	Pos. Z face, Cylinder, neg. Z face
BevelledCylinderNegativeFace	Neg. Z face, Cylinder, pos. Z face

Definition at line 18 of file BevelledCylinderVolumeBoundaryAccessors.h.

                                      {
         BevelledCylinderZincrease    = 0,   
         BevelledCylinderZdecrease    = 1,   
         BevelledCylinderPositiveFace = 2,   
         BevelledCylinderNegativeFace = 3    
 
   };

BevelledTubeAccessorType

enum Trk::BevelledTubeAccessorType

Enumerator
BevelledTubeRincreaseZincrease	Accessor type [ 2,1,0,3 ].
BevelledTubeRincreaseZdecrease	Accessor type [ 2,0,1,3 ].
BevelledTubeZincreaseRincrease	Accessor type [ 1,2,0,3 ].
BevelledTubeZdecreaseRincrease	Accessor type [ 0,2,1,3 ].
BevelledTubeRdecreaseZincrease	Accessor type [ 3,1,0,2 ].
BevelledTubeRdecreaseZdecrease	Accessor type [ 3,0,1,2 ].
BevelledTubeZincreaseRdecrease	Accessor type [ 1,3,0,2 ].
BevelledTubeZdecreaseRdecrease	Accessor type [ 0,3,1,2 ].
BevelledTubeOutsideRminRdecrease	Accessor type [ 3,1,0,2] - inverse case.
BevelledTubeOutsideRmaxRincrease	Accessor type [ 2,1,0,3 ] - inverse case.
BevelledTubeOutsideZminZdecrease	Accessor type [ 0,3,2,1 ] - inverse case.
BevelledTubeOutsideZmaxZincrease	Accessor type [ 1,3,2,0 ] - inverse case.

Definition at line 27 of file BevelledCylinderVolumeBoundaryAccessors.h.

                                  {
 
           BevelledTubeRincreaseZincrease         = 0,   
           BevelledTubeRincreaseZdecrease         = 1,   
           BevelledTubeZincreaseRincrease         = 2,   
           BevelledTubeZdecreaseRincrease         = 3,   
           BevelledTubeRdecreaseZincrease         = 4,   
           BevelledTubeRdecreaseZdecrease         = 5,   
           BevelledTubeZincreaseRdecrease         = 6,   
           BevelledTubeZdecreaseRdecrease         = 7,    
           BevelledTubeOutsideRminRdecrease       = 8,   
           BevelledTubeOutsideRmaxRincrease       = 9,   
           BevelledTubeOutsideZminZdecrease       = 10,  
           BevelledTubeOutsideZmaxZincrease       = 11   
 
   };

BinningOption

enum Trk::BinningOption

enum BinValue

Enumerator
open
closed

Definition at line 38 of file BinningType.h.

{
  open,
  closed
};

BinningType

enum Trk::BinningType

, BinningOption & BinningAccess

• BinningType:

  Enumeration to qualify the binning type for the use of the LayerArrayCreator and the TrackingVolumeArrayCreator

  • BinningOption: open: [0,max] closed: 0 -> nextbin -> max
  • BinningAcces necessary access to global positions

  Author

  Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
equidistant
biequidistant
arbitrary

Definition at line 30 of file BinningType.h.

{
  equidistant,
  biequidistant,
  arbitrary
};

BinningValue

enum Trk::BinningValue

how to take the global / local position

Enumerator
binX
binY
binZ
binR
binPhi
binRPhi
binH
binEta

Definition at line 45 of file BinningType.h.

{
  binX,
  binY,
  binZ,
  binR,
  binPhi,
  binRPhi,
  binH,
  binEta
};

BoundaryCheckResult

enum class Trk::BoundaryCheckResult

strong

Enumerator
Candidate
OnEdge	within the sensitive area of an active element
Insensitive	close to the edge of an active element
Outside	with the insensitive area of an active element
DeadElement	outside the element
Error	within the nominally active area of a dead element error-state

Definition at line 14 of file IBoundaryCheckTool.h.

                                   {
        Candidate,      
        OnEdge,         
        Insensitive,    
        Outside,        
        DeadElement,    
        Error           
    };

BoundarySurfaceFace

enum Trk::BoundarySurfaceFace

Enum to describe the position of the BoundarySurface respectively to the frame orientatin of the volume, this is mainly ment for code readability.

The different numeration sequences can be found in the documentation of the actual VolumeBounds implementations.

The order of faces is chosen to follow - as much as possible - a cycular structure.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
negativeFaceXY
positiveFaceXY
negativeFaceYZ
positiveFaceYZ
negativeFaceZX
positiveFaceZX
cylinderCover
tubeInnerCover
tubeOuterCover
tubeSectorNegativePhi
tubeSectorPositivePhi
tubeSectorInnerCover
tubeSectorOuterCover
trapezoidFaceAlpha
trapezoidFaceBeta
index0
index1
index2
index3
index4
index5
index6
index7
index8
index9
index10
index11
undefinedFace

Definition at line 31 of file BoundarySurfaceFace.h.

                         {
  negativeFaceXY = 0,
  positiveFaceXY = 1,
  negativeFaceYZ = 2,
  positiveFaceYZ = 3,
  negativeFaceZX = 4,
  positiveFaceZX = 5,
  cylinderCover = 2,
  tubeInnerCover = 3,
  tubeOuterCover = 2,
  tubeSectorNegativePhi = 4,
  tubeSectorPositivePhi = 5,
  tubeSectorInnerCover = 3,
  tubeSectorOuterCover = 2,
  trapezoidFaceAlpha = 2,
  trapezoidFaceBeta = 3,
  index0 = 0,
  index1 = 1,
  index2 = 2,
  index3 = 3,
  index4 = 4,
  index5 = 5,
  index6 = 6,
  index7 = 7,
  index8 = 8,
  index9 = 9,
  index10 = 10,
  index11 = 11,
  undefinedFace = 99
 
};

CylinderAccessorType

enum Trk::CylinderAccessorType

Enumerator
CylinderZincrease	Cylinder hit, then pos. Z face
CylinderZdecrease	Cylinder hit, the neg. Z face
CylinderPositiveFace	Pos. Z face, Cylinder, neg. Z face
CylinderNegativeFace	Neg. Z face, Cylinder, pos. Z face

Definition at line 17 of file CylinderVolumeBoundaryAccessors.h.

                          {
  CylinderZincrease = 0,     
  CylinderZdecrease = 1,     
  CylinderPositiveFace = 2,  
  CylinderNegativeFace = 3   
 
};

DetectorElemType

enum class Trk::DetectorElemType

strong

Enumerator
SolidState
Silicon
TRT
Csc
Mdt
Rpc
Tgc
sTgc
MM

Definition at line 38 of file TrkDetElementBase.h.

{
  SolidState = 0,
  Silicon = 1,
  TRT = 2,
  Csc = 3,
  Mdt = 4,
  Rpc = 5,
  Tgc = 6,
  sTgc = 7,
  MM = 8
};

DetectorRegion

enum Trk::DetectorRegion

Enumerator
pixelBarrelFlat
pixelBarrelInclined
pixelEndcap
stripBarrel
stripEndcap

Definition at line 13 of file DetailedHitInfo.h.

                      {
    pixelBarrelFlat     = 0,
    pixelBarrelInclined = 1,
    pixelEndcap         = 2,
    stripBarrel         = 3,
    stripEndcap         = 4
  };

DetectorType

enum Trk::DetectorType

enumerates the various detector types currently accessible from the isHit() method.

Todo

work out how to add muons to this

Enumerator
pixelBarrel0	there are three or four pixel barrel layers (R1/R2)
pixelBarrel1
pixelBarrel2
pixelBarrel3
pixelEndCap0	three pixel discs (on each side)
pixelEndCap1
pixelEndCap2
sctBarrel0	four sct barrel layers
sctBarrel1
sctBarrel2
sctBarrel3
sctEndCap0	and 9 sct discs (on each side)
sctEndCap1
sctEndCap2
sctEndCap3
sctEndCap4
sctEndCap5
sctEndCap6
sctEndCap7
sctEndCap8
trtBarrel
trtEndCap
DBM0
DBM1
DBM2
numberOfDetectorTypes

Definition at line 230 of file Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h.

{
  pixelBarrel0 = 0, 
  pixelBarrel1 = 1,
  pixelBarrel2 = 2,
  pixelBarrel3 = 3,
 
  pixelEndCap0 = 4, 
  pixelEndCap1 = 5,
  pixelEndCap2 = 6,
 
  sctBarrel0 = 7, 
  sctBarrel1 = 8,
  sctBarrel2 = 9,
  sctBarrel3 = 10,
 
  sctEndCap0 = 11, 
  sctEndCap1 = 12,
  sctEndCap2 = 13,
  sctEndCap3 = 14,
  sctEndCap4 = 15,
  sctEndCap5 = 16,
  sctEndCap6 = 17,
  sctEndCap7 = 18,
  sctEndCap8 = 19,
 
  trtBarrel = 20,
  trtEndCap = 21,
 
  DBM0 = 22,
  DBM1 = 23,
  DBM2 = 24,
 
  numberOfDetectorTypes = 25
 
}; // not complete yet

DriftCircleSide

enum Trk::DriftCircleSide

Enumerates the 'side' of the wire on which the tracks passed (i.e.

resolves the amibiguity) (based on the TRT_Side enum, from InDet::TRT_DriftCircleOnTrack, which this should eventually replace)

Author

edwar.nosp@m.d.mo.nosp@m.yse@c.nosp@m.ern..nosp@m.ch

Enumerator
NONE	it was not possible to determine the which side of the straw the track passed;
LEFT	the drift radius is negative (see Trk::AtaStraightLine)
RIGHT	the drift radius is positive (see Trk::AtaStraightLine)

Definition at line 15 of file DriftCircleSide.h.

    {
          NONE, 
          LEFT, 
          RIGHT
    };

DriftCircleStatus

enum Trk::DriftCircleStatus

Enumerates the 'status' of the wire on which the tracks passed (based on the TRT_Side enum, from InDet::TRT_DriftCircleOnTrack, which this should eventually replace)

Author

edwar.nosp@m.d.mo.nosp@m.yse@c.nosp@m.ern..nosp@m.ch

Enumerator
DECIDED	sign of drift radius has been determined
UNDECIDED	sign of drift radius has not been determined
CORRUPT	the measurement is corrupt, but for some reason has been left on a track.
NODRIFTTIME	drift time was not used - drift radius is 0.

Definition at line 15 of file DriftCircleStatus.h.

    {
          DECIDED, 
          UNDECIDED, 
          CORRUPT,
          NODRIFTTIME
    };

eProbabilityType

enum Trk::eProbabilityType

Enumerator
eProbabilityComb	Electron probability from combining the below probabilities.
eProbabilityHT	Electron probability from High Threshold (HT) information.
eProbabilityToT	Electron probability from Time-Over-Threshold (ToT) information.
eProbabilityBrem	Electron probability from Brem fitting (DNA).
eProbabilityNN	Electron probability from NN.
TRTTrackOccupancy	TRT track occupancy.
TRTdEdx	dEdx from TRT ToT measurement.
eProbabilityNumberOfTRTHitsUsedFordEdx	Number of TRT hits used for dEdx measurement.
numberOfeProbabilityTypes

Definition at line 208 of file Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h.

{
  eProbabilityComb =
    0, 
  eProbabilityHT =
    1, 
  eProbabilityToT =
    2, 
  eProbabilityBrem = 3,  
  eProbabilityNN = 4,    
  TRTTrackOccupancy = 5, 
  TRTdEdx = 6,           
  eProbabilityNumberOfTRTHitsUsedFordEdx =
    7, 
  numberOfeProbabilityTypes = 8
};

ExtraLocalPosParam

enum Trk::ExtraLocalPosParam

Enumerator
distDepth

Definition at line 19 of file SiLocalPosition.h.

{distDepth = 2}; // These will be defined in Trk soon.

ExtrapolationType

enum Trk::ExtrapolationType

Enumerator
FittedTrajectory
DeltaD0
DeltaZ0
DeltaPhi0
DeltaTheta0
DeltaQOverP0
DeltaQOverP1
ExtrapolationTypes

Definition at line 18 of file ExtrapolationType.h.

                       {
  FittedTrajectory,
  DeltaD0,
  DeltaZ0,
  DeltaPhi0,
  DeltaTheta0,
  DeltaQOverP0,
  DeltaQOverP1,
  ExtrapolationTypes
};

GeometrySignature

enum Trk::GeometrySignature

Enumerator
Global
ID
BeamPipe
Calo
MS
Cavern
HGTD
NumberOfSignatures
Unsigned

Definition at line 23 of file GeometrySignature.h.

{
  Global = 0,
  ID = 1,
  BeamPipe = 2,
  Calo = 3,
  MS = 4,
  Cavern = 5,
  HGTD =  6,
  NumberOfSignatures =  7,
  Unsigned = 99
};

GeometryType

enum Trk::GeometryType

Enumerator
Static
Dense
DenseWithLayers
Detached
Master
NumberOfGeometryTypes

Definition at line 36 of file GeometrySignature.h.

{
  Static = 0,
  Dense = 1,
  DenseWithLayers = 1,
  Detached = 2,
  Master = 3,
  NumberOfGeometryTypes = 3
};

JetVtxParamDefs

enum Trk::JetVtxParamDefs

Author

Nicol.nosp@m.a.Gi.nosp@m.acint.nosp@m.o.Pi.nosp@m.acqua.nosp@m.dio@.nosp@m.cern..nosp@m.ch

Chris.nosp@m.tian.nosp@m..Weis.nosp@m.er@c.nosp@m.ern.c.nosp@m.h

Enumerator
jet_xv
jet_yv
jet_zv	position x,y,z of primary vertex
jet_phi
jet_theta
jet_dist

Definition at line 25 of file JetVtxParamDefs.h.

                               {
   // Enums for vertex position on the jet axis starting from the primary vertex
     jet_xv=0, jet_yv=1, jet_zv=2,                     
     jet_phi=3,jet_theta=4,                        //direction of the jet axis (flight direction of B hadron),
     jet_dist=5                                //distance of vertex on jet axis from primary vertex
   };

LayerOrder

enum Trk::LayerOrder

This enum is used to declare Layers as previous/next in respect of a 1-dimensional binned array.

Enumerator
previous
next

Definition at line 30 of file BinningData.h.

{
  previous = -1,
  next = 1
};

LayerType

enum Trk::LayerType

For readability.

Enumerator
passive
active

Definition at line 47 of file Layer.h.

{ passive = 0, active = 1 };

MagneticFieldMode

enum Trk::MagneticFieldMode

MagneticFieldMode describing the field setup within a volume.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
NoField	Field is set to 0., 0., 0.,.
ConstantField	Field is set to be constant.
FastField	call the fast field access method of the FieldSvc
FullField	Field is set to be realistic, but within a given Volume.

Definition at line 17 of file MagneticFieldMode.h.

                       {
  NoField = 0,        
  ConstantField = 1,  
  FastField = 2,      
  FullField = 3  
};

MaterialAssociationType

enum Trk::MaterialAssociationType

Enumerator
EffectiveNumSteps
EffectiveNumAtoms
RadiationLength
StepLength

Definition at line 12 of file MaterialAssociationType.h.

{
  EffectiveNumSteps = 0, // cout the number of steps per layer
  EffectiveNumAtoms = 1, // compute the effective number of atoms
  RadiationLength = 2,   // weight by radiation length
  StepLength = 4
};

MaterialConcentration

enum Trk::MaterialConcentration

Simple enum to identify when a material update on a non-structured layer should be done, options are alongPre and oppositePre.

Enumerator
alongPre
split
oppositePre

Definition at line 38 of file LayerMaterialProperties.h.

{ alongPre = 1, split = 0, oppositePre = -1 };

MaterialUpdateMode

enum Trk::MaterialUpdateMode

This is a steering enum to force the material update it can be: (1) addNoise (-1) removeNoise Second is mainly for vertex reconstruction, but potentially dangeraous.

Enumerator
addNoise
removeNoise

Definition at line 17 of file MaterialUpdateMode.h.

{
  addNoise = 1,
  removeNoise = -1
};

MaterialUpdateStage

enum Trk::MaterialUpdateStage

This is a steering enum to tell which material update stage:

• preUpdate : when reaching a layer before layer is resolved
• fullUpdate : just pass through the layer
• postUpdate : when leaving the layer

Enumerator
preUpdate
fullUpdate
postUpdate

Definition at line 39 of file PropDirection.h.

     {
     
         preUpdate   = -1,
         fullUpdate  =  0,
         postUpdate  =  1
     };                            

MeasurementType

enum Trk::MeasurementType

Enumerator
perigeeParameters
transverseVertex
vertex
pixelCluster
stripCluster
trapezoidCluster
driftCircle
pseudoMeasurement
barrelScatterer
endcapScatterer
calorimeterScatterer
barrelInert
endcapInert
energyDeposit
alignment
discontinuity
bremPoint
hole
materialDelimiter

Definition at line 18 of file MeasurementType.h.

                     {
  perigeeParameters,
  transverseVertex,
  vertex,
  pixelCluster,
  stripCluster,
  trapezoidCluster,
  driftCircle,
  pseudoMeasurement,
  barrelScatterer,
  endcapScatterer,
  calorimeterScatterer,
  barrelInert,
  endcapInert,
  energyDeposit,
  alignment,
  discontinuity,
  bremPoint,
  hole,
  materialDelimiter
};

NavigationLevel

enum Trk::NavigationLevel

destinguishes an association TrackingGeometry with one for global search

Enumerator
noNavigation
globalSearch
association

Definition at line 41 of file TrackingGeometry.h.

{
  noNavigation = 0,
  globalSearch = 1,
  association = 2
};

ParamDefs

enum Trk::ParamDefs

This file defines the parameter enums in the Trk namespace.

Usage examples:

• Access the y-coordinate of the cartesian local frame:
  LocalPosition locpos(2.3, 4.5);
  double x = locpos[Trk::locX];
• Access the eta-value of a track state on a surface (Tsos):
  double theEta = Tsos[Trk::eta]
• Access the eta-value of a track state on a surface (Tsos):
  double theEta = Tsos[Trk::eta]

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
loc1
loc2	generic first and second local coordinate
locX
locY	local cartesian
locRPhi
locPhiR
locZ	local cylindrical
locR
locPhi	local polar
iPhi
iEta	(old readout) will be skipped
distPhi
distEta	readout for silicon
driftRadius	trt, straws
x
y
z	global position (cartesian)
px
py
pz	global momentum (cartesian)
d0
z0
phi0
theta
qOverP	perigee
phi
u	Enums for curvilinear frames.
v
trkMass	Extended perigee: mass.

Definition at line 32 of file ParamDefs.h.

               {
  // Enums for LocalParameters - LocalPosition/
  loc1 = 0,
  loc2 = 1, 
 
  locX = 0,
  locY = 1, 
 
  locRPhi = 0,
  locPhiR = 0,
  locZ = 1, 
 
  locR = 0,
  locPhi = 1, 
 
  iPhi = 0,
  iEta = 1, 
 
  distPhi = 0,
  distEta = 1,     
 
  driftRadius = 0, 
                   // Enums for const Amg::Vector3D & GlobalMomentum /
  x = 0,
  y = 1,
  z = 2, 
 
  px = 0,
  py = 1,
  pz = 2, 
          // Enums for PerigParamDefsee //
  d0 = 0,
  z0 = 1,
  phi0 = 2,
  theta = 3,
  qOverP = 4, 
              /* Enums for TrackState on Surfaces
               The first two enums in the TrackParameters refer to the local Frame, i.e.
                - LocalCartesian for AtanArbitraryPlane
                - LocalCylindrical for AtaCylinder (includes line)
                - LocalPolar for AtaDisc
                The other three enums are standard \f$(\phi, \eta, \frac{q}{p_{T}})\f$
               */
  phi = 2,
  u = 0,
  v = 1,

  trkMass = 5
}; 

ParametersType

enum Trk::ParametersType

Enum to avoid dynamic cast for different parameter types.

Enumerator
AtaSurface
Curvilinear
Pattern

Definition at line 29 of file ParametersCommon.h.

{ AtaSurface = 0, Curvilinear = 1, Pattern = 2 };

ParameterType

enum Trk::ParameterType

Enumerator
D0
Z0
Phi0
Theta0
QOverP0
QOverP1
ParameterTypes

Definition at line 18 of file ParameterType.h.

{ D0, Z0, Phi0, Theta0, QOverP0, QOverP1, ParameterTypes };

ParticleHypothesis

enum Trk::ParticleHypothesis

Enumeration for Particle hypothesis respecting the interaction with material.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
nonInteracting
geantino
electron
muon
pion
kaon
proton
photon
neutron
pi0
k0
nonInteractingMuon
noHypothesis
undefined

Definition at line 28 of file ParticleHypothesis.h.

                           { nonInteracting  = 0,
                             geantino        = 0,
                             electron        = 1,
                             muon            = 2,                            
                             pion            = 3,                             
                             kaon            = 4,
                             proton          = 5,
                             photon          = 6,  // for Fatras usage
                             neutron         = 7,  // for Fatras usage 
                             pi0             = 8, // for Fatras usage 
                             k0              = 9, // for Fatras usage 
                             nonInteractingMuon = 10, // For material collection
                             noHypothesis    = 99,
                             undefined       = 99};

PrepRawDataType

enum class Trk::PrepRawDataType

strong

Enumerator
SiCluster
PixelCluster
SCT_Cluster
TRT_DriftCircle
HGTD_Cluster
PlanarCluster
MdtPrepData
CscStripPrepData
CscPrepData
MMPrepData
RpcPrepData
TgcPrepData
sTgcPrepData

Definition at line 38 of file PrepRawData.h.

{
  SiCluster,
  PixelCluster,
  SCT_Cluster,
  TRT_DriftCircle,
  HGTD_Cluster,
  PlanarCluster,
  MdtPrepData,
  CscStripPrepData,
  CscPrepData,
  MMPrepData,
  RpcPrepData,
  TgcPrepData,
  sTgcPrepData
};

PropDirection

enum Trk::PropDirection

PropDirection, enum for direction of the propagation.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Enumerator
alongMomentum
oppositeMomentum
anyDirection
mappingMode

Definition at line 19 of file PropDirection.h.

                          {
                    alongMomentum    = 1,
                    oppositeMomentum =-1,
                    anyDirection     = 0,
                    mappingMode      = 2
                 };

RangeCheckDef

enum Trk::RangeCheckDef

Enumerator
absoluteCheck
differentialCheck

Definition at line 55 of file KalmanUpdatorSMatrix.h.

{
  absoluteCheck = 0,
  differentialCheck = 1
};

RQESolutionType [1/2]

enum Trk::RQESolutionType

Enumerator
none
one
two
none
one
two

Definition at line 19 of file TrkDetDescr/TrkSurfaces/TrkSurfaces/RealQuadraticEquation.h.

{
  none = 0,
  one = 1,
  two = 2
};

RQESolutionType [2/2]

enum Trk::RQESolutionType

Enumerator
none
one
two
none
one
two

Definition at line 19 of file TrkExtrapolation/TrkExUtils/TrkExUtils/RealQuadraticEquation.h.

{
  none = 0,
  one = 1,
  two = 2
};

SearchDirection

enum Trk::SearchDirection

Enumerator
outside
inside
bothway
undefinedDirection

Definition at line 29 of file PropDirection.h.

                          { outside=1, inside=-1,
                            bothway=0, undefinedDirection=0 };

SectoralBevelledCylinderAccessorType

enum Trk::SectoralBevelledCylinderAccessorType

Todo

implement correcly when needed

Enumerator
StandardSectoralBevelledCylinder

Definition at line 47 of file BevelledCylinderVolumeBoundaryAccessors.h.

                                               {
          StandardSectoralBevelledCylinder = 0
      };

SectoralBevelledTubeAccessorType

enum Trk::SectoralBevelledTubeAccessorType

Enumerator
StandardSectoralBevelledTube

Definition at line 54 of file BevelledCylinderVolumeBoundaryAccessors.h.

                                           {
          StandardSectoralBevelledTube = 0
      };

SectoralCylinderAccessorType

enum Trk::SectoralCylinderAccessorType

Todo

implement correcly when needed

Enumerator
StandardSectoralCylinder

Definition at line 46 of file CylinderVolumeBoundaryAccessors.h.

{ StandardSectoralCylinder = 0 };

SectoralTubeAccessorType

enum Trk::SectoralTubeAccessorType

Todo

implement correcly when needed

Todo

implement correcly when needed

Enumerator
StandardSectoralTube

Definition at line 51 of file CylinderVolumeBoundaryAccessors.h.

{ StandardSectoralTube = 0 };

SummaryType

enum Trk::SummaryType

enumerates the different types of information stored in Summary.

Use in get(const SummaryType type), for for example, summary.get(numOfPixelHits) When adding a new transient information type, please make sure to increase numberOfTrackSummaryTypes.

Enumerator
numberOfContribPixelLayers	number of contributing layers of the pixel detector these are the hits in the first pixel layer, i.e. b-layer
numberOfBLayerHits	these are the hits in the 0th pixel layer?
numberOfInnermostPixelLayerHits	these are the hits in the 1st pixel layer
numberOfNextToInnermostPixelLayerHits	these are the pixel hits, including the b-layer
numberOfPixelHits	number of pixel layers on track with absence of hits
numberOfPixelHoles	number of pixels which have a ganged ambiguity.
numberOfGangedPixels	number of Ganged Pixels flagged as fakes
numberOfGangedFlaggedFakes	number of dead pixel sensors crossed
numberOfPixelDeadSensors	number of pixel hits with broad errors (width/sqrt(12))
numberOfPixelSpoiltHits	number of DBM Hits
numberOfDBMHits	number of hits in SCT
numberOfSCTHits	number of SCT holes
numberOfSCTHoles	number of Holes in both sides of a SCT module
numberOfSCTDoubleHoles
numberOfSCTDeadSensors	number of TRT hits
numberOfSCTSpoiltHits
numberOfTRTHits	number of TRT outliers
numberOfTRTOutliers	number of TRT holes
numberOfTRTHoles	number of TRT hits which pass the high threshold (only xenon counted) total number of TRT hits which pass the high threshold
numberOfTRTHighThresholdHits	total number of TRT hits which pass the high threshold
numberOfTRTHighThresholdHitsTotal	number of TRT hits used for dE/dx computation
numberOfTRTHitsUsedFordEdx	number of TRT high threshold outliers (only xenon counted)
numberOfTRTHighThresholdOutliers	number of dead TRT straws crossed
numberOfTRTDeadStraws	number of TRT tube hits
numberOfTRTTubeHits	number of TRT hits on track in straws with xenon
numberOfTRTXenonHits
numberOfMdtHits	number of mdt hits tgc, rpc and csc measure both phi and eta coordinate
numberOfTgcPhiHits
numberOfTgcEtaHits
numberOfCscPhiHits
numberOfCscEtaHits
numberOfRpcPhiHits
numberOfRpcEtaHits
numberOfCscEtaHoles	number of CSC Eta measurements missing from the track
numberOfCscPhiHoles	number of CSC Phi measurements missing from the track
numberOfRpcEtaHoles	number of RPC Eta measurements missing from the track
numberOfRpcPhiHoles	number of RPC Phi measurements missing from the track
numberOfMdtHoles	number of MDT measurements missing from the track
numberOfTgcEtaHoles	number of TGC Eta measurements missing from the track
numberOfTgcPhiHoles	number of TGC Phi measurements missing from the track
numberOfStgcEtaHits	number of TGC Eta measurements missing from the track
numberOfStgcPhiHits	number of TGC Phi measurements missing from the track
numberOfMmHits	number of TGC Eta measurements missing from the track
numberOfStgcEtaHoles	number of TGC Eta measurements missing from the track
numberOfStgcPhiHoles	number of TGC Phi measurements missing from the track
numberOfMmHoles	number of TGC Eta measurements missing from the track
numberOfCscUnspoiltEtaHits	number of unspoilt CSC eta measurements (all CSC phi measurements are by definition spoilt). See Muon::CscClusterStatus for definitions of 'spoiled' hits.
numberOfGoodMdtHits	number of non-deweighted MDT hits. Only here as a placeholder, will be filled only on xAOD::Muon number of measurements flaged as outliers in TSOS
numberOfOutliersOnTrack	100 times the standard deviation of the chi2 from the surfaces
standardDeviationOfChi2OS
legacy_eProbabilityComb_res
legacy_eProbabilityHT_res
legacy_eProbabilityToT_res
legacy_eProbabilityBrem_res
legacy_pixeldEdx_res
legacy_eProbabilityNN_res
legacy_TRTTrackOccupancy_res
legacy_TRTdEdx_res
legacy_expectBLayerHit
legacy_expectInnermostPixelLayerHit
legacy_expectNextToInnermostPixelLayerHit
legacy_numberOfBLayerSharedHits
legacy_numberOfPixelSharedHits
legacy_numberOfSCTSharedHits
legacy_numberOfBLayerSplitHits
legacy_numberOfPixelSplitHits
legacy_numberOfInnermostPixelLayerSharedHits
legacy_numberOfInnermostLayerSplitHits
legacy_numberOfNextToInnermostPixelLayerSharedHits
legacy_numberOfNextToInnermostLayerSplitHits
legacy_numberOfTRTSharedHits
legacy_numberOfBLayerOutliers
legacy_numberOfInnermostPixelLayerOutliers
legacy_numberOfNextToInnermostPixelLayerOutliers
legacy_numberOfPixelOutliers
legacy_numberOfSCTOutliers
numberOfTrackSummaryTypes

Definition at line 44 of file Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h.

{
  // --- Inner Detector
 
  numberOfContribPixelLayers = 29,
  numberOfBLayerHits = 0,
  numberOfInnermostPixelLayerHits = 53,
  numberOfNextToInnermostPixelLayerHits = 58,
  numberOfPixelHits = 2,
  numberOfPixelHoles = 1,
  numberOfGangedPixels = 14,
  numberOfGangedFlaggedFakes = 32,
  numberOfPixelDeadSensors = 33,
  numberOfPixelSpoiltHits = 35,
  numberOfDBMHits = 63,
  numberOfSCTHits = 3,
  numberOfSCTHoles = 4,
  numberOfSCTDoubleHoles = 28,
  numberOfSCTDeadSensors = 34,
  numberOfSCTSpoiltHits = 36,
  numberOfTRTHits = 5,
  numberOfTRTOutliers = 19,
  numberOfTRTHoles = 40,
  numberOfTRTHighThresholdHits = 6,
  numberOfTRTHighThresholdHitsTotal = 64,
  numberOfTRTHitsUsedFordEdx = 65,
  numberOfTRTHighThresholdOutliers = 20,
  numberOfTRTDeadStraws = 37,
  numberOfTRTTubeHits = 38,
  numberOfTRTXenonHits = 46,
 
  // --- Muon Spectrometer
  numberOfMdtHits = 7,
  numberOfTgcPhiHits = 8,
  numberOfTgcEtaHits = 9,
  numberOfCscPhiHits = 10,
  numberOfCscEtaHits = 11,
  numberOfRpcPhiHits = 12,
  numberOfRpcEtaHits = 13,
  numberOfCscEtaHoles = 21,
  numberOfCscPhiHoles = 22,
  numberOfRpcEtaHoles = 23,
  numberOfRpcPhiHoles = 24,
  numberOfMdtHoles = 25,
  numberOfTgcEtaHoles = 26,
  numberOfTgcPhiHoles = 27,
 
  // New Small Wheel
  numberOfStgcEtaHits = 67,
  numberOfStgcPhiHits = 68,
  numberOfMmHits = 69,
  numberOfStgcEtaHoles = 70,
  numberOfStgcPhiHoles = 71,
  numberOfMmHoles = 72,
  numberOfCscUnspoiltEtaHits = 45,
  // --- all
  numberOfGoodMdtHits = 66,
  numberOfOutliersOnTrack = 15,
  standardDeviationOfChi2OS = 30,
 
  // reserved: added to keep synchronisation with xAOD::TrackSummary in
  // anticipation of the two being merged
  // in the past used to store  pixel and TRT PID information:
  legacy_eProbabilityComb_res = 47,
  legacy_eProbabilityHT_res = 48,
  legacy_eProbabilityToT_res = 49,
  legacy_eProbabilityBrem_res = 50,
  legacy_pixeldEdx_res = 51,
  legacy_eProbabilityNN_res = 73,
  legacy_TRTTrackOccupancy_res = 74,
  legacy_TRTdEdx_res = 75,
 
  // in the past used to store expected inner layer hits
  legacy_expectBLayerHit = 42,
  legacy_expectInnermostPixelLayerHit = 52,
  legacy_expectNextToInnermostPixelLayerHit = 57,
 
  // in the past used to store shared hits
  legacy_numberOfBLayerSharedHits = 16,
  legacy_numberOfPixelSharedHits = 17,
  legacy_numberOfSCTSharedHits = 18,
  legacy_numberOfBLayerSplitHits = 43,
  legacy_numberOfPixelSplitHits = 44,
  legacy_numberOfInnermostPixelLayerSharedHits = 55,
  legacy_numberOfInnermostLayerSplitHits = 56,
  legacy_numberOfNextToInnermostPixelLayerSharedHits = 60,
  legacy_numberOfNextToInnermostLayerSplitHits = 61,
  legacy_numberOfTRTSharedHits = 62,
 
  // in the past used to store pixel and SCT outliers
  legacy_numberOfBLayerOutliers = 31,
  legacy_numberOfInnermostPixelLayerOutliers = 54,
  legacy_numberOfNextToInnermostPixelLayerOutliers = 59,
  legacy_numberOfPixelOutliers = 41,
  legacy_numberOfSCTOutliers = 39,
 
  // -- numbers...
  numberOfTrackSummaryTypes = 76
};

SurfaceOwner

enum Trk::SurfaceOwner

Enumerator
noOwn
TGOwn
DetElOwn
userOwn

Definition at line 56 of file Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h.

                  {
  noOwn = 0,     // Surface is free can be deleted at will.
  TGOwn = 1,     // Surface is owned by the Geometry and will be deleted by it.
  DetElOwn = 2,  // Surface is associated with a detector element. So can not be
                 // deleted as long this is active.
  userOwn = 3  // Surface is owned by the user. e.g could be "static"
};

SurfaceType

enum class Trk::SurfaceType

strong

This enumerator simplifies the persistency & calculations,.

Enumerator
Cone
Cylinder
Disc
Perigee
Plane
Line
Curvilinear
Other

Definition at line 16 of file SurfaceTypes.h.

{
  Cone = 0,
  Cylinder = 1,
  Disc = 2,
  Perigee = 3,
  Plane = 4,
  Line = 5,
  Curvilinear = 6,
  Other = 7
};

TRT_ElectronPidProbability

enum Trk::TRT_ElectronPidProbability

Enumerator
Combined
HighThreshold
TimeOverThreshold
Bremsstrahlung

Definition at line 30 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{
  Combined = 0,
  HighThreshold = 1,
  TimeOverThreshold = 2,
  Bremsstrahlung = 3
};

TubeAccessorType

enum Trk::TubeAccessorType

Enumerator
TubeRincreaseZincrease	Accessor type [ 2,1,0,3 ].
TubeRincreaseZdecrease	Accessor type [ 2,0,1,3 ].
TubeZincreaseRincrease	Accessor type [ 1,2,0,3 ].
TubeZdecreaseRincrease	Accessor type [ 0,2,1,3 ].
TubeRdecreaseZincrease	Accessor type [ 3,1,0,2 ].
TubeRdecreaseZdecrease	Accessor type [ 3,0,1,2 ].
TubeZincreaseRdecrease	Accessor type [ 1,3,0,2 ].
TubeZdecreaseRdecrease	Accessor type [ 0,3,1,2 ].
TubeOutsideRminRdecrease	Accessor type [ 3,1,0,2] - inverse case.
TubeOutsideRmaxRincrease	Accessor type [ 2,1,0,3 ] - inverse case.
TubeOutsideZminZdecrease	Accessor type [ 0,3,2,1 ] - inverse case.
TubeOutsideZmaxZincrease	Accessor type [ 1,3,2,0 ] - inverse case.

Definition at line 26 of file CylinderVolumeBoundaryAccessors.h.

                      {
 
  TubeRincreaseZincrease = 0,     
  TubeRincreaseZdecrease = 1,     
  TubeZincreaseRincrease = 2,     
  TubeZdecreaseRincrease = 3,     
  TubeRdecreaseZincrease = 4,     
  TubeRdecreaseZdecrease = 5,     
  TubeZincreaseRdecrease = 6,     
  TubeZdecreaseRdecrease = 7,     
  TubeOutsideRminRdecrease = 8,   
  TubeOutsideRmaxRincrease = 9,   
  TubeOutsideZminZdecrease = 10,  
  TubeOutsideZmaxZincrease = 11   
 
};

VertexType

enum Trk::VertexType

This file defines the enums in the Trk namespace for the different vertex types.

The VxCandidate and the TrackParticleBase class store such an enum to signal which vertex it is or from which vertex it comes from (in the case of the TrackParticleBase object).

Author

Andre.nosp@m.as.W.nosp@m.ildau.nosp@m.er@c.nosp@m.ern.c.nosp@m.h

Enumerator
NoVtx	Dummy vertex, TrackParticle was not used in vertex fit.
PriVtx	Primary Vertex.
SecVtx	Secondary Vertex.
PileUp	Pile Up Vertex.
ConvVtx	Converstion Vertex.
V0Vtx	Vertex from V0 Decay.
KinkVtx	Kink Vertex.
V0Lambda	Temporary addition for V0 Lambda.
V0LambdaBar	Temporary addition for V0 LambdaBar.
V0KShort	Temporary addition for KShort.
NotSpecified	this is the default

Definition at line 24 of file VertexType.h.

{
  NoVtx = 0,         
  PriVtx = 1,        
  SecVtx = 2,        
  PileUp = 3,        
  ConvVtx = 4,       
  V0Vtx = 5,         
  KinkVtx = 6,       
  V0Lambda = 7,      
  V0LambdaBar = 8,   
  V0KShort = 9,      
  NotSpecified = -99 
};

VKConstraintType

enum class Trk::VKConstraintType

strong

Enumerator
Mass
Phi
Theta
Point
Plane
Radius

Definition at line 25 of file Derivt.h.

{ Mass, Phi, Theta, Point, Plane, Radius };

Function Documentation

abcCoef()

void Trk::abcCoef	(	double	g1,
		double	g2,
		double	g3,
		double &	a,
		double &	b,
		double &	c )

Definition at line 260 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
   a=g1;
   c=2.*(g3-g1) - 4.*(g2-g1);
   b=(g3-g1) - c;
}

addCrossVertexDeriv()

void Trk::addCrossVertexDeriv	(	CascadeEvent &	cascadeEvent_,
		double *	ader,
		long int	MATRIXSIZE,
		const std::vector< int > &	matrixPnt )

Definition at line 207 of file CascadeUtils.cxx.

{
   int iv,ivn;
   //for( iv=0; iv<cascadeEvent_.cascadeNV; iv++)std::cout<<matrixPnt[iv]<<", ";std::cout<<'\n';
 
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     VKVertex *vk = cascadeEvent_.cascadeVertexList[iv].get();
     if(!vk->nextCascadeVrt)continue;                        //no pointing
     for( ivn=iv; ivn<cascadeEvent_.cascadeNV; ivn++){
        if(vk->nextCascadeVrt == cascadeEvent_.cascadeVertexList[ivn].get()) break;    //vertex found
     }
     if( ivn == cascadeEvent_.cascadeNV ) continue;  // no found vertex
//
// Now we have vertex pair "from"(iv) "to"(ivn)
     int From=matrixPnt[iv];    // start of "from" information
     int Next=matrixPnt[iv+1];  // start of "next vertex" information. Pnt.constraints are 2 prevous param.!!!
     int Into=matrixPnt[ivn];   // start of "to" information
//
//  The same constraints, but derivatives are with respect to other ("to") vertex
     ader[(0+Into)   + (Next-1)*MATRIXSIZE] = - ader[(0+From)   + (Next-1)*MATRIXSIZE];
     ader[(1+Into)   + (Next-1)*MATRIXSIZE] = - ader[(1+From)   + (Next-1)*MATRIXSIZE];
     ader[(2+Into)   + (Next-1)*MATRIXSIZE] = - ader[(2+From)   + (Next-1)*MATRIXSIZE];
     ader[(0+Into)   + (Next-2)*MATRIXSIZE] = - ader[(0+From)   + (Next-2)*MATRIXSIZE];
     ader[(1+Into)   + (Next-2)*MATRIXSIZE] = - ader[(1+From)   + (Next-2)*MATRIXSIZE];
     ader[(2+Into)   + (Next-2)*MATRIXSIZE] = - ader[(2+From)   + (Next-2)*MATRIXSIZE];
     ader[(0+Into)*MATRIXSIZE   + (Next-1)] = - ader[(0+From)   + (Next-1)*MATRIXSIZE];
     ader[(1+Into)*MATRIXSIZE   + (Next-1)] = - ader[(1+From)   + (Next-1)*MATRIXSIZE];
     ader[(2+Into)*MATRIXSIZE   + (Next-1)] = - ader[(2+From)   + (Next-1)*MATRIXSIZE];
     ader[(0+Into)*MATRIXSIZE   + (Next-2)] = - ader[(0+From)   + (Next-2)*MATRIXSIZE];
     ader[(1+Into)*MATRIXSIZE   + (Next-2)] = - ader[(1+From)   + (Next-2)*MATRIXSIZE];
     ader[(2+Into)*MATRIXSIZE   + (Next-2)] = - ader[(2+From)   + (Next-2)*MATRIXSIZE];
   }
}

addToInverseMultiMap()

template<class OrigMap, class CmpT>

void Trk::addToInverseMultiMap	(	InverseMultiMap< OrigMap, CmpT > *	result,
		const OrigMap &	rec2truth )

Definition at line 50 of file InverseMultiMap.h.

                                                    {
  for (const auto& p : rec2truth) {
    result->insert(std::make_pair(p.second, p.first));
  }
}

afterFit()

int Trk::afterFit	(	VKVertex *	vk,
		double *	ader,
		double *	dcv,
		double *	ptot,
		double *	VrtMomCov,
		const VKalVrtControlBase *	CONTROL )

Definition at line 26 of file cfTotCov.cxx.

{
    int i,j;
    double px,py,pz,pt,invR,cth;
    double verr[6][6]={{0.}};   //for (i=0; i<6*6; i++) verr[i]=0;
 
    int NTRK = vk->TrackList.size();
    int NVar = NTRK*3+3;
    for (i=1; i<=6; ++i) {
    for (j=1; j<=NVar  ; ++j) dcv[i + j*6 - 7] = 0.;
    }
    cfsetdiag( 6, VrtMomCov, 100.);
    ptot[0] = 0.;
    ptot[1] = 0.;
    ptot[2] = 0.;
 
    double vBx,vBy,vBz,constBF;
    Trk::vkalMagFld::getMagFld(vk->refIterV[0],vk->refIterV[1],vk->refIterV[2],vBx,vBy,vBz,CONTROL);
 
    for (i = 1; i <= NTRK; ++i) {
        VKTrack *trk=vk->TrackList[i-1].get();
        invR = trk->fitP[2];
    cth = 1. / tan(trk->fitP[0]);
    constBF=Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->fitP[1], trk->fitP[0]) * Trk::vkalMagFld::getCnvCst();
    pt = std::abs( constBF / invR);
    px = pt * cos(trk->fitP[1]);
    py = pt * sin(trk->fitP[1]);
    pz = pt * cth;
    ptot[0] += px;
    ptot[1] += py;
    ptot[2] += pz;
    dcv[ (i*3 + 0)*6 + 5] = -pt * (cth * cth + 1);     /* dPz/d(theta) */
    dcv[ (i*3 + 1)*6 + 3] = -py;                       /* dPx/d(phi) */
    dcv[ (i*3 + 1)*6 + 4] =  px;                       /* dPy/d(phi) */
    dcv[ (i*3 + 2)*6 + 3] = -px / invR;         /* dPx/d(rho) */
    dcv[ (i*3 + 2)*6 + 4] = -py / invR;             /* dPy/d(rho) */
    dcv[ (i*3 + 2)*6 + 5] = -pz / invR;                 /* dPz/d(rho) */
    }
    dcv[0]  = 1.;
    dcv[7]  = 1.;
    dcv[14] = 1.;
    if(!ader)return 0;
    int IERR=getFullVrtCov(vk, ader, dcv, verr);     if (IERR) return IERR;
    int ijk = 0;
    for ( i=0; i<6; ++i) {
    for (j=0; j<=i; ++j) {
        VrtMomCov[ijk++] = verr[i][j];
    }
    }
    return 0;
}

afterFitWithIniPar()

int Trk::afterFitWithIniPar	(	VKVertex *	vk,
		double *	ader,
		double *	dcv,
		double *	ptot,
		double *	VrtMomCov,
		const VKalVrtControlBase *	CONTROL )

Definition at line 83 of file cfTotCov.cxx.

{
    int i,j;
    double px,py,pz,pt,invR,cth;
    double verr[6][6]={{0.}};
 
 
    int NTRK = vk->TrackList.size();
    int NVar = NTRK*3+3;
    for (i=1; i<=6; ++i) {
    for (j=1; j<=NVar  ; ++j)  dcv[i + j*6 - 7] = 0.;
    }
    cfsetdiag( 6, VrtMomCov, 10.);
    ptot[0] = 0.;
    ptot[1] = 0.;
    ptot[2] = 0.;
 
    double vBx,vBy,vBz,constBF;
    Trk::vkalMagFld::getMagFld(vk->refIterV[0],vk->refIterV[1],vk->refIterV[2],vBx,vBy,vBz,CONTROL);
 
    for (i = 1; i <= NTRK; ++i) {
        VKTrack *trk=vk->TrackList[i-1].get();
        invR = trk->iniP[2];
    cth = 1. / tan(trk->iniP[0]);
        constBF=Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->fitP[1], trk->fitP[0]) * Trk::vkalMagFld::getCnvCst();
    pt = std::abs( constBF/invR );
    px = pt * cos(trk->iniP[1]);
    py = pt * sin(trk->iniP[1]);
    pz = pt * cth;
    ptot[0] += px;
    ptot[1] += py;
    ptot[2] += pz;
    dcv[ (i*3 + 0)*6 + 5] = -pt * (cth * cth + 1);     /* dPz/d(theta) */
    dcv[ (i*3 + 1)*6 + 3] = -py;                       /* dPx/d(phi) */
    dcv[ (i*3 + 1)*6 + 4] =  px;                       /* dPy/d(phi) */
    dcv[ (i*3 + 2)*6 + 3] = -px / invR;         /* dPx/d(rho) */
    dcv[ (i*3 + 2)*6 + 4] = -py / invR;             /* dPy/d(rho) */
    dcv[ (i*3 + 2)*6 + 5] = -pz / invR;                 /* dPz/d(rho) */
    }
    dcv[0]  = 1.;
    dcv[7]  = 1.;
    dcv[14] = 1.;
    if(!ader)return 0;
    int IERR=getFullVrtCov(vk, ader, dcv, verr);     if (IERR) return IERR;
    int ijk = 0;
    for ( i=0; i<6; ++i) {
    for (j=0; j<=i; ++j) {
        VrtMomCov[ijk++] = verr[i][j];
    }
    }
    return 0;
}

AmgMatrix()

Trk::AmgMatrix	(	3	,
		3	)

Definition at line 231 of file NeutralParticleParameterCalculator.cxx.

                                              {
    AmgMatrix(3,3) transform; transform.setZero();
    transform(0,0)=-1./fabs(qOverP)*sin(theta)*sin(phi);
    transform(0,1)=1./fabs(qOverP)*sin(theta)*cos(phi);
    transform(0,2)=0.;
    transform(1,0)=1./fabs(qOverP)*cos(theta)*cos(phi);
    transform(1,1)=1./fabs(qOverP)*cos(theta)*sin(phi);
    transform(1,2)=-1./fabs(qOverP)*sin(theta);
    transform(2,0)=-1./qOverP/fabs(qOverP)*sin(theta)*cos(phi);
    transform(2,1)=-1./qOverP/fabs(qOverP)*sin(theta)*sin(phi);
    transform(2,2)=-1./qOverP/fabs(qOverP)*cos(theta);
    return transform.transpose().eval();
  }

AmgSymMatrix() [1/2]

const Trk::AmgSymMatrix

(

3

)

&

Definition at line 67 of file RecVertex.cxx.

  {return m_positionCovariance; }
  
  void RecVertex::scaleError(float factor) {
    //scale covariance matrix in *weight* representation
    m_positionCovariance *= 1./factor;
  }

AmgSymMatrix() [2/2]

const Trk::AmgSymMatrix ( 5 ) &

inline

Definition at line 156 of file GXFTrackState.h.

                                                              {
    return m_covariancematrix;
  }

applyConstraints()

void Trk::applyConstraints

(

VKVertex *

vk

)

Definition at line 22 of file stCnst.cxx.

                                    {
  int NCEntries = vk->ConstraintList.size();
  int NTRK = vk->TrackList.size();
  for (int ic = 0; ic < NCEntries; ic++) {
    vk->ConstraintList[ic]->applyConstraint();
  }
  //
  // Effect of symmetrization
  //
  for (int ii = 0; ii < (int)vk->ConstraintList.size(); ii++) {
    for (int ic = 0; ic < (int)vk->ConstraintList[ii]->NCDim; ic++) {
      vk->ConstraintList[ii]->h0t[ic].X *= 0.5;
      vk->ConstraintList[ii]->h0t[ic].Y *= 0.5;
      vk->ConstraintList[ii]->h0t[ic].Z *= 0.5;
      for (int it = 0; it < NTRK; it++) {
        vk->ConstraintList[ii]->f0t.at(it)[ic].X *= 0.5;
        vk->ConstraintList[ii]->f0t[it][ic].Y *= 0.5;
        vk->ConstraintList[ii]->f0t[it][ic].Z *= 0.5;
      }
    }
  }
}

calcMassConstraint()

void Trk::calcMassConstraint

(

VKMassConstraint *

cnst

)

Definition at line 24 of file Derclc1.cxx.

{
    int it,itc;
    double ptot[4]={0.,0.,0.,0.};
    double cth, invR, pp2, pt;
    VKConstraintBase * base_cnst = static_cast<VKConstraintBase*> (cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    const std::vector<int> &usedParticles=cnst->getUsedParticles();
    int usedNTRK = usedParticles.size();
    VKTrack * trk;
    noinit_vector< std::array<double, 4> > pp(usedNTRK);
    for( itc=0; itc<usedNTRK; itc++){
      it = usedParticles[itc];
      trk = vk->TrackList.at(it).get();
      pp[itc]=getCnstParticleMom( trk , vk);
      ptot[0] += pp[itc][0];
      ptot[1] += pp[itc][1];
      ptot[2] += pp[itc][2];
      ptot[3] += pp[itc][3];
   }
 
   double temp = 1.e-10;
   int ip=0; if( std::abs(ptot[1]) > std::abs(ptot[ip]) )ip=1; if( std::abs(ptot[2]) > std::abs(ptot[ip]) )ip=2;
   int im=0; if( std::abs(ptot[1]) < std::abs(ptot[im]) )im=1; if( std::abs(ptot[2]) < std::abs(ptot[im]) )im=2;
   int id=4; for(int i=0;i<3;i++) if(i!=ip && i!=im)id=i;
   if(id==4){
     std::cout<<"ERROR in mass constraint!!!"<<'\n';
     temp=ptot[3]*ptot[3]-ptot[0]*ptot[0]-ptot[1]*ptot[1]-ptot[2]*ptot[2];
   } else {
     temp = sqrt( (ptot[3]-ptot[ip])*(ptot[3]+ptot[ip]) );
     temp = sqrt( (  temp -ptot[id])*(  temp +ptot[id]) );
     temp =       (  temp -ptot[im])*(  temp +ptot[im]);
   }
   if(temp<1.e-10)temp=1.e-10;  //protection
   temp=sqrt(temp);             //system mass
//
//
    int numCNST=0;   //constraint number. Single constraint in this case
//
//Difference
   base_cnst->aa[numCNST] = ( temp - cnst->getTargetMass() ) * ( temp + cnst->getTargetMass() );
//
//Derivatives               Here pp[][3] - particle energy, pp[][4] - squared particle mom
    for( itc=0; itc<usedNTRK; itc++){
      it = usedParticles[itc];
      trk  = vk->TrackList.at(it).get();
      invR = trk->cnstP[2];
      cth  = 1. / tan( trk->cnstP[0] );
      pt   = sqrt(pp[itc][0]*pp[itc][0] + pp[itc][1]*pp[itc][1]);
      pp2  =      pp[itc][0]*pp[itc][0] + pp[itc][1]*pp[itc][1] + pp[itc][2]*pp[itc][2];
      base_cnst->f0t[it][numCNST].X =  ptot[3] * (-pp2* cth / pp[itc][3])
                         - ptot[2] * (-pt   * (cth*cth + 1.));
      base_cnst->f0t[it][numCNST].Y = -ptot[0] * (-pp[itc][1])
                         - ptot[1] *   pp[itc][0];
      base_cnst->f0t[it][numCNST].Z =  ptot[3] * (-pp2/ (invR * pp[itc][3]))
                                 - ptot[0] * (-pp[itc][0] / invR)
                         - ptot[1] * (-pp[itc][1] / invR)
                         - ptot[2] * (-pp[itc][2] / invR);
 
    }
    base_cnst->h0t[numCNST].X = 0.;
    base_cnst->h0t[numCNST].Y = 0.;
    base_cnst->h0t[numCNST].Z = 0.;
/* -- Relative normalisation. Now it is target mass (squared?) to make performance uniform */
    double Scale=0.025/(2.*cnst->getTargetMass()+1.); //28.03.2011 wrong idea for cascade. VK 06.05.2011 actually correct!
    //Scale=0.01;
    for (it = 0; it < (int)vk->TrackList.size(); ++it) {
    base_cnst->f0t[it][numCNST].X *=  Scale * 2;
    base_cnst->f0t[it][numCNST].Y *=  Scale * 2;
    base_cnst->f0t[it][numCNST].Z *=  Scale * 2;
    }
    base_cnst->aa[numCNST] *= Scale;
//std::cout.precision(11);
//std::cout<<" mass="<<temp<<", "<<cnst->getTargetMass()<<", "<<base_cnst->aa[numCNST]<<'\n';
//std::cout<<base_cnst->f0t[0][numCNST].X<<", "<<base_cnst->f0t[0][numCNST].Y<<", "
//         <<base_cnst->f0t[0][numCNST].Z<<'\n';
//std::cout<<base_cnst->f0t[1][numCNST].X<<", "<<base_cnst->f0t[1][numCNST].Y<<", "
//         <<base_cnst->f0t[1][numCNST].Z<<'\n';
}

calcPhiConstraint()

void Trk::calcPhiConstraint

(

VKPhiConstraint *

cnst

)

Definition at line 22 of file DerclcAng.cxx.

{
    VKConstraintBase * base_cnst = static_cast<VKConstraintBase*>( cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    int NTRK = vk->TrackList.size();
    int i,j;
    double Scale=1.;   // Scaling for better precision VK 28.03.2011 Wrong for error matrix!!! Should always be 1.!!!
 
    double diff=0., aa=0;
    std::vector<double> deriv(NTRK,0);
    for(i=0; i<NTRK-1; i++){
       for(j=i+1; j<NTRK; j++){
          diff  = vk->TrackList[i]->cnstP[1] - vk->TrackList[j]->cnstP[1];
          while(diff >  M_PI) diff -= 2.*M_PI;
          while(diff < -M_PI) diff += 2.*M_PI;
          aa       += diff*Scale;
      deriv[i] +=      Scale;
      deriv[j] -=      Scale;
       }
    }
 
    int numCNST=0;   //constraint number. Single constraint in this case
    base_cnst->h0t[numCNST].X = 0.;
    base_cnst->h0t[numCNST].Y = 0.;
    base_cnst->h0t[numCNST].Z = 0.;
    for(i=0; i<NTRK; i++){
       base_cnst->f0t[i][numCNST].X = 0.;
       base_cnst->f0t[i][numCNST].Y = deriv[i];
       base_cnst->f0t[i][numCNST].Z = 0.;
    }
    base_cnst->aa[numCNST]=aa;
//std::cout.precision(11);
//std::cout<<" new delta Phi="<<base_cnst->aa[numCNST]<<'\n';
//std::cout<<base_cnst->f0t[0][numCNST].X<<", "<<base_cnst->f0t[0][numCNST].Y<<", "
//         <<base_cnst->f0t[0][numCNST].Z<<'\n';
//std::cout<<base_cnst->f0t[1][numCNST].X<<", "<<base_cnst->f0t[1][numCNST].Y<<", "
//         <<base_cnst->f0t[1][numCNST].Z<<'\n';
}

calcPlaneConstraint()

void Trk::calcPlaneConstraint

(

VKPlaneConstraint *

cnst

)

Definition at line 99 of file DerclcAng.cxx.

{
    VKConstraintBase * base_cnst = static_cast<VKConstraintBase*>( cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    int NTRK = vk->TrackList.size();
    double curV[3] = {vk->refIterV[0]+vk->cnstV[0], vk->refIterV[1]+vk->cnstV[1],vk->refIterV[2]+vk->cnstV[2]};
 
 
    int numCNST=0;   //constraint number. Single constraint in this case
    base_cnst->h0t[numCNST].X = cnst->getA();
    base_cnst->h0t[numCNST].Y = cnst->getB();
    base_cnst->h0t[numCNST].Z = cnst->getC();
    for(int i=0; i<NTRK; i++){
       base_cnst->f0t[i][numCNST].X = 0.;
       base_cnst->f0t[i][numCNST].Y = 0.;
       base_cnst->f0t[i][numCNST].Z = 0.;
    }
    base_cnst->aa[numCNST]=cnst->getA()*curV[0]+cnst->getB()*curV[1]+cnst->getC()*curV[2] - cnst->getD() ;
//std::cout<<" new plane="<<base_cnst->aa[numCNST]<<'\n';
//std::cout<<(*cnst)<<'\n';
}

calcPointConstraint()

void Trk::calcPointConstraint

(

VKPointConstraint *

cnst

)

Definition at line 20 of file Derclc2.cxx.

{
    VKConstraintBase * base_cnst = static_cast<VKConstraintBase*>( cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    //  Magnetic field in fitted vertex position
    double cnstPos[3];
    cnstPos[0]=vk->refIterV[0]+vk->cnstV[0];
    cnstPos[1]=vk->refIterV[1]+vk->cnstV[1];
    cnstPos[2]=vk->refIterV[2]+vk->cnstV[2];
    double localField = Trk::vkalMagFld::getMagFld(cnstPos,(vk->vk_fitterControl).get());
    double magConst = localField * vkalMagCnvCst;
    //
    int it,Charge=0;
    double ptot[4]={0.,0.,0.,0.};
    int NTRK = vk->TrackList.size();
 
    std::vector< std::array<double, 4> > pp(NTRK);
    for( it=0; it<NTRK; it++){
      VKTrack * trk = vk->TrackList[it].get();
      pp[it]=getCnstParticleMom( trk, localField );
      ptot[0] += pp[it][0];
      ptot[1] += pp[it][1];
      ptot[2] += pp[it][2];
      ptot[3] += pp[it][3];
      Charge += trk->Charge;
    }
    //Summary particle at fitted vertex
    double Pt= sqrt(ptot[0]*ptot[0] + ptot[1]*ptot[1]) ;
    double mom= sqrt(ptot[2]*ptot[2] + Pt*Pt) ;
    double phi=atan2(ptot[1],ptot[0]);
    double theta=acos( ptot[2]/mom );
    if(theta<1.e-5) theta=1.e-5;
    if(theta>M_PI-1.e-5) theta=M_PI-1.e-5;
    double invR = magConst / Pt; if(Charge) invR *= Charge;
    //
    // Fitted vertex position in global reference frame
    double curV[3] = {vk->refIterV[0]+vk->cnstV[0], vk->refIterV[1]+vk->cnstV[1],vk->refIterV[2]+vk->cnstV[2]};
    double Px=ptot[0];
    double Py=ptot[1];
    double Pz=ptot[2];
    double sinp = sin(phi);
    double cosp = cos(phi);
    double cott = 1./tan(theta);
    //
    //Derivatives
    double dPhiDpx = -Py/Pt/Pt;               //dPhi/dPx
    double dPhiDpy =  Px/Pt/Pt;               //dPhi/dPy
    //double dPhiDpz =  0;                    //dPhi/dPz
    double dThetaDpx =  Px*Pz/(Pt*mom*mom);   //dTheta/dPx
    double dThetaDpy =  Py*Pz/(Pt*mom*mom);   //dTheta/dPy
    double dThetaDpz = -Pt/(mom*mom);         //dTheta/dPz
    double dRDpx =  Px/(Pt*magConst);         //dR/dPx
    double dRDpy =  Py/(Pt*magConst);         //dR/dPy
    //double dRDpz =  0;                      //dR/dPz
    if(Charge){dRDpx /=Charge; dRDpy /=Charge;}
 
// Main part
 
    double a0,t,z0;
    double dA0dPhi,dZdPhi,dZdTheta,dA0dR;
    if( Charge==0 ) {
      a0 =-sinp * (cnst->getTargetVertex()[0] - curV[0]) +     //Perigee with respect to targetVertex
           cosp * (cnst->getTargetVertex()[1] - curV[1]);
      t  = cosp * (cnst->getTargetVertex()[0] - curV[0]) +
           sinp * (cnst->getTargetVertex()[1] - curV[1]);
      z0 = curV[2] + t*cott - cnst->getTargetVertex()[2];
//----------------------------------------------------------------------
// First constraint  a0=0
//
      dA0dPhi = -t;
      for( it=0; it<NTRK; it++){
         double invRi = vk->TrackList[it]->cnstP[2];
         base_cnst->f0t[it][0].X = 0.;      // dPx/dTheta==0, dPy/dTheta==0
         base_cnst->f0t[it][0].Y = dA0dPhi * (dPhiDpx*(-pp[it][1]) + dPhiDpy*( pp[it][0])) ;
         base_cnst->f0t[it][0].Z = dA0dPhi * (dPhiDpx*(-pp[it][0]) + dPhiDpy*(-pp[it][1]))/invRi ;
      }
      base_cnst->h0t[0].X =  sinp;     // dA0/dFitVertex==dA0/dCurV
      base_cnst->h0t[0].Y = -cosp;
      base_cnst->h0t[0].Z =  0.;
//----------------------------------------------------------------------
// Second constraint  z=0
//
      dZdPhi   = a0*cott;
      dZdTheta = -t/(sin(theta)*sin(theta));
      for( it=0; it<NTRK; it++){
         double invRi = vk->TrackList[it]->cnstP[2];
         double p2i = pp[it][0]*pp[it][0]+pp[it][1]*pp[it][1]+pp[it][2]*pp[it][2];
         double pti = sqrt(pp[it][0]*pp[it][0]+pp[it][1]*pp[it][1]);
         base_cnst->f0t[it][1].X  = 0.;      // dPx/dTheta==0, dPy/dTheta==0                        // ../dTheta_i
         base_cnst->f0t[it][1].Y  = dZdPhi * (dPhiDpx*(-pp[it][1]) + dPhiDpy*( pp[it][0])) ;        // ../dPhi_i
         base_cnst->f0t[it][1].Z  = dZdPhi * (dPhiDpx*(-pp[it][0]) + dPhiDpy*(-pp[it][1]))/invRi;   // ../dInvR_i
         base_cnst->f0t[it][1].X += dZdTheta * (                                                  dThetaDpz*(-p2i/pti));        // ../dTheta_i
         base_cnst->f0t[it][1].Y += dZdTheta * (dThetaDpx*(-pp[it][1]) + dThetaDpy*( pp[it][0]) +  0.);                         // ../dPhi_;    dPz/dPhi_i=0
         base_cnst->f0t[it][1].Z += dZdTheta * (dThetaDpx*(-pp[it][0]) + dThetaDpy*(-pp[it][1]) + dThetaDpz*(-pp[it][2]))/invRi;// ../dInvR_i
      }
      base_cnst->h0t[1].X = -cosp*cott;     // dZ/dCurV
      base_cnst->h0t[1].Y = -sinp*cott;
      base_cnst->h0t[1].Z =  1.;
//std::cout<<" test0="<<Charge<<", "<<a0<<", "<<z0<<", "<<t<<", "<<Px<<", "<<Py<<", "<<Pz<<'\n';
//
// The same for charged particle
//
 
    }else{
      int Sign = 1; if(Charge<0)Sign=-1;
      double R = 1./invR;
      double xc = -R*sinp + curV[0]; // centre of circle
      double yc =  R*cosp + curV[1];
      double diffx = cnst->getTargetVertex()[0] - xc;
      double diffy = cnst->getTargetVertex()[1] - yc;
      double diff = sqrt(  diffx*diffx + diffy*diffy );
      double sindphi = (curV[0]-xc)*diffy - (curV[1]-yc)*diffx;
             sindphi =  sindphi/std::abs(R)/diff;
      double dphi = asin( sindphi );
      double cosdphi=sqrt(std::abs(1.-sindphi*sindphi)); if(cosdphi<1.e-10)cosdphi=1.e-10;
      a0 = R*(1.-diff/std::abs(R));
      t  = dphi*R;
      z0 = curV[2] + t*cott - cnst->getTargetVertex()[2];
      double dTdXcur = std::abs(R)/cosdphi * (cosp/diff-diffx*sindphi/(diff*diff)) * (-1.);
      double dTdYcur = std::abs(R)/cosdphi * (sinp/diff-diffy*sindphi/(diff*diff)) * (-1.);
//----------------------------------------------------------------------
// First constraint  a0=0
//
      dA0dPhi =    - (diffx*cosp + diffy*sinp)/diff*std::abs(R);
      dA0dR   = 1. - (diffx*sinp - diffy*cosp)/diff*R/std::abs(R);
      for( it=0; it<NTRK; it++){
         double invRi = vk->TrackList[it]->cnstP[2];
         base_cnst->f0t[it][0].X  = 0.;      // dPx/dTheta==0, dPy/dTheta==0
         base_cnst->f0t[it][0].Y  = dA0dPhi * (dPhiDpx*(-pp[it][1]) + dPhiDpy*( pp[it][0])) ;
         base_cnst->f0t[it][0].Z  = dA0dPhi * (dPhiDpx*(-pp[it][0]) + dPhiDpy*(-pp[it][1]))/invRi ;
         base_cnst->f0t[it][0].X += 0.;
         base_cnst->f0t[it][0].Y += dA0dR * (dRDpx*(-pp[it][1]) + dRDpy*( pp[it][0]));
         base_cnst->f0t[it][0].Z += dA0dR * (dRDpx*(-pp[it][0]) + dRDpy*(-pp[it][1]))/invRi ;
      }
      base_cnst->h0t[0].X =  Sign*diffx/diff;     // dA0/dFitVertex==dA0/dCurV
      base_cnst->h0t[0].Y =  Sign*diffy/diff;
      base_cnst->h0t[0].Z =  0.;
//----------------------------------------------------------------------
// Second constraint  z=0
//
      dZdPhi   = -a0*cott;
      dZdTheta = -t/sin(theta)/sin(theta);
      for( it=0; it<NTRK; it++){
         double invRi = vk->TrackList[it]->cnstP[2];
         double p2i = pp[it][0]*pp[it][0]+pp[it][1]*pp[it][1]+pp[it][2]*pp[it][2];
         double pti = sqrt(pp[it][0]*pp[it][0]+pp[it][1]*pp[it][1]);
         base_cnst->f0t[it][1].X  = 0.;      // dPx/dTheta==0, dPy/dTheta==0                        // ../dTheta_i
         base_cnst->f0t[it][1].Y  = dZdPhi * (dPhiDpx*(-pp[it][1]) + dPhiDpy*( pp[it][0])) ;        // ../dPhi_i
         base_cnst->f0t[it][1].Z  = dZdPhi * (dPhiDpx*(-pp[it][0]) + dPhiDpy*(-pp[it][1]))/invRi;   // ../dInvR_i
         base_cnst->f0t[it][1].X += dZdTheta * (                                                  dThetaDpz*(-p2i/pti));        // ../dTheta_i
         base_cnst->f0t[it][1].Y += dZdTheta * (dThetaDpx*(-pp[it][1]) + dThetaDpy*( pp[it][0]) +  0.);                         // ../dPhi_;    dPz/dPhi_i=0
         base_cnst->f0t[it][1].Z += dZdTheta * (dThetaDpx*(-pp[it][0]) + dThetaDpy*(-pp[it][1]) + dThetaDpz*(-pp[it][2]))/invRi;// ../dInvR_i
      }
      base_cnst->h0t[1].X =  dTdXcur*cott;     // dZ/dCurV
      base_cnst->h0t[1].Y =  dTdYcur*cott;
      base_cnst->h0t[1].Z =  1.;
//std::cout<<" test1="<<Charge<<", "<<a0<<", "<<z0<<"  dst="<<t<<" NTRK="<<NTRK<<'\n';
    }
    base_cnst->aa[0]=a0;
    base_cnst->aa[1]=z0;
 
 
// -----------------------Check of propagation
//   double paro[5],parn[5],s,ref[3],pere[3]; long int ichg=0;
//   paro[0]=0.; paro[1]=0.; paro[2]=theta; paro[3]=phi; paro[4]=invR;
//   ref[0]=cnst->getTargetVertex()[0]-curV[0]; ref[1]=cnst->getTargetVertex()[1]-curV[1]; ref[2]=cnst->getTargetVertex()[2]-curV[2];
//   cfnewp(&ichg, paro, ref, &s, parn, pere);
//   std::cout<<" testp="<<Charge<<", "<<parn[0]<<", "<<parn[1]<<", "<<s<<'\n';
// -----------------------Derivatives
//std::cout<<base_cnst->f0t[0][0].X<<", "<<base_cnst->f0t[0][0].Y<<", "<<base_cnst->f0t[0][0].Z<<'\n';
//std::cout<<base_cnst->f0t[0][1].X<<", "<<base_cnst->f0t[0][1].Y<<", "<<base_cnst->f0t[0][1].Z<<'\n';
//std::cout<<base_cnst->f0t[1][0].X<<", "<<base_cnst->f0t[1][0].Y<<", "<<base_cnst->f0t[1][0].Z<<'\n';
//std::cout<<base_cnst->f0t[1][1].X<<", "<<base_cnst->f0t[1][1].Y<<", "<<base_cnst->f0t[1][1].Z<<'\n';
//std::cout<<base_cnst->h0t[0].X<<", "<<base_cnst->h0t[0].Y<<", "<<base_cnst->h0t[0].Z<<'\n';
//std::cout<<base_cnst->h0t[1].X<<", "<<base_cnst->h0t[1].Y<<", "<<base_cnst->h0t[1].Z<<'\n';
//std::cout<<"-------"<<'\n';
//--------------------------------------------------------------------------------------------------
   if( cnst->onlyZ() ) {      //Z only constraint  <= all Rphi ralated stuff is 0
      for( it=0; it<NTRK; it++){
         base_cnst->f0t[it][0].X  = 0.001;
         base_cnst->f0t[it][0].Y  = 0.001;
         base_cnst->f0t[it][0].Z  = 0.001;
      }
      base_cnst->h0t[0].X=0.; base_cnst->h0t[0].Y=0.; base_cnst->h0t[0].Z=0.;
      base_cnst->aa[0]=0.;
   }
}

calcRadiusConstraint()

void Trk::calcRadiusConstraint

(

VKRadiusConstraint *

cnst

)

Definition at line 120 of file DerclcAng.cxx.

{
    VKConstraintBase * base_cnst = dynamic_cast<VKConstraintBase*>( cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    int NTRK = vk->TrackList.size();
    double curV[3] = {vk->refIterV[0]+vk->cnstV[0], vk->refIterV[1]+vk->cnstV[1],vk->refIterV[2]+vk->cnstV[2]};
    int numCNST=0;   //constraint number. Single constraint in this case
    base_cnst->h0t[numCNST].X = 2.*(curV[0]-cnst->getRefX());
    base_cnst->h0t[numCNST].Y = 2.*(curV[1]-cnst->getRefY());
    base_cnst->h0t[numCNST].Z = 0;
    for(int i=0; i<NTRK; i++){
       base_cnst->f0t[i][numCNST].X = 0.;
       base_cnst->f0t[i][numCNST].Y = 0.;
       base_cnst->f0t[i][numCNST].Z = 0.;
    }
    base_cnst->aa[numCNST]=cnst->getRC()*cnst->getRC() - std::pow(curV[0]-cnst->getRefX(),2.) - std::pow(curV[1]-cnst->getRefY(),2.);
}

calcThetaConstraint()

void Trk::calcThetaConstraint

(

VKThetaConstraint *

cnst

)

Definition at line 61 of file DerclcAng.cxx.

{
    VKConstraintBase * base_cnst = static_cast<VKConstraintBase*>( cnst);
    const VKVertex * vk=cnst->getOriginVertex();
    int NTRK = vk->TrackList.size();
    int i,j;
    double Scale=1.;   // Scaling for better precision  VK 28.03.2011 Wrong for error matrix!!! Should always be 1.!!!
 
    double diff=0., der=0., aa=0;
    std::vector<double> deriv(NTRK,0);
    for(i=0; i<NTRK-1; i++){
       for(j=i+1; j<NTRK; j++){
          diff = sin(vk->TrackList[i]->cnstP[0] - vk->TrackList[j]->cnstP[0])*Scale;
          der  =                                                              Scale;
          aa +=  diff;
      deriv[i] += der;
      deriv[j] -= der;
       }
    }
 
    int numCNST=0;   //constraint number. Single constraint in this case
    base_cnst->h0t[numCNST].X = 0.;
    base_cnst->h0t[numCNST].Y = 0.;
    base_cnst->h0t[numCNST].Z = 0.;
    for(i=0; i<NTRK; i++){
       base_cnst->f0t[i][numCNST].X = deriv[i];
       base_cnst->f0t[i][numCNST].Y = 0.;
       base_cnst->f0t[i][numCNST].Z = 0.;
    }
    base_cnst->aa[numCNST]=aa;
//std::cout.precision(11);
//std::cout<<" new delta Theta="<<base_cnst->aa[numCNST]<<'\n';
//std::cout<<base_cnst->f0t[0][numCNST].X<<", "<<base_cnst->f0t[0][numCNST].Y<<", "
//         <<base_cnst->f0t[0][numCNST].Z<<'\n';
//std::cout<<base_cnst->f0t[1][numCNST].X<<", "<<base_cnst->f0t[1][numCNST].Y<<", "
//         <<base_cnst->f0t[1][numCNST].Z<<'\n';
}

cascadeCnstRemnants()

double Trk::cascadeCnstRemnants

(

CascadeEvent &

cascadeEvent_

)

Definition at line 77 of file CFitCascade.cxx.

                                                        {
  double cnstRemnants=0.;
  for(int iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     VKVertex * vk = cascadeEvent_.cascadeVertexList[iv].get();
     for(int ii=0; ii<(int)vk->ConstraintList.size();ii++){
        for(int ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
           cnstRemnants +=  std::abs( vk->ConstraintList[ii]->aa[ic] );
     } }
  }
  return cnstRemnants;
}

cfchi2() [1/2]

double Trk::cfchi2	(	const double *	vrtt,
		const double *	part,
		VKTrack *	trk )

Definition at line 80 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
 
    double d1, d2, d3, d4, d5;
    double theta_f = part[0];
    double phi_f   = part[1];
    double invR_f  = part[2];
    double uu = vrtt[0] * cos(phi_f) + vrtt[1] * sin(phi_f );
    double vv = vrtt[1] * cos(phi_f) - vrtt[0] * sin(phi_f);
    double sr = invR_f * abs(trk->Charge);                // Zero in case of zero charge
    double epsf = -vv - (uu * uu + vv * vv) * sr / 2.;
    double zpf  = vrtt[2] - uu * (1. - vv * sr) / tan(theta_f);
    double phif = phi_f - uu * sr;
    d1 = epsf    - trk->Perig[0];
    d2 = zpf     - trk->Perig[1];
    d3 = theta_f - trk->Perig[2];
    d4 = phif    - trk->Perig[3];
    d5 = invR_f  - trk->Perig[4];
    if(d4 >  M_PI)d4-=2.*M_PI;
    if(d4 < -M_PI)d4+=2.*M_PI;
    double res = trk->WgtM[0] * (d1*d1)
               + trk->WgtM[2] * (d2*d2)
               + trk->WgtM[5] * (d3*d3)
               + trk->WgtM[9] * (d4*d4)
               + trk->WgtM[14]* (d5*d5)
            +(d2 *  d1*trk->WgtM[1]
        + d3 * (d1*trk->WgtM[3]  + d2*trk->WgtM[4])
        + d4 * (d1*trk->WgtM[6]  + d2*trk->WgtM[7]  + d3*trk->WgtM[8])
        + d5 * (d1*trk->WgtM[10] + d2*trk->WgtM[11] + d3*trk->WgtM[12] + d4*trk->WgtM[13])) * 2;
    trk->rmnd[0] = d1;
    trk->rmnd[1] = d2;
    trk->rmnd[2] = d3;
    trk->rmnd[3] = d4;
    trk->rmnd[4] = d5;
//std::cout<<__func__<<":"<<d1<<", "<<d2<<", "<<d3<<", "<<d4<<", "<<d5<<'\n';
//std::cout<<trk->Perig[0]<<", "<<trk->Perig[1]<<", "<<trk->Perig[2]<<", "<<trk->Perig[3]<<", "<<trk->Perig[4]<<'\n';
//std::cout<<theta_f<<", "<<phi_f<<", "<<invR_f<<'\n';
//std::cout<<trk->WgtM[0]<<", "<<trk->WgtM[2]<<", "<<trk->WgtM[5]<<", "<<trk->WgtM[9]<<", "<<trk->WgtM[14]<<'\n';
    return  (std::abs(res) < 1.e12 ? std::abs(res) : 1.e12);
}

cfchi2() [2/2]

double Trk::cfchi2	(	double *	xyzt,
		const long int	ich,
		double *	part,
		const double *	par0,
		double *	wgt,
		double *	rmnd )

Definition at line 27 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
    double phif, epsf, d1, d2, d3, d4, d5, sr, uu, vv, res, zpf;
 
    /* Parameter adjustments */
    --wgt;
    --part;
    --xyzt;
 
    uu = xyzt[1] * cos(part[2]) + xyzt[2] * sin(part[2]);
    vv = xyzt[2] * cos(part[2]) - xyzt[1] * sin(part[2]);
    sr = part[3] * std::abs(ich);
    epsf = -vv - (uu * uu + vv * vv) * sr / 2.;
    zpf = xyzt[3] - uu * (1. - vv * sr) / tan(part[1]);
    phif = part[2] - uu * sr;
    d1 = par0[0] - epsf;
    d2 = par0[1] - zpf;
    d3 = par0[2] - part[1];
    d4 = par0[3] - phif;
    d5 = par0[4] - part[3];
    while(d4 >  M_PI)d4-=2.*M_PI;
    while(d4 < -M_PI)d4+=2.*M_PI;
// -----------------------Check of propagation
//    double paro[5],parn[5],s,ref[3],peri[3];
//    paro[0]=0.; paro[1]=0.; paro[2]=part[1]; paro[3]=part[2]; paro[4]=part[3];
//    ref[0]=-xyzt[1]; ref[1]=-xyzt[2]; ref[2]=-xyzt[3];
//    cfnewp(ich, paro, ref, &s, parn, peri);
//    d1 =  par0[0] - parn[0]; d2 =  par0[1] - parn[1]; d3 =  par0[2] - parn[2];
//    d4 =  par0[3] - parn[3]; d5 =  par0[4] - parn[4];
//    std::cout<<" testp0="<<parn[0]<<", "<<parn[1]<<", "<<parn[3]<<", "<<s<<'\n';
//    std::cout<<" testp1="<<(*ich)<<", "<<epsf<<", "<<zpf<<", "<<phif<<", "<<res<<'\n';
//--------------------------------------------------------------------
    res = wgt[1] * (d1 * d1) + wgt[3] * (d2 * d2) + wgt[6] * (d3 * d3)
       + wgt[10] * (d4 * d4) + wgt[15] * (d5 * d5) + (d2 *
        d1 * wgt[2] + d3 * (d1 * wgt[4] + d2 * wgt[5]) + d4 * (d1 * wgt[7]
        + d2 * wgt[8] + d3 * wgt[9]) + d5 * (d1 * wgt[11] + d2 * wgt[12]
        + d3 * wgt[13] + d4 * wgt[14])) * 2;
    rmnd[0] = d1;
    rmnd[1] = d2;
    rmnd[2] = d3;
    rmnd[3] = d4;
    rmnd[4] = d5;
    return  (std::abs(res) < 1.e12 ? std::abs(res) : 1.e12);
}

cfdcopy()

void Trk::cfdcopy ( double * source, double * target, int n )

inline

Definition at line 23 of file TrkVKalUtils.h.

    {  std::copy(source, source + n, target); }

cfddist3D()

double Trk::cfddist3D ( double * V1, double * V2 )

inline

Definition at line 26 of file TrkVKalUtils.h.

    { return sqrt( (V2[0]-V1[0])*(V2[0]-V1[0]) + (V2[1]-V1[1])*(V2[1]-V1[1]) + (V2[2]-V1[2])*(V2[2]-V1[2]) ); }

cfdinv()

int Trk::cfdinv	(	double *	cov,
		double *	wgt,
		long int	NI )

Definition at line 497 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
    long int n = std::abs(NI);
    if (n <= 1) return -1;
    long int  jerr=0;;
 
//---Robust inversion if COV is suspected ill-defined
     if (NI>0) {
       jerr=vkSInvSVD(cov,NI,wgt, 1.e-18);
       //--Check if inverted matrix is at approximately correct
       if(!jerr){  if(checkMatrixInversion(cov, wgt, n)>0.1) jerr=-2; }
       return jerr;
    }
//---If COV is believed good
    jerr=vkcholInv(cov, wgt, n);
    if(!jerr){  if(checkMatrixInversion(cov, wgt, n)>0.1) jerr=-2; }
    return jerr;
}

cferpr()

void Trk::cferpr	(	const long int	ich,
		double *	par,
		double *	ref,
		const double	s0,
		double *	errold,
		double *	errnew )

Definition at line 12 of file cfErPr.cxx.

{
 
 
    double  r__, dsphi, dseps, dsrho, cs, sn, xp, yp;
    double  derivm[25]; /* was [5][5] */
    double  ctg, dsq, dyp, d__3;
/*     ------------------------------------------ */
/*       This routine propagates the trajectory error matrix */
/*       originally evaluated at s=0 to the curved abcissa S */
/*       assuming that the track travels into VACUUM */
/*        INPUT:        ICH    Charge of track */
/*             PAR(5) Track parameters */
/*             REF(3) New reference point */
/*                      ERROLD error matrix at (0,0,0) */
/*                      S0     curved abcissa of propagation */
/*        OUTPUT:    ERRNEW    New error matrix */
/* ------ */
/*  derivm(i,j)=D(X'.j)/D(X.i) */
/* ----------------------------------------------------------- */
/* Author: V.Kostyukhin */
/* ------------------------------------------------------------ */
    /* Parameter adjustments */
    --par;
    --ref;
 
 
 /* --------------------------------------------------- */
    for (int ii= 0; ii< 25; ++ii)  derivm[ii] = 0.;
/* -- */
    cs = cos(par[4]);
    sn = sin(par[4]);
    xp = ref[1] * cs + ref[2] * sn; //==(*s0) for neutral particles
    yp = ref[1] * sn - ref[2] * cs;
    double sinp3 = sin(par[3]);
    ctg = cos(par[3]) / sinp3;
    derivm[6] = 1.;
    derivm[12] = 1.;
    derivm[24] = 1.;
    if (ich != 0) {
    r__ = 1. / par[5];
    dyp = r__ - par[1] + yp;
    dsphi = -r__ * (yp * dyp + xp * xp) / (dyp * dyp + xp * xp);
    dseps =  r__ * xp / (dyp * dyp + xp * xp);
    dsrho = -r__ * s0 + r__ * r__ * dseps;
    derivm[5] = dseps * ctg;
    derivm[7] = -s0 / (sinp3 * sinp3);
    derivm[8] = dsphi * ctg;
    derivm[9] = dsrho * ctg;
    derivm[15] = par[5] * dseps;
/* Computing 2nd power */
    d__3 = r__ - par[1];
    dsq = sqrt(ref[1]*ref[1] + ref[2]*ref[2] + d__3*d__3 + 2.*d__3*yp);
    derivm[4] = -(r__*r__) + d_sign(1., r__) * (r__*r__) * dyp / dsq;
    derivm[3] = d_sign(1., r__) * (par[1] - r__) * xp / dsq;
    derivm[19] = s0 + par[5] * dsrho;
    derivm[0] = d_sign(1., r__) * dyp / dsq;
    derivm[18] = par[5] * dsphi + 1.;
    } else {
    derivm[0] = 1.;
    derivm[18] = 1.;
      //derivm[3] = par[1] - xp;   VK Error!!!
    derivm[3] =  - xp;                  //dEps/dPhi
    derivm[7] = -xp / (sinp3 * sinp3);  //dZ/dTheta
    derivm[8] = -yp * ctg;              //dZ/dPhi
    }
    tdasatVK(derivm, &errold[0], &errnew[0], 5, 5);
 
}

cfimp()

void Trk::cfimp	(	long int	TrkID,
		long int	ich,
		int	IFL,
		double *	par,
		const double *	err,
		double *	vrt,
		double *	vcov,
		double *	rimp,
		double *	rcov,
		double *	sign,
		VKalVrtControlBase *	FitCONTROL )

Definition at line 43 of file cfImp.cxx.

{
    double dcov[3], errd[15], paro[5];
    double dwgt[3], errn[15];
    int i__, j, ij;
 
    double cnv[6]   /* was [2][3] */;
/* --------------------------------------------------------- */
/*  Impact parameter calculation                             */
/*  Input:                                                   */
/*      ICH -charge(-1,0,1)                                  */
/*      IFL = 1 contribution from VRT is added               */
/*      IFL =-1 contribution from VRT is subtructed          */
/*      PAR(5),ERR(15) - peregee parameters and error matrix */
/*      VRT(3),VCOV(6) - vertex and its error matrix         */
/*                                                           */
/*    SIGNIFICANCE IS CALCULATED FOR PERIGEE POINT BY DEF.   */
/*           (NOT FOR THE CLOSEST POINT!!!)                  */
/*                                                           */
/*  Output:                                                  */
/*     RIMP(1) - impact in XY                                */
/*     RIMP(2) - impact in Z                                 */
/*     RIMP(3) - Theta at new vertex                         */
/*     RIMP(4) - Phi at new vertex                           */
/*     RIMP(5) - curvature at vertex                         */
/*     RCOV(3) - error matrix for RIMP                       */
/*     SIGN    - impact significance                         */
/* Author: V.Kostyukhin                                      */
/* --------------------------------------------------------- */
    /* Parameter adjustments */
    --vcov;
 
    /* Function Body */
    for (int ii = 0; ii < 15; ++ii) {errd[ii] = err[ii];}
 
 
    double Ref0[3]={0.,0.,0.};  //base reference point for standard perigee
 
    Trk::vkalPropagator::Propagate(TrkID, ich, par, errd, Ref0, vrt, paro, errn, FitCONTROL);
 
//std::cout <<" CFImp new par R,Z="<<paro[0]<<", "<<paro[1]<<'\n';
/* ---------- */
    rimp[0] = paro[0];
    rimp[1] = paro[1];
    rimp[2] = paro[2];
    rimp[3] = paro[3];
    rimp[4] = paro[4];
/*  X=paro(1)*sn, Y=-paro(1)*cs */
    double sn = sin(paro[3]);
    double cs = cos(paro[3]);
/* -- New error version */
    cnv[0] = -sn;
    cnv[2] = cs;
    cnv[4] = 0.;
    cnv[1] = sn / tan(paro[2]);
    cnv[3] = cs / tan(paro[2]);
    cnv[5] = -1.;
    dcov[0] = 0.;
    dcov[1] = 0.;
    dcov[2] = 0.;
    for (i__ = 1; i__ <= 3; ++i__) {
      for (j = 1; j <= 3; ++j) {
        ij = max(i__, j);
        ij = ij * (ij - 1) / 2 + min(i__, j);
        dcov[0] += cnv[(i__ << 1) - 2] * cnv[(j << 1) - 2] * vcov[ij];
        dcov[2] += cnv[(i__ << 1) - 1] * cnv[(j << 1) - 1] * vcov[ij];
        dcov[1] += cnv[(i__ << 1) - 2] * cnv[(j << 1) - 1] * vcov[ij];
      }
    }
    /* --------------------------------------------------------------- */
    if (IFL == 1) {
      rcov[0] = errn[0] + dcov[0];
      rcov[1] = errn[1] + dcov[1];
      rcov[2] = errn[2] + dcov[2];
    } else if (IFL == -1) {
      rcov[0] = errn[0] - dcov[0];
      rcov[1] = errn[1] - dcov[1];
      rcov[2] = errn[2] - dcov[2];
    } else {
      rcov[0] = errn[0];
      rcov[1] = errn[1];
      rcov[2] = errn[2];
    }
    int jerr = cfdinv(rcov, dwgt, -2);
    if (jerr) {jerr=cfdinv(rcov, dwgt, 2); if(jerr){dwgt[0]=dwgt[2]=1.e6; dwgt[1]=0.;}}
    (*sign) = sqrt(std::abs(dwgt[0] * rimp[0] * rimp[0] + dwgt[1] * 2. * rimp[0] * rimp[1] +
        dwgt[2] * rimp[1] * rimp[1]));
}

cfimpc()

void Trk::cfimpc	(	long int	TrkID,
		long int	ich,
		int	IFL,
		double *	par,
		const double *	err,
		double *	vrt,
		double *	vcov,
		double *	rimp,
		double *	rcov,
		double *	sign,
		VKalVrtControlBase *	FitCONTROL )

Definition at line 135 of file cfImp.cxx.

{
    double dcov[3], errd[15], paro[5];
    double dwgt[3], errn[15], cnv[6];   /* was [2][3] */
    int i__, j, ij;
 
 
    double cs, sn;
/* --------------------------------------------------------- */
/*    SIGNIFICANCE IS CALCULATED FOR THE CLOSEST POINT NOW!!!*/
/* Author: V.Kostyukhin                                      */
/* --------------------------------------------------------- */
    /* Parameter adjustments */
    --vcov;
    for (int ii = 0; ii < 15; ++ii) {errd[ii] = err[ii];}
 
    double Ref0[3]={0.,0.,0.};  //base reference point for standard perigee
    Trk::vkalPropagator::Propagate(TrkID, ich, par, errd, Ref0, vrt, paro, errn, FitCONTROL);
 
    double tmpVrt[3]={0.,0.,0.}; double ClosestPnt[3];
    cfClstPnt( paro, tmpVrt, ClosestPnt);
    paro[0]=sqrt(ClosestPnt[0]*ClosestPnt[0] + ClosestPnt[1]*ClosestPnt[1]);
    paro[1]=ClosestPnt[2];
/* ---------- */
    rimp[0] = paro[0];
    rimp[1] = paro[1];
    rimp[2] = paro[2];
    rimp[3] = paro[3];
    rimp[4] = paro[4];
    sn = sin(paro[3]);
    cs = cos(paro[3]);
/* -- New error version */
    cnv[0] = -sn;
    cnv[2] = cs;
    cnv[4] = 0.;
    cnv[1] = sn / tan(paro[2]);
    cnv[3] = cs / tan(paro[2]);
    cnv[5] = -1.;
    dcov[0] = 0.;
    dcov[1] = 0.;
    dcov[2] = 0.;
    for (i__ = 1; i__ <= 3; ++i__) {
        for (j = 1; j <= 3; ++j) {
            ij = max(i__, j);
            ij = ij * (ij - 1) / 2 + min(i__, j);
            dcov[0] += cnv[(i__ << 1) - 2] * cnv[(j << 1) - 2] * vcov[ij];
            dcov[2] += cnv[(i__ << 1) - 1] * cnv[(j << 1) - 1] * vcov[ij];
            dcov[1] += cnv[(i__ << 1) - 2] * cnv[(j << 1) - 1] * vcov[ij];
        }
    }
    /* --------------------------------------------------------------- */
    if (IFL == 1) {
        rcov[0] = errn[0] + dcov[0];
        rcov[1] = errn[1] + dcov[1];
        rcov[2] = errn[2] + dcov[2];
    } else if (IFL == -1) {
        rcov[0] = errn[0] - dcov[0];
        rcov[1] = errn[1] - dcov[1];
        rcov[2] = errn[2] - dcov[2];
    } else {
        rcov[0] = errn[0];
        rcov[1] = errn[1];
        rcov[2] = errn[2];
    }
    int jerr = cfdinv(rcov, dwgt, -2);
    if (jerr) {
        jerr = cfdinv(rcov, dwgt, 2);
        if (jerr) {
            dwgt[0] = dwgt[2] = 1.e6;
            dwgt[1] = 0.;
        }
    }
    (*sign) = sqrt(std::abs(dwgt[0] * rimp[0] * rimp[0] +
                            dwgt[1] * 2. * rimp[0] * rimp[1] +
                            dwgt[2] * rimp[1] * rimp[1]));
 }

cfInv5()

int Trk::cfInv5	(	double *	cov,
		double *	wgt )

Definition at line 459 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
    double dest[25];
    long int  i, j, k, N;
/* -----------------------------------------*/
/*  Track covariance matrix inversion       */
/*   stable to small value of mom. error    */
/*   Author: V.Kostyukhin                   */
/* -----------------------------------------*/
 
/* -- RESTORE MATRIX 4x4 -- */
    N = 4;
    k = 0;
    for (i=0; i<N; ++i)  for (j=0; j<=i; ++j) {
          dest[ i*N + j ] = dest[ j*N + i ] = cov[k]; wgt[k]=0.; k++; }
 
    double X[4]={cov[10], cov[11], cov[12], cov[13]};
 
    for (i = 0; i < N; ++i) {
    for (j = 0; j < N; ++j) dest[i*N+j] -= X[i]*X[j]/cov[14];
    }
    long int jerr;
    dsinv(N, dest, N, &jerr);
    if(jerr) return jerr;
 
    double L[4]={0.,0.,0.,0.};
    for (i = 0; i < N; ++i) {
      for (j = 0; j < N; ++j) L[i] -= dest[i*N+j]*X[j]/cov[14];
    }
    double W=1.;  for (i = 0; i < N; ++i)  W -= X[i]*L[i];
    wgt[10]=L[0]; wgt[11]=L[1]; wgt[12]=L[2]; wgt[13]=L[3]; wgt[14] = W/cov[14];
 
    k=0;  for (i=0; i<N; i++) for (j=0; j<=i; j++) wgt[k++]=dest[i*N+j];
 
    return 0;
}

CFit()

int Trk::CFit	(	VKalVrtControl *	FitCONTROL,
		int	ifCovV0,
		int	NTRK,
		long int *	ich,
		double	xyz0[3],
		double(*)	par0[3],
		double(*)	inp_Trk5[5],
		double(*)	inp_CovTrk5[15],
		double	xyzfit[3],
		double(*)	parfs[3],
		double	ptot[4],
		double	covf[21],
		double &	chi2,
		double *	chi2tr )

Definition at line 435 of file CFit.cxx.

{
 
    std::fill_n(ptot,4,0.);
    std::fill_n(covf,21,0.);
    cfdcopy(xyz0,xyzfit,3);
    FitCONTROL->renewFullCovariance(nullptr);
 
//
//   Create vertex
//
    std::unique_ptr<VKVertex> MainVRT(new VKVertex(*FitCONTROL));
    fillVertex(MainVRT.get(), NTRK, ich, xyz0, par0, inp_Trk5, inp_CovTrk5);
//
//  Fit vertex
//
    int IERR = fitVertex( MainVRT.get());
    if(IERR)   return IERR;
//
//  if successful - save results
//
    for(int i=0; i<3; i++) xyzfit[i] = MainVRT->refIterV[i]+MainVRT->fitV[i];  //   fitted vertex in global frame
    MainVRT->vk_fitterControl->vk_forcft.localbmag = Trk::vkalMagFld::getMagFld(xyzfit,(MainVRT->vk_fitterControl).get());
    chi2 = 0.;
    for (int tk = 0; tk < NTRK; tk++) {
        VKTrack * trk = MainVRT->TrackList[tk].get();
        chi2   += trk->Chi2;
        chi2tr[tk] = trk->Chi2;
        cfdcopy( trk->fitP, &parfs[tk][0], 3);
        std::array<double, 4> pp = getFitParticleMom( trk, MainVRT.get() );
        ptot[0]+=pp[0]; ptot[1]+=pp[1]; ptot[2]+=pp[2]; ptot[3]+=pp[3];
    }
    cfdcopy(MainVRT->fitVcov, covf  , 6);  //fitted vertex covariance
    double vM2=(ptot[3]-ptot[2])*(ptot[3]+ptot[2]) - ptot[1]*ptot[1] - ptot[0]*ptot[0];
    FitCONTROL->setVertexMass(std::sqrt(vM2>0. ? vM2 : 0. ) );
    FitCONTROL->setVrtMassError(0.);
//
//  If required - get full covariance matrix
//
    if(ifCovV0){
      double dptot[5], VrtMomCov[21];
      IERR = afterFit(MainVRT.get(), MainVRT->ader, MainVRT->FVC.dcv, dptot, VrtMomCov, (MainVRT->vk_fitterControl).get());
      if (IERR) return -2;   /* NONINVERTIBLE COV.MATRIX */
      if(MainVRT->existFullCov){
        FitCONTROL->renewFullCovariance(new double[ (3*NTRK+3)*(3*NTRK+3+1)/2 ]);
        int out=0;
        for(int ti=0; ti<3+3*NTRK; ti++){
          for(int tj=0; tj<=ti; tj++){
            FitCONTROL->getFullCovariance()[out] = ARR2D_FS(MainVRT->ader, 3*vkalNTrkM+3, ti, tj);
            out++;
        } }
        int activeTrk[vkalNTrkM]={0};  std::fill_n(activeTrk,NTRK,1);
        double vrtMass=0., vrtMassError=0.;
        cfmasserr(MainVRT.get(), activeTrk, &vrtMass, &vrtMassError);
        FitCONTROL->setVertexMass(vrtMass);
        FitCONTROL->setVrtMassError(vrtMassError);
      }
      cfdcopy( VrtMomCov,  covf, 21);  //XvYvZvPxPyPz covariance
      cfdcopy( MainVRT->vk_fitterControl->vk_forcft.robres, FitCONTROL->vk_forcft.robres, NTRK); //Track weights from robust fit
 
    }
 
    return 0;
}

cfmasserr()

void Trk::cfmasserr	(	VKVertex *	vk,
		const int *	list,
		double *	MASS,
		double *	sigM )

Definition at line 16 of file cfMassErr.cxx.

{
  int NTRK=vk->TrackList.size();
  //Deliberately not using make_unique
  std::unique_ptr < double[] > deriv(new double[3*NTRK+3]);
  double ptot[4]={0.};
  std::vector< std::array<double,6> > pmom(NTRK);
  double dm2dpx, dm2dpy, dm2dpz, ee, pt, px, py, pz, cth;
 
  double fieldPos[3];
  fieldPos[0]=vk->refIterV[0]+vk->fitV[0];
  fieldPos[1]=vk->refIterV[1]+vk->fitV[1];
  fieldPos[2]=vk->refIterV[2]+vk->fitV[2];
  double vBx,vBy,vBz;
  Trk::vkalMagFld::getMagFld(fieldPos[0], fieldPos[1], fieldPos[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
 
  for(int it=0; it<NTRK; it++){
    if (list[it]) {
       auto trk=vk->TrackList[it].get();
       double constBF = Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->fitP[1], trk->fitP[0]) * vkalMagCnvCst ;
       pmom[it][4] = pt = std::abs( constBF/trk->fitP[2] );
       pmom[it][5] = cth = 1. /tan(trk->fitP[0]);
       pmom[it][0] = px = pt * cos(trk->fitP[1]);
       pmom[it][1] = py = pt * sin(trk->fitP[1]);
       pmom[it][2] = pz = pt * cth;
       double mmm=trk->getMass();
       pmom[it][3] = sqrt(px*px + py*py + pz*pz + mmm*mmm);
       ptot[0] += px;
       ptot[1] += py;
       ptot[2] += pz;
       ptot[3] += pmom[it][3];
    }
  }
 
  for(int it = 0; it < NTRK; ++it) {
    if (list[it]) {
       pt = pmom[it][4];
       cth= pmom[it][5];
       px = pmom[it][0];
       py = pmom[it][1];
       pz = pmom[it][2];
       ee = pmom[it][3];
       dm2dpx = (ptot[3] / ee * px - ptot[0]) * 2.;
       dm2dpy = (ptot[3] / ee * py - ptot[1]) * 2.;
       dm2dpz = (ptot[3] / ee * pz - ptot[2]) * 2.;
       deriv[it*3 + 0] = dm2dpz * ((-pt) * (cth * cth + 1.));                                /* d(M2)/d(Theta) */
       deriv[it*3 + 1] =  -dm2dpx * py + dm2dpy * px;                                        /* d(M2)/d(Phi)   */
       deriv[it*3 + 2] = (-dm2dpx * px - dm2dpy*py - dm2dpz*pz)/vk->TrackList[it]->fitP[2];  /* d(M2)/d(Rho)   */
    } else {
       deriv[it*3 + 0] = deriv[it*3 + 1] = deriv[it*3 + 2] = 0.;
    }
  }
//----
  double covM2=0.;
  for(int i=0; i<NTRK*3; i++){
     double tmp=0.;
     for(int j=0; j<NTRK*3; j++){
       tmp += ARR2D_FS(vk->ader, vkalNTrkM*3+3, i+3, j+3) *deriv[j];
     }
     tmp *= deriv[i];
     if(std::isnan(tmp)) {tmp=0.;}
     if(std::isinf(tmp)) {tmp=0.;}
     covM2 += tmp;
  }
  std::feclearexcept(FE_ALL_EXCEPT);
  if(covM2<1.e-10)covM2=1.e-10;
//----
  (*MASS) = (ptot[3]-ptot[2])*(ptot[3]+ptot[2])-ptot[1]*ptot[1]-ptot[0]*ptot[0];
  if((*MASS)<1.e-10)  (*MASS) = 1.e-10;
  (*MASS)   = sqrt(*MASS);
  (*sigM) = sqrt(covM2) / 2. / (*MASS);
}

cfnewp()

void Trk::cfnewp	(	const long int	ich,
		double *	parold,
		double *	ref,
		double *	s,
		double *	parnew,
		double *	per )

Definition at line 10 of file cfNewP.cxx.

{
 
    double dphi, coth, hper, zper, zeps, r__, cs, xc, yc, sn, sipart, eps;
 
/* ------------------------------------------------------------*/
/*       This routine propagates the trajectory parameters     */
/*       w.r.t to a new reference point.                       */
/*   RETURNED POSITION IS NOT A POSITION OF CLOSEST APPROACH   */
/*   BUT PERIGEE ASSUMIMG THAT REF IS                  */
/*            A CENTER OF COORDINATE SYSTEM                    */
/*                                 */
/*        INPUT:  ICH    Charge(-1,0,1)                        */
/*       PAROLD Initial parameters(EPS,H,THE,PHI,1./R) */
/*                REF    Position of new reference point       */
/*        OUTPUT: S Curved abcissa of new perigee              */
/*                PARNEW Parameters evaluated at new perigee   */
/*                PER    Position of new perigee               */
/* Author: V.Kostyukhin                                        */
/* ------------------------------------------------------------*/
    /* Parameter adjustments */
    --per;
    --parnew;
    --ref;
    --parold;
 
    eps = parold[1];
    sn = sin(parold[4]);
    cs = cos(parold[4]);
    coth = 1. / tan(parold[3]);
    zeps = parold[2];
 
/*  Neutral track */
    if ( ich == 0) {
    hper = eps - ref[1] * sn + ref[2] * cs;
    dphi = 0.;
    (*s) = ref[1] * cs + ref[2] * sn;
    zper = zeps + coth * (*s) - ref[3];
    } else {
    r__ = 1. / parold[5];
    sipart = 1.;
    if (r__ < 0.) sipart = -1.;
/* -- Centre of the circle and perigee */
    xc = (eps - r__) * sn - ref[1];
    yc = -(eps - r__) * cs- ref[2];
    hper = r__ - sipart * sqrt(xc*xc + yc*yc);
/* -- Phi */
        double tmp_prec=  - eps - cs*ref[2] + sn*ref[1];
    dphi = atan2(sipart * (ref[1]*cs + ref[2]*sn),
                     sipart * (r__ + tmp_prec) );
    (*s) = r__*dphi;
/* -- Z at VXOLD */
    zper = zeps + coth * (*s) - ref[3];
    }
    parnew[1] = hper;
    parnew[2] = zper;
    parnew[3] = parold[3];
    parnew[4] = parold[4] + dphi;
 
/* check 2*pi period in phi */
    while (parnew[4] > 6.2831853071794) parnew[4] -= 6.2831853071794;
    while (parnew[4] <-6.2831853071794) parnew[4] += 6.2831853071794;
 
 
 
    parnew[5] = parold[5];
    per[1] = ref[1] + sin(parold[4] + dphi) * hper;
    per[2] = ref[2] - cos(parold[4] + dphi) * hper;
    per[3] = ref[3] + zper;
}

cfnewpm()

void Trk::cfnewpm	(	double *	par,
		const double *	xyzStart,
		double *	xyzEnd,
		const double	ustep,
		double *	parn,
		double *	closePoint,
		VKalVrtControlBase *	CONTROL )

Definition at line 16 of file cfNewPm.cxx.

{
    double d__1, d__2,dist_left;
    double vect[7], stmg, vout[7]={0.}, dpar0[5];
    double perig[3], dstep, xyzst[3], charge;
    double posold, poscur, totway, dp;
    double dX, dY, dZ;
    long int ich;
 
/* --------------------------------------------------------- */
/*  The same as CFNEWP but for the case on nonuniform        */
/*   magnetic field                                          */
/*                                                           */
/*  Propagation from xyzStart reference point to xyzEnd point*/
/*     PAR  - perigee parameters wrt xyzStart                */
/*     PARN - perigee parameters wrt xyzEnd                  */
/*  Author: V.Kostyukhin                                     */
/* --------------------------------------------------------- */
    /* Parameter adjustments */
    --par;
 
    d__1 = tan(par[3]);
    totway = (ustep) * sqrt(1. / (d__1 * d__1) + 1.);
 
    if (fabs(ustep) < 10. && fabs(totway) < 20.)  return;   // Distance(mm) is small. Simplest propagation is used
 
    stmg = 40.;  //Propagation step in mm for nonuniform field
 
    vect[0] =  sin(par[4]) * par[1]   +xyzStart[0];
    vect[1] = -cos(par[4]) * par[1]   +xyzStart[1];
    vect[2] = par[2]                  +xyzStart[2];
 
    double constB = Trk::vkalMagFld::getMagFld(vect,CONTROL) * Trk::vkalMagFld::getCnvCst();
 
    double pt = constB / fabs(par[5]);
    double px = pt * cos(par[4]);
    double py = pt * sin(par[4]);
    double pz = pt / tan(par[3]);
    double p = sqrt(pt * pt + pz * pz);
 
    vect[3] = px / p;
    vect[4] = py / p;
    vect[5] = pz / p;
    vect[6] = p;
    charge = -d_sign( 1., par[5]);
    poscur = 0.;
//std::cout <<"VkGrkuta vect="<<vect[0]<<", "<<vect[1]<<", "<<vect[2]<<", "<<vect[3]<<", "
//                            <<vect[4]<<", "<<vect[5]<<", "<<vect[6]<<'\n';
    while(fabs(poscur) < fabs(totway)) {
    posold = poscur;
    d__1 = fabs(poscur) + stmg;
        d__2 = fabs(totway);
    poscur = d__1 < d__2 ? d__1 : d__2;
    poscur = d_sign(poscur, totway);
    dstep = poscur - posold;
    vkgrkuta_(charge, dstep, vect, vout, CONTROL);
    vect[0] = vout[0];
    vect[1] = vout[1];
    vect[2] = vout[2];
    vect[3] = vout[3];
    vect[4] = vout[4];
    vect[5] = vout[5];
// safety for strongly nonuniform field
    dX = vect[0]-xyzEnd[0];
    dY = vect[1]-xyzEnd[1];
    dZ = vect[2]-xyzEnd[2];
    dist_left = sqrt( dX*dX + dY*dY + dZ*dZ);
    if(dist_left < stmg) break;    // arrived
    }
 
/* --- Now we are in the new point. Calculate track parameters */
/*   at new point with new mag.field */
 
    constB = Trk::vkalMagFld::getMagFld(xyzEnd,CONTROL) * Trk::vkalMagFld::getCnvCst() ;
    if(std::abs(constB)<0.001)constB=0.001; //Protection against zero field
 
    dpar0[0] = 0.;
    dpar0[1] = 0.;
    dpar0[2] = acos(vout[5]);
    dpar0[3] = atan2(vout[4], vout[3]);
//    if (dpar0[3] < 0.) dpar0[3] += 6.2831853071794;
 
    px = vect[3] * vect[6];
    py = vect[4] * vect[6];
    dpar0[4] = d_sign(  (constB/sqrt(px*px+py*py)), par[5]);    /* new value of curvature */
    ich = (long int) charge;
    xyzst[0] = xyzEnd[0] - vout[0];
    xyzst[1] = xyzEnd[1] - vout[1];
    xyzst[2] = xyzEnd[2] - vout[2];
 
    cfnewp(ich, dpar0, xyzst, &dp, parn, perig); // Last step of propagation
    closePoint[0] = perig[0] + vout[0];                  // with simple program
    closePoint[1] = perig[1] + vout[1];
    closePoint[2] = perig[2] + vout[2];
}

cfpest()

void Trk::cfpest	(	int	ntrk,
		double *	xyz,
		long int *	ich,
		double(*)	parst[5],
		double(*)	parf[3] )

Definition at line 10 of file cfPEst.cxx.

                               {
  /* --------------------------------------------------- */
  /*    Subroutine for primary estimation of Theta,Phi   */
  /*     and 1/R at point XYZ if they aren't known       */
  /* Author: V.Kostyukhin                                */
  /* --------------------------------------------------- */
 
  double partmp[5];
  double Ref0[3] = {0., 0., 0.};
 
  for (int i = 0; i < ntrk; ++i) {
 
    long int TrkID = i;
    Trk::vkalPropagator::Propagate(TrkID, ich[i], &parst[i][0], nullptr, Ref0,
                                   xyz, partmp, nullptr);
 
    parf[i][0] = partmp[2];
    parf[i][1] = partmp[3];
    parf[i][2] = partmp[4];
  }
}

cfsetdiag()

void Trk::cfsetdiag ( long int n, double * matr, double value )

noexcept

Definition at line 236 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
    long int i, j, ij;
    --matr;
 
    ij = 0;
    for (i = 1; i <= n; ++i) {
    for (j = 1; j <= i; ++j) {
        ++ij;
        matr[ij] = 0.;
        if (i == j) {
        matr[ij] = value;
        }
    }
    }
}

cfSmallEigenvalue()

double Trk::cfSmallEigenvalue	(	double *	cov,
		long int	n )

Definition at line 450 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
    if (n > 100 || n <= 1) return -1;
    double eig[100];
    vkGetEigVal(cov, eig, n);
 
    return eig[0];
}

cfTrkCovarCorr()

void Trk::cfTrkCovarCorr

(

double *

cov

)

Definition at line 290 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

                                {
//   std::cout<<cov[1]*cov[1]/cov[0]/cov[2]<<'\n';
//   std::cout<<cov[3]*cov[3]/cov[0]/cov[5]<<", "<<cov[4]*cov[4]/cov[2]/cov[5]<<'\n';
//   std::cout<<cov[6]*cov[6]/cov[0]/cov[9]<<", "<<cov[7]*cov[7]/cov[2]/cov[9]<<", "<<cov[8]*cov[8]/cov[5]/cov[9]<<'\n';
//   std::cout<<cov[10]*cov[10]/cov[0]/cov[14]<<", "<<cov[11]*cov[11]/cov[2]/cov[14]<<", "<<cov[12]*cov[12]/cov[5]/cov[14]<<
//        ", "<<cov[13]*cov[13]/cov[9]/cov[14]<<'\n';
   double Lim=0.99; double Lim2=Lim*Lim;
   bool i0,i1,i2,i3,i4; i0=i1=i2=i3=i4=false;
   if( std::abs(cov[1]*cov[1])/cov[0]/cov[2] > Lim2 ){ i0=true; i1=true;}
   if( std::abs(cov[3]*cov[3])/cov[0]/cov[5] > Lim2 ){ i0=true; i2=true;}
   if( std::abs(cov[4]*cov[4])/cov[2]/cov[5] > Lim2 ){ i1=true; i2=true;}
   if( std::abs(cov[6]*cov[6])/cov[0]/cov[9] > Lim2 ){ i0=true; i3=true;}
   if( std::abs(cov[7]*cov[7])/cov[2]/cov[9] > Lim2 ){ i1=true; i3=true;}
   if( std::abs(cov[8]*cov[8])/cov[5]/cov[9] > Lim2 ){ i2=true; i3=true;}
   if( std::abs(cov[10]*cov[10])/cov[0]/cov[14] > Lim2 ){ i0=true; i4=true;}
   if( std::abs(cov[11]*cov[11])/cov[2]/cov[14] > Lim2 ){ i1=true; i4=true;}
   if( std::abs(cov[12]*cov[12])/cov[5]/cov[14] > Lim2 ){ i2=true; i4=true;}
   if( std::abs(cov[13]*cov[13])/cov[9]/cov[14] > Lim2 ){ i3=true; i4=true;}
 
   if(i0){               cov[1]*=Lim;  cov[3]*=Lim;  cov[6]*=Lim;  cov[10]*=Lim; }
   if(i1){ cov[1]*=Lim;                cov[4]*=Lim;  cov[7]*=Lim;  cov[11]*=Lim; }
   if(i2){ cov[3]*=Lim;  cov[4]*=Lim;                cov[8]*=Lim;  cov[12]*=Lim; }
   if(i3){ cov[6]*=Lim;  cov[7]*=Lim;  cov[8]*=Lim;                cov[13]*=Lim; }
   if(i4){ cov[10]*=Lim; cov[11]*=Lim; cov[12]*=Lim; cov[13]*=Lim;               }
}

cfVrtDstSig()

double Trk::cfVrtDstSig	(	VKVertex *	vk,
		bool	UseTrkErr )

Definition at line 33 of file cfVrtDst.cxx.

{
    int i,j,ij,it;
    double parV0[5], covParV0[15];
    double Signif;
 /* ------------------------------------------------------------------- */
 
    double ptot[3]= {0.,0.,0.};
    int NTRK = vk->TrackList.size();
    for ( it=0; it<NTRK; it++) {
        std::array<double, 4>  pp=getCnstParticleMom( vk->TrackList[it].get(), vk );
        ptot[0] += pp[0];
        ptot[1] += pp[1];
        ptot[2] += pp[2];
    }
    double fittedVrt[3]={vk->refIterV[0] + vk->cnstV[0],
                         vk->refIterV[1] + vk->cnstV[1],
             vk->refIterV[2] + vk->cnstV[2]};
    long int Charge = 0; for ( it=0; it<NTRK; it++) Charge += vk->TrackList[it]->Charge;
//std::cout<<" cfVrtDst ntrk="<<NTRK<<" chg="<<Charge<<'\n';
    double localField=Trk::vkalMagFld::getMagFld(fittedVrt,(vk->vk_fitterControl).get());
    if ( UseTrkErr){
      combinedTrack( Charge, ptot, vk->fitCovXYZMom, localField, parV0, covParV0);
    }else{
      double DummyErr[21] = { 1.e-20,
                                  0., 1.e-20,
                  0.,     0., 1.e-20,
                  0.,     0.,     0., 1.e-18,
                  0.,     0.,     0.,     0., 1.e-18,
                  0.,     0.,     0.,     0.,     0., 1.e-18};
      combinedTrack( Charge, ptot, DummyErr, localField, parV0, covParV0);
    }
//
// Propagation to constraint vertex
//
    double nPar[5],nCov[15];
    long int TrkID = -999;   // Abstract track propagation
    Trk::vkalPropagator::Propagate( TrkID, Charge, parV0, covParV0, fittedVrt, vk->FVC.vrt, nPar, nCov, (vk->vk_fitterControl).get());
//
//
    double cnv[2][3];
    cnv[0][0] = -sin(nPar[3]);
    cnv[0][1] =  cos(nPar[3]);
    cnv[0][2] =  0.;
    cnv[1][0] =  sin(nPar[3])/tan(nPar[2]);
    cnv[1][1] =  cos(nPar[3])/tan(nPar[2]);
    cnv[1][2] =  -1.;
//--
    double covImp[3]={0.,0.,0.};
    for( i=0; i<3; i++){
       for( j=0; j<3; j++){
       if(i>=j){ ij=i*(i+1)/2+j; }else{ ij=j*(j+1)/2+i;}
           covImp[0] += cnv[0][i]*vk->FVC.covvrt[ij]*cnv[0][j];
           covImp[1] += cnv[0][i]*vk->FVC.covvrt[ij]*cnv[1][j];
           covImp[2] += cnv[1][i]*vk->FVC.covvrt[ij]*cnv[1][j];
       }
    }
    if ( UseTrkErr){ covImp[0] += nCov[0]; covImp[1] += nCov[1]; covImp[2] += nCov[2];}
 
    double dwgt[3];
    int IERR=cfdinv(covImp, dwgt, -2); if(IERR){ IERR=cfdinv(covImp, dwgt, 2); if(IERR){dwgt[0]=dwgt[2]=1.e6; dwgt[1]=0.;}}
    Signif = sqrt(dwgt[0] * nPar[0] * nPar[0] +  2. * dwgt[1] * nPar[0] * nPar[1] +
                  dwgt[2] * nPar[1] * nPar[1]);
 
//std::cout<<" fittedcov="<<nCov[0]<<", "<<nCov[2]<<'\n';
//std::cout<<"  cfVrtDstSig="<<Signif<<", "<<nPar[0]<<", "<<nPar[1]<<'\n';
    return Signif;
}

combinedTrack()

void Trk::combinedTrack	(	long int	ICH,
		double *	pv0,
		double *	covi,
		double	BMAG,
		double *	par,
		double *	covo )

Definition at line 113 of file XYZtrp.cxx.

{
 
    double cnv[36]; /* was [6][6] */
/* ---------------------------------------------------------- */
/*       Subroutine for convertion for VKalvrtCore            */
/* Correct magnetic field BMAG at conversion point            */
/*  is provided externally.                                   */
/*           (X,Y,Z,PX,PY,PZ) --> (eps,z,theta,phi,1/r)       */
/*       Input:                                               */
/*                 ICH      -  charge of track ( +1,0,-1 )    */
/*                  PV0(3)  -  Momentum of particle           */
/*                 COVI(21) -  simmetric covariance matrix    */
/*       Output:                                              */
/*                 PARO(5)  -  (eps,z,theta,phi,1/r)          */
/*                 ERRT(15) -  simmetric error matrix         */
/*       NO PROPAGATION IS DONE!!!!                           */
/*    For ICH=0  PARO(5) = const/pt                           */
/* Author: V.Kostyukhin                                       */
/* ---------------------------------------------------------- */
 
    double constBF =BMAG * vkalMagCnvCst;
 
    double pt = sqrt(pv0[0]*pv0[0] + pv0[1]*pv0[1]);
    double pp = pt*pt + pv0[2]*pv0[2];
    double cs  = pv0[0] / pt;
    double sn  = pv0[1] / pt;
    double ctg = pv0[2] / pt;
    double rho = ICH * constBF / pt;
    if ( ICH==0 )rho = constBF / pt;
/* --  Output parameters */
    par[0] = 0.;                    /*            (-Yv*cos + Xv*sin) */
    par[1] = 0.;                    /*  Zv - cotth*(Xv*cos + Yv*sin) */
    par[2] = acos(pv0[2] / sqrt(pp));
    if(par[2]<1.e-5)par[2]=1.e-5;
    if(par[2]>M_PI-1.e-5) par[2]=M_PI-1.e-5;
    par[3] = atan2(pv0[1], pv0[0]);
    par[4] = rho;
    if ( ICH==0 )par[4] = constBF / pt;
//
    double dTheta_dPx =  pv0[0]*pv0[2]/(pt*pp);   //dTheta/dPx
    double dTheta_dPy =  pv0[1]*pv0[2]/(pt*pp);   //dTheta/dPy
    double dTheta_dPz = -pt/pp;                   //dTheta/dPz
    double dPhi_dPx   = -pv0[1]/(pt*pt);          //dPhi/dPx
    double dPhi_dPy   =  pv0[0]/(pt*pt);          //dPhi/dPy
    double dPhi_dPz   =             0;            //dPhi/dPz
    double dRho_dPx   = -pv0[0]/(pt*pt) * rho;    //dInvR/dPx
    double dRho_dPy   = -pv0[1]/(pt*pt) * rho;    //dInvR/dPy
    double dRho_dPz   =                    0.;    //dInvR/dPz
//---
    cnv_ref(1, 1) =  sn;
    cnv_ref(2, 1) = -cs;
    cnv_ref(3, 1) =  0.;
    cnv_ref(4, 1) =  0.;
    cnv_ref(5, 1) =  0.;
    cnv_ref(6, 1) =  0.;
 
    cnv_ref(1, 2) = -cs * ctg;
    cnv_ref(2, 2) = -sn * ctg;
    cnv_ref(3, 2) = 1.;
    cnv_ref(4, 2) = 0.;
    cnv_ref(5, 2) = 0.;
    cnv_ref(6, 2) = 0.;
 
    cnv_ref(1, 3) = 0.;
    cnv_ref(2, 3) = 0.;
    cnv_ref(3, 3) = 0.;
    cnv_ref(4, 3) = dTheta_dPx;
    cnv_ref(5, 3) = dTheta_dPy;
    cnv_ref(6, 3) = dTheta_dPz;
 
    cnv_ref(1, 4) = 0.;
    cnv_ref(2, 4) = 0.;
    if(ICH) cnv_ref(1, 4) = -cs * rho; //For charged tracks only
    if(ICH) cnv_ref(2, 4) = -sn * rho; //
    cnv_ref(3, 4) = 0.;
    cnv_ref(4, 4) = dPhi_dPx;
    cnv_ref(5, 4) = dPhi_dPy;
    cnv_ref(6, 4) = dPhi_dPz;
 
    cnv_ref(1, 5) = 0.;
    cnv_ref(2, 5) = 0.;
    cnv_ref(3, 5) = 0.;
    cnv_ref(4, 5) = dRho_dPx;
    cnv_ref(5, 5) = dRho_dPy;
    cnv_ref(6, 5) = dRho_dPz;
    tdasatVK(cnv, covi , covo, 5, 6);
}

consistentSurfaces() [1/2]

template<typename U, typename ... T>

bool Trk::consistentSurfaces	(	U	a,
		T...	b )

Definition at line 23 of file SurfaceConsistencyCheck.h.

                                 {
    if (a==nullptr) return (consistentSurfaces(b...));
    return (((b!=nullptr)?(a->associatedSurface() == b->associatedSurface()):true) and ...);
  }

consistentSurfaces() [2/2]

template<typename U>

bool Trk::consistentSurfaces

(

U

)

Definition at line 17 of file SurfaceConsistencyCheck.h.

                        {
    return true;
  }

copyFullMtx()

void Trk::copyFullMtx	(	const double *	Input,
		long int	IPar,
		long int	IDIM,
		double *	Target,
		long int	TStart,
		long int	TDIM )

Definition at line 246 of file CascadeUtils.cxx.

{
   int i,j,it,jt;
   for( i=0; i<IPar; i++){
     for( j=0; j<IPar; j++){
        it=i+TStart; jt=j+TStart;
        Target[it*TDIM+jt] = Input[i*IDIM+j];
     }
   }
}

d_sign()

double Trk::d_sign ( double value, double sign )

inline

Definition at line 33 of file TrkVKalUtils.h.

    {
      if( value >= 0){
        if (sign >=0) return  value;
        if (sign < 0) return -value;
      }
      if( value < 0){
        if (sign >=0) return -value;
        if (sign < 0) return  value;
      }
      return value;
   }

decomposeTransform()

void Trk::decomposeTransform	(	const Amg::Transform3D &	transform,
		double *	values )

Definition at line 57 of file AlignModule.cxx.

  {
    Amg::Vector3D translation = transform.translation(); 
    values[0]=translation.x(); 
    values[1]=translation.y(); 
    values[2]=translation.z(); 
 
    Amg::RotationMatrix3D rotation = transform.rotation(); 
 
    double sinbeta = rotation(2,0);     
    if(fabs(sinbeta) < 0.99999 ){ 
    
//      double invcosbeta = 1./std::sqrt(1.-sinbeta*sinbeta);
//      double sinalpha = rotation(2,1)*invcosbeta;
//      double singamma = rotation(1,0)*invcosbeta;
//      std::cout << "Alpha " <<  -std::asin(sinalpha) << " " << -std::atan2( -rotation(2,1), rotation(2,2) )<< std::endl;
//      std::cout << "Beta  " <<  -std::asin(sinbeta) <<  " " << std::acos(1./invcosbeta)  << std::endl;
//      std::cout << "Gamma " <<  -std::asin(singamma) << " " << -std::atan2( -rotation(1,0), rotation(0,0 )) << std::endl;
     
      values[3]=-std::atan2( -rotation(2,1), rotation(2,2) ); 
      values[4]=-std::asin(sinbeta); 
      values[5]=-std::atan2( -rotation(1,0), rotation(0,0) ) ; 
      if (values[3] == 0) values[3] = 0; // convert -0 to 0
      if (values[5] == 0) values[5] = 0; // convert -0 to 0
 
   } else {
      double alphaPlusGamma = std::asin( rotation(0,1) );
      values[3] = alphaPlusGamma;     
      values[5] = 0;
      if( sinbeta > 0  ) 
        values[4] = M_PI * 0.5;
      else
        values[4] = -M_PI * 0.5;
   }
 
     }

detTypeStr()

std::string Trk::detTypeStr

(

AlignModule::DetectorType

detType

)

returns the detector type

Definition at line 177 of file AlignModule.cxx.

  {
    std::string typeStr;
    switch (detType) {
    case AlignModule::unidentified: 
      typeStr="none"; break;
    case AlignModule::Pixel:
      typeStr="Pixel"; break;
    case AlignModule::SCT:
      typeStr="SCT"; break;
    case AlignModule::TRT:
      typeStr="TRT"; break;
    case AlignModule::MDT:
      typeStr="MDT"; break;
    case AlignModule::CSC:
      typeStr="CSC"; break;
    case AlignModule::RPC:
      typeStr="RPC"; break;
    case AlignModule::TGC:
      typeStr="TGC"; break;    
    case AlignModule::NDetectorTypes:
      typeStr="NDetectorTypes"; break;
    }
    return typeStr;
  }

dsinv()

void Trk::dsinv ( long int n, double * a, long int DIM, long int * ifail )

noexcept

Definition at line 517 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
    long int a_dim1, a_offset, i__1, i__2, i__3;
    long int i__, j, k, l;
    double s1, s31, s32, s33;
    long int jm1, jm2, jp1;
 
 
    /* Parameter adjustments */
    a_dim1 = DIM;
    a_offset = a_dim1 + 1;
    a -= a_offset;
 
    /* Function Body */
    jp1 = 0;
    *ifail = 0;
    i__1 = n;
    for (j = 1; j <= i__1; ++j) {
    if (a[j + j * a_dim1] <= 0.) {
        goto L150;
    }
    a[j + j * a_dim1] = 1. / a[j + j * a_dim1];
    if (j == n) {
        goto L199;
    }
    jp1 = j + 1;
    i__2 = n;
    for (l = jp1; l <= i__2; ++l) {
        a[j + l * a_dim1] = a[j + j * a_dim1] * a[l + j * a_dim1];
        s1 = -a[l + (j + 1) * a_dim1];
        i__3 = j;
        for (i__ = 1; i__ <= i__3; ++i__) {
        s1 = a[l + i__ * a_dim1] * a[i__ + (j + 1) * a_dim1] + s1;
        }
        a[l + (j + 1) * a_dim1] = -s1;
    }
    }
L150:
    *ifail = -1;
    return;
L199:
 
    if (n == 1) {
    goto L399;
    }
    a[(a_dim1 << 1) + 1] = -a[(a_dim1 << 1) + 1];
    a[a_dim1 + 2] = a[(a_dim1 << 1) + 1] * a[(a_dim1 << 1) + 2];
    if (n == 2) {
    goto L320;
    }
    i__1 = n;
    for (j = 3; j <= i__1; ++j) {
    jm2 = j - 2;
    i__2 = jm2;
    for (k = 1; k <= i__2; ++k) {
        s31 = a[k + j * a_dim1];
        i__3 = jm2;
        for (i__ = k; i__ <= i__3; ++i__) {
        s31 = a[k + (i__ + 1) * a_dim1] * a[i__ + 1 + j * a_dim1] +
            s31;
        }
        a[k + j * a_dim1] = -s31;
        a[j + k * a_dim1] = -s31 * a[j + j * a_dim1];
    }
    a[j - 1 + j * a_dim1] = -a[j - 1 + j * a_dim1];
    a[j + (j - 1) * a_dim1] = a[j - 1 + j * a_dim1] * a[j + j * a_dim1];
    }
L320:
    j = 1;
L323:
    s33 = a[j + j * a_dim1];
    if (j == n) goto L325;
    jp1 = j + 1;
    i__1 = n;
    for (i__ = jp1; i__ <= i__1; ++i__) {
    s33 = a[j + i__ * a_dim1] * a[i__ + j * a_dim1] + s33;
    }
L325:
    a[j + j * a_dim1] = s33;
    jm1 = j;
    j = jp1;
    i__1 = jm1;
    for (k = 1; k <= i__1; ++k) {
    s32 = 0.;
    i__2 = n;
    for (i__ = j; i__ <= i__2; ++i__) {
        s32 = a[k + i__ * a_dim1] * a[i__ + j * a_dim1] + s32;
    }
    a[k + j * a_dim1] = s32;
    a[j + k * a_dim1] = s32;
    }
    if (j < n)  goto L323;
L399:
    return;
}

dumpAlignTrackType()

std::string Trk::dumpAlignTrackType

(

const AlignTrack::AlignTrackType

type

)

Definition at line 410 of file AlignTrack.cxx.

  {
    switch(type) {
      case AlignTrack::Unknown:              return "Unknown";
      case AlignTrack::Original:             return "Original";
      case AlignTrack::NormalRefitted:       return "NormalRefitted";
      case AlignTrack::BeamspotConstrained:  return "BeamspotConstrained";
      case AlignTrack::VertexConstrained:    return "VertexConstrained";
      default:                               return "UNDEFINED";
    }
  }

efdCoef()

void Trk::efdCoef	(	double	Ga0,
		double	Gamb,
		double	Gab,
		double	Gw0,
		double	Gwb,
		double	alf,
		double	bet,
		double	w,
		double &	d,
		double &	e,
		double &	f )

Definition at line 269 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
 
   e = (Gab + Gamb - 2.*Ga0)/bet/bet/2.;
   f = (Gwb + Gamb - 2.*e*bet*bet - Gw0 - Ga0)/bet/(w-alf);
   d = (Gab - Ga0 - e*bet*bet - f*alf*bet)/bet;
}

ErrorScalingCast()

template<typename T_res, typename T_src>

const T_res * Trk::ErrorScalingCast

(

const T_src *

src

)

Definition at line 14 of file ErrorScalingCast.h.

                                                {
 
  if (T_res::s_type != src->type()) {
    std::stringstream message;
    message << "Invalid RIO_OnTrackErrorScaling type. Expected "
            << T_res::s_type << " But Received " << src->type();
 
    throw std::runtime_error(message.str());
  }
  return static_cast<const T_res*>(src);
}

finter()

double Trk::finter	(	double	y0,
		double	y1,
		double	y2,
		double	x0,
		double	x1,
		double	x2 )

Definition at line 128 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
    double ret_val;
    volatile double b1,b2; // To guarantee AMD==Intel
 
/* ------------------------*/
/*  Function interpolation */
/* Author: V.Kostyukhin    */
/* ------------------------*/
    b1 = (y1 - y0) / (x1 - x0);
    b2 = (y2 - y0 - b1 * (x2 - x0)) / (x2 - x0) / (x2 - x1);
    if (std::abs(b2) < 1e-8) {
    if (y2 <= y0 && y2 < y1) {
        ret_val = x2;
    } else if (y1 <= y0 && y1 < y2) {
        ret_val = x1;
    } else if (y0 < y1 && y0 < y2) {
        ret_val = x0 + (x2 - x0) * .001;
    } else {
        ret_val = x2;
    }
    return ret_val;
    }
    ret_val = (x1 + x0) - ( b1 / b2 );
//VK 14.08.2007 Check now is after call of this subroutine
//    double NegativeLim = x0 + (x2 - x0) * (-0.3);
//    if (ret_val <= x0) {
//        if (ret_val <= NegativeLim) ret_val = NegativeLim;
//    }
    return ret_val/2.;
}

fitVertexCascade()

int Trk::fitVertexCascade	(	VKVertex *	vk,
		int	Pointing )

Definition at line 89 of file CFitCascade.cxx.

{
//-------------------------------------------------------------------------
//  Fits single vertex in cascade (no iterations , just a single fit!!!)
//  creates summary track after it and fills corresponding track parameters
//   in next vertex in cascade
//
//   Procedure assumes that "included tracks"(from vertices) are already
//  recalculated in predecessor vertices fits.
//
//   Pointing=0 (false) - for combined track FITTED at vertex parameters are used
//                                           ^^^^^^ better convergence
//   Pointing=1 (true)  - for combined track GUESSED(ini) at GUESSED(ini) vertex
//                        parameters are used together with afterfit error matrix.
//                        It's needed for correct treatment of pointing
//-------------------------------------------------------------------------
//
//  Fit itself. First get magnetic field at iteration reference point
//
   vk->vk_fitterControl->vk_forcft.localbmag=Trk::vkalMagFld::getMagFld(vk->refIterV,(vk->vk_fitterControl).get());
 
 
//
//-------- Check if pointing constraint exists
//
  bool existPointingCnst=false;
  for(int ic=0; ic<(int)vk->ConstraintList.size(); ic++){
    if(vk->ConstraintList[ic]->getType() == VKConstraintType::Point) { existPointingCnst=true; break; }
  }
//
//-------- Then fit
//
   applyConstraints(vk);                                         //apply all constraints in vertex
   int IERR = vtcfit( vk );
   if(IERR) return IERR;
//
//fit vertex once more with resolved constraints to prevent oscillations
//   if(Pointing){
//      double targVrt[3]={vk->refIterV[0] + vk->fitV[0],vk->refIterV[1] + vk->fitV[1],vk->refIterV[2] + vk->fitV[2]};
//      vk->vk_fitterControl->vk_forcft.localbmag=myMagFld.getMagFld(vk->targVrt,(vk->vk_fitterControl).get());
//      vk->setRefIterV(targVrt);
//      vk->iniV[0]=vk->fitV[0]=vk->cnstV[0]=vk->iniV[1]=vk->fitV[1]=vk->cnstV[1]=vk->iniV[2]=vk->fitV[2]=vk->cnstV[2]=0.;
//      for(int it=0; it<(int)vk->TrackList.size(); it++){
//         VKTrack * trk = vk->TrackList[it];
//         trk->cnstP[0] = trk->iniP[0] = trk->fitP[0];   // for constraint calculation on next step
//         trk->cnstP[1] = trk->iniP[1] = trk->fitP[1];
//         trk->cnstP[2] = trk->iniP[2] = trk->fitP[2];
//      }
//      applyConstraints(vk);                                         //apply all constraints in vertex
//      int IERR = vtcfit( vk );
//      if(IERR) return IERR;
//   }
//
//    Fill fitted combined track in next vertex (if needed)
//
   if(vk->nextCascadeVrt){
      FullMTXfill(vk, vk->ader);
      VKTrack * target_trk = getCombinedVTrack(vk);  // get address of combined track
      if( target_trk == nullptr ) return -12;
 
      long int Charge=getVertexCharge(vk);
      if(Charge!=0) Charge=std::copysign(1,Charge);
      target_trk->Charge=Charge;
 
      double dptot[4],VrtMomCov[21];
      double parV0[5],covParV0[15],tmpCov[15],fittedVrt[3];
      if(Pointing){
         IERR = afterFitWithIniPar( vk, vk->ader, vk->FVC.dcv, dptot, VrtMomCov, (vk->vk_fitterControl).get());
         fittedVrt[0]=vk->refIterV[0]+vk->iniV[0];
         fittedVrt[1]=vk->refIterV[1]+vk->iniV[1];
         fittedVrt[2]=vk->refIterV[2]+vk->iniV[2];
      }
      else{
         IERR = afterFit( vk, vk->ader, vk->FVC.dcv, dptot, VrtMomCov, (vk->vk_fitterControl).get());
         fittedVrt[0]=vk->refIterV[0]+vk->fitV[0];
         fittedVrt[1]=vk->refIterV[1]+vk->fitV[1];
         fittedVrt[2]=vk->refIterV[2]+vk->fitV[2];
      }
      if (IERR) return -13;                        /* NONINVERTIBLE COV.MATRIX */
      cfdcopy(    dptot, vk->fitMom, 3);          //save Momentum
      cfdcopy(VrtMomCov, vk->fitCovXYZMom, 21);   //save XYZMom covariance
//
//-- Solution (not ideal!) of cascade covariance problem.
//-- Covariance of pseudo-particle must be calculated WITHOUT pointing constraint ALWAYS!.
//
//      if(existPointingCnst){   // use saved matrix without pointing constraint
//        cfdcopy( vk->savedVrtMomCov, VrtMomCov, 21);
//      }else{                   // save computed matrix for further use
//        cfdcopy( VrtMomCov, vk->savedVrtMomCov, 21);
//      }
      if(existPointingCnst){   // add pointed vertex covariance to track
        for(int km=0; km<6; km++) VrtMomCov[km] += vk->nextCascadeVrt->fitCovXYZMom[km];
        if(vk->nextCascadeVrt->TrackList[0]->Id>0){ //There is at least one real track in this vertex
          VrtMomCov[0]  *= 1000.;
          VrtMomCov[2]  *= 1000.;
          VrtMomCov[5]  *= 1000.;
          VrtMomCov[9]  *= 1000.;
          VrtMomCov[14] *= 1000.;
          VrtMomCov[20] *= 1000.;
        }
      }
//
//  Particle creation and propagation
      double localField=Trk::vkalMagFld::getMagFld(fittedVrt,(vk->vk_fitterControl).get());
      combinedTrack( Charge, dptot, VrtMomCov, localField, parV0, covParV0);
      covParV0[0]=std::abs(covParV0[0]); covParV0[2]=std::abs(covParV0[2]); covParV0[5]=std::abs(covParV0[5]);
      covParV0[9]=std::abs(covParV0[9]); covParV0[14]=std::abs(covParV0[14]);  //VK protection against numerical problems
      Trk::vkalPropagator::Propagate(-999, Charge, parV0, covParV0, fittedVrt,
                vk->nextCascadeVrt->refIterV, target_trk->Perig, tmpCov, (vk->vk_fitterControl).get());
//    IERR=cfInv5(tmpCov, target_trk->WgtM);  if (IERR) IERR=cfdinv(tmpCov, target_trk->WgtM, 5);
//      target_trk->iniP[0]=target_trk->cnstP[0]=target_trk->fitP[0]=target_trk->Perig[2];   //initial guess
//      target_trk->iniP[1]=target_trk->cnstP[1]=target_trk->fitP[1]=target_trk->Perig[3];
//      target_trk->iniP[2]=target_trk->cnstP[2]=target_trk->fitP[2]=target_trk->Perig[4];
      if( target_trk->fitP[2] == 0.){
        target_trk->iniP[0]=target_trk->cnstP[0]=target_trk->Perig[2];   //initial guess
        target_trk->iniP[1]=target_trk->cnstP[1]=target_trk->Perig[3];
        target_trk->iniP[2]=target_trk->cnstP[2]=target_trk->Perig[4];
      }else if(Pointing){
        target_trk->iniP[0]=target_trk->cnstP[0]=target_trk->fitP[0];   //initial guess
        target_trk->iniP[1]=target_trk->cnstP[1]=target_trk->fitP[1];
        target_trk->iniP[2]=target_trk->cnstP[2]=target_trk->fitP[2];
      }else{
        target_trk->iniP[0]=target_trk->cnstP[0]=(target_trk->fitP[0]+target_trk->Perig[2])/2.;   //initial guess
        target_trk->iniP[1]=target_trk->cnstP[1]=(target_trk->fitP[1]+target_trk->Perig[3])/2.;
        target_trk->iniP[2]=target_trk->cnstP[2]=(target_trk->fitP[2]+target_trk->Perig[4])/2.;
      }
      if(tmpCov[0]>1.e12 || tmpCov[2]>1.e12) return -18; //Something is wrong in combined track creation
      if(Pointing){tmpCov[0] += target_trk->Perig[0]*target_trk->Perig[0]; tmpCov[2] += target_trk->Perig[1]*target_trk->Perig[1];}
      tmpCov[0] += 0.0001*0.0001; tmpCov[2] += 0.0002*0.0002;  //numerical accuracy protection
 
      IERR=cfInv5(tmpCov, target_trk->WgtM);  if (IERR) IERR=cfdinv(tmpCov, target_trk->WgtM, 5);
      if (IERR) return -15;                        /* NONINVERTIBLE COV.MATRIX */
   }
//
// For passing near vertex constraint. Normally first(mother) vertex of cascade
//   Now used also for "close to vertex" mode for cascade
//   For last in structure (mother in cascade...) always calculate it - needed for pointing
//
   CascadeEvent & cascadeEvent_ = *(vk->vk_fitterControl->getCascadeEvent());
   if( vk->passNearVertex || vk==cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1].get()){
      double dptot[4],VrtMomCov[21];
      IERR = afterFit( vk, vk->ader, vk->FVC.dcv, dptot, VrtMomCov, (vk->vk_fitterControl).get());
      if (IERR) return -13;                        /* NONINVERTIBLE COV.MATRIX */
      cfdcopy(    dptot, vk->fitMom, 3);          //save Momentum
      cfdcopy(VrtMomCov, vk->fitCovXYZMom, 21);   //save XYZMom covariance
   }
   return 0;
}

fitVertexCascadeScale()

int Trk::fitVertexCascadeScale	(	VKVertex *	vk,
		double &	distToVertex )

Definition at line 44 of file CFitCascadeScale.cxx.

{
//-------------------------------------------------------------------------
//  Fits single vertex in cascade (no iterations , just a single fit!!!)
//  creates summary track after it and fills corresponding track parameters
//   in next vertex in cascade
//
//   "Near to vertex" pointing is used here with decreasing vertex errors
//
//   Procedure assumes that "included tracks"(from vertices) are already
//  recalculated in predecessor vertices fits.
//
//  Fit itself. First get magnetic field at iteration reference point
//
   distToVertex = 0.;
   vk->vk_fitterControl->vk_forcft.localbmag=Trk::vkalMagFld::getMagFld(vk->refIterV,(vk->vk_fitterControl).get());
 
 
//
//-------- Then fit
//
   applyConstraints(vk);                                         //apply all constraints in vertex
   int IERR = vtcfit( vk );
   if(IERR) return IERR;
//
//
//    Fill fitted combined track in next vertex (if needed)
//
   double dptot[4],VrtMomCov[21];
   IERR = afterFit( vk, vk->ader, vk->FVC.dcv, dptot, VrtMomCov, (vk->vk_fitterControl).get());
   if (IERR) return -13;                        /* NONINVERTIBLE COV.MATRIX */
   cfdcopy(    dptot, vk->fitMom, 3);          //save Momentum
   cfdcopy(VrtMomCov, vk->fitCovXYZMom, 21);   //save XYZMom covariance
   vk->FVC.Charge=getVertexCharge(vk);
   if(vk->FVC.Charge!=0)vk->FVC.Charge=std::copysign(1,vk->FVC.Charge);
//
   if(vk->nextCascadeVrt){
      FullMTXfill(vk, vk->ader);
      VKTrack * target_trk = getCombinedVTrack(vk);  // get address of combined track
      if( target_trk == nullptr ) return -12;
 
      long int Charge=getVertexCharge(vk);
      if(Charge!=0)Charge=std::copysign(1,Charge);
      target_trk->Charge=Charge;
 
      double parV0[5],covParV0[15],tmpCov[15],fittedVrt[3];
      fittedVrt[0]=vk->refIterV[0]+vk->fitV[0];
      fittedVrt[1]=vk->refIterV[1]+vk->fitV[1];
      fittedVrt[2]=vk->refIterV[2]+vk->fitV[2];
//
//  Particle creation and propagation
      double localField=Trk::vkalMagFld::getMagFld(fittedVrt,(vk->vk_fitterControl).get());
      combinedTrack( Charge, dptot, VrtMomCov, localField, parV0, covParV0);
      covParV0[0]=std::abs(covParV0[0]); covParV0[2]=std::abs(covParV0[2]); covParV0[5]=fabs(covParV0[5]);
      covParV0[9]=std::abs(covParV0[9]); covParV0[14]=std::abs(covParV0[14]);  //VK protection against numerical problems
      Trk::vkalPropagator::Propagate(-999, Charge, parV0, covParV0, fittedVrt,
                vk->nextCascadeVrt->refIterV, target_trk->Perig, tmpCov, (vk->vk_fitterControl).get());
//std::cout<<"testR,Z="<<target_trk->Perig[0]<<", "<<target_trk->Perig[1]<<'\n';
      distToVertex = sqrt(target_trk->Perig[0]*target_trk->Perig[0]+target_trk->Perig[1]*target_trk->Perig[1]);
      target_trk->iniP[0]=target_trk->cnstP[0]=target_trk->Perig[2];   //initial guess
      target_trk->iniP[1]=target_trk->cnstP[1]=target_trk->Perig[3];
      target_trk->iniP[2]=target_trk->cnstP[2]=target_trk->Perig[4];
      IERR=cfInv5(tmpCov, target_trk->WgtM);  if (IERR) IERR=cfdinv(tmpCov, target_trk->WgtM, 5);
      if (IERR) return -15;                        /* NONINVERTIBLE COV.MATRIX */
      for(int im=0; im<15; im++)target_trk->WgtM[im] /= vk->vk_fitterControl->getCascadeEvent()->getSCALE();   // Tighten pseudotrack errors
   }
//
// Save refitted vertex position as target for predecessors
   if(!vk->includedVrt.empty()){  // Save fitted vertex as target for "pass near" constraint in previous vertex
      for(int pseu=0; pseu<(int)vk->includedVrt.size(); pseu++){
//         vk->includedVrt[pseu]->FVC.vrt[0] = (vk->refIterV[0] + vk->fitV[0] + vk->includedVrt[pseu]->FVC.vrt[0])/2.;
//         vk->includedVrt[pseu]->FVC.vrt[1] = (vk->refIterV[1] + vk->fitV[1] + vk->includedVrt[pseu]->FVC.vrt[1])/2.;
//         vk->includedVrt[pseu]->FVC.vrt[2] = (vk->refIterV[2] + vk->fitV[2] + vk->includedVrt[pseu]->FVC.vrt[2])/2.;
         vk->includedVrt[pseu]->FVC.vrt[0] = vk->refIterV[0] + vk->fitV[0];
         vk->includedVrt[pseu]->FVC.vrt[1] = vk->refIterV[1] + vk->fitV[1];
         vk->includedVrt[pseu]->FVC.vrt[2] = vk->refIterV[2] + vk->fitV[2];
      }
   }
   return 0;
}

fixPseudoTrackPt()

int Trk::fixPseudoTrackPt	(	long int	NPar,
		double *	fullMtx,
		double *	LSide,
		CascadeEvent &	cascadeEvent_ )

Definition at line 18 of file CascadeUtils.cxx.

{
 
   int iv,it,ivnext;
   //Deliberately not make_unique to bypass inititalization
   std::unique_ptr<double[]> DerivC( new double[NPar] );
   std::unique_ptr<double[]> DerivP( new double[NPar] );
   std::unique_ptr<double[]> DerivT( new double[NPar] );
//
   std::vector<double> vMagFld; double vBx,vBy,vBz;
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
      VKVertex * vk = cascadeEvent_.cascadeVertexList[iv].get();
      Trk::vkalMagFld::getMagFld(vk->refIterV[0]+vk->iniV[0], vk->refIterV[1]+vk->iniV[1], vk->refIterV[2]+vk->iniV[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
      vMagFld.push_back(vBz);  // fill mag.fields for all vertices
   }
//
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
      int indCombTrk=-1;
      int iniPosTrk=0;                              /* Start of track part of vertex in global matrix */
      int posCombTrk=0;                             /* Conbined track position in global matrix */
      VKVertex* vk = cascadeEvent_.cascadeVertexList[iv].get();
      if(vk->nextCascadeVrt){                           //next vertex exists
        ivnext=-1;                                      //index of next vertex in common structure
        for(int ivt=0;ivt<cascadeEvent_.cascadeNV;ivt++)if(vk->nextCascadeVrt==cascadeEvent_.cascadeVertexList[ivt].get())ivnext=ivt;
        if(ivnext<0){return -1;};  //error in cascade
//
        int NV=vk->nextCascadeVrt->includedVrt.size();
        if(NV>0){
          for(it=0; it<NV; it++)
        if(vk->nextCascadeVrt->includedVrt[it] == vk)
              indCombTrk=vk->nextCascadeVrt->TrackList.size() - NV + it;   // index of combined track in next vertex track list
        }
        if(indCombTrk>=0){
          iniPosTrk  =cascadeEvent_.matrixPnt[iv]+3;  /*Start of track part of vertex in global matrix */
          posCombTrk =cascadeEvent_.matrixPnt[ivnext]+3+3*indCombTrk;  /*Get position in global matrix */
        }
        if(posCombTrk==0 || iniPosTrk==0) {return -1;}  //ERROR  in cascade structure somewhere....
//
// Momentum of pseudo track in next vertex
        for(int ivt=0; ivt<NPar; ivt++)DerivC[ivt]=DerivP[ivt]=DerivT[ivt]=0.;
        DerivC[posCombTrk+2]=-1.;
        DerivT[posCombTrk+0]=-1.;
        DerivP[posCombTrk+1]=-1.;
        std::array<double, 4> ppsum = getIniParticleMom( vk->nextCascadeVrt->TrackList[indCombTrk].get(), vMagFld[ivnext] ); // INI for pseudo
        double csum=vk->nextCascadeVrt->TrackList[indCombTrk]->iniP[2];                                              // INI for pseudo
        double ptsum=sqrt(ppsum[0]*ppsum[0] + ppsum[1]*ppsum[1]);
        double sinth2sum=(ppsum[0]*ppsum[0] + ppsum[1]*ppsum[1])/(ppsum[0]*ppsum[0] + ppsum[1]*ppsum[1] + ppsum[2]*ppsum[2]);
 
//
// Momenta+Derivatives of tracks in vertex itself
  for(it=0; it<(int)vk->TrackList.size(); it++){
    std::array<double, 4> pp =    getIniParticleMom( vk->TrackList[it].get(), vMagFld[iv]);
      double curv=vk->TrackList[it]->iniP[2];
    double pt=sqrt(pp[0]*pp[0] + pp[1]*pp[1]);
    double cth=pp[2]/pt;
    double sinth2=(pp[0]*pp[0] + pp[1]*pp[1])/(pp[0]*pp[0] + pp[1]*pp[1] + pp[2]*pp[2]);
    DerivC[iniPosTrk+it*3+1] =  csum/ptsum/ptsum*(ppsum[0]*pp[1]-ppsum[1]*pp[0]);         //  dC/dPhi_i
    DerivC[iniPosTrk+it*3+2] =  csum/ptsum/ptsum*(ppsum[0]*pp[0]+ppsum[1]*pp[1])/curv;    //  dC/dC_i
    DerivP[iniPosTrk+it*3+1] =  (ppsum[0]*pp[0]+ppsum[1]*pp[1])/ptsum/ptsum;           //  dPhi/dPhi_i
    DerivP[iniPosTrk+it*3+2] =  (ppsum[1]*pp[0]-ppsum[0]*pp[1])/ptsum/ptsum/curv;      //  dPhi/dC_i
    DerivT[iniPosTrk+it*3+0] =  (sinth2sum*pt)/(sinth2*ptsum);                   //  dTheta/dTheta_i
    DerivT[iniPosTrk+it*3+2] =  (sinth2sum*pt*cth)/(curv*ptsum);                 //  dTheta/dC_i
  }
//        double iniV0Curv=myMagFld.getCnvCst()*vMagFld[iv]/sqrt(tpx*tpx+tpy*tpy);    //initial PseudoTrack Curvature
//        if(csum<0)iniV0Curv *= -1.;
//        iniV0Curv *= vMagFld[ivnext]/vMagFld[iv];  //magnetic field correction
//
//fill Full Matrix and left side vector
//
//---- Momentum only
//        for(it=0; it<NPar; it++) fullMtx[ (NPar-1*(cascadeEvent_.cascadeNV-1)+1*iv  )*NPar + it] = DerivC[it];
//        for(it=0; it<NPar; it++) fullMtx[ (NPar-1*(cascadeEvent_.cascadeNV-1)+1*iv  ) + it*NPar] = DerivC[it];
//        LSide[ NPar-1*(cascadeEvent_.cascadeNV-1)+1*iv] = -iniV0Curv+csum;
//---- Momentum+phi+theta //VK seems overshooting because direction is fixed by vertex-vertex pointing. Returns wrong error matrix
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv  )*NPar + it] = DerivT[it];
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+1)*NPar + it] = DerivP[it];
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+2)*NPar + it] = DerivC[it];
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv  ) + it*NPar] = DerivT[it];
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+1) + it*NPar] = DerivP[it];
        for(it=0; it<NPar; it++) fullMtx[ (NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+2) + it*NPar] = DerivC[it];
        VKTrack* cmbt=vk->nextCascadeVrt->TrackList[indCombTrk].get();
        LSide[ NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv  ] = cmbt->iniP[0]-cmbt->Perig[2];
        LSide[ NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+1] = cmbt->iniP[1]-cmbt->Perig[3];
        LSide[ NPar-3*(cascadeEvent_.cascadeNV-1)+3*iv+2] = cmbt->iniP[2]-cmbt->Perig[4];
      }
 
   } //end of vertex cycle
   return 0;  //All ok
}

FullMCNSTfill()

int Trk::FullMCNSTfill	(	VKVertex *	vk,
		double *	ader,
		double *	LSide )

Definition at line 81 of file FullMtx.cxx.

{
    int i,j,k,l,ii,ic,it,jt;
 
    int totNC=0;  //total number of constraints
    for(i=0; i<(int)vk->ConstraintList.size();i++)totNC += vk->ConstraintList[i]->NCDim;
 
    int NTRK = vk->TrackList.size();
    int NPar = 3*NTRK+3+totNC;
//    int NPar=3*NTrkM+3;
 
    for (i=0; i<NPar; i++) { for (j=0; j<NPar; j++) ader[i+j*NPar]=0.; }
    std::vector<std::vector< const Vect3DF*> > tf0t;  // derivative collectors
    std::vector< const Vect3DF* >              th0t;  // derivative collectors
    std::vector< double >               taa;   // derivative collectors
    std::vector< const Vect3DF* > tmpVec;
    for(ii=0; ii<(int)vk->ConstraintList.size();ii++){
       for(ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
         taa.push_back(  vk->ConstraintList[ii]->aa[ic] );
         th0t.push_back( &(vk->ConstraintList[ii]->h0t[ic]) );
         tmpVec.clear();
         tmpVec.reserve(vk->ConstraintList[ii]->f0t.size());
         for(it=0; it<(int)vk->ConstraintList[ii]->f0t.size(); it++){
        tmpVec.push_back( &(vk->ConstraintList[ii]->f0t[it][ic]) );
         }
     tf0t.push_back( std::move(tmpVec) );
       }
    }
//-----------------------------------------------------------------------------
    ader[0*NPar+ 0] += vk->wa[0];
    ader[0*NPar+ 1] += vk->wa[1];
    ader[1*NPar+ 1] += vk->wa[2];
    ader[0*NPar+ 2] += vk->wa[3];
    ader[1*NPar+ 2] += vk->wa[4];
    ader[2*NPar+ 2] += vk->wa[5];
    ader[1*NPar+ 0]  = ader[0*NPar+ 1];
    ader[2*NPar+ 0]  = ader[0*NPar+ 2];
    ader[2*NPar+ 1]  = ader[1*NPar+ 2];
 
 
    for (it=0; it<NTRK; ++it) {
    ader[0 + (it*3 + 3)*NPar] += vk->tmpArr[it]->wb[0];
    ader[1 + (it*3 + 3)*NPar] += vk->tmpArr[it]->wb[1];
    ader[2 + (it*3 + 3)*NPar] += vk->tmpArr[it]->wb[2];
    ader[0 + (it*3 + 4)*NPar] += vk->tmpArr[it]->wb[3];
    ader[1 + (it*3 + 4)*NPar] += vk->tmpArr[it]->wb[4];
    ader[2 + (it*3 + 4)*NPar] += vk->tmpArr[it]->wb[5];
    ader[0 + (it*3 + 5)*NPar] += vk->tmpArr[it]->wb[6];
    ader[1 + (it*3 + 5)*NPar] += vk->tmpArr[it]->wb[7];
    ader[2 + (it*3 + 5)*NPar] += vk->tmpArr[it]->wb[8];
    }
 
    for (it=0; it<NTRK; ++it) {
    ader[(it*3 + 3) + (it*3 + 3)*NPar] += vk->tmpArr[it]->wc[0];
    ader[(it*3 + 3) + (it*3 + 4)*NPar] += vk->tmpArr[it]->wc[1];
    ader[(it*3 + 4) + (it*3 + 4)*NPar] += vk->tmpArr[it]->wc[2];
    ader[(it*3 + 3) + (it*3 + 5)*NPar] += vk->tmpArr[it]->wc[3];
    ader[(it*3 + 4) + (it*3 + 5)*NPar] += vk->tmpArr[it]->wc[4];
    ader[(it*3 + 5) + (it*3 + 5)*NPar] += vk->tmpArr[it]->wc[5];
    ader[(it*3 + 4) + (it*3 + 3)*NPar] += vk->tmpArr[it]->wc[1];
    ader[(it*3 + 5) + (it*3 + 3)*NPar] += vk->tmpArr[it]->wc[3];
    ader[(it*3 + 5) + (it*3 + 4)*NPar] += vk->tmpArr[it]->wc[4];
    }
/* symmetrisation */
    for (i=0; i<NPar-1; i++) {
    for (j=i+1; j<NPar; ++j) {
        ader[j + i*NPar] = ader[i + j*NPar];
    }
    }
//
//  For "passing near" constraint
    if (vk->passNearVertex){
      double drdpy[2][3],dpipj[3][3];
      for (it = 0; it < NTRK; ++it) {
    drdpy[0][0] = vk->tmpArr[it]->drdp[0][0] * vk->FVC.ywgt[0] + vk->tmpArr[it]->drdp[1][0] * vk->FVC.ywgt[1];
        drdpy[1][0] = vk->tmpArr[it]->drdp[0][0] * vk->FVC.ywgt[1] + vk->tmpArr[it]->drdp[1][0] * vk->FVC.ywgt[2];
    drdpy[0][1] = vk->tmpArr[it]->drdp[0][1] * vk->FVC.ywgt[0] + vk->tmpArr[it]->drdp[1][1] * vk->FVC.ywgt[1];
    drdpy[1][1] = vk->tmpArr[it]->drdp[0][1] * vk->FVC.ywgt[1] + vk->tmpArr[it]->drdp[1][1] * vk->FVC.ywgt[2];
    drdpy[0][2] = vk->tmpArr[it]->drdp[0][2] * vk->FVC.ywgt[0] + vk->tmpArr[it]->drdp[1][2] * vk->FVC.ywgt[1];
    drdpy[1][2] = vk->tmpArr[it]->drdp[0][2] * vk->FVC.ywgt[1] + vk->tmpArr[it]->drdp[1][2] * vk->FVC.ywgt[2];
    for (jt = 0; jt < NTRK; ++jt) {   /* Matrix */
            for (k=0; k<3; ++k) {
            for (l=0; l<3; ++l) {
                dpipj[k][l] = 0.;
                for (j=0; j<2; ++j) {
                dpipj[k][l] +=  vk->tmpArr[jt]->drdp[j][k] * drdpy[j][l];
                }
            }
            }
            for (k=0; k<3; ++k) {
            for (l=0; l<3; ++l) {
                ader[(it*3+3 +k) +  (jt*3+3 +l)*NPar] += dpipj[l][k];
            }
            }
    } // jt cycle
      }   // it cycle
    }
//
//   Part for lagrange multipliers
//
    int NTrP=NTRK*3 + 3; // track part of matrix
    for(ic=0; ic<totNC; ic++){
       ader[(0)      + (NTrP+ic)*NPar] = -2.*th0t[ic]->X;
       ader[(1)      + (NTrP+ic)*NPar] = -2.*th0t[ic]->Y;
       ader[(2)      + (NTrP+ic)*NPar] = -2.*th0t[ic]->Z;
       ader[(0)*NPar + (NTrP+ic)     ] = -2.*th0t[ic]->X;
       ader[(1)*NPar + (NTrP+ic)     ] = -2.*th0t[ic]->Y;
       ader[(2)*NPar + (NTrP+ic)     ] = -2.*th0t[ic]->Z;
       for (it=0; it<NTRK; ++it) {
         ader[(it*3+3+0)      + (NTrP+ic)*NPar] = - 2.*tf0t[ic][it]->X;
         ader[(it*3+3+1)      + (NTrP+ic)*NPar] = - 2.*tf0t[ic][it]->Y;
         ader[(it*3+3+2)      + (NTrP+ic)*NPar] = - 2.*tf0t[ic][it]->Z;
         ader[(it*3+3+0)*NPar + (NTrP+ic)]      = - 2.*tf0t[ic][it]->X;
         ader[(it*3+3+1)*NPar + (NTrP+ic)]      = - 2.*tf0t[ic][it]->Y;
         ader[(it*3+3+2)*NPar + (NTrP+ic)]      = - 2.*tf0t[ic][it]->Z;
       }
    }
//
//  Left part
//
//    double *LSide = new double[NPar];
    LSide[0]=vk->T[0];
    LSide[1]=vk->T[1];
    LSide[2]=vk->T[2];
    for (it=0; it<NTRK; ++it) {
       LSide[it*3+3+0]=vk->tmpArr[it]->tt[0];
       LSide[it*3+3+1]=vk->tmpArr[it]->tt[1];
       LSide[it*3+3+2]=vk->tmpArr[it]->tt[2];
    }
    for(ic=0; ic<totNC; ic++){
       LSide[NTRK*3+3+ic]=taa[ic];
    }
//--------------------------------------------------
    //int IERR = vkMSolve(ader, LSide, NPar);
    //std::cout<<"global="<<NPar<<" err="<<IERR<<'\n';
    //std::cout<<" Vrt="<<LSide[0]<<", "<<LSide[1]<<", "<<LSide[2]<<'\n';
    //for(it=0; it<NTRK; it++)std::cout<<" trk="<<LSide[it*3+3+0]<<", "
    //                      <<LSide[it*3+3+1]<<", "<<LSide[it*3+3+2]<<'\n';
    return NPar;
}

FullMTXfill()

void Trk::FullMTXfill	(	VKVertex *	vk,
		double *	ader )

Definition at line 19 of file FullMtx.cxx.

{
    int i,j,it;
 
    int NTRK = vk->TrackList.size();
    int NPar=3*NTRK+3;
 
    for (i=0; i<NPar; i++) { for (j=0; j<NPar; j++) { ader_ref(i, j)=0.;} }
 
    ader_ref(0, 0) += vk->wa[0];
    ader_ref(0, 1) += vk->wa[1];
    ader_ref(1, 1) += vk->wa[2];
    ader_ref(0, 2) += vk->wa[3];
    ader_ref(1, 2) += vk->wa[4];
    ader_ref(2, 2) += vk->wa[5];
    ader_ref(1, 0)  = ader_ref(0, 1);
    ader_ref(2, 0)  = ader_ref(0, 2);
    ader_ref(2, 1)  = ader_ref(1, 2);
 
 
    for (it=0; it<NTRK; ++it) {
      ader_ref(0, it*3 + 3) += vk->tmpArr[it]->wb[0];
      ader_ref(1, it*3 + 3) += vk->tmpArr[it]->wb[1];
      ader_ref(2, it*3 + 3) += vk->tmpArr[it]->wb[2];
      ader_ref(0, it*3 + 4) += vk->tmpArr[it]->wb[3];
      ader_ref(1, it*3 + 4) += vk->tmpArr[it]->wb[4];
      ader_ref(2, it*3 + 4) += vk->tmpArr[it]->wb[5];
      ader_ref(0, it*3 + 5) += vk->tmpArr[it]->wb[6];
      ader_ref(1, it*3 + 5) += vk->tmpArr[it]->wb[7];
      ader_ref(2, it*3 + 5) += vk->tmpArr[it]->wb[8];
    }
 
    for (it=0; it<NTRK; ++it) {
      ader_ref(it*3 + 3, it*3 + 3) += vk->tmpArr[it]->wc[0];
      ader_ref(it*3 + 3, it*3 + 4) += vk->tmpArr[it]->wc[1];
      ader_ref(it*3 + 4, it*3 + 4) += vk->tmpArr[it]->wc[2];
      ader_ref(it*3 + 3, it*3 + 5) += vk->tmpArr[it]->wc[3];
      ader_ref(it*3 + 4, it*3 + 5) += vk->tmpArr[it]->wc[4];
      ader_ref(it*3 + 5, it*3 + 5) += vk->tmpArr[it]->wc[5];
      ader_ref(it*3 + 4, it*3 + 3) += vk->tmpArr[it]->wc[1];
      ader_ref(it*3 + 5, it*3 + 3) += vk->tmpArr[it]->wc[3];
      ader_ref(it*3 + 5, it*3 + 4) += vk->tmpArr[it]->wc[4];
    }
/* symmetrisation */
    for (i=0; i<NPar-1; i++) {
      for (j=i+1; j<NPar; ++j) {
        ader_ref(j, i) = ader_ref(i, j);
      }
    }
//std::cout<<" FULLMTX NEW="<<ader_ref(0, 0)<<", "<<ader_ref(1, 1)<<", "<<ader_ref(2, 2)<<", "
//                          <<ader_ref(3, 3)<<", "<<ader_ref(4, 4)<<", "<<ader_ref(5, 5)<<", "
//                          <<ader_ref(0, 3)<<", "<<ader_ref(1, 4)<<", "<<ader_ref(3, 5)<<'\n';
}

getCascadeNPar()

int Trk::getCascadeNPar	(	CascadeEvent &	cascadeEvent_,
		int	Type )

Definition at line 133 of file CascadeUtils.cxx.

{
  int NV=cascadeEvent_.cascadeNV;
  int NTrk=0;
  int NCnst=0;
  for( int iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     VKVertex *vk = cascadeEvent_.cascadeVertexList[iv].get();
     NTrk += vk->TrackList.size();
     for(int ic=0; ic<(int)vk->ConstraintList.size();ic++) NCnst += vk->ConstraintList[ic]->NCDim;
  }
  if(Type==1) return 3*(NV+NTrk);                              // Return amount of physics parameters
  return 3*(NV+NTrk)+NCnst + 3*(cascadeEvent_.cascadeNV-1);  //additional 3 momentum constraints
  //return 3*(NV+NTrk)+NCnst + 1*(cascadeEvent_.cascadeNV-1);    //additional 1 momentum constraints
}

getCnstParticleMom() [1/2]

std::array< double, 4 > Trk::getCnstParticleMom	(	const VKTrack *	trk,
		const VKVertex *	vk )

Definition at line 96 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double cnstPos[3];
    cnstPos[0]=vk->refIterV[0]+vk->cnstV[0];
    cnstPos[1]=vk->refIterV[1]+vk->cnstV[1];
    cnstPos[2]=vk->refIterV[2]+vk->cnstV[2];
    double vBx,vBy,vBz,magConst;
    Trk::vkalMagFld::getMagFld(cnstPos[0],cnstPos[1],cnstPos[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
    magConst = Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->cnstP[1], trk->cnstP[0]) * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->cnstP[0]);
    double phi      =      trk->cnstP[1];
    double pt       = std::abs( magConst/trk->cnstP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getCnstParticleMom() [2/2]

std::array< double, 4 > Trk::getCnstParticleMom	(	const VKTrack *	trk,
		double	effectiveBMAG )

Definition at line 117 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst = effectiveBMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->cnstP[0]);
    double phi      =      trk->cnstP[1];
    double pt       = std::abs( magConst/trk->cnstP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getCnstValues2()

double Trk::getCnstValues2 ( VKVertex * vk )

noexcept

Definition at line 244 of file VtCFitC.cxx.

{
    if (vk->ConstraintList.empty()) return 0.;
    double sumSQ=0.;
    for(int ii=0; ii<(int)vk->ConstraintList.size();ii++){
       for(int ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
         sumSQ +=  (vk->ConstraintList[ii]->aa[ic])*(vk->ConstraintList[ii]->aa[ic]);
       }
    }
    return sumSQ;
}

getCombinedVTrack()

VKTrack * Trk::getCombinedVTrack

(

VKVertex *

vk

)

Definition at line 110 of file CascadeUtils.cxx.

{
    if(!vk->nextCascadeVrt) return nullptr;                 //nonpointing vertex
    int NV=vk->nextCascadeVrt->includedVrt.size();
    if(NV==0) return nullptr;                               //Error in structure
 
    int itv=-1;
    for(int it=0; it<NV; it++) if(vk->nextCascadeVrt->includedVrt[it] == vk) {itv=it; break;};
    if(itv<0) return nullptr;                               // Not found in list
 
    int totNT = vk->nextCascadeVrt->TrackList.size();
    return vk->nextCascadeVrt->TrackList[totNT - NV + itv].get(); // pointer to combined track in next vertex
}

getFitParticleMom() [1/2]

std::array< double, 4 > Trk::getFitParticleMom	(	const VKTrack *	trk,
		const VKVertex *	vk )

Definition at line 25 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double fieldPos[3];
    fieldPos[0]=vk->refIterV[0]+vk->fitV[0];
    fieldPos[1]=vk->refIterV[1]+vk->fitV[1];
    fieldPos[2]=vk->refIterV[2]+vk->fitV[2];
    double vBx,vBy,vBz,magConst;
    Trk::vkalMagFld::getMagFld(fieldPos[0], fieldPos[1], fieldPos[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
    magConst = Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->fitP[1], trk->fitP[0]) * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->fitP[0]);
    double phi      = trk->fitP[1];
    double pt       = std::abs( magConst/trk->fitP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getFitParticleMom() [2/2]

std::array< double, 4 > Trk::getFitParticleMom	(	const VKTrack *	trk,
		double	effectiveBMAG )

Definition at line 46 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst = effectiveBMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->fitP[0]);
    double phi      = trk->fitP[1];
    double pt       = std::abs( magConst/trk->fitP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getFittedCascade()

void Trk::getFittedCascade	(	CascadeEvent &	cascadeEvent_,
		std::vector< Vect3DF > &	cVertices,
		std::vector< std::vector< double > > &	covVertices,
		std::vector< std::vector< VectMOM > > &	fittedParticles,
		std::vector< std::vector< double > > &	cascadeCovar,
		std::vector< double > &	particleChi2,
		std::vector< double > &	fullCovar )

Definition at line 686 of file CFitCascade.cxx.

{
   cVertices.clear();
   covVertices.clear();
   fittedParticles.clear();
   particleChi2.clear();
//
//   Split common covariance matrix into pieces
//
   std::vector< std::vector<double> > cascadeCovarFit;
   setFittedMatrices(cascadeEvent_.fullCovMatrix.get(), getCascadeNPar(cascadeEvent_), cascadeEvent_.matrixPnt, cascadeCovarFit, cascadeEvent_);
//
   double vBx,vBy,vBz,pp2,pt,invR;
   int iv,it,jt, NTRK, pnt;
//
   int PDIM=getCascadeNPar(cascadeEvent_, 1); // number of physics parametrs
   int ADIM=getCascadeNPar(cascadeEvent_, 0); // number of ALL parametrs
   double **DPhys     = new double*[PDIM]; for(it=0; it<PDIM; it++) DPhys[it]     = new double[ADIM];
   for(it=0;it<PDIM;it++) for(jt=0;jt<ADIM;jt++)DPhys[it][jt]=0.;
//
//
   Vect3DF vrtPos;
   VectMOM prtMom{};
   VKVertex * vk;
   std::vector<VectMOM> momCollector;
   std::vector<double>  tmpCov(6);
//
   int pntPhys=0;  // Counter for physics cascade parameters
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk=cascadeEvent_.cascadeVertexList[iv].get();
     vrtPos.X=vk->refIterV[0] + vk->fitV[0];  // target vertex for extrapolation
     vrtPos.Y=vk->refIterV[1] + vk->fitV[1];
     vrtPos.Z=vk->refIterV[2] + vk->fitV[2];
     cVertices.push_back(vrtPos);
     NTRK = vk->TrackList.size();            // Number of tracks at vertex
     momCollector.clear();
     int DIM=3*(NTRK+1);
     double **Deriv     = new double*[DIM]; for(it=0; it<DIM; it++) Deriv[it]     = new double[DIM];
     for(it=0;it<DIM;it++) for(jt=0;jt<DIM;jt++)Deriv[it][jt]=0.;
     Deriv[0][0]=1.;Deriv[1][1]=1.;Deriv[2][2]=1.;
     DPhys[pntPhys+0][cascadeEvent_.matrixPnt[iv]+0]=1.;
     DPhys[pntPhys+1][cascadeEvent_.matrixPnt[iv]+1]=1.;
     DPhys[pntPhys+2][cascadeEvent_.matrixPnt[iv]+2]=1.;
     Trk::vkalMagFld::getMagFld(vk->refIterV[0]+vk->fitV[0], vk->refIterV[1]+vk->fitV[1], vk->refIterV[2]+vk->fitV[2],
                                                      vBx,vBy,vBz,(vk->vk_fitterControl).get());
     for(it=0; it<NTRK; it++){
       std::array<double, 4> pp = getFitParticleMom( vk->TrackList[it].get(), vBz );
       prtMom.Px=pp[0]; prtMom.Py=pp[1]; prtMom.Pz=pp[2]; prtMom.E=pp[3];
       momCollector.push_back( prtMom );
       if(vk->TrackList[it]->Id >= 0) particleChi2.push_back( vk->TrackList[it]->Chi2 ); //Only real tracks
       pp2  = pp[0]*pp[0] + pp[1]*pp[1] +pp[2]*pp[2];
       pt   = sqrt(pp[0]*pp[0] + pp[1]*pp[1]);
       invR = vk->TrackList[it]->fitP[2];
 
       pnt  = it*3+3;
       DPhys[pntPhys+pnt+0][cascadeEvent_.matrixPnt[iv]+pnt+0]= Deriv[pnt+0][pnt+0]=   0   ;                           //dPx/dTheta
       DPhys[pntPhys+pnt+0][cascadeEvent_.matrixPnt[iv]+pnt+1]= Deriv[pnt+0][pnt+1]= -pp[1];                           //dPx/dPhi
       DPhys[pntPhys+pnt+0][cascadeEvent_.matrixPnt[iv]+pnt+2]= Deriv[pnt+0][pnt+2]= -pp[0]/invR;                      //dPx/dinvR
 
       DPhys[pntPhys+pnt+1][cascadeEvent_.matrixPnt[iv]+pnt+0]= Deriv[pnt+1][pnt+0]=   0   ;                           //dPy/dTheta
       DPhys[pntPhys+pnt+1][cascadeEvent_.matrixPnt[iv]+pnt+1]= Deriv[pnt+1][pnt+1]=  pp[0];                           //dPy/dPhi
       DPhys[pntPhys+pnt+1][cascadeEvent_.matrixPnt[iv]+pnt+2]= Deriv[pnt+1][pnt+2]= -pp[1]/invR;                      //dPy/dinvR
 
       DPhys[pntPhys+pnt+2][cascadeEvent_.matrixPnt[iv]+pnt+0]= Deriv[pnt+2][pnt+0]= -pp2/pt;                          //dPz/dTheta
       DPhys[pntPhys+pnt+2][cascadeEvent_.matrixPnt[iv]+pnt+1]= Deriv[pnt+2][pnt+1]=   0    ;                          //dPz/dPhi
       DPhys[pntPhys+pnt+2][cascadeEvent_.matrixPnt[iv]+pnt+2]= Deriv[pnt+2][pnt+2]= -pp[2]/invR;                      //dPz/dinvR
     }
     pntPhys += DIM;
     fittedParticles.push_back(momCollector);
     cascadeCovar.push_back( transformCovar(DIM, Deriv, cascadeCovarFit[iv] ) );  //Transform covariance and save it
     for(int kk=0; kk<6; kk++) tmpCov[kk]=cascadeCovar[iv][kk];
     covVertices.push_back(tmpCov);
     for(it=0; it<DIM; it++) delete[]Deriv[it];
     delete[]Deriv;
   }
//
// Get full physics covariance
   int itn,jtn;
   fullCovar.resize(PDIM*(PDIM+1)/2);
   for(it=0; it<PDIM; it++){
     for(jt=0; jt<=it; jt++){
        double tmp=0.;
    for(itn=0; itn<ADIM; itn++) for(jtn=0; jtn<ADIM; jtn++) tmp += DPhys[it][itn]*DPhys[jt][jtn]*cascadeEvent_.fullCovMatrix[itn*ADIM+jtn];
        fullCovar[it*(it+1)/2+jt]=tmp; // symmetrical index formula works ONLY if it>=jt!!!
     }
   }
   for(it=0; it<PDIM; it++) delete[]DPhys[it];
   delete[]DPhys;
}

getFullVrtCov()

int Trk::getFullVrtCov	(	VKVertex *	vk,
		double *	ader,
		const double *	dcv,
		double	verr[6][6] )

Definition at line 25 of file VtCFitE.cxx.

{
 
    int i,j,ic1,ic2;
 
    long int ic, jc, it, jt;
    double  cnt = 1e8;
 
    TWRK    * t_trk=nullptr;
    long int NTRK = vk->TrackList.size();
    long int IERR=0;
    long int NVar = (NTRK + 1) * 3;
    if(vk->passNearVertex && vk->ConstraintList.empty()) {
                                 /*  Fit is with "pass near" constraint and then */
                                 /*     matrix is already present                */
    } else if ( !vk->ConstraintList.empty()  && useWeightScheme ) {
/*  Full matrix inversion i */
//
    FullMTXfill( vk, ader);
    if ( vk->passNearVertex ) {
      double drdpy[2][3];
      double dpipj[3][3];
      for (it = 1; it <= NTRK; ++it) {
        drdpy[0][0] = vk->tmpArr[it-1]->drdp[0][0] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][0] * vk->FVC.ywgt[1];
        drdpy[1][0] = vk->tmpArr[it-1]->drdp[0][0] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][0] * vk->FVC.ywgt[2];
        drdpy[0][1] = vk->tmpArr[it-1]->drdp[0][1] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][1] * vk->FVC.ywgt[1];
        drdpy[1][1] = vk->tmpArr[it-1]->drdp[0][1] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][1] * vk->FVC.ywgt[2];
        drdpy[0][2] = vk->tmpArr[it-1]->drdp[0][2] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][2] * vk->FVC.ywgt[1];
        drdpy[1][2] = vk->tmpArr[it-1]->drdp[0][2] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][2] * vk->FVC.ywgt[2];
        for (jt = 1; jt <= NTRK; ++jt) {   /* Matrix */
            for (int k = 0; k < 3; ++k) {
            for (int l = 0; l < 3; ++l) {
                dpipj[k][l] = 0.;
                for (int j = 0; j < 2; ++j) {
                dpipj[k][l] +=  vk->tmpArr[jt-1]->drdp[j][k] * drdpy[j][l];
                }
            }
            }
            for (int k = 1; k <= 3; ++k) {
            for (int l = 1; l <= 3; ++l) {
                ader_ref(it * 3 + k, jt * 3 + l) +=  dpipj[l-1][k-1];
            }
            }
        }
      }
    }
    Vect3DF th0t,tf0t;
    for(ic1=0; ic1<(int)vk->ConstraintList.size();ic1++){
      for(ic2=0; ic2<vk->ConstraintList[ic1]->NCDim; ic2++){
        th0t = vk->ConstraintList[ic1]->h0t[ic2];
        ader_ref(1, 1) += cnt * th0t.X * th0t.X;
        ader_ref(2, 1) += cnt * th0t.Y * th0t.X;
        ader_ref(3, 1) += cnt * th0t.Z * th0t.X;
        ader_ref(1, 2) += cnt * th0t.X * th0t.Y;
        ader_ref(2, 2) += cnt * th0t.Y * th0t.Y;
        ader_ref(3, 2) += cnt * th0t.Z * th0t.Y;
        ader_ref(1, 3) += cnt * th0t.X * th0t.Z;
        ader_ref(2, 3) += cnt * th0t.Y * th0t.Z;
        ader_ref(3, 3) += cnt * th0t.Z * th0t.Z;
        for (it = 1; it <= NTRK; ++it) {
            tf0t = vk->ConstraintList[ic1]->f0t[it-1][ic2];
        ader_ref(1, it * 3 + 1) += cnt * th0t.X * tf0t.X;
        ader_ref(2, it * 3 + 1) += cnt * th0t.Y * tf0t.X;
        ader_ref(3, it * 3 + 1) += cnt * th0t.Z * tf0t.X;
        ader_ref(1, it * 3 + 2) += cnt * th0t.X * tf0t.Y;
        ader_ref(2, it * 3 + 2) += cnt * th0t.Y * tf0t.Y;
        ader_ref(3, it * 3 + 2) += cnt * th0t.Z * tf0t.Y;
        ader_ref(1, it * 3 + 3) += cnt * th0t.X * tf0t.Z;
        ader_ref(2, it * 3 + 3) += cnt * th0t.Y * tf0t.Z;
        ader_ref(3, it * 3 + 3) += cnt * th0t.Z * tf0t.Z;
        }
      }
    }
 
 
    for(ic1=0; ic1<(int)vk->ConstraintList.size();ic1++){
      for(ic2=0; ic2<vk->ConstraintList[ic1]->NCDim; ic2++){
        for (it = 1; it <= NTRK; ++it) {
          for (jt = it; jt <= NTRK; ++jt) {
            Vect3DF tf0ti = vk->ConstraintList[ic1]->f0t[it-1][ic2];
            Vect3DF tf0tj = vk->ConstraintList[ic1]->f0t[jt-1][ic2];
            ader_ref(it*3 + 1, jt*3 + 1) += cnt * tf0ti.X * tf0tj.X;
            ader_ref(it*3 + 2, jt*3 + 1) += cnt * tf0ti.Y * tf0tj.X;
            ader_ref(it*3 + 3, jt*3 + 1) += cnt * tf0ti.Z * tf0tj.X;
            ader_ref(it*3 + 1, jt*3 + 2) += cnt * tf0ti.X * tf0tj.Y;
            ader_ref(it*3 + 2, jt*3 + 2) += cnt * tf0ti.Y * tf0tj.Y;
            ader_ref(it*3 + 3, jt*3 + 2) += cnt * tf0ti.Z * tf0tj.Y;
            ader_ref(it*3 + 1, jt*3 + 3) += cnt * tf0ti.X * tf0tj.Z;
            ader_ref(it*3 + 2, jt*3 + 3) += cnt * tf0ti.Y * tf0tj.Z;
            ader_ref(it*3 + 3, jt*3 + 3) += cnt * tf0ti.Z * tf0tj.Z;
          }
        }
      }
    }
/* symmetrisation */
    for (i=1; i<=NVar-1; ++i) {
        for (j = i+1; j<=NVar; ++j) {
        ader_ref(j,i) = ader_ref(i,j);
        }
    }
//-------------------------------------------------------------------------
/* several checks for debugging */
//std::cout.precision(12);
//        for(ic1=0; ic1<(int)vk->ConstraintList.size();ic1++){
//          for(ic2=0; ic2<vk->ConstraintList[ic1]->NCDim; ic2++){
//            th0t = vk->ConstraintList[ic1]->h0t[ic2];
//std::cout<<"h0t="<<th0t.X<<", "<<th0t.Y<<", "<<th0t.Z<<'\n';
//         for (it = 1; it <= NTRK; ++it) {
//                tf0t = vk->ConstraintList[ic1]->f0t[it-1][ic2];
//std::cout<<"f0t="<<tf0t.X<<", "<<tf0t.Y<<", "<<tf0t.Z<<'\n';
//        } } }
//if(NTRK==2){
//  for(i=1; i<=NVar; i++){std::cout<<" newmtx=";
//    for(j=1; j<=NVar; j++)std::cout<<ader_ref(j,i)<<", "; std::cout<<'\n';}
//}
//-------------------------------------------------------------------------
// Weight matrix ready. Invert.  Beware - DSINV destroys initial matrix!
        noinit_vector<double*> ta (NVar+1);
        noinit_vector<double> tab ((NVar+1)*(NVar+1));
        for(i=0; i<NVar+1; i++){  ta[i] = tab.data() + i*(NVar+1);}
        for (i=1; i<=NVar; ++i) for (j = i; j<=NVar; ++j) ta[i][j] = ta[j][i] = ader_ref(i,j);  //Make copy for failure treatment
        dsinv(NVar, ader, vkalNTrkM*3+3, &IERR);
        if ( IERR != 0) {
          noinit_vector<double*> tv (NVar+1);
          noinit_vector<double> tvb ((NVar+1)*(NVar+1));
          noinit_vector<double*> tr (NVar+1);
          noinit_vector<double> trb ((NVar+1)*(NVar+1));
          noinit_vector<double> tw (NVar+1);
          for(i=0; i<NVar+1; i++){  tv[i] = tvb.data() + i*(NVar+1); tr[i] = trb.data() + i*(NVar+1);}
 
          vkSVDCmp( ta.data(), NVar, NVar, tw.data(), tv.data());
 
          double tmax=0;
          for(i=1; i<NVar+1; i++) if(fabs(tw[i])>tmax)tmax=fabs(tw[i]);
          for(i=1; i<NVar+1; i++) if(fabs(tw[i])/tmax < 1.e-18) tw[i]=0.;
          for(i=1; i<=NVar; i++){ for(j=1; j<=NVar; j++){
            tr[i][j]=0.; for(int k=1; k<=NVar; k++)  if(tw[k]!=0.) tr[i][j] += ta[i][k]*tv[j][k]/tw[k];
          }}
 
          for (i=1; i<=NVar; ++i) for (j=1; j<=NVar; ++j) ader_ref(i,j)=tr[i][j];
 
          IERR=0; //return IERR;
        }
        //------ Check matrix inversion quality
        double maxDiff=0.;
        for( i=1; i<=NVar; i++){ for(j=i; j<=NVar; j++){
           double mcheck=0.; for(int k=1; k<=NVar; k++) mcheck+=ta[i][k]*ader_ref(k,j);
           if(i!=j) maxDiff = (maxDiff > std::abs(mcheck)) ? maxDiff : std::abs(mcheck);
           if(i==j) maxDiff = (maxDiff > std::abs(1.-mcheck)) ? maxDiff : std::abs(1.-mcheck);
        } }
        //---------------------------------------------------------------------------------------
        if(maxDiff>0.1)return -1;
/* ---------------------------------------- */
    } else {
/* ---------------------------------------- */
/* Simple and fast without constraints */
    for (i=1; i<=NVar; i++) {
        for (j=1; j<=NVar; j++) {
        ader_ref(i,j)=0.;
        }
    }
    double vcov[6]={vk->fitVcov[0],vk->fitVcov[1],vk->fitVcov[2],vk->fitVcov[3],vk->fitVcov[4],vk->fitVcov[5]};
    ader_ref(1,1) = vcov[0];
    ader_ref(1,2) = vcov[1];
    ader_ref(2,2) = vcov[2];
    ader_ref(1,3) = vcov[3];
    ader_ref(2,3) = vcov[4];
    ader_ref(3,3) = vcov[5];
    ader_ref(2,1) = ader_ref(1,2);
    ader_ref(3,1) = ader_ref(1,3);
    ader_ref(3,2) = ader_ref(2,3);
 
    for (it=1; it<=NTRK; it++) {
            t_trk=vk->tmpArr[it-1].get();
        ader_ref(1, it*3 + 1) = -vcov[0] * t_trk->wbci[0]
                               - vcov[1] * t_trk->wbci[1]
                   - vcov[3] * t_trk->wbci[2];
        ader_ref(2, it*3 + 1) = -vcov[1] * t_trk->wbci[0]
                               - vcov[2] * t_trk->wbci[1]
                   - vcov[4] * t_trk->wbci[2];
        ader_ref(3, it*3 + 1) = -vcov[3] * t_trk->wbci[0]
                               - vcov[4] * t_trk->wbci[1]
                   - vcov[5] * t_trk->wbci[2];
        ader_ref(1, it*3 + 2) = -vcov[0] * t_trk->wbci[3]
                               - vcov[1] * t_trk->wbci[4]
                           - vcov[3] * t_trk->wbci[5];
        ader_ref(2, it*3 + 2) = -vcov[1] * t_trk->wbci[3]
                               - vcov[2] * t_trk->wbci[4]
                   - vcov[4] * t_trk->wbci[5];
        ader_ref(3, it*3 + 2) = -vcov[3] * t_trk->wbci[3]
                               - vcov[4] * t_trk->wbci[4]
                   - vcov[5] * t_trk->wbci[5];
        ader_ref(1, it*3 + 3) = -vcov[0] * t_trk->wbci[6]
                               - vcov[1] * t_trk->wbci[7]
                   - vcov[3] * t_trk->wbci[8];
        ader_ref(2, it*3 + 3) = -vcov[1] * t_trk->wbci[6]
                               - vcov[2] * t_trk->wbci[7]
                   - vcov[4] * t_trk->wbci[8];
        ader_ref(3, it*3 + 3) = -vcov[3] * t_trk->wbci[6]
                                    - vcov[4] * t_trk->wbci[7]
                            - vcov[5] * t_trk->wbci[8];
        ader_ref(it*3 + 1, 1) = ader_ref(1, it*3 + 1);
        ader_ref(it*3 + 1, 2) = ader_ref(2, it*3 + 1);
        ader_ref(it*3 + 1, 3) = ader_ref(3, it*3 + 1);
        ader_ref(it*3 + 2, 1) = ader_ref(1, it*3 + 2);
        ader_ref(it*3 + 2, 2) = ader_ref(2, it*3 + 2);
        ader_ref(it*3 + 2, 3) = ader_ref(3, it*3 + 2);
        ader_ref(it*3 + 3, 1) = ader_ref(1, it*3 + 3);
        ader_ref(it*3 + 3, 2) = ader_ref(2, it*3 + 3);
        ader_ref(it*3 + 3, 3) = ader_ref(3, it*3 + 3);
    }
 
 
    for (it = 1; it<=NTRK; ++it) {
            t_trk=vk->tmpArr[it-1].get();
        for (jt=1; jt<=NTRK; ++jt) {
            int j3   = jt*3;
            int i3   = it*3;
        ader_ref( i3+1, j3+1) = -t_trk->wbci[0]*ader_ref(1, j3+1) - t_trk->wbci[1]*ader_ref(2, j3+1) - t_trk->wbci[2]*ader_ref(3, j3+1);
        ader_ref( i3+2, j3+1) = -t_trk->wbci[3]*ader_ref(1, j3+1) - t_trk->wbci[4]*ader_ref(2, j3+1) - t_trk->wbci[5]*ader_ref(3, j3+1);
        ader_ref( i3+3, j3+1) = -t_trk->wbci[6]*ader_ref(1, j3+1) - t_trk->wbci[7]*ader_ref(2, j3+1) - t_trk->wbci[8]*ader_ref(3, j3+1);
        ader_ref( i3+1, j3+2) = -t_trk->wbci[0]*ader_ref(1, j3+2) - t_trk->wbci[1]*ader_ref(2, j3+2) - t_trk->wbci[2]*ader_ref(3, j3+2);
        ader_ref( i3+2, j3+2) = -t_trk->wbci[3]*ader_ref(1, j3+2) - t_trk->wbci[4]*ader_ref(2, j3+2) - t_trk->wbci[5]*ader_ref(3, j3+2);
        ader_ref( i3+3, j3+2) = -t_trk->wbci[6]*ader_ref(1, j3+2) - t_trk->wbci[7]*ader_ref(2, j3+2) - t_trk->wbci[8]*ader_ref(3, j3+2);
        ader_ref( i3+1, j3+3) = -t_trk->wbci[0]*ader_ref(1, j3+3) - t_trk->wbci[1]*ader_ref(2, j3+3) - t_trk->wbci[2]*ader_ref(3, j3+3);
        ader_ref( i3+2, j3+3) = -t_trk->wbci[3]*ader_ref(1, j3+3) - t_trk->wbci[4]*ader_ref(2, j3+3) - t_trk->wbci[5]*ader_ref(3, j3+3);
        ader_ref( i3+3, j3+3) = -t_trk->wbci[6]*ader_ref(1, j3+3) - t_trk->wbci[7]*ader_ref(2, j3+3) - t_trk->wbci[8]*ader_ref(3, j3+3);
        if (it == jt) {
            ader_ref( i3+1, i3+1) += t_trk->wci[0];
            ader_ref( i3+1, i3+2) += t_trk->wci[1];
            ader_ref( i3+2, i3+1) += t_trk->wci[1];
            ader_ref( i3+2, i3+2) += t_trk->wci[2];
            ader_ref( i3+1, i3+3) += t_trk->wci[3];
            ader_ref( i3+3, i3+1) += t_trk->wci[3];
            ader_ref( i3+2, i3+3) += t_trk->wci[4];
            ader_ref( i3+3, i3+2) += t_trk->wci[4];
            ader_ref( i3+3, i3+3) += t_trk->wci[5];
        }
        }
    }
//for(int ii=1; ii<=9; ii++)std::cout<<ader_ref(ii,ii)<<", "; std::cout<<__func__<<" fast full m NEW"<<'\n';
        if( !vk->ConstraintList.empty()  && !useWeightScheme ){
//---------------------------------------------------------------------
// Covariance matrix with constraints a la Avery.
// ader_ref() should contain nonconstraint covariance matrix
//---------------------------------------------------------------------
          long int totNC=0;  //total number of constraints
          std::vector<std::vector< Vect3DF> > tf0t;  // derivative collectors
          std::vector< Vect3DF >              th0t;  // derivative collectors
          std::vector< double >               taa;   // derivative collectors
          std::vector< Vect3DF > tmpVec;
          for(int ii=0; ii<(int)vk->ConstraintList.size();ii++){
             totNC += vk->ConstraintList[ii]->NCDim;
             for(ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
               taa.push_back(  vk->ConstraintList[ii]->aa[ic] );
               th0t.push_back( vk->ConstraintList[ii]->h0t[ic] );
               tmpVec.clear();
               for(it=0; it<(int)vk->ConstraintList[ii]->f0t.size(); it++){
             tmpVec.push_back( vk->ConstraintList[ii]->f0t[it][ic] );
              }
          tf0t.push_back( tmpVec );
            }
          }
// R,RC[ic][i]
      double **R =new double*[totNC]; for(ic=0; ic<totNC; ic++) R[ic]=new double[NVar];
      double **RC=new double*[totNC]; for(ic=0; ic<totNC; ic++)RC[ic]=new double[NVar];
      double *RCRt=new double[totNC*totNC];
      for(ic=0; ic<totNC; ic++){
        R[ic][0]=th0t[ic].X;
        R[ic][1]=th0t[ic].Y;
        R[ic][2]=th0t[ic].Z;
        for(it=1; it<=NTRK; it++){
          R[ic][it*3+0]=tf0t[ic][it-1].X;
          R[ic][it*3+1]=tf0t[ic][it-1].Y;
          R[ic][it*3+2]=tf0t[ic][it-1].Z;
            }
      }
// R*Cov matrix
          for(ic=0; ic<totNC; ic++){
        for(j=0; j<NVar; j++){ RC[ic][j]=0;
          for(i=0; i<NVar; i++) RC[ic][j] += R[ic][i]*ader_ref(i+1,j+1);
            }
          }
// R*Cov*Rt matrix        -  Lagrange multiplyers errors
          for(ic=0; ic<totNC; ic++){
            for(jc=0; jc<totNC; jc++){  RCRt[ic*totNC + jc] =0.;
          for(i=0; i<NVar; i++) RCRt[ic*totNC + jc] += RC[ic][i]*R[jc][i];
        }
          }
      dsinv(totNC, RCRt, totNC, &IERR);
      if ( IERR != 0) return IERR;
// Correction matrix
     for(i=0; i<NVar; i++){
       for(j=0; j<NVar; j++){  double COR=0.;
             for(ic=0; ic<totNC; ic++){
               for(jc=0; jc<totNC; jc++){
             COR += RC[ic][i]*RC[jc][j]*RCRt[ic*totNC +jc];
           }
         }
         ader_ref(i+1, j+1) -= COR;
       }
     }
// Delete temporary matrices
         for(ic=0; ic<totNC; ic++) delete[]  R[ic];
         delete[] R;
         for(ic=0; ic<totNC; ic++) delete[] RC[ic];
         delete[] RC;
     delete[] RCRt;
//for(int ii=1; ii<=9; ii++)std::cout<<ader_ref(ii,ii)<<", "; std::cout<<__func__<<" avery full m NEW"<<'\n';
       }  //end of Avery matrix
 
 
 
    }  // End of global IF() for matrix type selection
 
//if(NTRK==2){
//  for(i=1; i<=NVar; i++){std::cout<<__func__" new covfull=";
//    for(j=1; j<=NVar; j++)std::cout<<ader_ref(j,i)<<", "; std::cout<<'\n';}
//}
 
/* --Conversion to (X,Y,Z,Px,Py,Pz) form */
    for (i = 1; i <= 6; ++i) {
    for (j = 1; j <= 6; ++j) {
        verr[i-1][j-1] = 0.;
        for (ic=1; ic<=NVar; ++ic) {
            if(dcv_ref(i, ic)==0.) continue;
        for (jc=1; jc<=NVar; ++jc) {
                if(dcv_ref(j, jc)==0.) continue;
            verr[i-1][j-1] += dcv_ref(i, ic) * ader_ref(ic, jc) * dcv_ref(j, jc);
        }
        }
    }
    }
//for(int ii=1; ii<=6; ii++)std::cout<<verr[ii-1][ii-1]<<", "; std::cout<<" final m NEW"<<'\n';
    vk->existFullCov = 1;
    return 0;
}

getIniParticleMom() [1/2]

std::array< double, 4 > Trk::getIniParticleMom	(	const VKTrack *	trk,
		const VKVertex *	vk )

Definition at line 62 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double vBx,vBy,vBz,magConst;
    Trk::vkalMagFld::getMagFld(vk->refIterV[0],vk->refIterV[1],vk->refIterV[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
    magConst = Trk::vkalMagFld::getEffField(vBx, vBy, vBz, trk->iniP[1], trk->iniP[0]) * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->iniP[0]);
    double phi      =      trk->iniP[1];
    double pt       = std::abs( magConst/trk->iniP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getIniParticleMom() [2/2]

std::array< double, 4 > Trk::getIniParticleMom	(	const VKTrack *	trk,
		double	effectiveBMAG )

Definition at line 79 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst = effectiveBMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->iniP[0]);
    double phi      =      trk->iniP[1];
    double pt       = std::abs( magConst/trk->iniP[2] );
    double m   = trk->getMass();
    p[0] = pt * cos(phi);
    p[1] = pt * sin(phi);
    p[2] = pt * cth;
    p[3] = sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2] + m*m );
    return p;
}

getNewCov()

void Trk::getNewCov ( const double * OldCov, const double * Der, double * Cov, long int DIM )

noexcept

Definition at line 261 of file CascadeUtils.cxx.

{
   int i,j,it,jt;
   for( i=0; i<DIM; i++){
     for( j=0; j<DIM; j++){
       Cov[i*DIM+j]=0.;
       for( it=0; it<DIM; it++){
         for( jt=0; jt<DIM; jt++){
           Cov[i*DIM+j] += Der[i*DIM+it]*OldCov[it*DIM+jt]*Der[j*DIM+jt];
         }
       }
     }
   }
}

getVertexCharge()

long int Trk::getVertexCharge

(

VKVertex *

vk

)

Definition at line 71 of file CFitCascade.cxx.

                                        {
  long int tCharge=0;
  for(int it=0; it<(int)vk->TrackList.size(); it++) tCharge += vk->TrackList[it]->Charge;
  return tCharge;
}

makeCascade()

int Trk::makeCascade	(	VKalVrtControl &	FitCONTROL,
		long int	NTRK,
		const long int *	ich,
		double *	wm,
		double *	inp_Trk5,
		double *	inp_CovTrk5,
		const std::vector< std::vector< int > > &	vertexDefinition,
		const std::vector< std::vector< int > > &	cascadeDefinition,
		double	definedCnstAccuracy )

Definition at line 116 of file CascadeDefinition.cxx.

                                              {
  long int tk;
  int iv, it;
  if (vertexDefinition.size() != cascadeDefinition.size()) {
    std::cout << " WRONG INPUT!!!" << '\n';
    return -1;
  }
 
  long int IERR;
  int NV = vertexDefinition.size();
  double xyz[3] = {0.};
  double tmp[15] = {0.};
  double tmpWgt[15], out[3];
  double vBx, vBy, vBz;
  VKTrack *trk;
  int vEstimDone = 0;
 
  for (iv = 0; iv < NV; iv++) {
    auto VRT = std::make_unique<VKVertex>(FitCONTROL);
    VRT->setRefV(xyz);      // ref point
    VRT->setRefIterV(xyz);  // iteration ref. point
    VRT->setIniV(xyz);
    VRT->setCnstV(xyz);  // initial guess. 0 of course.
    auto arr = std::make_unique<double[]>(vertexDefinition[iv].size() * 5);
    int NTv = vertexDefinition[iv].size();
    for (it = 0; it < NTv; it++) {
      tk = vertexDefinition[iv][it];
      if (tk >= NTRK) {
        return -1;
      }
      VRT->TrackList.emplace_back(new VKTrack(
          tk, &inp_Trk5[tk * 5], &inp_CovTrk5[tk * 15], VRT.get(), wm[tk]));
      VRT->tmpArr.emplace_back(new TWRK());
      trk = VRT->TrackList[it].get();
      trk->Charge = ich[tk];
      trk->iniP[0] = trk->cnstP[0] = trk->fitP[0] =
          inp_Trk5[tk * 5 + 2];  // initial guess
      trk->iniP[1] = trk->cnstP[1] = trk->fitP[1] = inp_Trk5[tk * 5 + 3];
      trk->iniP[2] = trk->cnstP[2] = trk->fitP[2] = inp_Trk5[tk * 5 + 4];
      IERR = cfInv5(&inp_CovTrk5[tk * 15], tmpWgt);
      if (IERR)
        IERR = cfdinv(&inp_CovTrk5[tk * 15], tmpWgt, 5);
      if (IERR) {
        return -1;
      }
      trk->setCurrent(&inp_Trk5[tk * 5], tmpWgt);
      arr[it * 5] = inp_Trk5[tk * 5];
      arr[it * 5 + 1] = inp_Trk5[tk * 5 + 1];
      arr[it * 5 + 2] = inp_Trk5[tk * 5 + 2];
      arr[it * 5 + 3] = inp_Trk5[tk * 5 + 3];
      arr[it * 5 + 4] = inp_Trk5[tk * 5 + 4];
    }
    if (NTv > 1) {  // First estimation of vertex position if vertex has more
                    // than 2 tracks
      vEstimDone = 1;
      Trk::vkalMagFld::getMagFld(VRT->refIterV[0], VRT->refIterV[1],
                                 VRT->refIterV[2], vBx, vBy, vBz,
                                 (VRT->vk_fitterControl).get());
      double aVrt[3] = {0., 0., 0.};
      for (int i = 0; i < NTv - 1; i++)
        for (int j = i + 1; j < NTv; j++) {
          vkvFastV(&arr[i * 5], &arr[j * 5], xyz, vBz, out);
          aVrt[0] += out[0];
          aVrt[1] += out[1];
          aVrt[2] += out[2];
        }
      aVrt[0] /= (NTv * (NTv - 1) / 2);
      aVrt[1] /= (NTv * (NTv - 1) / 2);
      aVrt[2] /= (NTv * (NTv - 1) / 2);
      VRT->setRefIterV(aVrt);  // iteration ref. point
    }
    if (iv == 0) {  // start cascade creation
      startCascade(std::move(VRT));
      continue;
    }
    int includeNV = cascadeDefinition[iv].size();
    if (!includeNV) {  // no predecessors
      addCascadeEntry(std::move(VRT));
    } else {
      auto *vrttemp = addCascadeEntry(std::move(VRT), cascadeDefinition[iv]);
      for (it = 0; it < includeNV;
           it++) {  // tracks created out of predecessing vertices
        vrttemp->TrackList.emplace_back(
            new VKTrack(-999, tmp, tmp, vrttemp, 0.));
        vrttemp->tmpArr.emplace_back(new TWRK());
      }
    }
  }
  //
  // ----------------  If some vertex positions are different from (0,0,0) -
  // move tracks there
  if (vEstimDone) {
    IERR = translateToFittedPos(*(FitCONTROL.getCascadeEvent()), 1.);
    if (IERR)
      return IERR;
    for (iv = 0; iv < FitCONTROL.getCascadeEvent()->cascadeNV; iv++) {
      auto *VRT = FitCONTROL.getCascadeEvent()->cascadeVertexList[iv].get();
      int NTv = VRT->TrackList.size();  // Number of tracks at vertex
      for (it = 0; it < NTv; it++) {
        trk = VRT->TrackList[it].get();
        if (trk->Id < 0)
          continue;  // pseudo-track from cascade vertex
        trk->cnstP[0] = trk->iniP[0] = trk->fitP[0] = trk->Perig[2];
        trk->cnstP[1] = trk->iniP[1] = trk->fitP[1] = trk->Perig[3];
        trk->cnstP[2] = trk->iniP[2] = trk->fitP[2] = trk->Perig[4];
      }
    }
  }
  // ----------------  Init engine
 
  IERR = initCascadeEngine(*FitCONTROL.getCascadeEvent());
  FitCONTROL.getCascadeEvent()->setAccuracyConstraint(definedCnstAccuracy);
 
  return IERR;
}

operator<() [1/3]

bool Trk::operator<	(	const LayerIndex &	one,
		const LayerIndex &	two )

Overload of operator< | <= | > | >= for the usage in a map.

Definition at line 11 of file LayerIndex.cxx.

{
  return (one.value() < two.value());
}

operator<() [2/3]

bool Trk::operator< ( const TrackTruthKey & a, const TrackTruthKey & b )

inline

Definition at line 45 of file TrackTruthKey.h.

                                                                        {
    return a.index() < b.index();
  }

operator<() [3/3]

bool Trk::operator< ( const TrackTruthKey_p0 & a, const TrackTruthKey_p0 & b )

inline

Definition at line 29 of file TrackTruthKey_p0.h.

                                                                              {
    return a.m_index < b.m_index;
  }

operator<<() [1/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		const MultiComponentStateOnSurface &	)

Overload of << operator for MsgStream for debug output.

Definition at line 85 of file MultiComponentStateOnSurface.cxx.

{
  return log;
}

operator<<() [2/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const NoiseOnSurface &	se )

Definition at line 24 of file NoiseOnSurface.cxx.

{
  return se.dump(sl);
}

operator<<() [3/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const PatternTrackParameters &	se )

Definition at line 94 of file PatternTrackParameters.cxx.

{
  return se.dump(sl);
}

operator<<() [4/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		AlignResidualType	type )

operator<<() [5/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		ExtrapolationType	type )

Definition at line 14 of file ExtrapolationType.cxx.

                                                              {
  switch (type) {
    case FittedTrajectory:
      return log << " FittedTrajectory";
    case DeltaD0:
      return log << " DeltaD0         ";
    case DeltaZ0:
      return log << " DeltaZ0         ";
    case DeltaPhi0:
      return log << " DeltaPhi0       ";
    case DeltaTheta0:
      return log << " DeltaTheta0     ";
    case DeltaQOverP0:
      return log << " DeltaQOverP0    ";
    case DeltaQOverP1:
      return log << " DeltaQOverP1    ";
    case ExtrapolationTypes:
      return log << static_cast<int>(ExtrapolationTypes);
    default:
      return log << " unknown type    ";
  }
}

operator<<() [6/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		MeasurementType	type )

Definition at line 14 of file MeasurementType.cxx.

                                                            {
  switch (type) {
    case perigeeParameters:
      return log << " perigeeParameters";
    case transverseVertex:
      return log << " transverseVertex ";
    case vertex:
      return log << " vertex           ";
    case pixelCluster:
      return log << " pixelCluster     ";
    case stripCluster:
      return log << " stripCluster     ";
    case trapezoidCluster:
      return log << " trapezoidCluster ";
    case driftCircle:
      return log << " driftCircle      ";
    case pseudoMeasurement:
      return log << " pseudoMeas       ";
    case barrelScatterer:
      return log << " barrelScatterer  ";
    case endcapScatterer:
      return log << " endcapScatterer  ";
    case calorimeterScatterer:
      return log << " calorimeterScat  ";
    case barrelInert:
      return log << " barrelInert      ";
    case endcapInert:
      return log << " endcapInert      ";
    case energyDeposit:
      return log << " energyDeposit    ";
    case alignment:
      return log << " alignment        ";
    case discontinuity:
      return log << " discontinuity    ";
    case bremPoint:
      return log << " bremPoint        ";
    case hole:
      return log << " hole             ";
    case materialDelimiter:
      return log << " materialDelimiter";
 
    default:
      return log << " unknown type     ";
  }
}

operator<<() [7/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		ParameterType	type )

Definition at line 14 of file ParameterType.cxx.

                                                          {
  switch (type) {
    case D0:
      return log << " D0       ";
    case Z0:
      return log << " Z0       ";
    case Phi0:
      return log << " Phi0     ";
    case Theta0:
      return log << " Theta0   ";
    case QOverP0:
      return log << " QOverP0  ";
    case QOverP1:
      return log << " QOverP1  ";
    case ParameterTypes:
      return log << static_cast<int>(ParameterTypes);
    default:
      return log << " unknown type ";
  }
}

operator<<() [8/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		Trk::AlignMesType	type )

Definition at line 11 of file AlignResidualType.cxx.

  {
    switch (type)
    {
      case Measurement:
        return log << " measurement      ";    
      case Scatterer:
        return log << " scatterer        ";
      case EnergyDeposit:
        return log << " energy deposit   ";
      default:
        return log << " unknown mes type ";
    }
  }

operator<<() [9/112]

MsgStream & Trk::operator<<	(	MsgStream &	log,
		Trk::AlignResidualType	type )

Definition at line 26 of file AlignResidualType.cxx.

  {
    switch (type)
    {
      case HitOnly:
        return log << " HitOnly  ";    
      case Unbiased:
        return log << " Unbiased ";
//      case DCA:
//        return log << " DCA      ";
      default:
        return log << " unknown  ";
    }
  }

operator<<() [10/112]

MsgStream & Trk::operator<<	(	MsgStream &	out,
		const MuonTrackSummary &	trackSum )

output.

This dumps the values of each of the possible summary enums

Definition at line 112 of file MuonTrackSummary.cxx.

{
  out << "MuonTrackSummary: Hits: eta " << trackSum.netaHits() << " phi "
      << trackSum.nphiHits() << " holes " << trackSum.nholes() << " outliers "
      << trackSum.noutliers() << " close hits " << trackSum.ncloseHits()
      << endmsg;
  if (out.level() <= MSG::VERBOSE) {
    std::vector<MuonTrackSummary::ChamberHitSummary>::const_iterator it =
      trackSum.chamberHitSummary().begin();
    std::vector<MuonTrackSummary::ChamberHitSummary>::const_iterator it_end =
      trackSum.chamberHitSummary().end();
    for (; it != it_end; ++it) {
      const MuonTrackSummary::ChamberHitSummary& chSum = *it;
      const MuonTrackSummary::ChamberHitSummary::Projection& etaP =
        chSum.etaProjection();
      const MuonTrackSummary::ChamberHitSummary::Projection& phiP =
        chSum.phiProjection();
      out << " Chamber " << chSum.chamberId() << " isMdt " << chSum.isMdt()
          << std::endl
          << " First projection: Hits " << etaP.nhits << " holes "
          << etaP.nholes << " outlier " << etaP.noutliers << " deltas "
          << etaP.ndeltas << " close Hits " << etaP.ncloseHits << std::endl
          << " Second projection: Hits " << phiP.nhits << " holes "
          << phiP.nholes << " outlier " << phiP.noutliers << " deltas "
          << phiP.ndeltas << " close Hits " << phiP.ncloseHits << std::endl;
    }
  }
  return out;
}

operator<<() [11/112]

MsgStream & Trk::operator<<	(	MsgStream &	out,
		const TrackSummary &	trackSum )

output.

This dumps the values of each of the possible summary enums

Definition at line 208 of file TrackSummary.cxx.

{
  return dumpTrackSummary(out, trackSum);
}

operator<<() [12/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		AlignModuleTool &	alignModTool )

Definition at line 310 of file AlignModuleTool.cxx.

  {
    const AlignModuleList* modules=alignModTool.alignModules1D();
    for (int imod=0;imod<(int)modules->size(); imod++) {
      sl << "AML: "<<*((*modules)[imod]);
    }
    
    DataVector<AlignPar>* alignParList=alignModTool.alignParList1D();
    for (int iap=0;iap<(int)alignParList->size();iap++) {
      sl << *((*alignParList)[iap]);
    } 
    return sl;
  }

operator<<() [13/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AlignmentEffectsOnTrack &	tsos )

Overload of << operator for MsgStream for debug output.

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 26 of file AlignmentEffectsOnTrack.cxx.

{
  if (sl.level() < MSG::INFO) {
    sl << "AlignmentEffectsOnTrack:" << endmsg;
    sl << "deltaTranslation = " << aeot.deltaTranslation() << endmsg;
    sl << "sigmaDeltaTranslation = " << aeot.deltaTranslation() << endmsg;
    sl << "deltaAngle = " << aeot.deltaAngle() << endmsg;
    sl << "sigmaDeltaAngle = " << aeot.sigmaDeltaAngle() << endmsg;
    sl << "surface = " << aeot.associatedSurface() << endmsg;
  }
  return sl;
}

operator<<() [14/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AlignModule &	alignModule )

overload of << operator for MsgStream for debug output

Definition at line 204 of file AlignModule.cxx.

  {
    sl << "AlignModule \'"<<alignModule.name()<<"\' ID: "<<alignModule.identify()
       <<"  IDHash: "<<alignModule.identifyHash()<< endmsg;
    return sl;
  }

operator<<() [15/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AlignPar &	ap )

overload of << operator for MsgStream for debug output

Definition at line 10 of file AlignPar.cxx.

  {
    sl << "alignPar type : " << std::setw(10) << ap.dumpType()
       << "(" << ap.paramType() << " ) : " << &ap << endmsg;
    sl << "   init par: " << std::setw(6) << std::showpos << std::fixed 
       << ap.initPar()<<" +/- "<<std::noshowpos << ap.initErr() 
       <<   resetiosflags(std::ios::floatfield) << endmsg;
    sl << "        par: "<< std::showpos << ap.par() << " +/- "
       << std::noshowpos << ap.err() << endmsg;
    sl << "  final par: "<< std::showpos << ap.finalPar() << " +/- "
       << std::noshowpos << ap.finalErr() << endmsg;
    sl << "      sigma: "<< ap.sigma() << endmsg; 
    sl << "   soft-cut: "<< ap.softCut() << endmsg; 
    sl << "  first drv: "<< std::showpos << ap.firstDeriv()
       << std::noshowpos << endmsg;
    sl << "  secnd drv: "<< std::showpos << ap.secndDeriv()
       << std::noshowpos << endmsg;
    return sl; 
  } 

operator<<() [16/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AlignTrack::AlignTrackType	type )

Definition at line 372 of file AlignTrack.cxx.

  {
    switch(type) {
      case AlignTrack::Unknown:
        return sl<<"Unknown             ";
      case AlignTrack::Original:
        return sl<<"Original            ";
      case AlignTrack::NormalRefitted:
        return sl<<"NormalRefitted      ";
      case AlignTrack::BeamspotConstrained:
        return sl<<"BeamspotConstrained ";
      case AlignTrack::VertexConstrained:
        return sl<<"VertexConstrained   ";
      default:
        return sl<<"UNDEFINED           ";
    }
  }

operator<<() [17/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AlignTSOS &	atsos )

Overload of << operator for MsgStream for debug output.

Definition at line 164 of file AlignTSOS.cxx.

  { 
    //sl <<"\t"<<atsos.dumpType()
    // << std::setw(11) << std::showpos<< std::scientific
    // <<"\tres[0]="<<atsos.residual(0)<<", err[0]="<<atsos.residualErrorSq(0)
    // <<", dchi2="<<std::noshowpos
    // <<atsos.residual(0)*atsos.residual(0)/atsos.residualErrorSq(0)<<endmsg;
    sl <<"\t"<<atsos.dumpType()<<" ("<<atsos.dumpMeasType()<<", direction "<<atsos.dumpMeasDir()<<")"<<endmsg;
    sl << "          -->  ";
 
    int ires(0);
    std::vector<Residual>::const_iterator itRes     = atsos.firstResidual();
    std::vector<Residual>::const_iterator itRes_end = atsos.lastResidual();
    for( ; itRes != itRes_end ; ++itRes, ++ires) {
      double resnorm = itRes->residualNorm();
      if(ires){ 
        std::ios_base::fmtflags f(sl.stream().flags());  
        sl << endmsg << "          -->  ";
        sl << ires << ": res="
           << std::setw(11)     << std::showpos << std::scientific
           << itRes->residual() <<"  res/err="<<resnorm
           << ", dchi2="<<std::noshowpos<<resnorm*resnorm
       << resetiosflags(std::ios::floatfield);
        sl.flags(f);  
      }
    }
    return sl;
  }

operator<<() [18/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const AssociatedMaterial &	mstep )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 209 of file AssociatedMaterial.cxx.

                                                               {
  return mstep.dump(sl);
}

operator<<() [19/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const BinUtility &	bgen )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 17 of file BinUtility.cxx.

{
  return bgen.dump(sl);
}

operator<<() [20/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const CurvilinearUVT &	uvt )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 15 of file CurvilinearUVT.cxx.

{ 
    sl <<  "Trk::CuvilinearUVT - curvilinear frame (u,v,t)" << std::endl;
    sl << "          u = " << uvt.curvU() << std::endl;
    sl << "          v = " << uvt.curvV() << std::endl;
    sl << "          t = " << uvt.curvT() << std::endl;
    
    return sl;   
}

operator<<() [21/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const ElementTable &	etab )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 21 of file ElementTable.cxx.

                                                                     {
  std::string none = "None";
  sl << " ------------------------- Trk::ElementTable "
        "-------------------------- "
     << std::endl;
  sl << " - Listing " << etab.size() << " elements " << std::endl;
  for (unsigned int iel = 0; iel < static_cast<unsigned int>(UCHAR_MAX); ++iel)
    sl << " - Id : " << std::setw(3) << iel << " - Properties: "
       << (etab.element(iel) ? etab.element(iel)->toString() : none)
       << " - Name : " << etab.elementName(iel) << std::endl;
  sl << " ---------------------------------------------------------------------"
        "- "
     << endmsg;
  return sl;
}

operator<<() [22/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const EnergyLoss &	eloss )

Overload of << operator for MsgStream for debug output.

Definition at line 15 of file EnergyLoss.cxx.

{
  return eloss.dump(sl);
}

operator<<() [23/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const FitQualityImpl &	fq )

Overload of << operator for MsgStream for debug output.

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 16 of file FitQuality.cxx.

{
  std::ostringstream os;
  os<<fq;
  sl<<os.str();
  return sl;
}

operator<<() [24/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const JacobianCurvilinearToLocal &	jac )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 93 of file JacobianCurvilinearToLocal.cxx.

{ 
    sl << std::setiosflags(std::ios::fixed);
        sl << std::setprecision(6);
        sl << MSG::DEBUG << "Trk::JacobianCurvilinearToLocal"                          << std::endl;
        sl << "______________________________________________________________________" << std::endl;
    for (int irow = 0; irow<5; irow++){
            for (int icol =0; icol<5; icol++){
                sl <<  (jac)(irow,icol);
                if (irow < 4 || icol < 4 ) { sl << "     "; }
            }
            sl << std::endl;        
        }
        sl << "______________________________________________________________________";      
        return sl;
}

operator<<() [25/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const LayerIndex &	layx )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 35 of file LayerIndex.cxx.

{
  sl << layx.value();
  return sl;
}

operator<<() [26/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const LayerMaterialProperties &	mprop )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 9 of file LayerMaterialProperties.cxx.

                                                                  {
  return lmp.dump(sl);
}

operator<<() [27/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const LinearizedTrack &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output.

operator<<() [28/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const LocalDirection &	lomo )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 15 of file LocalDirection.cxx.

{ 
    ls << std::setiosflags(std::ios::fixed) << std::setprecision(3);
//    ls << "(angleXZ, angleYZ, magnitude) = ";
    ls << "(angleXZ, angleYZ) = ";
    ls << "(" <<  lom.angleXZ();
    ls << "," <<  lom.angleYZ() << ")";
    ls << std::setprecision(-1);
    return ls;
}

operator<<() [29/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const MagneticFieldProperties &	mprop )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 14 of file MagneticFieldProperties.cxx.

                                                                    {
  sl << "Trk::MagneticFieldProperties, configuration: "
     << mprop.magneticFieldMode() << endmsg;
  return sl;
}

operator<<() [30/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const MaterialEffectsBase &	meb )

Overload of << operator for MsgStream for debug output.

Definition at line 50 of file MaterialEffectsBase.cxx.

{
  return meb.dump(sl);
}

operator<<() [31/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const MaterialProperties &	mprop )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 84 of file MaterialProperties.cxx.

                                                               {
  sl << "Trk::MaterialProperties: " << endmsg;
  sl << "   - thickness/X0                          = " << mprop.thicknessInX0()
     << endmsg;
  sl << "   - thickness                       [mm]  = " << mprop.thickness()
     << endmsg;
  sl << "   - radiation length X0             [mm]  = " << mprop.x0() << endmsg;
  sl << "   - nuclear interaction length L0   [mm]  = " << mprop.l0() << endmsg;
  sl << "   - average material Z/A*rho [gram/mm^3]  = "
     << mprop.zOverAtimesRho() << endmsg;
  return sl;
}

operator<<() [32/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const MaterialStep &	mstep )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 70 of file MaterialStep.cxx.

                                                                      {
  return mstep.dump(sl);
}

operator<<() [33/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const MemoryLogger &	oac )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 49 of file MemoryLogger.cxx.

{
  sl << "[ memory usage ] in kB ( VmSize | VmRSS )  : " << mlg.vmSize() << '\t' << mlg.vmRss();
  return sl;
}

operator<<() [34/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const ObjectAccessor &	oac )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 15 of file ObjectAccessor.cxx.

{
  for (const ObjectAccessor::value_type& elm : oac) {
    sl << (oac.end() - oac.begin()) << "-ObjectAccessor: | " << elm << " | ";
  }
  return sl;
}

operator<<() [35/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Surface &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 212 of file Surface.cxx.

{
  return sf.dump(sl);
}

operator<<() [36/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const SurfaceBounds &	sb )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 13 of file SurfaceBounds.cxx.

{
  return sb.dump(sl);
}

operator<<() [37/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Track &	track )

Overload of << operator for MsgStream for debug output.

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 235 of file Tracking/TrkEvent/TrkTrack/src/Track.cxx.

                                                               {
  std::string name("Track ");
  sl << name << "Author = " << track.info().dumpInfo() << endmsg;
  if (track.fitQuality() != nullptr) {
    sl << *(track.fitQuality()) << endmsg;
  }
  if (track.trackSummary() != nullptr) {
    sl << *(track.trackSummary()) << endmsg;
  } else {
    sl << "No TrackSummary available in this track." << endmsg;
  }
  if (track.trackStateOnSurfaces() != nullptr) {
    sl << name << "has " << (track.trackStateOnSurfaces()->size())
       << " trackStateOnSurface(s)" << endmsg;
 
    // level() shows the output level, currentLevel()
    // shows what the stream is set to
    if (sl.level() < MSG::INFO) {
      // loop over TrackStateOnSurfaces if verbose turned on
      Trk::TrackStates::const_iterator it =
          track.trackStateOnSurfaces()->cbegin();
      int num = 0;
      for (; it != track.trackStateOnSurfaces()->cend(); ++it) {
        sl << " --------- Start of TrackStateOnSurface \t" << num << "\t-------"
           << endmsg;
        sl << (**it);
        sl << " ---------   End of TrackStateOnSurface \t" << num++
           << "\t-------" << endmsg;
      }
    }
  }
  return sl;
}

operator<<() [38/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const TrackInfo &	track )

Overload of << operator for MsgStream for debug output.

Definition at line 232 of file Tracking/TrkEvent/TrkTrack/src/TrackInfo.cxx.

{
  sl << info.dumpInfo() << endmsg;
  return sl;
}

operator<<() [39/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const TrackParticleBase &	trackParticleBase )

Overload of << operator for MsgStream for debug output.

Definition at line 247 of file TrackParticleBase.cxx.

    {
      trackParticleBase.dump(sl);
      return sl;
    }

operator<<() [40/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const TrackStateOnSurface &	tsos )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Overload of << operator for MsgStream for debug output.

Definition at line 249 of file TrackStateOnSurface.cxx.

{
  std::string name("TrackStateOnSurface: ");
  sl << name << "\t of type : " << tsos.dumpType() << endmsg;
 
  if (sl.level() < MSG::INFO) {
    sl << name << "Detailed dump of contained objects follows:" << endmsg;
    sl << (tsos.fitQualityOnSurface()) << "\n (end of FitQualityOnSurface dump)"
       << endmsg;
 
    if (tsos.trackParameters() != nullptr) {
      sl << *(tsos.trackParameters()) << "\n (end of TrackParameters dump)"
         << endmsg;
    }
 
    if (tsos.measurementOnTrack() != nullptr) {
      sl << *(tsos.measurementOnTrack()) << "\n (end of MeasurementBase dump"
         << endmsg;
    }
 
    if (tsos.materialEffectsOnTrack() != nullptr) {
      sl << *(tsos.materialEffectsOnTrack())
         << "\n (end of MaterialEffectsBase dump)" << endmsg;
    }
 
    if (tsos.alignmentEffectsOnTrack() != nullptr) {
      sl << *(tsos.alignmentEffectsOnTrack())
         << "\n (end of AlignmentEffectsOnTrack dump)" << endmsg;
    }
  }
  return sl;
}

operator<<() [41/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const TrackSurfaceIntersection &	tsfi )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 61 of file TrackSurfaceIntersection.cxx.

{
  std::ostringstream os;
  os<<tsfi;
  sl<<os.str();
  return sl;
}

operator<<() [42/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const TransportJacobian &	jac )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 62 of file TransportJacobian.cxx.

{
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
  sl << "| Jacobian(A) | Old   /dL1  |       /dL2  |      /dPhi  |      /dThe  "
        "|       /dCM  |"
     << std::endl;
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
 
  sl << "|  New  dL1 / |" << std::setw(12) << std::setprecision(5) << J(0, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(0, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 4) << " |" << std::endl;
  sl << "|       dL2 / |" << std::setw(12) << std::setprecision(5) << J(1, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(1, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 4) << " |" << std::endl;
  sl << "|       dPhi/ |" << std::setw(12) << std::setprecision(5) << J(2, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(2, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 4) << " |" << std::endl;
  sl << "|       dThe/ |" << std::setw(12) << std::setprecision(5) << J(3, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(3, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 4) << " |" << std::endl;
  sl << "|       dCM / |"
 
     << std::setw(12) << std::setprecision(5) << J(4, 0) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 4) << " |" << std::endl;
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
  return sl;
}

operator<<() [43/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Trk::LocalParameters &	lp )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 101 of file LocalParameters.cxx.

{
  std::ostringstream os;
  os << lp;
  sl << os.str();
  return sl;
}

operator<<() [44/112]

MsgStream & Trk::operator<< ( MsgStream & sl, const Trk::MeasurementBase & mbase )

inline

Overload of << operator for MsgStream for debug output.

Definition at line 116 of file MeasurementBase.h.

{
  return mbase.dump(sl);
}

operator<<() [45/112]

template<int DIM, class T>

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Trk::ParametersBase< DIM, T > &	tp )

Overload of << operator for both, MsgStream and std::ostream for debug output.

operator<<() [46/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Trk::ScatteringAngles &	saos )

Overload of << operator for MsgStream for debug output.

Definition at line 11 of file ScatteringAngles.cxx.

{
  std::string name("ScatteringAngles: ");
  sl << name << "deltaPhi        : " << saos.deltaPhi() << endmsg;
  sl << name << "deltaTheta      : " << saos.deltaTheta() << endmsg;
  sl << name << "sigmaDeltaPhi   : " << saos.sigmaDeltaPhi() << endmsg;
  sl << name << "sigmaDeltaTheta : " << saos.sigmaDeltaTheta() << endmsg;
  return sl;
}

operator<<() [47/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Trk::SpacePoint &	spacePoint )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Overload of << operator for MsgStream for debug output.

Definition at line 43 of file Tracking/TrkEvent/TrkSpacePoint/src/SpacePoint.cxx.

  { 
    return spacePoint.dump(sl);
  }

operator<<() [48/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Vertex &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 50 of file Vertex.cxx.

{
  return sf.dump(sl);
}

operator<<() [49/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const VertexPositions &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 73 of file VertexPositions.cxx.

{
  return sf.dump(sl);
}

operator<<() [50/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const Volume &	vol )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 97 of file Volume.cxx.

{
  sl << "Trk::Volume with VolumeBounds :" << vol.volumeBounds() << endmsg;
  return sl;
}

operator<<() [51/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const VolumeBounds &	vb )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 14 of file VolumeBounds.cxx.

{
  return vb.dump(sl);
}

operator<<() [52/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const VxCandidate &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output; only needed in base class?

Definition at line 122 of file VxCandidate.cxx.

{
  return sf.dump(sl);
}

operator<<() [53/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const VxClusteringTable &	sf )

Definition at line 55 of file VxClusteringTable.cxx.

  { return sf.dump(sl); }

operator<<() [54/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		const VxTrackAtVertex &	sf )

Overload of << operator for both, MsgStream and std::ostream for debug output; only needed in base class?

Definition at line 494 of file VxTrackAtVertex.cxx.

{
  return sf.dump(sl);
}

operator<<() [55/112]

MsgStream & Trk::operator<<	(	MsgStream &	sl,
		Trk::GlueVolumesDescriptor &	gvd )

Overload of << operator for both, MsgStream and std::ostream for debug output.

Definition at line 49 of file GlueVolumesDescriptor.cxx.

                                                          {
  sl << "Trk::GlueVolumesDescriptor: " << std::endl;
  const std::vector<Trk::BoundarySurfaceFace>& glueFaceVector = gvd.glueFaces();
  sl << "     has Tracking Volumes registered for : " << glueFaceVector.size()
     << " Volume faces." << std::endl;
  std::vector<Trk::BoundarySurfaceFace>::const_iterator glueFaceIter =
      glueFaceVector.begin();
  std::vector<Trk::BoundarySurfaceFace>::const_iterator glueFaceIterEnd =
      glueFaceVector.end();
  // loop over the faces
  for (; glueFaceIter != glueFaceIterEnd; ++glueFaceIter) {
    const std::vector<Trk::TrackingVolume*>& glueVolumesVector =
      gvd.glueVolumes(*glueFaceIter);
    auto glueVolumeIter = glueVolumesVector.begin();
    auto glueVolumeIterEnd = glueVolumesVector.end();
    // loop over the TrackingVolumes
    sl << "        -----> Processing Face: " << int(*glueFaceIter) << " - has ";
    sl << glueVolumesVector.size()
       << " TrackingVolumes marked as 'GlueVolumes' " << std::endl;
    for (; glueVolumeIter != glueVolumeIterEnd; ++glueVolumeIter)
      sl << "             - TrackingVolume: " << (*glueVolumeIter)->volumeName()
         << std::endl;
  }
  return sl;
}

operator<<() [56/112]

MsgStream & Trk::operator<<	(	MsgStream &	stream,
		const PrepRawData &	prd )

Definition at line 130 of file PrepRawData.cxx.

{
  return prd.dump(stream);
}

operator<<() [57/112]

MsgStream & Trk::operator<<	(	MsgStream &	stream,
		const TrackRoad &	tr )

Dump the road into a message stream.

Definition at line 41 of file TrackRoad.cxx.

{
  return tr.dump(stream);
}

operator<<() [58/112]

std::ostream & Trk::operator<<	(	std::ostream &	log,
		const MultiComponentStateOnSurface &	)

Overload of << operator for std::ostream for debug output.

Definition at line 91 of file MultiComponentStateOnSurface.cxx.

{
  return log;
}

operator<<() [59/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const NoiseOnSurface &	se )

Definition at line 18 of file NoiseOnSurface.cxx.

{ 
  return se.dump(sl); 
}   

operator<<() [60/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const PatternTrackParameters &	se )

Definition at line 88 of file PatternTrackParameters.cxx.

{
  return se.dump(sl);
}

operator<<() [61/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const MuonTrackSummary &	trackSum )

output.

This dumps the values of each of the possible summary enums

Definition at line 83 of file MuonTrackSummary.cxx.

{
  out << "MuonTrackSummary: npseudo " << trackSum.npseudoMeasurements()
      << " nscat " << trackSum.nscatterers() << " number of chambers "
      << trackSum.chamberHitSummary().size() << std::endl;
  std::vector<MuonTrackSummary::ChamberHitSummary>::const_iterator it =
    trackSum.chamberHitSummary().begin();
  std::vector<MuonTrackSummary::ChamberHitSummary>::const_iterator it_end =
    trackSum.chamberHitSummary().end();
 
  for (; it != it_end; ++it) {
    const MuonTrackSummary::ChamberHitSummary& chSum = *it;
    const MuonTrackSummary::ChamberHitSummary::Projection& etaP =
      chSum.etaProjection();
    const MuonTrackSummary::ChamberHitSummary::Projection& phiP =
      chSum.phiProjection();
    out << " Chamber " << chSum.chamberId() << " isMdt " << chSum.isMdt()
        << std::endl
        << " First projection: Hits " << etaP.nhits << " holes " << etaP.nholes
        << " outlier " << etaP.noutliers << " deltas " << etaP.ndeltas
        << " close Hits " << etaP.ncloseHits << std::endl
        << " Second projection: Hits " << phiP.nhits << " holes " << phiP.nholes
        << " outlier " << phiP.noutliers << " deltas " << phiP.ndeltas
        << " close Hits " << phiP.ncloseHits << std::endl;
  }
  return out;
}

operator<<() [62/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const TrackSummary &	trackSum )

output.

This dumps the values of each of the possible summary enums

Definition at line 202 of file TrackSummary.cxx.

{
  return dumpTrackSummary(out, trackSum);
}

operator<<() [63/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKConstraintBase &	cnst )

Definition at line 9 of file Derivt.cxx.

                                                                      {
  int NTRK = cnst.f0t.size();
  out.precision(7);
  out << std::defaultfloat;
  out << " Base constraint derivatives for NTRK=" << NTRK
      << " CNST dim=" << cnst.NCDim << "\n";
  out << " Momentum derivatives " << "\n";
  for (int ic = 0; ic < cnst.NCDim; ic++) {
    out << "   d(...)/dTheta  d(...)/dPhi   d(...)/dInvR   NC=" << ic
        << "\n";
    for (int i = 0; i < NTRK; i++) {
      out << cnst.f0t[i][ic].X << ", " << cnst.f0t[i][ic].Y << ", "
          << cnst.f0t[i][ic].Z << "\n";
    }
    out << "   d(...)/dXv  d(...)/dYy   d(...)/Zv\n";
    out << cnst.h0t[ic].X << ", " << cnst.h0t[ic].Y << ", " << cnst.h0t[ic].Z
        << "\n";
    out << " aa=" << cnst.aa[ic] << std::endl;
  }
  out.precision(6);  // restore default
  return out;
}

operator<<() [64/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKMassConstraint &	cnst )

Definition at line 32 of file Derivt.cxx.

                                                                      {
  const VKVertex* vk = cnst.getOriginVertex();
  int NP = cnst.m_usedParticles.size();
  out.precision(7);
  out << std::defaultfloat;
  out << " Mass constraint  (total NTRK=" << vk->TrackList.size() << ")"
      << "\n";
  out << " * target mass: " << cnst.getTargetMass() << "\n";
  out << " * particle indexes: ";
  for (int i = 0; i < NP; i++) {
    out << cnst.m_usedParticles[i] << ", ";
  }
  out << "\n";
  out << " * particle masses: ";
  for (int i = 0; i < NP; i++) {
    out << vk->TrackList[cnst.m_usedParticles[i]]->getMass() << ", ";
  }
  out << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst) << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [65/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKPhiConstraint &	cnst )

Definition at line 54 of file Derivt.cxx.

                                                                     {
  const VKVertex* vk = cnst.getOriginVertex();
  out.precision(7);
  out << std::defaultfloat;
  out << " Phi constraint  (total NTRK=" << vk->TrackList.size() << ")"
      << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst) << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [66/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKPlaneConstraint &	cnst )

Definition at line 95 of file Derivt.cxx.

                                                                       {
  const VKVertex* vk = cnst.getOriginVertex();
  out.precision(7);
  out << std::defaultfloat;
  out << " Vertex in plane constraint  (total NTRK=" << vk->TrackList.size()
      << ")" << "\n";
  out << " Plane(A,B,C,D):" << cnst.getA() << ", " << cnst.getB() << ", "
      << cnst.getC() << ", " << cnst.getD() << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst)  << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [67/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKPointConstraint &	cnst )

Definition at line 76 of file Derivt.cxx.

                                                                       {
  const VKVertex* vk = cnst.getOriginVertex();
  out.precision(7);
  out << std::defaultfloat;
  if (!cnst.onlyZ()) {
    out << " Point constraint  (total NTRK=" << vk->TrackList.size() << ")"
        << "\n";
  } else {
    out << " Z point constraint  (total NTRK=" << vk->TrackList.size() << ")"
        << "\n";
  }
  out << " target vertex=" << cnst.getTargetVertex()[0] << ", "
      << cnst.getTargetVertex()[1] << ", " << cnst.getTargetVertex()[2]
      << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst)  << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [68/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKRadiusConstraint &	cnst )

Definition at line 108 of file Derivt.cxx.

                                                                        {
  const VKVertex* vk = cnst.getOriginVertex();
  out.precision(7);
  out << std::defaultfloat;
  out << " Vertex in radius constraint  (total NTRK=" << vk->TrackList.size()
      << ")\n" ;
  out << " Fixed Radius:" << cnst.getRC() << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst) << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [69/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKThetaConstraint &	cnst )

Definition at line 65 of file Derivt.cxx.

                                                                       {
  const VKVertex* vk = cnst.getOriginVertex();
  out.precision(7);
  out << std::defaultfloat;
  out << " Theta constraint  (total NTRK=" << vk->TrackList.size() << ")"
      << "\n";
  out << dynamic_cast<const VKConstraintBase&>(cnst) << "\n";
  out.precision(6);  // restore default
  return out;
}

operator<<() [70/112]

std::ostream & Trk::operator<<	(	std::ostream &	out,
		const VKTrack &	track )

Definition at line 96 of file TrkVKalVrtCoreBase.cxx.

  {
    //out.setf( std::ios::defaultfloat ); out.precision(5); out << std::endl;
    out.precision(5); out << std::defaultfloat;
        out << " Track par:      Iteration   <->   Ref"       << std::endl;
    out << " * a_0   : "<< track.a0()   <<"   "<< track.r_a0()   << std::endl;
    out << " * z_0   : "<< track.z()    <<"   "<< track.r_z()    << std::endl;
    out << " * theta : "<< track.theta()<<"   "<< track.r_theta()<< std::endl;
    out << " * phi   : "<< track.phi()  <<"   "<< track.r_phi()  << std::endl;
    out << " * q/R   : "<< track.invR() <<"   "<< track.r_invR() << std::endl;
    out << " * Charge: "<< track.Charge <<" Mass: "<<track.m_mass<< std::endl;
    out << "-> with ref ErrorMatrix: "        << std::endl;out.precision(5);
    out << track.refCovar[0] <<std::endl;
    out << track.refCovar[1] <<", "<<track.refCovar[2] <<std::endl;
    out << track.refCovar[3] <<", "<<track.refCovar[4] <<", "<<track.refCovar[5] <<std::endl;
    out << track.refCovar[6] <<", "<<track.refCovar[7] <<", "<<track.refCovar[8] <<", "
        << track.refCovar[9]<<std::endl;
    out << track.refCovar[10]<<", "<<track.refCovar[11]<<", "<<track.refCovar[12]<<", "
        << track.refCovar[13]<<", "<<track.refCovar[14]<<std::endl;
    out << "-> and iteration WeightMatrix: "        << std::endl;
    out << track.WgtM[0] <<std::endl;
    out << track.WgtM[1] <<", "<<track.WgtM[2] <<std::endl;
    out << track.WgtM[3] <<", "<<track.WgtM[4] <<", "<<track.WgtM[5] <<std::endl;
    out << track.WgtM[6] <<", "<<track.WgtM[7] <<", "<<track.WgtM[8] <<", "
        << track.WgtM[9]<<std::endl;
    out << track.WgtM[10]<<", "<<track.WgtM[11]<<", "<<track.WgtM[12]<<", "
        << track.WgtM[13]<<", "<<track.WgtM[14]<<std::endl;
    return out;
  }

operator<<() [71/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const AlignmentEffectsOnTrack &	tsos )

Overload of << operator for std::ostream for debug output.

Definition at line 40 of file AlignmentEffectsOnTrack.cxx.

{
  sl << "AlignmentEffectsOnTrack:" << std::endl;
  sl << "deltaTranslation = " << aeot.deltaTranslation() << std::endl;
  sl << "sigmaDeltaTranslation = " << aeot.deltaTranslation() << std::endl;
  sl << "deltaAngle = " << aeot.deltaAngle() << std::endl;
  sl << "sigmaDeltaAngle = " << aeot.sigmaDeltaAngle() << std::endl;
  sl << "surface = " << aeot.associatedSurface() << std::endl;
  return sl;
}

operator<<() [72/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const AlignTrack::AlignTrackType	type )

Definition at line 391 of file AlignTrack.cxx.

  {
    switch(type) {
      case AlignTrack::Unknown:
        return sl<<"Unknown             ";
      case AlignTrack::Original:
        return sl<<"Original            ";
      case AlignTrack::NormalRefitted:
        return sl<<"NormalRefitted      ";
      case AlignTrack::BeamspotConstrained:
        return sl<<"BeamspotConstrained ";
      case AlignTrack::VertexConstrained:
        return sl<<"VertexConstrained   ";
      default:
        return sl<<"UNDEFINED           ";
    }
  }

operator<<() [73/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const AssociatedMaterial &	mstep )

Definition at line 214 of file AssociatedMaterial.cxx.

                                                                  {
  return mstep.dump(sl);
}

operator<<() [74/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const BinUtility &	bgen )

Definition at line 23 of file BinUtility.cxx.

{
  return bgen.dump(sl);
}

operator<<() [75/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const CurvilinearUVT &	uvt )

Definition at line 25 of file CurvilinearUVT.cxx.

{ 
    sl <<  "Trk::CuvilinearUVT - curvilinear frame (u,v,t)" << std::endl;
    sl << "          u = " << uvt.curvU() << std::endl;
    sl << "          v = " << uvt.curvV() << std::endl;
    sl << "          t = " << uvt.curvT() << std::endl;    
 
    return sl;
}   

operator<<() [76/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const ElementTable &	etab )

Definition at line 37 of file ElementTable.cxx.

                                                                       {
  std::string none = "None";
  sl << " ------------------------- Trk::ElementTable "
        "-------------------------- "
     << std::endl;
  sl << " - Listing " << etab.size() << " elements " << std::endl;
  for (unsigned int iel = 0; iel < static_cast<unsigned int>(UCHAR_MAX); ++iel)
    sl << " - Id : " << std::setw(3) << iel << " - Properties: "
       << (etab.element(iel) ? etab.element(iel)->toString() : none)
       << " - Name : " << etab.elementName(iel) << std::endl;
  sl << " ---------------------------------------------------------------------"
        "- "
     << std::endl;
  return sl;
}

operator<<() [77/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const EnergyLoss &	eloss )

Overload of << operator for std::ostream for debug outputstd::ostream&.

Definition at line 22 of file EnergyLoss.cxx.

{
  return eloss.dump(sl);
}

operator<<() [78/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const FitQualityImpl &	fq )

Overload of << operator for std::ostream for debug output.

Definition at line 24 of file FitQuality.cxx.

{ 
  const std::streamsize old_prec = sl.precision();
  const auto old_flags = sl.flags();
  sl << std::setiosflags(std::ios::fixed)<< std::setprecision(3);
  sl <<"FitQuality: \t"
     << "("<<fq.chiSquared()<<", \t"<<fq.numberDoF()<<")\t"
     << "(chi^2, ndf)";
  sl.flags(old_flags);
  sl.precision(old_prec);
  return sl;
}

operator<<() [79/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const JacobianCurvilinearToLocal &	jac )

Definition at line 110 of file JacobianCurvilinearToLocal.cxx.

{  
    sl << std::setiosflags(std::ios::fixed);
        sl << std::setprecision(7);        
        sl << "Trk::JacobianCurvilinearToLocal " << std::endl;
        sl << "______________________________________________________________________" << std::endl;
    for (int irow = 0; irow<5; irow++){
            for (int icol =0; icol<5; icol++){
                sl <<  (jac)(irow,icol);
                if (irow < 4 || icol < 4 ) { sl << "     ";}
            }
            sl << std::endl;        
        }
       sl << "______________________________________________________________________";  
       return sl;   
} 

operator<<() [80/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const LayerIndex &	layx )

Definition at line 42 of file LayerIndex.cxx.

{
  sl << layx.value();
  return sl;
}

operator<<() [81/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const LayerMaterialProperties &	mprop )

Definition at line 14 of file LayerMaterialProperties.cxx.

                                                                     {
  return lmp.dump(sl);
}

operator<<() [82/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const LinearizedTrack &	sf )

Definition at line 112 of file LinearizedTrack.cxx.

{
  return sf.dump(sl);
}

operator<<() [83/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const LocalDirection &	lomo )

Definition at line 26 of file LocalDirection.cxx.

{ 
    ls << std::setiosflags(std::ios::fixed) << std::setprecision(3);
//    ls << "(angleXZ, angleYZ, magnitude) = ";
    ls << "(angleXZ, angleYZ) = ";
    ls << "(" <<  lom.angleXZ();
    ls << "," <<  lom.angleYZ() << ")";
    ls << std::setprecision(-1);
    return ls;
}

operator<<() [84/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const MagneticFieldProperties &	mprop )

Definition at line 21 of file MagneticFieldProperties.cxx.

                                                                       {
  sl << "Trk::MagneticFieldProperties, configuration: "
     << mprop.magneticFieldMode() << std::endl;
  return sl;
}

operator<<() [85/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const MaterialEffectsBase &	meb )

Overload of << operator for std::ostream for debug output.

Definition at line 57 of file MaterialEffectsBase.cxx.

{
  return meb.dump(sl);
}

operator<<() [86/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const MaterialProperties &	mprop )

Definition at line 98 of file MaterialProperties.cxx.

                                                               {
  sl << "Trk::MaterialProperties: " << std::endl;
  sl << "   - thickness/X0                          = " << mprop.thicknessInX0()
     << std::endl;
  sl << "   - thickness                       [mm]  = " << mprop.thickness()
     << std::endl;
  sl << "   - radiation length X0             [mm]  = " << mprop.x0()
     << std::endl;
  sl << "   - nuclear interaction length L0   [mm]  = " << mprop.l0()
     << std::endl;
  sl << "   - average material Z/A*rho [gram/mm^3]  = "
     << mprop.zOverAtimesRho() << std::endl;
  return sl;
}

operator<<() [87/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const MaterialStep &	mstep )

Definition at line 74 of file MaterialStep.cxx.

                                                            {
  return mstep.dump(sl);
}

operator<<() [88/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const MemoryLogger &	oac )

Definition at line 56 of file MemoryLogger.cxx.

{
  sl << "[ memory usage ] in kB ( VmSize | VmRSS )  : " << mlg.vmSize() << '\t' << mlg.vmRss();
  return sl;
}

operator<<() [89/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const ObjectAccessor &	oac )

Definition at line 24 of file ObjectAccessor.cxx.

{
  for (const ObjectAccessor::value_type& elm : oac) {
    sl << (oac.end() - oac.begin()) << "-ObjectAccessor: | " << elm << " | ";
  }
  return sl;
}

operator<<() [90/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Trk::SpacePoint &	spacePoint )

Overload of << operator for std::ostream for debug output.

Definition at line 50 of file Tracking/TrkEvent/TrkSpacePoint/src/SpacePoint.cxx.

  {
    return spacePoint.dump(sl);
  }

operator<<() [91/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Surface &	sf )

Definition at line 218 of file Surface.cxx.

{
  return sf.dump(sl);
}

operator<<() [92/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const SurfaceBounds &	sb )

Definition at line 19 of file SurfaceBounds.cxx.

{
  return sb.dump(sl);
}

operator<<() [93/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Track &	track )

Overload of << operator for std::ostream for debug output.

Definition at line 269 of file Tracking/TrkEvent/TrkTrack/src/Track.cxx.

                                                                 {
  std::string name("Track ");
  sl << name << "Author = " << track.info().dumpInfo() << std::endl;
  if (track.fitQuality() != nullptr) {
    sl << *(track.fitQuality()) << std::endl;
  }
  if (track.trackSummary() != nullptr) {
    sl << *(track.trackSummary()) << std::endl;
  } else {
    sl << "No TrackSummary available in this track." << std::endl;
  }
 
  if (track.trackStateOnSurfaces() != nullptr) {
    sl << name << "has " << (track.trackStateOnSurfaces()->size())
       << " trackStateOnSurface(s)" << std::endl;
    Trk::TrackStates::const_iterator it =
        track.trackStateOnSurfaces()->cbegin();
    int num = 0;
    for (; it != track.trackStateOnSurfaces()->cend(); ++it) {
      sl << " --------- Start of TrackStateOnSurface \t" << num << "\t-------"
         << std::endl;
      sl << (**it);
      sl << " ---------   End of TrackStateOnSurface \t" << num++ << "\t-------"
         << std::endl;
    }
  }
  return sl;
}

operator<<() [94/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const TrackInfo &	track )

Overload of << operator for std::ostream for debug output.

Definition at line 225 of file Tracking/TrkEvent/TrkTrack/src/TrackInfo.cxx.

{
  sl << info.dumpInfo() << std::endl;
  return sl;
}

operator<<() [95/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const TrackParticleBase &	trackParticleBase )

Overload of << operator for std::ostream for debug output.

Definition at line 253 of file TrackParticleBase.cxx.

    {
      trackParticleBase.dump(sl);
      return sl;
    }

operator<<() [96/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const TrackStateOnSurface &	tsos )

Overload of << operator for std::ostream for debug output.

return sl; don't return here, the next code becomes dead

Definition at line 283 of file TrackStateOnSurface.cxx.

{
  std::string name("TrackStateOnSurface: ");
  sl << name << "\t of type : " << tsos.dumpType() << std::endl;
 
  sl << "\t FitQualityOnSurface(s)." << std::endl;
  sl << "\t \t" << (tsos.fitQualityOnSurface()) << std::endl;
 
  if (tsos.trackParameters() != nullptr) {
    sl << "\t HAS TrackParameter(s)." << std::endl;
    sl << "\t \t" << *(tsos.trackParameters()) << std::endl;
  } else {
    sl << "\t NO TrackParameters." << std::endl;
  }
 
  if (tsos.measurementOnTrack() != nullptr) {
    sl << "\t HAS MeasurementBase(s)." << std::endl;
    sl << "\t \t" << *(tsos.measurementOnTrack()) << std::endl;
  } else {
    sl << "\t NO MeasurementBase." << std::endl;
  }
 
  if (tsos.materialEffectsOnTrack() != nullptr) {
    sl << "\t HAS MaterialEffectsBase." << std::endl;
    sl << "\t \t" << *(tsos.materialEffectsOnTrack()) << std::endl;
  } else {
    sl << "\t NO MaterialEffects." << std::endl;
  } 
 
  if (tsos.alignmentEffectsOnTrack() != nullptr) {
    sl << "\t HAS AlignmentEffectsOnTrack." << std::endl;
    sl << "\t \t" << *(tsos.alignmentEffectsOnTrack()) << std::endl;
  } else {
    sl << "\t NO AlignmentEffectsOnTrack." << std::endl;
  }
  return sl;
}

operator<<() [97/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const TrackSurfaceIntersection &	tsfi )

Definition at line 70 of file TrackSurfaceIntersection.cxx.

{
  const auto old_flags = sl.flags();
  const auto old_prec  = sl.precision();
 
  sl.setf(std::ios::fixed, std::ios::floatfield);
  sl.precision(7);
 
  sl << "Trk::TrackSurfaceIntersection\n"
     << "    position  [mm] = (" << tsfi.position().x() << ", "
     << tsfi.position().y() << ", " << tsfi.position().z() << ")\n"
     << "    direction      = (" << tsfi.direction().x() << ", "
     << tsfi.direction().y() << ", " << tsfi.direction().z() << ")\n"
     << "    pathlength [mm] = " << tsfi.pathlength() << '\n';
 
  sl.flags(old_flags);
  sl.precision(old_prec);
  return sl;
}

operator<<() [98/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const TransportJacobian &	jac )

Definition at line 112 of file TransportJacobian.cxx.

{
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
  sl << "| Jacobian(A) | Old   /dL1  |       /dL2  |      /dPhi  |      /dThe  "
        "|       /dCM  |"
     << std::endl;
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
 
  sl << "|  New  dL1 / |" << std::setw(12) << std::setprecision(5) << J(0, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(0, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(0, 4) << " |" << std::endl;
  sl << "|       dL2 / |" << std::setw(12) << std::setprecision(5) << J(1, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(1, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(1, 4) << " |" << std::endl;
  sl << "|       dPhi/ |" << std::setw(12) << std::setprecision(5) << J(2, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(2, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(2, 4) << " |" << std::endl;
  sl << "|       dThe/ |" << std::setw(12) << std::setprecision(5) << J(3, 0)
     << " |" << std::setw(12) << std::setprecision(5) << J(3, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(3, 4) << " |" << std::endl;
  sl << "|       dCM / |"
 
     << std::setw(12) << std::setprecision(5) << J(4, 0) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 1) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 2) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 3) << " |"
     << std::setw(12) << std::setprecision(5) << J(4, 4) << " |" << std::endl;
  sl << "|-------------|-------------|-------------|-------------|-------------"
        "|-------------|"
     << std::endl;
  return sl;
}

operator<<() [99/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Trk::LocalParameters &	lp )

Definition at line 109 of file LocalParameters.cxx.

{
  std::streamsize ss = sl.precision();
  sl << std::setiosflags(std::ios::fixed)<< std::setprecision(3);
  sl << "Trk::LocalParameters " <<": (";
  for (int ipar=0; ipar<lp.dimension(); ++ipar)
    { sl << lp(ipar);
      if (ipar+1 < lp.dimension()) { sl << ", ";
      } else { sl << ")   - key: "<< lp.m_parameterkey << "(";}
    }
 
  for (int itag = 0, ipos=1; itag<5; ++itag, ipos*=2)
    { bool bit = (lp.m_parameterkey & ipos);
      if (bit) { sl << "1";
      } else { sl << "0";
      }
    }
  sl << ")";
  sl.precision (ss); sl<<std::resetiosflags(std::ios::fixed);
 
 
  return sl;
}

operator<<() [100/112]

std::ostream & Trk::operator<< ( std::ostream & sl, const Trk::MeasurementBase & mbase )

inline

Overload of << operator for std::ostream for debug output.

Definition at line 123 of file MeasurementBase.h.

{
  return mbase.dump(sl);
}

operator<<() [101/112]

template<int DIM, class T>

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Trk::ParametersBase< DIM, T > &	tp )

operator<<() [102/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Trk::ScatteringAngles &	saos )

Overload of << operator for std::ostream for debug output.

Definition at line 22 of file ScatteringAngles.cxx.

{
  sl << "ScatteringAngles: " << std::endl;
  sl << "\t deltaPhi        : " << saos.deltaPhi() << std::endl;
  sl << "\t deltaTheta      : " << saos.deltaTheta() << std::endl;
  sl << "\t sigmaDeltaPhi   : " << saos.sigmaDeltaPhi() << std::endl;
  sl << "\t sigmaDeltaTheta : " << saos.sigmaDeltaTheta() << std::endl;
  return sl;
}

operator<<() [103/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Vertex &	sf )

Definition at line 56 of file Vertex.cxx.

{
  return sf.dump(sl);
}

operator<<() [104/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const VertexPositions &	sf )

Definition at line 79 of file VertexPositions.cxx.

{
  return sf.dump(sl);
}

operator<<() [105/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const Volume &	vol )

Definition at line 104 of file Volume.cxx.

{
  sl << "Trk::Volume with VolumeBounds :" << vol.volumeBounds() << std::endl;
  return sl;
}

operator<<() [106/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const VolumeBounds &	vb )

Definition at line 20 of file VolumeBounds.cxx.

{
  return vb.dump(sl);
}

operator<<() [107/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const VxCandidate &	sf )

Definition at line 128 of file VxCandidate.cxx.

{
  return sf.dump(sl);
}

operator<<() [108/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const VxClusteringTable &	sf )

Definition at line 58 of file VxClusteringTable.cxx.

  { return sf.dump(sl); }

operator<<() [109/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		const VxTrackAtVertex &	sf )

Definition at line 500 of file VxTrackAtVertex.cxx.

{
  return sf.dump(sl);
}

operator<<() [110/112]

std::ostream & Trk::operator<<	(	std::ostream &	sl,
		GlueVolumesDescriptor &	mprop )

Definition at line 76 of file GlueVolumesDescriptor.cxx.

                                                          {
  sl << "Trk::GlueVolumesDescriptor: " << std::endl;
  const std::vector<Trk::BoundarySurfaceFace>& glueFaceVector = gvd.glueFaces();
  sl << "     has Tracking Volumes registered for : " << glueFaceVector.size()
     << " Volume faces." << std::endl;
  std::vector<Trk::BoundarySurfaceFace>::const_iterator glueFaceIter =
      glueFaceVector.begin();
  std::vector<Trk::BoundarySurfaceFace>::const_iterator glueFaceIterEnd =
      glueFaceVector.end();
  // loop over the faces
  for (; glueFaceIter != glueFaceIterEnd; ++glueFaceIter) {
    const std::vector<Trk::TrackingVolume*>& glueVolumesVector =
        gvd.glueVolumes(*glueFaceIter);
    auto glueVolumeIter = glueVolumesVector.begin();
    auto glueVolumeIterEnd = glueVolumesVector.end();
    // loop over the TrackingVolumes
    sl << "        -----> Processing Face: " << int(*glueFaceIter) << " - has ";
    sl << glueVolumesVector.size()
       << " TrackingVolumes marked as 'GlueVolumes' " << std::endl;
    for (; glueVolumeIter != glueVolumeIterEnd; ++glueVolumeIter)
      sl << "             - TrackingVolume: " << (*glueVolumeIter)->volumeName()
         << std::endl;
  }
  return sl;
}

operator<<() [111/112]

std::ostream & Trk::operator<<	(	std::ostream &	stream,
		const PrepRawData &	prd )

Definition at line 136 of file PrepRawData.cxx.

{
  return prd.dump(stream);
}

operator<<() [112/112]

std::ostream & Trk::operator<<	(	std::ostream &	stream,
		const TrackRoad &	tr )

Dump the road into a standard output stream.

Definition at line 47 of file TrackRoad.cxx.

{
  return tr.dump(stream);
}

operator<=()

bool Trk::operator<=	(	const LayerIndex &	one,
		const LayerIndex &	two )

Definition at line 17 of file LayerIndex.cxx.

{
  return (one.value() <= two.value());
}

operator>()

bool Trk::operator>	(	const LayerIndex &	one,
		const LayerIndex &	two )

Definition at line 24 of file LayerIndex.cxx.

{
  return (one.value() > two.value());
}

operator>=()

bool Trk::operator>=	(	const LayerIndex &	one,
		const LayerIndex &	two )

Definition at line 30 of file LayerIndex.cxx.

{
  return (one.value() >= two.value());
}

ParaMin()

void Trk::ParaMin	(	double	b,
		double	c,
		double	d,
		double	e,
		double	f,
		double &	xmin,
		double &	ymin )

Definition at line 282 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
    ymin =  (f*b-2.*c*d)/(4.*c*e - f*f);
    if( std::abs(f) > std::abs(c) ) {  xmin = - (2.*e*ymin + d)/f;}
    else                    {  xmin = - (f*ymin+b)/(2.*c);}
    }

processCascade() [1/3]

int Trk::processCascade

(

CascadeEvent &

cascadeEvent_

)

Definition at line 244 of file CFitCascade.cxx.

{
  int translateToFittedPos(CascadeEvent &, double Step=1.);
  int restorePreviousPos(CascadeEvent &,  std::vector<VKVertex> & );
 
  VKVertex * vk;
  long int Iter, IERR, iv, i;
//============================================================================================
//
// First without pointing to get initial estimations and resolve mass constraints
// This initial step is needed to get initial estimation for "passing near constraint
//
  for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk = cascadeEvent_.cascadeVertexList[iv].get();
     IERR = fitVertexCascade( vk, 0);     if(IERR)return IERR;   //fit
     IERR = setVTrackMass(vk);            if(IERR)return IERR;   //mass of combined particle
  }
  IERR = translateToFittedPos(cascadeEvent_);          if(IERR)return IERR;
//
//  Now standard fit without pointing in cascade but WITH pointing to PV if present
//
 
  double Chi2Old=0.,Chi2Cur=0.;
  for(Iter=0; Iter<100; Iter++){
     Chi2Cur=0.;
     for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
       vk = cascadeEvent_.cascadeVertexList[iv].get();
//
//Calculate derivatives for "passing near" cnst. Initial vertex position is used for derivatives.
//Results are saved in ForVRTClose structure
       if(cascadeEvent_.nearPrmVertex && iv==(cascadeEvent_.cascadeNV-1)){   //only last vertex in cascade may have it
          double dparst[6]={vk->refIterV[0]+vk->iniV[0], vk->refIterV[1]+vk->iniV[1], vk->refIterV[2]+vk->iniV[2],
                            vk->fitMom[0], vk->fitMom[1], vk->fitMom[2] };
          vk->FVC.Charge=getVertexCharge(vk);
          if(vk->FVC.Charge!=0)vk->FVC.Charge=std::copysign(1,vk->FVC.Charge);
          vpderiv(true, vk->FVC.Charge, dparst, vk->fitCovXYZMom, vk->FVC.vrt, vk->FVC.covvrt,
                              vk->FVC.cvder, vk->FVC.ywgt, vk->FVC.rv0, (vk->vk_fitterControl).get());
       }
       IERR = fitVertexCascade( vk, 0);     if(IERR)return IERR;   //fit
       IERR = setVTrackMass(vk);            if(IERR)return IERR;   //mass of combined particle
       Chi2Cur += vk->Chi2;
//std::cout<<iv<<"---Chi2="<<vk->Chi2<<", "<<vk->refIterV[0]+vk->fitV[0]<<", "<<vk->refIterV[1]+vk->fitV[1]<<", "<<vk->refIterV[2]+vk->fitV[2]<<'\n';
     }
     if( Chi2Cur-Chi2Old > 1. && Iter){ IERR = translateToFittedPos(cascadeEvent_,0.8);}   //step limitation is case of divergence
     else                             { IERR = translateToFittedPos(cascadeEvent_,1.0);}   if(IERR)return IERR;
 
//std::cout<<" free iter="<<Iter<<", "<<Chi2Cur<<", "<<Chi2Old-Chi2Cur<<"; "<<cascadeEvent_.cascadeNV<<'\n';
     if(std::abs(Chi2Cur-Chi2Old)<0.01)break;       //stable cascade position
     if(Iter>10 && (Chi2Cur-Chi2Old)>0.)break;  //oscillations. Stop preliminary fit
     Chi2Old=Chi2Cur;
     if(Chi2Cur>1.e6 && Iter>0) return -1;   //Too bad iteration. Drop fit
  }
//  if(Chi2Cur>3000.) return -1;   // Initial solution is too bad!!!
//-------------------------------- Check constraints status
  double cnstRemnants=cascadeCnstRemnants(cascadeEvent_);
  if( cnstRemnants > 10000.e0)           return -2;   /* Constraints are not resolved. Stop fit */
  if(cnstRemnants==0. && Chi2Cur>3000. ) return -1;   // Initial solution is too bad!!!
  if(                    Chi2Cur>50000.) return -1;   // Initial solution is too bad!!!
//-------------------------------------------------------------------------
//  Attach pointing constraint to affected vertices and create working arrays
//     of correct size
//
  for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk = cascadeEvent_.cascadeVertexList[iv].get();
     if(vk->nextCascadeVrt){
       long int NTRK = vk->TrackList.size();
       vk->ConstraintList.emplace_back(new VKPointConstraint( NTRK, vk->nextCascadeVrt->refIterV , vk, false));
     }
  }
  long int fullNPar = getCascadeNPar(cascadeEvent_);
  if (fullNPar<0) return -1;
  double * fullMatrix   = new double[fullNPar*fullNPar];
  double * iniCovMatrix = new double[fullNPar*fullNPar];for(int ss=0; ss<fullNPar*fullNPar; ss++) iniCovMatrix[ss]=0.;
  double * fullLSide  = new double[fullNPar];
  double * tmpLSide   = new double[fullNPar];
  //std::unique_ptr<double[]> tmpLSide    = std::unique_ptr<double[]>(new double[fullNPar])
  std::vector<VKVertex> listVCopy(cascadeEvent_.cascadeNV);
//-------------------------------------------------------
//  Now fit with pointing constraint
//
  cascadeEvent_.matrixPnt.resize(cascadeEvent_.cascadeNV);
  long int NParCur, NStart;
  int getBack=0;  // counter of oscillations
  int fullSTOP=0; // immediate stop iteration flag
  double Chi2Diff=0.;
 
  int NFitIterationMax=100;        // Maximal amount of iterations
  int badStepCountMax=5;           // Maximal amount of bad steps
 
  cnstRemnants=100000.; double cnstProgr=1.; double minCnstRemnants=100000.;
  int badStepCount=0;
 
  for(Iter=0; Iter<=NFitIterationMax; Iter++){
     Chi2Cur=0.;
     NStart=0;
     for( iv=0; iv<fullNPar*fullNPar; iv++)fullMatrix[iv]=0.;  // zero full matrix
     for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
       vk = cascadeEvent_.cascadeVertexList[iv].get();
//
//Calculate derivatives for "passing near" cnst. Initial vertex position is used for derivatives.
//Results are saved in ForVRTClose structure
       if(cascadeEvent_.nearPrmVertex && iv==(cascadeEvent_.cascadeNV-1)){   //only last vertex in cascade may have it
          double dparst[6]={vk->refIterV[0]+vk->iniV[0], vk->refIterV[1]+vk->iniV[1], vk->refIterV[2]+vk->iniV[2],
                            vk->fitMom[0], vk->fitMom[1], vk->fitMom[2] };
          vk->FVC.Charge=getVertexCharge(vk);
          if(vk->FVC.Charge!=0)vk->FVC.Charge=std::copysign(1,vk->FVC.Charge);
          vpderiv(vk->passWithTrkCov, vk->FVC.Charge, dparst, vk->fitCovXYZMom,
             vk->FVC.vrt, vk->FVC.covvrt, vk->FVC.cvder, vk->FVC.ywgt, vk->FVC.rv0, (vk->vk_fitterControl).get());
       }
       if (vk->vk_fitterControl->vk_forcft.irob != 0) {robtest(vk, 0, Iter);}  // ROBUSTIFICATION new data structure
       if (vk->vk_fitterControl->vk_forcft.irob != 0) {robtest(vk, 1, Iter);}  // ROBUSTIFICATION new data structure
       IERR = fitVertexCascade( vk, 1 );   if(IERR) break;              //with passNear for last vertex in cascade if needed
       IERR = setVTrackMass(vk);           if(IERR) break;               //mass of combined particle
//
//Get full constraint matrix and left side for vertex
       cascadeEvent_.matrixPnt[iv]=NStart;
       NParCur = FullMCNSTfill( vk, vk->ader, tmpLSide);
//
//Move them to cascade full matrix and left side
       copyFullMtx( vk->ader, NParCur, NParCur, fullMatrix, NStart, fullNPar);
//
//Copy error matrix for left side vector (measured part T,U1,..,Un - see Billoir)
//  to correct place in iniCovMatrix matrix. Only at last step and without constraint part!!! CHECK IT!!!
       if(Iter==NFitIterationMax || fullSTOP || badStepCount>=badStepCountMax)
       copyFullMtx( vk->ader, 3+3*vk->TrackList.size(), NParCur, iniCovMatrix, NStart, fullNPar);
//
// Fill left part of the system
       for(i=0; i<NParCur; i++) fullLSide[i+NStart] = tmpLSide[i];
       NStart += NParCur;
       Chi2Cur += vk->Chi2;
//std::cout<<iv<<"--------Chi2="<<vk->Chi2<<", "<<cascadeEvent_.nearPrmVertex<<" nstart="<<NStart<<'\n';
     }
     if( (Chi2Cur>1.e8 && Iter>0) || IERR){
       delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix;
       if(Chi2Cur>1.e8) return -1;
       return IERR;
     }
//
//--- Attempt to dump oscillations by returning to good position
     cnstProgr=cascadeCnstRemnants(cascadeEvent_)/cnstRemnants;
     if( Iter>3 && cnstProgr>4. && getBack<5 && fullSTOP==0 ) {  //------ Bad previous step discovered.
       //std::cout<<" oscillation discovered="<<Iter<<" progr="<<cnstProgr<<'\n';
       IERR=restorePreviousPos(cascadeEvent_, listVCopy );
       if(IERR){ delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix; return IERR;}
       cnstRemnants=100000.; Chi2Old+=10000;                // to skip restoring on next iteration
       if(Iter==NFitIterationMax  )Iter-=2;      // to give time to converge after this operation
       if(Iter==NFitIterationMax-1)Iter-=1;      // to give time to converge after this operation
       getBack++; badStepCount=0;
       continue;
     }                    //--------- Make some copy of vertices for safety
     cnstRemnants*=cnstProgr; cnstRemnants += 1.e-6*cascadeEvent_.getAccuracyConstraint(); //VK Protection against 0
     if(cnstRemnants<minCnstRemnants)minCnstRemnants=cnstRemnants;
     if(minCnstRemnants==cnstRemnants){        //--------- Make copy of vertices for safety at best point
       for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
         listVCopy.at(iv)=*(cascadeEvent_.cascadeVertexList[iv]);     // vertex list copy
       }
     }
//--------------------------------------------------------------------------
//for( iv=0; iv<fullNPar; iv++)std::cout<<fullLSide[iv]<<", ";std::cout<<'\n';
//    std::cout<<fullLSide[3+3*2]<<", "<<fullLSide[3+3*2+1]<<", "<<
//               fullLSide[20]<<", "<<fullLSide[21]<<", "<<fullLSide[22]<<'\n';
//---------------------------------------------------------------------------
//
//  Add cross vertices derivatives
     addCrossVertexDeriv(cascadeEvent_, fullMatrix, fullNPar, cascadeEvent_.matrixPnt);
//
//   Add pseudotrack momentum fix
//
     int tstRet=fixPseudoTrackPt(fullNPar, fullMatrix, fullLSide, cascadeEvent_ );
     if( tstRet ){ delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix; return -1; }
//
//  Resolve full cascade with constraints system
//
     if( Iter<NFitIterationMax && fullSTOP==0 && badStepCount<badStepCountMax){    //Normal step. Solution of system only
       IERR = vkMSolve(fullMatrix, fullLSide, fullNPar);
       if(IERR){ delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix;return IERR;}
     }else{                                               //Last step. Solution+full error matrix
       cascadeEvent_.fullCovMatrix.reset( new double[fullNPar*fullNPar] );     //Create fresh matrix
       IERR = vkMSolve(fullMatrix, fullLSide, fullNPar, cascadeEvent_.fullCovMatrix.get());
       if(IERR){ delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix;
                 cascadeEvent_.fullCovMatrix.reset(); return IERR;}
//std::cout<<"fulcov="; for(int tt=0; tt<fullNPar; tt++)std::cout<<cascadeEvent_.fullCovMatrix[tt*fullNPar+tt]<<", "; std::cout<<'\n';
       std::unique_ptr<double[]> newCov(new double[fullNPar*fullNPar]); //Check via error transfer from left side (measured values). Gives exactly the same errors - correct!!!
       getNewCov(iniCovMatrix, cascadeEvent_.fullCovMatrix.get(), newCov.get(), fullNPar);
       cascadeEvent_.fullCovMatrix=std::move(newCov); //Unique_ptr will handle deletion automatically
     }
//
// Set fitted parameters
//
     setFittedParameters( fullLSide, cascadeEvent_.matrixPnt, cascadeEvent_ );
//
// Update pointing constraints and calculate real cascade Chi2
//
     double Chi2Full=0.;
     for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
        vk = cascadeEvent_.cascadeVertexList[iv].get();
        for(int it=0; it<(int)vk->TrackList.size(); it++){
           VKTrack * trk=vk->TrackList[it].get(); if(trk->Id >= 0)Chi2Full+=trk->Chi2;    // real track in cascade
        }
        if(cascadeEvent_.nearPrmVertex && iv==(cascadeEvent_.cascadeNV-1)){   //only last vertex in cascade may have it
           double signift = cfVrtDstSig( vk, vk->passWithTrkCov);
           Chi2Full += signift*signift;
       }
     }
     Chi2Diff=Chi2Old-Chi2Full;
     if(Chi2Diff<0. && cnstProgr>0.99)  badStepCount++;
     if(cnstRemnants==minCnstRemnants || cnstProgr<0.9)  badStepCount=0;
//std::cout.precision(5); std::cout<<" iter="<<Iter<<" separ="<<Chi2Cur<<" full="<<Chi2Full<<" iter diff="<<Chi2Full/Chi2Cur<<
//" cnstrem="<<cnstRemnants<<" progr="<<cnstProgr<<" lim="<<cnstRemnants/minCnstRemnants<<" bstep="<<badStepCount<<'\n';
     bool badFullStep=false;
     if( Iter>5 && Chi2Full/Chi2Cur>1.2)          badFullStep=true;   //VK 16.04.2013 New strategy
     if( Iter==NFitIterationMax || fullSTOP )     badFullStep=false;  //VK 16.04.2013 No step limitation on last iteration
//
//  Prepare next iteration
//
     if(badFullStep) IERR = translateToFittedPos(cascadeEvent_,0.3);
     else            IERR = translateToFittedPos(cascadeEvent_);
     if(IERR){ delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix; return IERR;}
 
     for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
        vk = cascadeEvent_.cascadeVertexList[iv].get();
        if(vk->nextCascadeVrt){
          int pntCnst = vk->ConstraintList.size() - 1;  // pointing constraint is always last in the list
          VKPointConstraint * pcnst = dynamic_cast<VKPointConstraint*>(vk->ConstraintList[pntCnst].get());
          pcnst->setTargetVertex(vk->nextCascadeVrt->refIterV);
        }
     }
//
 
     if(fullSTOP) break;
     if(cnstRemnants>1.e4&&Iter>10)     //no way to fulfil constraints
       { delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix; return -2;}
//
     if( Iter<NFitIterationMax && Iter>2){
       if(std::abs(Chi2Diff)<0.001 && cnstRemnants/minCnstRemnants<10.){   //stable cascade position before end of cycling
         NFitIterationMax=Iter+1;                           //then makes additional iteration to get the full error matrix
       }
       if(cnstRemnants<cascadeEvent_.getAccuracyConstraint()) fullSTOP++;   //Good constraint accuracy is reached
     }
     if ( Iter>NFitIterationMax+50 ) break;     //Protection - too many iterations due to whatever reason.
     if(badStepCount>badStepCountMax)break;     //Divergence discovered (in both cases the full error matrix is ready!!!)
 
     Chi2Old=Chi2Full;
  }
 
  //if(tmpc0)std::cout<<(*tmpc0)<<'\n';
  //if(tmpc1)std::cout<<(*tmpc1)<<'\n';
 
  delete[] fullMatrix; delete[] fullLSide; delete[] tmpLSide; delete[] iniCovMatrix;
//-------------------------------- Check constraints status
  cnstRemnants=cascadeCnstRemnants(cascadeEvent_);
//std::cout<<"fullcnst="<<cnstRemnants<<" lim="<<cnstRemnants/minCnstRemnants<<'\n';
  if( cnstRemnants > 1.e0) return -2;           /* Constraints are not resolved. Stop fit */
  return 0;
}

processCascade() [2/3]

int Trk::processCascade	(	CascadeEvent &	cascadeEvent_,
		const double *	primVrt,
		const double *	primVrtCov )

Definition at line 532 of file CFitCascade.cxx.

{
    cascadeEvent_.nearPrmVertex=1;                                             //setting up additional Chi2 term
    VKVertex * vk = cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1].get(); //Main vertex
    vk->passNearVertex  =true;                        // For fitting machinery
    vk->passWithTrkCov  =true;                        // For fitting machinery
    std::copy(primVrt, primVrt+3, vk->FVC.vrt);
    std::copy(primVrtCov, primVrtCov+6, vk->FVC.covvrt);
    return processCascade(cascadeEvent_);
}

processCascade() [3/3]

int Trk::processCascade	(	CascadeEvent &	cascadeEvent_,
		double *	primVrt )

Definition at line 546 of file CFitCascade.cxx.

{
    VKVertex * vk = cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1].get(); //Main vertex
    long int NTRK = vk->TrackList.size();
    vk->ConstraintList.emplace_back(new VKPointConstraint( NTRK, primVrt, vk, false));
    cascadeEvent_.nearPrmVertex=0;                 //explicitly turn off additional Chi2 term
    return processCascade(cascadeEvent_);
}

processCascadePV()

int Trk::processCascadePV	(	CascadeEvent &	cascadeEvent_,
		const double *	primVrt,
		const double *	primVrtCov )

Definition at line 504 of file CFitCascade.cxx.

{
    double aermd[6],tmpd[6];  // temporary arrays
    VKVertex * vk = cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1].get(); //Main vertex
 
    vk->vk_fitterControl->vk_forcft.vrt[0] = primVrt[0];
    vk->vk_fitterControl->vk_forcft.vrt[1] = primVrt[1];
    vk->vk_fitterControl->vk_forcft.vrt[2] = primVrt[2];
    vk->vk_fitterControl->vk_forcft.covvrt[0] = primVrtCov[0];
    vk->vk_fitterControl->vk_forcft.covvrt[1] = primVrtCov[1];
    vk->vk_fitterControl->vk_forcft.covvrt[2] = primVrtCov[2];
    vk->vk_fitterControl->vk_forcft.covvrt[3] = primVrtCov[3];
    vk->vk_fitterControl->vk_forcft.covvrt[4] = primVrtCov[4];
    vk->vk_fitterControl->vk_forcft.covvrt[5] = primVrtCov[5];
 
    vk->useApriorVertex = 1;
    cfdcopy(vk->vk_fitterControl->vk_forcft.covvrt, tmpd,   6);
    int IERR=cfdinv(tmpd, aermd, -3); if (IERR) {  IERR = -4; return IERR; }
    cfdcopy(vk->vk_fitterControl->vk_forcft.vrt, vk->apriorV,   3);
    cfdcopy(      aermd, vk->apriorVWGT,6);
 
    return processCascade(cascadeEvent_);
}

processCascadeScale()

int Trk::processCascadeScale

(

CascadeEvent &

cascadeEvent_

)

Definition at line 129 of file CFitCascadeScale.cxx.

{
  VKVertex * vk=nullptr;
  long int Iter, IERR, iv;
  cascadeEvent_.setSCALE(1.);                    // Safety
//============================================================================================
//
// First without pointing to get initial estimations and resolve mass constraints
// This initial step is needed to get initial estimation for "passing near" constraints
//
  double iv_dstToVrt=0., sum_dstToVrt=0., old_dstToVrt;
  for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk = cascadeEvent_.cascadeVertexList[iv].get();
     vk->passNearVertex=false;
     vk->passWithTrkCov=false;
     IERR = fitVertexCascadeScale( vk, iv_dstToVrt );    if(IERR)return IERR;   //fit
     IERR = setVTrackMass(vk);                           if(IERR)return IERR;   //mass of combined particle
  }
  IERR = translateToFittedPos(cascadeEvent_);          if(IERR)return IERR;
 
//
//  Now fit "close to vertex" pointing and cooling
//
  for(iv=0; iv<cascadeEvent_.cascadeNV-1; iv++) cascadeEvent_.cascadeVertexList[iv]->passNearVertex=true;
  if(cascadeEvent_.nearPrmVertex){  // Primary vertex if needed
     cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1]->passNearVertex=true;
     cascadeEvent_.cascadeVertexList[cascadeEvent_.cascadeNV-1]->passWithTrkCov=true;
  }
//
  double Chi2Old=0.,Chi2Cur=0;
  double Scale=2.;
  double limDstToVrt=0.001;
  old_dstToVrt=100000.;
  for(Iter=0; Iter<20; Iter++){
 
    //*******************************************************************************
    for(int Stabil=0; Stabil<2; Stabil++){  // Stabilization cycling for given SCALE
      Chi2Cur=0.;
      sum_dstToVrt=0.;
      for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
        vk = cascadeEvent_.cascadeVertexList[iv].get();
//
//Calculate derivatives for "passing near" cnst. Initial vertex position is used for derivatives.
        if(vk->passNearVertex){
          double dparst[6]={vk->refIterV[0]+vk->iniV[0], vk->refIterV[1]+vk->iniV[1], vk->refIterV[2]+vk->iniV[2],
                        vk->fitMom[0], vk->fitMom[1], vk->fitMom[2] };
      vpderiv(vk->passWithTrkCov, vk->FVC.Charge, dparst, vk->fitCovXYZMom, vk->FVC.vrt, vk->FVC.covvrt,
                                                 vk->FVC.cvder, vk->FVC.ywgt, vk->FVC.rv0, (vk->vk_fitterControl).get());
        }
        IERR = fitVertexCascadeScale( vk, iv_dstToVrt);    if(IERR)return IERR;   //fit
        IERR = setVTrackMass(vk);                          if(IERR)return IERR;   //mass of combined particle
        Chi2Cur += vk->Chi2;
        sum_dstToVrt += iv_dstToVrt;
      }
      IERR = translateToFittedPos(cascadeEvent_,1.0);   if(IERR)return IERR;
      //if(Stabil>0 && sum_dstToVrt<old_dstToVrt) break;
    }
    //********************************************************************************
    if(Iter>5 && Chi2Cur>1.e4) return -1;      //Too bad iteration. Drop fit
    if(cascadeEvent_.getSCALE() < 1.e-6)Scale=1.;   //Enough tightening
    if(sum_dstToVrt<old_dstToVrt){
       rescaleVrtErrForPointing( Scale, cascadeEvent_ );    // Tighten pointing accuracy
       if(old_dstToVrt/3. < sum_dstToVrt) { old_dstToVrt=sum_dstToVrt;} else {old_dstToVrt/=3.;}
    }
//std::cout<<"Cool iter="<<Iter<<" Scale="<<cascadeEvent_.getSCALE()<<", "<<Chi2Cur<<" NV="<<cascadeEvent_.cascadeNV<<
//           " dst="<<sum_dstToVrt<<'\n';
    if(std::abs(Chi2Cur-Chi2Old)<0.01 && Iter>5 && sum_dstToVrt<limDstToVrt*(cascadeEvent_.cascadeNV-1) )break;       //stable cascade position
    Chi2Old=Chi2Cur;
  }
  double cnstRemnants=0. ;
  for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk = cascadeEvent_.cascadeVertexList[iv].get();
     for(int ii=0; ii<(int)vk->ConstraintList.size();ii++){
        for(int ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
           cnstRemnants +=  std::abs( vk->ConstraintList[ii]->aa[ic] );
     } }
  }
  if( cnstRemnants > 1.e0) return -2;                                        /* Constraints are not resolved. Stop fit */
std::cout<<"================================================="<<sum_dstToVrt<<'\n';
//  if(sum_dstToVrt>limDstToVrt*(cascadeEvent_.cascadeNV-1) )return -2;        //Pointing is not resolved
 
  long int fullNPar = getCascadeNPar(cascadeEvent_);
  cascadeEvent_.fullCovMatrix.reset( new double[fullNPar*fullNPar] );
  for(int im=0; im<fullNPar*fullNPar; im++)cascadeEvent_.fullCovMatrix[im]=0.;
  for(int im=0; im<fullNPar; im++)cascadeEvent_.fullCovMatrix[im*fullNPar + im]=1.;
  int NStart=0;
  cascadeEvent_.matrixPnt.resize(cascadeEvent_.cascadeNV);
  auto tmpLSide   = std::make_unique<double[]>(fullNPar);
  for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
    cascadeEvent_.matrixPnt[iv]=NStart;
    NStart  += FullMCNSTfill( vk, vk->ader, tmpLSide.get());
  }
 
  return 0;
}

propJacobian()

ATH_ALWAYS_INLINE void Trk::propJacobian	(	double *ATH_RESTRICT	P,
		const double *ATH_RESTRICT	H0,
		const double *ATH_RESTRICT	H1,
		const double *ATH_RESTRICT	H2,
		const double *ATH_RESTRICT	A,
		const double *ATH_RESTRICT	A0,
		const double *ATH_RESTRICT	A3,
		const double *ATH_RESTRICT	A4,
		const double *ATH_RESTRICT	A6,
		const double	S3 )

This provides an inline helper function for updating the jacobian during Runge-Kutta propagation.

Used in several clients, put in here to avoid code duplication Based on the existing implementation, but using vectorisation to improve speed by approximately 30%.

The mathematics behind this procedure are documented in JINST 4 (2009) P04016 also found as http://cds.cern.ch/record/1114177 / https://inspirehep.net/literature/826186

In this implementation, we preserve the conventions of client code, hence the use of array pointers rather than std constructs. P is a 42-element array containing global coordinates, direction, inverse momentum and Jacobian of transformation. Its elements are updated in-place by this method. H0, H1, and H3 represent the field at the three points eachj is a 3-element array A represents the direction vector before propagation It is a 3-vector A0, A3, A4, and A6 represent cross products of the direction with the field across the 3 points. Each is a 3-vector. S3 is a step length

now update the parameter array in the slots representing the Jacobian

Definition at line 41 of file JacobianHelper.h.

{
  using namespace CxxUtils;
  using vec2 = CxxUtils::vec<double, 2>;
 
  vec2 d23A_0{ P[24], P[31] };
  vec2 d23A_1{ P[25], P[32] };
  vec2 d23A_2{ P[26], P[33] };
  const double d4A_0 = P[38];
  const double d4A_1 = P[39];
  const double d4A_2 = P[40];
  // H
  const double H0_0 = H0[0];
  const double H0_1 = H0[1];
  const double H0_2 = H0[2];
  const double H1_0 = H1[0];
  const double H1_1 = H1[1];
  const double H1_2 = H1[2];
  const double H2_0 = H2[0];
  const double H2_1 = H2[1];
  const double H2_2 = H2[2];
  //
  vec2 d23A0 = H0_2 * d23A_1 - H0_1 * d23A_2;
  vec2 d23B0 = H0_0 * d23A_2 - H0_2 * d23A_0;
  vec2 d23C0 = H0_1 * d23A_0 - H0_0 * d23A_1;
  const double d4A0 = (A0[0] + H0_2 * d4A_1) - H0_1 * d4A_2;
  const double d4B0 = (A0[1] + H0_0 * d4A_2) - H0_2 * d4A_0;
  const double d4C0 = (A0[2] + H0_1 * d4A_0) - H0_0 * d4A_1;
  //
  vec2 d23A2 = d23A0 + d23A_0;
  vec2 d23B2 = d23B0 + d23A_1;
  vec2 d23C2 = d23C0 + d23A_2;
  const double d4A2 = d4A0 + d4A_0;
  const double d4B2 = d4B0 + d4A_1;
  const double d4C2 = d4C0 + d4A_2;
  const double d0 = d4A_0 - A[0];
  const double d1 = d4A_1 - A[1];
  const double d2 = d4A_2 - A[2];
  //
  vec2 d23A3 = (d23A_0 + d23B2 * H1_2) - d23C2 * H1_1;
  vec2 d23B3 = (d23A_1 + d23C2 * H1_0) - d23A2 * H1_2;
  vec2 d23C3 = (d23A_2 + d23A2 * H1_1) - d23B2 * H1_0;
  const double d4A3 = ((A3[0] + d0) + d4B2 * H1_2) - d4C2 * H1_1;
  const double d4B3 = ((A3[1] + d1) + d4C2 * H1_0) - d4A2 * H1_2;
  const double d4C3 = ((A3[2] + d2) + d4A2 * H1_1) - d4B2 * H1_0;
  //
  vec2 d23A4 = (d23A_0 + d23B3 * H1_2) - d23C3 * H1_1;
  vec2 d23B4 = (d23A_1 + d23C3 * H1_0) - d23A3 * H1_2;
  vec2 d23C4 = (d23A_2 + d23A3 * H1_1) - d23B3 * H1_0;
  const double d4A4 = ((A4[0] + d0) + d4B3 * H1_2) - d4C3 * H1_1;
  const double d4B4 = ((A4[1] + d1) + d4C3 * H1_0) - d4A3 * H1_2;
  const double d4C4 = ((A4[2] + d2) + d4A3 * H1_1) - d4B3 * H1_0;
  //
  vec2 d23A5 = 2. * d23A4 - d23A_0;
  vec2 d23B5 = 2. * d23B4 - d23A_1;
  vec2 d23C5 = 2. * d23C4 - d23A_2;
  const double d4A5 = 2. * d4A4 - d4A_0;
  const double d4B5 = 2. * d4B4 - d4A_1;
  const double d4C5 = 2. * d4C4 - d4A_2;
  //
  vec2 d23A6 = d23B5 * H2_2 - d23C5 * H2_1;
  vec2 d23B6 = d23C5 * H2_0 - d23A5 * H2_2;
  vec2 d23C6 = d23A5 * H2_1 - d23B5 * H2_0;
  double d4A6 = d4B5 * H2_2 - d4C5 * H2_1;
  double d4B6 = d4C5 * H2_0 - d4A5 * H2_2;
  double d4C6 = d4A5 * H2_1 - d4B5 * H2_0;
 
  vec2 dR23_A = (d23A2 + d23A3 + d23A4) * S3;
  vec2 dR23_B = (d23B2 + d23B3 + d23B4) * S3;
  vec2 dR23_C = (d23C2 + d23C3 + d23C4) * S3;
 
  vec2 res23_0 = ((d23A0 + 2. * d23A3) + (d23A5 + d23A6)) * (1. / 3.);
  vec2 res23_1 = ((d23B0 + 2. * d23B3) + (d23B5 + d23B6)) * (1. / 3.);
  vec2 res23_2 = ((d23C0 + 2. * d23C3) + (d23C5 + d23C6)) * (1. / 3.);

  P[21] += dR23_A[0];
  P[22] += dR23_B[0];
  P[23] += dR23_C[0];
  P[24] = res23_0[0];
  P[25] = res23_1[0];
  P[26] = res23_2[0];
 
  P[28] += dR23_A[1];
  P[29] += dR23_B[1];
  P[30] += dR23_C[1];
  P[31] = res23_0[1];
  P[32] = res23_1[1];
  P[33] = res23_2[1];
 
  P[35] += (d4A2 + d4A3 + d4A4) * S3;
  P[36] += (d4B2 + d4B3 + d4B4) * S3;
  P[37] += (d4C2 + d4C3 + d4C4) * S3;
  P[38] = ((d4A0 + 2. * d4A3) + (d4A5 + d4A6 + A6[0])) * (1. / 3.);
  P[39] = ((d4B0 + 2. * d4B3) + (d4B5 + d4B6 + A6[1])) * (1. / 3.);
  P[40] = ((d4C0 + 2. * d4C3) + (d4C5 + d4C6 + A6[2])) * (1. / 3.);
}

rescaleVrtErrForPointing()

void Trk::rescaleVrtErrForPointing	(	double	Div,
		CascadeEvent &	cascadeEvent_ )

Definition at line 32 of file CFitCascadeScale.cxx.

{
   if(Div<1.)Div=1.;
   cascadeEvent_.setSCALE(cascadeEvent_.getSCALE()/Div);
   for(int iv=0; iv<cascadeEvent_.cascadeNV-1; iv++){        // Last vertex must not be touched
     VKVertex *vk = cascadeEvent_.cascadeVertexList[iv].get();
     for(int i=0; i<6; i++) vk->FVC.covvrt[i] /=Div;
   }
}

ResidualPullType()

ResidualPull::ResidualType Trk::ResidualPullType

(

AlignResidualType

type

)

Definition at line 41 of file AlignResidualType.cxx.

  {
    // defines mapping between residual types for the alignment and those
    // used in the ResidualPullCalculator
    switch(type)
    {
      case HitOnly:
        return ResidualPull::HitOnly;
      case Unbiased:
//      case DCA:
        return ResidualPull::Unbiased;
      default:
        return ResidualPull::HitOnly;
    }
  }

restorePreviousPos()

int Trk::restorePreviousPos	(	CascadeEvent &	cascadeEvent_,
		std::vector< VKVertex > &	SV )

Definition at line 640 of file CFitCascade.cxx.

{
  int iv,it;
  long int NTRK;
  VKTrack * trk; VKTrack * trks; VKVertex * vk; VKVertex * vks;
 
  for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk=cascadeEvent_.cascadeVertexList[iv].get();
     vks=&SV[iv];
     NTRK = vk->TrackList.size();            // Number of tracks at vertex
     vk->refIterV[0]=vks->refIterV[0];
     vk->refIterV[1]=vks->refIterV[1];
     vk->refIterV[2]=vks->refIterV[2];
     vk->iniV[0] = vk->fitV[0] = vk->cnstV[0]=0.;
     vk->iniV[1] = vk->fitV[1] = vk->cnstV[1]=0.;
     vk->iniV[2] = vk->fitV[2] = vk->cnstV[2]=0.;
     cfdcopy(vks->fitMom,       vk->fitMom, 3);        //saved Momentum
     cfdcopy(vks->fitCovXYZMom, vk->fitCovXYZMom, 21); //saved XYZMom covariance
     for(it=0; it<NTRK; it++){
       trk =vk ->TrackList[it].get();                  //  working track
       trks=vks->TrackList[it].get();                // track from saved copy
       if(trk->Id < 0) {     // pseudo-track from cascade vertex
          //trk->fitP[2]=0.;        // reset the pseudo-track parameters
          trk->fitP[0] =(trks->iniP[0]+trks->fitP[0])/2.;
          trk->fitP[1] = trks->iniP[1];
          trk->fitP[2] =(trks->iniP[2]+trks->fitP[2])/2.;
      continue;
       }
       cfdcopy(trks->Perig,  trk->Perig, 5);
       cfdcopy(trks->WgtM,   trk->WgtM, 15);
       cfdcopy(trks->fitP,   trk->fitP,  3);
       cfdcopy(trks->iniP,   trk->iniP,  3);
       cfdcopy(trks->cnstP,  trk->cnstP, 3);
     }
  }
  for(iv=0; iv<cascadeEvent_.cascadeNV; iv++){
    vk = cascadeEvent_.cascadeVertexList[iv].get();
    if(vk->nextCascadeVrt){
       int pntCnst = vk->ConstraintList.size() - 1;  // pointing constraint is always last in the list
       if(vk->ConstraintList[pntCnst]->getType() != VKConstraintType::Point) return -1;
       static_cast< VKPointConstraint* >(vk->ConstraintList[pntCnst].get())->setTargetVertex(vk->nextCascadeVrt->refIterV);
    }
  }
  return 0;
}

robtest()

void Trk::robtest	(	VKVertex *	vk,
		int	ifl,
		int	nIteration )

Definition at line 14 of file RobTest.cxx.

{
    long int i, j, k, kk, it;
    double rob, res, c[5], darg, absX, roba[5];
 
/* ------------------------------------------------------------ */
/*  Robustification procedure for weight matrix */
/*  IROB  = 0  - Standard chi^2 */
/*        = 1  - Geman-McClure function */
/*        = 2  - Welch function */
/*        = 3  - Cauchy function */
/*        = 4  - L1-L2 function */
/*        = 5  - Fair function */
/*        = 6  - Huber function */
/*        = 7  - Modified Huber function */
/*   (1,2,3)  - Zero outliers */
/*   (4,5,6,7)  - Downweight outliers */
/* Author: V.Kostyukhin */
/* ------------------------------------------------------------ */
 
    int NTRK = vk->TrackList.size();
 
    long int irob = vk->vk_fitterControl->vk_forcft.irob;
    double    Scl = vk->vk_fitterControl->vk_forcft.RobustScale;  //Tuning constant
    double    C;                          // Breakdown constant
 
    if(!vk->vk_fitterControl->m_frozenVersionForBTagging)Scl *= (1.+exp(3.-nIteration)); //Annealing
 
    if ( ifl == 0) {                               /* FILLING OF EIGENVALUES AND VECTORS */
        for (it = 0; it < NTRK ; ++it) {               /* RESTORE MATRIX */
            VKTrack *trk=vk->TrackList[it].get();
            if(trk->Id < 0) continue;  // Not a real track
            vkGetEigVect(trk->WgtM, trk->e ,&(trk->v[0][0]), 5);
        }
        return;
    }
/* -- */
    double    halfPi=M_PI/2.;
    for (it = 0; it < NTRK; ++it) {
        VKTrack *trk=vk->TrackList[it].get();
        if(trk->Id < 0) continue;  // Not a real track
        c[0]=c[1]=c[2]=c[3]=c[4]=0.;
        for( k = 0; k < 5; k++){
          c[0] +=   trk->rmnd[k] * trk->v[0][k];
          c[1] +=   trk->rmnd[k] * trk->v[1][k];
          c[2] +=   trk->rmnd[k] * trk->v[2][k];
          c[3] +=   trk->rmnd[k] * trk->v[3][k];
          c[4] +=   trk->rmnd[k] * trk->v[4][k];
        }
    for (k = 0; k < 5; ++k) {
      darg = c[k]*c[k]*trk->e[k];
      if(darg < 1.e-10) darg = 1.e-10;
      absX = sqrt(darg);                          /* Abs(X) == sqrt(X)*/
      rob = 1.; C=1;
      if(irob == 1)C = 1.58*Scl;                  /* Geman-McClure Standard =1 but c^2=2.5 is better(Gem.McC) */
      if(irob == 2)C = 2.9846*Scl;                /* Welch def c^2=2.9846^2 */
      if(irob == 3)C = 2.3849*Scl;                /* Cauchy def 2.385^2=5.7 */
      if(irob == 4)C = 1.;                        /* L1-L2  no tuning*/
      if(irob == 5)C = 1.3998*Scl;                /* Fair (def=1.3998)*/
      if(irob == 6)C = 1.345 *Scl;                /* Huber (def=1.345)*/
      if(irob == 7)C = 1.2107 *Scl;               /* Modified Huber (def=1.2107)*/
/* Functionals here are divided by (X^2/2)!!!*/
          double C2=C*C;
      if(irob == 1)rob = 1. / (darg/C2 + 1.);                                  /* Geman-McClure */
      if(irob == 2)rob = C2*(1. - exp(-darg/C2) )/darg;                        /* Welch */
      if(irob == 3)rob = C2*log(darg/C2 + 1.)/darg;                            /* Cauchy  */
      if(irob == 4)rob = 4.*(sqrt(darg / 2. + 1.) - 1.)/darg;                  /* L1-L2 */
      if(irob == 5)rob = 2.*C2*(absX/C - log(absX/C + 1.))/darg;               /* Fair */
      if(irob == 6)rob = C>absX ? 1. : (2*C/absX - C*C/darg) ;                 /* Huber */
      if(irob == 7)rob = halfPi>(absX/C) ? 2*C*C*(1-cos(absX/C))/darg :
                                               2*(C*absX+C*C*(1.-halfPi))/darg;    /* Modified Huber */
          roba[k] = rob;
          if(rob>0.99)roba[k] = 1.; //To improve precision
    }
    for (i = 0; i < 5; ++i) if(roba[i]<1.e-3)roba[i]=1.e-3;
    kk = 0;
    for (i = 0; i < 5; ++i) {
        for (j = 0; j <= i; ++j) {
        res = 0.;
        for (k = 0; k < 5; ++k) {
                    res += trk->v[k][i] * trk->e[k] * trk->v[k][j]*roba[k];
        }
        trk->WgtM[kk]=res;
        kk++;
        }
    }
    vk->vk_fitterControl->vk_forcft.robres[it] = roba[0] * roba[1] * roba[2] * roba[3] * roba[4];
    if(vk->vk_fitterControl->vk_forcft.robres[it]>1.)vk->vk_fitterControl->vk_forcft.robres[it]=1.;
    }
}

setCascadeMassConstraint() [1/2]

int Trk::setCascadeMassConstraint	(	CascadeEvent &	cascadeEvent_,
		long int	IV,
		double	Mass )

Definition at line 241 of file CascadeDefinition.cxx.

                                          {
  if (IV > cascadeEvent_.cascadeNV - 1) {
    return -1;  // error in format
  }
  if (IV < 0) {
    return -1;
  }
  VKVertex *vk = cascadeEvent_.cascadeVertexList[IV].get();  // target vertex
  int NTRK = vk->TrackList.size();
  vk->ConstraintList.emplace_back(new VKMassConstraint(NTRK, Mass, vk));
  return 0;
}

setCascadeMassConstraint() [2/2]

int Trk::setCascadeMassConstraint	(	CascadeEvent &	cascadeEvent_,
		long int	IV,
		std::vector< int > &	trkInVrt,
		std::vector< int > &	pseudoInVrt,
		double	Mass )

Definition at line 260 of file CascadeDefinition.cxx.

                                                                       {
  std::vector<int> tmpIndex;
  int it;
  if (IV > cascadeEvent_.cascadeNV - 1)
    return -1;  // error in format
  if (IV < 0)
    return -1;
  VKVertex *vk = cascadeEvent_.cascadeVertexList[IV].get();  // target vertex
  int NTRK = vk->TrackList.size();  // tracks+pseudotracks
  int nRealTrk = 0;                 // number of real tracks
  for (it = 0; it < (int)trkInVrt.size(); it++) {
    if (vk->TrackList[it]->Id >= 0) {
      nRealTrk++;
    }
  }
  //
  //-- Real tracks
  //
  if ((int)trkInVrt.size() > NTRK) {
    return -1;  // checks...
  }
  for (it = 0; it < (int)trkInVrt.size(); it++) {
    if (trkInVrt[it] < 0) {
      return -1;
    }
    if (trkInVrt[it] >= NTRK) {
      return -1;
    }
    tmpIndex.push_back(trkInVrt[it]);
  }
  //
  //-- Pseudo tracks
  //
  if ((int)pseudoInVrt.size() > NTRK) {
    return -1;  // checks...
  }
  for (int it = 0; it < (int)pseudoInVrt.size(); it++) {
    if (pseudoInVrt[it] < 0) {
      return -1;
    }
    if (pseudoInVrt[it] >= NTRK) {
      return -1;
    }
    tmpIndex.push_back(pseudoInVrt[it] + nRealTrk);
  }
 
  vk->ConstraintList.emplace_back(
      new VKMassConstraint(NTRK, Mass, std::move(tmpIndex), vk));
  return 0;
}

setFittedMatrices()

void Trk::setFittedMatrices	(	const double *	COVFIT,
		long int	MATRIXSIZE,
		std::vector< int > &	matrixPnt,
		std::vector< std::vector< double > > &	covarCascade,
		CascadeEvent &	cascadeEvent_ )

Definition at line 168 of file CascadeUtils.cxx.

{
   int iv, Pnt, ic, ir, vrtMtxSize, count;
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     VKVertex *vk = cascadeEvent_.cascadeVertexList[iv].get();
     Pnt=matrixPnt[iv];    // start of vertex parameters
     vrtMtxSize=3+vk->TrackList.size()*3;         //size of matrix for given vertex
     std::vector<double> Res(vrtMtxSize*(vrtMtxSize+1)/2);
     count=0;
     for (int col=0; col<vrtMtxSize; col++){
       for (int row=0; row<=col; row++){
          ic=Pnt+col; ir=Pnt+row;
          Res[count]=COVFIT[ic*MATRIXSIZE + ir]; count++;
       }
     }
     covarCascade.emplace_back(std::move(Res));
   }
}

setFittedParameters()

void Trk::setFittedParameters	(	const double *	result,
		std::vector< int > &	matrixPnt,
		CascadeEvent &	cascadeEvent_ )

Definition at line 151 of file CascadeUtils.cxx.

{
   int iv,it,Pnt;
   for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     VKVertex *vk = cascadeEvent_.cascadeVertexList[iv].get();
     Pnt=matrixPnt[iv];    // start of vertex parameters
     vk->fitV[0]=result[Pnt]; vk->fitV[1]=result[Pnt+1]; vk->fitV[2]=result[Pnt+2];
     for( it=0; it<(int)vk->TrackList.size(); it++){
        VKTrack * trk=vk->TrackList[it].get();
        trk->fitP[0]=trk->iniP[0]+result[Pnt+3+it*3 + 0];
        trk->fitP[1]=trk->iniP[1]+result[Pnt+3+it*3 + 1];
        trk->fitP[2]=trk->iniP[2]+result[Pnt+3+it*3 + 2];
        trk->Chi2 = cfchi2(vk->fitV, trk->fitP, trk );
     }
   }
}

setVTrackMass()

int Trk::setVTrackMass

(

VKVertex *

vk

)

Definition at line 34 of file CFitCascade.cxx.

{
   double vBx,vBy,vBz;
   int it, NTRK;
   VectMOM totP{};
 
   if(!vk->nextCascadeVrt)return 0;               // nonpointing vertex
 
   Trk::vkalMagFld::getMagFld(vk->refIterV[0]+vk->fitV[0], vk->refIterV[1]+vk->fitV[1], vk->refIterV[2]+vk->fitV[2],
                                        vBx,vBy,vBz,(vk->vk_fitterControl).get());
 
   NTRK = vk->TrackList.size();                   // Number of tracks at vertex
   totP.Px=0.;totP.Py=0.;totP.Pz=0.;totP.E=0.;
   for(it=0; it<NTRK; it++){
       std::array<double, 4> pp = getFitParticleMom( vk->TrackList[it].get(), vBz );
       totP.Px += pp[0];
       totP.Py += pp[1];
       totP.Pz += pp[2];
       totP.E  += pp[3];
   }
   VKTrack * target_trk = getCombinedVTrack(vk);
   if( target_trk == nullptr ) {
       std::cout<<" ERROR in CASCADE STRUCTURE"<<'\n';
       return -1;
   }
       double Pt=sqrt(totP.Px*totP.Px + totP.Py*totP.Py);
       double Mass;
       if(Pt > std::abs(totP.Pz)){
         Mass = sqrt( (totP.E-Pt)*(totP.E+Pt) - totP.Pz*totP.Pz);
       }else{
         Mass = sqrt( (totP.E-totP.Pz)*(totP.E+totP.Pz) - Pt*Pt);
       }
       target_trk->setMass(Mass);
 
   return 0;
}

SymIndex()

int Trk::SymIndex ( int it, int i, int j )

inline

Definition at line 271 of file TrkCascadeFitter.cxx.

{  return (3*it+3+i)*(3*it+3+i+1)/2 + (3*it+3+j);}

tdasatVK()

void Trk::tdasatVK	(	const double *	Der,
		const double *	CovI,
		double *	CovF,
		long int	M,
		long int	N )

Definition at line 218 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Utilities.cxx.

{
   int i,j,k,f;
   for( k=0; k<M; k++) {        // sycle on output index
      for( f=0; f<=k; f++ ) {   //
         double sum=0.;
     for( i=0; i<N; i++){
           double tmp=0.;
       for( j=0; j<N; j++) tmp += CovI[sIndexVK(i,j)]*Der[j+f*N];
           sum += Der[i+k*N]*tmp;
         }
     CovF[sIndexVK(k,f)]=sum;
      }
   }
}

transformCovar()

std::vector< double > Trk::transformCovar	(	int	NPar,
		double **	Deriv,
		const std::vector< double > &	covarI )

Definition at line 191 of file CascadeUtils.cxx.

{
      std::vector<double> covarO(NPar*(NPar+1)/2, 0.);
      int ii,ij,oi,oj, indexO, indexI;
      for(oi=0; oi<NPar; oi++){
        for(oj=0; oj<=oi; oj++){
            indexO = oi*(oi+1)/2+oj;
            for(ii=0; ii<NPar; ii++){
              for(ij=0; ij<NPar; ij++){
                indexI = ii>=ij ? ii*(ii+1)/2+ij : ij*(ij+1)/2+ii;
                covarO[indexO] += Deriv[oi][ii]*covarI[indexI]*Deriv[oj][ij];
      } }   } }
      return covarO;
}

translateToFittedPos()

int Trk::translateToFittedPos	(	CascadeEvent &	cascadeEvent_,
		double	Step )

Definition at line 560 of file CFitCascade.cxx.

{
  int iv,it;
  long int IERR,NTRK;
  double vShift, tmpPer[5], tmpWgt[15], tmpCov[15], targetVertex[3];
  VKTrack * trk; VKVertex * vk;
  if(Step>1.)Step=1.;
 
  for( iv=0; iv<cascadeEvent_.cascadeNV; iv++){
     vk=cascadeEvent_.cascadeVertexList[iv].get();
     NTRK = vk->TrackList.size();            // Number of tracks at vertex
     targetVertex[0]=vk->refIterV[0] + vk->fitV[0]*Step;  // target vertex for extrapolation
     targetVertex[1]=vk->refIterV[1] + vk->fitV[1]*Step;
     targetVertex[2]=vk->refIterV[2] + vk->fitV[2]*Step;
     vShift = sqrt( (vk->refV[0]-targetVertex[0])*(vk->refV[0]-targetVertex[0])
               +(vk->refV[1]-targetVertex[1])*(vk->refV[1]-targetVertex[1])
                   +(vk->refV[2]-targetVertex[2])*(vk->refV[2]-targetVertex[2]) );
     for(auto *pvx : vk->includedVrt){ //Check space position of internal vertex
        double dirMom=(pvx->refIterV[0]-targetVertex[0])*pvx->fitMom[0]+
                      (pvx->refIterV[1]-targetVertex[1])*pvx->fitMom[1]+
                      (pvx->refIterV[2]-targetVertex[2])*pvx->fitMom[2];
        if(dirMom<0.)cfdcopy(pvx->refIterV,targetVertex,3);
     }
     bool insideGoodVolume=false;
     if(vk->vk_fitterControl && vk->vk_fitterControl->vk_objProp)
          { insideGoodVolume = vk->vk_fitterControl->vk_objProp->checkTarget(targetVertex, *vk->vk_fitterControl->vk_istate);}
     else { insideGoodVolume = Trk::vkalPropagator::checkTarget(targetVertex); }
     if(!insideGoodVolume) { return -16; }       //Vertex is definitely outside working volume
     for(it=0; it<NTRK; it++){
       trk=vk->TrackList[it].get();
       if(trk->Id < 0){                // pseudo-track from cascade vertex
          trk->fitP[0] =trk->iniP[0]+ Step*(trk->fitP[0]-trk->iniP[0]);
          trk->fitP[1] =trk->iniP[1]+ Step*(trk->fitP[1]-trk->iniP[1]);
          trk->fitP[2] =trk->iniP[2]+ Step*(trk->fitP[2]-trk->iniP[2]);
          continue;
       }
       Trk::vkalPropagator::Propagate(trk, vk->refV,  targetVertex, tmpPer, tmpCov, (vk->vk_fitterControl).get());
 //Check!!!And protection if needed.
       double eig5=cfSmallEigenvalue(tmpCov,5 );
       if(eig5<1.e-15 || tmpCov[0]>1.e7) {  //Bad propagation with material. Try without it.
          Trk::vkalPropagator::Propagate(-999, trk->Charge,trk->refPerig,trk->refCovar, vk->refV, targetVertex, tmpPer, tmpCov, (vk->vk_fitterControl).get());
      if(cfSmallEigenvalue(tmpCov,5 )<1.e-15){    //Final protection
            tmpCov[1]=0.;tmpCov[3]=0.;tmpCov[6]=0.;tmpCov[10]=0.;
                     tmpCov[4]=0.;tmpCov[7]=0.;tmpCov[11]=0.;
                                  tmpCov[8]=0.;tmpCov[12]=0.;
                                               tmpCov[13]=0.;
                tmpCov[0]=std::abs(tmpCov[0]); tmpCov[2]=std::abs(tmpCov[2]);tmpCov[5]=std::abs(tmpCov[5]);
                tmpCov[9]=std::abs(tmpCov[9]); tmpCov[14]=std::abs(tmpCov[14]);
          }
       }
       if(tmpCov[0]>1.e7){ IERR=-7; return IERR; }     //extremely big A0 error !!!
       IERR=cfInv5(tmpCov, tmpWgt);  if (IERR) IERR=cfdinv(tmpCov, tmpWgt, 5); if(IERR)return -8;
       trk->setCurrent(tmpPer,tmpWgt);
       if ( vShift > 100. ) trk->setReference( tmpPer, tmpCov ); //Change reference for big shift
     }
     vk->setRefIterV(targetVertex);
     if ( vShift > 100. )vk->setRefV(targetVertex);  // Change reference vertex for big shift
     vk->iniV[0] = vk->fitV[0] = vk->cnstV[0]=0.;
     vk->iniV[1] = vk->fitV[1] = vk->cnstV[1]=0.;
     vk->iniV[2] = vk->fitV[2] = vk->cnstV[2]=0.;
     for(it=0; it<NTRK; it++){
       trk=vk->TrackList[it].get();
       if(Step<1.){                          // Step limitation for constraint calculation on next step
         trk->cnstP[0] = trk->iniP[0] =trk->iniP[0]+ Step*(trk->fitP[0]-trk->iniP[0]);
         trk->cnstP[1] = trk->iniP[1] =trk->iniP[1]+ Step*(trk->fitP[1]-trk->iniP[1]);
         trk->cnstP[2] = trk->iniP[2] =trk->iniP[2]+ Step*(trk->fitP[2]-trk->iniP[2]);
       }else{
         trk->cnstP[0] = trk->iniP[0] = trk->fitP[0];   // for constraint calculation on next step
         trk->cnstP[1] = trk->iniP[1] = trk->fitP[1];
         trk->cnstP[2] = trk->iniP[2] = trk->fitP[2];
       }
     }
  }
  return 0;
}

unique_clone() [1/2]

template<typename T>

std::unique_ptr< T > Trk::unique_clone

(

const std::unique_ptr< T > &

v

)

Definition at line 18 of file unique_clone.h.

                                                            {
    if (v != nullptr) {
      return std::unique_ptr<T>(v->clone());
    } else {
      return nullptr;
    }
  }

unique_clone() [2/2]

template<typename T>

std::unique_ptr< T > Trk::unique_clone

(

const T *

v

)

Definition at line 8 of file unique_clone.h.

                                             {
    if (v != nullptr) {
      return std::unique_ptr<T>(v->clone());
    } else {
      return nullptr;
    }
  }

vkGetEigVal()

void Trk::vkGetEigVal	(	const double	ci[],
		double	d[],
		int	n )

Definition at line 828 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
  int i,j,k; d--;
  noinit_vector<double*> a (n+1);
  noinit_vector<double> ab ((n+1)*(n+1));
  for(i=0; i<n+1; i++) a[i] = ab.data() + i*(n+1);
 
  for( i=1; i<=n; i++) {
    for( j=i; j<=n; j++) { k=(j-1)*j/2 + i; a[i][j]=a[j][i]=ci[k-1];}
  }
 
  vkjacobi(a.data(),n,d,nullptr);
 
  for (i=1;i<n;i++) {
     double p=d[k=i]; for (j=i+1;j<=n;j++) if (d[j] < p) p=d[k=j];
     if (k != i) { d[k]=d[i]; d[i]=p; }
  }
}

vkGetEigVect()

void Trk::vkGetEigVect	(	const double	ci[],
		double	d[],
		double	vect[],
		int	n )

Definition at line 847 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
  int i,j,k; d--;
  noinit_vector<double*> a (n+1);
  noinit_vector<double> ab ((n+1)*(n+1));
  noinit_vector<double*> v (n+1);
  noinit_vector<double> vb ((n+1)*(n+1));
  for(i=0; i<n+1; i++) a[i] = ab.data() + i*(n+1);
  for(i=0; i<n+1; i++) v[i] = vb.data() + i*(n+1);
 
  for( i=1; i<=n; i++) {
    for( j=i; j<=n; j++) { k=(j-1)*j/2 + i; a[i][j]=a[j][i]=ci[k-1];}
  }
 
  vkjacobi(a.data(),n,d,v.data());
 
  for (i=1;i<n;i++) {
     double p=d[k=i]; for (j=i+1;j<=n;j++) if (d[j] < p) p=d[k=j];
     if (k != i) { d[k]=d[i]; d[i]=p;
              for (j=1;j<=n;j++) { p=v[j][i]; v[j][i]=v[j][k]; v[j][k]=p;}
     }
  }
 
  k=0; for (i=1;i<=n;i++) for(j=1;j<=n;j++) vect[k++]=v[j][i];
}

vkgrkuta_()

void Trk::vkgrkuta_	(	const double	charge,
		const double	step,
		double *	vect,
		double *	vout,
		VKalVrtControlBase *	CONTROL )

Definition at line 14 of file VKgrkuta.cxx.

{
    double equiv_2[3], equiv_5[3];
    long int iter, ncut, j;
    double cost, pinv, rest, sint, a, b, c, f[4], hst;
    double hnorm, secxs[4], secys[4], seczs[4], f1, f2, h2, f3, h4, f4;
    double g1, g2, g3, g4, g5, g6, at, bt, ct, ph, hp, fx, fy, fz, tl;
    double ph2, cba, rho, est, tet, hxp[3], dxt, dyt, dzt, ang2, rho1;
 
 
 
#define xyz (equiv_2)
#define x   (equiv_2)
#define y   (equiv_2 + 1)
#define z   (equiv_2 + 2)
#define xyzt (equiv_5)
#define xt   (equiv_5)
#define yt   (equiv_5 + 1)
#define zt   (equiv_5 + 2)
 
 
/* *******************************************************************/
/*                                                                   */
/*     Runge-Kutta method for tracking a particle through a magnetic */
/* .   field. Uses Nystroem algorithm (See Handbook Nat. Bur. of     */
/* .   Standards, procedure 25.5.20)                                 */
/* .                                                                 */
/* .     Input parameters                                            */
/* .           CHARGE    Particle charge                             */
/* .           STEP      Step size                                   */
/* .           VECT      Initial co-ords,direction cosines,momentum  */
/* .     Output parameters                                           */
/* .           VOUT      Output co-ords,direction cosines,momentum   */
/* .      User routine called                                        */
/*            CALL GUFLD(X,F)                                        */
/*           Authors    R.Brun, M.Hansroul  *********                */
/*                      V.Perevoztchikov (CUT STEP implementation)   */
/*      Taken from GEANT3.21                                         */
/*      Modified for VKalVrt   V.Kostyukhin                          */
/*********************************************************************/
/*             This constant is for units CM,GEV/C and KGAUSS */
 
    /* Parameter adjustments */
    --vout;
    --vect;
 
    iter = 0;
    ncut = 0;
    for (j = 1; j <= 7; ++j) {vout[j] = vect[j];}
    pinv = (charge) * 2.9979251e-2 / vect[7];      // New for MM, MEV/C and KGAUSS
    tl = 0.;
    hst = step;
 
//std::cout <<" Now in grkuta="<<vect[1]<<", "<<vect[2]<<", "<<vect[3]<<'\n';
 
L20:
    rest = step - tl;
    if (std::abs(hst) > std::abs(rest)) hst = rest;
/* *****      CALL GUFLD(VOUT,F) */
    Trk::vkalMagFld::getMagFld( vout[1], vout[2], vout[3], fx, fy, fz, CONTROL);
    f[0] = fx*10.;   //VK Convert returned field in Tesla into kGauss for old code
    f[1] = fy*10.;
    f[2] = fz*10.;
 
/*  Start of integration */
 
    *x = vout[1];
    *y = vout[2];
    *z = vout[3];
    a = vout[4];
    b = vout[5];
    c = vout[6];
 
    h2 = hst * .5;
    h4 = h2  * .5;
    ph = pinv * hst;
    ph2 = ph * .5;
    secxs[0] = (b * f[2] - c * f[1]) * ph2;
    secys[0] = (c * f[0] - a * f[2]) * ph2;
    seczs[0] = (a * f[1] - b * f[0]) * ph2;
    ang2 = secxs[0]*secxs[0] + secys[0]*secys[0] + seczs[0]*seczs[0];
    if (ang2 > 9.86960440109)      goto L40;
    dxt = h2 * a + h4 * secxs[0];
    dyt = h2 * b + h4 * secys[0];
    dzt = h2 * c + h4 * seczs[0];
    *xt = *x + dxt;
    *yt = *y + dyt;
    *zt = *z + dzt;
 
/*  Second intermediate point */
 
    est = std::abs(dxt) + std::abs(dyt) + std::abs(dzt);
    if (est > hst)  goto L30;
 
 
/* *****      CALL GUFLD(XYZT,F) */
    Trk::vkalMagFld::getMagFld( xyzt[0], xyzt[1], xyzt[2], fx, fy, fz, CONTROL);
    f[0] = fx*10.;   //VK Convert returned field in Tesla into kGauss for old code
    f[1] = fy*10.;
    f[2] = fz*10.;
    at = a + secxs[0];
    bt = b + secys[0];
    ct = c + seczs[0];
 
    secxs[1] = (bt * f[2] - ct * f[1]) * ph2;
    secys[1] = (ct * f[0] - at * f[2]) * ph2;
    seczs[1] = (at * f[1] - bt * f[0]) * ph2;
    at = a + secxs[1];
    bt = b + secys[1];
    ct = c + seczs[1];
    secxs[2] = (bt * f[2] - ct * f[1]) * ph2;
    secys[2] = (ct * f[0] - at * f[2]) * ph2;
    seczs[2] = (at * f[1] - bt * f[0]) * ph2;
    dxt = hst * (a + secxs[2]);
    dyt = hst * (b + secys[2]);
    dzt = hst * (c + seczs[2]);
    *xt = *x + dxt;
    *yt = *y + dyt;
    *zt = *z + dzt;
    at = a + secxs[2] * 2.;
    bt = b + secys[2] * 2.;
    ct = c + seczs[2] * 2.;
 
    est = std::abs(dxt) + std::abs(dyt) + std::abs(dzt);
    if (est > std::abs(hst) * 2.)          goto L30;
/* *****      CALL GUFLD(XYZT,F) */
    Trk::vkalMagFld::getMagFld( xyzt[0], xyzt[1], xyzt[2], fx, fy, fz, CONTROL);
    f[0] = fx*10.; //VK Convert returned field in Tesla into kGauss for old code
    f[1] = fy*10.;
    f[2] = fz*10.;
 
    *z   += (c + (seczs[0] + seczs[1] + seczs[2]) /3.) * hst;
    *y   += (b + (secys[0] + secys[1] + secys[2]) /3.) * hst;
    *x   += (a + (secxs[0] + secxs[1] + secxs[2]) /3.) * hst;
 
    secxs[3] = (bt * f[2] - ct * f[1]) * ph2;
    secys[3] = (ct * f[0] - at * f[2]) * ph2;
    seczs[3] = (at * f[1] - bt * f[0]) * ph2;
    a  += (secxs[0] + secxs[3] + (secxs[1] + secxs[2]) * 2.) /3.;
    b  += (secys[0] + secys[3] + (secys[1] + secys[2]) * 2.) /3.;
    c  += (seczs[0] + seczs[3] + (seczs[1] + seczs[2]) * 2.) /3.;
 
    est = std::abs(secxs[0] + secxs[3] - (secxs[1] + secxs[2]))
        + std::abs(secys[0] + secys[3] - (secys[1] + secys[2]))
    + std::abs(seczs[0] + seczs[3] - (seczs[1] + seczs[2]));
 
    if (est > 1e-4 && std::abs(hst) > 1e-4)    goto L30;
    ++iter;
    ncut = 0;
 
 
/*  If too many iterations, go to HELIX */
    if (iter > 1992)    goto L40;
 
    tl += hst;
    if (est < 3.125e-6)
    hst *= 2.;
    cba = 1. / sqrt(a * a + b * b + c * c);
    vout[1] = *x;
    vout[2] = *y;
    vout[3] = *z;
    vout[4] = cba * a;
    vout[5] = cba * b;
    vout[6] = cba * c;
    rest = step - tl;
    if (step < 0.)  rest = -rest;
    if (rest > std::abs(step) * 1e-5)   goto L20;
 
    return;
 
/* *              CUT STEP */
L30:
    ++ncut;
/*               If too many cuts , go to HELIX */
    if (ncut > 11) {
    goto L40;
    }
    hst *= .5;
    goto L20;
 
/* *              ANGLE TOO BIG, USE HELIX */
L40:
    f1 = f[0];
    f2 = f[1];
    f3 = f[2];
    f4 = sqrt(f1*f1 + f2*f2 + f3*f3);
    rho = -f4 * pinv;
    tet = rho * step;
    if (tet != 0.) {
    hnorm = 1. / f4;
    f1 *= hnorm;
    f2 *= hnorm;
    f3 *= hnorm;
 
    hxp[0] = f2 * vect[6] - f3 * vect[5];
    hxp[1] = f3 * vect[4] - f1 * vect[6];
    hxp[2] = f1 * vect[5] - f2 * vect[4];
    hp = f1 * vect[4] + f2 * vect[5] + f3 * vect[6];
 
    rho1 = 1. / rho;
    sint = sin(tet);
    cost = sin(tet/2.) * sin(tet/2.) * 2.;
 
    g1 = sint * rho1;
    g2 = cost * rho1;
    g3 = (tet - sint) * hp * rho1;
    g4 = -cost;
    g5 = sint;
    g6 = cost * hp;
    vout[1] = vect[1] + (g1 * vect[4] + g2 * hxp[0] + g3 * f1);
    vout[2] = vect[2] + (g1 * vect[5] + g2 * hxp[1] + g3 * f2);
    vout[3] = vect[3] + (g1 * vect[6] + g2 * hxp[2] + g3 * f3);
    vout[4] = vect[4] + (g4 * vect[4] + g5 * hxp[0] + g6 * f1);
    vout[5] = vect[5] + (g4 * vect[5] + g5 * hxp[1] + g6 * f2);
    vout[6] = vect[6] + (g4 * vect[6] + g5 * hxp[2] + g6 * f3);
 
    } else {
    vout[1] = vect[1] + step * vect[4];
    vout[2] = vect[2] + step * vect[5];
    vout[3] = vect[3] + step * vect[6];
 
    }
 
    }

vkMSolve()

int Trk::vkMSolve	(	double *	a,
		double *	b,
		long int	n,
		double *	ainv )

Definition at line 618 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
   std::unique_ptr<int[]>  indx(new int[n+1]);
   std::unique_ptr<double[]> Scale(new double[n]);
   scaleg(a,Scale.get(),n,n);
   int ierr = vkLUdcmp( a, n, indx.get());
   if( ierr )return -1;
   for(int i=0;i<n;i++)b[i]*=Scale[i];
   vkLUbksb(a, n, indx.get(), b);
   for(int i=0;i<n;i++)b[i]*=Scale[i];
   if(ainv){  //Also invert matrix on request
     int i,j;
     std::unique_ptr<double[]> tmp(new double[n]);
     for(j=0; j<n; j++){
       for(i=0;i<n;i++)tmp[i]=0.;
       tmp[j]=1.;
       vkLUbksb(a, n, indx.get(), tmp.get());
       for(i=0;i<n;i++)ainv[i+j*n]=tmp[i];
     }
     for(i=0;i<n;i++) for(j=0;j<n;j++) ainv[i+j*n] *= Scale[i]*Scale[j];
   }
   return 0;
}

vkPerigeeToP()

void Trk::vkPerigeeToP	(	const double *	perig3,
		double *	pp,
		double	effectiveBMAG )

Definition at line 15 of file cfMomentum.cxx.

{
    double constB = effectiveBMAG  * vkalMagCnvCst;
    double phiv = perig3[1];
    double pt   = std::abs( constB/perig3[2] );
    pp[0] = pt * cos(phiv);
    pp[1] = pt * sin(phiv);
    pp[2] = pt / tan(perig3[0]);
}

vkSVDCmp()

void Trk::vkSVDCmp	(	double **	a,
		int	m,
		int	n,
		double	w[],
		double **	v )

Definition at line 648 of file Tracking/TrkVertexFitter/TrkVKalVrtCore/src/Matrix.cxx.

{
    int flag,i,its,j,jj,k,l=0, nm=0;
    double anorm,c,f,g,h,s,scale,x,y,z;
 
    std::vector<double> rv1(n+1,0.);
    g=scale=anorm=0.0;
    for (i=1;i<=n;i++) {
        l=i+1;
        rv1[i]=scale*g;
        g=s=scale=0.0;
        if (i <= m) {
            for (k=i;k<=m;k++) scale += std::abs(a[k][i]);
            if (scale) {
                for (k=i;k<=m;k++) {
                    a[k][i] /= scale;
                    s += a[k][i]*a[k][i];
                }
                f=a[i][i];
                g = -SIGN(std::sqrt(s),f);
                h=f*g-s;
                a[i][i]=f-g;
                for (j=l;j<=n;j++) {
                    for (s=0.0,k=i;k<=m;k++) s += a[k][i]*a[k][j];
                    f=s/h;
                    for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
                }
                for (k=i;k<=m;k++) a[k][i] *= scale;
            }
        }
        w[i]=scale *g;
        g=s=scale=0.0;
        if (i <= m && i != n) {
            for (k=l;k<=n;k++) scale += std::abs(a[i][k]);
            if (scale) {
                for (k=l;k<=n;k++) {
                    a[i][k] /= scale;
                    s += a[i][k]*a[i][k];
                }
                f=a[i][l];
                g = -SIGN(std::sqrt(s),f);
                h=f*g-s;
                a[i][l]=f-g;
                for (k=l;k<=n;k++) rv1[k]=a[i][k]/h;
                for (j=l;j<=m;j++) {
                    for (s=0.0,k=l;k<=n;k++) s += a[j][k]*a[i][k];
                    for (k=l;k<=n;k++) a[j][k] += s*rv1[k];
                }
                for (k=l;k<=n;k++) a[i][k] *= scale;
            }
        }
        double nanorm=std::abs(w[i])+std::abs(rv1[i]);
        if(anorm < nanorm) anorm = nanorm;
    }
    for (i=n;i>=1;i--) {
        if (i < n) {
            if (g) {
                for (j=l;j<=n;j++)
                    v[j][i]=(a[i][j]/a[i][l])/g;
                for (j=l;j<=n;j++) {
                    for (s=0.0,k=l;k<=n;k++) s += a[i][k]*v[k][j];
                    for (k=l;k<=n;k++) v[k][j] += s*v[k][i];
                }
            }
            for (j=l;j<=n;j++) v[i][j]=v[j][i]=0.0;
        }
        v[i][i]=1.0;
        g=rv1[i];
        l=i;
    }
    for (i=(m<n?m:n);i>=1;i--) {
        l=i+1;
        g=w[i];
        for (j=l;j<=n;j++) a[i][j]=0.0;
        if (g) {
            g=1.0/g;
            for (j=l;j<=n;j++) {
                for (s=0.0,k=l;k<=m;k++) s += a[k][i]*a[k][j];
                f=(s/a[i][i])*g;
                for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
            }
            for (j=i;j<=m;j++) a[j][i] *= g;
        } else for (j=i;j<=m;j++) a[j][i]=0.0;
        ++a[i][i];
    }
    for (k=n;k>=1;k--) {
        for (its=1;its<=300;its++) {
            flag=1;
            for (l=k;l>=1;l--) {
                nm=l-1;
                if ( (std::abs(rv1[l])+anorm) == anorm) {
                    flag=0;
                    break;
                }
                if ( (std::abs(w[nm])+anorm) == anorm) break;
            }
            if (flag) {
                c=0.0;
                s=1.0;
                for (i=l;i<=k;i++) {
                    f=s*rv1[i];
                    rv1[i]=c*rv1[i];
                    if ( (std::abs(f)+anorm) == anorm) break;
                    g=w[i];
                    h=vkPythag(f,g);
                    w[i]=h;
                    h=1.0/h;
                    c=g*h;
                    s = -f*h;
                    for (j=1;j<=m;j++) {
                        y=a[j][nm];
                        z=a[j][i];
                        a[j][nm]=y*c+z*s;
                        a[j][i]=z*c-y*s;
                    }
                }
            }
            z=w[k];
            if (l == k) {
                if (z < 0.0) {
                    w[k] = -z;
                    for (j=1;j<=n;j++) v[j][k] = -v[j][k];
                }
                break;
            }
            x=w[l];
            nm=k-1;
            y=w[nm];
            g=rv1[nm];
            h=rv1[k];
            f=((y-z)*(y+z)+(g-h)*(g+h))/(2.0*h*y);
            g=vkPythag(f,1.0);
            f=((x-z)*(x+z)+h*((y/(f+SIGN(g,f)))-h))/x;
            c=s=1.0;
            for (j=l;j<=nm;j++) {
                i=j+1;
                g=rv1[i];
                y=w[i];
                h=s*g;
                g=c*g;
                z=vkPythag(f,h);
                rv1[j]=z;
                c=f/z;
                s=h/z;
                f=x*c+g*s;
                g = g*c-x*s;
                h=y*s;
                y *= c;
                for (jj=1;jj<=n;jj++) {
                    x=v[jj][j];
                    z=v[jj][i];
                    v[jj][j]=x*c+z*s;
                    v[jj][i]=z*c-x*s;
                }
                z=vkPythag(f,h);
                w[j]=z;
                if (z) {
                    z=1.0/z;
                    c=f*z;
                    s=h*z;
                }
                f=c*g+s*y;
                x=c*y-s*g;
                for (jj=1;jj<=m;jj++) {
                    y=a[jj][j];
                    z=a[jj][i];
                    a[jj][j]=y*c+z*s;
                    a[jj][i]=z*c-y*s;
                }
            }
            rv1[l]=0.0;
            rv1[k]=f;
            w[k]=x;
        }
    }
}

vkvFastV()

double Trk::vkvFastV	(	double *	p1,
		double *	p2,
		const double *	vRef,
		double	dbmag,
		double *	out )

Definition at line 42 of file VKvFast.cxx.

{
    double d__1;
    double diff, coef, cent1[2], cent2[2], angle, cross[6];/* was [3][2] */
    double r1, r2, z1, z2, a01[3], a02[3], dc, an[2];
    double ar1, ar2, xd1, xd2, yd1, yd2, dz1, dz2, pt1, pt2, pz1, pz2, det;
    double loc_bmag;
 
 
#define cross_ref(a_1,a_2) cross[(a_2)*3 + (a_1) - 4]
 
/* ---- */
    /* Parameter adjustments */
    --out;
    --p2;
    --p1;
 
    /* Function Body */
    loc_bmag = dbmag;
    if (dbmag <= .1) {loc_bmag = 0.1;}  // To avoid ZERO magnetic field
/* ---- */
    double psum[3]={0.,0.,0.}; double ptmp[3]={0.,0.,0.};
    vkPerigeeToP(&p1[3],ptmp,loc_bmag); psum[0]+=ptmp[0];psum[1]+=ptmp[1];psum[2]+=ptmp[2];
    vkPerigeeToP(&p2[3],ptmp,loc_bmag); psum[0]+=ptmp[0];psum[1]+=ptmp[1];psum[2]+=ptmp[2];
/*------*/
    r1 = 1. / p1[5];
    r2 = 1. / p2[5];
    ar1 = std::abs(r1);
    ar2 = std::abs(r2);
//    pt1 = ar1 * loc_bmag * .00299979; // For GeV and CM
//    pt2 = ar2 * loc_bmag * .00299979;
//    pt1 = ar1 * loc_bmag * .299979;  // For MeV and MM
//    pt2 = ar2 * loc_bmag * .299979;
    pt1 = ar1 * loc_bmag * vkalMagCnvCst;  // from CommonPars.h
    pt2 = ar2 * loc_bmag * vkalMagCnvCst;
    pz1 = pt1 / tan(p1[3]);
    pz2 = pt2 / tan(p2[3]);
/* --- */
    xd1 = cos(p1[4]);
/* Need for calculation of Z of crossing point */
    xd2 = cos(p2[4]);
    yd1 = sin(p1[4]);
    yd2 = sin(p2[4]);
/* ---  Point of minimal approach to the beam */
    a01[0] =  p1[1] * yd1;
    a01[1] = -p1[1] * xd1;
    a01[2] =  p1[2];
    a02[0] =  p2[1] * yd2;
    a02[1] = -p2[1] * xd2;
    a02[2] =  p2[2];
/* -- coordinates of centres of trajectories */
    cent1[0] = a01[0] - r1 * yd1;
    cent1[1] = a01[1] + r1 * xd1;
    cent2[0] = a02[0] - r2 * yd2;
    cent2[1] = a02[1] + r2 * xd2;
/* -- */
    an[0] = cent2[0] - cent1[0];
    an[1] = cent2[1] - cent1[1];
    dc = sqrt(an[0]*an[0] + an[1]*an[1]);
    an[0] /= dc;
    an[1] /= dc;
/* -- Single point*/
    if (dc <= std::abs(ar1 - ar2)) {
    if (ar1 < ar2) {
        cross_ref(1, 1) = ar1 / dc * (cent1[0] - cent2[0]) + cent1[0];
        cross_ref(1, 2) = ar2 / dc * (cent1[0] - cent2[0]) + cent2[0];
        cross_ref(2, 1) = ar1 / dc * (cent1[1] - cent2[1]) + cent1[1];
        cross_ref(2, 2) = ar2 / dc * (cent1[1] - cent2[1]) + cent2[1];
    } else {
        cross_ref(1, 1) = ar1 / dc * (cent2[0] - cent1[0]) + cent1[0];
        cross_ref(1, 2) = ar2 / dc * (cent2[0] - cent1[0]) + cent2[0];
        cross_ref(2, 1) = ar1 / dc * (cent2[1] - cent1[1]) + cent1[1];
        cross_ref(2, 2) = ar2 / dc * (cent2[1] - cent1[1]) + cent2[1];
    }
    angle = vkvang_(&cross_ref(1, 1), cent1, &r1, &xd1, &yd1);
    z1 = pz1 * r1 * angle / pt1 + a01[2];
    angle = vkvang_(&cross_ref(1, 2), cent2, &r2, &xd2, &yd2);
    z2 = pz2 * r2 * angle / pt2 + a02[2];
    //diffz = std::abs(z2 - z1);
    out[1] = (cross_ref(1, 1) + cross_ref(1, 2)) / 2.;
    out[2] = (cross_ref(2, 1) + cross_ref(2, 2)) / 2.;
    out[3] = (z1 + z2) / 2.;
    return std::abs(z1 - z2);
    }
/* ---------------------------------------------------------- */
    double bestZdiff=0.;
    diff = dc - (ar1 + ar2);
    if (diff < 0.) {
/*  2 distinct points, A1 & A2. */
    coef = (r1*r1 + dc*dc - r2*r2) / (dc * 2);
    if (r1*r1 - coef*coef > 0.) {
        det = sqrt(r1 * r1 - coef * coef);
    } else {
        det = 0.;
    }
    cross_ref(1, 1) = cent1[0] + coef * an[0] + det * an[1];
    cross_ref(2, 1) = cent1[1] + coef * an[1] - det * an[0];
    cross_ref(3, 1) = 0.;
    cross_ref(1, 2) = cent1[0] + coef * an[0] - det * an[1];
    cross_ref(2, 2) = cent1[1] + coef * an[1] + det * an[0];
    cross_ref(3, 2) = 0.;
/* -First cross */
    angle = vkvang_(&cross_ref(1, 1), cent1, &r1, &xd1, &yd1);
    z1 = pz1 * r1 * angle / pt1 + a01[2];
    angle = vkvang_(&cross_ref(1, 1), cent2, &r2, &xd2, &yd2);
    z2 = pz2 * r2 * angle / pt2 + a02[2];
    dz1 = std::abs(z2 - z1);
    cross_ref(3, 1) = (z1 + z2) / 2.;
/* -Second cross */
    angle = vkvang_(&cross_ref(1, 2), cent1, &r1, &xd1, &yd1);
    z1 = pz1 * r1 * angle / pt1 + a01[2];
    angle = vkvang_(&cross_ref(1, 2), cent2, &r2, &xd2, &yd2);
    z2 = pz2 * r2 * angle / pt2 + a02[2];
    dz2 = std::abs(z2 - z1);
    cross_ref(3, 2) = (z1 + z2) / 2.;
/* if reterence vertex is present  -> check 2D mom direction -> must be avay from it*/
        if(vRef && std::abs(dz1-dz2)<5.){
          double dir1=ptmp[0]*(cross_ref(1,1)-vRef[0])+ptmp[1]*(cross_ref(2,1)-vRef[1]);
          double dir2=ptmp[0]*(cross_ref(1,2)-vRef[0])+ptmp[1]*(cross_ref(2,2)-vRef[1]);
          if(dir1*dir2<0){   // points are on different sides of ref. vertex
            if(dir1<0) dz1+=1000.;
            if(dir2<0) dz2+=1000.;
          }
        }
/* - choice of best dz */
 
    if (dz1 < dz2) {
        out[1] = cross_ref(1, 1);
        out[2] = cross_ref(2, 1);
        out[3] = cross_ref(3, 1);
        bestZdiff=dz1;
    } else {
        out[1] = cross_ref(1, 2);
        out[2] = cross_ref(2, 2);
        out[3] = cross_ref(3, 2);
        bestZdiff=dz2;
    }
    } else {
    cross_ref(1, 1) = (ar1 * cent2[0] + ar2 * cent1[0]) / (ar1 + ar2);
    cross_ref(2, 1) = (ar1 * cent2[1] + ar2 * cent1[1]) / (ar1 + ar2);
    out[1] = cross_ref(1, 1);
    out[2] = cross_ref(2, 1);
    out[3] = 0.;
    d__1 = r1 * dc / (ar1 + ar2);
    angle = vkvang_(cross, cent1, &d__1, &xd1, &yd1);
    z1 = pz1 * r1 * angle / pt1 + a01[2];
    d__1 = r2 * dc / (ar1 + ar2);
    angle = vkvang_(cross, cent2, &d__1, &xd2, &yd2);
    z2 = pz2 * r2 * angle / pt2 + a02[2];
    out[3] = (z1 + z2) / 2.;
    bestZdiff = std::abs(z1 - z2);
    }
    return bestZdiff;
}

vpderiv()

void Trk::vpderiv	(	bool	UseTrackErr,
		long int	Charge,
		const double *	pari0,
		double *	covi,
		double *	vrtref,
		double *	covvrtref,
		double *	drdpar,
		double *	dwgt,
		double *	rv0,
		VKalVrtControl *	FitCONTROL )

Definition at line 16 of file VtDeriv.cxx.

{
    /* Initialized data */
 
    double dshft[6] = { 1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4};   //step for each parameter
         /* Symmetric version for derivatives calculation*/
    double DrvCoef[4] = {-2., -1., 1.,2.};
 
    /* Local variables */
    double pari[6], covd[15], dcov[3], rvec[50]; /* was [2][6*4+1] */
    double  paro[5];
    int j, ij, ip, ipp, id=0;
    double dwgt0[3]={0.,0.,0.};
    //double deriv[6], dchi2[4*6+1];                     //VK for debugging
    double cs, pp, sn, pt, rho;
    double covdtr[15], ctg, par[5], cnv[36]; /* was [6][6] */
 
#define rvec_ref(a_1,a_2) rvec[(a_2)*2 + (a_1) - 1]
#define drdpar_ref(a_1,a_2) drdpar[(a_2)*2 + (a_1)]
#define cnv_ref(a_1,a_2) cnv[(a_2)*6 + (a_1) - 7]
 
/* ---------------------------------------------------------- */
/*       Subroutine for derivative calculations               */
/*       Input:                                               */
/*              Charge         -  charge of track ( +1,0,-1 ) */
/*              PARI0(1:3)  -  Vertex of particle             */
/*              PARI0(4:6)  -  Momentum of particle           */
/*                COVI(21)  -  symmetric covariance matrix    */
/*        BMAG      -  magnetic field                 */
/*     UseTrackErr =false  Fitted track is assumed errorless  */
/*                         only vertex error is used          */
/*                          may be used for constraint        */
/*                  =true  Fitted track error is added        */
/*       Output:                                              */
/*                Deriv(6)  -  Chi2 derivatives for debugging */
/*                drdpar    -  derivatives                    */
/*                rv0[2]    -  track impact vs vertex         */
/*                dwgt[3]   -  track impact covarinance       */
/* ---------------------------------------------------------- */
    /* Parameter adjustments */
    drdpar -= 3;
    --covvrtref;
 
    /* Function Body */
/* --------------------- */
    double constB =FitCONTROL->vk_forcft.localbmag * vkalMagCnvCst ;
 
    for (ip = 0; ip <= 4*6; ++ip) {    // Number of points * Number of parameters
/* --  Input parameters */
    pari[0] = pari0[0];
    pari[1] = pari0[1];
    pari[2] = pari0[2];
    pari[3] = pari0[3];
    pari[4] = pari0[4];
    pari[5] = pari0[5];
//  ipp - parameter number, id - number of step
    ipp = ip; while(ipp>6)ipp-=6;
    if(ip>=1  && ip<=6 ) id=0;
    if(ip>=7  && ip<=12) id=1;
    if(ip>=13 && ip<=18) id=2;
    if(ip>=19 && ip<=24) id=3;
    if (ip != 0) pari[ipp - 1] *= (dshft[ipp-1]*DrvCoef[id] + 1.);
/* -- */
    pt  = sqrt(pari[3]*pari[3] + pari[4]*pari[4]);
    pp  = pt*pt + pari[5]*pari[5];
    cs  = pari[3] / pt;
    sn  = pari[4] / pt;
    ctg = pari[5] / pt;
    rho =  Charge * constB / pt;   // Sign of charge coinside with sign of curvature!!!
/* --  Output parameters */
    par[0] = 0.;
    par[1] = 0.;
    par[2] = acos(pari[5] / sqrt(pp));
        if(par[2]<1.e-5) par[2]=1.e-5;
        if(par[2]>M_PI-1.e-5) par[2]=M_PI-1.e-5;
    par[3] = atan2(pari[4], pari[3]);
    par[4] = rho;
    if (Charge == 0)  par[4] = constB / pt;
/* -- */
    cnv_ref(1, 1) = sn;
    cnv_ref(2, 1) = -cs;
    cnv_ref(3, 1) = 0.;
    cnv_ref(4, 1) = 0.;
    cnv_ref(5, 1) = 0.;
    cnv_ref(6, 1) = 0.;
/* -- */
    cnv_ref(1, 2) = -cs * ctg;
    cnv_ref(2, 2) = -sn * ctg;
    cnv_ref(3, 2) = 1.;
    cnv_ref(4, 2) = 0.;
    cnv_ref(5, 2) = 0.;
    cnv_ref(6, 2) = 0.;
/* -- */
    cnv_ref(1, 3) = 0.;
    cnv_ref(2, 3) = 0.;
    cnv_ref(3, 3) = 0.;
    cnv_ref(4, 3) = pari[5] * pari[3] / pp / pt;
    cnv_ref(5, 3) = pari[5] * pari[4] / pp / pt;
    cnv_ref(6, 3) = -pt / pp;
/* -- */
    cnv_ref(1, 4) = 0.;
    cnv_ref(2, 4) = 0.;
        if (Charge)cnv_ref(1, 4) = -cs * rho;   //  For charged tracks only
        if (Charge)cnv_ref(2, 4) = -sn * rho;   //
    cnv_ref(3, 4) = 0.;
    cnv_ref(4, 4) = -pari[4] / (pt * pt);
    cnv_ref(5, 4) =  pari[3] / (pt * pt);
    cnv_ref(6, 4) = 0.;
/* -- */
    cnv_ref(1, 5) = 0.;
    cnv_ref(2, 5) = 0.;
    cnv_ref(3, 5) = 0.;
    cnv_ref(4, 5) = -pari[3] * rho / (pt * pt);
    cnv_ref(5, 5) = -pari[4] * rho / (pt * pt);
    if ( Charge == 0) {cnv_ref(4, 5) = -pari[3] * constB / (pt*pt*pt);}
    if ( Charge == 0) {cnv_ref(5, 5) = -pari[4] * constB / (pt*pt*pt);}
    cnv_ref(6, 5) = 0.;
/* -- not needed really but... */
    cnv_ref(1, 6) = cnv_ref(2, 6) = cnv_ref(3, 6) = cnv_ref(4, 6) = cnv_ref(5, 6) = cnv_ref(6, 6) = 0.;
 
    tdasatVK(cnv, &covi[0], covd, 5, 6);
 
/* -- Translation to New Reference Point */
        Trk::vkalPropagator::Propagate(-999, Charge, par, covd, pari, vrtref, paro, covdtr, FitCONTROL);
 
 
 
/* -- Now impact significance */
/*  X=paro(1)*sn, Y=-paro(1)*cs */
    sn = sin(paro[3]);
    cs = cos(paro[3]);
/* -- New error version */
    cnv_ref(1, 1) = -sn;
    cnv_ref(1, 2) =  cs;
    cnv_ref(1, 3) =  0.;
    cnv_ref(2, 1) =  sn / tan(paro[2]);
    cnv_ref(2, 2) =  cs / tan(paro[2]);
    cnv_ref(2, 3) = -1.;
    dcov[0] = 0.;
    dcov[1] = 0.;
    dcov[2] = 0.;
    for (int i = 1; i <= 3; ++i) {
        for (j = 1; j <= 3; ++j) {
            ij = i > j ? i : j;
        ij = ij * (ij - 1) / 2 + ( i < j ? i : j );
        dcov[0] += cnv_ref(1, i) * cnv_ref(1, j) * covvrtref[ij];
        dcov[2] += cnv_ref(2, i) * cnv_ref(2, j) * covvrtref[ij];
        dcov[1] += cnv_ref(1, i) * cnv_ref(2, j) * covvrtref[ij];
        }
    }
/* --------------------------------------------------------------- */
    if( UseTrackErr ){          // Add track error if needed
       dcov[0] += covdtr[0];
       dcov[1] += covdtr[1];
       dcov[2] += covdtr[2];
        }
/*---------------------------------------------------------------- */
//     Weight matrix and chi2 for given shift
//
    int jerr=cfdinv(dcov, &dwgt[0], -2); if(jerr){jerr=cfdinv(dcov, &dwgt[0], 2); if(jerr){dwgt[0]=dwgt[2]=1.e6; dwgt[1]=0.;}};
    //dchi2[ip] = sqrt(fabs(dwgt[0]*paro[0]*paro[0] + 2.*dwgt[1]*paro[0]*paro[1] + dwgt[2]*paro[1]*paro[1]));
    rvec_ref(1, ip) = paro[0];
    rvec_ref(2, ip) = paro[1];
    if (ip == 0) {          //Save weight matrix for output
        dwgt0[0] = dwgt[0];
        dwgt0[1] = dwgt[1];
        dwgt0[2] = dwgt[2];
    }
    }
/* ---------------------------------------------------------------- */
//  Now calculate derivatives themselves
//
    for (int i = 1; i <= 6; ++i) {
      //deriv[i-1]      = (dchi2[i] -8.*dchi2[i+6] +8.*dchi2[i+12]-dchi2[i+18] ) / (12.*dshft[i-1]*pari0[i-1]);
      drdpar_ref(1,i) = (rvec_ref(1,i) -8.*rvec_ref(1,i+6) +8.*rvec_ref(1,i+12) -rvec_ref(1,i+18)) / (12.*dshft[i-1]*pari0[i-1]);
      drdpar_ref(2,i) = (rvec_ref(2,i) -8.*rvec_ref(2,i+6) +8.*rvec_ref(2,i+12) -rvec_ref(2,i+18)) / (12.*dshft[i-1]*pari0[i-1]);
    }
//std::cout<<deriv[0]<<", "<<deriv[1]<<", "<<deriv[2]<<", "<<deriv[3]<<", "<<deriv[4]<<", "<<deriv[5]<<'\n';
//std::cout<<drdpar_ref(1, 1)<<", "<<drdpar_ref(1, 2)<<", "<<drdpar_ref(1, 3)<<", "<<drdpar_ref(1, 4)<<
//                             ", "<<drdpar_ref(1, 5)<<", "<<drdpar_ref(1, 6)<<'\n';
//std::cout<<drdpar_ref(2, 1)<<", "<<drdpar_ref(2, 2)<<", "<<drdpar_ref(2, 3)<<", "<<drdpar_ref(1, 4)<<
//                             ", "<<drdpar_ref(2, 5)<<", "<<drdpar_ref(2, 6)<<'\n';
//std::cout<<"---------------------"<<'\n';
//
//  Output parameters
//
 
    rv0[0] = rvec_ref(1, 0);
    rv0[1] = rvec_ref(2, 0);
    dwgt[0] = dwgt0[0];
    dwgt[1] = dwgt0[1];
    dwgt[2] = dwgt0[2];
 
//std::cout<<" VpDerivR,Z="<<rv0[0]<<", "<<rv0[1]<<'\n';
//std::cout<<" Ref="<<vrtref[0]<<", "<<vrtref[1]<<", "<<vrtref[2]<<'\n';
#undef cnv_ref
#undef drdpar_ref
#undef rvec_ref
}

vtcfit()

int Trk::vtcfit

(

VKVertex *

vk

)

Definition at line 293 of file VtCFit.cxx.

                           {
 
  double dxyz[3], xyzt[3], eigv[8];
  double dpipj[3][3]    /* was [3][3] */;
  double drdpy[2][3]    /* was [2][3] */;
  double drdvy[2][3]    /* was [2][3] */;
  double pyv[3][3] /*was [3][3]*/;
  double vyv[3][3] /*was [3][3]*/;
  double wa[6], stv[3], wgtvrtd[6], tv[3];
 
  int ic, jj, it, jt, ii, kt;
  int j, k, l;
 
#define ader_ref(a_1,a_2) vk->ader[(a_2)*(vkalNTrkM*3+3) + (a_1) - (vkalNTrkM*3+4)]
#define cvder_ref(a_1,a_2) vk->FVC.cvder[(a_2)*2 + (a_1) - 3]
#define dcv_ref(a_1,a_2) vk->FVC.dcv[(a_2)*6 + (a_1) - 7]
 
  /* ************************************************************************/
  /*  Created     :  14-MAY-2008   Author : V.KOSTYUKHIN (INFN) */
  /* ********* */
  /*  Arguments   : Input  : NTRK             :  number of tracks */
  /*               ICH(1:NTRK)      :  charge */
  /*                         PAR(1:5,1:NTRK)  :  "perigee" parameters */
  /*                          1 : epsilon (impact par. in xy projection, with sign)*/
  /*                          2 : z coordinate */
  /*                          3 : theta angle */
  /*                          4 : phi angle */
  /*                          5 : 1/R (R = radius of curvature, with sign) */
  /*                                   0.0029979246d0/Pt  if charge=0 */
  /*                         WGT(1:15,1:NTRK) :  weight matrix on PAR */
  /*                                   :in case of zero charge WGT(15) must be */
  /*                                   :error of 0.0029979246d0/Pt with correlation*/
  /*                         XYZ(1:3)  :  approximate coordinates of the vertex*/
  /*                         PAR0(1:3) :  approximate parameters of tracks at*/
  /*                                      the vertex(result of pxfvtx fit) */
  /*                Output : XYZF(1:3) :  fitted coordinates of the vertex */
  /*                         PARF(1:3,1:NTRK) : fitted parameters at THE vertex*/
  /*                          1 : theta */
  /*                          2 : phi */
  /*                          3 : 1/R */
  /*                         CHI2      :  chi2 of the fit */
  /*                         CHI2TR(I)=CONTRIBUTION OF TRACK I TO THE */
  /*                                      TOTAL CHI2 */
 
  /*  Errors      :  IERR = 1 :  too many tracks (NTRK > NTRMAX) */
  /*                 IERR = 2 :  covariance or weight matrix not positive */
  /**************************************************************************/
 
  /* -------------------------------------------- */
  /* Fit results needed in other calculations     */
  /* -------------------------------------------- */
  /* For close to vertex constraint */
  /* For step constraint */
  /* -- Derivatives and others for constraint */
  /* ---------------------------------------------------------------------- */
 
  long int IERR = 0;
  int NTRK = vk->TrackList.size();
  double xyz[3]={vk->iniV[0],vk->iniV[1],vk->iniV[2]};
  double twb[9];
  double twci[6];
  double twbci[9];
  double xyzf[3];
 
  vk->truncatedStep=false;
  if ( NTRK > vkalNTrkM ) return 1;
 
  std::unique_ptr<double[]> dphi   = std::unique_ptr<double[]>(new double[NTRK]);
  std::unique_ptr<double[]> deps   = std::unique_ptr<double[]>(new double[NTRK]);
  std::unique_ptr<double[]> drho   = std::unique_ptr<double[]>(new double[NTRK]);
  std::unique_ptr<double[]> dtet   = std::unique_ptr<double[]>(new double[NTRK]);
  std::unique_ptr<double[]> dzp    = std::unique_ptr<double[]>(new double[NTRK]);
 
  for (int i=0; i<3; ++i) { tv[i] = 0.; stv[i] = 0.;}
  for (int i=0; i<6; ++i) { vk->wa[i] = 0.; wa[i] = 0.;}
  for (k=0; k<2; k++) { for(j=0; j<3; j++) drdvy[k][j] = drdpy[k][j] = 0.;};
  for (k=0; k<3; k++) { for(j=0; j<3; j++)   pyv[k][j] =   vyv[k][j] = 0.;};
 
  /* =================================================================== */
  /*   loop over the tracks */
 
  if (vk->passNearVertex) {
    /* dR/dV*Y and dR/dV*Y*dR/dV f */
    drdvy[0][0]= cvder_ref(1, 1)*vk->FVC.ywgt[0] + cvder_ref(2, 1)*vk->FVC.ywgt[1];
    drdvy[1][0]= cvder_ref(1, 1)*vk->FVC.ywgt[1] + cvder_ref(2, 1)*vk->FVC.ywgt[2];
    drdvy[0][1]= cvder_ref(1, 2)*vk->FVC.ywgt[0] + cvder_ref(2, 2)*vk->FVC.ywgt[1];
    drdvy[1][1]= cvder_ref(1, 2)*vk->FVC.ywgt[1] + cvder_ref(2, 2)*vk->FVC.ywgt[2];
    drdvy[0][2]= cvder_ref(1, 3)*vk->FVC.ywgt[0] + cvder_ref(2, 3)*vk->FVC.ywgt[1];
    drdvy[1][2]= cvder_ref(1, 3)*vk->FVC.ywgt[1] + cvder_ref(2, 3)*vk->FVC.ywgt[2];
    for (ii = 1; ii <= 3; ++ii) {                        /* Matrix dR/dV*Y*dR/dV */
      for (jj = 1; jj <= 3; ++jj) {
        vyv[ii-1][jj-1] = drdvy[0][ii-1]*cvder_ref(1, jj) + drdvy[1][ii-1]*cvder_ref(2, jj);
      }
    }
  }
 
  double vBx,vBy,vBz;
  Trk::vkalMagFld::getMagFld(xyz[0], xyz[1], xyz[2],vBx,vBy,vBz,(vk->vk_fitterControl).get());
 
  for ( kt = 0; kt < NTRK; ++kt) {
    VKTrack* trk = vk->TrackList[kt].get();
    double theta_ini =trk->iniP[0];
    double phi_ini   =trk->iniP[1];
    double invR_ini  =trk->iniP[2];
    /*  "perigee" parameters EPS and ZP if the trajectory goes through XYZ */
    /*   and its theta,phi,1/R at perigee are equal to the values at input*/
    double cotth = 1. / tan( theta_ini );    /*   theta at vertex */
    double cosf = cos(phi_ini);
    double sinf = sin(phi_ini);
    double uu = xyz[0]*cosf + xyz[1]*sinf;
    double vv = xyz[1]*cosf - xyz[0]*sinf;
    double phip,zp,eps;
    double corrCz = (vBy*cosf-vBx*sinf)/Trk::vkalMagFld::getEffField(vBx, vBy, vBz, phi_ini, theta_ini);
    if ( trk->Charge ) {
      eps    = -vv - uu*uu * invR_ini / 2.;
      zp     = -uu * (1. - vv * invR_ini) * cotth - 0.5*uu*uu*invR_ini*corrCz;   //xyz[2] is added later to gain precision
      phip   = -uu * invR_ini;                       //phi_ini is added later to gain precision
    } else {
      eps    = -vv;
      zp     = -uu * cotth;
      phip   = 0.;
    }
 
    /*   contribution of this track to chi2 with initial values */
 
    deps[kt] = trk->a0()    - eps;
    dzp[kt] = trk->z()     - xyz[2];      // Precision
    dzp[kt]-= zp;
    dtet[kt] = trk->theta() - theta_ini;
    dphi[kt] = trk->phi()   - phi_ini;     // Precision
    dphi[kt]-= phip;
    drho[kt] = trk->invR()  - invR_ini;
    while(dphi[kt] >  M_PI)dphi[kt]-=2.*M_PI;
    while(dphi[kt] < -M_PI)dphi[kt]+=2.*M_PI;
 
 
    /*   derivatives (deriv1) of perigee param. w.r.t. X,Y,Z (vertex) uu=Q, vv=R */
    double d11 =  sinf             - (                 uu*cosf   *invR_ini);
    double d12 = -cosf             - (                 uu*sinf   *invR_ini);
    double d21 = -cosf * cotth     + (  (vv*cosf-uu*sinf)*cotth  *invR_ini) - uu*cosf*invR_ini*corrCz;
    double d22 = -sinf * cotth     + (  (vv*sinf+uu*cosf)*cotth  *invR_ini) - uu*sinf*invR_ini*corrCz;
    //double d23 = 1.;        //VK for reference
    double d41 = -cosf * invR_ini;
    double d42 = -sinf * invR_ini;
    if (trk->Charge == 0) {
      d11 =  sinf;
      d12 = -cosf;
      d21 = -cosf * cotth;
      d22 = -sinf * cotth;
      d41 = 0.;
      d42 = 0.;
    }
 
    /*   matrix DW = (deriv1)t * weight */
    double dw11 = d11 * trk->WgtM[0] + d21 * trk->WgtM[1] + d41 * trk->WgtM[6];
    double dw12 = d11 * trk->WgtM[1] + d21 * trk->WgtM[2] + d41 * trk->WgtM[7];
    double dw13 = d11 * trk->WgtM[3] + d21 * trk->WgtM[4] + d41 * trk->WgtM[8];
    double dw14 = d11 * trk->WgtM[6] + d21 * trk->WgtM[7] + d41 * trk->WgtM[9];
    double dw15 = d11 * trk->WgtM[10]+ d21 * trk->WgtM[11]+ d41 * trk->WgtM[13];
 
 
    double dw21 = d12 * trk->WgtM[0] + d22 * trk->WgtM[1] + d42 * trk->WgtM[6];
    double dw22 = d12 * trk->WgtM[1] + d22 * trk->WgtM[2] + d42 * trk->WgtM[7];
    double dw23 = d12 * trk->WgtM[3] + d22 * trk->WgtM[4] + d42 * trk->WgtM[8];
    double dw24 = d12 * trk->WgtM[6] + d22 * trk->WgtM[7] + d42 * trk->WgtM[9];
    double dw25 = d12 * trk->WgtM[10]+ d22 * trk->WgtM[11]+ d42 * trk->WgtM[13];
    double dw31 = trk->WgtM[1];
    double dw32 = trk->WgtM[2];
    double dw33 = trk->WgtM[4];
    double dw34 = trk->WgtM[7];
    double dw35 = trk->WgtM[11];
 
    /*  summation of  DW * DPAR  to vector TV */
    tv[0]  +=  dw11 * deps[kt] + dw12 * dzp[kt];
    tv[1]  +=  dw21 * deps[kt] + dw22 * dzp[kt];
    tv[2]  +=  dw31 * deps[kt] + dw32 * dzp[kt];
    tv[0]  +=  dw13 * dtet[kt] + dw14 * dphi[kt] + dw15 * drho[kt];
    tv[1]  +=  dw23 * dtet[kt] + dw24 * dphi[kt] + dw25 * drho[kt];
    tv[2]  +=  dw33 * dtet[kt] + dw34 * dphi[kt] + dw35 * drho[kt];
 
    stv[0] +=  dw11 * deps[kt] + dw12 * dzp[kt];
    stv[1] +=  dw21 * deps[kt] + dw22 * dzp[kt];
    stv[2] +=  dw31 * deps[kt] + dw32 * dzp[kt];
    stv[0] +=  dw13 * dtet[kt] + dw14 * dphi[kt] + dw15*drho[kt];
    stv[1] +=  dw23 * dtet[kt] + dw24 * dphi[kt] + dw25*drho[kt];
    stv[2] +=  dw33 * dtet[kt] + dw34 * dphi[kt] + dw35*drho[kt];
 
    /*   derivatives (deriv2) of perigee param. w.r.t. theta,phi,1/R (vertex) uu=Q, vv=R */
    double e12 =  uu - invR_ini * vv * uu;
    double e13 = -uu*uu / 2.;
    double e21 =  uu *(1. - vv*invR_ini) * (cotth*cotth + 1.);
    double e22 = -vv*cotth  + (vv*vv-uu*uu)*invR_ini*cotth - uu*vv*invR_ini*corrCz;
    double e23 =  uu*vv*cotth    -0.5*uu*uu*corrCz;
    double e43 = -uu + 2.*uu*vv*invR_ini;
    /*  if straight line, set to zero derivatives w.r.t. the curvature */
    /*  and curvature terms in derivatives */
    if (trk->Charge == 0) {
      e12 =  uu;
      e13 =  0.;
      e21 =  uu * (cotth*cotth + 1.);
      e22 = -vv * cotth;
      e23 =  0.;
      e43 =  0.;
    }
 
    /*   matrix EW = (deriv2)t * weight */
    double ew11 = e21 * trk->WgtM[1] + trk->WgtM[3];
    double ew12 = e21 * trk->WgtM[2] + trk->WgtM[4];
    double ew13 = e21 * trk->WgtM[4] + trk->WgtM[5];
    double ew14 = e21 * trk->WgtM[7] + trk->WgtM[8];
    double ew15 = e21 * trk->WgtM[11]+ trk->WgtM[12];
    double ew21 = e12 * trk->WgtM[0] + e22 * trk->WgtM[1] + trk->WgtM[6];
    double ew22 = e12 * trk->WgtM[1] + e22 * trk->WgtM[2] + trk->WgtM[7];
    double ew23 = e12 * trk->WgtM[3] + e22 * trk->WgtM[4] + trk->WgtM[8];
    double ew24 = e12 * trk->WgtM[6] + e22 * trk->WgtM[7] + trk->WgtM[9];
    double ew25 = e12 * trk->WgtM[10]+ e22 * trk->WgtM[11]+ trk->WgtM[13];
    double ew31 = e13 * trk->WgtM[0] + e23 * trk->WgtM[1] + e43 * trk->WgtM[6] + trk->WgtM[10];
    double ew32 = e13 * trk->WgtM[1] + e23 * trk->WgtM[2] + e43 * trk->WgtM[7] + trk->WgtM[11];
    double ew33 = e13 * trk->WgtM[3] + e23 * trk->WgtM[4] + e43 * trk->WgtM[8] + trk->WgtM[12];
    double ew34 = e13 * trk->WgtM[6] + e23 * trk->WgtM[7] + e43 * trk->WgtM[9] + trk->WgtM[13];
    double ew35 = e13 * trk->WgtM[10]+ e23 * trk->WgtM[11]+ e43 * trk->WgtM[13]+ trk->WgtM[14];
 
    /*   computation of vector  TT = EW * DPAR */
    TWRK* t_trk=vk->tmpArr[kt].get();
    t_trk->tt[0]  = ew11*deps[kt] + ew12*dzp[kt];
    t_trk->tt[1]  = ew21*deps[kt] + ew22*dzp[kt];
    t_trk->tt[2]  = ew31*deps[kt] + ew32*dzp[kt];
    t_trk->tt[0] += ew13*dtet[kt] + ew14*dphi[kt] + ew15*drho[kt];
    t_trk->tt[1] += ew23*dtet[kt] + ew24*dphi[kt] + ew25*drho[kt];
    t_trk->tt[2] += ew33*dtet[kt] + ew34*dphi[kt] + ew35*drho[kt];
    if ( vk->passNearVertex ) {
      for (j = 1; j <= 2; ++j) {                             /* Derivatives dR/dQi */
        int i3=(kt+1)*3;
        t_trk->drdp[j-1][0] = cvder_ref(j,4) * dcv_ref(4,i3 + 1) + cvder_ref(j,5) * dcv_ref(5,i3 + 1);
        t_trk->drdp[j-1][1] = cvder_ref(j,4) * dcv_ref(4,i3 + 2) + cvder_ref(j,5) * dcv_ref(5,i3 + 2);
        t_trk->drdp[j-1][2] = cvder_ref(j,4) * dcv_ref(4,i3 + 3) + cvder_ref(j,5) * dcv_ref(5,i3 + 3);
        t_trk->drdp[j-1][0] +=  cvder_ref(j, 6) * dcv_ref(6, i3 + 1);
        t_trk->drdp[j-1][1] +=  cvder_ref(j, 6) * dcv_ref(6, i3 + 2);
        t_trk->drdp[j-1][2] +=  cvder_ref(j, 6) * dcv_ref(6, i3 + 3);
      }
      /* Matrix dR/dQ */
      drdpy[0][0] = t_trk->drdp[0][0] * vk->FVC.ywgt[0] + t_trk->drdp[1][0] * vk->FVC.ywgt[1];
      drdpy[1][0] = t_trk->drdp[0][0] * vk->FVC.ywgt[1] + t_trk->drdp[1][0] * vk->FVC.ywgt[2];
      drdpy[0][1] = t_trk->drdp[0][1] * vk->FVC.ywgt[0] + t_trk->drdp[1][1] * vk->FVC.ywgt[1];
      drdpy[1][1] = t_trk->drdp[0][1] * vk->FVC.ywgt[1] + t_trk->drdp[1][1] * vk->FVC.ywgt[2];
      drdpy[0][2] = t_trk->drdp[0][2] * vk->FVC.ywgt[0] + t_trk->drdp[1][2] * vk->FVC.ywgt[1];
      drdpy[1][2] = t_trk->drdp[0][2] * vk->FVC.ywgt[1] + t_trk->drdp[1][2] * vk->FVC.ywgt[2];
      t_trk->tt[0] -= drdpy[0][0]*vk->FVC.rv0[0] + drdpy[1][0]*vk->FVC.rv0[1];
      t_trk->tt[1] -= drdpy[0][1]*vk->FVC.rv0[0] + drdpy[1][1]*vk->FVC.rv0[1];
      t_trk->tt[2] -= drdpy[0][2]*vk->FVC.rv0[0] + drdpy[1][2]*vk->FVC.rv0[1];
      for (ii = 1; ii <= 3; ++ii) {             /* Matrix dR/dQi*Y*dR/dV */
        for (jj = 1; jj <= 3; ++jj) {
          pyv[jj-1][ii-1] = drdpy[0][ii-1] * cvder_ref(1, jj) + drdpy[1][ii-1] * cvder_ref(2, jj);
        }
      }
    }
 
    /*   summation of  (deriv1)t * weight * (deriv1)  to  matrix WA */
    wa[0] += dw11 * d11 + dw12 * d21 + dw14 * d41;
    wa[1] += dw11 * d12 + dw12 * d22 + dw14 * d42;
    wa[2] += dw21 * d12 + dw22 * d22 + dw24 * d42;
    wa[3] += dw12;
    wa[4] += dw22;
    wa[5] += dw32;
    vk->wa[0] = vk->wa[0] + dw11 * d11 + dw12 * d21 + dw14 * d41;
    vk->wa[1] = vk->wa[1] + dw11 * d12 + dw12 * d22 + dw14 * d42;
    vk->wa[2] = vk->wa[2] + dw21 * d12 + dw22 * d22 + dw24 * d42;
    vk->wa[3] += dw12;
    vk->wa[4] += dw22;
    vk->wa[5] += dw32;
 
    /*   computation of matrix  WB = (deriv1)t * weight * (deriv2) */
    twb[0] = dw12 * e21 + dw13;
    twb[1] = dw22 * e21 + dw23;
    twb[2] = dw32 * e21 + dw33;
    twb[3] = dw11 * e12 + dw12 * e22 + dw14;
    twb[4] = dw21 * e12 + dw22 * e22 + dw24;
    twb[5] = dw31 * e12 + dw32 * e22 + dw34;
    twb[6] = dw11 * e13 + dw12 * e23 + dw14 * e43 + dw15;
    twb[7] = dw21 * e13 + dw22 * e23 + dw24 * e43 + dw25;
    twb[8] = dw31 * e13 + dw32 * e23 + dw34 * e43 + dw35;
    if ( vk->passNearVertex ) {
      twb[0] +=  pyv[0][0];
      twb[1] +=  pyv[1][0];
      twb[2] +=  pyv[2][0];
      twb[3] +=  pyv[0][1];
      twb[4] +=  pyv[1][1];
      twb[5] +=  pyv[2][1];
      twb[6] +=  pyv[0][2];
      twb[7] +=  pyv[1][2];
      twb[8] +=  pyv[2][2];
    }
 
    /*   computation of matrix  WC = (deriv2)t * weight * (deriv2) */
    vk->tmpArr[kt]->wc[0] = ew12 * e21 + ew13;
    vk->tmpArr[kt]->wc[1] = ew22 * e21 + ew23;
    vk->tmpArr[kt]->wc[3] = ew32 * e21 + ew33;
    vk->tmpArr[kt]->wc[2] = ew21 * e12 + ew22 * e22 + ew24;
    vk->tmpArr[kt]->wc[4] = ew31 * e12 + ew32 * e22 + ew34;
    vk->tmpArr[kt]->wc[5] = ew31 * e13 + ew32 * e23 + ew34 * e43 + ew35;
 
    /*   computation of matrices  WCI = (WC)**(-1) and  WBCI = WB * WCI */
    IERR=cfdinv(&(vk->tmpArr[kt]->wc[0]), twci, -3);
    if (IERR) {IERR=cfdinv(&(vk->tmpArr[kt]->wc[0]), twci, 3);}
    if (IERR)       return IERR;
 
 
    twbci[0] = twb[0]*twci[0] + twb[3]*twci[1] + twb[6]*twci[3];
    twbci[1] = twb[1]*twci[0] + twb[4]*twci[1] + twb[7]*twci[3];
    twbci[2] = twb[2]*twci[0] + twb[5]*twci[1] + twb[8]*twci[3];
    twbci[3] = twb[0]*twci[1] + twb[3]*twci[2] + twb[6]*twci[4];
    twbci[4] = twb[1]*twci[1] + twb[4]*twci[2] + twb[7]*twci[4];
    twbci[5] = twb[2]*twci[1] + twb[5]*twci[2] + twb[8]*twci[4];
    twbci[6] = twb[0]*twci[3] + twb[3]*twci[4] + twb[6]*twci[5];
    twbci[7] = twb[1]*twci[3] + twb[4]*twci[4] + twb[7]*twci[5];
    twbci[8] = twb[2]*twci[3] + twb[5]*twci[4] + twb[8]*twci[5];
 
    /*   subtraction of  WBCI * (WB)t  from matrix WA */
    wa[0] = wa[0] - twbci[0]*twb[0] - twbci[3]*twb[3] - twbci[6]*twb[6];
    wa[1] = wa[1] - twbci[0]*twb[1] - twbci[3]*twb[4] - twbci[6]*twb[7];
    wa[2] = wa[2] - twbci[1]*twb[1] - twbci[4]*twb[4] - twbci[7]*twb[7];
    wa[3] = wa[3] - twbci[0]*twb[2] - twbci[3]*twb[5] - twbci[6]*twb[8];
    wa[4] = wa[4] - twbci[1]*twb[2] - twbci[4]*twb[5] - twbci[7]*twb[8];
    wa[5] = wa[5] - twbci[2]*twb[2] - twbci[5]*twb[5] - twbci[8]*twb[8];
 
    /*   subtraction of  WBCI * TT  from vector  TV */
    tv[0] = tv[0] - twbci[0] * vk->tmpArr[kt]->tt[0] - twbci[3] * vk->tmpArr[kt]->tt[1] - twbci[6] * vk->tmpArr[kt]->tt[2];
    tv[1] = tv[1] - twbci[1] * vk->tmpArr[kt]->tt[0] - twbci[4] * vk->tmpArr[kt]->tt[1] - twbci[7] * vk->tmpArr[kt]->tt[2];
    tv[2] = tv[2] - twbci[2] * vk->tmpArr[kt]->tt[0] - twbci[5] * vk->tmpArr[kt]->tt[1] - twbci[8] * vk->tmpArr[kt]->tt[2];
    //Save to vertex ....
    for( int tpn=0; tpn<9; tpn++){
      vk->tmpArr[kt]->wb[tpn]   = twb[tpn];
      if(tpn<6)vk->tmpArr[kt]->wci[tpn]  = twci[tpn];
      vk->tmpArr[kt]->wbci[tpn] = twbci[tpn];
    }
  }
  if (vk->useApriorVertex) {
    for (ic = 0; ic < 3; ++ic) {   xyzt[ic] = vk->apriorV[ic] - vk->refIterV[ic] - xyz[ic];}
    for (ic = 0; ic < 6; ++ic) {wgtvrtd[ic] = vk->apriorVWGT[ic];}
    wa[0] += wgtvrtd[0];
    wa[1] += wgtvrtd[1];
    wa[2] += wgtvrtd[2];
    wa[3] += wgtvrtd[3];
    wa[4] += wgtvrtd[4];
    wa[5] += wgtvrtd[5];
    vk->wa[0] += wgtvrtd[0];
    vk->wa[1] += wgtvrtd[1];
    vk->wa[2] += wgtvrtd[2];
    vk->wa[3] += wgtvrtd[3];
    vk->wa[4] += wgtvrtd[4];
    vk->wa[5] += wgtvrtd[5];
    tv[0]  = tv[0]  + xyzt[0] * wgtvrtd[0] + xyzt[1] * wgtvrtd[1] + xyzt[2] * wgtvrtd[3];
    tv[1]  = tv[1]  + xyzt[0] * wgtvrtd[1] + xyzt[1] * wgtvrtd[2] + xyzt[2] * wgtvrtd[4];
    tv[2]  = tv[2]  + xyzt[0] * wgtvrtd[3] + xyzt[1] * wgtvrtd[4] + xyzt[2] * wgtvrtd[5];
    stv[0] = stv[0] + xyzt[0] * wgtvrtd[0] + xyzt[1] * wgtvrtd[1] + xyzt[2] * wgtvrtd[3];
    stv[1] = stv[1] + xyzt[0] * wgtvrtd[1] + xyzt[1] * wgtvrtd[2] + xyzt[2] * wgtvrtd[4];
    stv[2] = stv[2] + xyzt[0] * wgtvrtd[3] + xyzt[1] * wgtvrtd[4] + xyzt[2] * wgtvrtd[5];
  }
  //Save T vector(see Billoir...)
  vk->T[0]=stv[0]; vk->T[1]=stv[1]; vk->T[2]=stv[2];
 
  //std::cout<<" newwa="<<wa[0]<<", "<<wa[1]<<", "<<wa[2]<<", "<<wa[3]<<", "<<wa[4]<<", "<<wa[5]<<'\n';
 
  /*   solution of the linear system */
  if ( !vk->passNearVertex ) {           /* No correction for these constraints */
    /* because solution is calculated with full error matrix*/
    if( vk->ConstraintList.empty()){
      double EigThreshold = 1.e-9;
      vkGetEigVal(wa, eigv, 3);
      if (eigv[0] < eigv[2] * EigThreshold) {
        wa[0] += (eigv[2] * EigThreshold - eigv[0]);
        wa[2] += (eigv[2] * EigThreshold - eigv[0]);
        wa[5] += (eigv[2] * EigThreshold - eigv[0]);
      }
    }else{
      vkGetEigVal(vk->wa, eigv, 3);
      wa[0] += eigv[2] * 1.e-12;  //Permanent addition works better than addition
      wa[2] += eigv[2] * 1.e-12;  // for small eigenvalues only.
      wa[5] += eigv[2] * 1.e-12;
      vk->wa[0] += eigv[2] * 1.e-12;  //Permanent addition works better than addition
      vk->wa[2] += eigv[2] * 1.e-12;  // for small eigenvalues only.
      vk->wa[5] += eigv[2] * 1.e-12;
    }
  }
 
  /*   covariance matrix on vertex coordinates */
  for(ii=0; ii<6; ii++) {if(std::isnan(wa[ii])) return -2;} // Matrix inversion failed
  if(wa[0]<0 || wa[2]<0 || wa[5]<0) return -2; // Matrix elements must be positive!
  IERR=cfdinv(wa, &(vk->fitVcov[0]), -3);
  if (IERR) {IERR=cfdinv(wa, &(vk->fitVcov[0]), 3);}  // last safety
  if ( !vk->passNearVertex ) {  if (IERR) return IERR; } // If nothing helps - detect failure (not for passNearVertex!!!)
  else {vk->fitVcov[0]=1.;vk->fitVcov[1]=0;vk->fitVcov[2]=1.;vk->fitVcov[3]=0;vk->fitVcov[4]=0;vk->fitVcov[5]=1;}
 
  /*   corrections to vertex coordinates */
  dxyz[0] = vk->fitVcov[0]*tv[0] + vk->fitVcov[1]*tv[1] + vk->fitVcov[3]*tv[2];
  dxyz[1] = vk->fitVcov[1]*tv[0] + vk->fitVcov[2]*tv[1] + vk->fitVcov[4]*tv[2];
  dxyz[2] = vk->fitVcov[3]*tv[0] + vk->fitVcov[4]*tv[1] + vk->fitVcov[5]*tv[2];
  for (j = 0; j < 3; ++j) {
    vk->dxyz0[j] = dxyz[j];
    vk->fitV[j]  = xyzf[j] =  vk->iniV[j] + dxyz[j];
  }
  //std::cout<< "NVertex Old="<<vk->iniV[0]<<", "<<vk->iniV[1]<<", "<<vk->iniV[2]<<" CloseV="<<vk->passNearVertex<<'\n';
  //std::cout<<__func__<<":NVertex shift="<<dxyz[0]<<", "<<dxyz[1]<<", "<<dxyz[2]<<'\n';
 
 
 
 
 
  /*-----------------------------------------------------------*/
  /*   corrections to track parameters and covariance matrices */
 
  for (kt = 0; kt < NTRK; ++kt) {                    /*   variation on PAR is  WCI * TT - (WBCI)t * DXYZ */
    for( int tpn=0; tpn<9; tpn++){
      if(tpn<6)twci[tpn]  = vk->tmpArr[kt]->wci[tpn];
      twbci[tpn] = vk->tmpArr[kt]->wbci[tpn];
    }
    double tt1=vk->tmpArr[kt]->tt[0];
    double tt2=vk->tmpArr[kt]->tt[1];
    double tt3=vk->tmpArr[kt]->tt[2];
    vk->tmpArr[kt]->parf0[0] = twci[0]*tt1 + twci[1]*tt2 + twci[3]*tt3 - twbci[0]*dxyz[0] - twbci[1]*dxyz[1] - twbci[2]*dxyz[2];
    if( !std::isfinite(vk->tmpArr[kt]->parf0[0]) ) return -19; // Rare FPE presumably seen in trigger
    vk->tmpArr[kt]->parf0[1] = twci[1]*tt1 + twci[2]*tt2 + twci[4]*tt3 - twbci[3]*dxyz[0] - twbci[4]*dxyz[1] - twbci[5]*dxyz[2];
    if( !std::isfinite(vk->tmpArr[kt]->parf0[1]) ) return -19; // Rare FPE presumably seen in trigger
    vk->tmpArr[kt]->parf0[2] = twci[3]*tt1 + twci[4]*tt2 + twci[5]*tt3 - twbci[6]*dxyz[0] - twbci[7]*dxyz[1] - twbci[8]*dxyz[2];
    if( !std::isfinite(vk->tmpArr[kt]->parf0[2]) ) return -19; // Rare FPE presumably seen in trigger
    if( (vk->TrackList[kt]->iniP[2] + vk->tmpArr[kt]->parf0[2]) * vk->TrackList[kt]->iniP[2] < 0 ){
      vk->tmpArr[kt]->parf0[2]= - vk->TrackList[kt]->iniP[2]/4.; } // VK 15.12.2009 - Protection against change of sign
    vk->TrackList[kt]->fitP[0] = vk->TrackList[kt]->iniP[0] + vk->tmpArr[kt]->parf0[0];
    vk->TrackList[kt]->fitP[1] = vk->TrackList[kt]->iniP[1] + vk->tmpArr[kt]->parf0[1];
    vk->TrackList[kt]->fitP[2] = vk->TrackList[kt]->iniP[2] + vk->tmpArr[kt]->parf0[2];
    //std::cout<<__func__<<":NTrack  shift="<<vk->tmpArr[kt]->parf0[0]<<", "<<vk->tmpArr[kt]->parf0[1]<<", "
    //                                      <<vk->tmpArr[kt]->parf0[2]<<'\n';
  }
  /* ------------------------------------------------------------ */
  /*  The same solution but through full matrix */
  /* ------------------------------------------------------------ */
  if ( vk->passNearVertex ) {
    //std::cout <<" Std="<<vk->dxyz0[0]<<", "<<vk->dxyz0[1]<<", "<<vk->dxyz0[2]<<'\n';
    stv[0] = stv[0] - drdvy[0][0] * vk->FVC.rv0[0] - drdvy[1][0] * vk->FVC.rv0[1];
    stv[1] = stv[1] - drdvy[0][1] * vk->FVC.rv0[0] - drdvy[1][1] * vk->FVC.rv0[1];
    stv[2] = stv[2] - drdvy[0][2] * vk->FVC.rv0[0] - drdvy[1][2] * vk->FVC.rv0[1];
    //Save T vector(see Billoir...)
    vk->T[0]=stv[0];vk->T[1]=stv[1];vk->T[2]=stv[2];
    //
    vk->wa[0] += vyv[0][0];
    vk->wa[1] += vyv[1][0];
    vk->wa[2] += vyv[1][1];
    vk->wa[3] += vyv[2][0];
    vk->wa[4] += vyv[2][1];
    vk->wa[5] += vyv[2][2];
    FullMTXfill(vk, vk->ader);
    if ( vk->passNearVertex ) {
      for (it = 1; it <= NTRK; ++it) {
        drdpy[0][0] = vk->tmpArr[it-1]->drdp[0][0] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][0] * vk->FVC.ywgt[1];
        drdpy[1][0] = vk->tmpArr[it-1]->drdp[0][0] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][0] * vk->FVC.ywgt[2];
        drdpy[0][1] = vk->tmpArr[it-1]->drdp[0][1] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][1] * vk->FVC.ywgt[1];
        drdpy[1][1] = vk->tmpArr[it-1]->drdp[0][1] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][1] * vk->FVC.ywgt[2];
        drdpy[0][2] = vk->tmpArr[it-1]->drdp[0][2] * vk->FVC.ywgt[0] + vk->tmpArr[it-1]->drdp[1][2] * vk->FVC.ywgt[1];
        drdpy[1][2] = vk->tmpArr[it-1]->drdp[0][2] * vk->FVC.ywgt[1] + vk->tmpArr[it-1]->drdp[1][2] * vk->FVC.ywgt[2];
        for (jt = 1; jt <= NTRK; ++jt) {   /* Matrix */
          for (k = 0; k < 3; ++k) {
            for (l = 0; l < 3; ++l) {
              dpipj[k][l] = 0.;
              for (j = 0; j < 2; ++j) {
                dpipj[k][l] +=  vk->tmpArr[jt-1]->drdp[j][k] * drdpy[j][l];
              }
            }
          }
          for (k = 1; k <= 3; ++k) {
            for (l = 1; l <= 3; ++l) {
              ader_ref(it * 3 + k, jt * 3 + l) +=  dpipj[l-1][k-1];
            }
          }
        }
      }
    }
    //VK 27-Sep-2006     Add eigenvalue limitation for 7,8,9,10,13,14 constraints
    double ArrTmp[9]; int ktmp=0;
    for (k=1; k<=3; ++k) {
      for (l=1; l<=k; ++l)  { ArrTmp[ktmp++] = ader_ref(k,l); }}
    vkGetEigVal(ArrTmp, eigv, 3);
    double EigAddon=0.;
    if( eigv[0]<0 ){EigAddon=eigv[0];}
    for (k = 1; k <=3; ++k) {
      ader_ref(k,k) = ader_ref(k,k) - EigAddon + eigv[2] * 1.e-18 ;
    }
    //----------------------------------------------------------------------------------
    long int NParam = NTRK*3 + 3;
    dsinv(NParam, vk->ader, vkalNTrkM*3+3, &IERR);
    if ( IERR) return IERR;
    double *fortst = new double[vkalNTrkM*3+3];
    for (j = 0; j < 3; ++j) {
      fortst[j] = stv[j];
      for (ii=0; ii<NTRK; ++ii) { fortst[ii*3 +3 +j] = vk->tmpArr[ii]->tt[j];}
    }
    for (j=0; j<3; ++j) {
      dxyz[j] = 0.;
      for (ii=0; ii<NParam; ++ii) {dxyz[j] += ader_ref(j+1, ii+1) * fortst[ii];}
      vk->dxyz0[j]  = dxyz [j];
      vk->fitV[j] = vk->iniV[j] + dxyz[j];
    }
    double tparf0[3]={0.};
    for (it = 1; it <= NTRK; ++it) {
      TWRK* t_trk=vk->tmpArr[it-1].get();
      for (j=0; j<3; ++j) {
        tparf0[j] = 0.;
        for (ii = 1; ii <= NParam; ++ii) { tparf0[j] +=  ader_ref(it*3+j+1, ii)*fortst[ii-1];}
      }
      for (j=0; j<3; ++j) { t_trk->parf0[j] = tparf0[j];
        vk->TrackList[it-1]->fitP[j] = vk->TrackList[it-1]->iniP[j] + tparf0[j];}
    }
    vk->fitVcov[0] = ader_ref(1, 1);
    vk->fitVcov[1] = ader_ref(2, 1);
    vk->fitVcov[2] = ader_ref(2, 2);
    vk->fitVcov[3] = ader_ref(3, 1);
    vk->fitVcov[4] = ader_ref(3, 2);
    vk->fitVcov[5] = ader_ref(3, 3);
    delete[]  fortst;
 
    //std::cout<< "NVertex Full="<<vk->fitV[0]<<", "<<vk->fitV[1]<<", "<<vk->fitV[2]<<'\n';
    //std::cout<< "NVertex Full shft="<<dxyz[0]<<", "<<dxyz[1]<<", "<<dxyz[2]<<'\n';
    //double *tmpA=new double[3+3*NTRK+20];
    //IERR = FullMCNSTfill( vk, vk->ader, tmpA);
    //delete[] tmpA;
  }
  /* ------------------------------------------------------------ */
  /*           End of the solution with full matrix               */
  /*                                */
  /*          Now constraints                   */
  /* ------------------------------------------------------------ */
  double dCoefNorm = 0;
  if ( !vk->ConstraintList.empty()) {
    IERR =  vtcfitc( vk );
    if (IERR != 0)   return IERR;
    double* tmpB=new double[3+3*NTRK]; double* tmpA=new double[3+3*NTRK];
    for (ii=0; ii<3; ++ii) {
      tmpA[ii]   =  vk->fitV[ii] - vk->iniV[ii];
      tmpB[ii]   =  vk->dxyz0[ii];
    }
    for ( it=0; it<NTRK; ++it) {
      tmpA[0 +3*it+3] =  vk->TrackList[it]->fitP[0] - vk->TrackList[it]->iniP[0];
      tmpA[1 +3*it+3] =  vk->TrackList[it]->fitP[1] - vk->TrackList[it]->iniP[1];
      tmpA[2 +3*it+3] =  vk->TrackList[it]->fitP[2] - vk->TrackList[it]->iniP[2];
      tmpB[0 +3*it+3] =  vk->tmpArr[it]->parf0[0];
      tmpB[1 +3*it+3] =  vk->tmpArr[it]->parf0[1];
      tmpB[2 +3*it+3] =  vk->tmpArr[it]->parf0[2];
    }
    double scalAA=0., scalAB=0.;
    for (ii=0; ii<3+3*NTRK; ii++) scalAA += tmpA[ii]*tmpA[ii];
    for (ii=0; ii<3+3*NTRK; ii++) scalAB += tmpA[ii]*tmpB[ii];
    if(scalAB != 0.) dCoefNorm = -scalAA/scalAB;
    //double scalCC;
    //for (ii=0; ii<3+3*NTRK; ii++) scalCC += (tmpA[ii]+dCoefNorm*tmpB[ii])*(tmpA[ii]+dCoefNorm*tmpB[ii]); // Length of perp vector
    delete[] tmpA; delete[] tmpB;
 
    //std::cout<<"VRTOLD="<<vk->fitV[0] - vk->iniV[0]<<", "<<vk->fitV[1] - vk->iniV[1]<<", "
    //                                                     <<vk->fitV[2] - vk->iniV[2]<<'\n';
    //for ( it=0; it<NTRK; ++it) std::cout<<"TRKOLD="<<vk->TrackList[it]->fitP[0] - vk->TrackList[it]->iniP[0]<<", "
    //                                               <<vk->TrackList[it]->fitP[1] - vk->TrackList[it]->iniP[1]<<", "
    //                                               <<vk->TrackList[it]->fitP[2] - vk->TrackList[it]->iniP[2]<<'\n';
    //tmpA=new double[3+3*NTRK+20];
    //IERR = FullMCNSTfill( vk, vk->ader, tmpA);
    //delete[] tmpA;
  }
 
  /*   chi2 with fitted values */
 
  for (it = 0; it < NTRK; ++it) {    //Check if curvature sign is changed or change in Pt is too big
    if(vk->TrackList[it]->Id >= 0){
      double Ratio=vk->TrackList[it]->fitP[2]/vk->TrackList[it]->Perig[4]; if(std::abs(Ratio)<1.)Ratio=1./Ratio;
      if(Ratio<0. || Ratio > vkalAllowedPtChange ){
        if(std::abs(vk->TrackList[it]->fitP[2])<std::abs(vk->TrackList[it]->Perig[4]) || Ratio<0 ){
          vk->TrackList[it]->fitP[2]=vk->TrackList[it]->Perig[4]/vkalAllowedPtChange;
        }else{
          vk->TrackList[it]->fitP[2]=vk->TrackList[it]->Perig[4]*vkalAllowedPtChange;
        }
      }
    }
  }
  //--Additional iterations along shift direction
  bool improved=makePostFit( vk , wgtvrtd, dCoefNorm);
  if(!improved)improved=makePostFit( vk , wgtvrtd, dCoefNorm); //Step truncation doesn't help. Make second pass
  if(!improved)vk->truncatedStep=true;
 
  //-- If no additional iterations (for tests)
  //makeNoPostFit( vk , wgtvrtd, dCoefNorm);
 
 
  return 0;
 
}

vtcfitc()

int Trk::vtcfitc

(

VKVertex *

vk

)

Definition at line 16 of file VtCFitC.cxx.

{
 
    int ii,ic,it,jc,index;
 
    double tmp[3];
 
/* -------------------------------------------------------- */
/*         Start of constraint treatment */
/* -------------------------------------------------------- */
    long int IERR = 0;
    long int totNC=0;  //total number of constraints
    long int NTRK = vk->TrackList.size();
    if (vk->ConstraintList.empty()) {return 0;}
//
    double dxyz[3]={vk->dxyz0[0],vk->dxyz0[1],vk->dxyz0[2]}; //nonconstraint vertex shift
//
// Extruction of derivatives
//
    std::vector<std::vector< const Vect3DF*> > tf0t;  // derivative collectors
    std::vector< const Vect3DF* >       th0t;  // derivative collectors
    std::vector< double >               taa;   // derivative collectors
    th0t.reserve(vk->ConstraintList.size() * vk->ConstraintList[0]->NCDim);
    tf0t.reserve(vk->ConstraintList.size());
 
    for(ii=0; ii<(int)vk->ConstraintList.size();ii++){
       totNC += vk->ConstraintList[ii]->NCDim;
       for(ic=0; ic<(int)vk->ConstraintList[ii]->NCDim; ic++){
         taa.push_back(  vk->ConstraintList[ii]->aa[ic] );
         th0t.push_back( &(vk->ConstraintList[ii]->h0t[ic]) );
         std::vector< const Vect3DF* > tmpVec;
         tmpVec.reserve(vk->ConstraintList[ii]->f0t.size());
         for(it=0; it<(int)vk->ConstraintList[ii]->f0t.size(); it++){
           tmpVec.push_back( &(vk->ConstraintList[ii]->f0t[it][ic]) );
         }
         tf0t.push_back( std::move(tmpVec) );
       }
    }
    if(totNC==0)return 0;
//
    std::vector< std::vector<double> > denom;
    denom.reserve(totNC);
    for(int ic=0; ic<totNC; ic++) denom.emplace_back( totNC, 0 );
//
//  Start of calc
//
    //This is deliberately written without make_unqiue to bypass auto intialization!!
    std::unique_ptr< Vect3DF[] > al0( new Vect3DF[ totNC ]);
    for(ic=0;ic<totNC; ic++){ al0[ic].X=0.; al0[ic].Y=0.; al0[ic].Z=0.;}
    std::vector<double> anum(totNC,0.);
    for (ic=0; ic<totNC; ++ic) {
    for (it = 0; it<NTRK; ++it) {
 
/*   summation of  WBCI * F0T  into vector  AL0 */
        al0[ic].X +=  vk->tmpArr[it]->wbci[0] * tf0t[ic][it]->X
                + vk->tmpArr[it]->wbci[3] * tf0t[ic][it]->Y
                + vk->tmpArr[it]->wbci[6] * tf0t[ic][it]->Z;
        al0[ic].Y +=  vk->tmpArr[it]->wbci[1] * tf0t[ic][it]->X
                + vk->tmpArr[it]->wbci[4] * tf0t[ic][it]->Y
                + vk->tmpArr[it]->wbci[7] * tf0t[ic][it]->Z;
        al0[ic].Z +=  vk->tmpArr[it]->wbci[2] * tf0t[ic][it]->X
                + vk->tmpArr[it]->wbci[5] * tf0t[ic][it]->Y
                + vk->tmpArr[it]->wbci[8] * tf0t[ic][it]->Z;
 
        anum[ic] +=  vk->tmpArr[it]->parf0[0] * tf0t[ic][it]->X
                   + vk->tmpArr[it]->parf0[1] * tf0t[ic][it]->Y
               + vk->tmpArr[it]->parf0[2] * tf0t[ic][it]->Z;
 
    }
    al0[ic].X -=  th0t[ic]->X;
    al0[ic].Y -=  th0t[ic]->Y;
    al0[ic].Z -=  th0t[ic]->Z;
    anum[ic] = 2.*anum[ic] + dxyz[0] * 2. * th0t[ic]->X
                           + dxyz[1] * 2. * th0t[ic]->Y
                       + dxyz[2] * 2. * th0t[ic]->Z
                       + taa[ic];
    }
 
//std::cout<<" vertex="<<dxyz[0]<<", "<<dxyz[1]<<", "<<dxyz[2]<<'\n';
//std::cout<<"    h0t="<<th0t[0].X<<", "<<th0t[0].Y<<", "<<th0t[0].Z<<'\n';
//std::cout<<"    f0t="<<tf0t[0][0].X<<", "<<tf0t[0][0].Y<<", "<<tf0t[0][0].Z<<'\n';
//std::cout<<"    f0t="<<tf0t[0][1].X<<", "<<tf0t[0][1].Y<<", "<<tf0t[0][1].Z<<'\n';
 
 
 
/*  calculation (AL0)t * VCOV * AL0 and (F0T)t * WCI * F0T */
    for (ic=0; ic<totNC; ++ic) {
    for (jc=0; jc<totNC; ++jc) {
        denom[ic][jc] =     al0[ic].X * vk->fitVcov[0] * al0[jc].X
                          + al0[ic].Y * vk->fitVcov[1] * al0[jc].X
                  + al0[ic].Z * vk->fitVcov[3] * al0[jc].X
                  + al0[ic].X * vk->fitVcov[1] * al0[jc].Y
                  + al0[ic].Y * vk->fitVcov[2] * al0[jc].Y
                  + al0[ic].Z * vk->fitVcov[4] * al0[jc].Y
                  + al0[ic].X * vk->fitVcov[3] * al0[jc].Z
                  + al0[ic].Y * vk->fitVcov[4] * al0[jc].Z
                  + al0[ic].Z * vk->fitVcov[5] * al0[jc].Z
                  + al0[jc].X * vk->fitVcov[0] * al0[ic].X
                  + al0[jc].Y * vk->fitVcov[1] * al0[ic].X
                  + al0[jc].Z * vk->fitVcov[3] * al0[ic].X
                  + al0[jc].X * vk->fitVcov[1] * al0[ic].Y
                  + al0[jc].Y * vk->fitVcov[2] * al0[ic].Y
                  + al0[jc].Z * vk->fitVcov[4] * al0[ic].Y
                  + al0[jc].X * vk->fitVcov[3] * al0[ic].Z
                  + al0[jc].Y * vk->fitVcov[4] * al0[ic].Z
                  + al0[jc].Z * vk->fitVcov[5] * al0[ic].Z;
 
        for (it=0; it<NTRK; ++it) {
                TWRK * t_trk=vk->tmpArr[it].get();
        denom[ic][jc] +=          tf0t[ic][it]->X * t_trk->wci[0] * tf0t[jc][it]->X
                    + tf0t[ic][it]->Y * t_trk->wci[1] * tf0t[jc][it]->X
                    + tf0t[ic][it]->Z * t_trk->wci[3] * tf0t[jc][it]->X
                    + tf0t[ic][it]->X * t_trk->wci[1] * tf0t[jc][it]->Y
                    + tf0t[ic][it]->Y * t_trk->wci[2] * tf0t[jc][it]->Y
                    + tf0t[ic][it]->Z * t_trk->wci[4] * tf0t[jc][it]->Y
                    + tf0t[ic][it]->X * t_trk->wci[3] * tf0t[jc][it]->Z
                    + tf0t[ic][it]->Y * t_trk->wci[4] * tf0t[jc][it]->Z
                    + tf0t[ic][it]->Z * t_trk->wci[5] * tf0t[jc][it]->Z
                    + tf0t[jc][it]->X * t_trk->wci[0] * tf0t[ic][it]->X
                    + tf0t[jc][it]->Y * t_trk->wci[1] * tf0t[ic][it]->X
                    + tf0t[jc][it]->Z * t_trk->wci[3] * tf0t[ic][it]->X
                    + tf0t[jc][it]->X * t_trk->wci[1] * tf0t[ic][it]->Y
                    + tf0t[jc][it]->Y * t_trk->wci[2] * tf0t[ic][it]->Y
                    + tf0t[jc][it]->Z * t_trk->wci[4] * tf0t[ic][it]->Y
                    + tf0t[jc][it]->X * t_trk->wci[3] * tf0t[ic][it]->Z
                    + tf0t[jc][it]->Y * t_trk->wci[4] * tf0t[ic][it]->Z
                    + tf0t[jc][it]->Z * t_trk->wci[5] * tf0t[ic][it]->Z;
        }
    }
    }
 
/*    Solving of system DENOM(i,j)*COEF(j)=ANUM(i) */
/*            for lagrange couplings               */
/*-------------------------------------------------*/
    //This is deliberately written without make_unqiue to bypass auto intialization!!
    auto coef = std::unique_ptr<double[]>(new double[totNC]);
    if (totNC == 1) {
    if (denom[0][0] != 0.) {
        coef[0] = anum[0] / denom[0][0];
    } else {
        coef[0] = 1.e3;
    }
    } else {
        //This is deliberately written without make_unqiue to bypass auto intialization!!
        std::unique_ptr<double[]> adenom( new double[totNC*totNC] );
 
    for (ic=0; ic<totNC; ic++) {
        for (jc=0; jc<totNC; jc++) {
        adenom[ic*totNC + jc] = denom[ic][jc];
        }
    }
/* -- INVERT */
    dsinv(totNC, adenom.get(), totNC, &IERR);
    if (IERR) {
      return IERR;
    }
    for (ic=0; ic<totNC; ++ic) {
        coef[ic] = 0.;
        for (jc=0; jc<totNC; ++jc) {
        index = ic*totNC + jc;
        coef[ic] += adenom[index] * anum[jc];
        }
    }
    }
 
 
/*  new vertex */
    dxyz[0] = 0.;
    dxyz[1] = 0.;
    dxyz[2] = 0.;
 
    //This is deliberately written without make_unqiue to bypass auto intialization!!
    auto tmpVec = std::unique_ptr<Vect3DF[]>(new  Vect3DF[totNC]);
    for (ic=0; ic<totNC; ++ic) {
    tmpVec[ic].X =     vk->fitVcov[0] * al0[ic].X
                     + vk->fitVcov[1] * al0[ic].Y
                 + vk->fitVcov[3] * al0[ic].Z;
    tmpVec[ic].Y =     vk->fitVcov[1] * al0[ic].X
             + vk->fitVcov[2] * al0[ic].Y
             + vk->fitVcov[4] * al0[ic].Z;
    tmpVec[ic].Z =     vk->fitVcov[3] * al0[ic].X
             + vk->fitVcov[4] * al0[ic].Y
             + vk->fitVcov[5] * al0[ic].Z;
    dxyz[0] += coef[ic] * tmpVec[ic].X;
    dxyz[1] += coef[ic] * tmpVec[ic].Y;
    dxyz[2] += coef[ic] * tmpVec[ic].Z;
    }
    vk->fitV[0]  =   vk->iniV[0] + vk->dxyz0[0] + dxyz[0];
    vk->fitV[1]  =   vk->iniV[1] + vk->dxyz0[1] + dxyz[1];
    vk->fitV[2]  =   vk->iniV[2] + vk->dxyz0[2] + dxyz[2];
 
//std::cout <<"New vrt="<<vk->dxyz0[0]<<", "<<vk->dxyz0[1]<<", "<<vk->dxyz0[2]<<'\n';
//std::cout<<"Ncntvrt shift="<<dxyz[0]<<", "<<dxyz[1]<<", "<<dxyz[2]<<'\n';
 
/*  new momenta */
    for (it=0; it<NTRK; ++it) {
       TWRK * t_trk=vk->tmpArr[it].get();
    tmp[0] = 0.;
    tmp[1] = 0.;
    tmp[2] = 0.;
    for (ic=0; ic<totNC; ++ic) {
        tmp[0] += coef[ic] * ( tf0t[ic][it]->X + t_trk->wb[0]*tmpVec[ic].X
                              + t_trk->wb[1]*tmpVec[ic].Y
                          + t_trk->wb[2]*tmpVec[ic].Z);
        tmp[1] += coef[ic] * ( tf0t[ic][it]->Y + t_trk->wb[3]*tmpVec[ic].X
                              + t_trk->wb[4]*tmpVec[ic].Y
                          + t_trk->wb[5]*tmpVec[ic].Z);
        tmp[2] += coef[ic] * ( tf0t[ic][it]->Z + t_trk->wb[6]*tmpVec[ic].X
                              + t_trk->wb[7]*tmpVec[ic].Y
                          + t_trk->wb[8]*tmpVec[ic].Z);
    }
 
/*    calculation WCI * TMP */
        VKTrack * trk = vk->TrackList[it].get();
    trk->fitP[0] -=  t_trk->wci[0]*tmp[0] + t_trk->wci[1]*tmp[1] + t_trk->wci[3]*tmp[2];
    trk->fitP[1] -=  t_trk->wci[1]*tmp[0] + t_trk->wci[2]*tmp[1] + t_trk->wci[4]*tmp[2];
    double concor =  t_trk->wci[3]*tmp[0] + t_trk->wci[4]*tmp[1] + t_trk->wci[5]*tmp[2];
    if( (trk->fitP[2] - concor)*trk->fitP[2] < 0) { concor=trk->fitP[2]/4.; } // VK 15.12.2009 - Protection against change of sign
    trk->fitP[2] -=  concor;
//std::cout<<" Npar="<<trk->fitP[0] <<", "<<trk->fitP[1]<<", "<<trk->fitP[2]<<'\n';
   }
/* =================================================================== */
    return 0;
}

xyztrp()

void Trk::xyztrp	(	const long int	ich,
		double *	vrt0,
		double *	pv0,
		double *	covi,
		double	BMAG,
		double *	paro,
		double *	errt )

Definition at line 16 of file XYZtrp.cxx.

{
    double covd[15],par[5], cnv[36];    /* was [6][6] */
/* ---------------------------------------------------------- */
/*       Subroutine for convertion                            */
/*           (X,Y,Z,PX,PY,PZ) --> (eps,z,theta,phi,1/r)       */
/* Now it's used in VKalVrtFitter only                        */
/*                                                            */
/*       Input:                                               */
/*                 ICH      -  charge of track ( +1,0,-1 )    */
/*                 VRT0(3)  -  Vertex of particle             */
/*                  PV0(3)  -  Momentum of particle           */
/*                 COVI(21) -  simmetric covariance matrix    */
/*       Output:                                              */
/*                 PARO(5)  -  (eps,z,theta,phi,1/r)          */
/*                 ERRT(15) -  simmetric error matrix         */
/*    Reference point for output is (0,0,0)                   */
/*    For ICH=0  PARO(5) = const/pt                           */
/*          Propagation is done for NEW track,                */
/*           so no TrkID reference established                */
/* Author: V.Kostyukhin                                       */
/* ---------------------------------------------------------- */
 
    double constBF =BMAG * vkalMagCnvCst;
 
    double pt = sqrt(pv0[0]*pv0[0] + pv0[1]*pv0[1]);
    double pp = pt*pt + pv0[2]*pv0[2];                   // p**2
    double cs  = pv0[0] / pt;
    double sn  = pv0[1] / pt;
    double ctg = pv0[2] / pt;
    double rho = ich * constBF / pt;
    if (ich == 0)rho = constBF / pt;
/* --  Output parameters */
    par[0] = 0.;                    /*            (-Yv*cos + Xv*sin) */
    par[1] = 0.;                    /*  Zv - cotth*(Xv*cos + Yv*sin) */
    par[2] = acos(pv0[2] / sqrt(pp));
    if(par[2]<1.e-5)par[2]=1.e-5;
    if(par[2]>M_PI-1.e-5) par[2]=M_PI-1.e-5;
    par[3] = atan2(pv0[1], pv0[0]);
    par[4] = rho;
    if (ich == 0)par[4] = constBF / pt;
//---
    double dTheta_dPx =  pv0[0]*pv0[2]/(pt*pp);   //dTheta/dPx
    double dTheta_dPy =  pv0[1]*pv0[2]/(pt*pp);   //dTheta/dPy
    double dTheta_dPz = -pt/pp;                   //dTheta/dPz
    double dPhi_dPx   = -pv0[1]/(pt*pt);          //dPhi/dPx
    double dPhi_dPy   =  pv0[0]/(pt*pt);          //dPhi/dPy
    double dPhi_dPz   =             0;            //dPhi/dPz
    double dRho_dPx   = -pv0[0]/(pt*pt) * rho;    //dInvR/dPx
    double dRho_dPy   = -pv0[1]/(pt*pt) * rho;    //dInvR/dPy
    double dRho_dPz   =                    0.;    //dInvR/dPz
//---
    cnv_ref(1, 1) =  sn;
    cnv_ref(2, 1) = -cs;
    cnv_ref(3, 1) =  0.;
    cnv_ref(4, 1) =  0.;
    cnv_ref(5, 1) =  0.;
    cnv_ref(6, 1) =  0.;
 
    cnv_ref(1, 2) = -cs * ctg;
    cnv_ref(2, 2) = -sn * ctg;
    cnv_ref(3, 2) = 1.;
    cnv_ref(4, 2) = 0.;
    cnv_ref(5, 2) = 0.;
    cnv_ref(6, 2) = 0.;
 
    cnv_ref(1, 3) = 0.;
    cnv_ref(2, 3) = 0.;
    cnv_ref(3, 3) = 0.;
    cnv_ref(4, 3) = dTheta_dPx;
    cnv_ref(5, 3) = dTheta_dPy;
    cnv_ref(6, 3) = dTheta_dPz;
 
    cnv_ref(1, 4) = 0.;
    cnv_ref(2, 4) = 0.;
    if(ich) cnv_ref(1, 4) = -cs * rho;  // For charged tracks only
    if(ich) cnv_ref(2, 4) = -sn * rho;  //
    cnv_ref(3, 4) = 0.;
    cnv_ref(4, 4) = dPhi_dPx;
    cnv_ref(5, 4) = dPhi_dPy;
    cnv_ref(6, 4) = dPhi_dPz;
 
    cnv_ref(1, 5) = 0.;
    cnv_ref(2, 5) = 0.;
    cnv_ref(3, 5) = 0.;
    cnv_ref(4, 5) = dRho_dPx;
    cnv_ref(5, 5) = dRho_dPy;
    cnv_ref(6, 5) = dRho_dPz;
    tdasatVK(cnv, covi , covd, 5, 6);
 
/* -- Translation to (0,0,0) (BackPropagation) --*/
    double Ref0[3]={0.,0.,0.};
    Trk::vkalPropagator::Propagate(-999, ich, par, covd, vrt0, Ref0, paro, errt, nullptr);
 
}

Variable Documentation

do_not_delete

template<typename T>

const auto Trk::do_not_delete = [](T*) {}

Definition at line 15 of file SharedDoNoDelete.h.

{};

MAXNCHAMBERS

int Trk::MAXNCHAMBERS =50

constexpr

Definition at line 38 of file GlobalChi2AlignTool.cxx.

MAXNINDICES

int Trk::MAXNINDICES =50*6

constexpr

Definition at line 39 of file GlobalChi2AlignTool.cxx.

NeutralParametersDim

size_t Trk::NeutralParametersDim = 5

constexpr

Definition at line 24 of file NeutralParameters.h.

TrackParametersDim

size_t Trk::TrackParametersDim = 5

constexpr

Definition at line 22 of file Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h.