tracking

Topics
	tracking data objects
	tracking modules

Namespaces
namespace	Belle2::CDC
namespace	Belle2::TestHelpers
	Some utilities to help with writing unit tests.
namespace	Belle2::AnalyzingAlgorithmHelper
	INFO This file contains all the algorithms retrieving infos from Clusters.
namespace	Belle2::SecMapHelper
	namespace for SectorMapHelper-related stuff
namespace	Belle2::DNN
	namespace for DirectedNodeNetwork-related stuff

Classes
class	CDCCKFState
	Define states for CKF algorithm, which can be seed track or CDC wire hit. More...
class	ArcLengthBasedCDCfromEclPathPairFilter
	For the two paths with the same number of hits prefers one with shortest arcLength ("densest path") More...
class	ArcLengthBasedCDCPathPairFilter
	For the two paths with the same number of hits prefers one with shortest arcLength ("densest path") More...
class	CDCPathPairFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	Chi2BasedCDCPathPairFilter
	Prefers path with smallest sum dist^2 / length of path. More...
class	DistanceBasedCDCPathPairFilter
	For the two paths with the same number of hits prefers one with smallest sum dist^2. More...
class	DuplicateCDCPathPairFilter
	Simple filter to distinguish between photon conversion and Bremsstrahlung. More...
class	HitDistanceBasedCDCPathPairFilter
	Prefers path with smallest sum dist^2 / length of path. More...
class	MCTruthCDCPathPairFilter
	For the two paths select the one with the most of MC matched hits. More...
class	CDCfromEclPathTruthVarNames
	Vehicle class to transport the variable names. More...
class	CDCfromEclPathTruthVarSet
	Var set to store basic quantities related to CDC CKF (using truth information) More...
class	CDCPathBasicVarNames
	Vehicle class to transport the variable names. More...
class	CDCPathBasicVarSet
	Var set to store basic quantities related to CDC CKF. More...
class	CDCPathFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	CDCPathTruthVarNames
	Vehicle class to transport the variable names. More...
class	CDCPathTruthVarSet
	Var set to store basic quantities related to CDC CKF (using truth information) More...
class	SeedChargeCDCPathFilter
	Check if charge of fitted path corresponds to charge of seed. More...
class	SizeCDCPathFilter
	Return the size of the path. More...
class	CDCfromEclStateTruthVarNames
	Vehicle class to transport the variable names. More...
class	CDCfromEclStateTruthVarSet
	Var set to store basic quantities related to CDC CKF (using truth information) More...
class	CDCStateBasicVarNames
	Vehicle class to transport the variable names. More...
class	CDCStateBasicVarSet
	Var set to store basic quantities related to CDC CKF. More...
class	CDCStateFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	CDCStateTruthVarNames
	Vehicle class to transport the variable names. More...
class	CDCStateTruthVarSet
	Var set to store basic quantities related to CDC CKF (using truth information) More...
class	DistanceCDCStateFilter
	Give a weight based on the distance from the hit to the path. More...
class	ExtrapolateAndUpdateCDCStateFilter
	An extrapolateAndUpdate filter for all CDC states. More...
class	MCTruthCDCStateFilter
	Give a weight based on the mc truth information (1 or NAN) More...
class	MCTruthEclSeedFilter
	Give a weight based on the mc truth information (1 or NAN) More...
class	RoughCDCfromEclStateFilter
	A very rough filter for all CDC states. More...
class	RoughCDCStateFilter
	A very rough filter for all CDC states. More...
class	CDCCKFDuplicateRemover
	Remove duplicate paths created from ECLShowers These typically come from the seeding with two charge assumptions and Bremsstrahlung. More...
class	CDCCKFEclSeedCreator
	Findlet for. More...
class	CDCCKFPathMerger
	Merge similar paths. More...
class	CDCCKFPathSelector
	Select the m_maximalCandidatesInFlight paths for further processing. More...
class	CDCCKFResultFinalizer
	Findlet to finalize CKF Paths in terms of final result. More...
class	CDCCKFResultStorer
	Store resulting tracks and relations on the dataStore. More...
class	CDCCKFSeedCreator
	Create a CKF seed based on RecoTrack (presumably from VXDTF2) More...
class	CDCCKFStateCreator
	Create CKF states, based on the current path. Perform some basic selection at this stage (based on phi, max. jump of layers) More...
class	CDCCKFStateFilter
	A stack of pre-, helix-extrapolation- , Kalman-extrapolation- and Kalman-update-filters. More...
class	CKFToCDCFindlet
	Main findlet of the ToCDCCKF module. More...
class	CKFToCDCFromEclFindlet
	Main findlet of the ToCDCCKF module. More...
class	StackTreeSearcher
	CKF tree searcher which traces several best paths. More...
class	CKFResult< ASeed, AHit >
	Object for temporary storage of a CKF tree search result. More...
class	CKFState< ASeed, AHit >
	State object to store one step in the CKF algorithm together with its parent (the state before), the hit (e.g. More...
class	AdvanceFilter< AState, AnAdvancer >
	Filter which can be used on a pair of path (vector of states) and states, which will call the extrapolate function of the given advancer class, to extrapolate the last path state to the plane of the new state and store the mSoP in the new state. More...
class	KalmanFilter< AState, AKalmanStepper >
	Filter which can be used on a pair of path (vector of states) and states, which will call the kalmanStep function of the given stepper class, to update the mSoP of the new state with a klaman update. More...
class	NonIPCrossingStateFilter< AllStateFilter >
	Reusable filter for checking the direction of a new state if it is in the correct orientation (forwards or backwards) by their arc length. More...
class	CKFRelationCreator< AState, ASeedRelationFilter, AHitRelationFilter >
	Findlet for applying filters for creating hit-hit and hit-seed relations. More...
class	LayerToggledApplier< AState, AFindlet >
	A special findlet, which is chooseable based on a given findlet for layers higher than N, N and for the rest. More...
class	LimitedOnStateApplier< AState, AFilter >
	Specialisation of the OnStateApplier, which (a) uses a filter for the () operator, which is configurable (b) does only allow for the best N candidates in the child states. More...
class	OnStateApplier< AState >
	Helper findlet which applies its () operator to all pairs of path and state with all states in the given child state list. More...
class	OverlapResolver< AFilter >
	Simple findlet for searching the best candidate for a given seed applying the given filter. More...
class	ResultStorer< AResult >
	This findlet does also handle the storing of the results. More...
class	SpacePointTagger< AResult, ACluster >
	Findlet for tagging all space points in the results vector as used. More...
class	StateCreator< AnObject, AState >
	Create new states and add them to a vector from a given object vector. More...
class	StateCreatorWithReversal< AState >
	An adaption of the normal state creator introducing another parameter to reverse the seed. More...
class	StateRejecter< AState, AFilter >
	Reject some (or all) states from a given list of child states using 5 filters. More...
class	TrackFitterAndDeleter
	Findlet to fit tracks and remove all non fitted ones. More...
class	TrackLoader
	Findlet for loading the seeds from the data store. More...
class	TreeSearcher< AState, AStateRejecter, AResult >
	Findlet for constructing result paths out of a list of states, which are connected with weighted relations. More...
class	Advancer
	Helper findlet for performing an extrapolation of a mSoP of one plane to another plane using the representation stored in the mSoP. More...
struct	SeedGetter
	Helper Functor to get the Seed of a given result. More...
struct	NumberOfHitsGetter
	Helper Functor to get the Number of hits of a given result. More...
struct	GetArcLength
	Helper Functor to get the arc length of a given result. More...
class	KalmanStepper< Dimension >
	Class to bundle all algorithms needed for the kalman update procedure. More...
class	CKFToPXDResult
	Specialized CKF Result for extrapolating into the PXD. More...
class	CKFToPXDState
	Specialized CKF State for extrapolating into the PXD. More...
class	AngularDistancePXDPairFilter
	Base filter for CKF PXD states. More...
class	CylinderDistancePXDPairFilter
	Base filter for CKF PXD states. More...
class	InterceptDistancePXDPairFilter
	Base filter for CKF PXD states. More...
class	LayerPXDRelationFilter< AFilter, APrefilter >
	Base filter for CKF PXD states. More...
class	LoosePXDPairFilter
	Base filter for CKF PXD states. More...
class	PXDPairFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	SensorPXDPairFilter
	Base filter for CKF PXD states. More...
class	PXDResultFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	PXDResultTruthVarNames
	Vehicle class to transport the variable names. More...
class	PXDResultTruthVarSet
	Var set used in the CKF for calculating the probability of a correct result, which knows the truth information if two tracks belong together or not. More...
class	PXDResultVarNames
	Vehicle class to transport the variable names. More...
class	PXDResultVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not. More...
class	SizePXDResultFilter
	Base filter for CKF PXD results (on overlap check) More...
class	AllPXDStateFilter
	A very simple filter for all space points. More...
class	PXDStateBasicVarNames
	Vehicle class to transport the variable names. More...
class	PXDStateBasicVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match. More...
class	PXDStateFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	PXDStateTruthVarNames
	Vehicle class to transport the variable names. More...
class	PXDStateTruthVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not. More...
class	SimplePXDStateFilter
	A very simple filter for all space points. More...
class	CKFToPXDFindlet
	Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (PXD) and collect space points. More...
class	PXDKalmanStepper
	Kalman stepper implementation for the PXD CKF. More...
class	MCUtil
	Class bundling all helper functions for the MC information used in the PXD CKF. More...
class	CKFToSVDResult
	Specialized CKF Result for extrapolating into the SVD. More...
class	CKFToSVDState
	Specialized CKF State for extrapolating into the SVD. More...
class	DistanceSVDPairFilter
	Base filter for CKF SVD states. More...
class	LayerSVDRelationFilter< AFilter, APrefilter >
	Base filter for CKF SVD states. More...
class	LooseSVDPairFilter
	Base filter for CKF SVD states. More...
class	SectorMapBasedSVDPairFilter
	Filter for relations between CKF SVD states based on SectorMaps. More...
class	SensorSVDPairFilter
	Base filter for CKF SVD states. More...
class	SVDPairFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	RelationSVDResultVarNames
	Vehicle class to transport the variable names. More...
class	RelationSVDResultVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not. More...
class	SizeSVDResultFilter
	Base filter for CKF SVD results (on overlap check) More...
class	SVDResultFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	SVDResultTruthVarNames
	Vehicle class to transport the variable names. More...
class	SVDResultTruthVarSet
	Var set used in the CKF for calculating the probability of a correct result, which knows the truth information if two tracks belong together or not. More...
class	SVDResultVarNames
	Vehicle class to transport the variable names. More...
class	SVDResultVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not. More...
class	WeightSVDResultFilter
	Base filter for CKF SVD results (on overlap check) More...
class	AllSVDStateFilter
	A very simple filter for all space points. More...
class	ResidualSVDStateFilter
	A very simple filter for all space points. More...
class	SimpleSVDStateFilter
	A very simple filter for all space points. More...
class	SVDStateBasicVarNames
	Vehicle class to transport the variable names. More...
class	SVDStateBasicVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match. More...
class	SVDStateFilterFactory
	Factory that can create appropriate cluster filters from associated names. More...
class	SVDStateTruthVarNames
	Vehicle class to transport the variable names. More...
class	SVDStateTruthVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match, which knows the truth information if two tracks belong together or not. More...
class	SVDStateVarNames
	Vehicle class to transport the variable names. More...
class	SVDStateVarSet
	Var set used in the VXD-CDC-Merger for calculating the probability of a VXD-CDC-track match. More...
class	CKFToSVDFindlet
	Combinatorial Kalman Filter to extrapolate CDC Reco Tracks into the VXD (SVD) and collect space points. More...
class	CKFToSVDSeedFindlet
	Findlet for combining CDC tracks with SVD tracks. More...
class	RecoTrackRelator
	The results of the CKF ar in the form (seed -> vector of hits). More...
class	RelationApplier
	Relate the SVD and CDC tracks in the given relations also in the store array. More...
class	RelationFromSVDTracksCreator
	Simplified relation creator only creating relations between states of CDC Reco Track seeds and states with SpacePoints, that: (a) for the seed states: connect every seed with every lst hit of the SVD Reco Tracks (b) for the hit states: are in the same SVD Reco Track and follow each other directly. More...
class	SpacePointLoader
	Load the space points from the store array to the given vector. More...
class	SVDKalmanStepper
	Kalman stepper implementation for the SVD CKF. More...
struct	DATCONSVDClusterCandidate
	struct containing a cluster candidate for easier handling More...
class	DATCONSVDDigit
	The DATCONSVDDigit class. More...
class	DATCONFPGAFindlet
	Findlet for performing the DATCON ROI calculation close to the implementation on FPGA. More...
class	DATCONSVDClusterizer
	Findlet for clustering DATCONSVDDigits and creating SVDClusters that are used for tracking in DATCON. More...
class	DATCONSVDClusterLoaderAndPreparer
	Findlet for loading SVDClusters that were created by the DATCONSVDClusterizer findlet and prepare them for usage in the FastInterceptFinder2D by calculating the conformal transformed x,y coordinates and the creating pairs of coordinates for finding track candidates in r-phi and r-z. More...
class	FastInterceptFinder2DFPGA
	Findlet for finging intersections of sinosoidal curves in the 2D Hough space by iteratively calling fastInterceptFinder2d. More...
class	ROICalculator
	Findlet to calculate ROI on the PXD sensors based on input hits. More...
class	SVDShaperDigitConverter
	Findlet for converting SVDShaperDigits into DATCONSVDDigits. More...
class	ToPXDExtrapolator
	Findlet to extrapolate found tracks to the PXD sensors and calculate intercepts. More...
class	CKFParameters
	The payload containing all parameters for the PXD and SVD CKF. More...
class	CkfToPXDFiltersSetting
	The payload containing. More...
class	DAFConfiguration
	The payload containing all the DAFParameters configuration, one for each different track fit option. More...
class	DAFParameters
	The payload containing the DAF parameters. More...
class	KinkFinderParameters
	The payload containing the parameters for the kinkFinder. More...
class	ROICalculationParameters
	The payload containing all PXD ROI parameters. More...
class	SVDEventT0Configuration
	This class store the configuration of the selections applied on the tracks used to compute the SVD EventT0. More...
class	TrackFitMomentumRange
	The payload containing the momentum threshold to disable the particle hypothesis in the track fit. More...
class	TrackFlippingCuts
	The payload containing the cuts for 2 mva based filters to decide whether a RecoTrack should be flipped or not. More...
class	TrackingMVAFilterParameters
	Class for the MVA filter payloads. More...
class	DQMEventProcessorBase
	The purpose of this class is to process one event() in DQMHistoModuleBase, which is a base for TrackDQMModule and AlignDQMModule. More...
class	DQMHistoModuleBase
	This class serves as a base for the TrackDQMModule and AlignDQMModule (and possibly other DQM histogram modules). More...
class	BaseEventTimeExtractor< AIOTypes >
	Class to extract the event t0. More...
class	BaseEventTimeExtractorModuleFindlet< AFindlet >
	Base class for most of the time extraction modules doing a track selection beforehand. More...
class	Chi2BasedEventTimeExtractor
	Event time extraction based on the principle of arXiv:0810.2241. More...
class	DriftLengthBasedEventTimeExtractor
	Event time extraction based on the principle of the CDC drift time calculation. More...
class	FullGridChi2TrackTimeExtractor
	Class to extract the event t0 using the chi-squared approach. More...
class	FullGridDriftLengthTrackTimeExtractor
	Class to extract the event t0 using the drift-length approach. More...
class	GridEventTimeExtractor< AFindlet >
	Generic findlet applying a certain time extractor multiple times. More...
class	HitBasedT0Extractor
	Findlet to extract the T0 time of an event only using CDC Hits. More...
class	IterativeChi2BasedEventTimeExtractor
	Class to iteratively extract the event t0 using the chi-squared approach. More...
class	IterativeDriftLengthBasedEventTimeExtractor
	Class to iteratively extract the event t0 using the drift-length approach. More...
class	IterativeEventTimeExtractor< AFindlet >
	Generic findlet applying a certain time extractor multiple times. More...
class	TrackSelector
	Select the tracks for the event time extraction. More...
class	TimeExtractionUtils
	Helper class to perform all kind of track extrapolations using the methods from arXiv:0810.2241. More...
class	KinkFitter
	KinkFitter class to create Kink mdst's objects from reconstructed tracks. More...
class	TrackMatchLookUp
	Class to provide convenient methods to look up matching information between pattern recognition and Monte Carlo tracks. More...
class	ROIDetPlane
	ROIDetPlane describes the plane containing a sensor. More...
class	ROIGeometry
	This class appends the VXDIntercept infos of a track to the list of intercepts. More...
class	ROIToUnitTranslator< aIntercept >
	Translator for ROI-geometry-information into a list of pixels or strips. More...
class	VXDInterceptor< aIntercept >
	This Class implements the interceptor of the SVD tracks on the PXD layers. More...
class	MCVXDPurityInfo
	The MC VXD Purity info container class. More...
class	SpacePoint
	SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters. More...
class	SpacePointTrackCand
	Storage for (VXD) SpacePoint-based track candidates. More...
struct	ExtState
	Data structure to define extrapolation state. More...
struct	Intersection
	intersection of muid-extrapolated track with a KLM layer More...
class	TrackExtrapolateG4e
	geant4e-based track extrapolation. More...
struct	CALogger
	simple logger for CA algorithm More...
struct	CAValidator< CellType >
	validation tool for CA algorithm More...
class	CellularAutomaton< ContainerType, ValidatorType >
	The CellularAutomaton class This class serves as a functor for the algorithm itself. More...
struct	NodeCompatibilityCheckerBase< NodeType >
	most trivial node compatibility checker, says always true More...
struct	NodeCompatibilityCheckerCA< NodeType >
	simple NodeCompatibilityChecker, which checks for compatible Neighboring states of passed nodes (does no extended validation check) More...
struct	NodeCompatibilityCheckerPathCollector< NodeType >
	simple NodeCompatibilityChecker, which checks for compatible Neighboring states of passed nodes (does no extended validation check) More...
class	NodeFamilyDefiner< ContainerType, NodeType, NeighbourContainerType >
	This class assigns a common family identifier to all CACells in the network that are connected. More...
class	PathCollectorRecursive< ContainerType, NodeType, NeighbourContainerType, NodeCompatibilityCheckerType >
	Path finder for generic ContainerType. More...
class	SPTCSelectorXBestPerFamily
	Algorithm to collect the x best TrackCandidates per family based on a VXD Quality estimator method output. More...
class	StandaloneCosmicsCollector
	Track finding algorithm class for linear tracks produced by cosmics in the VXD without magnetic field. More...
class	TrackerAlgorithmBase< ContainerType, ValidatorType >
	base class for TrackerAlgorithms. shall allow a common base for algorithms like the cellular automaton More...
class	AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >
	Base class for storing an algorithm determining the data one wants to have. More...
class	AnalyzingAlgorithmLostUClusters< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out how many u-type-clusters the testTC lost compared to the refTC. More...
class	AnalyzingAlgorithmLostVClusters< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out how many v-type-clusters the testTC lost compared to the refTC. More...
class	AnalyzingAlgorithmLostUEDep< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out the energy deposit of u-type-clusters the testTC lost compared to the refTC. More...
class	AnalyzingAlgorithmLostVEDep< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out the energy deposit of v-type-clusters the testTC lost compared to the refTC. More...
class	AnalyzingAlgorithmTotalUClusters< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out how many u-type-clusters the given TC had. More...
class	AnalyzingAlgorithmTotalVClusters< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out how many v-type-clusters the given TC had. More...
class	AnalyzingAlgorithmTotalUEDep< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out the energy deposit of u-type-clusters the given TC had. More...
class	AnalyzingAlgorithmTotalVEDep< DataType, TCInfoType, VectorType >
	Class for storing an algorithm to find out the energy deposit of v-type-clusters the given TC had. More...
class	AnalyzingAlgorithmResidualPX< DataType, TCInfoType, VectorType >
	INFO This file contains all the algorithms calculating residuals of something. More...
class	AnalyzingAlgorithmResidualPY< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in Y. More...
class	AnalyzingAlgorithmResidualPZ< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in Z. More...
class	AnalyzingAlgorithmResidualPT< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in pT. More...
class	AnalyzingAlgorithmResidualP< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in |p|. More...
class	AnalyzingAlgorithmResidualPTheta< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in theta (in degrees) More...
class	AnalyzingAlgorithmResidualPPhi< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in phi (in degrees) More...
class	AnalyzingAlgorithmResidualPAngle< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of momentum in its angle (direction residual in degrees) More...
class	AnalyzingAlgorithmResidualPTAngle< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of pT in angle (transverse direction residual in degrees) More...
class	AnalyzingAlgorithmResidualPosition< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of the seed position in 3D. More...
class	AnalyzingAlgorithmResidualPositionXY< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the residual (ref-test) of the seed position in XY (=r) More...
class	AnalyzingAlgorithmValuePX< DataType, TCInfoType, VectorType >
	INFO This file contains all the algorithms calculating a certain value of something. More...
class	AnalyzingAlgorithmValuePY< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in Y. More...
class	AnalyzingAlgorithmValuePZ< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in Z. More...
class	AnalyzingAlgorithmValuePT< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in pT. More...
class	AnalyzingAlgorithmValueP< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in |p|. More...
class	AnalyzingAlgorithmValuePTheta< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in theta (in degrees) More...
class	AnalyzingAlgorithmValuePPhi< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the momentum in phi (in degrees) More...
class	AnalyzingAlgorithmValueDistSeed2IP< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the the distance seedHit to IP in 3D. More...
class	AnalyzingAlgorithmValueDistSeed2IPXY< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the distance seedHit to IP in XY (=r) More...
class	AnalyzingAlgorithmValueDistSeed2IPZ< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the distance seedHit to IP in XY (=r) More...
class	AnalyzingAlgorithmValueQI< DataType, TCInfoType, VectorType >
	Class for storing an algorithm determining the quality indicator of the TC. More...
class	AlgoritmType
	Small class for classifying types of analyzing algorithms. More...
class	AnalizerTCInfo
	simple class storing infos relevant for a TC for analyzing it. More...
class	KeyValBox< KeyType, ValueType >
	Minimal container storing a pair of < KeyType, ValueType> More...
class	RootParameterTracker
	Production notes for RootParameterTracker: More...
class	TCType
	Small class for classifying types of reconstructed track candidates. More...
class	VXDTFFilters< point_t >
	Class that contains all the static sectors to which the filters are attached. More...
class	ClosedLowerBoundedSet< MinType >
	Represents a closed lower bounded set of arithmetic types. More...
class	ClosedRange< MinType, MaxType >
	Represents a closed set of arithmetic types. More...
class	ClosedUpperBoundedSet< MaxType >
	Represents an upper bounded set of arithmetic types. More...
class	Filter< typePack >
	This class is used to select pairs, triplets... of objects. More...
struct	all_same< types >
	The all_same struct is meant to check that all the types in a template pack are of the same type. More...
struct	all_same< T >
	The all_same struct is meant to check that all the types in a template pack are of the same type. More...
struct	all_same< >
	The all_same struct is meant to check that all the types in a template pack are of the same type. More...
struct	all_same< T, T, types ... >
	The all_same struct is meant to check that all the types in a template pack are of the same type. More...
class	Filter< Variable, RangeType, Observer >
	Basic Filter ///. More...
class	Filter< Variable, RangeType, Belle2::BypassableFilter, Observer >
	Bypassable Filter ///. More...
class	Filter< Variable, RangeType, Belle2::ActivatableFilter, Observer >
	Activatable Filter /// TODO: Remove, as it is no longer used...? More...
class	Filter< Belle2::OperatorNot, someFilter, templateObserverType >
	Realization of a NOT operator for the Filter classes. More...
class	Filter< Belle2::OperatorAnd, FilterA, FilterB, templateObserverType >
	Realization of the AND operator between two objects of the Filter class. More...
class	Filter< Belle2::OperatorOr, FilterA, FilterB, templateObserverType >
	Realization of the OR operator between two objects of the Filter class. More...
class	LowerBoundedSet< InfType >
	Represents a lower bounded set of arithmetic types. More...
class	Observer
	Observer base class which can be used to evaluate the VXDTF2's Filters. More...
class	Range< InfType, SupType >
	Represents a range of arithmetic types. More...
class	SelectionVariable< templateArgumentType, Nargs, templateReturnType >
	Base class of the selection variable objects used for pair filtering. More...
class	SingleElementSet< Type >
	Represents a set containing a single element;. More...
class	UpperBoundedSet< SupType >
	Represents an upper bounded set of arithmetic types. More...
class	VoidObserver
	The most CPU efficient Observer for the VXDTF filter tools (even if useless). More...
class	DELTACIRCLERADIUS_NAME< PointType >
	calculates delta-circleRadius-value (difference in circle radii of 2 subsets of the hits), returning unit: cm. More...
class	DELTADISTCIRCLECENTER_NAME< PointType >
	calculates the distance between the estimated circle centers (using 2 subsets of given hits) in the xy-plane, returning unit: cm. More...
class	DELTAPT_NAME< PointType >
	calculates dpt-value (dpt= difference in transverse momentum of 2 subsets of the hits), returning unit: GeV/c. More...
class	CompactSecIDs
	This class provides a computer convenient numbering scheme for the sectors in the sector map and for the N sectors combinations. More...
class	FiltersContainer< point_t >
	This class contains everything needed by the VXDTF that is not going to change during a RUN, i.e. More...
class	SectorsOnSensor< sectorID >
	This class associates to an ordered pairs of normalized local coordinates a compact sector id. More...
class	ANGLE3DFULL_NAME< PointType >
	calculates the angle between the hits/vectors (3D), returning unit: angle in degrees. More...
class	ANGLE3DSIMPLE_NAME< PointType >
	calculates the angle between the hits/vectors (3D), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use Angle3DFull instead). More...
class	ANGLERZFULL_NAME< PointType >
	calculates the angle between the hits/vectors (RZ), returning unit: angle in degrees. More...
class	ANGLERZSIMPLE_NAME< PointType >
	calculates the angle between the hits/vectors (RZ), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use AngleRZFull instead). More...
class	ANGLEXYFULL_NAME< PointType >
	calculates the angle between the hits/vectors (XY), returning unit: angle in degrees. More...
class	CIRCLECENTERXY_NAME< PointType >
	calculates the center of the circle for 3 hits in the XY plane and returns a B2Vector3 with the result (z=0). More...
class	CIRCLEDIST2IP_NAME< PointType >
	calculates the distance of the point of closest approach of circle to the IP, returning unit: cm More...
class	CIRCLERADIUS_NAME< PointType >
	calculates the estimation of the circle radius of the 3-hit-tracklet, returning unit: cm. More...
class	COSANGLEXY_NAME< PointType >
	calculates the angle between the hits/vectors (XY), returning unit: none (calculation for degrees is incomplete, if you want readable numbers, use AngleXYFull instead): More...
class	DELTASLOPERZ_NAME< PointType >
	calculates deviations in the slope of the inner segment and the outer segment, returning unit: none More...
class	DELTASLOPEZOVERS_NAME< PointType >
	compares the "slopes" z over arc length. More...
class	DELTASOVERZ_NAME< PointType >
	calculates the helixparameter describing the deviation in arc length per unit in z. More...
class	DISTANCEINTIME< PointType >
	This variable returns the difference among the V and U side clusters of th ecenter space point. More...
class	HELIXPARAMETERFIT_NAME< PointType >
	calculates the helixparameter describing the deviation in z per unit angle, returning unit: none. More...
class	MLHANDOVER_NAME< PointType, Ndims >
	SelectionVariable that is used for the Machine Learning (ML) based filters. More...
class	PT_NAME< PointType >
	calculates the estimation of the transverse momentum of the 3-hit-tracklet, returning unit: GeV/c. More...
class	SIGNCURVATUREXY_NAME< PointType >
	calculates the sign of the curvature for three hits More...
class	SIGNCURVATUREXYERROR_NAME< PointType >
	calculates the sign of the curvature for three hits More...
class	ZIGGZAGGRZ_NAME< PointType, PointContainerType >
	checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the R-Z-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging). More...
class	ZIGGZAGGXY_NAME< PointType, PointContainerType >
	checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the X-Y-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging). More...
class	ZIGGZAGGXYWITHSIGMA_NAME< PointType, PointContainerType >
	checks whether chain of segments are zigg-zagging (changing sign of curvature of neighbouring segments) in the X-Y-plane, returns number of charge-signs found (if != 1, then the given hitContainer is ziggZagging). More...
