Trk Namespace Reference

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

Namespaces
	Error
	GsfMeasurementUpdator
	InvalidParam
	MeasurementBaseType
	MultiComponentStateAssembler
	Helper struct representing a cache of the Multicomponent state under assembly.
	MultiComponentStateCombiner
	MultiComponentStateHelpers
	MultiComponentStateModeCalculator
	ParticleMasses
	ParticleSwitcher
	RIO_OnTrackType
	RungeKuttaUtils
	TrackFitInputPreparator
	Helpers to transform combinations of tracking input (for example, existing tracks plus additional measurements) into a digestable fitter input: either tracks, measurement-sets or proto-state vectors.
	TrackState
	TruthClassification

Classes
class	AbstractVolume
class	AdaptiveMultiVertexFitter
class	AdaptiveMultiVertexFitterTestAlg
class	AdaptiveVertexFitter
class	AdaptiveVertexFitterTestAlg
class	AlignableTrackingVolume
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
class	AlSpaMat
class	AlSymMat
class	AlSymMatBase
class	AlVec
class	AmbiguityProcessorBase
class	AnalyticalDerivCalcTool
class	AnnulusBounds
class	AnnulusBoundsPC
	Class that implements the asymmetric shape of the ITk strip endcap modules. More...
class	ApproachDescriptor
class	ApproachSurfaces
class	AreaExcluder
class	AssociatedMaterial
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
class	BevelledCylinderVolumeBounds
class	BinnedArray
class	BinnedArray1D
class	BinnedArray1D1D
class	BinnedArray1D1D1D
class	BinnedArray2D
class	BinnedArrayArray
class	BinnedLayerMaterial
class	BinnedLayerMaterial_p1
class	BinnedLayerMaterialCreator
class	BinnedMaterial
class	BinningData
class	BinUtility
class	BinUtility_p1
class	BinUtilityTest
class	BitField
	A class managing bits belonging to a range of bits. More...
class	BoundaryCheck
class	BoundaryCylinderSurface
class	BoundaryDiscSurface
class	BoundaryPlaneSurface
class	BoundarySubtractedCylinderSurface
class	BoundarySubtractedPlaneSurface
class	BoundarySurface
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	CaloExtension
	Tracking class to hold the extrapolation from a particle from the ID to the muon system (or the other way around) Both the caloEntryLayerIntersection and the muonEntryLayerIntersection can return NULL 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
class	Charged
class	Chi2TrackCompatibilityEstimator
struct	ClusterSplitProbability_p1
class	ClusterSplitProbabilityContainer
	Container to associate Cluster with cluster splitting probabilities. More...
class	ClusterSplitProbabilityContainer_p1
class	ClusterSplitProbabilityContainerCnv_p1
class	CollinearityConstraint
class	CombinedExtrapolatorTest
class	CombinedVolumeBounds
class	CommonTruthMatchWeights
class	CompactBinnedArray
class	CompactBinnedArray1D
class	CompactBinnedArray2D
class	CompareTwoTracks
class	ComparisonFunction
class	CompetingRIOsOnTrack
	Base class for all CompetingRIOsOnTack implementations, extends the common MeasurementBase. More...
class	CompetingRIOsOnTrack_p1
struct	ComponentParameters
class	CompoundLayer
	A class to represent complex geometries requiring a description using multiple surfaces. More...
class	CompoundLayerMaterial
class	CompoundLayerMaterial_p1
class	CompoundLayerMaterialCreator
class	CompressedLayerMaterial
class	CompressedLayerMaterial_p1
class	CompressedLayerMaterialCreator
class	ConeBounds
class	ConeBounds_p1
class	ConeLayer
class	ConeSurface
class	ConstrainedTrackProvider
class	ConstSharedPtrSpan
struct	CovarianceMatrix
class	CrossDistancesSeedFinder
class	CuboidVolumeBounds
class	CurvilinearParametersT
class	CurvilinearUVT
class	CylinderBounds
class	CylinderBounds_p1
struct	CylinderIntersector
class	CylinderLayer
class	CylinderLayerAttemptsCalculator
class	CylinderLayerSorterR
class	CylinderSurface
class	CylinderVolumeBoundaryAccessors
class	CylinderVolumeBounds
class	CylinderVolumeCreator
class	DAF_ValidationNtupleHelper
class	DecayInFlyTruthTrajectoryBuilder
class	DefParamPullPlots
class	DenseEnvironmentsAmbiguityProcessorTool
class	DenseEnvironmentsAmbiguityScoreProcessorTool
struct	DestBound
class	DetachedTrackingVolume
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
class	DetElementSurface
class	DetElementSurface_p1
class	DiamondBounds
class	DiamondBounds_p1
class	DigitizationModule
struct	DigitizationStep
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	DiscBounds_p1
class	DiscLayer
class	DiscLayerAttemptsCalculator
class	DiscLayerSorterZ
class	DiscSurface
class	DiscTrapezoidalBounds
class	DistanceSolution
class	DistributedKalmanFilter
class	DoubleTrapezoidVolumeBounds
class	DummyAnnealingMaker
class	DummySeedFinder
class	DummyVertexSelectionTool
class	DummyVertexSmoother
struct	EdgeCross
class	EfficiencyPlots
class	ElasticTruthTrajectoryBuilder
class	ElectronCombinedMaterialEffects
class	ElectronMaterialMixtureConvolution
class	ElementFraction
class	ElementTable
class	ElementTable_p1
class	EllipseBounds
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
class	EnergyLossMonitor
class	EnergyLossUpdator
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
class	EventPropertyNtupleTool
class	EventToTrackLinkNtupleTool
class	ExtendedVxCandidate
class	ExtendedVxCandidate_p1
class	ExtrapolationCache
class	ExtrapolationCell
class	ExtrapolationCode
class	ExtrapolationConfig
class	ExtrapolationEngine
class	ExtrapolationEngineTest
class	ExtrapolationMode
	enumeration to decode - for Extrapolation steering More...
class	ExtrapolationStep
class	ExtrapolationValidation
class	Extrapolator
	Extrapolation of track parameters and their associated covariances to destination surfaces. More...
class	ExtrapolatorComparisonTest
class	ExtrapolatorTest
class	ExtrLayerPlots
class	ExtrRegionPlots
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. It holds the same payload as FitQuality_p1. More...
class	FitQualityOnSurface
class	FitterStatusCode
	Status codes for track fitters. More...
struct	ForCFT
struct	ForVrtClose
class	FsmwMode1dFinder
class	FullIntersection
	Class extension to return the object, a represenation & the result. More...
class	FullLinearizedTrackFactory
class	FullVertexFitter
	This class implements a full vertex fitting algorithm as proposed by P. More...
class	GaussianDensityTestAlg
class	GaussianSumFitter
class	GaussianTrackDensity
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
class	GeometryAsciiDumper
class	GeometryBuilder
class	GeometryBuilderCond
class	GeometryJsonDumper
class	GeometryTTreeDumper
class	GeoShapeConverter
class	GlobalChi2AlignTool
class	GlobalChi2Fitter
class	GlueVolumesDescriptor
class	GMTreeBrowser
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
class	HitResidualPlots
class	HitTypePlots
class	HomogeneousLayerMaterial
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
class	IBoundaryCheckTool
class	ICaloCellSelector
	abstract class that judge if a calo cell is to be included in a collection More...