class	VariablesTTree< filterLeaves >
	Dump on a TTree the values of all the variables in a filter. More...
class	VariablesTTree<>
	Defines the interface using an empty template pack. More...
class	VariablesTTree< Filter< Variable, other ... > >
	Specialization for a simple filter. More...
class	VariablesTTree< Filter< unaryOperator, Filter< args ... >, other ... > >
	Specialization for unary operators acting on a filter. More...
class	VariablesTTree< Filter< binaryOperator, Filter< argsA ... >, Filter< argsB ... >, other ... > >
	Specialization for binary operators acting on a filter. More...
class	VariableTBranch< Variable >
	This class contains. More...
class	COSDIRECTIONXY_NAME< PointType >
	This is a specialization returning floats, where value calculates the cos of the angle of the segment of two hits in the XY plane. More...
class	DISTANCE1DZ_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the distance between two hits in 1D on the Z-axis. More...
class	DISTANCE1DZSQUARED_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 1D on the Z-axis. More...
class	DISTANCE2DXYSQUARED_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 2D on the X-Y-plane. More...
class	DISTANCE3DNORMED_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the normed distance between two hits in 3D. More...
class	DISTANCE3DSQUARED_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the squared distance between two hits in 3D. More...
class	DISTANCEINTIME_U_NAME< PointType >
	This variable returns the time difference among the U side clusters of the two space points. More...
class	DISTANCEINTIME_V_NAME< PointType >
	This variable returns the time difference among the V side clusters of the two space points. More...
class	SLOPERZ_NAME< PointType >
	This is the specialization for SpacePoints with returning floats, where value calculates the slope in R-Z for a given pair of hits. More...
class	DecorrelationMatrix< Ndims >
	Class holding a Matrix that can be used to decorrelate input data to Machine Learning classifiers. More...
class	FBDTClassifier< Ndims >
	FastBDT as RelationsObject to make it storable and accessible on/via the DataStore. More...
struct	FBDTTrainSample< Ndims >
	bundle together the classifier input and the target value into one struct for easier passing around. More...
class	MLRange< ClassifierType, Ndims, CutType >
	Range used for the Machine Learning assisted TrackFinding approach. More...
class	Observer3HitPrintResults
	this observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning(if failed) or as an Info (if succeeded) More...
class	ObserverCheckFilters
	this observer searches logs the response for each of SelectionVariables used in the filters If the pointer to the StoreArray is set the results will be put into the datastore More...
class	ObserverCheckMCPurity
	this observer searches for mcParticles attached to the hits given and stores the information found to be retrieved later. More...
class	ObserverPrintResults
	this observer does simply print the name of the SelectionVariable and the result of its value-function as a Warning(if failed) or as an Info (if succeeded) More...
class	SelectionVariableFactory< PointType >
	The factory,as the name implies, does not implement at all the factory paradigm. More...
struct	SelVarHelper< PointType, DataType >
	contains a collection of functions and related stuff needed for SelectionVariables implementing 2-, 3- and 4-hitfilters. More...
class	MVAExpert
	Class to interact with the MVA package, based on class with same name in CDC package. More...
class	ActivatedSector
	ActivatedSector is carrying the dynamic part of a Sector. More...
struct	BranchInterface< ValueType >
	simple struct for interfacing the Branch. More...
class	FilterMill< PointType >
	Small class which stores the filters/selectionVariables to be used for a secMap and has an interface for applying them. More...
class	SecIDPair
	allows to set outer and inner secID. More...
class	SecIDTriplet
	allows to set outer, center and inner secID. More...
class	SecIDQuadruplet
	allows to set outer, outerCenter, innerCenter and inner secID. More...
class	FilterValueDataSet< SecIDSetType >
	contains the relevant information needed for filling a TTree containing train-data for the secMap. More...
class	MinMax
	small class for storing min and max. More...
class	MinMaxCollector< DataType >
	A container for collecting data, where min- and max-quantiles near q(0) and q(1) are to be found. More...
class	NoKickCuts
	This class is an auxiliary class that implement methods to access to a single cut, used in NoKickRTSel class. More...
class	NoKickRTSel
	This class implement some methods useful for the application of cuts evaluated in NoKickCutsEval module. More...
class	RawDataCollectedMinMax
	takes care of collecting raw data and staying below RAM-threshold. More...
class	RawSecMapRootInterface
	To be used as an interface to root-stuff. More...
class	SecMapTrainer< FilterFactoryType >
	This class contains all relevant tools for training a VXDTFFilters. More...
class	SecMapTrainerHit
	simple Hit class used for sectorMap-training. More...
class	SecMapTrainerTC
	simple Hit class used for sectorMap-training. More...
class	Sector
	Sector is a central part of storing information for VXD trackFinders. More...
class	SectorFriendship
	SectorFriendship is carrying the link between parent sector and a connected sector (socalled Friendsector). More...
class	SectorGraph< FilterType >
	contains all subgraphs. More...
class	SectorMapComparer
	A root tool that compares two Sectormaps (local root files) and produces some statistics output. More...
class	SubGraph< FilterType >
	contains all relevant stuff needed for dealing with a subGraph. More...
class	SubGraphID
	stores the ID of a subgraph, which is basically a chain of FullSecID coded as unsigned ints. More...
class	ActiveSector< StaticSectorType, HitType >
	The ActiveSector Class. More...
class	CACell
	The CACell class This Class stores all relevant information one wants to have stored in a cell for a Cellular automaton. More...
class	DirectedNode< EntryType, MetaInfoType >
	The Node-Class. More...
class	DirectedNodeNetwork< EntryType, MetaInfoType >
	Network of directed nodes of the type EntryType. More...
class	DirectedNodeNetworkContainer
	The Container stores the output produced by the SegmentNetworkProducerModule. More...
class	Segment< HitType >
	The Segment class This class represents segments of track candidates needed for TrackFinderVXD-Modules. More...
class	StaticSector< HitType, Filter2sp, Filter3sp, Filter4sp >
	class to describe a static sector of the sector map. More...
struct	TrackNode
	Minimal class to store combination of sector and spacePoint, since SpacePoint can not carry sectorConnection. More...
class	VoidMetaInfo
	The most CPU efficient MetaInfo for the DirectedNode-requirements (even if useless). More...
struct	SpacePointTrackCandCreator< SPTCContainerType >
	small class to take simple vectors of SpacePoints and convert them to real SpacePointTrackCands More...
struct	QualityEstimationResults
	Container for complete fit/estimation results. More...
class	QualityEstimatorBase
	BaseClass for QualityEstimators. More...
class	QualityEstimatorCircleFit
	Class containing the algorithm to perform the simple circle fit. More...
class	QualityEstimatorLineFit3D
	Testbeam: Coords: Sensors: ^ . More...
class	QualityEstimatorMC
	Class implementing the algorithm used for the MC based quality estimation. More...
class	QualityEstimatorRandom
	Class implementing a random quality estimation. More...
class	QualityEstimatorRiemannHelixFit
	Based on R. More...
class	QualityEstimatorTripletFit
	does a tripletFit of the given hits The filter is based on the paper 'A New Three-Dimensional Track Fit with Multiple Scattering' by Andre Schoening et al. More...
class	AlwaysYesFilter
	AlwaysYesFilter is a simple filter saying always yes, which is meant for testing purposes. More...
class	FilterBase
	FilterBase is the baseClass for filters applied on (chains of) spacepoints. More...
class	HopfieldNetwork
	Hopfield Algorithm with number based inputs. More...
class	OverlapMatrixCreator
	Creates a vector of vectors, that knows which track is conflicting with which other. More...
class	OverlapNetwork
	Hold information about overlap of SpacePointTrackCand. More...
struct	OverlapResolverNodeInfo
	Struct for holding information needed by overlap resolving algorithms for one node. More...
class	Scrooge
	Executes greedy algorithm for vector of QITrackOverlap structs. More...
class	Named< T >
	A mixin class to attach a name to an object. Based on class with same name in CDC package. More...
class	ClusterInfoExtractor
	class to extract info from individual clusters and combine for SPTC More...
class	QEResultsExtractor
	class to extract results from qualityEstimation More...
class	SimpleVariableRecorder
	Class to write collected variables into a root file, Used by VXDQETrainingDataCollectorModule. More...
class	VariableExtractor
	class to extract individual variables More...
class	TrackFitter
	Algorithm class to handle the fitting of RecoTrack objects. More...
class	MeasurementAdder
	Algorithm class to translate the added detector hits (e.g. More...
class	BaseMeasurementCreator
	Base class for all measurement creators. More...
class	BaseMeasurementCreatorFromCoordinateMeasurement< HitType, detector >
	Baseclass to create measurement track points based on the coordinate measurements. More...
class	BaseMeasurementCreatorFromHit< HitType, detector >
	Base Class to create measurements based on a given hit related to the RecoTrack. More...
class	CoordinateMeasurementCreator< HitType, detector >
	A measurement creator for normal coordinate measurements out of cdc/svd/pxd hits. More...
class	VXDMomentumEstimationMeasurementCreator< HitType, detector >
	Creator for VXDMeasurements with momentum estimation based on the dEdX information. More...
class	AdditionalMeasurementCreatorFactory
	Add measurement creators that do not rely on a specific hit type, but rather add measurements without corresponding hit. More...
class	BKLMMeasurementCreatorFactory
	Add all measurement creators related to BKLM hits. More...
class	CDCMeasurementCreatorFactory
	Add all measurement creators related to CDC hits. More...
class	EKLMMeasurementCreatorFactory
	Add all measurement creators related to EKLM hits. More...
class	MeasurementCreatorFactory< BaseMeasurementCreatorType >
	This is the base class for all MeasurementCreatorFactories used in the MeasurementCreatorModule. More...
class	PXDMeasurementCreatorFactory
	Add all measurement creators related to PXD hits. More...
class	SVDMeasurementCreatorFactory
	Add all measurement creators related to SVD hits. More...
class	HMatrixQP
	AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization. More...
class	PlanarMomentumMeasurement
	Measurement class implementing a planar hit geometry (1 or 2D) with only a momentum measurement. More...
class	PlanarVXDMomentumMeasurement< HitType >
	Measurement class implementing a planar hit geometry (1 or 2D) with a momentum measurement based on the VXD dEdX information with setable parameters (see VXDMomentumEstimationMeasurementCreator). More...
class	TrackBuilder
	TrackBuilder class to create the Track/TrackFitResult mdst output from the RecoTrack. More...
class	EventInfoExtractor
	class to extract results from qualityEstimation More...
class	HitInfoExtractor
	class to extract info from individual clusters and combine for SPTC More...
class	RecoTrackExtractor
	class to extract results from qualityEstimation More...
class	SubRecoTrackExtractor
	class to extract results from qualityEstimation More...
class	NewV0Fitter
	Improved V0 fitter class. More...
class	V0Fitter
	V0Fitter class to create V0 mdst's from reconstructed tracks. More...
class	ExporterEventInfo
	Bundles information for a single event to be stored by NonRootDataExportModule. More...
class	ExporterHitInfo
	Bundles information for a single hit to be stored by EventInfo (needed for HitExporter, which is needed by NonRootDataExportModule) More...
class	ExporterTcInfo
	Bundles information for a single track candidate to be stored by EventInfo (needed for HitExporter, which is needed by NonRootDataExportModule) More...
class	FilterExceptions
	Exception which are thrown by members of the FilterClasses. More...
class	FourHitFilters
	The class 'FourHitFilters' bundles filter methods using 4 hits which are stored in B2Vector3Ds. More...
class	GlobalNames
	Bundles filter methods using 2 hits. More...
class	ThreeHitFilters
	The class 'ThreeHitFilters' bundles filter methods using 3 hits which are stored in B2Vector3Ds. More...
class	TwoHitFilters
	The class 'TwoHitFilters' bundles filter methods using 2 hits which are stored in B2Vector3Ds. More...
class	XHitFilterFactory< PointType >
	The factory serves as an interface between all x-hit-filters and a user only knowing their name (in string), but not their type. More...
class	VXDMomentumEstimation< ClusterType >
	Class doing the momentum estimation from dEdX for SVDClusters and PXDClusters. More...
class	VXDMomentumEstimationTools< ClusterType >
	Tools needed for the VXD momentum estimation to, e.g. More...

Macros
#define	SELECTION_VARIABLE(variableName, nArgs, argumentType, implementation)
	Template to define a selection-variable class.

Typedefs
using	CDCCKFPath = std::vector<CDCCKFState>
	Shortcut for the collection of CDC CKF-algorithm states.
using	CDCCKFResult = CDCCKFPath
	Alias for the collection of CDC CKF-algorithm states.
using	BaseCDCPathPairFilter = TrackFindingCDC::Filter<std::pair<const CDCCKFPath*, const CDCCKFPath*>>
	Base filter for CKF CDC paths.
using	BaseCDCPathFilter = TrackFindingCDC::Filter<CDCCKFPath>
	Base filter for CKF CDC paths.
using	BaseCDCStateFilter
	Base filter for CKF CDC states.
using	BasePXDPairFilter = TrackFindingCDC::Filter<std::pair<const CKFToPXDState*, const CKFToPXDState*>>
	Base filter for CKF PXD states.
using	ChooseablePXDRelationFilter = LayerPXDRelationFilter<TrackFindingCDC::ChooseableFilter<PXDPairFilterFactory>>
	A chooseable filter for picking out the relations between states.
using	BasePXDResultFilter = TrackFindingCDC::Filter<CKFToPXDResult>
	Base filter for CKF PXD results (on overlap check)
using	ChooseablePXDResultFilter = TrackFindingCDC::ChooseableFilter<PXDResultFilterFactory>
	Alias for filter to weight the PXD clusters.
using	BasePXDStateFilter
	Base filter for CKF PXD states.
using	ChooseableOnPXDStateApplier
	Alias to apply the () operator to all items filtered by CKF PXD layer states.
using	NonIPCrossingPXDStateFilter = NonIPCrossingStateFilter<AllPXDStateFilter>
	Alias for filter to check direction of a new CKF PXD state.
using	PXDStateRejecter = StateRejecter<CKFToPXDState, ChooseableOnPXDStateApplier>
	Rejecter findlet for CKF PXD states.
using	PXDAdvancer = Advancer
	The PXD advancer is just a synonym of the normal advancer (but may change in the future).
using	BaseSVDPairFilter = TrackFindingCDC::Filter<std::pair<const CKFToSVDState*, const CKFToSVDState*>>
	Base filter for CKF SVD states.
using	ChooseableSVDRelationFilter = LayerSVDRelationFilter<TrackFindingCDC::ChooseableFilter<SVDPairFilterFactory>>
	A chooseable filter for picking out the relations between states.
using	BaseSVDResultFilter = TrackFindingCDC::Filter<CKFToSVDResult>
	Base filter for CKF SVD results (on overlap check)
using	ChooseableSVDResultFilter = TrackFindingCDC::ChooseableFilter<SVDResultFilterFactory>
	Alias for filter to weight the SVD clusters.
using	BaseSVDStateFilter
	Base filter for CKF SVD states.
using	ChooseableOnSVDStateApplier
	Alias to apply the () operator to all items filtered by CKF SVD layer states.
using	NonIPCrossingSVDStateFilter = NonIPCrossingStateFilter<AllSVDStateFilter>
	Alias for filter to check direction of a new CKF SVD state.
using	SVDStateRejecter = StateRejecter<CKFToSVDState, ChooseableOnSVDStateApplier>
	Rejecter findlet for CKF SVD states.
using	SVDAdvancer = Advancer
	The PXD advancer is just a synonym of the normal advancer (but may change in the future).
template<class AFindlet>
using	EventTimeExtractorModule
	Alias for the event time extraction module.
using	CDCBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedCDCHit, Const::CDC>
	Needed for templating.
using	SVDBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedSVDHit, Const::SVD>
	Standard base class for SVD measurement creators.
using	PXDBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedPXDHit, Const::PXD>
	Standard base class for PXD measurement creators.
using	BKLMBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedBKLMHit, Const::BKLM>
	Standard base class for BKLM measurement creators.
using	EKLMBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedEKLMHit, Const::EKLM>
	Standard base class for EKLM measurement creators.
using	CDCCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedCDCHit, Const::CDC>
	Needed for templating.
using	SVDCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedSVDHit, Const::SVD>
	Hit to reco hit measurement creator for the SVD.
using	PXDCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedPXDHit, Const::PXD>
	Hit to reco hit measurement creator for the PXD.
using	BKLMCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedBKLMHit, Const::BKLM>
	Hit to reco hit measurement creator for the BKLM.
using	EKLMCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedEKLMHit, Const::EKLM>
	Hit to reco hit measurement creator for the EKLM.
using	SVDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedSVDHit, Const::SVD>
	Momentum measurement creator for the SVD.
using	PXDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedPXDHit, Const::PXD>
	Momentum measurement creator for the PXD.

Enumerations
enum	VolTypes {   VOLTYPE_CDC ,   VOLTYPE_TOP1 ,   VOLTYPE_TOP2 ,   VOLTYPE_TOP3 ,   VOLTYPE_ARICH1 ,   VOLTYPE_ARICH2 ,   VOLTYPE_ARICH3 ,   VOLTYPE_ECL ,   VOLTYPE_BKLM1 ,   VOLTYPE_BKLM2 ,   VOLTYPE_EKLM }
	Enumeration for G4VPhysicalVolume sensitive-volume categories. More...

Functions
std::ostream &	operator<< (std::ostream &output, const CDCCKFPath &path)
	Output operator for the collection of CDC CKF-algorithm states.
std::ostream &	operator<< (std::ostream &output, const CDCCKFState &state)
	print state info
std::string	getClassMnemomicParameterName (const RecoTrack *dispatchTag)
	Returns a short name for class RecoTrack to be used in names of parameters.
std::string	getClassMnemomicParameterDescription (const RecoTrack *dispatchTag)
	Returns a short description for class RecoTrack to be used in descriptions of parameters.
std::string	getClassMnemomicParameterName (const SpacePoint *dispatchTag)
	Returns a short name for class SpacePoint to be used in names of parameters.
std::string	getClassMnemomicParameterDescription (const SpacePoint *dispatchTag)
	Returns a short description for class SpacePoint to be used in descriptions of parameters.
template<unsigned int NRows, unsigned int NCols, class AMatrix>
Eigen::Matrix< double, NRows, NCols, Eigen::RowMajor >	convertToEigen (const AMatrix &matrix)
	Convert a ROOT matrix to Eigen. Checks for the correct row and column number.
template<unsigned int NRows>
Eigen::Matrix< double, NRows, 1 >	convertToEigen (const TVectorD &matrix)
	Convert a ROOT matrix to Eigen - TVector specialisation. Checks for the correct row number.
template<class T>
void	checkResizeClear (std::vector< T > &vectorToCheck, uint limit)
	Check capacity of a vector and create a fresh one if capacity too large If the capacity of a std::vector is very large without being used, it just allocates RAM for no reason, increasing the RAM usage unnecessarily.
constexpr bool	arcLengthInRightDirection (double arcLength2D, TrackFindingCDC::EForwardBackward forwardBackward)
	Given the calculated arc length between a start point and an end point, checks if the travelled path is along the given direction or not.
TrackFindingCDC::EForwardBackward	fromString (const std::string &directionString)
	Helper function to turn a direction string into a valid forward backward information.
long	convertFloatToInt (double value, int power)
	Convert float or double to long int for more similarity to the FPGA implementation.
template<typename MapType>
std::vector< typename MapType::key_type >	getUniqueKeys (const MapType &aMap)
	get the unique keys of a map (i.e.
template<typename MapType>
unsigned int	getUniqueSize (const MapType &aMap)
	get the number of unique keys inside the map NOTE: for non-multimap this is the same as .size()
template<typename MapType>
std::vector< std::pair< typename MapType::key_type, unsigned int > >	getNValuesPerKey (const MapType &aMap)
	get the unique keys of a map together with the number of values associated to each key.
template<typename MapType>
std::vector< typename MapType::mapped_type >	getValuesToKey (const MapType &aMap, typename MapType::key_type aKey)
	get all values stored in the map for a given key
template<typename MapType>
std::vector< std::tuple< typename MapType::key_type, typename MapType::mapped_type, unsigned int > >	getSortedKeyValueTuples (const MapType &aMap)
	get the (key, value, number of values) tuples stored in the map, sorted after the following scheme (descending order) 1) the number of associated values to one key 2) the sum of the associated values to that key NOTE: for a non-multimap this returns the content of the map ordered by valued CAUTION: if one of the values to a key is NaN this key will be the first (of the ones with the same number of associated values)