class	ICaloTrackingVolumeBuilder
struct	IdentifiedIntersection
class	IdentifierExtractor
	Small utility to get hit Identifiers out of MeasurementBase (either in a vector or single). More...
class	IDerivCalcTool
class	IDetachedTrackingVolumeBuilder
class	IDetachedTrackingVolumeBuilderCond
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
class	IEnergyLossMonitor
class	IEnergyLossUpdator
class	IEventCnvSuperTool
class	IEventPropertyNtupleTool
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
class	IExtrapolator
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
class	IGeometryBuilderCond
class	IGeometryManagerTool
class	IGeometryProcessor
class	IGlobalTrackFitter
class	IImpactPoint3dEstimator
class	IIntersector
class	IIsoTrackSelectorTool
	The abstract interface base class for track selector tools targeted at isoloation. More...
class	IJacobianManagerTool
class	IJetTruthNtupleTool
class	IKinematicConstraint
class	ILayerArrayCreator
class	ILayerBuilder
class	ILayerBuilderCond
class	ILayerMaterialAnalyser
class	ILayerMaterialCreator
class	ILayerMaterialManipulator
class	ILayerProvider
class	ILayerProviderCond
class	IMaterialAllocator
class	IMaterialEffectsEngine
class	IMaterialEffectsOnTrackProvider
class	IMaterialEffectsUpdator
class	IMaterialMapper
class	IMaterialMixtureConvolution
class	IMatrixTool
class	IMode1dFinder
class	IMode3dFinder
class	IMode3dInfo
	Auxillary interface for getting back additional data. More...
class	IModuleStepper
struct	ImpactParametersAndSigma
class	ImpactPlots
class	ImpactPoint3dEstimator
class	IMultipleScatteringUpdator
class	IMultiStateExtrapolator
class	INavigationEngine
class	INavigator
class	InDetHaloSelector
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
class	InputLayerMaterialProvider
struct	Intersection
class	IntersectorWrapper
class	IntVec
class	InvalidBounds
class	InverseMultiMap
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
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
class	IPropagator
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
class	ITimedExtrapolator
class	ITimedMatEffUpdator
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
class	ITrackFitter
class	ITrackHoleSearchTool
	interface for searching, counting and adding holes on tracks anywhere in ATLAS. More...
class	ITrackingGeometrySvc
class	ITrackingVolumeArrayCreator
class	ITrackingVolumeBuilder
class	ITrackingVolumeCreator
class	ITrackingVolumeHelper
class	ITrackingVolumesSvc
class	ITrackLink
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
class	ITrkAlignDBTool
class	ITrkAlignmentDeviationTool
	Interface for tool to add alignmenties to a global chi2 fit. More...
class	ITrkDistanceFinder
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
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
class	IVertexAnalyticSeedFinder
class	IVertexAnnealingMaker
class	IVertexCascadeFitter
class	IVertexCollectionSortingTool
	Interface class for vertex Container Sorting. More...
class	IVertexFitter
class	IVertexLinearizedTrackFactory
class	IVertexMapper
class	IVertexMergingTool
	Interface class for merging compatible vertices in a single collection. More...
class	IVertexSeedFinder
class	IVertexSelectionTool
	Interface class for vertex Container Sorting. More...
class	IVertexSmoother
class	IVertexTrackCompatibilityEstimator
class	IVertexTrackDensityEstimator
class	IVertexTrackUpdator
class	IVertexUpdator
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
class	JacobianCotThetaPtToThetaP
class	JacobianCurvilinearToLocal
class	JacobianLocalAnglesPhiTheta
class	JacobianLocalToCurvilinear
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
class	JacobianPhiThetaQoverPToPxyz
class	JacobianPolarToCartesian
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
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
struct	JetVtxParamDefsStrings
class	KalmanUpdator
	Implementation of Trk::IUpdator based on gain formalism and Eigen. More...
class	KalmanUpdator_xk
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
class	KalmanVertexUpdator
struct	KDOP
class	Layer
class	LayerArrayCreator
class	LayerAttemptsCalculator
class	LayerIndex
class	LayerMaterialAnalyser
class	LayerMaterialConverter
class	LayerMaterialInspector
class	LayerMaterialMap
class	LayerMaterialMap_p1
class	LayerMaterialMap_tlp1
class	LayerMaterialProperties
class	LayerMaterialProvider
class	LayerMaterialRecord
class	LayerProvider
class	LayerProviderCond
class	LayerProviderImpl
struct	LayerTreeObject
class	LinearizedTrack
struct	LineIntersection2D
class	LineSaggingDescriptor
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
struct	MappedVertex
class	MappingTest
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
class	Material_p1
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
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
class	MaterialInteraction
class	MaterialLayer
class	MaterialManipulation
class	MaterialMapper
class	MaterialMapping
class	MaterialOnTrackValidation
class	MaterialProperties
class	MaterialProperties_p1
class	MaterialStep
class	MaterialStep_p1
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
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
class	Mode3dFromFsmw1dFinder
class	Mode3dTo1dFinder
class	MSConstraintTracksProvider
class	MSHitDiffPlots
class	MSHitPlots
class	MultiComponentStateOnSurface
class	MultipleScatteringUpdator
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
struct	NavigationCell
	useful struct for a single navigation cell More...
class	NavigationLayer
class	Navigator
class	NeuralNetworkToHistoTool
class	Neutral
class	NeutralParticleParameterCalculator
class	NeutralTrack
class	NewtonTrkDistanceFinder
class	NIMatEffUpdator
class	NoBounds
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
class	PairOfVxVertexOnJetAxis
struct	ParamDefsAccessor
class	ParametersBase
class	ParametersCommon
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
class	Perigee_p1
class	Perigee_p2
class	PerigeeParametersNtupleTool
	Explain... More...
class	PerigeeSurface
class	PGraph
class	PlanarModuleStepper
class	PlaneLayer
class	PlaneLayerSorterX
class	PlaneLayerSorterY
class	PlaneLayerSorterZ
class	PlaneSurface
class	PointOnTrack
struct	PolygonCache
class	PositionMomentumWriter
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
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
class	ProjectionMatricesSet
	the matrices to access the variably-dimensioned local parameters and map them to the defined five track parameters. More...
class	PropagationEngine
class	PropResultRootWriterSvc
class	PseudoMeasurementOnTrack
	Class to handle pseudo-measurements in fitters and on track objects. More...
class	PseudoMeasurementOnTrack_p1
class	PseudoMeasurementOnTrack_p2
class	RandomSurfaceBuilder
struct	RealLinearEquation
struct	RealQuadraticEquation
class	RecMomentumQualityValidation
class	RecoInfoPlots
class	RectangleBounds
class	RectangleBounds_p1
class	RectangularSegmentation
class	RecursiveGeometryProcessor
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
class	ResolutionPlots
class	RiddersAlgorithm
class	RIO_OnTrack
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
class	RotatedDiamondBounds_p1
class	RotatedTrapezoidBounds
class	RotatedTrapezoidBounds_p1
class	RungeKuttaIntersector
class	RungeKuttaPropagator
class	SaggedLineSurface
class	ScatteringAngleOnTrack_p1
class	ScatteringAngles
	represents a deflection of the track caused through multiple scattering in material. More...
class	SecVertexMergingTool
class	SeedNewtonTrkDistanceFinder
class	Segment
class	Segment_p1
class	Segmentation
class	SegmentCollection_p1
class	SegmentCollection_tlp1
class	SegmentCollection_tlp2
class	SegmentCollection_tlp3
class	SegmentCollection_tlp4
class	SelectedTracksInJet
class	SelectEventNumber
class	SequentialVertexFitter
class	SequentialVertexSmoother
class	ShiftingDerivCalcTool
class	SimpleAmbiguityProcessorTool
class	SimplePolygonBrepVolumeBounds
struct	sincosCache
class	SingleTrackDiffAlg
class	SlidingCylinderSurface
class	SlidingDiscSurface
class	SolenoidalIntersector
class	SolenoidParametrization
class	SolenoidParametrizationCondAlg
class	SpacePoint
class	SpaceTimePoint
	SpaceTimePoint. More...
class	SpaceTimePointBase
	SpaceTimePointBase. More...
class	StaticEngine
class	StaticNavigationEngine
class	StatTruthCollectionFilter
	Works like PCutTruthCollectionFilter, but also gathers some stats about the collections. More...
class	STEP_Propagator
class	StepEngine
class	StraightLineIntersector
class	StraightLineSurface
class	SubDetHitStatistics_p0
class	SubtractedCylinderLayer
class	SubtractedCylinderSurface
class	SubtractedDiscSurface
class	SubtractedPlaneLayer
class	SubtractedPlaneSurface
class	SubtractedVolumeBounds
class	SumPtVertexWeightCalculator
class	Surface
class	Surface_p1
class	Surface_p2
class	SurfaceBounds
class	SurfaceDeleter
class	SurfaceIntersectionTest
struct	SurfaceNtupleBranch
	This class provides a simple interface to write Surfaces to a root tree. More...
class	SurfacePtrHolderImpl
class	SurfacePtrHolderImplBase
class	SurfacePtrHolderImplDetEl
struct	SurfaceTreeObject
class	SurfaceUniqHolderImpl
struct	TargetSurface
	target surface info ( navigation ) More...
class	TargetSurfaces
class	temp
class	TimedExtrapolator
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
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
class	TrackingGeometryCondAlg
class	TrackingGeometryCondAlgTest
class	TrackingGeometrySvc
class	TrackingGeometryTest
class	TrackingVolume
class	TrackingVolumeArrayCreator
class	TrackingVolumeDisplayer
class	TrackingVolumeHelper
class	TrackingVolumeManipulator
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	TrackSegment_p1
class	TrackSelectionProcessorTool
class	TrackSlimmer
class	TrackSlimmingTool
class	TrackStateData
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
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
struct	TransformNtupleBranch
	This class provides a simple interface to write Transforms to a root tree. More...
class	TransportJacobian
class	TrapezoidBounds
class	TrapezoidBounds_p1
class	TrapezoidSegmentation
class	TrapezoidVolumeBounds
class	TriangleBounds
class	TriangleBounds_p1
	Persisent representation of the transient TriangleBounds class. More...
class	Trk2DDistanceFinder
class	Trk2dDistanceSeeder
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
class	TrkDetDescrTPCnvTest
class	TrkDetDescrUnitTestBase
class	TrkDetElementBase
class	TrkDistanceFinderNeutralCharged
class	TrkDistanceFinderNeutralNeutral
class	TrkEndCapClusterNode
class	TrkExUnitTestBase
class	TrkFilteringNode1D
class	TrkFilteringNode2D
class	TrkMaterialProviderTool
class	TrkObserverTool
class	TrkPixelNode
class	TrkPlanarSurface
class	TrkPriVxPurity
class	TrkPriVxPurityTool
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
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
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
class	Vertex_p1
class	VertexCollectionSortingTool
class	VertexMapper
class	VertexMergingTool
class	VertexOnTrack
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	VKThetaConstraint
class	VKTrack
class	VKVertex
class	Volume
class	VolumeBounds
class	VolumeConverter
class	VolumeExcluder
struct	VolumeExit
class	VolumeIntersection
class	VolumeLink
struct	VolumePart
struct	VolumeSpan
struct	VolumeTreeObject
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< SharedObject< Surface >, Amg::Vector3D >	SurfaceOrderPosition
using	TrackingVolumeOrderPosition = std::pair< std::shared_ptr< TrackingVolume >, Amg::Vector3D >
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 BinnedArray< Layer >	LayerArray
typedef std::vector< std::vector< const MaterialProperties * > >	MaterialPropertiesMatrix
using	TrackingVolumeArray = BinnedArray< TrackingVolume >
typedef std::pair< SharedObject< const Layer >, Amg::Vector3D >	LayerOrderPosition
template<class T >
using	BinnedArraySpan = std::span< T >
typedef std::map< Trk::LayerIndex, int >	LayerIndexSampleMap
using	ThreeObjectsAccessor = std::array< ObjectAccessor::value_type, 3 >
using	FourObjectsAccessor = std::pair< std::array< ObjectAccessor::value_type, 4 >, bool >
using	FiveObjectsAccessor = std::array< ObjectAccessor::value_type, 5 >
using	SixObjectsAccessor = std::array< ObjectAccessor::value_type, 6 >
using	EightObjectsAccessor = std::array< ObjectAccessor::value_type, 8 >
template<class T >
using	SharedObject = std::shared_ptr< T >
typedef std::pair< const Material *, int >	IdentifiedMaterial
typedef std::vector< unsigned char >	ValueVector
typedef std::vector< ValueVector >	ValueMatrix
template<class T >
using	ArraySpan = std::span< T >
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. More...
typedef DataVector< Trk::MaterialStep >	MaterialStepCollection
template<class T >
using	LayerIntersection = FullIntersection< Layer, Surface, T >
template<class T >
using	BoundaryIntersection = FullIntersection< BoundarySurface< TrackingVolume >, Surface, T >
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 = SurfaceUniqHolderImpl< StraightLineSurface >
using	SurfaceUniqHolder = SurfaceUniqHolderImpl< Surface >
using	SurfacePtrHolderDetEl = Trk::SurfacePtrHolderImplDetEl< Surface >
typedef std::pair< size_t, size_t >	DigitizationCell
typedef std::pair< double, ParamDefs >	DefinedParameter
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 More...
typedef std::pair< const Surface *, BoundaryCheck >	DestSurf
	typedef for input surfaces, boundary check More...