template<typename MapType>
std::vector< typename MapType::mapped_type >	getAllValues (const MapType &aMap)
	get all values in the map (i.e.
template<typename MapType>
std::string	printMap (const MapType &aMap)
	get the contents of the map as string.
static bool	findWeightInVector (std::vector< std::pair< int, double > > &vec, double weight)
	find the given weight in the given vector of pair<int,double> NOTE: the criteria for finding are rather loose (i.e.
template<typename TrueHitType>
static std::vector< std::pair< int, double > >	getMCParticles (const Belle2::SpacePoint *spacePoint)
	get the related MCParticles to the TrueHit.
static void	increaseClusterCounters (const Belle2::SpacePoint *spacePoint, std::array< unsigned, 3 > &clusterCtr)
	increase the appropriate Cluster counter by asking the SpacePoint which type he has and which Clusters are assigned
static std::vector< size_t >	getAccessorsFromWeight (double weight)
	convert the relation weight (SpacePoint <-> TrueHit) to a type that can be used to access arrays
static std::vector< Belle2::MCVXDPurityInfo >	createPurityInfosVec (const std::vector< const Belle2::SpacePoint * > &spacePoints)
	create a vector of MCVXDPurityInfos objects for a std::vector<Belle2::SpacePoints>.
template<typename SPContainer>
static std::vector< Belle2::MCVXDPurityInfo >	createPurityInfos (const SPContainer *container)
	create a vector of MCVXDPurityInfos objects for any given container holding SpacePoints and providing a getHits() method each MCParticle that is in the container gets its own object NOTE: negative MCParticleIds are possible und used as follows:
template<typename SPContainer>
static std::vector< Belle2::MCVXDPurityInfo >	createPurityInfos (const SPContainer &container)
template<class NetworkPath>
SpacePointTrackCand	convertNetworkPath (NetworkPath networkPath)
	Create new SPTC from network path.
void	insertSpacePoint (std::vector< const SpacePoint * > &target, TrackNode source)
	Convert TrackNode to SpaePoint an add to a SpacePoint path.
void	insertSpacePoints (std::vector< const SpacePoint * > &target, const Segment< TrackNode > &source)
	Insert of inner and outer TrackNodes of a Segment as SpacePoints into path of SpacePoints.
template<class DataType, class TCInfoType, class VectorType>
bool	operator== (const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > &a, const std::string &b)
	non-memberfunction Comparison for equality with a std::string
template<class DataType, class TCInfoType, class VectorType>
bool	operator== (const std::string &a, const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > &b)
	non-memberfunction Comparison for equality with a std::string
template<class DataType, class TCInfoType, class VectorType>
bool	operator== (const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > &a, const AlgoritmType::Type &b)
	non-memberfunction Comparison for equality with a AlgoritmType::Type
template<class DataType, class TCInfoType, class VectorType>
bool	operator== (const AlgoritmType::Type &a, const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > &b)
	non-memberfunction Comparison for equality with a AlgoritmType::Type
template<class DataType, class TCInfoType, class VectorType>
AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > *	AnalyzingAlgorithmFactoryDouble (AlgoritmType::Type algorithmID)
	the analyzingAlgorithm factory for algorithms returning one double for each TC passed:
template<class DataType, class TCInfoType, class VectorType>
AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > *	AnalyzingAlgorithmFactoryInt (AlgoritmType::Type algorithmID)
	the analyzingAlgorithm factory for algorithms returning one int for each TC passed:
template<class DataType, class TCInfoType, class VectorType>
AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > *	AnalyzingAlgorithmFactoryVecDouble (AlgoritmType::Type algorithmID)
	the analyzingAlgorithm factory for algorithms returning one vector< double> for each TC passed:
template<typename ... types>
Filter< OperatorNot, Filter< types... >, VoidObserver >	operator! (const Filter< types... > &filter)
	Definition of the NOT operator !
template<typename ... types1, typename ... types2>
Filter< Belle2::OperatorAnd, Belle2::Filter< types1... >, Belle2::Filter< types2... >, Belle2::VoidObserver >	operator&& (const Filter< types1... > &filter1, const Filter< types2... > &filter2)
	Definition of the boolean AND operator && of the Filter class.
template<typename ... types1, typename ... types2>
Filter< Belle2::OperatorOr, Belle2::Filter< types1... >, Belle2::Filter< types2... >, Belle2::VoidObserver >	operator|| (const Filter< types1... > &filter1, const Filter< types2... > &filter2)
	Definition of the boolean OR operator || of the Filter class.
template<class booleanBinaryOperator, typename ... types1, typename ... types2, class observer, typename ... argsTypes>
bool	initializeObservers (const Filter< booleanBinaryOperator, Belle2::Filter< types1... >, Belle2::Filter< types2... >, observer > &, argsTypes ... args)
	Observer Stuff ///.
template<class booleanUnaryOperator, typename ... types1, class observer, typename ... argsTypes>
bool	initializeObservers (const Filter< booleanUnaryOperator, Belle2::Filter< types1... >, observer > &, argsTypes ... args)
	Recursive function to initialize all the observers in a unary boolean Filter.
template<class Variable, class RangeType, class observer, typename ... argsTypes>
bool	initializeObservers (const Belle2::Filter< Variable, RangeType, observer > &filter, argsTypes ... args)
	Initialize the observer of a RangeType Filter.
template<class Variable, class Range, class ... Options>
std::unordered_map< std::string, typename Variable::functionType >	SelectionVariableNamesToFunctions (Belle2::Filter< Variable, Range, Options... >)
	Return a map from the SelectionVariable name to the SelectionVariable function of the Variable used in the filter that is the template argument parameter.
template<class someFilter, class ... options>
std::unordered_map< std::string, typename someFilter::functionType >	SelectionVariableNamesToFunctions (Belle2::Filter< Belle2::OperatorNot, someFilter, options... >)
	Wrapper for filters with NOT Operator tag.
template<class FilterA, class FilterB, class ... options>
std::unordered_map< std::string, typename FilterA::functionType >	SelectionVariableNamesToFunctions (Belle2::Filter< Belle2::OperatorAnd, FilterA, FilterB, options... >)
	Wrapper for filters with AND Operator tag.
template<class FilterA, class FilterB, class ... options>
std::unordered_map< std::string, typename FilterA::functionType >	SelectionVariableNamesToFunctions (Belle2::Filter< Belle2::OperatorOr, FilterA, FilterB, options... >)
	Wrapper for filters with OR Operator tag.
template<class Var, class Arithmetic, typename ... types>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, UpperBoundedSet< Arithmetic >, VoidObserver > >::type	operator< (const Var &, Arithmetic upperBound)
	Creates a Filters with an upper bound < on the provided variable Var < lowerBound.
template<class Var, class Arithmetic, typename ... types>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedUpperBoundedSet< Arithmetic >, VoidObserver > >::type	operator<= (const Var &, Arithmetic upperBound)
	Creates a Filters with a closed upper bound <= on the provided variable Var <= lowerBound.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, LowerBoundedSet< Arithmetic >, VoidObserver > >::type	operator> (const Var &, Arithmetic lowerBound)
	Creates a Filters with an lower bound > on the provided variable Var > lowerBound.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedLowerBoundedSet< Arithmetic >, VoidObserver > >::type	operator>= (const Var &, Arithmetic lowerBound)
	Creates a Filters with a closed lower bound >= on the provided variable Var >= lowerBound.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, UpperBoundedSet< Arithmetic >, VoidObserver > >::type	operator> (Arithmetic upperBound, const Var &)
	Creates a Filters with an upper bound < on the provided variable upperBound > Var.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedUpperBoundedSet< Arithmetic >, VoidObserver > >::type	operator>= (Arithmetic upperBound, const Var &)
	Creates a Filters with a closed upper bound <= on the provided variable upperBound >= Var.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, LowerBoundedSet< Arithmetic >, VoidObserver > >::type	operator< (Arithmetic lowerBound, const Var &)
	Creates a Filters with an lower bound > on the provided variable lowerBound < Var.
template<class Var, class Arithmetic>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedLowerBoundedSet< Arithmetic >, VoidObserver > >::type	operator<= (Arithmetic lowerBound, const Var &)
	Creates a Filters with a closed lower bound >= on the provided variable lowerBound <= Var.
template<class Var, class Val>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value, Filter< Var, SingleElementSet< Val >, VoidObserver > >::type	operator== (const Var &, Val v)
	Creates a Filters to compare a variable against a given value Var == Val;.
template<class Var, class Val>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value, Filter< Var, SingleElementSet< Val >, VoidObserver > >::type	operator== (Val val, const Var &var)
	Creates a Filters to compare a variable against a given value Val == Var;.
template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, Range< ArithmeticLower, ArithmeticUpper >, Observer > >::type	operator< (const Filter< Var, LowerBoundedSet< ArithmeticLower >, Observer > &filter, ArithmeticUpper upperBound)
	Adding upper bound to filter with lower bound to create a filter with an allowed range between lower and upper bound.
template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, Range< ArithmeticLower, ArithmeticUpper >, Observer > >::type	operator> (const Filter< Var, UpperBoundedSet< ArithmeticUpper >, Observer > &filter, ArithmeticLower lowerBound)
	Adding lower bound to filter with upper bound to create a filter with an allowed range between lower and upper bound.
template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, ClosedRange< ArithmeticLower, ArithmeticUpper >, Observer > >::type	operator<= (const Filter< Var, ClosedLowerBoundedSet< ArithmeticLower >, Observer > &filter, ArithmeticUpper upperBound)
	Adding closed upper bound to filter with closed lower bound to create a filter with an allowed closed range between lower and upper bound.
template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>
std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, ClosedRange< ArithmeticLower, ArithmeticUpper >, Observer > >::type	operator>= (const Filter< Var, ClosedUpperBoundedSet< ArithmeticUpper >, Observer > &filter, ArithmeticLower lowerBound)
	Adding closed lower bound to filter with closed upper bound to create a filter with an allowed closed range between lower and upper bound.
char	TBranchLeafType (const char *)
	Overloading TBranchLeafType to be able to get identifier 'C' for type char*.
char	TBranchLeafType (const Char_t &)
	Overloading TBranchLeafType to be able to get identifier 'B' for type Char_t.
char	TBranchLeafType (const unsigned char &)
	Overloading TBranchLeafType to be able to get identifier 'b' for type unsigned char.
char	TBranchLeafType (const short &)
	Overloading TBranchLeafType to be able to get identifier 'S' for type short.
char	TBranchLeafType (const unsigned short &)
	Overloading TBranchLeafType to be able to get identifier 's' for type unsigned short.
char	TBranchLeafType (const Int_t &)
	Overloading TBranchLeafType to be able to get identifier 'I' for type Int_t.
char	TBranchLeafType (const UInt_t &)
	Overloading TBranchLeafType to be able to get identifier 'i' for type UInt_t.
char	TBranchLeafType (const Float_t &)
	Overloading TBranchLeafType to be able to get identifier 'F' for type Float_t.
char	TBranchLeafType (const Double_t &)
	Overloading TBranchLeafType to be able to get identifier 'D' for type Double_t.
char	TBranchLeafType (const long int &)
	Overloading TBranchLeafType to be able to get identifier 'L' for type long int.
char	TBranchLeafType (const unsigned long int &)
	Overloading TBranchLeafType to be able to get identifier 'l' for type unsigned long int.
char	TBranchLeafType (const bool &)
	Overloading TBranchLeafType to be able to get identifier 'O' for type bool.
template<size_t Ndims>
const Eigen::Matrix< double, Ndims, Ndims, Eigen::RowMajor >	calculateCovMatrix (std::array< std::vector< double >, Ndims > inputData)
	calculates the empirical covariance matrix from the inputData.
template<size_t Ndims>
static void	readSamplesFromStream (std::istream &is, std::vector< FBDTTrainSample< Ndims > > &samples)
	read samples from stream and append them to samples
template<size_t Ndims>
static void	writeSamplesToStream (std::ostream &os, const std::vector< FBDTTrainSample< Ndims > > &samples)
	write all samples to stream
template<class EntryType, class MetaInfoType>
bool	operator== (const EntryType &a, const DirectedNode< EntryType, MetaInfoType > &b)
	************************* NON-MEMBER FUNCTIONS *************************
short	calcCurvatureSignum (std::vector< SpacePoint const * > const &measurements)
	Calculate curvature based on triplets of measurements.
TrackFindingCDC::Weight	operator() (const Object &pair) final
	Main function testing the object for the direction.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the direction parameter.
void	initialize () final
	Copy the string direction parameter to the enum.
	~CKFRelationCreator ()
	Default destructor.
	CKFRelationCreator ()
	Construct this findlet and add the subfindlet as listener.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the subfindlet.
void	apply (std::vector< AState > &seedStates, std::vector< AState > &states, std::vector< TrackFindingCDC::WeightedRelation< AState > > &relations) override
	Apply both filters for creating state-hit and hit-hit relations.
	LayerToggledApplier ()
	Add the subfilters as listeners.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose parameters of the subfilters and the layer to change.
void	apply (const std::vector< TrackFindingCDC::WithWeight< const AState * > > &currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > &childStates) override
	The weight is calculated using the subfilter based on the geometrical layer of the state.
	LimitedOnStateApplier ()
	Constructor adding the findlet as a listener.
void	apply (const std::vector< TrackFindingCDC::WithWeight< const AState * > > &currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > &childStates) override
	Apply the filter to each pair of states and current path and let only pass the best N states.
TrackFindingCDC::Weight	operator() (const Object &object) override
	Copy the filter operator to this method.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the subfindlet.
void	apply (const std::vector< TrackFindingCDC::WithWeight< const AState * > > &currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > &childStates) override
	Apply the () operator to all pairs of state and current path.
virtual TrackFindingCDC::Weight	operator() (const Object &object)
	The filter operator for this class.
	OverlapResolver ()
	Construct this findlet and add the subfindlet as listener.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the subfindlet.
void	apply (std::vector< Object > &results, std::vector< Object > &filteredResult) override
	For each seed, search for the best candidate and return it.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the sub findlets.
void	initialize () override
	Create the store arrays.
void	apply (std::vector< AResult > &results) override
	Load in the reco tracks and the hits.
void	beginEvent () override
	Clear the used clusters.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the findlet.
void	apply (const std::vector< AResult > &results, const std::vector< const SpacePoint * > &spacePoints) override
	Mark all space points as used, that they share clusters if the given kind with the results.
void	apply (const std::vector< AnObject * > &objects, std::vector< AState > &states) override
	Add new states to the list of states using all given objects.
void	apply (const std::vector< RecoTrack * > &objects, std::vector< AState > &states) final
	Create states from the space points, including a reverse flag or not.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters.
	StateRejecter ()
	Construct this findlet and add the subfindlet as listener.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the subfindlet.
void	apply (const std::vector< TrackFindingCDC::WithWeight< const AState * > > &currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > &childStates) final
	Apply all five filters to the child states.
	TreeSearcher ()
	Construct this findlet and add the subfindlet as listener.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the subfindlet.
void	apply (const std::vector< AState > &seededStates, std::vector< AState > &hitStates, const std::vector< TrackFindingCDC::WeightedRelation< AState > > &relations, std::vector< AResult > &results) final
	Main function of this findlet: traverse a tree starting from a given seed states.
void	traverseTree (std::vector< TrackFindingCDC::WithWeight< const AState * > > &path, const std::vector< TrackFindingCDC::WeightedRelation< AState > > &relations, std::vector< AResult > &results)
	Implementation of the traverseTree function.
	LayerPXDRelationFilter ()
	Add the filter as listener.
	~LayerPXDRelationFilter ()
	Default destructor.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the filter.
void	initialize () override
	Receive and dispatch signal before the start of the event processing.
void	beginRun () override
	Receive and dispatch signal for the beginning of a new run.
std::vector< CKFToPXDState * >	getPossibleTos (CKFToPXDState *from, const std::vector< CKFToPXDState * > &states) const override
	Return all states the given state is possible related to.
TrackFindingCDC::Weight	operator() (const CKFToPXDState &from, const CKFToPXDState &to) override
	Give a final weight to the possibilities by asking the filter.
	LayerSVDRelationFilter ()
	Add the filter as listener.
void	beginRun () final
	Initialize the maximal ladder cache.
	~LayerSVDRelationFilter ()
	Default destructor.
std::vector< CKFToSVDState * >	getPossibleTos (CKFToSVDState *from, const std::vector< CKFToSVDState * > &states) const final
	Return all states the given state is possible related to.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the filter.
TrackFindingCDC::Weight	operator() (const CKFToSVDState &from, const CKFToSVDState &to) final
	Give a final weight to the possibilities by asking the filter.
void	beginRun () final
	Initialize the sector map.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters of the filter.
TrackFindingCDC::Weight	operator() (const std::pair< const CKFToSVDState *, const CKFToSVDState * > &relation) override
	Give a final weight to the possibilities by asking the filter.
bool	wasSuccessful () const
	Returns true if the last run t0 extraction was successful.
virtual void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose our parameters to the super module.
virtual void	initialize () override
	Initialize the event t0 store obj ptr.
virtual void	beginEvent () override
	Create the event t0 store obj ptr.
void	resetEventT0 () const
	Reset the t0 value to cached value if it exists or clear it otherwise.
	BaseEventTimeExtractorModuleFindlet ()
	Add the subfindlet as listener.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override final
	Expose our parameters to the super module.
void	apply (std::vector< RecoTrack * > &recoTracks) override final
	Apply the findlets.
	GridEventTimeExtractor ()
	Add the subfindlet as listener.
void	apply (std::vector< RecoTrack * > &recoTracks) override final
	Timing extraction for this findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override final
	Expose the parameters.
	IterativeEventTimeExtractor ()
	Add the subfindlet as listener.
void	apply (std::vector< RecoTrack * > &recoTracks) override final
	Timing extraction for this findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters.
	ROIToUnitTranslator (const ROIinfo *theROIinfo)
	Constructor.
	ROIToUnitTranslator (double sigmaSystU, double sigmaSystV, double numSigmaTotU, double numSigmaTotV, double maxWidthU, double maxWidthV)
	Second Constructor.
void	fillRoiIDList (StoreArray< aIntercept > *listOfIntercepts, StoreArray< ROIid > *ROIidList)
	Append the ROIid to the list listToBeFilled.
void	fillInterceptList (StoreArray< aIntercept > *listToBeFilled, const StoreArray< RecoTrack > &trackList, RelationArray *recoTrackToIntercepts)
	Fill the list of PXD intecepts corresponding to the list of track candidates.
void	appendIntercepts (StoreArray< aIntercept > *interceptList, std::list< ROIDetPlane > planeList, genfit::MeasuredStateOnPlane state, int recoTrackIndex, RelationArray *recoTrackToIntercepts)
	Append the Intercept infos related to the track theTrack to the listToBeFilled.
	VariableTBranch (TTree *tree)
	Add to the TTree.
void	calculateDecorrMatrix (std::array< std::vector< double >, Ndims > inputData, bool normalise=true)
	calculate the transformation matrix that when applied to the input data yields linearly uncorrelated data.
std::vector< double >	decorrelate (const std::vector< double > &inputVec) const
	"decorrelate" one measurement (i.e.
std::vector< double >	decorrelate (const std::array< double, Ndims > &inputs) const
	"decorrelate" one measurement (i.e.
std::array< std::vector< double >, Ndims >	decorrelate (const std::array< std::vector< double >, Ndims > &inputMat) const
	decorrelate M measurements (i.e.
std::string	print () const
	print the matrix to a string.
bool	readFromStream (std::istream &is)
	read from stream.
double	analyze (const std::array< double, Ndims > &hits) const
	calculate the output of the FastBDT.
virtual std::vector< genfit::MeasurementOnPlane * >	constructMeasurementsOnPlane (const genfit::StateOnPlane &state) const override
	Construct the measurement on the plane set in the parent element.
const TMatrixD &	getMatrix () const override
	Return the underlying matrix.
TVectorD	Hv (const TVectorD &v) const override
	Calculate H * v = v_0.
TMatrixD	MHt (const TMatrixDSym &M) const override
	Calculate M * H^T = first column of M.
TMatrixD	MHt (const TMatrixD &M) const override
	Calculate M * H^T = first column of M.
void	HMHt (TMatrixDSym &M) const override
	Calculate H * M * H^T = M_00.
virtual void	Print (const Option_t *="") const override
	Print a symbol for the matrix for debugging.

Variables
static constexpr char const *const	cdcfromEclPathTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	cdcPathBasicVarNames []
	Names of the variables to be generated.
static constexpr char const *const	cdcPathTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	cdcfromEclStateTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	cdcStateBasicVarNames []
	Names of the variables to be generated.
static constexpr char const *const	cdcStateTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	pxdResultTruthNames []
	Names of the variables to be generated.
static constexpr char const *const	pxdResultVarNames []
	Names of the variables to be generated.
static constexpr char const *const	pxdStateBasicVarNames []
	Names of the variables to be generated.
static constexpr char const *const	pxdStateTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	relationSVDResultVarNames []
	Names of the variables to be generated.
static constexpr char const *const	svdResultTruthNames []
	Names of the variables to be generated.
static constexpr char const *const	svdResultVarNames []
	Names of the variables to be generated.
static constexpr char const *const	svdStateBasicVarNames []
	Names of the variables to be generated.
static constexpr char const *const	svdStateTruthVarNames []
	Names of the variables to be generated.
static constexpr char const *const	svdStateVarNames []
	Names of the variables to be generated.
template<class DataType, class TCInfoType, class VectorType>
VectorType	AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::s_origin = VectorType(0, 0, 0)
	setting the static origin to a standard value
template<class DataType, class TCInfoType, class VectorType>
bool	AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::m_storeRefTCDataForTestTC = false
	setting the static storeRefTCDataForTestTC to a standard value
template<typename PointType, typename DataType>
DataType	SelVarHelper< PointType, DataType >::s_MagneticFieldFactor
	magnetic field factor

Detailed Description

Macro Definition Documentation

SELECTION_VARIABLE

#define SELECTION_VARIABLE	(		variableName,
			nArgs,
			argumentType,
			implementation )

Value:

  class variableName:             \
    public SelectionVariable< argumentType , nArgs, double >     \
  {                 \
  public:               \
    static const std::string name(void) {return #variableName; };   \
    implementation              \
  };                  \

Template to define a selection-variable class.

Definition at line 111 of file SelectionVariable.h.

#define SELECTION_VARIABLE( variableName, nArgs, argumentType, implementation ) \
  class variableName:             \
    public SelectionVariable< argumentType , nArgs, double >     \
  {                 \
  public:               \
    static const std::string name(void) {return #variableName; };   \
    implementation              \
  };                  \
 

Typedef Documentation

BaseCDCPathFilter

using BaseCDCPathFilter = TrackFindingCDC::Filter<CDCCKFPath>

Base filter for CKF CDC paths.

Definition at line 19 of file BaseCDCPathFilter.h.

BaseCDCPathPairFilter

using BaseCDCPathPairFilter = TrackFindingCDC::Filter<std::pair<const CDCCKFPath*, const CDCCKFPath*>>

Base filter for CKF CDC paths.

Definition at line 21 of file BaseCDCPathPairFilter.h.

BaseCDCStateFilter

using BaseCDCStateFilter

Initial value:

 
    TrackFindingCDC::Filter<std::pair<const CDCCKFPath*, CDCCKFState*>>

Base filter for CKF CDC states.

Definition at line 20 of file BaseCDCStateFilter.h.

BasePXDPairFilter

using BasePXDPairFilter = TrackFindingCDC::Filter<std::pair<const CKFToPXDState*, const CKFToPXDState*>>

Base filter for CKF PXD states.

Definition at line 19 of file BasePXDPairFilter.h.

BasePXDResultFilter

using BasePXDResultFilter = TrackFindingCDC::Filter<CKFToPXDResult>

Base filter for CKF PXD results (on overlap check)

Definition at line 19 of file BasePXDResultFilter.h.

BasePXDStateFilter

using BasePXDStateFilter

Initial value:

 
    TrackFindingCDC::Filter<std::pair<const std::vector<TrackFindingCDC::WithWeight<const CKFToPXDState*>>, CKFToPXDState*>>

Base filter for CKF PXD states.

Definition at line 20 of file BasePXDStateFilter.h.

BaseSVDPairFilter

using BaseSVDPairFilter = TrackFindingCDC::Filter<std::pair<const CKFToSVDState*, const CKFToSVDState*>>

Base filter for CKF SVD states.

Definition at line 19 of file BaseSVDPairFilter.h.

BaseSVDResultFilter

using BaseSVDResultFilter = TrackFindingCDC::Filter<CKFToSVDResult>

Base filter for CKF SVD results (on overlap check)

Definition at line 19 of file BaseSVDResultFilter.h.

BaseSVDStateFilter

using BaseSVDStateFilter

Initial value:

 
    TrackFindingCDC::Filter<std::pair<const std::vector<TrackFindingCDC::WithWeight<const CKFToSVDState*>>, CKFToSVDState*>>

Base filter for CKF SVD states.

Definition at line 21 of file BaseSVDStateFilter.h.

BKLMBaseMeasurementCreator

using BKLMBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedBKLMHit, Const::BKLM>

Standard base class for BKLM measurement creators.

Definition at line 89 of file BaseMeasurementCreatorFromHit.h.

BKLMCoordinateMeasurementCreator

using BKLMCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedBKLMHit, Const::BKLM>

Hit to reco hit measurement creator for the BKLM.

Definition at line 42 of file CoordinateMeasurementCreator.h.

CDCBaseMeasurementCreator

using CDCBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedCDCHit, Const::CDC>

Needed for templating.

Standard base class for CDC measurement creators.

Definition at line 83 of file BaseMeasurementCreatorFromHit.h.

CDCCKFPath

using CDCCKFPath = std::vector<CDCCKFState>

Shortcut for the collection of CDC CKF-algorithm states.

Definition at line 19 of file CDCCKFPath.h.

CDCCKFResult

using CDCCKFResult = CDCCKFPath

Alias for the collection of CDC CKF-algorithm states.

Definition at line 18 of file CDCCKFResult.h.

CDCCoordinateMeasurementCreator

using CDCCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedCDCHit, Const::CDC>

Needed for templating.

Hit to reco hit measurement creator for the CDC.

Definition at line 36 of file CoordinateMeasurementCreator.h.

ChooseableOnPXDStateApplier

using ChooseableOnPXDStateApplier

Initial value:

 
                                              LayerToggledApplier<CKFToPXDState, LimitedOnStateApplier<CKFToPXDState, TrackFindingCDC::ChooseableFilter<PXDStateFilterFactory>>>

Alias to apply the () operator to all items filtered by CKF PXD layer states.

Definition at line 24 of file ChooseableOnPXDStateApplier.h.

ChooseableOnSVDStateApplier

using ChooseableOnSVDStateApplier

Initial value:

 LayerToggledApplier<CKFToSVDState, LimitedOnStateApplier<CKFToSVDState,
                                                  TrackFindingCDC::ChooseableFilter<SVDStateFilterFactory>>>

Alias to apply the () operator to all items filtered by CKF SVD layer states.

Definition at line 25 of file ChooseableOnSVDStateApplier.h.

ChooseablePXDRelationFilter

using ChooseablePXDRelationFilter = LayerPXDRelationFilter<TrackFindingCDC::ChooseableFilter<PXDPairFilterFactory>>

A chooseable filter for picking out the relations between states.

Definition at line 22 of file ChooseablePXDRelationFilter.h.

ChooseablePXDResultFilter

using ChooseablePXDResultFilter = TrackFindingCDC::ChooseableFilter<PXDResultFilterFactory>

Alias for filter to weight the PXD clusters.

Definition at line 24 of file ChooseablePXDResultFilter.h.

ChooseableSVDRelationFilter

using ChooseableSVDRelationFilter = LayerSVDRelationFilter<TrackFindingCDC::ChooseableFilter<SVDPairFilterFactory>>

A chooseable filter for picking out the relations between states.

Definition at line 20 of file ChooseableSVDRelationFilter.h.

ChooseableSVDResultFilter

using ChooseableSVDResultFilter = TrackFindingCDC::ChooseableFilter<SVDResultFilterFactory>

Alias for filter to weight the SVD clusters.

Definition at line 19 of file ChooseableSVDResultFilter.h.

EKLMBaseMeasurementCreator

using EKLMBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedEKLMHit, Const::EKLM>

Standard base class for EKLM measurement creators.

Definition at line 91 of file BaseMeasurementCreatorFromHit.h.

EKLMCoordinateMeasurementCreator

using EKLMCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedEKLMHit, Const::EKLM>

Hit to reco hit measurement creator for the EKLM.

Definition at line 44 of file CoordinateMeasurementCreator.h.

EventTimeExtractorModule

template<class AFindlet>

using EventTimeExtractorModule

Initial value:

 TrackFindingCDC::FindletModule <
                                   TrackFindingCDC::FindletStoreArrayInput<BaseEventTimeExtractorModuleFindlet<AFindlet> >>

Alias for the event time extraction module.

Definition at line 50 of file BaseEventTimeExtractorModule.dcl.h.

NonIPCrossingPXDStateFilter

using NonIPCrossingPXDStateFilter = NonIPCrossingStateFilter<AllPXDStateFilter>

Alias for filter to check direction of a new CKF PXD state.

Definition at line 20 of file NonIPCrossingPXDStateFilter.h.

NonIPCrossingSVDStateFilter

using NonIPCrossingSVDStateFilter = NonIPCrossingStateFilter<AllSVDStateFilter>

Alias for filter to check direction of a new CKF SVD state.

Definition at line 20 of file NonIPCrossingSVDStateFilter.h.

PXDAdvancer

using PXDAdvancer = Advancer

The PXD advancer is just a synonym of the normal advancer (but may change in the future).

Definition at line 18 of file PXDAdvancer.h.

PXDBaseMeasurementCreator

using PXDBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedPXDHit, Const::PXD>

Standard base class for PXD measurement creators.

Definition at line 87 of file BaseMeasurementCreatorFromHit.h.

PXDCoordinateMeasurementCreator

using PXDCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedPXDHit, Const::PXD>

Hit to reco hit measurement creator for the PXD.

Definition at line 40 of file CoordinateMeasurementCreator.h.

PXDMomentumMeasurementCreator

using PXDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedPXDHit, Const::PXD>

Momentum measurement creator for the PXD.

Definition at line 123 of file VXDMomentumEstimationMeasurementCreator.h.

PXDStateRejecter

using PXDStateRejecter = StateRejecter<CKFToPXDState, ChooseableOnPXDStateApplier>

Rejecter findlet for CKF PXD states.

Definition at line 22 of file PXDStateRejecter.h.

SVDAdvancer

using SVDAdvancer = Advancer

The PXD advancer is just a synonym of the normal advancer (but may change in the future).

Definition at line 18 of file SVDAdvancer.h.

SVDBaseMeasurementCreator

using SVDBaseMeasurementCreator = BaseMeasurementCreatorFromHit<RecoHitInformation::UsedSVDHit, Const::SVD>

Standard base class for SVD measurement creators.

Definition at line 85 of file BaseMeasurementCreatorFromHit.h.

SVDCoordinateMeasurementCreator

using SVDCoordinateMeasurementCreator = CoordinateMeasurementCreator<RecoHitInformation::UsedSVDHit, Const::SVD>

Hit to reco hit measurement creator for the SVD.

Definition at line 38 of file CoordinateMeasurementCreator.h.

SVDMomentumMeasurementCreator

using SVDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedSVDHit, Const::SVD>

Momentum measurement creator for the SVD.

Definition at line 121 of file VXDMomentumEstimationMeasurementCreator.h.

SVDStateRejecter

using SVDStateRejecter = StateRejecter<CKFToSVDState, ChooseableOnSVDStateApplier>

Rejecter findlet for CKF SVD states.

Definition at line 24 of file SVDStateRejecter.h.

Enumeration Type Documentation

VolTypes

enum VolTypes

Enumeration for G4VPhysicalVolume sensitive-volume categories.

Enumerator
VOLTYPE_CDC	CDC.
VOLTYPE_TOP1	TOP container.
VOLTYPE_TOP2	TOP quartz.
VOLTYPE_TOP3	TOP glue.
VOLTYPE_ARICH1	ARICH aerogel.
VOLTYPE_ARICH2	ARICH Img plate.
VOLTYPE_ARICH3	ARICH HAPD window.
VOLTYPE_ECL	ECL.
VOLTYPE_BKLM1	BKLM RPC.
VOLTYPE_BKLM2	BKLM scintillator.
VOLTYPE_EKLM	EKLM.

Definition at line 70 of file TrackExtrapolateG4e.h.

                {
    VOLTYPE_CDC,
    VOLTYPE_TOP1,
    VOLTYPE_TOP2,
    VOLTYPE_TOP3,
    VOLTYPE_ARICH1,
    VOLTYPE_ARICH2,
    VOLTYPE_ARICH3,
    VOLTYPE_ECL,
    VOLTYPE_BKLM1,
    VOLTYPE_BKLM2,
    VOLTYPE_EKLM
  };

Function Documentation

analyze()

template<size_t Ndims>

double analyze

(

const std::array< double, Ndims > &

hits

)

const

calculate the output of the FastBDT.

At the moment fixed to 3 hits

Definition at line 96 of file FBDTClassifier.h.

  {
    std::vector<double> positions = m_decorrMat.decorrelate(hits);
 
    std::vector<unsigned> bins(Ndims);
    for (size_t i = 0; i < Ndims; ++i) {
      bins[i] = m_featBins[i].ValueToBin(positions[i]);
    }
 
    return m_forest.Analyse(bins);
  }

AnalyzingAlgorithmFactoryDouble()

template<class DataType, class TCInfoType, class VectorType>

AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > * AnalyzingAlgorithmFactoryDouble

(

AlgoritmType::Type

algorithmID

)

the analyzingAlgorithm factory for algorithms returning one double for each TC passed:

returns the algorithm matching the given ID.

residuals

values of single entries

Definition at line 34 of file AnalyzingAlgorithmFactory.h.

  {
    if (algorithmID == AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPX<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPX<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPY<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPY<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPZ<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPZ<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPT<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPT<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualP<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualP<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPTheta<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPTheta<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPPhi<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPPhi<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPAngle<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPAngle<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPTAngle<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPTAngle<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPosition<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPosition<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmResidualPositionXY<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmResidualPositionXY<DataType, TCInfoType, VectorType>(); }
 

    if (algorithmID == AnalyzingAlgorithmValuePX<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePX<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValuePY<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePY<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValuePZ<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePZ<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValuePT<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePT<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValueP<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValueP<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValuePTheta<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePTheta<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValuePPhi<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValuePPhi<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValueDistSeed2IP<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValueDistSeed2IP<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValueDistSeed2IPXY<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValueDistSeed2IPXY<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValueDistSeed2IPZ<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValueDistSeed2IPZ<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmValueQI<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmValueQI<DataType, TCInfoType, VectorType>(); }
 
    if (!AlgoritmType::isValueDoubleType(algorithmID)
        and !AlgoritmType::isResidualDoubleType(algorithmID)
        and (AlgoritmType::isHitValueVecDoubleType(algorithmID)
             or AlgoritmType::isHitValueIntType(algorithmID))) {
      B2WARNING(" AnalyzingAlgorithmFactoryDouble: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
                " is no algorithm of double type but of another (valid) category. Please use the correct factory for your purpose. Returning non-functioning base-class instead!");
    } else {
      B2ERROR(" AnalyzingAlgorithmFactoryDouble: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
              " is not known, returning non-functioning base-class instead!");
    }
 
    return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>();
  }

AnalyzingAlgorithmFactoryInt()

template<class DataType, class TCInfoType, class VectorType>

AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > * AnalyzingAlgorithmFactoryInt

(

AlgoritmType::Type

algorithmID

)

the analyzingAlgorithm factory for algorithms returning one int for each TC passed:

returns the algorithm matching the given ID.

residuals

Definition at line 129 of file AnalyzingAlgorithmFactory.h.

  {
    if (algorithmID == AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmLostUClusters<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmLostUClusters<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmLostVClusters<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmLostVClusters<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmTotalUClusters<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmTotalUClusters<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmTotalVClusters<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmTotalVClusters<DataType, TCInfoType, VectorType>(); }
 
    if (!AlgoritmType::isHitValueIntType(algorithmID)
        and (AlgoritmType::isValueDoubleType(algorithmID)
             or AlgoritmType::isResidualDoubleType(algorithmID)
             or AlgoritmType::isHitValueVecDoubleType(algorithmID))) {
      B2WARNING(" AnalyzingAlgorithmInt: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
                " is no algorithm of int type but of another (valid) category. Please use the correct factory for your purpose. Returning non-functioning base-class instead!");
    } else {
      B2ERROR(" AnalyzingAlgorithmInt: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
              " is not known, returning non-functioning base-class instead!");
    }
 
    return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>();
  }

AnalyzingAlgorithmFactoryVecDouble()

template<class DataType, class TCInfoType, class VectorType>

AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > * AnalyzingAlgorithmFactoryVecDouble

(

AlgoritmType::Type

algorithmID

)

the analyzingAlgorithm factory for algorithms returning one vector< double> for each TC passed:

returns the algorithm matching the given ID.

residuals

Definition at line 168 of file AnalyzingAlgorithmFactory.h.

  {
    if (algorithmID == AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmLostUEDep<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmLostUEDep<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmLostVEDep<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmLostVEDep<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmTotalUEDep<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmTotalUEDep<DataType, TCInfoType, VectorType>(); }
 
    if (algorithmID == AnalyzingAlgorithmTotalVEDep<DataType, TCInfoType, VectorType>())
    { return new AnalyzingAlgorithmTotalVEDep<DataType, TCInfoType, VectorType>(); }
 
 
    if (!AlgoritmType::isHitValueVecDoubleType(algorithmID)
        and (AlgoritmType::isValueDoubleType(algorithmID)
             or AlgoritmType::isResidualDoubleType(algorithmID)
             or AlgoritmType::isHitValueIntType(algorithmID))) {
      B2WARNING(" AnalyzingAlgorithmVecDouble: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
                " is no algorithm of vector<double> type but of another (valid) category. Please use the correct factory for your purpose. Returning non-functioning base-class instead!");
    } else {
      B2ERROR(" AnalyzingAlgorithmVecDouble: given algorithmID " << AlgoritmType::getTypeName(algorithmID) <<
              " is not known, returning non-functioning base-class instead!");
    }
 
    return new AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>();
  }

appendIntercepts()

template<class aIntercept>

void appendIntercepts ( StoreArray< aIntercept > * interceptList, std::list< ROIDetPlane > planeList, genfit::MeasuredStateOnPlane state, int recoTrackIndex, RelationArray * recoTrackToIntercepts )

private

Append the Intercept infos related to the track theTrack to the listToBeFilled.

Definition at line 87 of file VXDInterceptor.templateDetails.h.

  {
    aIntercept tmpIntercept;
 
    B2DEBUG(20, " ...-appendIntercepts, checking " << planeList.size() << " planes");
 
    double lambda = 0;
 
    std::list<ROIDetPlane>::iterator itPlanes = planeList.begin();
    while (itPlanes != planeList.end()) {
      B2DEBUG(20, " searching in appendIntercepts :  " << (itPlanes->getVxdID()));
 
      try {
        lambda = state.extrapolateToPlane(itPlanes->getSharedPlanePtr());
      }  catch (...) {
        B2DEBUG(20, " ...-extrapolation to plane failed");
        ++itPlanes;
        continue;
      }
 
      const TVectorD& predictedIntersect = state.getState();
      const TMatrixDSym& covMatrix = state.getCov();
 
      tmpIntercept.setCoorU(predictedIntersect[3]);
      tmpIntercept.setCoorV(predictedIntersect[4]);
      tmpIntercept.setSigmaU(sqrt(covMatrix(3, 3)));
      tmpIntercept.setSigmaV(sqrt(covMatrix(4, 4)));
      tmpIntercept.setSigmaUprime(sqrt(covMatrix(1, 1)));
      tmpIntercept.setSigmaVprime(sqrt(covMatrix(2, 2)));
      tmpIntercept.setLambda(lambda);
      tmpIntercept.setVxdID(itPlanes->getVxdID());
      tmpIntercept.setUprime(predictedIntersect[1]);
      tmpIntercept.setVprime(predictedIntersect[2]);
 
      B2DEBUG(20, "extrapolate to plane!!! >>> coordinates with getPos = " << state.getPos().X()
              << ", " << state.getPos().Y()
              << ", " << state.getPos().Z());
      B2DEBUG(20, "coordinates with predInter = " << predictedIntersect[3]
              << ", " << predictedIntersect[4]);
      B2DEBUG(20, "momentum with getMom = " << state.getMom().X()
              << ", " << state.getMom().Y()
              << ", " << state.getMom().Z());
      B2DEBUG(20, "U/V prime momentum with getMom = " << state.getMom().Z() / state.getMom().X()
              << ", " << state.getMom().Z() / state.getMom().Y());
      B2DEBUG(20, "U/V prime momentum with predInter = " << predictedIntersect[1]
              << ", " << predictedIntersect[2]);
 
      interceptList->appendNew(tmpIntercept);
 
      recoTrackToIntercepts->add(recoTrackIndex, interceptList->getEntries() - 1);
 
      ++itPlanes;
 
    }
 
  }

apply() [1/14]

template<class AFindlet>

void apply ( std::vector< RecoTrack * > & recoTracks )

finaloverride

Apply the findlets.

Definition at line 33 of file BaseEventTimeExtractorModule.icc.h.

  {
    std::vector<RecoTrack*> copiedRecoTracks = recoTracks;
    m_trackSelector.apply(copiedRecoTracks);
    m_findlet.apply(copiedRecoTracks);
 
    for (RecoTrack* recoTrack : recoTracks) {
      recoTrack->setDirtyFlag();
    }
  }

apply() [2/14]

template<class AState, class ASeedRelationFilter, class AHitRelationFilter>

void apply ( std::vector< AState > & seedStates, std::vector< AState > & states, std::vector< TrackFindingCDC::WeightedRelation< AState > > & relations )

override

Apply both filters for creating state-hit and hit-hit relations.

Definition at line 57 of file CKFRelationCreator.icc.h.

  {
    const std::vector<AState*> seedStatePointers = TrackFindingCDC::as_pointers<AState>(seedStates);
    const std::vector<AState*> statePointers = TrackFindingCDC::as_pointers<AState>(states);
 
    // Just some arbitrary number...
    relations.reserve(10000);
 
    // relations += seed states -> states
    TrackFindingCDC::RelationFilterUtil::appendUsing(m_seedFilter, seedStatePointers, statePointers, relations, 1000000);
 
    // relations += states -> states
    if (m_onlyUseHitStatesRelatedToSeeds) {
      // only use subset of hit states for inter hit state relation creation
      std::vector<AState*> selectedStatePointers;
      selectedStatePointers.reserve(relations.size());
 
      for (const auto& relation : relations) {
        // hit state pointers are the "To"s in the relation, only take those
        const auto it = std::find(selectedStatePointers.begin(), selectedStatePointers.end(), relation.getTo());
        if (it == selectedStatePointers.end()) {
          selectedStatePointers.push_back(relation.getTo());
        }
      }
 
      if (m_onlyCombineRelatedHitStates) {
        // Reduce combinatorics a lot by only combining selectedStatePointers with other selectedStatePointers
        TrackFindingCDC::RelationFilterUtil::appendUsing(m_hitFilter, selectedStatePointers, selectedStatePointers, relations, 1000000);
      } else {
        // Reduce combinatorics a bit less by only combining selectedStatePointers essentially all statePointers
        TrackFindingCDC::RelationFilterUtil::appendUsing(m_hitFilter, selectedStatePointers, statePointers, relations, 1000000);
      }
    } else {
      // use all of hit states for inter hit state relation creation
      TrackFindingCDC::RelationFilterUtil::appendUsing(m_hitFilter, statePointers, statePointers, relations, 1000000);
    }
  }

apply() [3/14]

template<class AFindlet>

void apply ( std::vector< RecoTrack * > & recoTracks )

finaloverride

Timing extraction for this findlet.

Definition at line 29 of file GridEventTimeExtractor.icc.h.

  {
    m_wasSuccessful = false;
 
    m_eventT0WithQuality.clear();
 
    TimeExtractionUtils::addEventT0WithQuality(recoTracks, m_eventT0, m_eventT0WithQuality);
 
    const double eventT0Delta = (m_param_maximalT0Value - m_param_minimalT0Value) / static_cast<double>(m_param_gridSteps);
 
    for (unsigned int gridIndex = 0; gridIndex <= m_param_gridSteps; gridIndex++) {
      const double eventT0Hypothesis = eventT0Delta * static_cast<double>(gridIndex) + m_param_minimalT0Value;
 
      m_eventT0->setEventT0(EventT0::EventT0Component(eventT0Hypothesis, NAN, Const::CDC, "grid"));
      TimeExtractionUtils::addEventT0WithQuality(recoTracks, m_eventT0, m_eventT0WithQuality);
 
      for (unsigned int iteration = 0; iteration < m_param_iterations; iteration++) {
        // The findlet will set the final event t0, but will probably not add any temporary event t0s, which is fine as we will do so.
        m_findlet.apply(recoTracks);
 
        if (m_findlet.wasSuccessful()) {
          TimeExtractionUtils::addEventT0WithQuality(recoTracks, m_eventT0, m_eventT0WithQuality);
        } else if (m_param_abortOnUnsuccessfulStep) {
          B2DEBUG(25, "Aborting because time extraction was not successful.");
          break;
        }
      }
    }
 
    if (not m_eventT0WithQuality.empty()) {
      m_wasSuccessful = true;
      // Look for the best event t0 (with the smallest chi2)
      const auto& bestChi2 = std::max_element(m_eventT0WithQuality.begin(), m_eventT0WithQuality.end(),
      [](const auto & lhs, const auto & rhs) {
        return lhs.quality < rhs.quality;
      });
      m_eventT0->setEventT0(*bestChi2);
    } else {
      // We have changes the event t0, so lets switch it back
      resetEventT0();
    }
  }

apply() [4/14]

template<class AFindlet>

void apply ( std::vector< RecoTrack * > & recoTracks )

finaloverride

Timing extraction for this findlet.

Definition at line 29 of file IterativeEventTimeExtractor.icc.h.

  {
    m_wasSuccessful = false;
 
    m_eventT0WithQuality.clear();
 
    TimeExtractionUtils::addEventT0WithQuality(recoTracks, m_eventT0, m_eventT0WithQuality);
 
    unsigned int iteration = 0;
    for (; iteration < m_param_maxIterations; iteration++) {
      // The findlet will set the final event t0, but will probably not add any temporary event t0s, which is fine as we will do so.
      m_findlet.apply(recoTracks);
 
      bool breakLoop = false;
      if (m_findlet.wasSuccessful()) {
 
        if (not m_eventT0WithQuality.empty()) {
          const double deltaT0 = std::abs(m_eventT0->getEventT0() - m_eventT0WithQuality.back().eventT0);
          if (deltaT0 < m_param_minimalDeltaT0 and iteration >= m_param_minIterations) {
            breakLoop = true;
          }
        }
        TimeExtractionUtils::addEventT0WithQuality(recoTracks, m_eventT0, m_eventT0WithQuality);
      } else if (m_param_abortOnUnsuccessfulStep) {
        B2DEBUG(25, "Aborting because time extraction was not successful.");
        breakLoop = true;
      }
 
      if (breakLoop) {
        break;
      }
    }
 
    if (not m_eventT0WithQuality.empty() and iteration != m_param_maxIterations) {
      if (m_param_useLastEventT0) {
        m_eventT0->addTemporaryEventT0(m_eventT0WithQuality.back());
        m_eventT0->setEventT0(m_eventT0WithQuality.back());
      } else {
        // Look for the best event t0 (with the smallest chi2)
        const auto& bestEventT0 = std::max_element(m_eventT0WithQuality.begin(), m_eventT0WithQuality.end(),
        [](const auto & lhs, const auto & rhs) {
          return lhs.quality < rhs.quality;
        });
        m_eventT0->setEventT0(*bestEventT0);
      }
      m_wasSuccessful = true;
    }
  }

apply() [5/14]

template<class AState, class AFindlet>

void apply ( const std::vector< TrackFindingCDC::WithWeight< const AState * > > & currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > & childStates )

override

The weight is calculated using the subfilter based on the geometrical layer of the state.

Definition at line 45 of file LayerToggledApplier.icc.h.

  {
    const AState* previousState = currentPath.back();
    const int layer = previousState->getGeometricalLayer();
 
    if (layer > m_param_toggleOnLayer) {
      m_highLayerFindlet.apply(currentPath, childStates);
    } else if (layer == m_param_toggleOnLayer) {
      m_equalLayerFindlet.apply(currentPath, childStates);
    } else {
      m_lowLayerFindlet.apply(currentPath, childStates);
    }
  }

apply() [6/14]

template<class AState, class AFilter>

void apply ( const std::vector< TrackFindingCDC::WithWeight< const AState * > > & currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > & childStates )

override

Apply the filter to each pair of states and current path and let only pass the best N states.

Definition at line 30 of file LimitedOnStateApplier.icc.h.

  {
    Super::apply(currentPath, childStates);
 
    if (m_param_useNStates > 0 and childStates.size() > static_cast<unsigned int>(m_param_useNStates)) {
      std::sort(childStates.begin(), childStates.end(), TrackFindingCDC::LessOf<TrackFindingCDC::GetWeight>());
      childStates.erase(childStates.begin() + m_param_useNStates, childStates.end());
    }
  };

apply() [7/14]

template<class AState>

void apply ( const std::vector< TrackFindingCDC::WithWeight< const AState * > > & currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > & childStates )

override

Apply the () operator to all pairs of state and current path.

Definition at line 20 of file OnStateApplier.icc.h.

  {
    if (childStates.empty()) {
      return;
    }
 
    for (TrackFindingCDC::WithWeight<AState*>& stateWithWeight : childStates) {
      AState& state = *stateWithWeight;
      const TrackFindingCDC::Weight& weight = this->operator()({currentPath, &state});
      stateWithWeight.setWeight(weight);
    }
 
    TrackFindingCDC::erase_remove_if(childStates, TrackFindingCDC::HasNaNWeight());
  };

apply() [8/14]

template<class AFilter>

void apply ( std::vector< Object > & results, std::vector< Object > & filteredResult )

override

For each seed, search for the best candidate and return it.

Definition at line 51 of file OverlapResolver.icc.h.

  {
    if (not m_param_enableOverlapResolving or results.empty()) {
      std::swap(results, filteredResults);
      return;
    }
 
    // Sort results by seed, as it makes the next operations faster
    std::sort(results.begin(), results.end(), TrackFindingCDC::LessOf<SeedGetter>());
 
    // resolve overlaps in each seed separately
    const auto& groupedBySeed = TrackFindingCDC::adjacent_groupby(results.begin(), results.end(), SeedGetter());
    for (const TrackFindingCDC::VectorRange<Object>& resultsWithSameSeed : groupedBySeed) {
 
      m_resultsWithWeight.clear();
      for (Object& result : resultsWithSameSeed) {
        TrackFindingCDC::Weight weight = m_filter(result);
        if (std::isnan(weight)) {
          continue;
        }
        m_resultsWithWeight.emplace_back(&result, weight);
      }
 
      if (not m_resultsWithWeight.empty()) {
        // sort results so that 'std::max' below picks path with highest weight if multiple paths have same size
        std::sort(m_resultsWithWeight.begin(), m_resultsWithWeight.end(), TrackFindingCDC::GreaterWeight());
 
        const unsigned int useBestNResults = std::min(m_resultsWithWeight.size(), m_param_useBestNInSeed);
        const auto& lastItemToUse = std::next(m_resultsWithWeight.begin(), useBestNResults);
        const auto& longestElement = *(std::max_element(m_resultsWithWeight.begin(), lastItemToUse,
                                                        TrackFindingCDC::LessOf<NumberOfHitsGetter>()));
        filteredResults.push_back(*(longestElement));
      }
    }
  }

apply() [9/14]

template<class AResult>

void apply ( std::vector< AResult > & results )

override

Load in the reco tracks and the hits.

Store the reco tracks and the relations.

Definition at line 64 of file ResultStorer.icc.h.

  {
    if (not m_param_exportTracks) {
      return;
    }
 
    for (const auto& result : results) {
 
      const ROOT::Math::XYZVector& trackPosition = result.getPosition();
      const ROOT::Math::XYZVector& trackMomentum = result.getMomentum();
      const short& trackCharge = result.getCharge();
 
      RecoTrack* newRecoTrack = m_outputRecoTracks.appendNew(trackPosition, trackMomentum, trackCharge);
      result.addToRecoTrack(*newRecoTrack);
 
      const RecoTrack* seed = result.getSeed();
      if (not seed) {
        continue;
      }
      seed->addRelationTo(newRecoTrack, m_param_writeOutDirection);
    }
  }

apply() [10/14]

template<class AResult, class ACluster>

void apply ( const std::vector< AResult > & results, const std::vector< const SpacePoint * > & spacePoints )

override

Mark all space points as used, that they share clusters if the given kind with the results.

Definition at line 52 of file SpacePointTagger.icc.h.

  {
    if (not m_param_markUsedSpacePoints) {
      return;
    }
 
    for (const AResult& result : results) {
      const std::vector<const SpacePoint*>& hits = result.getHits();
      for (const SpacePoint* spacePoint : hits) {
        m_usedSpacePoints.insert(spacePoint);
 
        if (not m_param_singleClusterLevel) {
          continue;
        }
 
        const auto& relatedClusters = spacePoint->getRelationsTo<ACluster>();
        for (const ACluster& relatedCluster : relatedClusters) {
          m_usedClusters.insert(&relatedCluster);
        }
      }
    }
 
    for (const SpacePoint* spacePoint : spacePoints) {
      if (TrackFindingCDC::is_in(spacePoint, m_usedSpacePoints)) {
        spacePoint->setAssignmentState(true);
        continue;
      }
 
      if (not m_param_singleClusterLevel) {
        continue;
      }
 
      const auto& relatedClusters = spacePoint->getRelationsTo<ACluster>();
      for (const ACluster& relatedCluster : relatedClusters) {
        if (TrackFindingCDC::is_in(&relatedCluster, m_usedClusters)) {
          spacePoint->setAssignmentState(true);
          break;
        }
      }
    }
  }

apply() [11/14]

template<class AnObject, class AState>

void apply ( const std::vector< AnObject * > & objects, std::vector< AState > & states )

override

Add new states to the list of states using all given objects.

Findlet for tagging all space points in the results vector as used.

Definition at line 19 of file StateCreator.icc.h.

  {
    states.reserve(states.size() + objects.size());
 
    for (AnObject* object : objects) {
      states.emplace_back(object);
    }
  }

apply() [12/14]

template<class AState>

void apply ( const std::vector< RecoTrack * > & objects, std::vector< AState > & states )

final

Create states from the space points, including a reverse flag or not.

Definition at line 20 of file StateCreatorWithReversal.icc.h.

  {
    for (const RecoTrack* object : objects) {
      states.emplace_back(object, m_param_reverseSeed);
    }
  }

apply() [13/14]

template<class AState, class AFindlet>

void apply ( const std::vector< TrackFindingCDC::WithWeight< const AState * > > & currentPath, std::vector< TrackFindingCDC::WithWeight< AState * > > & childStates )

final

Apply all five filters to the child states.

Definition at line 42 of file StateRejecter.icc.h.

  {
    B2DEBUG(29, "Starting with " << childStates.size() << " states.");
    m_firstFilter.apply(currentPath, childStates);
    B2DEBUG(29, "After first filter " << childStates.size() << " states.");
    // Nothing to do anymore
    if (childStates.size() == 0) {
      return;
    }
    m_advanceFilter.apply(currentPath, childStates);
    B2DEBUG(29, "After advance filter " << childStates.size() << " states.");
    // Nothing to do anymore
    if (childStates.size() == 0) {
      return;
    }
    m_secondFilter.apply(currentPath, childStates);
    B2DEBUG(29, "After second filter " << childStates.size() << " states.");
    // Nothing to do anymore
    if (childStates.size() == 0) {
      return;
    }
    m_updateFilter.apply(currentPath, childStates);
    B2DEBUG(29, "After update filter " << childStates.size() << " states.");
    // Nothing to do anymore
    if (childStates.size() == 0) {
      return;
    }
    m_thirdFilter.apply(currentPath, childStates);
    B2DEBUG(29, "After third filter " << childStates.size() << " states.");
  };

apply() [14/14]

template<class AState, class AStateRejecter, class AResult>

void apply ( const std::vector< AState > & seededStates, std::vector< AState > & hitStates, const std::vector< TrackFindingCDC::WeightedRelation< AState > > & relations, std::vector< AResult > & results )

final

Main function of this findlet: traverse a tree starting from a given seed states.

ATTENTION: As described above, the states themselves can be altered during the tree traversal.

Definition at line 42 of file TreeSearcher.icc.h.

  {
    B2ASSERT("Expected relation to be sorted",
             std::is_sorted(relations.begin(), relations.end()));
 
    // TODO: May be better to just do this for each seed separately
    const std::vector<AState*>& statePointers = TrackFindingCDC::as_pointers<AState>(hitStates);
    m_automaton.applyTo(statePointers, relations);
 
    std::vector<TrackFindingCDC::WithWeight<const AState*>> path;
    for (const AState& state : seededStates) {
      B2DEBUG(29, "Starting with new seed...");
 
      path.emplace_back(&state, 0);
      traverseTree(path, relations, results);
      path.pop_back();
      B2ASSERT("Something went wrong during the path traversal", path.empty());
 
      B2DEBUG(29, "... finished with seed");
    }
  }

arcLengthInRightDirection()

bool arcLengthInRightDirection ( double arcLength2D, TrackFindingCDC::EForwardBackward forwardBackward )

inlineconstexpr

Given the calculated arc length between a start point and an end point, checks if the travelled path is along the given direction or not.

If the arc length distance is negative, the end point has a higher arc length value than the start point meaning it is farther away -> the travelled distance is forward. If the arc length distance is positive, it is backward.

If it is 0 or the direction is unknown, true is always returned.

Definition at line 30 of file SearchDirection.h.

  {
    return static_cast<double>(forwardBackward) * arcLength2D >= 0;
  }

BaseEventTimeExtractorModuleFindlet()

template<class AFindlet>

BaseEventTimeExtractorModuleFindlet

(

)

Add the subfindlet as listener.

Definition at line 19 of file BaseEventTimeExtractorModule.icc.h.

  {
    addProcessingSignalListener(&m_findlet);
    addProcessingSignalListener(&m_trackSelector);
  }

beginEvent() [1/2]

template<class ... AIOTypes>

void beginEvent ( )

overridevirtual

Create the event t0 store obj ptr.

Reimplemented from ProcessingSignalListener.

Definition at line 45 of file BaseEventTimeExtractor.icc.h.

  {
    Super::beginEvent();
 
    m_wasSuccessful = false;
 
    if (not m_eventT0.isValid()) {
      m_eventT0.create();
    }
 
    m_eventT0Before = m_eventT0->getEventT0Component();
  }

beginEvent() [2/2]

template<class AResult, class ACluster>

void beginEvent ( )

overridevirtual

Clear the used clusters.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 26 of file SpacePointTagger.icc.h.

  {
    Super::beginEvent();
 
    m_usedClusters.clear();
    m_usedSpacePoints.clear();
  }

beginRun() [1/3]

template<class AFilter, class APrefilter>

void beginRun ( )

overridevirtual

Receive and dispatch signal for the beginning of a new run.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 61 of file LayerPXDRelationFilter.icc.h.

  {
    Super::beginRun();
 
    // use values from payload if parameter is set to -1
    if (m_param_hitJumping == -1) {
      if (m_ckfParameters->isValid()) {
        m_layerJumpPtThreshold = (*m_ckfParameters)->getLayerJumpPtThreshold();
        m_layerJumpLowPt = (*m_ckfParameters)->getLayerJumpLowPt();
        m_layerJumpHighPt = (*m_ckfParameters)->getLayerJumpHighPt();
        if (m_prefix == "hit" && m_layerJumpPtThreshold > 0.) {
          // if we want to have this, some major restructure of the whole CKF code is necessary
          // (CKF states from hits don't know anything about the seed track, i.e. you cannot access its momentum)
          B2FATAL("pt dependence of layerJump parameter currently not implemented for hit->hit extrapolation.");
        }
      } else {
        B2FATAL("Trying to read layerJump parameter from DB but payload '" << m_ckfParameters->getName() << "' not found.");
      }
      // we don't need all this if simple value from python config is to be used
    } else {
      m_layerJumpPtThreshold = -1;
      m_layerJumpLowPt = m_param_hitJumping;
      m_layerJumpHighPt = m_param_hitJumping;
    }
  }

beginRun() [2/3]

template<class AFilter, class APrefilter>

void beginRun ( )

finalvirtual

Initialize the maximal ladder cache.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 33 of file LayerSVDRelationFilter.icc.h.

  {
    Super::beginRun();
 
    // Fill maximum number cache
    auto& geoCache = VXD::GeoCache::getInstance();
    const auto& layers = geoCache.getLayers(VXD::SensorInfoBase::SensorType::SVD);
    for (const auto& layerVXDID : layers) {
      m_maximalLadderCache[layerVXDID.getLayerNumber()] = geoCache.getLadders(layerVXDID).size();
    }
  }

beginRun() [3/3]

void beginRun ( )

finalvirtual

Initialize the sector map.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 22 of file SectorMapBasedSVDPairFilter.cc.

  {
    Super::beginRun();
 
    m_vxdtfFilters = m_filtersContainer.getFilters(m_param_sectorMapName);
    if (not m_vxdtfFilters) {
      B2FATAL("Requested secMapName '" << m_param_sectorMapName << "' does not exist!");
    }
  }

calcCurvatureSignum()

short calcCurvatureSignum ( std::vector< SpacePoint const * > const & measurements )

inline

Calculate curvature based on triplets of measurements.

Ignores uncertainties. Returns -1,0,1 depending on the sum of all triplets.

Definition at line 22 of file CalcCurvatureSignum.h.

  {
    if (measurements.size() < 3) return 0;
    float sumOfCurvature = 0.;
    for (unsigned int i = 0; i < measurements.size() - 2; ++i) {
      B2Vector3D ab = measurements.at(i + 1)->getPosition() - measurements.at(i)->getPosition();
      ab.SetZ(0.);
      B2Vector3D bc = measurements.at(i + 2)->getPosition() - measurements.at(i + 1)->getPosition();
      bc.SetZ(0.);
      sumOfCurvature += bc.Orthogonal() * ab; //normal vector of m_vecBC times segment of ba
    }
    // signum
    return (0 < sumOfCurvature) - (sumOfCurvature < 0);
  }

calculateCovMatrix()

template<size_t Ndims>

const Eigen::Matrix< double, Ndims, Ndims, Eigen::RowMajor > calculateCovMatrix

(

std::array< std::vector< double >, Ndims >

inputData

)

calculates the empirical covariance matrix from the inputData.

Parameters

inputData

data "matrix", where each vector represents a column in the n x Ndims matrix, where n is the number of samples in the input data.

NOTE: if the input does not consist of an array of same-length vectors an error message is issued and the Ndims x Ndims identity matrix is returned.

Implements the calculation of the empirical covariance matrix: , where is the mean (row) vector containing the mean value of every "feature" in the data. Every (random) vector is a row vector containing one measurement.

Definition at line 37 of file DecorrelationMatrixHelper.h.

  {
    // typedefs used in function
    using RVector = Eigen::Matrix<double, 1, Ndims, Eigen::RowMajor>; // typedef for row vector type of one measurement
    using DMatrix = Eigen::Matrix<double, Eigen::Dynamic, Ndims, Eigen::ColMajor>; // typedef for dataMatrix type
    using DVector = Eigen::Matrix<double, Eigen::Dynamic, 1>; // typedef for column vector in dataMatrix
 
    // check if the inputData represent a "full" data matrix
    size_t nSamples = inputData[0].size();
    for (size_t i = 1; i < Ndims; ++i) {
      if (inputData[i].size() != nSamples) {
        B2ERROR("The input data is no MxN matrix, cannot calculate covariance matrix! Returning identity");
        return Eigen::Matrix<double, Ndims, Ndims, Eigen::RowMajor>::Identity();
      }
    }
 
    // calculate the mean of every column and store them in a row vector
    RVector meanVector{};
    for (size_t i = 0; i < Ndims; ++i) {
      meanVector(i) = std::accumulate(inputData[i].begin(), inputData[i].end(), 0.0) / inputData[i].size();
    }
 
    // map the data to a more easily accessible Eigen::Matrix where each row is one measurement (consisting of Ndims values)
    DMatrix dataMatrix(nSamples, Ndims);
    for (size_t i = 0; i < Ndims; ++i) {
      dataMatrix.col(i) = Eigen::Map<const DVector>(inputData[i].data(), inputData[i].size());
    }
 
    // define a matrix where each row holds the mean vector to be able to subtract the mean value from each column directly
    DMatrix meanMatrix(nSamples, Ndims);
    for (size_t i = 0; i < Ndims; ++i) {
      meanMatrix.col(i) = DVector::Ones(nSamples) * meanVector(i);
    }
 
    // calculate the cov matrix as product of dataMatrix reduced by meanValues in order to (hopefully) utilize Eigens optimizations
    // COULDDO: test if this can be accelerated by splitting the process in smaller matrices
    return (dataMatrix - meanMatrix).transpose() * (dataMatrix - meanMatrix) / (nSamples);
  }

calculateDecorrMatrix()

template<size_t Ndims>

void calculateDecorrMatrix	(	std::array< std::vector< double >, Ndims >	inputData,
		bool	normalise = true )

calculate the transformation matrix that when applied to the input data yields linearly uncorrelated data.

Parameters

inputData	input data, where each vector represents a column in the MxNdims matrix, where M is the number of samples in in the input data
normalise	if set to true the covariance matrix of the transformed data will be identity, else it will only be diagonal

Definition at line 98 of file DecorrelationMatrix.h.

  {
    calculateDecorrMatrix(calculateCovMatrix(inputData), normalise);
  }

checkResizeClear()

template<class T>

void checkResizeClear	(	std::vector< T > &	vectorToCheck,
		uint	limit )

Check capacity of a vector and create a fresh one if capacity too large If the capacity of a std::vector is very large without being used, it just allocates RAM for no reason, increasing the RAM usage unnecessarily.

In this case, start with a fresh one. Since std::vector.shrink() or std::vector.shrink_to_fit() not necessarily reduce the capacity in the desired way, create a temporary vector of the same type, swap them to use the vector at the new location afterwards, and clear the tempoary vector.

Definition at line 23 of file Helpers.h.

  {
 
    if (vectorToCheck.capacity() > limit) {
      B2DEBUG(29, "Capacity of vector too large, create fresh vector and swap.");
      std::vector<T> tmp;
      std::swap(vectorToCheck, tmp);
      tmp.clear();
    }
    vectorToCheck.clear();
    vectorToCheck.reserve(limit / 4);
  }

CKFRelationCreator()

template<class AState, class ASeedRelationFilter, class AHitRelationFilter>

CKFRelationCreator

(

)

Construct this findlet and add the subfindlet as listener.

Definition at line 27 of file CKFRelationCreator.icc.h.

                                                                                          : Super()
  {
    Super::addProcessingSignalListener(&m_seedFilter);
    Super::addProcessingSignalListener(&m_hitFilter);
  }

constructMeasurementsOnPlane()

template<class HitType>

std::vector< genfit::MeasurementOnPlane * > constructMeasurementsOnPlane ( const genfit::StateOnPlane & state ) const

overridevirtual

Construct the measurement on the plane set in the parent element.

Do the job: construct a measurement based on the estimator chosen by the parameters.

TODO: Implement better error handling and a smarter cut.

Definition at line 122 of file PlanarVXDMomentumMeasurement.h.

  {
    const VXDMomentumEstimation<HitType>& momentumEstimator = VXDMomentumEstimation<HitType>::getInstance();
    const VXDMomentumEstimationTools<HitType>& momentumEstimationTools = VXDMomentumEstimationTools<HitType>::getInstance();
 
    TVectorD rawHitCoordinates(1);
    TMatrixDSym rawHitCovariance(1);
 
    // Copy the information from the current state
    const B2Vector3D& statePosition(state.getPos());
    const B2Vector3D& stateMomentum(state.getMom());
    short stateCharge = state.getCharge();
 
 
    // Copy the information from the reco track.
    const B2Vector3D& trackPosition(m_recoTrack->getPositionSeed());
    const B2Vector3D& trackMomentum(m_recoTrack->getMomentumSeed());
    short trackCharge = m_recoTrack->getChargeSeed();
 
    // Copy the information from the mc particle (if there is one)
    MCParticle* relatedMCParticle = m_hit->template getRelated<MCParticle>("MCParticles");
 
    ROOT::Math::XYZVector mcMomentum;
    ROOT::Math::XYZVector mcPosition;
    short mcCharge;
 
    if (relatedMCParticle == nullptr) {
      mcMomentum = ROOT::Math::XYZVector(trackMomentum);
      mcPosition = ROOT::Math::XYZVector(trackPosition);
      mcCharge = trackCharge;
    } else {
      mcMomentum = relatedMCParticle->getMomentum();
      mcPosition = relatedMCParticle->getProductionVertex();
      mcCharge = relatedMCParticle->getCharge();
    }
 
    // Copy information from the mc hit
    const ROOT::Math::XYZVector& hitMCMomentum = momentumEstimationTools.getEntryMomentumOfMCParticle(*m_hit);
    const ROOT::Math::XYZVector& hitMCPosition = momentumEstimationTools.getEntryPositionOfMCParticle(*m_hit);
 
 
    if (m_useThickness) {
      rawHitCoordinates(0) = momentumEstimator.estimateQOverPWithThickness(*m_hit, stateCharge, m_fitParameters,
                             m_correctionFitParameters);
    } else {
      if (m_useTrackingSeeds) {
        if (m_useMCInformation) {
          rawHitCoordinates(0) = momentumEstimator.estimateQOverP(*m_hit, mcMomentum, mcPosition, mcCharge,
                                                                  m_fitParameters,
                                                                  m_correctionFitParameters);
 
        } else {
          rawHitCoordinates(0) = momentumEstimator.estimateQOverP(*m_hit, ROOT::Math::XYZVector(trackMomentum),
                                                                  ROOT::Math::XYZVector(trackPosition), trackCharge,
                                                                  m_fitParameters,
                                                                  m_correctionFitParameters);
        }
      } else {
        if (m_useMCInformation) {
          rawHitCoordinates(0) = momentumEstimator.estimateQOverP(*m_hit, hitMCMomentum, hitMCPosition, stateCharge,
                                                                  m_fitParameters,
                                                                  m_correctionFitParameters);
        } else {
          rawHitCoordinates(0) = momentumEstimator.estimateQOverP(*m_hit, ROOT::Math::XYZVector(stateMomentum),
                                                                  ROOT::Math::XYZVector(statePosition), stateCharge,
                                                                  m_fitParameters,
                                                                  m_correctionFitParameters);
        }
      }
    }
 
    rawHitCovariance(0, 0) = m_sigma;
 
    genfit::MeasurementOnPlane* mop = new genfit::MeasurementOnPlane(rawHitCoordinates, rawHitCovariance,
        state.getPlane(), state.getRep(), constructHMatrix(state.getRep()));
    return {mop};
  }

convertFloatToInt()

long convertFloatToInt ( double value, int power )

inline

Convert float or double to long int for more similarity to the FPGA implementation.

Parameters

value	to be converted
power	multiply value by 10^power

Definition at line 21 of file DATCONHelpers.h.

  {
    long factor = (long)pow(10, power);
    return round(factor * value);
  }

convertNetworkPath()

template<class NetworkPath>

SpacePointTrackCand convertNetworkPath ( NetworkPath networkPath )

inline

Create new SPTC from network path.

Definition at line 24 of file NetworkPathConversion.h.

  {
    std::vector <const SpacePoint*> spVector;
    spVector.reserve(networkPath.size());
    if (networkPath.empty()) {
      return SpacePointTrackCand();
    }
 
    auto family = networkPath[0]->getFamily();
    for (auto aNodeIt = networkPath.rbegin(); aNodeIt != networkPath.rend();  ++aNodeIt) {
      insertSpacePoints(spVector, (*aNodeIt)->getEntry());
    }
 
    auto sptc = SpacePointTrackCand(spVector);
    sptc.setFamily(family);
    return sptc;
  }

convertToEigen() [1/2]

template<unsigned int NRows, unsigned int NCols, class AMatrix>

Eigen::Matrix< double, NRows, NCols, Eigen::RowMajor > convertToEigen

(

const AMatrix &

matrix

)

Convert a ROOT matrix to Eigen. Checks for the correct row and column number.

Definition at line 21 of file EigenHelper.h.

  {
    B2ASSERT("Matrix should be in the form " << NRows << "x" << NCols << ", not " << matrix.GetNrows() << "x" << matrix.GetNcols(),
             matrix.GetNcols() == NCols and matrix.GetNrows() == NRows);
    return Eigen::Matrix<double, NRows, NCols, Eigen::RowMajor>(matrix.GetMatrixArray());
  };

convertToEigen() [2/2]

template<unsigned int NRows>

Eigen::Matrix< double, NRows, 1 > convertToEigen

(

const TVectorD &

matrix

)

Convert a ROOT matrix to Eigen - TVector specialisation. Checks for the correct row number.

Definition at line 30 of file EigenHelper.h.

  {
    B2ASSERT("Matrix should be in the form " << NRows << "x" << 1 << ", not " << matrix.GetNrows() << "x" << 1,
             matrix.GetNrows() == NRows);
    return Eigen::Matrix<double, NRows, 1>(matrix.GetMatrixArray());
  };

createPurityInfos() [1/2]

template<typename SPContainer>

static std::vector< Belle2::MCVXDPurityInfo > createPurityInfos ( const SPContainer & container )

static

• create a vector of MCVXDPurityInfos objects for any given container holding SpacePoints and providing a getHits() method each MCParticle that is in the container gets its own object NOTE: negative MCParticleIds are possible und used as follows:
• -1 -> there was a TrueHit (i.e. Cluster) related to a SpacePoint in the container that did not have relation to a MCParticle
• -2 -> there was a SpacePoint with a Cluster that was not related to a TrueHit (noise Cluster)

  Returns

  sorted vector of MCVXDPurityInfo (sorted by overall purity)

  wrapper taking a const reference instead of a const pointer for use in e.g. C++11 for loops

Definition at line 218 of file PurityCalculatorTools.h.

  {
    return createPurityInfos(&container);
  }

createPurityInfos() [2/2]

template<typename SPContainer>

static std::vector< Belle2::MCVXDPurityInfo > createPurityInfos ( const SPContainer * container )

static

create a vector of MCVXDPurityInfos objects for any given container holding SpacePoints and providing a getHits() method each MCParticle that is in the container gets its own object NOTE: negative MCParticleIds are possible und used as follows:

• -1 -> there was a TrueHit (i.e. Cluster) related to a SpacePoint in the container that did not have a relation to a MCParticle
• -2 -> there was a SpacePoint with a Cluster that was not related to a TrueHit (noise Cluster)

  Returns

  sorted vector of MCVXDPurityInfo (sorted by overall purity)

Definition at line 202 of file PurityCalculatorTools.h.

  {
    return createPurityInfosVec(container->getHits());
  }

createPurityInfosVec()

static std::vector< Belle2::MCVXDPurityInfo > createPurityInfosVec ( const std::vector< const Belle2::SpacePoint * > & spacePoints )

static

create a vector of MCVXDPurityInfos objects for a std::vector<Belle2::SpacePoints>.

each MCParticle that is in the vector gets its own object NOTE: negative MCParticleIds are possible and used as follows:

• -1 -> there was a TrueHit (i.e. Cluster) related to a SpacePoint in the vector that did not have a relation to a MCParticle
• -2 -> there was a SpacePoint with a Cluster that was not related to a TrueHit (noise Cluster)

  Returns

  sorted vector of MCVXDPurityInfo (sorted by overall purity)

Definition at line 149 of file PurityCalculatorTools.h.

  {
    std::array<unsigned, 3> totalClusters = { {0, 0, 0 } };
    // WARNING: relying on the fact here that all array entries will be initialized to 0
    std::unordered_map<int, std::array<unsigned, 3> > mcClusters;
 
    unsigned nClusters = 0; // NOTE: only needed for DEBUG output -> remove?
 
    for (const Belle2::SpacePoint* spacePoint : spacePoints) {
      B2DEBUG(29, "Now processing SpacePoint " << spacePoint->getArrayIndex() << " from Array " << spacePoint->getArrayName());
      increaseClusterCounters(spacePoint, totalClusters);
 
      nClusters += spacePoint->getNClustersAssigned();
 
      std::vector<std::pair<int, double> > mcParticles;
      if (spacePoint->getType() == VXD::SensorInfoBase::PXD) mcParticles = getMCParticles<PXDTrueHit>(spacePoint);
      else if (spacePoint->getType() == VXD::SensorInfoBase::SVD) mcParticles = getMCParticles<SVDTrueHit>(spacePoint);
      else if (spacePoint->getType() == VXD::SensorInfoBase::VXD) {B2DEBUG(25, "found generic spacePoint, treating it as virtualIP");}
      else B2FATAL("Unknown DetectorType (" << spacePoint->getType() << ") in createPurityInfos! Skipping this SpacePoint " <<
                     spacePoint->getArrayIndex() << " from Array " << spacePoint->getArrayName());
 
      for (const std::pair<int, double>& particle : mcParticles) {
        std::vector<size_t> accessors = getAccessorsFromWeight(particle.second);
        for (size_t acc : accessors) {
          mcClusters[particle.first][acc]++;
        }
      }
    }
    B2DEBUG(29, "container contained " << spacePoints.size() << " SpacePoint with " << nClusters << " Clusters");
 
    // create MCVXDPurityInfos and add them to the return vector
    std::vector<Belle2::MCVXDPurityInfo> purityInfos;
    for (int mcId : getUniqueKeys(mcClusters)) {
      // cppcheck-suppress useStlAlgorithm
      purityInfos.push_back(MCVXDPurityInfo(mcId, totalClusters, mcClusters[mcId]));
    }
 
    // sort in descending order before return
    std::sort(purityInfos.begin(), purityInfos.end(),
    [](const MCVXDPurityInfo & left, const MCVXDPurityInfo & right) { return left > right; }
             );
    return purityInfos;
  }

decorrelate() [1/3]

template<size_t Ndims>

std::vector< double > decorrelate

(

const std::array< double, Ndims > &

inputs

)

const

"decorrelate" one measurement (i.e.

apply the transformation that has previously been determined).

Definition at line 136 of file DecorrelationMatrix.h.

  {
    return decorrelate(std::vector<double>(input.begin(), input.end()));
  }

decorrelate() [2/3]

template<size_t Ndims>

std::array< std::vector< double >, Ndims > decorrelate

(

const std::array< std::vector< double >, Ndims > &

inputMat

)

const

decorrelate M measurements (i.e.

apply the transformation that has previously been determined). NOTE: the transformation has to be calculated prior to the call of this function!

Definition at line 143 of file DecorrelationMatrix.h.

  {
    using DVector = Eigen::Matrix<double, Eigen::Dynamic, 1, Eigen::ColMajor>;
    using DMatrix = Eigen::Matrix<double, Eigen::Dynamic, Ndims, Eigen::ColMajor>;
 
    size_t nSamples = inputMat[0].size();
    DMatrix dataMatrix(nSamples, Ndims);
    for (size_t i = 0; i < Ndims; ++i) {
      dataMatrix.col(i) = Eigen::Map<const DVector>(inputMat[i].data(), inputMat[i].size());
    }
 
    DMatrix transform = dataMatrix * m_matrix;
 
    std::array<std::vector<double>, Ndims> output;
    for (size_t i = 0; i < Ndims; ++i) {
      output[i] = std::vector<double>(transform.col(i).data(), transform.col(i).data() + transform.col(i).size());
    }
 
    return output;
  }

decorrelate() [3/3]

template<size_t Ndims>

std::vector< double > decorrelate

(

const std::vector< double > &

inputVec

)

const

"decorrelate" one measurement (i.e.

apply the transformation that has previously been determined).

Definition at line 125 of file DecorrelationMatrix.h.

  {
    using RVector = Eigen::Matrix<double, 1, Ndims, Eigen::RowMajor>;
    Eigen::Map<const RVector> input(inputVec.data(), Ndims);
 
    const RVector transform = input * m_matrix;
 
    return std::vector<double>(transform.data(), transform.data() + transform.size());
  }

exposeParameters() [1/17]

template<class ... AIOTypes>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose our parameters to the super module.

Reimplemented from CompositeProcessingSignalListener.

Reimplemented in Chi2BasedEventTimeExtractor, FullGridChi2TrackTimeExtractor, FullGridDriftLengthTrackTimeExtractor, GridEventTimeExtractor< AFindlet >, GridEventTimeExtractor< Belle2::Chi2BasedEventTimeExtractor >, GridEventTimeExtractor< Belle2::DriftLengthBasedEventTimeExtractor >, HitBasedT0Extractor, IterativeChi2BasedEventTimeExtractor, IterativeDriftLengthBasedEventTimeExtractor, IterativeEventTimeExtractor< AFindlet >, IterativeEventTimeExtractor< Chi2BasedEventTimeExtractor >, IterativeEventTimeExtractor< Chi2BasedEventTimeExtractor >, IterativeEventTimeExtractor< DriftLengthBasedEventTimeExtractor >, and IterativeEventTimeExtractor< DriftLengthBasedEventTimeExtractor >.

Definition at line 27 of file BaseEventTimeExtractor.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "overwriteExistingEstimation"),
                                  m_param_overwriteExistingEstimation,
                                  "Is it fine to overwrite the current EventT0?",
                                  m_param_overwriteExistingEstimation);
 
    Super::exposeParameters(moduleParamList, prefix);
  }

exposeParameters() [2/17]

template<class AFindlet>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finaloverridevirtual

Expose our parameters to the super module.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 26 of file BaseEventTimeExtractorModule.icc.h.

  {
    m_trackSelector.exposeParameters(moduleParamList, prefix);
    m_findlet.exposeParameters(moduleParamList, prefix);
  }

exposeParameters() [3/17]

template<class AState, class ASeedRelationFilter, class AHitRelationFilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 34 of file CKFRelationCreator.icc.h.

  {
    m_seedFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("seed", prefix));
    m_hitFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("hit", prefix));
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "onlyUseHitStatesRelatedToSeeds"),
                                  m_onlyUseHitStatesRelatedToSeeds,
                                  "Only use hit states related to seed states to build the inter hit relations to reduce combinatorics. "\
                                  "By default, only the \"FromStates\" will be the ones related to seeds. If also the \"ToStates\" should be "\
                                  "related to the seeds, also m_onlyCombineRelatedHitStates (name in Python: " + \
                                  TrackFindingCDC::prefixed(prefix, "onlyCombineRelatedHitStates") + ") should be set to true.",
                                  m_onlyUseHitStatesRelatedToSeeds);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "onlyCombineRelatedHitStates"),
                                  m_onlyCombineRelatedHitStates,
                                  "Only use hit states related to seed states to build the inter hit relations to reduce combinatorics. "\
                                  "If true, both \"FromStates\" and \"ToStates\" will be those that are already related to seeds. "\
                                  "Only works if also m_onlyUseHitStatesRelatedToSeeds (name in Python: " + \
                                  TrackFindingCDC::prefixed(prefix, "onlyUseHitStatesRelatedToSeeds") + ") is set to true.",
                                  m_onlyCombineRelatedHitStates);
  }