typedef std::vector< std::unique_ptr< Trk::TrackParameters > >	TrackParametersUVector
using	TrackParmContainer = ObjContainer< Trk::TrackParameters >
using	TrackParmPtr = ObjRef
using	ManagedTrackParmPtr = ObjPtr< Trk::TrackParameters >
typedef std::pair< const NavigationCell *, const NavigationCell * >	NavigationPair
typedef std::vector< const Trk::TrackParameters * >	TrackParametersVector
typedef std::vector< TargetSurface >	TargetSurfaceVector
typedef bool	RunOutlierRemoval
	switch to toggle quality processing after fit More...
using	PrepRawDataSet = std::vector< const PrepRawData * >
	vector of clusters and drift circles More...
using	MeasurementSet = std::vector< const MeasurementBase * >
	vector of fittable measurements More...
using	RIO_OnTrackSet = std::vector< const RIO_OnTrack * >
	vector of detector hits on a track More...
using	SpacePointSet = std::vector< const SpacePoint * >
	vector of space points More...
typedef bool	SortInputFlag
	switch to toggle sorting More...
typedef DataVector< const TrackStateOnSurface >::const_iterator	TS_iterator
typedef std::vector< std::pair< const Trk::MeasurementBase *, int > >	MB_IndexVector
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. More...
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 }
enum	BinningType { equidistant, biequidistant, arbitrary }
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	DetectorElemType {   DetectorElemType::SolidState = 0, DetectorElemType::Silicon = 1, DetectorElemType::TRT = 2, DetectorElemType::Csc = 3,   DetectorElemType::Mdt = 4, DetectorElemType::Rpc = 5, DetectorElemType::Tgc = 6, DetectorElemType::sTgc = 7,   DetectorElemType::MM = 8 }
enum	LayerType { passive = 0, active = 1 }
enum	MaterialConcentration { alongPre = 1, split = 0, oppositePre = -1 }
enum	MagneticFieldMode { NoField = 0, ConstantField = 1, FastField = 2, FullField = 3 }
enum	NavigationLevel { noNavigation = 0, globalSearch = 1, association = 2 }
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	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 }
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 }
enum	PropDirection { alongMomentum = 1, oppositeMomentum =-1, anyDirection = 0, mappingMode = 2 }
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	SurfaceType {   SurfaceType::Cone = 0, SurfaceType::Cylinder = 1, SurfaceType::Disc = 2, SurfaceType::Perigee = 3,   SurfaceType::Plane = 4, SurfaceType::Line = 5, Curvilinear = 6, SurfaceType::Other = 7 }
enum	VertexType {   NoVtx = 0, PriVtx = 1, SecVtx = 2, PileUp = 3,   ConvVtx = 4, V0Vtx = 5, KinkVtx = 6, V0Lambda = 7,   V0LambdaBar = 8, V0KShort = 9, NotSpecified = -99 }
enum	ParametersType { AtaSurface = 0, Curvilinear = 1, Curvilinear = 6, Pattern = 2 }
enum	PrepRawDataType {   PrepRawDataType::SiCluster, PrepRawDataType::PixelCluster, PrepRawDataType::SCT_Cluster, PrepRawDataType::TRT_DriftCircle,   PrepRawDataType::HGTD_Cluster, PrepRawDataType::PlanarCluster, PrepRawDataType::MdtPrepData, PrepRawDataType::CscStripPrepData,   PrepRawDataType::CscPrepData, PrepRawDataType::MMPrepData, PrepRawDataType::RpcPrepData, PrepRawDataType::TgcPrepData,   PrepRawDataType::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	SurfNavigType {   Target = 0, BoundaryFrame = 1, BoundaryDetached = 2, SensitiveLayer = 3,   MaterialLayer = 4 }
	typedef for surface and volume navigation types More...
enum	TVNavigType { Unknown = 0, Frame = 1, AlignableVolume = 2, DenseVolume = 3 }
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	BoundaryCheckResult {   BoundaryCheckResult::Candidate, BoundaryCheckResult::OnEdge, BoundaryCheckResult::Insensitive, BoundaryCheckResult::Outside,   BoundaryCheckResult::DeadElement, BoundaryCheckResult::Error }
enum	TRT_ElectronPidProbability { Combined = 0, HighThreshold = 1, TimeOverThreshold = 2, Bremsstrahlung = 3 }
enum	VKContraintType {   VKContraintType::Mass, VKContraintType::Phi, VKContraintType::Theta, VKContraintType::Point,   VKContraintType::Plane }
enum	{ NTrMaxVFit =200 }

Functions
void	decomposeTransform (const Amg::Transform3D &transform, double *values)
std::string	detTypeStr (AlignModule::DetectorType detType)
	returns the detector type More...
MsgStream &	operator<< (MsgStream &sl, const AlignModule &alignModule)
	overload of << operator for MsgStream for debug output More...
MsgStream &	operator<< (MsgStream &sl, const AlignPar &alignPar)
	overload of << operator for MsgStream for debug output More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
std::ostream &	operator<< (std::ostream &sl, const CurvilinearUVT &uvt)
MsgStream &	operator<< (MsgStream &sl, const FitQualityImpl &fq)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const FitQualityImpl &fq)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const JacobianCurvilinearToLocal &jac)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const JacobianCurvilinearToLocal &jac)
MsgStream &	operator<< (MsgStream &sl, const JacobianLocalToCurvilinear &jac)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const JacobianLocalToCurvilinear &jac)
MsgStream &	operator<< (MsgStream &sl, const LocalDirection &lomo)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
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. More...
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. More...
std::ostream &	operator<< (std::ostream &sl, const EnergyLoss &eloss)
	Overload of << operator for std::ostream for debug outputstd::ostream&. More...
MsgStream &	operator<< (MsgStream &sl, const MaterialEffectsBase &meb)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const MaterialEffectsBase &meb)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const Trk::ScatteringAngles &saos)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const Trk::ScatteringAngles &saos)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const Trk::MeasurementBase &mbase)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const Trk::MeasurementBase &mbase)
	Overload of << operator for std::ostream for debug output. More...
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. More...
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. More...
std::ostream &	operator<< (std::ostream &sl, const TrackParticleBase &trackParticleBase)
	Overload of << operator for std::ostream for debug output. More...
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. More...
std::ostream &	operator<< (std::ostream &stream, const TrackRoad &tr)
	Dump the road into a standard output stream. More...
MsgStream &	operator<< (MsgStream &sl, const Trk::SpacePoint &spacePoint)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const SpacePoint &spacePoint)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const TrackStateOnSurface &tsos)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const TrackStateOnSurface &tsos)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const AlignmentEffectsOnTrack &tsos)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const AlignmentEffectsOnTrack &tsos)
	Overload of << operator for std::ostream for debug output. More...
	AmgSymMatrix (5) &GXFTrackState
MsgStream &	operator<< (MsgStream &, const MultiComponentStateOnSurface &)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &, const MultiComponentStateOnSurface &)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const Track &track)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const Track &track)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &sl, const TrackInfo &track)
	Overload of << operator for MsgStream for debug output. More...
std::ostream &	operator<< (std::ostream &sl, const TrackInfo &track)
	Overload of << operator for std::ostream for debug output. More...