exposeParameters() [4/17]

template<class AFindlet>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finaloverridevirtual

Expose the parameters.

Reimplemented from BaseEventTimeExtractor< RecoTrack * >.

Definition at line 73 of file GridEventTimeExtractor.icc.h.

  {
    Super::exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "iterations"),
                                  m_param_iterations,
                                  "How many iterations should be done?",
                                  m_param_iterations);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "abortOnUnsuccessfulStep"),
                                  m_param_abortOnUnsuccessfulStep,
                                  "Abort on a single unsuccessful step. Otherwise, the success is defined by the last step",
                                  m_param_abortOnUnsuccessfulStep);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximalT0Value"),
                                  m_param_maximalT0Value,
                                  "Maximal Grid Value of the T0 extraction",
                                  m_param_maximalT0Value);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimalT0Value"),
                                  m_param_minimalT0Value,
                                  "Maximal Grid Value of the T0 extraction",
                                  m_param_minimalT0Value);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "gridSteps"),
                                  m_param_gridSteps,
                                  "Number of steps in the grid",
                                  m_param_gridSteps);
 
    m_findlet.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("sub", prefix));
  }

exposeParameters() [5/17]

template<class AFindlet>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters.

Reimplemented from BaseEventTimeExtractor< RecoTrack * >.

Definition at line 79 of file IterativeEventTimeExtractor.icc.h.

  {
    Super::exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maxIterations"),
                                  m_param_maxIterations,
                                  "How many iterations should be done maximally?",
                                  m_param_maxIterations);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minIterations"),
                                  m_param_minIterations,
                                  "How many iterations should be done minimally?",
                                  m_param_minIterations);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimalDeltaT0"),
                                  m_param_minimalDeltaT0,
                                  "What is the final precision?",
                                  m_param_minimalDeltaT0);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "useLastEventT0"),
                                  m_param_useLastEventT0,
                                  "Use the last event t0 instead of the best one.",
                                  m_param_useLastEventT0);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "abortOnUnsuccessfulStep"),
                                  m_param_abortOnUnsuccessfulStep,
                                  "Abort on a single unsuccessful step. Otherwise, the success is defined by the last step",
                                  m_param_abortOnUnsuccessfulStep);
 
    m_findlet.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("sub", prefix));
  }

exposeParameters() [6/17]

template<class AFilter, class APrefilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters of the filter.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 34 of file LayerPXDRelationFilter.icc.h.

  {
    // use value from DB if parameter is set to -1
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "hitJumping"), m_param_hitJumping,
                                  "Make it possible to jump over N layers.", m_param_hitJumping);
 
    m_filter.exposeParameters(moduleParamList, prefix);
    m_prefilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("pre", prefix));
 
    m_prefix = prefix;
  }

exposeParameters() [7/17]

template<class AFilter, class APrefilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the filter.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 122 of file LayerSVDRelationFilter.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "hitJumping"), m_param_hitJumping,
                                  "Make it possible to jump over N layers.", m_param_hitJumping);
 
    m_filter.exposeParameters(moduleParamList, prefix);
    m_prefilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("pre", prefix));
  }

exposeParameters() [8/17]

template<class AState, class AFindlet>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose parameters of the subfilters and the layer to change.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 31 of file LayerToggledApplier.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "toggleOnLayer"),
                                  m_param_toggleOnLayer, "Where to toggle between low, equal and high filter",
                                  m_param_toggleOnLayer);
 
    m_highLayerFindlet.exposeParameters(moduleParamList, TrackFindingCDC::prefixed(prefix, "high"));
    m_equalLayerFindlet.exposeParameters(moduleParamList, TrackFindingCDC::prefixed(prefix, "equal"));
    m_lowLayerFindlet.exposeParameters(moduleParamList, TrackFindingCDC::prefixed(prefix, "low"));
  }

exposeParameters() [9/17]

template<class AState, class AFilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters of the subfindlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 48 of file LimitedOnStateApplier.icc.h.

  {
    m_filter.exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "useNStates"), m_param_useNStates, "Only use the best N states",
                                  m_param_useNStates);
  };

exposeParameters() [10/17]

template<class AllStateFilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

override

Expose the direction parameter.

Definition at line 71 of file NonIPCrossingStateFilter.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "direction"), m_param_directionAsString,
                                  "The direction where the extrapolation will happen.");
  }

exposeParameters() [11/17]

template<class AFilter>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 36 of file OverlapResolver.icc.h.

  {
    m_filter.exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "enableOverlapResolving"),
                                  m_param_enableOverlapResolving,
                                  "Enable the overlap resolving.",
                                  m_param_enableOverlapResolving);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "useBestNInSeed"),
                                  m_param_useBestNInSeed,
                                  "In seed mode, use only the best seeds.",
                                  m_param_useBestNInSeed);
  }

exposeParameters() [12/17]

template<class AResult>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters of the sub findlets.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 25 of file ResultStorer.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "exportTracks"), m_param_exportTracks,
                                  "Export the result tracks into a StoreArray.",
                                  m_param_exportTracks);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "outputRecoTrackStoreArrayName"),
                                  m_param_outputRecoTrackStoreArrayName,
                                  "StoreArray name of the output Track Store Array.");
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "outputRelationRecoTrackStoreArrayName"),
                                  m_param_outputRelationRecoTrackStoreArrayName,
                                  "StoreArray name of the tracks, the output reco tracks should be related to.");
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "writeOutDirection"),
                                  m_param_writeOutDirectionAsString,
                                  "Write out the relations with the direction of the VXD part as weight");
  }

exposeParameters() [13/17]

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the filter.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 32 of file SectorMapBasedSVDPairFilter.cc.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "sectorMapName"), m_param_sectorMapName,
                                  "Name of the sector map to use.", m_param_sectorMapName);
  }

exposeParameters() [14/17]

template<class AResult, class ACluster>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters of the findlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 36 of file SpacePointTagger.icc.h.

  {
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "singleClusterLevel"),
                                  m_param_singleClusterLevel,
                                  "Mark SP as used, if the share a single cluster with the results, or if they "
                                  "share a whole SP.",
                                  m_param_singleClusterLevel);
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "markUsedSpacePoints"),
                                  m_param_markUsedSpacePoints,
                                  "Mark used space points as assigned.",
                                  m_param_markUsedSpacePoints);
  }

exposeParameters() [15/17]

template<class AState>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 28 of file StateCreatorWithReversal.icc.h.

  {
    moduleParamList->addParameter("reverseSeed",
                                  m_param_reverseSeed,
                                  "Reverse the seed.");
  }

exposeParameters() [16/17]

template<class AState, class AFindlet>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 32 of file StateRejecter.icc.h.

  {
    m_firstFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("first", prefix));
    m_advanceFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("advance", prefix));
    m_secondFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("second", prefix));
    m_updateFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("update", prefix));
    m_thirdFilter.exposeParameters(moduleParamList, TrackFindingCDC::prefixed("third", prefix));
  };

exposeParameters() [17/17]

template<class AState, class AStateRejecter, class AResult>

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 32 of file TreeSearcher.icc.h.

  {
    m_stateRejecter.exposeParameters(moduleParamList, prefix);
 
    moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "endEarly"), m_param_endEarly,
                                  "Make it possible to have all subresults in the end result vector.",
                                  m_param_endEarly);
  }

fillInterceptList()

template<class aIntercept>

void fillInterceptList	(	StoreArray< aIntercept > *	listToBeFilled,
		const StoreArray< RecoTrack > &	trackList,
		RelationArray *	recoTrackToIntercepts )

Fill the list of PXD intecepts corresponding to the list of track candidates.

Definition at line 26 of file VXDInterceptor.templateDetails.h.

  {
    for (int i = 0; i < trackList.getEntries(); ++i) { //loop over all tracks
 
      B2DEBUG(20, " %%%%%  track candidate Nr. : " << i + 1);
 
      if (! trackList[i] ->wasFitSuccessful()) {
        B2DEBUG(20, "%%%%% Fit not successful! discard this RecoTrack");
        continue;
      }
 
      // extrapolate track to cylinders (VXD layers)
      for (unsigned int layer = 0; layer < m_layerRadii.size(); layer++) {
        const unsigned int layerOffset = (m_detector == VXD::SensorInfoBase::SVD ? 3 : 1);
 
        B2DEBUG(20, " .fill intercept List, Layer: " << layer + layerOffset);
        // if this ROI / intercept finding is for DQM, only extrapolate backwards, starting from first hit
        // if it's for actual ROI finding (or any other case), extrapolate in both directions, once starting
        // from the first hit extrapolating backwards, and once starting from the last hit extrapolating forwards
        for (short direction : (m_ForDQM ? c_backwards : c_both)) {
          std::list<ROIDetPlane> selectedPlanes;
          genfit::MeasuredStateOnPlane gfTrackState;
          switch (direction) {
            case -1:
              gfTrackState = trackList[i]->getMeasuredStateOnPlaneFromFirstHit();
              break;
            case 1:
              gfTrackState = trackList[i]->getMeasuredStateOnPlaneFromLastHit();
              gfTrackState.setPosMom(gfTrackState.getPos(), -gfTrackState.getMom());
              gfTrackState.setChargeSign(-gfTrackState.getCharge());
              break;
            default:
              break;
          }
 
          try {
            gfTrackState.extrapolateToCylinder(m_layerRadii[layer]);
          } catch (...) {
            B2DEBUG(20, " .-extrapolation to cylinder failed");
            continue;
          }
 
          B2DEBUG(20, " ..append selected planes, position " << gfTrackState.getPos().X() << ", " << gfTrackState.getPos().Y() << ", " <<
                  gfTrackState.getPos().Z());
 
          m_theROIGeometry.appendSelectedPlanes(&selectedPlanes, ROOT::Math::XYZVector(gfTrackState.getPos()), layer + layerOffset);
          B2DEBUG(20, " ...append intercepts for track " << i << "\n"\
                  " ...the size of the selectedPlanes : " << selectedPlanes.size() << "\n"\
                  " ...extrapolating in direction " << direction << " (-1 for backwards from first hit, +1 for forwards from last hit)");
          appendIntercepts(interceptList, selectedPlanes, gfTrackState, i, recoTrackToIntercepts);
        }
 
      } //loop on layers
    } //loop on the track list
 
  } //fillInterceptList