MsgStream &	operator<< (MsgStream &out, const MuonTrackSummary &trackSum)
	output. More...
std::ostream &	operator<< (std::ostream &out, const MuonTrackSummary &trackSum)
	output. More...
MsgStream &	operator<< (MsgStream &out, const TrackSummary &trackSum)
	output. More...
std::ostream &	operator<< (std::ostream &out, const TrackSummary &trackSum)
	output. More...
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. More...
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. More...
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? More...
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? More...
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. More...
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. More...
MsgStream &	operator<< (MsgStream &sl, const TrackSurfaceIntersection &tsfi)
	Overload of << operator for both, MsgStream and std::ostream for debug output. More...
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 BMAG, double *MASS, double *sigM)
void	cfmasserrold_ (const long int ntrk, long int *list, double *parfs, double *ams, double *deriv, double BMAG, double *dm, double *sigm)
void	vkPerigeeToP (const double *perig3, double *pp, double BMAG)
std::array< double, 4 >	getFitParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getFitParticleMom (const VKTrack *trk, double BMAG)
std::array< double, 4 >	getIniParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getIniParticleMom (const VKTrack *trk, double BMAG)
std::array< double, 4 >	getCnstParticleMom (const VKTrack *trk, const VKVertex *vk)
std::array< double, 4 >	getCnstParticleMom (const VKTrack *trk, double BMAG)
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)
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)
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 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))

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

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.

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

namespace for general tracking tools and interfaces

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.

In reality one should prefer the code based on SurfaceUniquePtr But : We get this kind of warning when creating dictionaries: Error in <CloseStreamerInfoROOTFile>: I/O is supported only for unique_ptrs with a default deleter. Trk::SurfaceUniqHolder::m_associatedSurface appears to have a custom one Which can be problematic for some cases. So we provide also the plain ptr one

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

A namespace to enclose the Tracking classes.

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

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

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

A namespace for all vertexing packages and related stuff.

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 22 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 = typedef std::span<T>

Definition at line 34 of file DetachedTrackingVolume.h.

AtaCone

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

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

AtaCylinder

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

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

AtaDisc

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

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

AtaPlane

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

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

AtaStraightLine

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

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

BaseParameters

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

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

BinnedArraySpan

template<class T >

using Trk::BinnedArraySpan = typedef std::span<T>

Definition at line 34 of file BinnedArray.h.

BoundaryIntersection

template<class T >

using Trk::BoundaryIntersection = typedef FullIntersection<BoundarySurface<TrackingVolume>, Surface, T>

Definition at line 86 of file TrackingVolume.h.

ConeSurfacePtrHolder

using Trk::ConeSurfacePtrHolder = typedef SurfacePtrHolderImpl<ConeSurface>

Definition at line 19 of file SurfaceHolders.h.

ConeSurfaceUniqHolder

using Trk::ConeSurfaceUniqHolder = typedef 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 = typedef CurvilinearParametersT<TrackParametersDim, Charged, PlaneSurface>

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

CylinderSurfacePtrHolder

using Trk::CylinderSurfacePtrHolder = typedef SurfacePtrHolderImpl<CylinderSurface>

Definition at line 20 of file SurfaceHolders.h.

CylinderSurfaceUniqHolder

using Trk::CylinderSurfaceUniqHolder = typedef 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

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

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 = typedef SurfacePtrHolderImpl<DiscSurface>

Definition at line 21 of file SurfaceHolders.h.

DiscSurfaceUniqHolder

using Trk::DiscSurfaceUniqHolder = typedef 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 = typedef 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 = typedef std::array<ObjectAccessor::value_type, 5>

Definition at line 16 of file ObjectsAccessor.h.

FourObjectsAccessor

using Trk::FourObjectsAccessor = typedef 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<const Material*, int> Trk::IdentifiedMaterial

Definition at line 28 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 30 of file ILayerArrayCreator.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 = typedef FullIntersection<Layer, Surface, T>

Definition at line 84 of file TrackingVolume.h.

LayerMaterialCollection

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

Definition at line 19 of file LayerMaterialCollection.h.

LayerOrderPosition

Trk::LayerOrderPosition

Definition at line 37 of file LayerArrayCreator.h.

ManagedTrackParmPtr

using Trk::ManagedTrackParmPtr = typedef ObjPtr<Trk::TrackParameters>

Definition at line 66 of file Extrapolator.h.

mapiterator

typedef datamap::iterator Trk::mapiterator

Definition at line 29 of file AlSymMatBase.h.

MaterialComponent

using Trk::MaterialComponent = typedef 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.

MB_IndexVector

typedef std::vector<std::pair<const Trk::MeasurementBase *, int> > Trk::MB_IndexVector

Definition at line 24 of file TrackFitInputPreparator.h.

MeasuredPerigee

typedef Perigee Trk::MeasuredPerigee

Definition at line 23 of file MeasuredPerigeeCnv_p1.h.

MeasurementSet

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

vector of fittable measurements

Definition at line 30 of file FitterTypes.h.

MultiComponentState

using Trk::MultiComponentState = typedef 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 = typedef ParametersT<NeutralParametersDim, Neutral, ConeSurface>

Definition at line 28 of file NeutralParameters.h.

NeutralAtaCylinder

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

Definition at line 29 of file NeutralParameters.h.

NeutralAtaDisc

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

Definition at line 30 of file NeutralParameters.h.

NeutralAtaPlane

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

Definition at line 32 of file NeutralParameters.h.

NeutralAtaStraightLine

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

Definition at line 33 of file NeutralParameters.h.

NeutralCurvilinearParameters

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

Definition at line 27 of file NeutralParameters.h.

NeutralParameters

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

Definition at line 26 of file NeutralParameters.h.

NeutralPerigee

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

Definition at line 31 of file NeutralParameters.h.

noinit_vector

template<class T >

using Trk::noinit_vector = typedef 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 = typedef 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 = typedef SurfacePtrHolderImpl<PerigeeSurface>

Definition at line 22 of file SurfaceHolders.h.

PerigeeSurfaceUniqHolder

using Trk::PerigeeSurfaceUniqHolder = typedef SurfaceUniqHolderImpl<PerigeeSurface>

Definition at line 30 of file SurfaceHolders.h.

PlaneSurfacePtrHolder

using Trk::PlaneSurfacePtrHolder = typedef SurfacePtrHolderImpl<PlaneSurface>

Definition at line 23 of file SurfaceHolders.h.

PlaneSurfaceUniqHolder

using Trk::PlaneSurfaceUniqHolder = typedef 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 = typedef std::vector<const PrepRawData*>

vector of clusters and drift circles

Definition at line 26 of file FitterTypes.h.

RIO_OnTrackSet

using Trk::RIO_OnTrackSet = typedef 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.

SharedObject

template<class T >

using Trk::SharedObject = typedef std::shared_ptr<T>

Definition at line 24 of file SharedObject.h.

SixObjectsAccessor

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

Definition at line 17 of file ObjectsAccessor.h.

SortInputFlag

typedef bool Trk::SortInputFlag

switch to toggle sorting

Definition at line 21 of file TrackFitInputPreparator.h.

SpacePointSet

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

vector of space points

Definition at line 38 of file FitterTypes.h.

StraightLineSurfacePtrHolder

using Trk::StraightLineSurfacePtrHolder = typedef SurfacePtrHolderImpl<StraightLineSurface>

Definition at line 24 of file SurfaceHolders.h.

StraightLineSurfaceUniqHolder

using Trk::StraightLineSurfaceUniqHolder = typedef SurfaceUniqHolderImpl<StraightLineSurface>

Definition at line 32 of file SurfaceHolders.h.

SurfaceArray

typedef BinnedArray<Surface> Trk::SurfaceArray

Definition at line 41 of file Layer.h.

SurfaceIntersection

typedef ObjectIntersection< Surface > Trk::SurfaceIntersection

Definition at line 40 of file Layer.h.

SurfaceOrderPosition

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

Definition at line 37 of file HGTD_LayerBuilderCond.h.

SurfacePtrHolder

using Trk::SurfacePtrHolder = typedef SurfacePtrHolderImpl<Surface>

Definition at line 25 of file SurfaceHolders.h.

SurfacePtrHolderDetEl

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

Definition at line 36 of file SurfaceHolders.h.

SurfaceUniqHolder

using Trk::SurfaceUniqHolder = typedef 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 = typedef std::unique_ptr<S, SurfaceDeleter<S> >

Definition at line 32 of file SurfaceUniquePtrT.h.

TargetSurfaceVector

typedef std::vector<TargetSurface> Trk::TargetSurfaceVector

Definition at line 121 of file TargetSurfaces.h.

ThreeObjectsAccessor

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

Definition at line 13 of file ObjectsAccessor.h.

TrackingVolumeArray

typedef BinnedArray< TrackingVolume > Trk::TrackingVolumeArray

simply for the eye

Definition at line 29 of file ITrackingVolumeArrayCreator.h.

TrackingVolumeOrderPosition

using Trk::TrackingVolumeOrderPosition = typedef 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 = typedef ParametersBase<TrackParametersDim, Charged>

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

TrackParametersUVector

typedef std::vector<std::unique_ptr<Trk::TrackParameters> > Trk::TrackParametersUVector

Definition at line 61 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.

TrackParmContainer

using Trk::TrackParmContainer = typedef ObjContainer<Trk::TrackParameters>

Definition at line 64 of file Extrapolator.h.

TrackParmPtr

using Trk::TrackParmPtr = typedef ObjRef

Definition at line 65 of file Extrapolator.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

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.

TS_iterator

typedef DataVector<const TrackStateOnSurface>::const_iterator Trk::TS_iterator

Definition at line 22 of file TrackFitInputPreparator.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 = typedef 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 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 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 48 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 42 of file TrackingGeometry.h.

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

ParamDefs

enum Trk::ParamDefs

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
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

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

Definition at line 25 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 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 52 of file Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h.

{
  noOwn = 0,
  TGOwn = 1,
  DetElOwn = 2,
  userOwn = 3
};

SurfaceType

enum Trk::SurfaceType

strong

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
};

SurfNavigType

enum Trk::SurfNavigType

typedef for surface and volume navigation types

Enumerator
Target
BoundaryFrame
BoundaryDetached
SensitiveLayer
MaterialLayer

Definition at line 38 of file TargetSurfaces.h.

{
  Target = 0,
  BoundaryFrame = 1,
  BoundaryDetached = 2,
  SensitiveLayer = 3, // sensitive layer
  MaterialLayer = 4   // material layer
};

TRT_ElectronPidProbability

enum Trk::TRT_ElectronPidProbability

Enumerator
Combined
HighThreshold
TimeOverThreshold
Bremsstrahlung

Definition at line 30 of file 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   
 
};

TVNavigType

enum Trk::TVNavigType

Enumerator
Unknown
Frame
AlignableVolume
DenseVolume

Definition at line 46 of file TargetSurfaces.h.

{
  Unknown = 0,
  Frame = 1,           // static volume
  AlignableVolume = 2, // alignable volume
  DenseVolume = 3      // dense alignable volume
};

VertexType

enum Trk::VertexType

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 
};

VKContraintType

enum Trk::VKContraintType

strong

Enumerator
Mass
Phi
Theta
Point
Plane