fillRoiIDList()

template<class aIntercept>

void fillRoiIDList	(	StoreArray< aIntercept > *	listOfIntercepts,
		StoreArray< ROIid > *	ROIidList )

Append the ROIid to the list listToBeFilled.

Definition at line 45 of file ROIToUnitTranslator.templateDetails.h.

  {
 
    const VXD::GeoCache& aGeometry = VXD::GeoCache::getInstance();
 
    for (int i = 0; i < listOfIntercepts->getEntries(); i++) {
 
      B2DEBUG(21, "  --->> a NEW INTERCEPT!");
 
 
      const VXD::SensorInfoBase& aSensorInfo = aGeometry.getSensorInfo((*listOfIntercepts)[i]->getSensorID());
 
      double widthTotU = std::min(m_maxWidthU,
                                  sqrt((*listOfIntercepts)[i]->getSigmaU() * (*listOfIntercepts)[i]->getSigmaU() + m_sigmaSystU * m_sigmaSystU) * m_numSigmaTotU);
      double widthTotV = std::min(m_maxWidthV,
                                  sqrt((*listOfIntercepts)[i]->getSigmaV() * (*listOfIntercepts)[i]->getSigmaV() + m_sigmaSystV * m_sigmaSystV) * m_numSigmaTotV);
 
      double minU = (*listOfIntercepts)[i]->getCoorU() - widthTotU / 2 ;
      double maxU = (*listOfIntercepts)[i]->getCoorU() + widthTotU / 2 ;
      const int nUnitsU = aSensorInfo.getUCells() - 1;
 
      double minV = (*listOfIntercepts)[i]->getCoorV() - widthTotV / 2;
      double maxV = (*listOfIntercepts)[i]->getCoorV() + widthTotV / 2;
      const int nUnitsV = aSensorInfo.getVCells() - 1;
 
      const int firstPixelID = 0;
 
      double bottomLeft_uID = aSensorInfo.getUCellID(minU, minV, false);
      double bottomLeft_vID = aSensorInfo.getVCellID(minV, false);
      double topRight_uID = aSensorInfo.getUCellID(maxU, maxV, false);
      double topRight_vID = aSensorInfo.getVCellID(maxV, false);
 
      B2DEBUG(21, "  LAYER = " << VxdID((*listOfIntercepts)[i]->getSensorID()).getLayerNumber()
              << " LADDER = " << VxdID((*listOfIntercepts)[i]->getSensorID()).getLadderNumber()
              << " SENSOR = " << VxdID((*listOfIntercepts)[i]->getSensorID()).getSensorNumber()
             );
 
      B2DEBUG(21, "  number of units (pixel or strip) (U,V) = (" << nUnitsU << "," << nUnitsV << ")");
 
      B2DEBUG(21, "  widthU = " << maxU - minU
              << "  minU = "  << minU
              << "  maxU = "  << maxU
              << "  lengthU = " << aSensorInfo.getUSize((*listOfIntercepts)[i]->getCoorV())
             );
 
      B2DEBUG(21, "  widthV = " << maxV - minV
              << "  minV = " << minV
              << "  maxV = " << maxV
              << "  lengthV = " << aSensorInfo.getVSize());
 
      B2DEBUG(21, "  bottom left unit (pixel or strip) (U,V) = (" << bottomLeft_uID << "," << bottomLeft_vID << ")");
      B2DEBUG(21, "  top right unit (pixel or strip) (U,V) = (" << topRight_uID << "," << topRight_vID << ")");
 
 
      //check that the pixel belong to the sensor
      bool inside = true;
      if (bottomLeft_uID > nUnitsU || topRight_uID < firstPixelID || bottomLeft_vID > nUnitsV || topRight_vID < firstPixelID) {
        B2DEBUG(21, "  OOOPS: this unit (pixel or strip) does NOT belong to the sensor");
        inside = false;
      }
 
      ROIid tmpROIid;
 
      if (inside) {
        tmpROIid.setMinUid(aSensorInfo.getUCellID(minU, minV, true));
        tmpROIid.setMinVid(aSensorInfo.getVCellID(minV, true));
        tmpROIid.setMaxUid(aSensorInfo.getUCellID(maxU, maxV, true));
        tmpROIid.setMaxVid(aSensorInfo.getVCellID(maxV, true));
        tmpROIid.setSensorID((*listOfIntercepts)[i]->getSensorID()) ;
 
        ROIidList->appendNew(tmpROIid);
 
        // this is the pointer to the transient copy of tmpROIid
        ROIid* transientROIid = (*ROIidList)[ROIidList->getEntries() - 1];
 
        (*listOfIntercepts)[i]->addRelationTo(transientROIid);
      }
    }
  }

findWeightInVector()

static bool findWeightInVector ( std::vector< std::pair< int, double > > & vec, double weight )

static

find the given weight in the given vector of pair<int,double> NOTE: the criteria for finding are rather loose (i.e.

actual value and desired value must not differ by more than 1e-4) as the values that are encountered lie rather far apart!

Definition at line 39 of file PurityCalculatorTools.h.

  {
    const double epsilon = 1e-4; // no real need for accuracy here since weights are rather far apart!
    return (std::find_if(vec.begin(), vec.end(),
                         [&epsilon, &weight](const std::pair<int, double>& p)
    { return fabs(p.second - weight) <= epsilon; })
    != vec.end());
  }

fromString()

TrackFindingCDC::EForwardBackward fromString ( const std::string & directionString )

inline

Helper function to turn a direction string into a valid forward backward information.

Definition at line 36 of file SearchDirection.h.

  {
    if (directionString == "forward" or directionString == "above" or directionString == "after") {
      return TrackFindingCDC::EForwardBackward::c_Forward;
    } else if (directionString == "backward" or directionString == "below" or directionString == "before") {
      return TrackFindingCDC::EForwardBackward::c_Backward;
    } else if (directionString == "both" or directionString == "unknown") {
      return TrackFindingCDC::EForwardBackward::c_Unknown;
    } else if (directionString == "none" or directionString == "invalid") {
      return TrackFindingCDC::EForwardBackward::c_Invalid;
    } else {
      B2FATAL("Do not understand direction " << directionString << ". Valid names are " <<
              "forward/above/after, backward/below/before, both/unknown, none/invalid");
    }
  }

getAccessorsFromWeight()

static std::vector< size_t > getAccessorsFromWeight ( double weight )

static

convert the relation weight (SpacePoint <-> TrueHit) to a type that can be used to access arrays

Definition at line 132 of file PurityCalculatorTools.h.

  {
    if (weight < 1.5 && weight > 0) return {0}; // weight 1 -> PXD
    if (weight < 2.5 && weight > 0) return { 1, 2 }; // weight 2 -> both Clusters with relation to MCParticle
    if (weight < 20 && weight > 0) return {1}; // weight 11 -> only U-Cluster related to MCParticle
    if (weight > 20 && weight < 30) return {2}; // weight 21 -> only V-Cluster related to MCParticle
 
    return std::vector<size_t>(); // empty vector else
  }

getAllValues()

template<typename MapType>

std::vector< typename MapType::mapped_type > getAllValues

(

const MapType &

aMap

)

get all values in the map (i.e.

dump out all values that are stored in the map). The connection to the keys is lost! TODO: write test for this!!!!

Definition at line 133 of file MapHelperFunctions.h.

  {
    typedef typename MapType::key_type keyT;
    std::vector<keyT> allKeys = getUniqueKeys(aMap);
 
    typedef typename MapType::mapped_type valueT;
    std::vector<valueT> allValues;
    for (const keyT& key : allKeys) {
      std::vector<valueT> keyValues = getValuesToKey(aMap, key);
      for (const valueT& value : keyValues) {
        allValues.push_back(value);
      }
    }
 
    return allValues;
  }

getClassMnemomicParameterDescription() [1/2]

std::string getClassMnemomicParameterDescription ( const RecoTrack * dispatchTag )

inline

Returns a short description for class RecoTrack to be used in descriptions of parameters.

Definition at line 31 of file ClassMnemomics.h.

  {
    return "Reco Track";
  }

getClassMnemomicParameterDescription() [2/2]

std::string getClassMnemomicParameterDescription ( const SpacePoint * dispatchTag )

inline

Returns a short description for class SpacePoint to be used in descriptions of parameters.

Definition at line 43 of file ClassMnemomics.h.

  {
    return "Space Point";
  }

getClassMnemomicParameterName() [1/2]

std::string getClassMnemomicParameterName ( const RecoTrack * dispatchTag )

inline

Returns a short name for class RecoTrack to be used in names of parameters.

Definition at line 25 of file ClassMnemomics.h.

  {
    return "recoTrack";
  }

getClassMnemomicParameterName() [2/2]

std::string getClassMnemomicParameterName ( const SpacePoint * dispatchTag )

inline

Returns a short name for class SpacePoint to be used in names of parameters.

Definition at line 37 of file ClassMnemomics.h.

  {
    return "spacePoint";
  }

getMatrix()

const TMatrixD & getMatrix ( ) const

override

Return the underlying matrix.

Definition at line 23 of file HMatrixQP.cc.

  {
    static const double HMatrixContent[5] = {1, 0, 0, 0, 0};
 
    static const TMatrixD HMatrix(1, 5, HMatrixContent);
 
    return HMatrix;
  }

getMCParticles()

template<typename TrueHitType>

static std::vector< std::pair< int, double > > getMCParticles ( const Belle2::SpacePoint * spacePoint )

static

get the related MCParticles to the TrueHit.

Returns

vector of pairs, where .first is the MCParticleId, which is -1 if there was no MCParticle related to a TrueHit and -2 if there is a Cluster without a relation to a TrueHit (probably a noise Cluster then) .second is the relation weight between SpacePoint and TrueHit (encodes additional information that is needed afterwards)

Definition at line 55 of file PurityCalculatorTools.h.

  {
    // CAUTION: getting all TrueHits here (i.e. from all StoreArrays)
    Belle2::RelationVector<TrueHitType> trueHits = spacePoint->getRelationsTo<TrueHitType>("ALL");
    std::vector<std::pair<int, double> > mcParticles;
    B2DEBUG(29, "Found " << trueHits.size() << " TrueHits related to SpacePoint " << spacePoint->getArrayIndex());
 
    for (size_t iTH = 0; iTH < trueHits.size(); ++iTH) {
      B2DEBUG(29, "Trying to get MCParticles from TrueHit " << trueHits[iTH]->getArrayIndex() <<
              " from Array " << trueHits[iTH]->getArrayName());
      Belle2::MCParticle* mcPart = trueHits[iTH]->template getRelatedFrom<Belle2::MCParticle>("ALL");
 
      int mcPartId = -1; // default value for MCPartId (not found)
      if (mcPart != nullptr) {
        mcPartId = mcPart->getArrayIndex();
        B2DEBUG(29, "TrueHit is related to MCParticle " << mcPartId);
      } else {
        B2DEBUG(20, "Found no MCParticle related to TrueHit " << trueHits[iTH]->getArrayIndex() <<
                " from Array " << trueHits[iTH]->getArrayName());
      }
      mcParticles.push_back(std::make_pair(mcPartId, trueHits.weight(iTH)));
    }
 
    // sort & unique to filter out double MCIds (if the relations are set correct, this only happens if more than one TrueHits point to the same MCParticle)
    std::sort(mcParticles.begin(), mcParticles.end());
    auto newEnd = std::unique(mcParticles.begin(), mcParticles.end(),
    [](const std::pair<int, double>& a, const std::pair<int, double>& b) { return a.first == b.first; }
                             );
    if (newEnd != mcParticles.end()) B2DEBUG(20,
                                               "More than one TrueHits (related to one SpacePoint) are related to the same MCParticle!");
    mcParticles.resize(std::distance(mcParticles.begin(), newEnd));
 
    // check if there were noise Clusters in the SpacePoint
    // only case left for PXD is missing TrueHit for underlying Cluster, everything else is covered!
    if (spacePoint->getType() == VXD::SensorInfoBase::PXD) {
      if (mcParticles.empty()) mcParticles.push_back(std::make_pair(-2, 1)); // if no Id in vector there is no relation to TrueHit
    } else  if (spacePoint->getType() == VXD::SensorInfoBase::SVD) { // for SVD some more tests are needed!
      // check if there is one MCParticle that is related to both Clusters of the SpacePoint
      if (!findWeightInVector(mcParticles, 2)) { // if not both related check which ones should have a relation and act accordingly
        const std::pair<bool, bool>& clusters = spacePoint->getIfClustersAssigned();
        bool uGood = clusters.first && findWeightInVector(mcParticles, 11);
        bool vGood = clusters.second && findWeightInVector(mcParticles, 21);
        if (!uGood && !vGood) mcParticles.push_back(std::make_pair(-2, 2)); // if both Clusters are not related -> weight is 2
        else if (uGood && !vGood) mcParticles.push_back(std::make_pair(-2, 21)); // if only V-Cluster is not related -> weight is 21
        else if (!uGood && vGood) mcParticles.push_back(std::make_pair(-2, 11)); // if only U-Cluster is not related -> weight is 11
      }
    } else {
      B2ERROR("Unknown DetectorType in getMCParticles! This is just a notification! Needs to be handled!"); // should not happen
    }
 
    return mcParticles;
  }

getNValuesPerKey()

template<typename MapType>

std::vector< std::pair< typename MapType::key_type, unsigned int > > getNValuesPerKey

(

const MapType &

aMap

)

get the unique keys of a map together with the number of values associated to each key.

first elements are keys, second are number of values NOTE: for a non-multimap this returns all keys with a .second of 1!

Definition at line 58 of file MapHelperFunctions.h.

  {
    typedef typename MapType::key_type keyT;
    typedef typename MapType::const_iterator mapIter;
 
    std::vector<std::pair<keyT, unsigned int> > valuesPerKey;
    if (aMap.empty()) return valuesPerKey; // return empty vector if map is empty
 
    std::vector<keyT> uniqueKeys = getUniqueKeys<MapType>(aMap);
 
    for (keyT key : uniqueKeys) {
      std::pair<mapIter, mapIter> keyRange = aMap.equal_range(key);
      valuesPerKey.push_back(std::make_pair(key, std::distance(keyRange.first, keyRange.second)));
    }
    return valuesPerKey;
  }

getPossibleTos() [1/2]

template<class AFilter, class APrefilter>

std::vector< CKFToPXDState * > getPossibleTos ( CKFToPXDState * from, const std::vector< CKFToPXDState * > & states ) const

overridevirtual

Return all states the given state is possible related to.

Reimplemented from RelationFilter< CKFToPXDState >.

Definition at line 89 of file LayerPXDRelationFilter.icc.h.

  {
    std::vector<CKFToPXDState*> possibleNextStates;
 
    const CKFToPXDState::stateCache& currentStateCache = currentState->getStateCache();
    const unsigned int& currentLayer = currentStateCache.geoLayer;
 
    // this is the parameter value set in the python config
    int m_hitJump = m_param_hitJumping;
    // if it is set to -1 we want to use the values in the payload
    if (m_hitJump == -1) {
      m_hitJump = currentStateCache.ptSeed < m_layerJumpPtThreshold ? m_layerJumpLowPt : m_layerJumpHighPt;
    }
 
    const unsigned int& nextPossibleLayer = std::max(static_cast<int>(currentLayer) - 1 - m_hitJump, 0);
 
    // Patch for the PXD layer 2 overlap inefficiency fix
    // previous implementation of maximumLadderNumber was calculated using GeoCache gave incorrect value for exp1003
    // Geometrically, PXD layer 1 has 8 ladders, pxd layer 2 has 12 ladder
    int numberOfLaddersForLayer[2] = {8, 12};
 
    for (CKFToPXDState* nextState : states) {
      const CKFToPXDState::stateCache& nextStateCache = nextState->getStateCache();
      const unsigned int nextLayer = nextStateCache.geoLayer;
      if (nextLayer < std::min(currentLayer, nextPossibleLayer) or std::max(currentLayer, nextPossibleLayer) < nextLayer) {
        continue;
      }
 
      if (currentLayer == nextLayer) {
        // next layer is an overlap one, so lets return all hits from the same layer, that are on a
        // ladder which is below the last added hit.
        const unsigned int fromLadderNumber = currentStateCache.ladder;
        const unsigned int maximumLadderNumber = numberOfLaddersForLayer[currentLayer - 1];
 
        // the reason for this strange formula is the numbering scheme in the VXD.
        // we first subtract 1 from the ladder number to have a ladder counting from 0 to N - 1,
        // then we add (PXD)/subtract(PXD) one to get to the next (overlapping) ladder and do a % N to also cope for the
        // highest number. Then we add 1 again, to go from the counting from 0 .. N-1 to 1 .. N.
        // The + maximumLadderNumber in between makes sure, we are not ending with negative numbers
        const int direction = 1;
        const unsigned int overlappingLadder =
          ((fromLadderNumber + maximumLadderNumber - 1) + direction) % maximumLadderNumber + 1;
 
        if (nextStateCache.ladder != overlappingLadder) {
          continue;
        }
 
        // Next we make sure to not have any cycles in our graph: we do this by defining only the halves of the
        // sensor as overlapping. So if the first hit is coming from sensor 1 and the second from sensor 2,
        // they are only related if the one from sensor 1 is on the half, that is pointing towards sensor 2
        // and the one on sensor 2 is on the half that is pointing towards sensor 1.
        //
        //                       X                            X                               X
        //                      ----|----                    ----|----                ----|----
        //  This is fine:       X           This not:    X             This not:        X
        //                ----|----                    ----|----                 ----|----
 
        // for PXD its the other way round!
        if (currentStateCache.localNormalizedu <= 0.8f) {
          continue;
        }
 
        if (nextStateCache.localNormalizedu > 0.2f) {
          continue;
        }
      }
 
      // Some loose prefiltering of possible states
      TrackFindingCDC::Weight weight = m_prefilter(std::make_pair(currentState, nextState));
      if (std::isnan(weight)) {
        continue;
      }
 
      possibleNextStates.push_back(nextState);
    }
 
    return possibleNextStates;
  }

getPossibleTos() [2/2]

template<class AFilter, class APrefilter>

std::vector< CKFToSVDState * > getPossibleTos ( CKFToSVDState * from, const std::vector< CKFToSVDState * > & states ) const

finalvirtual

Return all states the given state is possible related to.

Reimplemented from RelationFilter< CKFToSVDState >.

Definition at line 50 of file LayerSVDRelationFilter.icc.h.

  {
    std::vector<CKFToSVDState*> possibleNextStates;
    possibleNextStates.reserve(states.size());
 
    const CKFToSVDState::stateCache& currentStateCache = currentState->getStateCache();
    const unsigned int currentLayer = currentStateCache.geoLayer;
    const unsigned int nextPossibleLayer = std::max(static_cast<int>(currentLayer) - 1 - m_param_hitJumping, 0);
 
    for (CKFToSVDState* nextState : states) {
      if (currentState == nextState) {
        continue;
      }
 
      const CKFToSVDState::stateCache& nextStateCache = nextState->getStateCache();
      const unsigned int nextLayer = nextStateCache.geoLayer;
 
      if (std::max(currentLayer, nextPossibleLayer) >= nextLayer and nextLayer >= std::min(currentLayer, nextPossibleLayer)) {
 
        if (currentLayer == nextLayer) {
          // next layer is an overlap one, so lets return all hits from the same layer, that are on a
          // ladder which is below the last added hit.
          const unsigned int fromLadderNumber = currentStateCache.ladder;
          const unsigned int maximumLadderNumber = m_maximalLadderCache.find(currentLayer)->second;
 
          // the reason for this strange formula is the numbering scheme in the VXD.
          // we first subtract 1 from the ladder number to have a ladder counting from 0 to N - 1,
          // then we add (PXD)/subtract(SVD) one to get to the next (overlapping) ladder and do a % N to also cope for the
          // highest number. Then we add 1 again, to go from the counting from 0 .. N-1 to 1 .. N.
          // The + maximumLadderNumber in between makes sure, we are not ending with negative numbers
          const int direction = -1;
          const unsigned int overlappingLadder =
            ((fromLadderNumber + maximumLadderNumber - 1) + direction) % maximumLadderNumber + 1;
 
          if (nextStateCache.ladder != overlappingLadder) {
            continue;
          }
 
          // Next we make sure to not have any cycles in our graph: we do this by defining only the halves of the
          // sensor as overlapping. So if the first hit is coming from sensor 1 and the second from sensor 2,
          // they are only related if the one from sensor 1 is on the half, that is pointing towards sensor 2
          // and the one on sensor 2 is on the half that is pointing towards sensor 1.
          //
          //                       X                         X                         X
          //               ----|----                    ----|----                    ----|----
          //  This is fine:         X        This not:                X   This not:          X
          //                      ----|----                    ----|----                    ----|----
          if (currentStateCache.localNormalizedu > 0.2f) {
            continue;
          }
 
          if (nextStateCache.localNormalizedu <= 0.8f) {
            continue;
          }
        }
 
        // Some loose prefiltering of possible states
        TrackFindingCDC::Weight weight = m_prefilter(std::make_pair(currentState, nextState));
        if (std::isnan(weight)) {
          continue;
        }
 
 
        possibleNextStates.push_back(nextState);
      }
    }
 
    return possibleNextStates;
  }

getSortedKeyValueTuples()

template<typename MapType>

std::vector< std::tuple< typename MapType::key_type, typename MapType::mapped_type, unsigned int > > getSortedKeyValueTuples

(

const MapType &

aMap

)

get the (key, value, number of values) tuples stored in the map, sorted after the following scheme (descending order) 1) the number of associated values to one key 2) the sum of the associated values to that key NOTE: for a non-multimap this returns the content of the map ordered by valued CAUTION: if one of the values to a key is NaN this key will be the first (of the ones with the same number of associated values)

Returns

a vector of tuples where get<0> is the key, get<1> is the sum of the values to the key and get<2> is the number of values to the key

Definition at line 102 of file MapHelperFunctions.h.

  {
    typedef typename MapType::key_type keyT;
    typedef typename MapType::mapped_type mapT;
 
    std::vector<std::tuple<keyT, mapT, unsigned int> > keyValuePairs;
    if (aMap.empty()) return keyValuePairs; // return empty vector if nothing is stored in map
 
    std::vector<std::pair<keyT, unsigned int> > nValuesPerKey = getNValuesPerKey(aMap);
 
    for (std::pair<keyT, unsigned int> keyValues : nValuesPerKey) {
      std::vector<mapT> valuesToKey = getValuesToKey(aMap, keyValues.first);
 
      mapT valueSum = std::accumulate(valuesToKey.begin(), valuesToKey.end(), 0.0);
      keyValuePairs.push_back(std::make_tuple(keyValues.first, valueSum, keyValues.second));
    }
 
    // sort using a lambda function (using std::tie as std::tuple has a defined operator < that ensures strict weak ordering)
    std::sort(keyValuePairs.begin(), keyValuePairs.end(),
              [](const std::tuple<keyT, mapT, unsigned int>& lTuple, const std::tuple<keyT, mapT, unsigned int>& rTuple)
    { return std::tie(std::get<2>(rTuple), std::get<1>(rTuple)) < std::tie(std::get<2>(lTuple), std::get<1>(lTuple)); }
             );
 
    return keyValuePairs;
  }

getUniqueKeys()

template<typename MapType>

std::vector< typename MapType::key_type > getUniqueKeys

(

const MapType &

aMap

)

get the unique keys of a map (i.e.

if no multimap is passed all keys are returned) NOTE: for this to work the keys have to have a defined operator < () as std::sort is used! NOTE: as a side effect the keys are returned sorted!

Definition at line 32 of file MapHelperFunctions.h.

  {
    std::vector<typename MapType::key_type> allKeys; // collect all keys of the map -> then sort & unique (+resize)
    if (aMap.empty()) { return allKeys; }
 
    typedef typename MapType::const_iterator mapIter;
    for (mapIter it = aMap.begin(); it != aMap.end(); ++it) { allKeys.push_back(it->first); }
    std::sort(allKeys.begin(), allKeys.end());
    auto newEnd = std::unique(allKeys.begin(), allKeys.end());
    allKeys.resize(std::distance(allKeys.begin(), newEnd));
 
    return allKeys;
  }

getUniqueSize()

template<typename MapType>

unsigned int getUniqueSize

(

const MapType &

aMap

)

get the number of unique keys inside the map NOTE: for non-multimap this is the same as .size()

Definition at line 51 of file MapHelperFunctions.h.

{ return getUniqueKeys<MapType>(aMap).size(); }

getValuesToKey()

template<typename MapType>

std::vector< typename MapType::mapped_type > getValuesToKey	(	const MapType &	aMap,
		typename MapType::key_type	aKey )

get all values stored in the map for a given key

Definition at line 79 of file MapHelperFunctions.h.

  {
    typedef typename MapType::const_iterator mapIter;
 
    std::vector<typename MapType::mapped_type> values;
    if (aMap.empty()) return values;
 
    std::pair<mapIter, mapIter> keyRange = aMap.equal_range(aKey);
    for (mapIter it = keyRange.first; it != keyRange.second; ++it) { values.push_back(it->second); }
 
    return values;
  }

GridEventTimeExtractor()

template<class AFindlet>

GridEventTimeExtractor

(

)

Add the subfindlet as listener.

Definition at line 23 of file GridEventTimeExtractor.icc.h.

  {
    Super::addProcessingSignalListener(&m_findlet);
  }

HMHt()

void HMHt ( TMatrixDSym & M ) const

override

Calculate H * M * H^T = M_00.

Definition at line 73 of file HMatrixQP.cc.

  {
    assert(M.GetNrows() == 5);
    // Just use the 0,0 entry
    M.ResizeTo(1, 1);
  }

Hv()

TVectorD Hv ( const TVectorD & v ) const

override

Calculate H * v = v_0.

Definition at line 33 of file HMatrixQP.cc.

  {
    assert(v.GetNrows() == 5);
 
    TVectorD returnValue(1);
 
    returnValue(0) = v(0);
 
    return returnValue;
  }

increaseClusterCounters()

static void increaseClusterCounters ( const Belle2::SpacePoint * spacePoint, std::array< unsigned, 3 > & clusterCtr )

static

increase the appropriate Cluster counter by asking the SpacePoint which type he has and which Clusters are assigned

Definition at line 111 of file PurityCalculatorTools.h.

  {
    if (spacePoint->getType() == Belle2::VXD::SensorInfoBase::PXD) {
      clusterCtr[0]++;
      B2DEBUG(29, "SpacePoint contains PXDCluster");
    } else {
      std::pair<bool, bool> setClusters = spacePoint->getIfClustersAssigned();
      if (setClusters.first) {
        clusterCtr[1]++;
        B2DEBUG(29, "SpacePoint contains U SVDCluster");
      }
      if (setClusters.second) {
        clusterCtr[2]++;
        B2DEBUG(29, "SpacePoint contains V SVDCluster");
      }
    }
  }

initialize() [1/4]

template<class ... AIOTypes>

void initialize ( )

overridevirtual

Initialize the event t0 store obj ptr.

Reimplemented from ProcessingSignalListener.

Reimplemented in HitBasedT0Extractor.

Definition at line 38 of file BaseEventTimeExtractor.icc.h.

  {
    Super::initialize();
    m_eventT0.registerInDataStore();
  }

initialize() [2/4]

template<class AFilter, class APrefilter>

void initialize ( )

overridevirtual

Receive and dispatch signal before the start of the event processing.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 47 of file LayerPXDRelationFilter.icc.h.

  {
    Super::initialize();
 
    if (m_prefix == "seed") {
      m_ckfParameters = std::make_unique<OptionalDBObjPtr<CKFParameters>>("PXDCKFSeedHitParameters");
    } else if (m_prefix == "hit") {
      m_ckfParameters = std::make_unique<OptionalDBObjPtr<CKFParameters>>("PXDCKFHitHitParameters");
    } else {
      B2ERROR("Unknown prefix. Apparently, some non-trivial changes to code were done.");
    }
  }