Definition at line 23 of file Derivt.h.

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

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 constBF = Trk::vkalMagFld::getMagFld(vk->refIterV,CONTROL) * Trk::vkalMagFld::getCnvCst() ;
 
    for (i = 1; i <= NTRK; ++i) {
        VKTrack *trk=vk->TrackList[i-1].get();
        invR = trk->fitP[2];
    cth = 1. / tan(trk->fitP[0]);
    pt = constBF / std::abs(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 80 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 constBF = Trk::vkalMagFld::getMagFld(vk->refIterV,CONTROL) * Trk::vkalMagFld::getCnvCst() ;
 
    for (i = 1; i <= NTRK; ++i) {
        VKTrack *trk=vk->TrackList[i-1].get();
        invR = trk->iniP[2];
    cth = 1. / tan(trk->iniP[0]);
    pt = constBF / std::abs(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 233 of file NeutralParticleParameterCalculator.cxx.

AmgSymMatrix() [1/2]

const Trk::AmgSymMatrix

(

3

)

&

Definition at line 77 of file RecVertex.cxx.

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 = (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 = (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 = (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.precision(11);
//std::cout<<" new plane="<<base_cnst->aa[numCNST]<<'\n';
}

calcPointConstraint()

void Trk::calcPointConstraint

(

VKPointConstraint *

cnst

)

Definition at line 20 of file Derclc2.cxx.

{
    VKConstraintBase * base_cnst = (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.;
   }
}

calcThetaConstraint()

void Trk::calcThetaConstraint

(

VKThetaConstraint *

cnst

)

Definition at line 61 of file DerclcAng.cxx.

{
    VKConstraintBase * base_cnst = (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 429 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->vk_fitterControl->vk_forcft.localbmag );
        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,MainVRT->vk_fitterControl->vk_forcft.localbmag, &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	BMAG,
		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 constBF = BMAG * vkalMagCnvCst ;
 
  for(int it=0; it<NTRK; it++){
    if (list[it]) {
       pmom[it][4] = pt = constBF / std::abs(vk->TrackList[it]->fitP[2]);
       pmom[it][5] = cth = 1. /tan(vk->TrackList[it]->fitP[0]);
       pmom[it][0] = px = pt * cos(vk->TrackList[it]->fitP[1]);
       pmom[it][1] = py = pt * sin(vk->TrackList[it]->fitP[1]);
       pmom[it][2] = pz = pt * cth;
       double mmm=vk->TrackList[it]->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);
}

cfmasserrold_()

void Trk::cfmasserrold_	(	const long int	ntrk,
		long int *	list,
		double *	parfs,
		double *	ams,
		double *	deriv,
		double	BMAG,
		double *	dm,
		double *	sigm
	)

Definition at line 83 of file cfMassErr.cxx.

{
    int  i__;
    double ptot[4];
    double constB, dm2dpx, dm2dpy, dm2dpz, ee, pt, px, py, pz, cth;
 
    --deriv;
    --ams;
    parfs -= 4;
    --list;
 
    /* Function Body */
    ptot[0] = 0.;
    ptot[1] = 0.;
    ptot[2] = 0.;
    ptot[3] = 0.;
 
    constB = BMAG * vkalMagCnvCst ;
 
    int i3;
    for (i__ = 1; i__ <= ntrk; ++i__) {
    if (list[i__] == 1) {
        i3 = i__ * 3;
        pt = std::abs(parfs[i3 + 3]);
        pt = constB / pt;
        cth = 1. /tan(parfs[i3 + 1]);
        px = pt * cos(parfs[i3 + 2]);
        py = pt * sin(parfs[i3 + 2]);
        pz = pt * cth;
        ptot[0] += px;
        ptot[1] += py;
        ptot[2] += pz;
        ptot[3] += sqrt(px*px + py*py + pz*pz + ams[i__]*ams[i__]);
    }
    }
 
 
    for (i__ = 1; i__ <= ntrk; ++i__) {
    i3 = i__ * 3;
    if (list[i__] == 1) {
        pt = std::abs(parfs[i3+3]);
        pt = constB / pt;
        cth = 1. / tan(parfs[i3+1]);
        px  = pt * cos(parfs[i3+2]);
        py  = pt * sin(parfs[i3+2]);
        pz  = pt * cth;
        ee = sqrt(px*px + py*py + pz*pz + ams[i__]*ams[i__]);
        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[i3 + 1] = dm2dpz * ((-pt) * (cth * cth + 1.));                    /* d(M2)/d(Theta) */
        deriv[i3 + 2] =  -dm2dpx * py + dm2dpy * px;                            /* d(M2)/d(Phi)   */
        deriv[i3 + 3] = (-dm2dpx * px - dm2dpy*py - dm2dpz*pz)/ parfs[i3+3];    /* d(M2)/d(Rho) */
/* cc Std derivatives-------------------------------------------*/
/*          DCV(6,I*3+1)=-PT*(1+CTH**2)           ! dPz/d(theta)*/
/*          DCV(4,I*3+2)=-PY                      ! dPx/d(phi)  */
/*          DCV(5,I*3+2)= PX                      ! dPy/d(phi)  */
/*          DCV(4,I*3+3)=-PX/PARFS(3,I)           ! dPx/d(rho)  */
/*          DCV(5,I*3+3)=-PY/PARFS(3,I)           ! dPy/d(rho)  */
/*          DCV(6,I*3+3)=-PZ/PARFS(3,I)           ! dPz/d(rho)  */
/* d(M2)/d(Rho) */
    } else {
        deriv[i3 + 1] = 0.;
        deriv[i3 + 2] = 0.;
        deriv[i3 + 3] = 0.;
    }
    }
    deriv[1] = 0.;
    deriv[2] = 0.;
    deriv[3] = 0.;
    double covarm2=ptot[3]; //To avoid compiler warning
    //cferrany_(ntrk, &deriv[1], &covarm2);
    (*dm) = (ptot[3]-ptot[2])*(ptot[3]+ptot[2])-ptot[1]*ptot[1]-ptot[0]*ptot[0];
    if((*dm)<1.e-6)  (*dm) = 1.e-6;
    (*dm)   = sqrt(*dm);
    (*sigm) = sqrt(covarm2) / 2. / (*dm);
}

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() == VKContraintType::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 92 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 magConst = Trk::vkalMagFld::getMagFld(cnstPos,(vk->vk_fitterControl).get())  * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->cnstP[0]);
    double phi      =      trk->cnstP[1];
    double pt       = magConst/ std::abs( 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	BMAG
	)

Definition at line 111 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst =BMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->cnstP[0]);
    double phi      =      trk->cnstP[1];
    double pt       = magConst/ std::abs( 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 magConst =Trk::vkalMagFld::getMagFld(fieldPos,(vk->vk_fitterControl).get())  * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->fitP[0]);
    double phi      = trk->fitP[1];
    double pt       = magConst/ std::abs( 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	BMAG
	)

Definition at line 44 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst =BMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->fitP[0]);
    double phi      = trk->fitP[1];
    double pt       = magConst/ std::abs( 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 685 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 60 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst = Trk::vkalMagFld::getMagFld(vk->refIterV,(vk->vk_fitterControl).get())  * Trk::vkalMagFld::getCnvCst();
 
    double cth = 1. / tan( trk->iniP[0]);
    double phi      =      trk->iniP[1];
    double pt       = magConst/ std::abs( 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	BMAG
	)

Definition at line 75 of file cfMomentum.cxx.

{
    std::array<double, 4> p{};
    double magConst =BMAG  * vkalMagCnvCst;
 
    double cth = 1. / tan( trk->iniP[0]);
    double phi      =      trk->iniP[1];
    double pt       = magConst/ std::abs( 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/113]

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/113]

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

Definition at line 24 of file NoiseOnSurface.cxx.

{
  return se.dump(sl);
}

operator<<() [3/113]

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

Definition at line 94 of file PatternTrackParameters.cxx.

{
  return se.dump(sl);
}

operator<<() [4/113]

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

operator<<() [5/113]

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

Definition at line 16 of file ExtrapolationType.cxx.

                         :
      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    ";
  }
}
}  // namespace Trk

operator<<() [6/113]

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

Definition at line 16 of file MeasurementType.cxx.

                          :
      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     ";
  }
}
}  // namespace Trk

operator<<() [7/113]

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

Definition at line 16 of file ParameterType.cxx.

           :
      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 ";
  }
}
}  // namespace Trk

operator<<() [8/113]

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/113]

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/113]

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/113]

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/113]

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

Definition at line 323 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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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/113]

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 15 of file FitQuality.cxx.

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

operator<<() [24/113]

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/113]

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

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

Definition at line 82 of file JacobianLocalToCurvilinear.cxx.

{ 
    sl << std::setiosflags(std::ios::fixed);
        sl << std::setprecision(6);
        sl << MSG::DEBUG << "Trk::JacobianLocalToCurvilinear"                          << 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<<() [26/113]

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<<() [27/113]

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<<() [28/113]

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

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

operator<<() [29/113]

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<<() [30/113]

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<<() [31/113]

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<<() [32/113]

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<<() [33/113]

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<<() [34/113]

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<<() [35/113]

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<<() [36/113]

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<<() [37/113]

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<<() [38/113]

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<<() [39/113]

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<<() [40/113]

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<<() [41/113]

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<<() [42/113]

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

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

Definition at line 60 of file TrackSurfaceIntersection.cxx.

{
  const std::streamsize ss = sl.precision();
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << MSG::DEBUG << "Trk::TrackSurfaceIntersection  " << std::endl;
  sl << "    position  [mm]   =  (" << tsfi.position().x() << ", "
     << tsfi.position().y() << ", " << tsfi.position().z() << ")" << std::endl;
  sl << "    direction [mm]   =  (" << tsfi.direction().x() << ", "
     << tsfi.direction().y() << ", " << tsfi.direction().z() << ")"
     << std::endl;
  sl << "    delta pathlength =   " << tsfi.pathlength() << std::endl;
  sl.precision(ss);
  return sl;
}

operator<<() [43/113]

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<<() [44/113]

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

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

Definition at line 98 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<<() [45/113]

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<<() [46/113]

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<<() [47/113]

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<<() [48/113]

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<<() [49/113]

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

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

Definition at line 59 of file Vertex.cxx.

{

operator<<() [50/113]

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

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

Definition at line 82 of file VertexPositions.cxx.

{

operator<<() [51/113]

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

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

Definition at line 115 of file Volume.cxx.

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

operator<<() [52/113]

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<<() [53/113]

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 129 of file VxCandidate.cxx.

{
  return sf.dump(sl);
}
 

operator<<() [54/113]

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

Definition at line 70 of file VxClusteringTable.cxx.

operator<<() [55/113]

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 503 of file VxTrackAtVertex.cxx.

operator<<() [56/113]

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<<() [57/113]

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

Definition at line 130 of file PrepRawData.cxx.

{
  return prd.dump(stream);
}

operator<<() [58/113]

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<<() [59/113]

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<<() [60/113]

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

Definition at line 18 of file NoiseOnSurface.cxx.

{ 
  return se.dump(sl); 
}   

operator<<() [61/113]

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

Definition at line 88 of file PatternTrackParameters.cxx.

{
  return se.dump(sl);
}

operator<<() [62/113]

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<<() [63/113]

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<<() [64/113]

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

Definition at line 9 of file Derivt.cxx.

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

operator<<() [65/113]

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

Definition at line 33 of file Derivt.cxx.

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

operator<<() [66/113]

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

Definition at line 56 of file Derivt.cxx.

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

operator<<() [67/113]

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

Definition at line 100 of file Derivt.cxx.

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

operator<<() [68/113]

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

Definition at line 80 of file Derivt.cxx.

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

operator<<() [69/113]

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

Definition at line 68 of file Derivt.cxx.

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

operator<<() [70/113]

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

Definition at line 94 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/113]

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/113]

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/113]

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

Definition at line 214 of file AssociatedMaterial.cxx.

                                                                  {
  return mstep.dump(sl);
}

operator<<() [74/113]

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

Definition at line 23 of file BinUtility.cxx.

{
  return bgen.dump(sl);
}

operator<<() [75/113]

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/113]

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/113]

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/113]

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

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

Definition at line 26 of file FitQuality.cxx.

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

operator<<() [79/113]

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/113]

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

Definition at line 99 of file JacobianLocalToCurvilinear.cxx.

{  
    sl << std::setiosflags(std::ios::fixed);
        sl << std::setprecision(7);        
        sl << "Trk::JacobianLocalToCurvilinear " << 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<<() [81/113]

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

Definition at line 42 of file LayerIndex.cxx.

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

operator<<() [82/113]

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

Definition at line 14 of file LayerMaterialProperties.cxx.

                                                                     {
  return lmp.dump(sl);
}

operator<<() [83/113]

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

Definition at line 119 of file LinearizedTrack.cxx.

operator<<() [84/113]

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<<() [85/113]

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<<() [86/113]

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<<() [87/113]

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<<() [88/113]

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

Definition at line 74 of file MaterialStep.cxx.

                                                            {
  return mstep.dump(sl);
}

operator<<() [89/113]

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<<() [90/113]

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<<() [91/113]

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<<() [92/113]

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

Definition at line 218 of file Surface.cxx.

{
  return sf.dump(sl);
}

operator<<() [93/113]

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

Definition at line 19 of file SurfaceBounds.cxx.

{
  return sb.dump(sl);
}

operator<<() [94/113]

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<<() [95/113]

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<<() [96/113]

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<<() [97/113]

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<<() [98/113]

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

Definition at line 77 of file TrackSurfaceIntersection.cxx.

{
  const std::streamsize ss = sl.precision();
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::TrackSurfaceIntersection  " << std::endl;
  sl << "    position  [mm]   =  (" << tsfi.position().x() << ", "
     << tsfi.position().y() << ", " << tsfi.position().z() << ")" << std::endl;
  sl << "    direction [mm]   =  (" << tsfi.direction().x() << ", "
     << tsfi.direction().y() << ", " << tsfi.direction().z() << ")"
     << std::endl;
  sl << "    delta pathlength =   " << tsfi.pathlength() << std::endl;
  sl.precision(ss);
  return sl;
}

operator<<() [99/113]

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<<() [100/113]

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

Definition at line 120 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<<() [101/113]

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<<() [102/113]

template<int DIM, class T >

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

operator<<() [103/113]

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<<() [104/113]

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

Definition at line 65 of file Vertex.cxx.

operator<<() [105/113]

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

Definition at line 88 of file VertexPositions.cxx.

                   : VertexPositions is not able to return a valid position "
            << " as a const object: need to go from Update to Use mode. "

operator<<() [106/113]

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

Definition at line 122 of file Volume.cxx.

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

operator<<() [107/113]

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

Definition at line 20 of file VolumeBounds.cxx.

{
  return vb.dump(sl);
}

operator<<() [108/113]

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

Definition at line 135 of file VxCandidate.cxx.

operator<<() [109/113]

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

Definition at line 73 of file VxClusteringTable.cxx.

                                     {
 

operator<<() [110/113]

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

Definition at line 509 of file VxTrackAtVertex.cxx.

operator<<() [111/113]

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<<() [112/113]

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

Definition at line 136 of file PrepRawData.cxx.

{
  return prd.dump(stream);
}

operator<<() [113/113]

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_);
  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 531 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 545 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 503 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 639 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() != VKContraintType::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 559 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	BMAG
	)

Definition at line 15 of file cfMomentum.cxx.

{
    double constB =BMAG  * vkalMagCnvCst;
    double phiv = perig3[1];
    double pt   = constB / std::abs(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);
      }
    }
  }
 
  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;
    if ( trk->Charge ) {
      eps     = -vv - uu*uu * invR_ini / 2.;
      zp     = -uu * (1. - vv * invR_ini) * cotth;   //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);
    double d22 = -sinf * cotth     + (  (vv*sinf+uu*cosf)*cotth  *invR_ini);
    //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;
    double e23 =  uu*vv*cotth;
    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 27 of file SharedObject.h.

MAXNCHAMBERS

constexpr int Trk::MAXNCHAMBERS =50

constexpr

Definition at line 38 of file GlobalChi2AlignTool.cxx.

MAXNINDICES

constexpr int Trk::MAXNINDICES =50*6

constexpr

Definition at line 39 of file GlobalChi2AlignTool.cxx.

NeutralParametersDim

constexpr size_t Trk::NeutralParametersDim = 5

constexpr

Definition at line 24 of file NeutralParameters.h.

TrackParametersDim

constexpr size_t Trk::TrackParametersDim = 5

constexpr

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