initialize() [3/4]

template<class AllStateFilter>

void initialize ( )

final

Copy the string direction parameter to the enum.

Definition at line 78 of file NonIPCrossingStateFilter.icc.h.

  {
    Super::initialize();
    m_param_direction = fromString(m_param_directionAsString);
  }

initialize() [4/4]

template<class AResult>

void initialize ( )

overridevirtual

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 45 of file ResultStorer.icc.h.

  {
    Super::initialize();
 
    if (not m_param_exportTracks) {
      return;
    }
 
    m_outputRecoTracks.registerInDataStore(m_param_outputRecoTrackStoreArrayName);
    RecoTrack::registerRequiredRelations(m_outputRecoTracks);
 
    StoreArray<RecoTrack> relationRecoTracks(m_param_outputRelationRecoTrackStoreArrayName);
    relationRecoTracks.registerRelationTo(m_outputRecoTracks);
 
    m_param_writeOutDirection = fromString(m_param_writeOutDirectionAsString);
  }

initializeObservers() [1/3]

template<class Variable, class RangeType, class observer, typename ... argsTypes>

bool initializeObservers	(	const Belle2::Filter< Variable, RangeType, observer > &	filter,
		argsTypes ...	args )

Initialize the observer of a RangeType Filter.

Template Parameters

Variable	: Filter variable type
RangeType	: range type
observer	: observer type to be used
argsTypes	: argument types of the filter

Parameters

filter	: Filter for which the observer shall be initialized
args	: arguments of the filter

Returns

boolean to indicate if the observer has been initialized

Definition at line 985 of file Filter.h.

  {
    return observer::initialize(Variable(), filter.getRange(), args ...);
  }

initializeObservers() [2/3]

template<class booleanBinaryOperator, typename ... types1, typename ... types2, class observer, typename ... argsTypes>

bool initializeObservers	(	const Filter< booleanBinaryOperator, Belle2::Filter< types1... >, Belle2::Filter< types2... >, observer > &	,
		argsTypes ...	args )

Observer Stuff ///.

Recursive function to initialize all the observers in a binary boolean Filter.

Template Parameters

booleanBinaryOperator	: Tag Class to identify the Filter operator
types1	: template pack of a filter
types2	: template pack of another filter
observer	: observer type to be used
argsTypes	: argument types of the filter

Parameters

args	: arguments of the filter

Returns

boolean to indicate if the observer has been initialized

Definition at line 947 of file Filter.h.

  {
    return observer::initialize(args ...)
           && initializeObservers(Belle2::Filter<types1...>(), args...)
           && initializeObservers(Belle2::Filter<types2...>(), args ...);
  }

initializeObservers() [3/3]

template<class booleanUnaryOperator, typename ... types1, class observer, typename ... argsTypes>

bool initializeObservers	(	const Filter< booleanUnaryOperator, Belle2::Filter< types1... >, observer > &	,
		argsTypes ...	args )

Recursive function to initialize all the observers in a unary boolean Filter.

Template Parameters

booleanUnaryOperator	: Tag Class to identify the Filter operator
types1	: template pack of the filter
observer	: observer type to be used
argsTypes	: argument types of the filter

Parameters

args	: arguments of the filter

Returns

boolean to indicate if the observer has been initialized

Definition at line 969 of file Filter.h.

  {
    return observer::initialize(args ...) && initializeObservers(Belle2::Filter<types1...>(), args...);
  }

insertSpacePoint()

void insertSpacePoint ( std::vector< const SpacePoint * > & target, TrackNode source )

inline

Convert TrackNode to SpaePoint an add to a SpacePoint path.

Definition at line 44 of file NetworkPathConversion.h.

  {
    target.push_back(source.m_spacePoint);
  }

insertSpacePoints()

void insertSpacePoints ( std::vector< const SpacePoint * > & target, const Segment< TrackNode > & source )

inline

Insert of inner and outer TrackNodes of a Segment as SpacePoints into path of SpacePoints.

Definition at line 51 of file NetworkPathConversion.h.

  {
    if (target.empty()) {
      insertSpacePoint(target, *(source.getInnerHit()));
      insertSpacePoint(target, *(source.getOuterHit()));
    } else {
      insertSpacePoint(target, *(source.getOuterHit()));
    }
  }

IterativeEventTimeExtractor()

template<class AFindlet>

IterativeEventTimeExtractor

(

)

Add the subfindlet as listener.

Definition at line 23 of file IterativeEventTimeExtractor.icc.h.

  {
    Super::addProcessingSignalListener(&m_findlet);
  }

LayerPXDRelationFilter()

template<class AFilter, class APrefilter>

LayerPXDRelationFilter

(

)

Add the filter as listener.

Definition at line 24 of file LayerPXDRelationFilter.icc.h.

                                                                      : Super()
  {
    Super::addProcessingSignalListener(&m_filter);
    Super::addProcessingSignalListener(&m_prefilter);
  }

LayerSVDRelationFilter()

template<class AFilter, class APrefilter>

LayerSVDRelationFilter

(

)

Add the filter as listener.

Definition at line 26 of file LayerSVDRelationFilter.icc.h.

                                                                      : Super()
  {
    Super::addProcessingSignalListener(&m_filter);
    Super::addProcessingSignalListener(&m_prefilter);
  }

LayerToggledApplier()

template<class AState, class AFindlet>

LayerToggledApplier

(

)

Add the subfilters as listeners.

Definition at line 22 of file LayerToggledApplier.icc.h.

                                                             : Super()
  {
    Super::addProcessingSignalListener(&m_highLayerFindlet);
    Super::addProcessingSignalListener(&m_equalLayerFindlet);
    Super::addProcessingSignalListener(&m_lowLayerFindlet);
  }

LimitedOnStateApplier()

template<class AState, class AFilter>

LimitedOnStateApplier

(

)

Constructor adding the findlet as a listener.

Definition at line 24 of file LimitedOnStateApplier.icc.h.

  {
    this->addProcessingSignalListener(&m_filter);
  };

MHt() [1/2]

TMatrixD MHt ( const TMatrixD & M ) const

override

Calculate M * H^T = first column of M.

Definition at line 59 of file HMatrixQP.cc.

  {
    assert(M.GetNcols() == 5);
 
    TMatrixD returnMatrix(M.GetNrows(), 1);
 
    for (int i = 0; i < M.GetNrows(); ++i) {
      returnMatrix(i, 0) = M(0, i);
    }
 
    return returnMatrix;
  }

MHt() [2/2]

TMatrixD MHt ( const TMatrixDSym & M ) const

override

Calculate M * H^T = first column of M.

Definition at line 45 of file HMatrixQP.cc.

  {
    assert(M.GetNcols() == 5);
 
    TMatrixD returnVector(5, 1);
 
    for (unsigned int i = 0; i < 5; ++i) {
      returnVector(i, 0) = M(0, i);
    }
 
    return returnVector;
  }

operator!()

template<typename ... types>

Filter< OperatorNot, Filter< types... >, VoidObserver > operator!

(

const Filter< types... > &

filter

)

Definition of the NOT operator !

for the Filter class

Template Parameters

types

: template pack defining the filter

Parameters

filter

: filter to which the NOT operator shall be added

Returns

!filter, so a filter with NOT operator attached

Definition at line 583 of file Filter.h.

  {
    return Filter<OperatorNot, Filter<types...>, VoidObserver>(filter);
  }

operator&&()

template<typename ... types1, typename ... types2>

Filter< Belle2::OperatorAnd, Belle2::Filter< types1... >, Belle2::Filter< types2... >, Belle2::VoidObserver > operator&&	(	const Filter< types1... > &	filter1,
		const Filter< types2... > &	filter2 )

Definition of the boolean AND operator && of the Filter class.

Template Parameters

types1	: template pack of filter A
types2	: template pack of filter B

Parameters

filter1	: filter A
filter2	: filter B

Returns

Boolean AND combination of the two filters

Definition at line 753 of file Filter.h.

  {
    return Filter<OperatorAnd, Filter<types1...>, Filter<types2...>, VoidObserver> (filter1, filter2);
  }

operator()() [1/6]

template<class AFilter, class APrefilter>

TrackFindingCDC::Weight operator() ( const CKFToPXDState & from, const CKFToPXDState & to )

overridevirtual

Give a final weight to the possibilities by asking the filter.

Reimplemented from RelationFilter< CKFToPXDState >.

Definition at line 170 of file LayerPXDRelationFilter.icc.h.

  {
    return m_filter(std::make_pair(&from, &to));
  }

operator()() [2/6]

template<class AFilter, class APrefilter>

TrackFindingCDC::Weight operator() ( const CKFToSVDState & from, const CKFToSVDState & to )

finalvirtual

Give a final weight to the possibilities by asking the filter.

Reimplemented from RelationFilter< CKFToSVDState >.

Definition at line 132 of file LayerSVDRelationFilter.icc.h.

  {
    return m_filter(std::make_pair(&from, &to));
  }

operator()() [3/6]

template<class AState, class AFilter>

TrackFindingCDC::Weight operator() ( const Object & object )

overridevirtual

Copy the filter operator to this method.

Reimplemented from OnStateApplier< AState >.

Definition at line 42 of file LimitedOnStateApplier.icc.h.

  {
    return m_filter(object);
  };

operator()() [4/6]

template<class AllStateFilter>

TrackFindingCDC::Weight operator() ( const Object & pair )

final

Main function testing the object for the direction.

Definition at line 27 of file NonIPCrossingStateFilter.icc.h.

  {
    if (std::isnan(AllStateFilter::operator()(pair))) {
      return NAN;
    }
 
    const auto& previousStates = pair.first;
    auto* state = pair.second;
 
    const RecoTrack* cdcTrack = previousStates.front()->getSeed();
    B2ASSERT("Path without seed?", cdcTrack);
 
    const SpacePoint* spacePoint = state->getHit();
    B2ASSERT("Path without hit?", spacePoint);
 
    const genfit::MeasuredStateOnPlane& firstMeasurement = [&state, &previousStates]() {
      if (state->mSoPSet()) {
        return state->getMeasuredStateOnPlane();
      } else {
        B2ASSERT("Previous state was not fitted?", previousStates.back()->mSoPSet());
        return previousStates.back()->getMeasuredStateOnPlane();
      }
    }();
 
    const TrackFindingCDC::Vector3D& position = static_cast<TrackFindingCDC::Vector3D>(firstMeasurement.getPos());
    const TrackFindingCDC::Vector3D& momentum = static_cast<TrackFindingCDC::Vector3D>(firstMeasurement.getMom());
 
    const TrackFindingCDC::CDCTrajectory2D trajectory2D(position.xy(), 0, momentum.xy(), cdcTrack->getChargeSeed());
 
    const TrackFindingCDC::Vector3D& hitPosition = static_cast<TrackFindingCDC::Vector3D>(spacePoint->getPosition());
    const TrackFindingCDC::Vector2D origin(0, 0);
 
    const double deltaArcLengthHitOrigin = trajectory2D.calcArcLength2DBetween(hitPosition.xy(), origin);
    const double deltaArcLengthTrackHit = trajectory2D.calcArcLength2D(hitPosition.xy());
 
    if (not arcLengthInRightDirection(deltaArcLengthTrackHit, m_param_direction) or
        not arcLengthInRightDirection(deltaArcLengthHitOrigin, m_param_direction)) {
      return NAN;
    }
 
    return 1.0;
  }

operator()() [5/6]

template<class AState>

TrackFindingCDC::Weight operator() ( const Object & object )

virtual

The filter operator for this class.

Reimplemented in LimitedOnStateApplier< AState, AFilter >.

Definition at line 37 of file OnStateApplier.icc.h.

  {
    return NAN;
  };

operator()() [6/6]

TrackFindingCDC::Weight operator() ( const std::pair< const CKFToSVDState *, const CKFToSVDState * > & relation )

override

Give a final weight to the possibilities by asking the filter.

Definition at line 38 of file SectorMapBasedSVDPairFilter.cc.

  {
    const CKFToSVDState* fromState = relation.first;
    const CKFToSVDState* toState = relation.second;
 
    B2ASSERT("From and to state must be set", fromState and toState);
 
    const CKFToSVDState::stateCache& outerStateCache = fromState->getStateCache();
    const CKFToSVDState::stateCache& innerStateCache = toState->getStateCache();
 
    B2ASSERT("Both hits must be present!", outerStateCache.isHitState and innerStateCache.isHitState);
 
    // TODO maybe it would be better to look for the full IDs first; maybe not
    B2ASSERT("Outer hit is invalid",
             m_vxdtfFilters->areCoordinatesValid(outerStateCache.sensorID, outerStateCache.localNormalizedu, outerStateCache.localNormalizedv));
    B2ASSERT("Inner hit is invalid",
             m_vxdtfFilters->areCoordinatesValid(innerStateCache.sensorID, innerStateCache.localNormalizedu, innerStateCache.localNormalizedv));
 
    FullSecID outerSecID = m_vxdtfFilters->getFullID(outerStateCache.sensorID, outerStateCache.localNormalizedu,
                                                     outerStateCache.localNormalizedv);
    FullSecID innerSecID = m_vxdtfFilters->getFullID(innerStateCache.sensorID, innerStateCache.localNormalizedu,
                                                     innerStateCache.localNormalizedv);
 
    const auto* outerStaticSector = m_vxdtfFilters->getStaticSector(outerSecID);
 
    const auto* filter = outerStaticSector->getFilter2sp(innerSecID);
    if (not filter) {
      return NAN;
    }
 
    const SpacePoint* outerHit = fromState->getHit();
    const SpacePoint* innerHit = toState->getHit();
 
    if (not filter->accept(*outerHit, *innerHit)) {
      return NAN;
    }
 
    B2INFO(outerSecID.getVxdID() << " -> " << innerSecID.getVxdID());
    return 1;
  }

operator<() [1/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, LowerBoundedSet< Arithmetic >, VoidObserver > >::type operator<	(	Arithmetic	lowerBound,
		const Var &	)

Creates a Filters with an lower bound > on the provided variable lowerBound < Var.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

lowerBound

: lower bound value to be checked by the filter

Returns

the created filter

Definition at line 171 of file Shortcuts.h.

  {
    return Filter<Var, LowerBoundedSet<Arithmetic>, VoidObserver>(LowerBoundedSet<Arithmetic> (lowerBound));
  }

operator<() [2/3]

template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, Range< ArithmeticLower, ArithmeticUpper >, Observer > >::type operator<	(	const Filter< Var, LowerBoundedSet< ArithmeticLower >, Observer > &	filter,
		ArithmeticUpper	upperBound )

Adding upper bound to filter with lower bound to create a filter with an allowed range between lower and upper bound.

(Var with lowerBound) < upperBound

Template Parameters

Var	: variable type to be used for the filter
ArithmeticLower	: type of lower bound
ArithmeticUpper	: type of upper bound
Observer	: observer type

Parameters

filter	: filter with lower bound to which the upper bound shall be added
upperBound	: value of upper bound

Returns

filter with range allowing values between lower and upper bound

Definition at line 255 of file Shortcuts.h.

  {
    return Filter<Var, Range<ArithmeticLower, ArithmeticUpper>, Observer>
           (Range<ArithmeticLower, ArithmeticUpper> (filter.getRange().getInf(), upperBound));
  }

operator<() [3/3]

template<class Var, class Arithmetic, typename ... types>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, UpperBoundedSet< Arithmetic >, VoidObserver > >::type operator<	(	const Var &	,
		Arithmetic	upperBound )

Creates a Filters with an upper bound < on the provided variable Var < lowerBound.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function
types	: other types

Parameters

upperBound

: upper bound value to be checked by the filter

Returns

the created filter

Definition at line 48 of file Shortcuts.h.

  {
    return Filter<Var, UpperBoundedSet<Arithmetic>, VoidObserver>(UpperBoundedSet<Arithmetic> (upperBound));
  }

operator<<() [1/2]

std::ostream & operator<<	(	std::ostream &	output,
		const CDCCKFPath &	path )

Output operator for the collection of CDC CKF-algorithm states.

Definition at line 15 of file CDCCKFPath.cc.

  {
    output << "[";
    for (const auto& state : path) {
      output << state << ", ";
    }
    output << "]";
    return output;
  }

operator<<() [2/2]

std::ostream & operator<<	(	std::ostream &	output,
		const CDCCKFState &	state )

print state info

Definition at line 16 of file CDCCKFState.cc.

  {
    if (state.isSeed()) {
      output << "seed";
    } else {
      const auto* wireHit = state.getWireHit();
      const auto& wire = wireHit->getWire();
      output << wire.getICLayer() << " " << wire.getIWire();
    }
    return output;
  }

operator<=() [1/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedLowerBoundedSet< Arithmetic >, VoidObserver > >::type operator<=	(	Arithmetic	lowerBound,
		const Var &	)

Creates a Filters with a closed lower bound >= on the provided variable lowerBound <= Var.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

lowerBound

: lower bound value to be checked by the filter

Returns

the created filter

Definition at line 191 of file Shortcuts.h.

  {
    return Filter<Var, ClosedLowerBoundedSet<Arithmetic>, VoidObserver>(ClosedLowerBoundedSet<Arithmetic> (lowerBound));
  }

operator<=() [2/3]

template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, ClosedRange< ArithmeticLower, ArithmeticUpper >, Observer > >::type operator<=	(	const Filter< Var, ClosedLowerBoundedSet< ArithmeticLower >, Observer > &	filter,
		ArithmeticUpper	upperBound )

Adding closed upper bound to filter with closed lower bound to create a filter with an allowed closed range between lower and upper bound.

(Var with closed lowerBound) <= upperBound

Template Parameters

Var	: variable type to be used for the filter
ArithmeticLower	: type of lower bound
ArithmeticUpper	: type of upper bound
Observer	: observer type

Parameters

filter	: filter with lower bound to which the upper bound shall be added
upperBound	: value of upper bound

Returns

filter with closed range allowing values between lower and upper bound

Definition at line 307 of file Shortcuts.h.

  {
    return Filter<Var, ClosedRange<ArithmeticLower, ArithmeticUpper>, Observer>
           (ClosedRange<ArithmeticLower, ArithmeticUpper> (filter.getRange().getInf(), upperBound));
  }

operator<=() [3/3]

template<class Var, class Arithmetic, typename ... types>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedUpperBoundedSet< Arithmetic >, VoidObserver > >::type operator<=	(	const Var &	,
		Arithmetic	upperBound )

Creates a Filters with a closed upper bound <= on the provided variable Var <= lowerBound.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function
types	: other types

Parameters

upperBound

: upper bound value to be checked by the filter

Returns

the created filter

Definition at line 71 of file Shortcuts.h.

  {
    return Filter<Var, ClosedUpperBoundedSet<Arithmetic>, VoidObserver>(ClosedUpperBoundedSet<Arithmetic> (upperBound));
  }

operator==() [1/7]

template<class DataType, class TCInfoType, class VectorType>

bool operator== ( const AlgoritmType::Type & a, const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > & b )

inline

non-memberfunction Comparison for equality with a AlgoritmType::Type

Definition at line 191 of file AnalyzingAlgorithmBase.h.

  { return (a == b.getID()); }

operator==() [2/7]

template<class DataType, class TCInfoType, class VectorType>

bool operator== ( const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > & a, const AlgoritmType::Type & b )

inline

non-memberfunction Comparison for equality with a AlgoritmType::Type

Definition at line 185 of file AnalyzingAlgorithmBase.h.

  { return (a.getID() == b); }

operator==() [3/7]

template<class DataType, class TCInfoType, class VectorType>

bool operator== ( const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > & a, const std::string & b )

inline

non-memberfunction Comparison for equality with a std::string

Definition at line 173 of file AnalyzingAlgorithmBase.h.

  { return (a.getIDName() == b); }

operator==() [4/7]

template<class EntryType, class MetaInfoType>

bool operator==	(	const EntryType &	a,
		const DirectedNode< EntryType, MetaInfoType > &	b )

************************* NON-MEMBER FUNCTIONS *************************

Non-memberfunction Comparison for equality with EntryType <-> DirectedNode< EntryType >

Definition at line 131 of file DirectedNode.h.

  {
    return (a == b.getConstEntry());
  }

operator==() [5/7]

template<class DataType, class TCInfoType, class VectorType>

bool operator== ( const std::string & a, const AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType > & b )

inline

non-memberfunction Comparison for equality with a std::string

Definition at line 179 of file AnalyzingAlgorithmBase.h.

  { return (a == b.getIDName()); }

operator==() [6/7]

template<class Var, class Val>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value, Filter< Var, SingleElementSet< Val >, VoidObserver > >::type operator==	(	const Var &	,
		Val	v )

Creates a Filters to compare a variable against a given value Var == Val;.

Template Parameters

Var	: variable type to use for the filter
Val	: value type to compare variable against

Parameters

v	: value to compare variable against

Returns

the created filter

Definition at line 211 of file Shortcuts.h.

  {
    return Filter<Var, SingleElementSet<Val>, VoidObserver>(SingleElementSet<Val> (v));
  }

operator==() [7/7]

template<class Var, class Val>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value, Filter< Var, SingleElementSet< Val >, VoidObserver > >::type operator==	(	Val	val,
		const Var &	var )

Creates a Filters to compare a variable against a given value Val == Var;.

Template Parameters

Var	: variable type to be used for the filter
Val	: value type to compare variable against

Parameters

val	: value to compare variable against
var	: variable

Returns

the created filter

Definition at line 231 of file Shortcuts.h.

  {
    return var == val;
  }

operator>() [1/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, UpperBoundedSet< Arithmetic >, VoidObserver > >::type operator>	(	Arithmetic	upperBound,
		const Var &	)

Creates a Filters with an upper bound < on the provided variable upperBound > Var.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

upperBound

: upper bound value to be checked by the filter

Returns

the created filter

Definition at line 132 of file Shortcuts.h.

  {
    return Filter<Var, UpperBoundedSet<Arithmetic>, VoidObserver>(UpperBoundedSet<Arithmetic> (upperBound));
  }

operator>() [2/3]

template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, Range< ArithmeticLower, ArithmeticUpper >, Observer > >::type operator>	(	const Filter< Var, UpperBoundedSet< ArithmeticUpper >, Observer > &	filter,
		ArithmeticLower	lowerBound )

Adding lower bound to filter with upper bound to create a filter with an allowed range between lower and upper bound.

(Var with upperBound) > lowerBound

Template Parameters

Var	: variable type to be used for the filter
ArithmeticLower	: type of lower bound
ArithmeticUpper	: type of upper bound
Observer	: observer type

Parameters

filter	: filter with lower bound to which the upper bound shall be added
lowerBound	: value of lower bound

Returns

filter with range allowing values between lower and upper bound

Definition at line 282 of file Shortcuts.h.

  {
    return Filter<Var, Range<ArithmeticLower, ArithmeticUpper>, Observer>
           (Range<ArithmeticLower, ArithmeticUpper> (lowerBound, filter.getRange().getSup()));
  }

operator>() [3/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, LowerBoundedSet< Arithmetic >, VoidObserver > >::type operator>	(	const Var &	,
		Arithmetic	lowerBound )

Creates a Filters with an lower bound > on the provided variable Var > lowerBound.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

lowerBound

: lower bound value to be checked by the filter

Returns

the created filter

Definition at line 92 of file Shortcuts.h.

  {
    return Filter<Var, LowerBoundedSet<Arithmetic>, VoidObserver >(LowerBoundedSet<Arithmetic> (lowerBound));
  }

operator>=() [1/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedUpperBoundedSet< Arithmetic >, VoidObserver > >::type operator>=	(	Arithmetic	upperBound,
		const Var &	)

Creates a Filters with a closed upper bound <= on the provided variable upperBound >= Var.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

upperBound

: upper bound value to be checked by the filter

Returns

the created filter

Definition at line 152 of file Shortcuts.h.

  {
    return Filter<Var, ClosedUpperBoundedSet<Arithmetic>, VoidObserver>(ClosedUpperBoundedSet<Arithmetic> (upperBound));
  }

operator>=() [2/3]

template<class Var, class ArithmeticLower, class ArithmeticUpper, class Observer>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< ArithmeticLower >::value &&std::is_arithmetic< ArithmeticUpper >::value, Filter< Var, ClosedRange< ArithmeticLower, ArithmeticUpper >, Observer > >::type operator>=	(	const Filter< Var, ClosedUpperBoundedSet< ArithmeticUpper >, Observer > &	filter,
		ArithmeticLower	lowerBound )

Adding closed lower bound to filter with closed upper bound to create a filter with an allowed closed range between lower and upper bound.

(Var with closed upperBound) >= lowerBound

Template Parameters

Var	: variable type to be used for the filter
ArithmeticLower	: type of lower bound
ArithmeticUpper	: type of upper bound
Observer	: observer type

Parameters

filter	: filter with lower bound to which the upper bound shall be added
lowerBound	: value of lower bound

Returns

filter with closed range allowing values between lower and upper bound

Definition at line 334 of file Shortcuts.h.

  {
    return Filter<Var, ClosedRange<ArithmeticLower, ArithmeticUpper>, Observer>
           (ClosedRange<ArithmeticLower, ArithmeticUpper> (lowerBound, filter.getRange().getSup()));
  }

operator>=() [3/3]

template<class Var, class Arithmetic>

std::enable_if< std::is_base_of< SelectionVariable< typenameVar::argumentType, Var::c_Nargs, typenameVar::variableType >, Var >::value &&std::is_arithmetic< Arithmetic >::value, Filter< Var, ClosedLowerBoundedSet< Arithmetic >, VoidObserver > >::type operator>=	(	const Var &	,
		Arithmetic	lowerBound )

Creates a Filters with a closed lower bound >= on the provided variable Var >= lowerBound.

Template Parameters

Var	: variable type to use for the filter
Arithmetic	: type of the return value of the variable function

Parameters

lowerBound

: lower bound value to be checked by the filter

Returns

the created filter

Definition at line 112 of file Shortcuts.h.

  {
    return Filter<Var, ClosedLowerBoundedSet<Arithmetic>, VoidObserver >(ClosedLowerBoundedSet<Arithmetic> (lowerBound));
  }

operator||()

template<typename ... types1, typename ... types2>

Filter< Belle2::OperatorOr, Belle2::Filter< types1... >, Belle2::Filter< types2... >, Belle2::VoidObserver > operator||	(	const Filter< types1... > &	filter1,
		const Filter< types2... > &	filter2 )

Definition of the boolean OR operator || of the Filter class.

Template Parameters

types1	: template pack of filter A
types2	: template pack of filter B

Parameters

filter1	: filter A
filter2	: filter B

Returns

Boolean OR combination of the two filters

Definition at line 925 of file Filter.h.

  {
    return Filter<OperatorOr, Filter<types1...>, Filter<types2...>, VoidObserver> (filter1, filter2);
  }

OverlapResolver()

template<class AFilter>

OverlapResolver

(

)

Construct this findlet and add the subfindlet as listener.

Definition at line 29 of file OverlapResolver.icc.h.

                                            : Super()
  {
    Super::addProcessingSignalListener(&m_filter);
  }

Print()

void Print ( const Option_t * = "" ) const

overridevirtual

Print a symbol for the matrix for debugging.

Definition at line 81 of file HMatrixQP.cc.

  {
    std::cout << "V" << std::endl;
  }

print()

template<size_t Ndims>

std::string print

(

)

const

print the matrix to a string.

Format: a row, a line, elements of rows delimited by a space. No trailing newline after last row!

Definition at line 165 of file DecorrelationMatrix.h.

  {
    std::stringstream sstr{};
    sstr << std::setprecision(std::numeric_limits<double>::digits10 + 1) <<  m_matrix; // ensure precision at write-out
    return sstr.str();
  }

printMap()

template<typename MapType>

std::string printMap

(

const MapType &

aMap

)

get the contents of the map as string.

NOTE: should compile without warning for any map (e.g. map, multimap, unordered_map,...) with key and values of a type that have a defined stream insertion operator (only tested for multimap and unordered_multimap!)

Definition at line 154 of file MapHelperFunctions.h.

  {
    if (aMap.empty()) return std::string("passed map is empty!");
 
    typedef typename MapType::key_type keyT;
    typedef typename MapType::mapped_type mapT;
 
    std::stringstream mapContent;
    mapContent << "content of map:\n";
    for (keyT key : getUniqueKeys(aMap)) {
      mapContent << "key: " << key << " -> value(s):";
      for (mapT value : getValuesToKey(aMap, key)) { mapContent << " " << value; }
      mapContent << "\n";
    }
 
    return mapContent.str() + "\n"; // terminate with endline
  }

readFromStream()

template<size_t Ndims>

bool readFromStream

(

std::istream &

is

)

read from stream.

Expected format: a row per line, elements of rows delimited by a space. returns true if operation was successful, false otherwise

NOTE: it is only checked if enough elements are present in each row and column. However, any superfluous values are ignored.

Definition at line 173 of file DecorrelationMatrix.h.

  {
    MatrixT inMat{};
    using RVector = Eigen::Matrix<double, 1, Ndims, Eigen::RowMajor>; // typedef for row vector
 
    size_t iRow = 0;
    while (iRow < Ndims) { // read only as many lines as needed
      std::string line{};
      if (is.eof()) return false;
      std::getline(is, line);
      if (line.empty()) continue; // skip empty lines
      std::stringstream lstr(line);
      std::array<double, Ndims> linevalues;
      for (double& value : linevalues) { // read only as many values in the line as needed
        if (lstr.eof()) return false;
        lstr >> value;
      }
      inMat.row(iRow) = Eigen::Map<const RVector>(linevalues.data(), linevalues.size());
      ++iRow;
    }
 
    m_matrix = inMat;
    return true;
  }

readSamplesFromStream()

template<size_t Ndims>

static void readSamplesFromStream ( std::istream & is, std::vector< FBDTTrainSample< Ndims > > & samples )

static

read samples from stream and append them to samples

Definition at line 42 of file FBDTClassifierHelper.h.

  {
    size_t nSamplesBefore = samples.size();
    std::string line;
    while (!is.eof()) {
      getline(is, line);
      if (line.empty()) continue; // ignore empty lines
      std::stringstream ss(line);
      std::array<double, 9> coords;
      for (double& c : coords) ss >> c;
      bool sig; ss >> sig;
 
      samples.push_back(FBDTTrainSample<9>(coords, sig));
    }
 
    B2INFO("Read in " << (samples.size() - nSamplesBefore) << " samples.");
  }

resetEventT0()

template<class ... AIOTypes>

void resetEventT0 ( ) const

protected

Reset the t0 value to cached value if it exists or clear it otherwise.

Definition at line 59 of file BaseEventTimeExtractor.icc.h.

  {
    if (m_eventT0Before) {
      m_eventT0->setEventT0(*m_eventT0Before);
    } else {
      m_eventT0->clearEventT0();
    }
  }

ROIToUnitTranslator() [1/2]

template<class aIntercept>

ROIToUnitTranslator ( const ROIinfo * theROIinfo )

explicit

Constructor.

Definition at line 23 of file ROIToUnitTranslator.templateDetails.h.

    : m_sigmaSystU(theROIinfo->sigmaSystU)
    , m_sigmaSystV(theROIinfo->sigmaSystV)
    , m_numSigmaTotU(theROIinfo->numSigmaTotU)
    , m_numSigmaTotV(theROIinfo->numSigmaTotV)
    , m_maxWidthU(theROIinfo->maxWidthU)
    , m_maxWidthV(theROIinfo->maxWidthV)
  {};

ROIToUnitTranslator() [2/2]

template<class aIntercept>

ROIToUnitTranslator	(	double	sigmaSystU,
		double	sigmaSystV,
		double	numSigmaTotU,
		double	numSigmaTotV,
		double	maxWidthU,
		double	maxWidthV )

Second Constructor.

Definition at line 33 of file ROIToUnitTranslator.templateDetails.h.

    : m_sigmaSystU(sigmaSystU)
    , m_sigmaSystV(sigmaSystV)
    , m_numSigmaTotU(numSigmaTotU)
    , m_numSigmaTotV(numSigmaTotV)
    , m_maxWidthU(maxWidthU)
    , m_maxWidthV(maxWidthV)
  {};

SelectionVariableNamesToFunctions() [1/4]

template<class FilterA, class FilterB, class ... options>

std::unordered_map< std::string, typename FilterA::functionType > SelectionVariableNamesToFunctions

(

Belle2::Filter< Belle2::OperatorAnd, FilterA, FilterB, options... >

)

Wrapper for filters with AND Operator tag.

Template Parameters

FilterA	: a Filter variable type
FilterB	: another Filter variable type
options	: optional types

Returns

unordered map relating strings to the filter variable functions

Definition at line 71 of file SelectionVariableNamesToFunctions.h.

  {
    auto result = SelectionVariableNamesToFunctions(FilterA());
    auto resultB = SelectionVariableNamesToFunctions(FilterB());
    result.insert(resultB.begin(), resultB.end());
    return result;
  }

SelectionVariableNamesToFunctions() [2/4]

template<class someFilter, class ... options>

std::unordered_map< std::string, typename someFilter::functionType > SelectionVariableNamesToFunctions

(

Belle2::Filter< Belle2::OperatorNot, someFilter, options... >

)

Wrapper for filters with NOT Operator tag.

Template Parameters

someFilter	: Filter variable type
options	: optional types

Returns

unordered map relating strings to the filter variable functions

Definition at line 52 of file SelectionVariableNamesToFunctions.h.

  {
    return SelectionVariableNamesToFunctions(someFilter());
  }

SelectionVariableNamesToFunctions() [3/4]

template<class FilterA, class FilterB, class ... options>

std::unordered_map< std::string, typename FilterA::functionType > SelectionVariableNamesToFunctions

(

Belle2::Filter< Belle2::OperatorOr, FilterA, FilterB, options... >

)

Wrapper for filters with OR Operator tag.

Template Parameters

FilterA	: a Filter variable type
FilterB	: another Filter variable type
options	: optional types

Returns

unordered map relating strings to the filter variable functions

Definition at line 93 of file SelectionVariableNamesToFunctions.h.

  {
    auto result = SelectionVariableNamesToFunctions(FilterA());
    auto resultB = SelectionVariableNamesToFunctions(FilterB());
    result.insert(resultB.begin(), resultB.end());
    return result;
  }

SelectionVariableNamesToFunctions() [4/4]

template<class Variable, class Range, class ... Options>

std::unordered_map< std::string, typename Variable::functionType > SelectionVariableNamesToFunctions

(

Belle2::Filter< Variable, Range, Options... >

)

Return a map from the SelectionVariable name to the SelectionVariable function of the Variable used in the filter that is the template argument parameter.

This is the basic building block we will exploit later

Template Parameters

Variable	: Filter variable type
Range	: range type
Options	: optional types

Returns

unordered map relating strings to the filter variable functions

Definition at line 35 of file SelectionVariableNamesToFunctions.h.

  {
    // Note: Variable::value is the pointer to the function that return the values
    return std::unordered_map< std::string, typename Variable::functionType>
    ({ {Variable::name(), Variable::value } });
  };

StateRejecter()

template<class AState, class AFindlet>

StateRejecter

(

)

Construct this findlet and add the subfindlet as listener.

Definition at line 21 of file StateRejecter.icc.h.

                                                 : Super()
  {
    Super::addProcessingSignalListener(&m_firstFilter);
    Super::addProcessingSignalListener(&m_advanceFilter);
    Super::addProcessingSignalListener(&m_secondFilter);
    Super::addProcessingSignalListener(&m_updateFilter);
    Super::addProcessingSignalListener(&m_thirdFilter);
  };

TBranchLeafType() [1/12]

char TBranchLeafType ( const bool & )

inline

Overloading TBranchLeafType to be able to get identifier 'O' for type bool.

Definition at line 52 of file TBranchLeafType.h.

{ return 'O'; };

TBranchLeafType() [2/12]

char TBranchLeafType ( const char * )

inline

Overloading TBranchLeafType to be able to get identifier 'C' for type char*.

Definition at line 19 of file TBranchLeafType.h.

{ return 'C'; };

TBranchLeafType() [3/12]

char TBranchLeafType ( const Char_t & )

inline

Overloading TBranchLeafType to be able to get identifier 'B' for type Char_t.

Definition at line 22 of file TBranchLeafType.h.

{ return 'B'; };

TBranchLeafType() [4/12]

char TBranchLeafType ( const Double_t & )

inline

Overloading TBranchLeafType to be able to get identifier 'D' for type Double_t.

Definition at line 43 of file TBranchLeafType.h.

{ return 'D'; };

TBranchLeafType() [5/12]

char TBranchLeafType ( const Float_t & )

inline

Overloading TBranchLeafType to be able to get identifier 'F' for type Float_t.

Definition at line 40 of file TBranchLeafType.h.

{ return 'F'; };

TBranchLeafType() [6/12]

char TBranchLeafType ( const Int_t & )

inline

Overloading TBranchLeafType to be able to get identifier 'I' for type Int_t.

Definition at line 34 of file TBranchLeafType.h.

{ return 'I'; };

TBranchLeafType() [7/12]

char TBranchLeafType ( const long int & )

inline

Overloading TBranchLeafType to be able to get identifier 'L' for type long int.

Definition at line 46 of file TBranchLeafType.h.

{ return 'L'; };

TBranchLeafType() [8/12]

char TBranchLeafType ( const short & )

inline

Overloading TBranchLeafType to be able to get identifier 'S' for type short.

Definition at line 28 of file TBranchLeafType.h.

{ return 'S'; };

TBranchLeafType() [9/12]

char TBranchLeafType ( const UInt_t & )

inline

Overloading TBranchLeafType to be able to get identifier 'i' for type UInt_t.

Definition at line 37 of file TBranchLeafType.h.

{ return 'i'; };

TBranchLeafType() [10/12]

char TBranchLeafType ( const unsigned char & )

inline

Overloading TBranchLeafType to be able to get identifier 'b' for type unsigned char.

Definition at line 25 of file TBranchLeafType.h.

{ return 'b'; };

TBranchLeafType() [11/12]

char TBranchLeafType ( const unsigned long int & )

inline

Overloading TBranchLeafType to be able to get identifier 'l' for type unsigned long int.

Definition at line 49 of file TBranchLeafType.h.

{ return 'l'; };

TBranchLeafType() [12/12]

char TBranchLeafType ( const unsigned short & )

inline

Overloading TBranchLeafType to be able to get identifier 's' for type unsigned short.

Definition at line 31 of file TBranchLeafType.h.

{ return 's'; };

traverseTree()

template<class AState, class AStateRejecter, class AResult>

void traverseTree ( std::vector< TrackFindingCDC::WithWeight< const AState * > > & path, const std::vector< TrackFindingCDC::WeightedRelation< AState > > & relations, std::vector< AResult > & results )

private

Implementation of the traverseTree function.

Definition at line 68 of file TreeSearcher.icc.h.

  {
    if (m_param_endEarly) {
      // Make it possible to end earlier (with less hits)
      results.emplace_back(path);
    }
 
    // Implement only graph traversal logic and leave the extrapolation and selection to the
    // rejecter.
    const AState* currentState = path.back();
    auto continuations =
      TrackFindingCDC::asRange(std::equal_range(relations.begin(), relations.end(), currentState));
 
    std::vector<TrackFindingCDC::WithWeight<AState*>> childStates;
    for (const TrackFindingCDC::WeightedRelation<AState>& continuation : continuations) {
      AState* childState = continuation.getTo();
      TrackFindingCDC::Weight weight = continuation.getWeight();
      // the state may still include information from an other round of processing, so lets set it back
 
      if (std::count(path.begin(), path.end(), childState)) {
        // Cycle detected -- is this the best handling?
        // Other options: Raise an exception and bail out of this seed
        B2FATAL("Cycle detected!");
      }
 
      childState->reset();
      childStates.emplace_back(childState, weight);
    }
 
    if (childStates.empty()) {
      B2DEBUG(29, "Terminating this route, as there are no possible child states.");
      if (not m_param_endEarly) {
        results.emplace_back(path);
      }
      return;
    }
 
    // Do everything with child states, linking, extrapolation, teaching, discarding, what have
    // you.
    const std::vector<TrackFindingCDC::WithWeight<const AState*>>& constPath = path;
    m_stateRejecter.apply(constPath, childStates);
 
    if (childStates.empty()) {
      B2DEBUG(29, "Terminating this route, as there are no possible child states.");
      if (not m_param_endEarly) {
        results.emplace_back(path);
      }
      return;
    }
 
    // Traverse the tree from each new state on
    const auto stateLess = [](const auto & lhs, const auto & rhs) {
      return lhs->getAutomatonCell().getCellState() < rhs->getAutomatonCell().getCellState();
    };
    std::sort(childStates.begin(), childStates.end(), stateLess);
 
    B2DEBUG(29, "Having found " << childStates.size() << " child states.");
    for (const TrackFindingCDC::WithWeight<AState*>& childState : childStates) {
      path.emplace_back(childState, childState.getWeight());
      traverseTree(path, relations, results);
      path.pop_back();
    }
  }

TreeSearcher()

template<class AState, class AStateRejecter, class AResult>

TreeSearcher

(

)

Construct this findlet and add the subfindlet as listener.

Definition at line 26 of file TreeSearcher.icc.h.

                                                              : Super()
  {
    Super::addProcessingSignalListener(&m_stateRejecter);
  };

VariableTBranch()

template<class Variable>

VariableTBranch ( TTree * tree )

explicit

Add to the TTree.

Constructor specialized for arithmetic types.

Parameters

tree	a branch whose name and type are inferred from parameter var

Definition at line 53 of file VariableTBranch.h.

  {
    if (tree != nullptr && tree -> GetBranch(Variable::name().c_str()) == nullptr)
      m_branch = tree->Branch(Variable::name().c_str(), & m_storedValue,
                              TBranchLeafType(m_storedValue));
  }

wasSuccessful()

template<class ... AIOTypes>

bool wasSuccessful

(

)

const

Returns true if the last run t0 extraction was successful.

Definition at line 21 of file BaseEventTimeExtractor.icc.h.

  {
    return m_wasSuccessful;
  }

writeSamplesToStream()

template<size_t Ndims>

static void writeSamplesToStream ( std::ostream & os, const std::vector< FBDTTrainSample< Ndims > > & samples )

static

write all samples to stream

Definition at line 62 of file FBDTClassifierHelper.h.

  {
    for (const auto& event : samples) {
      for (const auto& val : event.hits) {
        os << val << " ";
      }
      os << event.signal << std::endl;
    }
    B2INFO("Wrote out " << samples.size() << " samples.");
  }

Variable Documentation

AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::m_storeRefTCDataForTestTC

template<class DataType, class TCInfoType, class VectorType>

bool AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::m_storeRefTCDataForTestTC = false

setting the static storeRefTCDataForTestTC to a standard value

Definition at line 168 of file AnalyzingAlgorithmBase.h.

AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::s_origin

template<class DataType, class TCInfoType, class VectorType>

VectorType AnalyzingAlgorithmBase< DataType, TCInfoType, VectorType >::s_origin = VectorType(0, 0, 0)

setting the static origin to a standard value

Definition at line 163 of file AnalyzingAlgorithmBase.h.

cdcfromEclPathTruthVarNames

char const* const cdcfromEclPathTruthVarNames[]

staticconstexpr

Initial value:

= {
    "matched",
    "daughters",
    "PDG",
    "mcTrackHits",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  }

Names of the variables to be generated.

Definition at line 22 of file CDCfromEclPathTruthVarSet.h.

                                                           {
    "matched",
    "daughters",
    "PDG",
    "mcTrackHits",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  };

cdcfromEclStateTruthVarNames

char const* const cdcfromEclStateTruthVarNames[]

staticconstexpr

Initial value:

= {
    "match",
    "PDG",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  }

Names of the variables to be generated.

Definition at line 22 of file CDCfromEclStateTruthVarSet.h.

                                                            {
    "match",
    "PDG",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  };

cdcPathBasicVarNames

char const* const cdcPathBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 25 of file CDCPathBasicVarSet.h.

                                                    {
    "eventNumber",
    "totalHits",
    "reachedEnd",
    "totalHitsSeedTrack",
    "firstChi2",
    "lastChi2",
    "seedICLayer",
    "firstICLayer",
    "lastICLayer",
    "seed_r",
    "seed_z",
    "seed_x",
    "seed_y",
    "seed_p",
    "seed_theta",
    "seed_pt",
    "seed_pz",
    "seed_px",
    "seed_py",
    "seed_charge",
    "track_theta",
    "track_p",
    "track_pt",
    "track_pz",
    "track_px",
    "track_py",
    "track_charge",
    "chargeFlip",
    "ICLayerLast0",
    "ICLayerLast1",
    "ICLayerLast2",
    "IWireLast0",
    "IWireLast1",
    "IWireLast2",
    "flipPos0",
    "flipPos1",
    "flipPos2",
    "flipPos3",
    "arcLength0",
    "arcLength1",
    "arcLength2",
    "arcLength3",
    "arcLength4",
    "arcLength5",
    "arcLength6",
    "arcLength7",
    "arcLength8",
    "arcLength9",
    "hitDistance0",
    "hitDistance1",
    "hitDistance2",
    "hitDistance3",
    "hitDistance4",
    "hitDistance5",
    "hitDistance6",
    "hitDistance7",
    "hitDistance8",
    "hitDistance9"
  };

cdcPathTruthVarNames

char const* const cdcPathTruthVarNames[]

staticconstexpr

Initial value:

= {
    "mcTrackHits",
    "daughters",
    "PDG",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  }

Names of the variables to be generated.

Definition at line 22 of file CDCPathTruthVarSet.h.

                                                    {
    "mcTrackHits",
    "daughters",
    "PDG",
    "seed_p_truth",
    "seed_theta_truth",
    "seed_pt_truth",
    "seed_pz_truth",
    "seed_px_truth",
    "seed_py_truth"
  };

cdcStateBasicVarNames

char const* const cdcStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 25 of file CDCStateBasicVarSet.h.

                                                     {
    "eventNumber",
    "i_hit",
    "firstHit",
    "iCLayer_lastState",
    "iCLayer",
    "arcLength",
    "hitDistance",
    "seed_theta",
    "seed_r",
    "seed_z",
    "seed_x",
    "seed_y",
    "seed_p",
    "seed_pt",
    "seed_pz",
    "seed_px",
    "seed_py",
    "seed_charge",
    "track_momTheta",
    "track_p",
    "track_pt",
    "track_pz",
    "track_px",
    "track_py",
    "track_posTheta",
    "track_r",
    "track_z",
    "track_x",
    "track_y",
    "track_charge",
    "track_pt_firstHit",
    "track_pz_firstHit",
    "track_r_firstHit",
    "track_z_firstHit",
    "wire_r",
    "wire_z",
    "wire_x",
    "wire_y"
  };

cdcStateTruthVarNames

char const* const cdcStateTruthVarNames[]

staticconstexpr

Initial value:

= {
    "match",
    "PDG"
  }

Names of the variables to be generated.

Definition at line 22 of file CDCStateTruthVarSet.h.

                                                     {
    "match",
    "PDG"
  };

pxdResultTruthNames

char const* const pxdResultTruthNames[]

staticconstexpr

Initial value:

= {
    "truth",
    "truth_number_of_correct_hits",
    "truth_number_of_mc_pxd_hits",
    "truth_number_of_mc_svd_hits",
    "truth_number_of_mc_cdc_hits",
    "truth_event_number",
    "truth_seed_number",
  }

Names of the variables to be generated.

Definition at line 28 of file PXDResultTruthVarSet.h.

                                                   {
    "truth",
    "truth_number_of_correct_hits",
    "truth_number_of_mc_pxd_hits",
    "truth_number_of_mc_svd_hits",
    "truth_number_of_mc_cdc_hits",
    "truth_event_number",
    "truth_seed_number",
  };

pxdResultVarNames

char const* const pxdResultVarNames[]

staticconstexpr

Initial value:

= {
    "chi2_vxd_max",
    "chi2_vxd_min",
    "chi2_seed",
    "chi2",
 
    "number_of_hits",
 
    "pt",
    "theta",
 
    "number_of_holes",
 
    "last_hit_layer",
    "first_hit_layer",
 
    "weight_sum",
 
    "has_missing_layer_1",
    "has_missing_layer_2",
    "has_missing_layer_3",
    "has_missing_layer_4",
    "has_missing_layer_5",
    "has_missing_layer_6",
 
    "number_of_overlap_hits",
 
    "distance_to_seed_track",
    "distance_to_seed_track_xy",
  }

Names of the variables to be generated.

Definition at line 25 of file PXDResultVarSet.h.

                                                 {
    "chi2_vxd_max",
    "chi2_vxd_min",
    "chi2_seed",
    "chi2",
 
    "number_of_hits",
 
    "pt",
    "theta",
 
    "number_of_holes",
 
    "last_hit_layer",
    "first_hit_layer",
 
    "weight_sum",
 
    "has_missing_layer_1",
    "has_missing_layer_2",
    "has_missing_layer_3",
    "has_missing_layer_4",
    "has_missing_layer_5",
    "has_missing_layer_6",
 
    "number_of_overlap_hits",
 
    "distance_to_seed_track",
    "distance_to_seed_track_xy",
  };

pxdStateBasicVarNames

char const* const pxdStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 23 of file PXDStateBasicVarSet.h.

                                                     {
    "distance",
    "xy_distance",
    "z_distance",
 
    "mSoP_distance",
    "mSoP_xy_distance",
    "mSoP_z_distance",
 
    "same_hemisphere",
 
    "layer",
    "number",
 
    "arcLengthOfHitPosition",
    "arcLengthOfCenterPosition",
 
    "pt",
    "tan_lambda",
    "phi",
 
    "sigma_uv",
    "residual_over_sigma",
 
    "residual",
 
    "chi2",
 
    "cluster_charge",
    "cluster_seed_charge",
    "cluster_size",
    "cluster_size_u",
    "cluster_size_v",
 
    "ladder",
    "sensor",
    "segment",
    "id",
 
    "last_layer",
    "last_ladder",
    "last_sensor",
    "last_segment",
    "last_id",
 
    "last_cluster_charge",
    "last_cluster_seed_charge",
    "last_cluster_size",
    "last_cluster_size_u",
    "last_cluster_size_v",
  };

pxdStateTruthVarNames

char const* const pxdStateTruthVarNames[]

staticconstexpr

Initial value:

= {
    "truth",
    "truth_position_x",
    "truth_position_y",
    "truth_position_z",
    "truth_momentum_x",
    "truth_momentum_y",
    "truth_momentum_z",
    "truth_event_id",
    "truth_seed_number"
  }

Names of the variables to be generated.

Definition at line 27 of file PXDStateTruthVarSet.h.

                                                     {
    "truth",
    "truth_position_x",
    "truth_position_y",
    "truth_position_z",
    "truth_momentum_x",
    "truth_momentum_y",
    "truth_momentum_z",
    "truth_event_id",
    "truth_seed_number"
  };

relationSVDResultVarNames

char const* const relationSVDResultVarNames[]

staticconstexpr

Initial value:

= {
    "svd_highest_layer",
    "number_of_hits_related_svd_track",
  }

Names of the variables to be generated.

Definition at line 23 of file RelationSVDResultVarSet.h.

                                                         {
    "svd_highest_layer",
    "number_of_hits_related_svd_track",
  };

SelVarHelper< PointType, DataType >::s_MagneticFieldFactor

template<typename PointType, typename DataType>

DataType SelVarHelper< PointType, DataType >::s_MagneticFieldFactor

Initial value:

= 1.5 *
      0.00299710

magnetic field factor

Definition at line 75 of file SelectionVariableHelper.h.

svdResultTruthNames

char const* const svdResultTruthNames[]

staticconstexpr

Initial value:

= {
    "truth",
    "truth_svd_cdc_relation",
    "truth_number_of_correct_hits",
    "truth_number_of_mc_pxd_hits",
    "truth_number_of_mc_svd_hits",
    "truth_number_of_mc_cdc_hits",
    "truth_event_number",
    "truth_seed_number",
  }

Names of the variables to be generated.

Definition at line 28 of file SVDResultTruthVarSet.h.

                                                   {
    "truth",
    "truth_svd_cdc_relation",
    "truth_number_of_correct_hits",
    "truth_number_of_mc_pxd_hits",
    "truth_number_of_mc_svd_hits",
    "truth_number_of_mc_cdc_hits",
    "truth_event_number",
    "truth_seed_number",
  };

svdResultVarNames

char const* const svdResultVarNames[]

staticconstexpr

Initial value:

= {
    "chi2_vxd_max",
    "chi2_vxd_min",
    "chi2_cdc",
    "chi2",
 
    "number_of_hits",
 
    "pt",
    "theta",
 
    "number_of_holes",
 
    "cdc_lowest_layer",
 
    "last_hit_layer",
    "first_hit_layer",
 
    "weight_sum",
 
    "has_missing_layer_1",
    "has_missing_layer_2",
    "has_missing_layer_3",
    "has_missing_layer_4",
    "has_missing_layer_5",
    "has_missing_layer_6",
 
    "distance_to_cdc_track",
    "distance_to_cdc_track_xy",
  }

Names of the variables to be generated.

Definition at line 25 of file SVDResultVarSet.h.

                                                 {
    "chi2_vxd_max",
    "chi2_vxd_min",
    "chi2_cdc",
    "chi2",
 
    "number_of_hits",
 
    "pt",
    "theta",
 
    "number_of_holes",
 
    "cdc_lowest_layer",
 
    "last_hit_layer",
    "first_hit_layer",
 
    "weight_sum",
 
    "has_missing_layer_1",
    "has_missing_layer_2",
    "has_missing_layer_3",
    "has_missing_layer_4",
    "has_missing_layer_5",
    "has_missing_layer_6",
 
    "distance_to_cdc_track",
    "distance_to_cdc_track_xy",
  };

svdStateBasicVarNames

char const* const svdStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 23 of file SVDStateBasicVarSet.h.

                                                     {
    "distance",
    "xy_distance",
    "z_distance",
 
    "mSoP_distance",
    "mSoP_xy_distance",
    "mSoP_z_distance",
 
    "same_hemisphere",
 
    "layer",
    "number",
    "ladder",
    "sensor",
    "segment",
    "id",
 
    "cluster_1_time",
    "cluster_2_time",
 
    "arcLengthOfHitPosition",
    "arcLengthOfCenterPosition",
 
    "pt",
    "tan_lambda",
    "phi",
 
    "sigma_uv",
    "residual_over_sigma",
 
    "residual",
 
    "chi2",
 
    "last_layer",
    "last_ladder",
    "last_sensor",
    "last_segment",
    "last_id",
 
    "last_cluster_1_time",
    "last_cluster_2_time",
  };

svdStateTruthVarNames

char const* const svdStateTruthVarNames[]

staticconstexpr

Initial value:

= {
    "truth",
    "truth_position_x",
    "truth_position_y",
    "truth_position_z",
    "truth_momentum_x",
    "truth_momentum_y",
    "truth_momentum_z",
    "truth_event_id",
    "truth_seed_number"
  }

Names of the variables to be generated.

Definition at line 27 of file SVDStateTruthVarSet.h.

                                                     {
    "truth",
    "truth_position_x",
    "truth_position_y",
    "truth_position_z",
    "truth_momentum_x",
    "truth_momentum_y",
    "truth_momentum_z",
    "truth_event_id",
    "truth_seed_number"
  };

svdStateVarNames

char const* const svdStateVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 27 of file SVDStateVarSet.h.

                                                {
    "seed_cdc_hits",
    "seed_svd_hits",
    "seed_lowest_svd_layer",
    "seed_lowest_cdc_layer",
 
    "quality_index_triplet",
    "quality_index_circle",
    "quality_index_helix",
 
    "cluster_1_charge",
    "cluster_2_charge",
    "mean_rest_cluster_charge",
    "min_rest_cluster_charge",
    "std_rest_cluster_charge",
 
    "cluster_1_seed_charge",
    "cluster_2_seed_charge",
    "mean_rest_cluster_seed_charge",
    "min_rest_cluster_seed_charge",
    "std_rest_cluster_seed_charge",
 
    "cluster_1_size",
    "cluster_2_size",
    "mean_rest_cluster_size",
    "min_rest_cluster_size",
    "std_rest_cluster_size",
 
    "cluster_1_snr",
    "cluster_2_snr",
    "mean_rest_cluster_snr",
    "min_rest_cluster_snr",
    "std_rest_cluster_snr",
 
    "cluster_1_charge_over_size",
    "cluster_2_charge_over_size",
    "mean_rest_cluster_charge_over_size",
    "min_rest_cluster_charge_over_size",
    "std_rest_cluster_charge_over_size",
  };