tracking

Modules
	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	BeamSpotAlgorithm
	Class implementing BeamSpot calibration algorithm. More...
class	BoostVectorAlgorithm
	Class implementing BoostVector calibration algorithm. More...
struct	CalibPars
	The parameters related to single calibration interval. More...
struct	CalibrationData
	Parameters and data relevant for single calibration interval. More...
class	ChebFitter
	Unbinned Maximum Likelihood fitter with a possibility to use Chebyshev interpolation. More...
class	InvariantMassAlgorithm
	Class implementing InvariantMass calibration algorithm. More...
struct	Atom
	Very small (few mins) calibration interval which cannot be further divided : Atom. More...
struct	ExpRun
	Struct containing exp number and run number. More...
struct	ExpRunEvt
	struct with expNum, runNum, evtNum More...
class	Splitter
	Class that allows to split runs into the intervals of intended properties given by the lossFunction. More...
struct	Spline
	Spline structure for zero-order & linear splines. More...
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 resutling 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 aplying 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	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...
class	MapHelperFunctionsTest
	function object that implements cosecans(x) == 1/cos(x) by tan(x) / sin(x). More...
class	SpacePointTest
	Set up a few arrays and objects in the datastore. More...
class	SpacePointTrackCandTest
	Test class for the SpacePointTrackCand class. More...
class	RecoTrackTest
	Test class for the RecoTrack object. More...
class	CollectorTFInfoTest
	Set up a few arrays and objects in the datastore. More...
class	FilterIDTest
	Set up a few arrays and objects in the datastore. More...
class	FullSecIDTest
	Testing everything from FullSecID. More...
class	VerbosityClass< Verbosity >
	should behave differently for different verbosity-levels given - class More...
class	SandBox4TestingTest
	Testing autoAssignment of vectors for functions. More...
class	SectorTest
	Set up a few arrays and objects in the datastore. More...
class	ThreeHitFiltersTest
	Set up a few arrays and objects in the datastore. More...
class	TwoHitFiltersTest
	Set up a few arrays and objects in the datastore. 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 analizing 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	VariablesOnTTree
	Test for VariablesTTree. 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 storeable and accesible 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	FlipRecoTrackExtractor2nd
	class to extract results from qualityEstimation More...
class	FlipRecoTrackExtractor
	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	V0FitterTest
	Set up a few arrays and objects in the datastore. 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
typedef std::map< std::string, double >	Pars
	values of parameters in ML fit
typedef std::map< std::string, std::pair< double, double > >	Limits
	limits of parameters in ML fit
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 = TrackFindingCDC::Filter< std::pair< const CDCCKFPath *, CDCCKFState * > >
	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 = TrackFindingCDC::Filter< std::pair< const std::vector< TrackFindingCDC::WithWeight< const CKFToPXDState * > >, CKFToPXDState * > >
	Base filter for CKF PXD states.
using	ChooseableOnPXDStateApplier = LayerToggledApplier< CKFToPXDState, LimitedOnStateApplier< CKFToPXDState, TrackFindingCDC::ChooseableFilter< PXDStateFilterFactory > > >
	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 = TrackFindingCDC::Filter< std::pair< const std::vector< TrackFindingCDC::WithWeight< const CKFToSVDState * > >, CKFToSVDState * > >
	Base filter for CKF SVD states.
using	ChooseableOnSVDStateApplier = LayerToggledApplier< CKFToSVDState, LimitedOnStateApplier< CKFToSVDState, TrackFindingCDC::ChooseableFilter< SVDStateFilterFactory > > >
	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 = TrackFindingCDC::FindletModule< TrackFindingCDC::FindletStoreArrayInput< BaseEventTimeExtractorModuleFindlet< AFindlet > > >
	Alias for the event time extraction module.
typedef std::unordered_multimap< int, double >	i2dMultiMap
	typedef for less writing effort
typedef std::unordered_map< int, double >	i2dMap
	typedef for less writing effort
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
TMatrixDSym	toTMatrixDSym (Eigen::MatrixXd mIn)
	Function that converts Eigen symmetric matrix to ROOT matrix.
B2Vector3D	toB2Vector3 (Eigen::VectorXd vIn)
	Function that converts Eigen vector to ROOT vector.
int	getID (const std::vector< double > &breaks, double t)
	get id of the time point t
void	extrapolateCalibration (std::vector< CalibrationData > &calVec)
	Extrapolate calibration to intervals where it failed.
void	addShortRun (std::vector< CalibrationData > &calVec, std::pair< ExpRun, std::pair< double, double > > shortRun)
	Extrapolate calibration to the very short runs which were filtered before.
double	encodeNumber (double val, unsigned num)
	Encode integer num into double val such that val is nearly not changed (maximally by a relative shift 1e-6).
unsigned	decodeNumber (double val)
	Decode the integer number encoded in val.
template<typename Evt >
void	storePayloads (const std::vector< Evt > &evts, const std::vector< CalibrationData > &calVecConst, std::string objName, std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd) > getCalibObj)
	Store payloads to files.
void	storePayloadsNoIntraRun (const std::vector< CalibrationData > &calVecConst, std::string objName, std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd) > getCalibObj)
	Store payloads to files, where calib data have no intra-run dependence.
template<typename Evt , typename Fun >
CalibrationData	runAlgorithm (const std::vector< Evt > &evts, std::vector< std::map< ExpRun, std::pair< double, double > > > range, Fun runCalibAnalysis)
	run calibration algorithm for single calibration interval
template<typename Fun1 , typename Fun2 >
CalibrationAlgorithm::EResult	runCalibration (TTree *tracks, const std::string &calibName, Fun1 GetEvents, Fun2 calibAnalysis, std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd)> calibObjCreator, TString m_lossFunctionOuter, TString m_lossFunctionInner)
	Run the the calibration over the whole event sample.
std::pair< double, double >	getMinima (std::vector< std::vector< double > > vals, int i0, int j0)
	Get minimum inside and outside of the smaller window defined by i0, j0.
std::vector< double >	getMinimum (std::function< double(double, double)> fun, double xMin, double xMax, double yMin, double yMax)
	Get minimum of 2D function in the rectangular domain defined by xMin,xMax & yMin,yMax.
Eigen::VectorXd	getWeights (int Size)
	Get the vector of weights to calculate the integral over the Chebyshev nodes The nodes are by definition between 0 and 1, there are Size nodes To get their positions, use getNodes.
Eigen::VectorXd	getNodes (int Size)
	Get the vector of positions of the Chebyshev nodes The nodes are by definition between 0 and 1, there are Size nodes For the corresponding weights use getWeights.
Eigen::VectorXd	getPols (int Size, double x)
	Evaluate Chebyshev polynomials up to Size at point x It returns a vector of the P_i(x) for i=0..Size-1 The polynomial is defined for x between 0 and 1.
Eigen::VectorXd	getPolsSum (int Size, Eigen::VectorXd x)
	Calculate the Chebyshev polynomials of order i=0..Size-1 at points given in vector x_j and sum it over point index j It returns sum_j P_i(x_j) for i=0..Size-1 The Chebyshev polynomials are defined for x between 0 and 1.
Eigen::MatrixXd	getCoefs (int Size, bool isInverse=false)
	Transformation matrix between Cheb nodes and coefficients of the Cheb polynomials Notice, that there are two alternative ways defining polynomial interpolation:
double	evalPol (const Eigen::VectorXd &polCoef, double x)
	Evaluate Cheb.
Eigen::MatrixXd	getCoefsCheb (int oldSize)
	Transformation matrix between Cheb nodes and Cheb coefficients with better normalization of the borders.
Eigen::VectorXd	interpol (const Eigen::VectorXd &xi, double x)
	Get Interpolation vector k_i for point x from the function values at points xi (polynomial interpolation) In the second step, the function value at x can be evaluated as sum_i vals_i k_i.
double	interpol (Eigen::VectorXd xi, Eigen::VectorXd vals, double x)
	Get interpolated function value at point x when function values vals at points xi are provided.
bool	operator!= (ExpRun a, ExpRun b)
	Not equal for ExpRun.
bool	operator< (ExpRun a, ExpRun b)
	less than for ExpRun
std::map< ExpRun, std::pair< double, double > >	filter (const std::map< ExpRun, std::pair< double, double > > &runs, double cut, std::map< ExpRun, std::pair< double, double > > &runsRemoved)
	filter events to remove runs shorter than cut, it stores removed runs in runsRemoved
std::pair< int, int >	getStartEndIndexes (int nIntervals, std::vector< int > breaks, int indx)
	get the range of interval with nIntervals and breaks stored in a vector
std::vector< Atom >	slice (std::vector< Atom > vec, int s, int e)
	Slice the vector to contain only elements with indexes s .. e (included)
std::vector< std::map< ExpRun, std::pair< double, double > > >	breaks2intervalsSep (const std::map< ExpRun, std::pair< double, double > > &runsMap, const std::vector< Atom > &currVec, const std::vector< int > &breaks)
	Get calibration intervals according to the indexes of the breaks.
template<typename Evt >
std::map< ExpRun, std::pair< double, double > >	getRunInfo (const std::vector< Evt > &evts)
	Get the map of runs, where each run contains pair with start/end time [hours].
template<typename Evt >
ExpRunEvt	getPosition (const std::vector< Evt > &events, double tEdge)
	Get the exp-run-evt number from the event time [hours].
template<typename Evt >
std::vector< ExpRunEvt >	convertSplitPoints (const std::vector< Evt > &events, std::vector< double > splitPoints)
	Convert splitPoints [hours] to breakPoints in ExpRunEvt.
TString	rn ()
	Get random string.
std::vector< std::vector< double > >	merge (std::vector< std::vector< std::vector< double > > > toMerge)
	merge { vector<double> a, vector<double> b} into {a, b}
Eigen::VectorXd	vec2vec (std::vector< double > vec)
	std vector -> ROOT vector
std::vector< double >	vec2vec (Eigen::VectorXd v)
	ROOT vector -> std vector.
Eigen::MatrixXd	vecs2mat (std::vector< std::vector< double > > vecs)
	merge columns (from std::vectors) into ROOT matrix
std::vector< double >	getRangeLin (int nVals, double xMin, double xMax)
	Equidistant range between xMin and xMax for spline of the first order.
std::vector< double >	getRangeZero (int nVals, double xMin, double xMax)
	Equidistant range between xMin and xMax for spline of the zero order.
std::vector< double >	slice (std::vector< double > v, unsigned ind, unsigned n)
	put slice of original vector v[ind:ind+n] into new one, n is number of elements
double	eval (const std::vector< double > &spl, const std::vector< double > &vals, double x)
	Evaluate spline (zero order or first order) in point x.
VectorXd	getPolsSum (int Size, VectorXd x)
	Calculate the Chebyshev polynomials of order i=0..Size-1 at points given in vector x_j and sum it over point index j It returns sum_j P_i(x_j) for i=0..Size-1 The Chebyshev polynomials are defined for x between 0 and 1.
double	evalPol (const VectorXd &polCoef, double x)
	Evaluate Cheb.
VectorXd	interpol (const VectorXd &xi, double x)
	Get Interpolation vector k_i for point x from the function values at points xi (polynomial interpolation) In the second step, the function value at x can be evaluated as sum_i vals_i k_i.
double	interpol (VectorXd xi, VectorXd vals, double x)
	Get interpolated function value at point x when function values vals at points xi are provided.
void	plotRuns (std::vector< std::pair< double, double > > runs)
	plot runs on time axis
void	plotSRuns (std::vector< std::pair< double, double > > runs, std::vector< int > breaks, int offset=2)
	plot clusters or runs on time axis
void	printBySize (std::vector< std::pair< double, double > > runs)
	print sorted lenghts of the runs
static ExpRun	getRun (std::map< ExpRun, std::pair< double, double > > runs, double t)
	Get exp number + run number from time.
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<typename Functor >
i2dMultiMap	createMultiMap (int nEntries, Functor funct)
	create a multimap with
template<typename Functor >
i2dMap	createMap (int nEntries, Functor funct)
	create a multimap with
	TEST_F (MapHelperFunctionsTest, testCreatorFunctions)
	test the methods that are use to create the maps for the later tests
	TEST_F (MapHelperFunctionsTest, testGetUniqueKeys)
	test if the 'getUniqueKeys' method returns the right values
	TEST_F (MapHelperFunctionsTest, testGetValuesToKey)
	test if the 'getValuesToKey' method returns the right values to a given key
	TEST_F (MapHelperFunctionsTest, testGetNValuesPerKey)
	test the 'getNValuesPerKey' method
	TEST_F (MapHelperFunctionsTest, testGetSortedKeyValueTuples)
	test if the 'getSortedKeyValuePairs' method actually works as advertised
	TEST_F (MapHelperFunctionsTest, testGetAllValues)
	test the getAllValues() function actually returns all values that are stored in the map
	TEST_F (SpacePointTest, testConstructorPXD)
	Test constructor for PXDClsuters tests the constructor importing a PXDCluster and tests results by using the getters of the spacePoint...
	TEST_F (SpacePointTest, testConstructorSVD)
	Test constructor for SVDClsuters tests the constructor importing a SVDCluster and tests results by using the getters of the spacePoint...
	TEST_F (SpacePointTest, testRootIOPXDCluster)
	Test if cluster writing in and reading from root files work.
	TEST_F (SpacePointTest, testRootIOB2Vector3)
	Test if B2Vector3 writing in and reading from root files work.
	TEST_F (SpacePointTest, testRootIOSP)
	Test if spacePoints writing in and reading from root files work.
	TEST_F (SpacePointTest, testConvertLocalToNormalizedCoordinates)
	Testing member of spacePoint: convertToNormalizedCoordinates.
	TEST_F (SpacePointTest, testConvertNormalizedToLocalCoordinates)
	Testing member of spacePoint: convertToLocalCoordinates.
	TEST_F (SpacePointTest, testGetNClustersAssigned)
	Test if the number of assigned Clusters is obtained correctly NOTE: using the same constructors as in previous tests!
	TEST_F (SpacePointTrackCandTest, testConstructorFromVector)
	Test the Constructor, that takes a vector of SpacePoint* as argument.
	TEST_F (SpacePointTrackCandTest, testEqualityOperator)
	Test operator == of SpacePointTrackCand.
	TEST_F (SpacePointTrackCandTest, testSetPdgCode)
	Test setPdgCode method, by comparing its results with the expected values for the according particles.
	TEST_F (SpacePointTrackCandTest, testGetHitsInRange)
	Test the get hits in range method.
	TEST_F (SpacePointTrackCandTest, testRefereeStatus)
	Test the setRefereeStatus and getRefereeStatus methods.
	TEST_F (SpacePointTrackCandTest, testRemoveSpacePoints)
	Test the removeSpacePoint method.
	TEST_F (SpacePointTrackCandTest, testGetSortedHits)
	Test setPdgCode method, by comparing its results with the expected values for the according particles.
	TEST_F (RecoTrackTest, cdcHit)
	Test simple Setters and Getters.
	TEST_F (RecoTrackTest, cdcHitMCFinderCategory)
	Test simple Correct handling fo the MCFinder hit classification.
	TEST_F (RecoTrackTest, testGenfitConversionOne)
	Test conversion to genfit track cands.
	TEST_F (RecoTrackTest, testGenfitConversionTwo)
	Test conversion from genfit track cands.
	TEST_F (RecoTrackTest, copyRecoTrack)
	Test copying a RecoTrack.
	TEST_F (RecoTrackTest, recoHitInformations)
	Test the getRecoHitInformations() function.
	TEST_F (RecoTrackTest, trackTime)
	Test getOutgoingArmTime() and getIngoingArmTime() functions.
	TEST_F (CollectorTFInfoTest, testAllInformationLoop)
	dummy comment: testAllInformationLoop
	TEST_F (FilterIDTest, simpleTest)
	Test simple Setters and Getters.
	TEST_F (FullSecIDTest, constructorAndGetterTests)
	Test simple Setters and Getters.
	TEST_F (FullSecIDTest, overloadedOperatorTests)
	testing the overloaded operators of the FullSecID-class
	TEST_F (FullSecIDTest, bufferOverflowTest)
	Unfinished test - shall test bufferOverflows...
	TEST_F (SandBox4TestingTest, testingVerbosityViaTemplates)
	test function call with auto-assigned value
	TEST_F (SandBox4TestingTest, JustSomePlayingAroundWithfunction)
	test function call with auto-assigned value
	TEST_F (SandBox4TestingTest, TestIsNanAndIsInfBehavior)
	shall show when to get nan and when to get inf (and that inf != nan)
	TEST_F (SectorTest, testConstructorSettersAndGetters)
	Test Constructor, Setters and Getters.
	TEST_F (ThreeHitFiltersTest, simpleTest)
	Test simple Setters and Getters.
	TEST_F (ThreeHitFiltersTest, TestMagneticField)
	the correctness of the magneticField-values (important for pT-related calculations)
	TEST_F (ThreeHitFiltersTest, TestAngles)
	the correctness of the angle calculators
	TEST_F (ThreeHitFiltersTest, TestSignAndOtherFilters)
	test sign, helixFit and calcDeltaSlopeRZ filters
	TEST_F (ThreeHitFiltersTest, TestDeltaSOverZ)
	test DeltaSOverZ
	TEST_F (ThreeHitFiltersTest, TestCalcPt)
	test cramer method in calcPt
	TEST_F (TwoHitFiltersTest, TestEmptyFilter)
	Test simple Setters and Getters by filling zeroes.
	TEST_F (TwoHitFiltersTest, TestFilledFilter)
	Test simple Setters and Getters by filling non-zero-values.
	TEST_F (TwoHitFiltersTest, testLargeFilter)
	Test simple Setters and Getters by filling extreme values.
B2Vector3D	outerHit (0, 0, 0)
	testing out of range behavior
	TEST_F (TwoHitFiltersTest, TestOutOfRangeNormedDistFilter)
	And now possibly the only case where TwoHitFilters produces wrong results.
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 ! for the Filter class.
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.
	SELECTION_VARIABLE (Difference, 2, double, static double value(const double &t1, const double &t2) { return t1 - t2;};)
	Quick definition of a selection variable implementing the difference of 2 doubles.
	SELECTION_VARIABLE (Sum, 2, double, static double value(const double &t1, const double &t2) { return t1+t2;};)
	Quick definition of a selection variable implementing the sum of 2 doubles.
	TEST_F (VariablesOnTTree, basic_test)
	Basic test of the class.
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.
	TEST_F (V0FitterTest, GetTrackHypotheses)
	Test getter for track hypotheses.
	TEST_F (V0FitterTest, InitializeCuts)
	Test initialization of cuts.
Eigen::VectorXd	getLogFunction (Pars pars) const
	Get the -2*log(p(x)) on the Cheb nodes.
void	init (int Size, double xMin, double xMax)
	Initialize the fitter (the Chebyshev coefficients)
double	getLogLikelihoodSlow (const Pars &pars) const
	Calculate log likelihood using exact formula.
double	getLogLikelihoodFast (const Pars &pars) const
	Calculate log likelihood using approximation based on Chebyshev polynomials (typically faster)
double	operator() (const double *par) const
	Evaluate the log likelihood.
Eigen::VectorXd	getDataGrid () const
	Calculate Chebyshev coefficients for the data set.
std::pair< Eigen::VectorXd, Eigen::MatrixXd >	getDataGridWithCov () const
	Calculate Chebyshev coefficients with the covariance (useful for toy studies)
std::pair< Pars, Eigen::MatrixXd >	fitData (Pars pars, Limits limits, bool UseCheb=true)
	Fit the data with specified initial values of parameters and limits on them.
double	getFunctionFast (const Pars &pars, double x)
	Evaluate the fitted function approximated with the Chebyshev polynomial, typically runs faster.
double	lossFunction (const std::vector< Atom > &vec, int s, int e) const
	lossFunction of the calibration interval consisting of several "atoms" stored in vector vec The atoms included in calibration interval have indices between s and e
static std::vector< std::pair< double, double > >	splitToSmall (std::map< ExpRun, std::pair< double, double > > runs, double intSize=1./60)
	Split the runs into small calibration intervals (atoms) of a specified size.
double	getMinLoss (const std::vector< Atom > &vec, int e, std::vector< int > &breaks)
	Recursive function to evaluate minimal sum of the lossFuctions for the optimal clustering.
std::vector< int >	dynamicBreaks (const std::vector< Atom > &runs)
	Get optimal break points using algorithm based on dynamic programing.
static std::map< ExpRun, std::pair< double, double > >	mergeIntervals (std::map< ExpRun, std::pair< double, double > > I1, std::map< ExpRun, std::pair< double, double > > I2)
	Merge two subintervals into one subinterval.
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 signal before the start of the event processing.
void	beginRun () override
	Receive 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.
void	import_sectors_standard ()
	dummy comment: import_sectors_standard
void	import_clusters_standard ()
	dummy comment: import_clusters_standard
void	import_sectors_loop ()
	Documentation Comment Jakob Lettenbichler: this was written by a student and will be removed after finishing redesign of VXDTF.
void	import_clusters_loop ()
	dummy comment: import_clusters_loop
void	import_hit_standard ()
	dummy comment: import_hit_standard
void	import_hit_loop ()
	dummy comment: import_hit_loop
void	import_cell_standard ()
	dummy comment: import_cell_standard
void	import_cell_loop ()
	dummy comment: import_cell_loop
void	import_tfc_standard ()
	dummy comment: import_tfc_standard
void	import_tfc_loop ()
	dummy comment: import_tfc_loop
void	getAllCells ()
	Output of all interesting Information of Cells.
void	getAllHits ()
	Output of all interesting Information of Hits.
void	getAllClusters ()
	Output of all interesting Information of Clusters.
void	getAllTC ()
	Output of all interesting Information of TC.
void	getAllSectors ()
	Output of all interesting Information of Sectors.
	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.
static VectorType	s_origin = VectorType(0, 0, 0)
	stores the origin used for some calculations, can be set here
static bool	m_storeRefTCDataForTestTC = false
	if true, for testTC the values of attached refTC will be stored instead of own values.
static DataType	s_MagneticFieldFactor
	is factor containing speed of light (c), the magnetic field (b) and the scaling factor s for conversion of meter in cm : c*b/100 = c*b*s.

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.

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

using EventTimeExtractorModule = TrackFindingCDC::FindletModule < TrackFindingCDC::FindletStoreArrayInput<BaseEventTimeExtractorModuleFindlet<AFindlet> > >

Alias for the event time extraction module.

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

i2dMap

typedef std::unordered_map<int, double> i2dMap

typedef for less writing effort

Definition at line 29 of file mapHelperFunctions.cc.

i2dMultiMap

typedef std::unordered_multimap<int, double> i2dMultiMap

typedef for less writing effort

Definition at line 28 of file mapHelperFunctions.cc.

Limits

typedef std::map<std::string, std::pair<double, double> > Limits

limits of parameters in ML fit

Definition at line 28 of file ChebFitter.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.

Pars

typedef std::map<std::string, double> Pars

values of parameters in ML fit

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

addShortRun()

void addShortRun ( std::vector< CalibrationData > &  calVec, std::pair< ExpRun, std::pair< double, double > >  shortRun  )

inline

Extrapolate calibration to the very short runs which were filtered before.

Definition at line 151 of file calibTools.h.

  {
    double shortStart = shortRun.second.first;
    double shortEnd   = shortRun.second.second;
 
    double distMin = 1e20;
    int iMin = -1, jMin = -1;
 
    for (unsigned i = 0; i < calVec.size(); ++i) {
      if (calVec[i].isCalibrated == false)
        continue;
      for (unsigned j = 0; j < calVec[i].subIntervals.size(); ++j) {
        for (auto I : calVec[i].subIntervals[j]) {
          double s = I.second.first;
          double e = I.second.second;
 
          double dist1 = (s - shortEnd >= 0)   ? (s - shortEnd) : 1e20;
          double dist2 = (shortStart - e >= 0) ? (shortStart - e) : 1e20;
          double dist = std::min(dist1, dist2);
 
          if (dist < distMin) {
            distMin = dist;
            iMin = i;
            jMin = j;
          }
        }
      }
    }
 
    B2ASSERT("Must be found", iMin != -1 && jMin != -1);
    calVec[iMin].subIntervals[jMin].insert(shortRun);
  }

analyze()

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

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

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

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

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]

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() [2/14]

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() [3/14]

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

apply() [4/14]

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() [5/14]

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() [6/14]

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

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() [8/14]

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() [9/14]

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]

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() [11/14]

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() [12/14]

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() [13/14]

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

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

arcLengthInRightDirection()

constexpr 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()

BaseEventTimeExtractorModuleFindlet

Add the subfindlet as listener.

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

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

beginEvent() [1/2]

void beginEvent

overridevirtual

Clear the used clusters.

Reimplemented from ProcessingSignalListener.

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

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

beginEvent() [2/2]

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

beginRun() [1/3]

void beginRun

finalvirtual

Initialize the maximal ladder cache.

Reimplemented from ProcessingSignalListener.

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() [2/3]

void beginRun ( )

finalvirtual

Initialize the sector map.

Reimplemented from ProcessingSignalListener.

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!");
    }
  }

beginRun() [3/3]

void beginRun

overridevirtual

Receive signal for the beginning of a new run.

Reimplemented from ProcessingSignalListener.

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

breaks2intervalsSep()

std::vector< std::map< ExpRun, std::pair< double, double > > > breaks2intervalsSep	(	const std::map< ExpRun, std::pair< double, double > > &	runsMap,
		const std::vector< Atom > &	currVec,
		const std::vector< int > &	breaks
	)

Get calibration intervals according to the indexes of the breaks.

Parameters

runsMap	map defining the time ranges of the runs
currVec	vector with time intervals of the atoms (small non-divisible time intervals)
breaks	vector with integer indexes of the breaks

Returns

: a vector of the calib. intervals where each interval is a map with exp-run as a key and start- end-time as a value

Definition at line 280 of file Splitter.cc.

  {
    std::vector<std::map<ExpRun, std::pair<double, double>>> splitsNow(breaks.size() + 1);
    for (int i = 0; i < int(breaks.size()) + 1; ++i) {
      int s, e;
      std::tie(s, e) = getStartEndIndexes(currVec.size(), breaks, i);
 
      // loop over atoms in single calib interval
      for (int k = s; k <= e; ++k) {
        ExpRun r = getRun(runsMap, (currVec[k].t1 + currVec[k].t2) / 2.); //runexp of the atom
        if (splitsNow[i].count(r)) { //if already there
          splitsNow[i].at(r).first  = std::min(splitsNow[i].at(r).first, currVec[k].t1);
          splitsNow[i].at(r).second = std::max(splitsNow[i].at(r).second, currVec[k].t2);
        } else { //if new
          splitsNow[i][r].first  = currVec[k].t1;
          splitsNow[i][r].second = currVec[k].t2;
        }
      }
    }
 
    return splitsNow;
  }

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

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 substract 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()

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

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

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

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

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

convertSplitPoints()

std::vector< ExpRunEvt > convertSplitPoints	(	const std::vector< Evt > &	events,
		std::vector< double >	splitPoints
	)

Convert splitPoints [hours] to breakPoints in ExpRunEvt.

Parameters

events	vector of events
splitPoints	the vector containing times of the edges of the calibration intervals [hours]

Returns

a vector with calibration break-points in the exp-run-evt format

Definition at line 363 of file Splitter.h.

  {
 
    std::vector<ExpRunEvt>  breakPos;
    for (auto p : splitPoints) {
      auto pos = getPosition(events, p);
      breakPos.push_back(pos);
    }
    return breakPos;
  }

convertToEigen() [1/2]

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]

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

createMap()

i2dMap createMap	(	int	nEntries,
		Functor	funct
	)

create a multimap with

Parameters

nEntries	entries.
funct	Function object which values are used to determine the keys by the return value of funct.operator() NOTE: funct.operator has to take an int and return a double

Definition at line 52 of file mapHelperFunctions.cc.

  {
    i2dMap map;
    for (int i = 0; i < nEntries; ++i) {
      map.insert(std::make_pair(i, funct.operator()(i)));
    }
    return map;
  }

createMultiMap()

i2dMultiMap createMultiMap	(	int	nEntries,
		Functor	funct
	)

create a multimap with

Parameters

nEntries	entries.
funct	Function object which values are used to determine the keys by the return value of funct.operator() NOTE: funct.operator has to take an int and return a double

Definition at line 37 of file mapHelperFunctions.cc.

  {
    i2dMultiMap map;
    for (int i = 0; i < nEntries; ++i) {
      map.insert(std::make_pair((i % 6), funct.operator()(i)));
    }
    return map;
  }

createPurityInfos() [1/2]

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]

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

decodeNumber()

unsigned decodeNumber ( double  val )

inline

Decode the integer number encoded in val.

Definition at line 208 of file calibTools.h.

  {
    double factor = pow(FLT_RADIX, DBL_MANT_DIG);
    static const long long fEnc   = pow(2, 32); //32 binary digits  for encoded number
 
    int e;
    double mantisa = std::frexp(val, &e);
    long long mantisaI = mantisa * factor;
 
    return (mantisaI % fEnc);
  }

decorrelate() [1/3]

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]

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]

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

dynamicBreaks()

std::vector< int > dynamicBreaks ( const std::vector< Atom > &  runs )

private

Get optimal break points using algorithm based on dynamic programing.

Parameters

runs	Vector of atoms, where each atom is an intervals in time

Returns

: Optimal indexes of the break points

Definition at line 241 of file Splitter.cc.

  {
    //reset cache
    cache.resize(runs.size());
    for (auto& c : cache)
      c = std::make_pair(-1.0, std::vector<int>({}));
 
 
    std::vector<int> breaks;
    getMinLoss(runs, runs.size() - 1, breaks); //the minLoss (output) currently not used, only breaks
 
    return breaks;
  }

encodeNumber()

double encodeNumber ( double  val, unsigned  num  )

inline

Encode integer num into double val such that val is nearly not changed (maximally by a relative shift 1e-6).

It is use to store time information to the payloads

Definition at line 186 of file calibTools.h.

  {
    double factor = pow(FLT_RADIX, DBL_MANT_DIG);
    static const long long fEnc   = pow(2, 32); //32 binary digits  for encoded number
 
    int e; //exponent of the number
    double mantisa = std::frexp(val, &e);
    long long mantisaI = mantisa * factor; //mantissa as integer
 
    if (val != 0)
      mantisaI = (mantisaI / fEnc) * fEnc  + num; //adding encoded number to last digits of mantissa
    else {
      mantisaI = factor / 2 + num;
      e = -100; //if the val is zero, ensure very small number by the exponent
    }
 
    double newVal = ldexp(mantisaI / factor, e);
 
    return newVal;
  }

eval()

double eval ( const std::vector< double > &  spl, const std::vector< double > &  vals, double  x  )

inline

Evaluate spline (zero order or first order) in point x.

Definition at line 115 of file tools.h.

  {
    int order = -1;
    if (spl.size() == 0)
      order = 0;
    else if (spl.size() == vals.size() - 1)
      order = 0;
    else if (spl.size() == vals.size())
      order = 1;
    else {
      B2FATAL("Unknown order of spline");
    }
    B2ASSERT("Spline order should be zero or one", order == 0 || order == 1);
 
    if (order == 1) {
      B2ASSERT("Linear spline only meaningful for two or more nodes", spl.size() >= 2);
      B2ASSERT("As nodes as values in lin. spline", spl.size() == vals.size());
 
      if (x <= spl[0]) return vals[0];
      if (x >= spl.back()) return vals.back();
 
      // binary search for position
      int i1 = lower_bound(spl.begin(), spl.end(), x) - spl.begin() - 1;
 
      if (!(spl[i1] <= x && x <= spl[i1 + 1])) {
        B2FATAL("Wrong place founded : " <<  spl[i1] << " " << x << " " << spl[i1 + 1]);
      }
 
      // Linear interpolation between neighbouring nodes
      double v = ((spl[i1 + 1] - x) * vals[i1] + (x - spl[i1]) * vals[i1 + 1]) / (spl[i1 + 1] - spl[i1]);
      return v;
    } else if (order == 0) { //zero order polynomial
      B2ASSERT("#values vs #nodes in zero-order spline", spl.size() + 1 == vals.size());
      if (vals.size() == 1) {
        return vals[0];
      } else {
        double res = vals[0]; //by default value from lowest node
        for (unsigned i = 0; i < spl.size(); ++i) {
          if (spl[i] <= x) res = vals[i + 1];
          else break;
        }
        return res;
      }
    }
    return -99;
  }

evalPol() [1/2]

double evalPol	(	const Eigen::VectorXd &	polCoef,
		double	x
	)

Evaluate Cheb.

pol at point x when the coefficients of the expansion are provided

evalPol() [2/2]

double evalPol	(	const VectorXd &	polCoef,
		double	x
	)

Evaluate Cheb.

pol at point x when the coefficients of the expansion are provided

Definition at line 176 of file nodes.cc.

  {
    VectorXd pols = getPols(polCoef.size(), x);
 
    double s = pols.dot(polCoef);
 
    return s;
  }

exposeParameters() [1/17]

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

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from Findlet< AState, AState, TrackFindingCDC::WeightedRelation< AState > >.

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() [2/17]

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

finalvirtual

Expose parameters of the subfilters and the layer to change.

Reimplemented from Findlet< const TrackFindingCDC::WithWeight< const AState * >, TrackFindingCDC::WithWeight< AState * > >.

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() [3/17]

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

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from Findlet< AFilter::Object, AFilter::Object >.

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() [4/17]

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

finalvirtual

Expose the parameters.

Reimplemented from Findlet< AIOTypes >.

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

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

exposeParameters() [5/17]

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

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from Findlet< const TrackFindingCDC::WithWeight< const AState * >, TrackFindingCDC::WithWeight< AState * > >.

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() [6/17]

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

finalvirtual

Expose the parameters of the subfindlet.

Reimplemented from Findlet< const AState, AState, const TrackFindingCDC::WeightedRelation< AState >, AResult >.

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

exposeParameters() [7/17]

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

finalvirtual

Expose the parameters of the filter.

Reimplemented from Filter< AObject >.

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]

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

finalvirtual

Expose the parameters of the filter.

Reimplemented from Filter< AObject >.

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() [9/17]

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() [10/17]

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

overridevirtual

Expose the parameters of the subfindlet.

Reimplemented from Findlet< const TrackFindingCDC::WithWeight< const AState * >, TrackFindingCDC::WithWeight< AState * > >.

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() [11/17]

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

overridevirtual

Expose the parameters of the sub findlets.

Reimplemented from Findlet< AResult >.

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() [12/17]

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

overridevirtual

Expose the parameters of the findlet.

Reimplemented from Findlet< AIOTypes >.

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() [13/17]

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

overridevirtual

Expose the parameters of the filter.

Reimplemented from Filter< AObject >.

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() [14/17]

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

overridevirtual

Expose our parameters to the super module.

Reimplemented from Findlet< AIOTypes... >.

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

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() [15/17]

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() [16/17]

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

finaloverridevirtual

Expose our parameters to the super module.

Reimplemented from Findlet< RecoTrack * >.

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

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

exposeParameters() [17/17]

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

extrapolateCalibration()

void extrapolateCalibration ( std::vector< CalibrationData > &  calVec )

inline

Extrapolate calibration to intervals where it failed.

Definition at line 102 of file calibTools.h.

  {
    //put closest neighbor, where the statistic was low or algo failed
    for (unsigned i = 0; i < calVec.size(); ++i) {
      if (calVec[i].pars.cnt.size() != 0) continue;
      const auto& r =  calVec[i].subIntervals;
      double Start, End;
      std::tie(Start, End) = Splitter::getStartEnd(r);
 
      Eigen::Vector3d ipNow;
      Eigen::MatrixXd ipeNow;
      Eigen::MatrixXd sizeMatNow;
 
      double distMin = 1e20;
      //Find the closest calibrated interval
      for (unsigned j = 0; j < calVec.size(); ++j) {
        if (calVec[j].isCalibrated == false) continue; //skip not-calibrated intervals
        const auto& rJ = calVec[j].subIntervals;
        for (unsigned jj = 0; jj < rJ.size(); ++jj) { //loop over subintervals
          const auto& rNow = rJ[jj];
          double s = rNow.begin()->second.first;
          double e = rNow.rbegin()->second.second;
 
          double dist1 = (s - End >= 0) ? (s - End) : 1e20;
          double dist2 = (Start - e >= 0) ? (Start - e) : 1e20;
          double dist = std::min(dist1, dist2);
 
          if (dist < distMin) {
            ipNow = calVec[j].pars.cnt.at(jj);
            ipeNow = calVec[j].pars.cntUnc.at(jj);
            sizeMatNow = calVec[j].pars.spreadMat;
            distMin = dist;
          }
        }
      }
 
      //Store it to vectors
      calVec[i].pars.cnt.resize(r.size());
      calVec[i].pars.cntUnc.resize(r.size());
      for (unsigned ii = 0; ii < r.size(); ++ii) {
        calVec[i].pars.cnt.at(ii) = ipNow;
        calVec[i].pars.cntUnc.at(ii) = ipeNow;
      }
      calVec[i].pars.spreadMat = sizeMatNow;
    }
 
  }

fillInterceptList()

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

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

filter()

std::map< ExpRun, std::pair< double, double > > filter	(	const std::map< ExpRun, std::pair< double, double > > &	runs,
		double	cut,
		std::map< ExpRun, std::pair< double, double > > &	runsRemoved
	)

filter events to remove runs shorter than cut, it stores removed runs in runsRemoved

Definition at line 38 of file Splitter.cc.

  {
    std::map<ExpRun, std::pair<double, double>> runsCopy;
 
    for (auto r : runs) {
      auto& I = r.second;
      double d =  I.second - I.first;
      if (d > cut)
        runsCopy[r.first] = r.second;
      else
        runsRemoved[r.first] = r.second;
    }
 
    return runsCopy;
  }

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

fitData()

std::pair< Pars, MatrixXd > fitData	(	Pars	pars,
		Limits	limits,
		bool	UseCheb = true
	)

Fit the data with specified initial values of parameters and limits on them.

Definition at line 155 of file ChebFitter.cc.

  {
    m_useCheb = UseCheb;
 
    ROOT::Math::Minimizer* minimum =
      ROOT::Math::Factory::CreateMinimizer("Minuit2", "");
 
    // set tolerance , etc...
    minimum->SetMaxFunctionCalls(10000000); // for Minuit/Minuit2
    minimum->SetMaxIterations(100000);  // for GSL
    minimum->SetTolerance(10.0);
    //minimum->SetPrecision(1e-5);
 
    //minimum->SetPrintLevel(3); //many outputs
    minimum->SetPrintLevel(0); //few outputs
    minimum->SetStrategy(2);
    minimum->SetErrorDef(1);
 
 
    // Set the free variables to be minimized !
    m_parNames.clear();
    int k = 0;
    for (auto p : pars) {
      std::string n    = p.first;
      double vCnt = p.second;
      if (limits.count(n) == 1) {
        double vMin = limits.at(n).first;
        double vMax = limits.at(n).second;
        double step = (vMax - vMin) / 100;
        minimum->SetLimitedVariable(k, n, vCnt, step, vMin, vMax);
      } else {
        double step = 1;
        minimum->SetVariable(k, n, vCnt, step);
      }
      m_parNames.push_back(n);
      ++k;
    }
 
    // create function wrapper for minimizer
    // a IMultiGenFunction type
    ROOT::Math::Functor f(*this, pars.size());
    minimum->SetFunction(f);
 
 
    // do the minimization
    minimum->Minimize();
 
 
    Pars parsF;
    for (unsigned i = 0; i < m_parNames.size(); ++i)
      parsF[m_parNames[i]] = minimum->X()[i];
 
    MatrixXd covMat(parsF.size(), parsF.size());
    for (unsigned i = 0; i < parsF.size(); ++i)
      for (unsigned j = 0; j < parsF.size(); ++j)
        covMat(i, j) = minimum->CovMatrix(i, j);
 
    // print pars
    std::stringstream log;
    log << "Minuit status : " << minimum->Status() << ", ";
    for (auto p : parsF)
      log << "\"" << p.first << "\" : " << p.second << ", ";
 
    B2INFO(log.str());
 
    delete minimum;
 
    return std::make_pair(parsF, covMat);
  }

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
  }

getAllCells()

void getAllCells

(

)

Output of all interesting Information of Cells.

Definition at line 374 of file collectortfinfo.h.

  {
    for (uint i = 0; i <  m_collector.m_cellTF.size(); i++) {
      B2INFO("* Cell ID: " << i << "; active: " << m_collector.m_cellTF[i].getActive() << ", died_at: " <<
             m_collector.m_cellTF[i].getDiedAt() << "; m_assigned_hits_ids - size: " << m_collector.m_cellTF[i].getAssignedHits().size() <<
             "; Neighbours - size: " << m_collector.m_cellTF[i].getNeighbours().size() << "; State: " << m_collector.m_cellTF[i].getState() <<
             "; use counter: " << m_collector.m_cellTF[i].getUseCounter());
    }
  }

getAllClusters()

void getAllClusters

(

)

Output of all interesting Information of Clusters.

Definition at line 397 of file collectortfinfo.h.

  {
    for (uint i = 0; i <  m_collector.m_clustersTF.size(); i++) {
      B2INFO("* Cluster ID: " << i << "; active: " << m_collector.m_clustersTF[i].getActive() << ", died_at: " <<
             m_collector.m_clustersTF[i].getDiedAt() << "; Real Cluster ID: " <<
             m_collector.m_clustersTF[i].getRealClusterID() << "; Detector Type: "
             << m_collector.m_clustersTF[i].getDetectorType() << "; use counter: " << m_collector.m_clustersTF[i].getUseCounter());
    }
  }

getAllHits()

void getAllHits

(

)

Output of all interesting Information of Hits.

Definition at line 386 of file collectortfinfo.h.

  {
    for (uint i = 0; i <  m_collector.m_hitTF.size(); i++) {
      B2INFO("* Hit ID: " << i << "; active: " << m_collector.m_hitTF[i].getActive() << ", died_at: " <<
             m_collector.m_hitTF[i].getDiedAt() << "; m_assigned_cluster - size: " << m_collector.m_hitTF[i].getAssignedCluster().size() <<
             "; UseTC IDs - size: " << m_collector.m_hitTF[i].getUseCounterTCIDs().size() <<
             "; use counter: " << m_collector.m_hitTF[i].getUseCounter() << "; SectorID: " << m_collector.m_hitTF[i].getSectorID());
    }
  }

getAllSectors()

void getAllSectors

(

)

Output of all interesting Information of Sectors.

Definition at line 421 of file collectortfinfo.h.

  {
    for (auto& akt_sector : m_collector.m_sectorTF) {
      B2INFO("* Sector ID: " << akt_sector.second.getSectorID() << "; active: " << akt_sector.second.getActive() << ", died_at: " <<
             akt_sector.second.getDiedAt() << "; is only friend: " <<
             akt_sector.second.getIsOnlyFriend() << "; Friends - size: "
             << akt_sector.second.getFriends().size() << "; use counter: " << akt_sector.second.getUseCounter());
    }
  }

getAllTC()

void getAllTC

(

)

Output of all interesting Information of TC.

Definition at line 409 of file collectortfinfo.h.

  {
    for (uint i = 0; i <  m_collector.m_tfCandTF.size(); i++) {
      B2INFO("* TC ID: " << i << "; active: " << m_collector.m_tfCandTF[i].getActive() << ", died_at: " <<
             m_collector.m_tfCandTF[i].getDiedAt() << "; Own ID: " <<
             m_collector.m_tfCandTF[i].getOwnID() << "; AssignedCells - size: " <<
             m_collector.m_tfCandTF[i].getAssignedCell().size());
    }
  }

getAllValues()

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

getCoefs()

MatrixXd getCoefs	(	int	Size,
		bool	isInverse = false
	)

Transformation matrix between Cheb nodes and coefficients of the Cheb polynomials Notice, that there are two alternative ways defining polynomial interpolation:

• coefficients c_i in of the Cheb polynomials, i.e. f(x) = sum_i c_i P_i(x)
• Values of the f(x) in the Cheb nodes, i.e. d_j = f(x_j), where x_j are the nodes The Chebyshev polynomials are defined for x between 0 and 1

Definition at line 127 of file nodes.cc.

  {
    const int N = Size - 1;
    assert(N % 2 == 0);
 
    MatrixXd  coef(Size, Size);
 
    double mul = 1;
    double C = 1. / N;
    if (isInverse == true) {C = 1. / 2; }
 
    for (int k = 0; k <= N; ++k) {
      if (!isInverse) {
        coef(k, N) = C;
        coef(k, 0) = C * (k % 2 == 1 ? -1 : 1);
      } else {
        mul = k % 2 == 1 ? -1 : 1;
        coef(N - k, N) = C * mul;
        coef(N - k, 0) = C ;
      }
 
      for (int n = 1; n <= N - 1; ++n) {
        double el = cos(n * k * M_PI / N) * 2.*C * mul;
        if (!isInverse) coef(k, N - n) = el;
        else           coef(N - k, N - n) = el;
      }
    }
 
    return coef;
  }

getCoefsCheb()

MatrixXd getCoefsCheb

(

int

oldSize

)

Transformation matrix between Cheb nodes and Cheb coefficients with better normalization of the borders.

Definition at line 162 of file nodes.cc.

  {
    auto coef = getCoefs(oldSize);
 
    coef.row(0) *= 0.5;
    coef.row(coef.rows() - 1) *= 0.5;
 
    return coef;
  }

getDataGrid()

VectorXd getDataGrid ( ) const

private

Calculate Chebyshev coefficients for the data set.

Definition at line 109 of file ChebFitter.cc.

  {
    double a = m_nodes[0];
    double b = m_nodes[m_nodes.size() - 1];
 
 
    VectorXd polSum = VectorXd::Zero(m_nodes.size());
    for (double x : m_data) {
      double xx = (x - a) / (b - a); //normalize between 0 and 1
      polSum += getPols(m_nodes.size(), xx);
    }
 
 
    //transform to the basis of the cheb m_nodes
    VectorXd gridVals = m_coefsMat * polSum;
 
    return gridVals;
  }

getDataGridWithCov()

std::pair< VectorXd, MatrixXd > getDataGridWithCov ( ) const

private

Calculate Chebyshev coefficients with the covariance (useful for toy studies)

Definition at line 130 of file ChebFitter.cc.

  {
    double a = m_nodes[0];
    double b = m_nodes[m_nodes.size() - 1];
 
    MatrixXd polSum2 = MatrixXd::Zero(m_nodes.size(), m_nodes.size());
    VectorXd polSum  = VectorXd::Zero(m_nodes.size());
    for (double x : m_data) {
      double xx = (x - a) / (b - a); //normalize between 0 and 1
      VectorXd pol = getPols(m_nodes.size(), xx);
      polSum  += pol;
      polSum2 += pol * pol.transpose();
    }
 
 
    //transform to the basis of the cheb nodes
    MatrixXd coefs = getCoefsCheb(polSum.size()).transpose();
    VectorXd gridVals = coefs * polSum;
    MatrixXd gridValsCov = coefs * polSum2 * coefs.transpose();
 
    return std::make_pair(gridVals, gridValsCov);
  }

getFunctionFast()

double getFunctionFast ( const Pars &  pars, double  x  )

private

Evaluate the fitted function approximated with the Chebyshev polynomial, typically runs faster.

Definition at line 226 of file ChebFitter.cc.

  {
    static VectorXd funVals = getLogFunction(pars);
 
 
    return  exp(-0.5 * interpol(m_nodes, funVals, x));
 
  }

getID()

int getID ( const std::vector< double > &  breaks, double  t  )

inline

get id of the time point t

Definition at line 60 of file calibTools.h.

  {
    for (int i = 0; i < int(breaks.size()) + 1; ++i) {
      double s = (i == 0)             ? 0 : breaks[i - 1];
      double e = (i == int(breaks.size())) ? 1e20 : breaks[i];
      if (s  <= t   &&  t < e)
        return i;
    }
    return -1;
  }

getLogFunction()

VectorXd getLogFunction ( Pars  pars ) const

private

Get the -2*log(p(x)) on the Cheb nodes.

Definition at line 43 of file ChebFitter.cc.

  {
    VectorXd fVals(m_nodes.size());
 
    //calc function values
    fVals = m_nodes.unaryExpr([&](double x) { return m_myFun(x, pars); });
 
    //normalize the function
    double I = fVals.dot(m_weights);
 
    fVals = -2 * log(fVals.array() / I); //normalize by integral
 
    return fVals;
 
  }

getLogLikelihoodFast()

double getLogLikelihoodFast ( const Pars &  pars ) const

private

Calculate log likelihood using approximation based on Chebyshev polynomials (typically faster)

Definition at line 89 of file ChebFitter.cc.

  {
    VectorXd funVals = getLogFunction(pars);
    double LL = funVals.dot(m_dataGrid);
 
    return LL;
  }

getLogLikelihoodSlow()

double getLogLikelihoodSlow ( const Pars &  pars ) const

private

Calculate log likelihood using exact formula.

Definition at line 76 of file ChebFitter.cc.

  {
 
    double L = 0;
    for (double d : m_data) {
      double v = m_myFun(d, pars);
      L += -2 * log(v);
    }
 
    return L;
  }

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

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

getMinima()

std::pair< double, double > getMinima ( std::vector< std::vector< double > >  vals, int  i0, int  j0  )

inline

Get minimum inside and outside of the smaller window defined by i0, j0.

Definition at line 23 of file minimizer.h.

  {
    int N = vals.size();
    int Nzoom = (N + 1) / 2;
 
 
    double minIn  = std::numeric_limits<double>::max();
    double minOut = std::numeric_limits<double>::max();
 
    for (int i = 0; i < N; ++i)
      for (int j = 0; j < N; ++j) {
        if ((i0 <= i && i < i0 + Nzoom) &&
            (j0 <= j && j < j0 + Nzoom))
          minIn = std::min(minIn, vals[i][j]);
        else
          minOut = std::min(minOut, vals[i][j]);
      }
    return {minIn, minOut};
  }

getMinimum()

std::vector< double > getMinimum ( std::function< double(double, double)>  fun, double  xMin, double  xMax, double  yMin, double  yMax  )

inline

Get minimum of 2D function in the rectangular domain defined by xMin,xMax & yMin,yMax.

Definition at line 44 of file minimizer.h.

  {
    const int N = 17; //the grid has size N x N
    const int Nzoom = (N + 1) / 2; // the size of the zoomed rectangle where minimum is
 
 
    const int kMax = 35; //number of iterations
 
    std::vector<std::vector<double>> vals(N);
    for (auto& v : vals) v.resize(N);
 
    for (int k = 0; k < kMax; ++k) {
 
      // get values of the function
      for (int i = 0; i < N; ++i)
        for (int j = 0; j < N; ++j) {
          double x = xMin + i * (xMax - xMin) / (N - 1.);
          double y = yMin + j * (yMax - yMin) / (N - 1.);
          vals[i][j] = fun(x, y);
        }
 
      if (k == kMax - 1) break;
 
      double mOutMax = - std::numeric_limits<double>::max();
      int iOpt = -1, jOpt = -1;
      //find optimal rectangle
      for (int i = 0; i < N - Nzoom; ++i)
        for (int j = 0; j < N - Nzoom; ++j) {
          double mIn, mOut;
          std::tie(mIn, mOut) = getMinima(vals, i, j);
 
          if (mOut > mOutMax) {
            mOutMax = mOut;
            iOpt = i;
            jOpt = j;
          }
        }
 
      //Zoom to the optimal rectangle
      // get values of the function
 
      double xMinNow = xMin + iOpt * (xMax - xMin) / (N - 1.);
      double xMaxNow = xMin + (iOpt + Nzoom - 1) * (xMax - xMin) / (N - 1.);
 
      double yMinNow = yMin + jOpt * (yMax - yMin) / (N - 1.);
      double yMaxNow = yMin + (jOpt + Nzoom - 1) * (yMax - yMin) / (N - 1.);
 
      xMin = xMinNow;
      xMax = xMaxNow;
      yMin = yMinNow;
      yMax = yMaxNow;
 
    }
 
 
    //get the overall minimum
    double minTot = std::numeric_limits<double>::max();
    int iOpt = -1, jOpt = -1;
 
    for (int i = 0; i < N; ++i)
      for (int j = 0; j < N; ++j) {
        if (vals[i][j] < minTot) {
          minTot = vals[i][j];
          iOpt = i;
          jOpt = j;
        }
      }
 
    double xMinNow = xMin + iOpt * (xMax - xMin) / (N - 1.);
    double yMinNow = yMin + jOpt * (yMax - yMin) / (N - 1.);
 
    return {xMinNow, yMinNow};
  }

getMinLoss()

double getMinLoss ( const std::vector< Atom > &  vec, int  e, std::vector< int > &  breaks  )

private

Recursive function to evaluate minimal sum of the lossFuctions for the optimal clustering.

It return the minimum of the lossFunction and optimal break points giving such value. It acts only on atoms with indexes between 0 and e

Parameters

	vec	Vector of atoms, where each atom is an intervals in time
	e	the index of the last atom included in the optimisation problem
[out]	breaks	Output vector with indexes of optimal break points

Returns

: Minimal value of the summed loss function

Definition at line 204 of file Splitter.cc.

  {
    // If entry in cache (speed up)
    if (cache[e].first >= 0) {
      breaks = cache[e].second;
      return cache[e].first;
    }
 
 
    std::vector<int> breaksOpt;
    double minVal = 1e30;
    int iMin = -10;
    for (int i = -1; i <= e - 1; ++i) {
      auto breaksNow = breaks;
      double r1 = 0;
      if (i != -1)
        r1 = getMinLoss(vec, i, breaksNow);
      double r2 = lossFunction(vec, i + 1, e);
      double tot = r1 + r2;
 
      if (tot < minVal) { //store minimum
        minVal = tot;
        iMin = i;
        breaksOpt = breaksNow;
      }
    }
 
    if (iMin != -1)
      breaksOpt.push_back(iMin);
 
 
    breaks = breaksOpt;
    cache[e] = std::make_pair(minVal, breaks); //store solution to cache
    return minVal;
  }

getNodes()

VectorXd getNodes

(

int

Size

)

Get the vector of positions of the Chebyshev nodes The nodes are by definition between 0 and 1, there are Size nodes For the corresponding weights use getWeights.

Definition at line 65 of file nodes.cc.

  {
    assert((Size - 1) % 2 == 0);
    VectorXd xi = VectorXd::Zero(Size);
    for (int i = 0; i < Size; ++i) {
      double Cos = cos(i / (Size - 1.) * M_PI);
      xi[i] = (1 - Cos) / 2;
    }
    return xi;
  }

getNValuesPerKey()

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

getPols()

VectorXd getPols	(	int	Size,
		double	x
	)

Evaluate Chebyshev polynomials up to Size at point x It returns a vector of the P_i(x) for i=0..Size-1 The polynomial is defined for x between 0 and 1.

Definition at line 77 of file nodes.cc.

  {
    VectorXd pol(Size);
    double C = 2 * (2 * x - 1);
 
    if (Size >= 1) pol[0] = 1;
    if (Size >= 2) pol[1] = C / 2;
 
    for (int i = 2; i < Size; ++i)
      pol[i] = C * pol[i - 1] - pol[i - 2];
    return pol;
  }

getPolsSum()

VectorXd getPolsSum	(	int	Size,
		VectorXd	x
	)

Calculate the Chebyshev polynomials of order i=0..Size-1 at points given in vector x_j and sum it over point index j It returns sum_j P_i(x_j) for i=0..Size-1 The Chebyshev polynomials are defined for x between 0 and 1.

Definition at line 96 of file nodes.cc.

  {
    assert(Size > 2);
 
    VectorXd polSum(Size);
 
    VectorXd pol0 = 0 * x.array() + 1;
    VectorXd pol1 = 2 * x.array() - 1;
    VectorXd C    = 2 * pol1;
 
    VectorXd pol2(x.size());
    for (int i = 2; i < Size; ++i) {
      polSum(i - 2) = pol0.sum();
 
      pol2 = C.array() * pol1.array() - pol0.array();
 
      pol0 = pol1;
      pol1 = pol2;
    }
 
    polSum(Size - 2) = pol0.sum();
    polSum(Size - 1) = pol1.sum();
 
    return polSum;
  }

getPosition()

ExpRunEvt getPosition ( const std::vector< Evt > &  events, double  tEdge  )

inline

Get the exp-run-evt number from the event time [hours].

Parameters

events	vector of events
tEdge	the event time of the event of interest [hours]

Returns

the position of the time point in the exp-run-evt format

Definition at line 341 of file Splitter.h.

  {
    ExpRunEvt evt(-1, -1, -1);
    double tBreak = -1e10;
    for (auto& e : events) {
      if (e.t < tEdge) {
        if (e.t > tBreak) {
          tBreak = e.t;
          evt =  ExpRunEvt(e.exp, e.run, e.evtNo);
        }
      }
    }
    return evt;
  }

getPossibleTos() [1/2]

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

override

Return all states the given state is possible related to.

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

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

final

Return all states the given state is possible related to.

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

getRangeLin()

std::vector< double > getRangeLin ( int  nVals, double  xMin, double  xMax  )

inline

Equidistant range between xMin and xMax for spline of the first order.

Definition at line 83 of file tools.h.

  {
    B2ASSERT("At least one value in the spline required", nVals >= 1);
    if (nVals == 1) return {};
    std::vector<double> v(nVals);
    for (int i = 0; i < nVals; ++i)
      v[i] = xMin + i * (xMax - xMin) / (nVals - 1);
    return v;
  }

getRangeZero()

std::vector< double > getRangeZero ( int  nVals, double  xMin, double  xMax  )

inline

Equidistant range between xMin and xMax for spline of the zero order.

Definition at line 94 of file tools.h.

  {
    B2ASSERT("At least one value in the spline required", nVals >= 1);
    if (nVals == 1) return {};
    std::vector<double> v(nVals - 1);
    for (int i = 1; i < nVals; ++i)
      v[i - 1] = xMin + i * (xMax - xMin) / (nVals);
    return v;
  }

getRun()

static ExpRun getRun ( std::map< ExpRun, std::pair< double, double > >  runs, double  t  )

static

Get exp number + run number from time.

Parameters

runs	map, where key contain the exp-run number and value the start- and end-time of the run
t	time of interest [hours]

Returns

: the exp-run number at the input time t

Definition at line 262 of file Splitter.cc.

  {
    ExpRun rFound(-1, -1);
    int nFound = 0;
    for (auto r : runs) { //Linear search over runs
      if (r.second.first <= t && t < r.second.second) {
        rFound = r.first;
        ++nFound;
      }
    }
 
    B2ASSERT("Exactly one interval should be found", nFound == 1);
    B2ASSERT("Assert that something was found", rFound != ExpRun(-1, -1));
    return rFound;
  }

getRunInfo()

std::map< ExpRun, std::pair< double, double > > getRunInfo ( const std::vector< Evt > &  evts )

inline

Get the map of runs, where each run contains pair with start/end time [hours].

Parameters

evts	vector of events

Returns

a map where the key is exp-run and value start/end time of the particular run [hours]

Definition at line 312 of file Splitter.h.

  {
    std::map<ExpRun, std::pair<double, double>> runsInfo;
 
    for (auto& evt : evts) {
      int Exp = evt.exp;
      int Run = evt.run;
      double time = evt.t;
      if (runsInfo.count(ExpRun(Exp, Run))) {
        double tMin, tMax;
        std::tie(tMin, tMax) = runsInfo.at(ExpRun(Exp, Run));
        tMin = std::min(tMin, time);
        tMax = std::max(tMax, time);
        runsInfo.at(ExpRun(Exp, Run)) = {tMin, tMax};
      } else {
        runsInfo[ExpRun(Exp, Run)] = {time, time};
      }
 
    }
    return runsInfo;
  }

getSortedKeyValueTuples()

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

getStartEndIndexes()

std::pair< int, int > getStartEndIndexes	(	int	nIntervals,
		std::vector< int >	breaks,
		int	indx
	)

get the range of interval with nIntervals and breaks stored in a vector

Definition at line 83 of file Splitter.cc.

  {
    B2ASSERT("There must be at least one interval", nIntervals >= 1);
    B2ASSERT("Interval index must be positive", indx >= 0);
    B2ASSERT("Interval index must be smaller than #breaks", indx < int(breaks.size()) + 1); //There is one more interval than #breaks
    int s = (indx == 0) ? 0 : breaks[indx - 1] + 1;
    int e = (indx == int(breaks.size())) ? nIntervals - 1 : breaks[indx];
    return {s, e};
  }

getUniqueKeys()

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

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

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

getWeights()

VectorXd getWeights

(

int

Size

)

Get the vector of weights to calculate the integral over the Chebyshev nodes The nodes are by definition between 0 and 1, there are Size nodes To get their positions, use getNodes.

Definition at line 29 of file nodes.cc.

  {
    const int N = Size - 1;
    assert(N % 2 == 0);
 
    std::vector<std::vector<double>> coef(Size);
    for (auto& el : coef) el.resize(Size);
 
 
    for (int k = 0; k <= N / 2; ++k) {
      coef[2 * k][N] = 1. / N;
      coef[2 * k][0] = 1. / N ;
 
      coef[2 * k][N / 2] = 2. / N * (2 * ((k + 1) % 2) - 1);
 
      for (int n = 1; n <= N / 2 - 1; ++n)
        coef[2 * k][n] = coef[2 * k][N - n] = 2. / N * cos(n * k * M_PI * 2 / N);
    }
 
    VectorXd wgt = VectorXd::Zero(Size);
 
 
    for (int i = 0; i < Size; ++i) {
      wgt[i] += coef[0][i];
      wgt[i] += coef[N][i] / (1. - N * N);
      for (int k = 1; k <= N / 2 - 1; ++k) {
        double w = 2. / (1 - 4 * k * k);
        wgt[i] += w * coef[2 * k][i];
      }
 
      wgt[i] *= 0.5; //for interval (0,1)
    }
    return wgt;
  }

GridEventTimeExtractor()

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

import_cell_loop()

void import_cell_loop

(

)

dummy comment: import_cell_loop

Definition at line 313 of file collectortfinfo.h.

  {
    uint anz_cell = 10;
    std::vector<int> hits = {1, 2, 3};
 
    for (uint index = 0; index < pass_sector_ids.size(); index++) {
      for (uint i = 0; i <  anz_cell; i++) {
        //     virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted,
        //                             std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
        /*int akt_id =*/ m_collector.importCell(index, "", -1, std::vector<int>(), std::vector<int>(), hits);
      }
    }
  }

import_cell_standard()

void import_cell_standard

(

)

dummy comment: import_cell_standard

Definition at line 291 of file collectortfinfo.h.

  {
    // ID 0 - 9
    // Allowed Overlap => Cellid 2, 3 (same hit)
    // Not allowed overlap => Cellid 7, 8 (other hit)
 
    // Cellid 1 => overlapped Sector
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({1, 2}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4, 5}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 9}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9, 10}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({15, 16}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({16, 17}));
    m_collector.importCell(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>());
 
    //     virtual int importCell (int pass_index, std::string died_at, std::vector<int> accepted, std::vector<int> rejected, std::vector<int> assigned_Hit_IDs); // Cell Import
  }

import_clusters_loop()

void import_clusters_loop

(

)

dummy comment: import_clusters_loop

Definition at line 189 of file collectortfinfo.h.

  {
    uint anz_clusters_svd = 10;
    uint anz_clusters_pxd = 10;
 
    for (uint index = 0; index < pass_sector_ids.size(); index++) {
      for (uint i = 0; i <  anz_clusters_svd; i++) {
        // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
        /*int akt_id =*/
        m_collector.importCluster(index, "", -1, std::vector<int>(), std::vector<int>(), Const::SVD, i);
      }
      for (uint i = 0; i <  anz_clusters_pxd; i++) {
        // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
        /*int akt_id =*/
        m_collector.importCluster(index, "", -1, std::vector<int>(), std::vector<int>(), Const::PXD, i);
      }
    }
  }

import_clusters_standard()

void import_clusters_standard

(

)

dummy comment: import_clusters_standard

Definition at line 130 of file collectortfinfo.h.

  {
 
    uint anz_clusters_svd = 15;
    uint anz_clusters_pxd = 15;
 
 
    for (uint i = 0; i <  anz_clusters_svd; i++) {
      // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
      /*int akt_id =*/ m_collector.importCluster(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), Const::SVD, i);
 
//      B2INFO ("AKT ID SVD: " << akt_id);
 
    }
 
    for (uint i = 0; i <  anz_clusters_pxd; i++) {
      // importCluster (int pass_index, std::string died_at, int accepted, int rejected, int detector_type)
      /*int akt_id = */m_collector.importCluster(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), Const::PXD, i);
 
//      B2INFO ("AKT ID PXD: " << akt_id);
    }
  }

import_hit_loop()

void import_hit_loop

(

)

dummy comment: import_hit_loop

Definition at line 273 of file collectortfinfo.h.

  {
    uint anz_hits = 10;
 
    // std::vector<int> clusters = {7, 8, 9};
    for (uint index = 0; index < pass_sector_ids.size(); index++) {
      for (uint i = 0; i <  anz_hits; i++) {
        //     virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted,
        //                            std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs,
        //                            int sec_id, B2Vector3D hit_position); // Hit import_clusters
 
        /*int akt_id =*/ m_collector.importHit(index, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 1, B2Vector3D(),
                                               B2Vector3D());
      }
    }
  }

import_hit_standard()

void import_hit_standard

(

)

dummy comment: import_hit_standard

Definition at line 208 of file collectortfinfo.h.

  {
    //     virtual int importHit (int pass_index, std::string died_at, std::vector<int> accepted,
    //                            std::vector<int> rejected, std::vector<int> assigned_Cluster_IDs,
    //                            int sec_id, B2Vector3D hit_position); // Hit import_clusters
 
    // ID 0 - 4
    // Sector Overlap => Hitid 3,4
    // Cluster Overlap => Hitid 7,8
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({1, 2, 3}), 0,
                          B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({4}), 2, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({7}), 4, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({9}), 5, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({10}), 5,
                          B2Vector3D(),
                          B2Vector3D());
 
    // ID 5 - 9
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({11, 12, 13}), 6,
                          B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({14, 15}), 7,
                          B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 8,
                          B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({17}), 9,
                          B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>({18}), 1,
                          B2Vector3D(),
                          B2Vector3D());
 
    // ID 10 - 14
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), -1, B2Vector3D(),
                          B2Vector3D());
 
    // ID 15 - 19
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 19, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 20, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 21, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 22, B2Vector3D(),
                          B2Vector3D());
    m_collector.importHit(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), std::vector<int>(), 23, B2Vector3D(),
                          B2Vector3D());
  }

import_sectors_loop()

void import_sectors_loop

(

)

Documentation Comment Jakob Lettenbichler: this was written by a student and will be removed after finishing redesign of VXDTF.

Therefore some documentation-entries are not very useful - all of them are marked with "dummy comment". dummy comment: import_sectors_loop

Definition at line 154 of file collectortfinfo.h.

  {
    // Create Test Sector
    std::map<unsigned int, std::vector<int>> sector_map;
    uint size_of_sectors = 10;
 
    for (uint i = 0; i < size_of_sectors; i++) {
      sector_map.insert(std::make_pair(i, std::vector<int>()));
    }
 
    // 1. Sectors init
    //KeySectors dosn't function => so pair Int int
    std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors_display_all_pass;
    std::vector<int> sectors_display_friends;
 
    for (uint i = 0; i < pass_sector_ids.size(); i++) {
 
      B2DEBUG(1, "PassNr. " << i << "Size of Sector Map: " << sector_map.size());
 
      for (auto& akt_sector : sector_map) {
        sectors_display_friends.clear();
 
        // Friends read and store in second vector
        for (auto& akt_friend : akt_sector.second) {
          sectors_display_friends.push_back(akt_friend);
        }
        sectors_display_all_pass.insert(std::make_pair(std::make_pair(i, akt_sector.first), sectors_display_friends));
      }
    }
    m_collector.initPersistent();
    m_collector.intEvent();
    //  m_collector.initSectors (sectors_display_all_pass, std::vector<double>(), std::vector<double>());
  }

import_sectors_standard()

void import_sectors_standard

(

)

dummy comment: import_sectors_standard

Definition at line 91 of file collectortfinfo.h.

  {
 
 
    uint sector_map_size = 40;
 
    // Create Test Sector
    std::map<std::pair<unsigned int, unsigned int>, std::vector<int>> sectors_display_all_pass;
    std::vector<int> sectors_display_friends;
 
//       B2INFO ("PassNr. " << pass_sector_id_single << "Size of Sector Map: " << sector_map_size );
 
    sectors_display_friends.clear();
    sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 0), sectors_display_friends));
 
    sectors_display_friends.clear();
    sectors_display_friends.push_back(0);
    sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 1), sectors_display_friends));
 
    sectors_display_friends.clear();
    sectors_display_friends.push_back(1);
    sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, 2), sectors_display_friends));
 
    // Sector 3 - 40
    sectors_display_friends.clear();
    for (uint u = 3; u < sector_map_size; u++) {
      sectors_display_all_pass.insert(std::make_pair(std::make_pair(pass_sector_id_single, u), sectors_display_friends));
    }
 
 
 
 
    m_collector.initPersistent();
    m_collector.intEvent();
    // m_collector.initSectors (sectors_display_all_pass, std::vector<double>(), std::vector<double>());
 
  }

import_tfc_loop()

void import_tfc_loop

(

)

dummy comment: import_tfc_loop

Definition at line 357 of file collectortfinfo.h.

  {
    uint anz_tfc = 10;
    std::vector<std::pair<int, unsigned int>>  cells = {std::make_pair(1, 1), std::make_pair(2, 2), std::make_pair(3, 3)};
 
    for (uint index = 0; index < pass_sector_ids.size(); index++) {
      for (uint i = 0; i <  anz_tfc; i++) {
        // int passIndex, std::string diedAt, int diedId, std::vector<int> accepted, std::vector<int> rejected,
        // const std::vector<std::pair<int, unsigned int>> assignedCellIDs
        // TC Import
        /*int akt_id =*/ m_collector.importTC(index, "", -1, std::vector<int>(), std::vector<int>(), cells);
      }
    }
  }

import_tfc_standard()

void import_tfc_standard

(

)

dummy comment: import_tfc_standard

Definition at line 327 of file collectortfinfo.h.

  {
    std::vector<std::pair<int, unsigned int>>  cells0 = {std::make_pair(0, 0)};
    std::vector<std::pair<int, unsigned int>>  cells1 = {std::make_pair(1, 1)};
    std::vector<std::pair<int, unsigned int>>  cells23 = {std::make_pair(2, 2), std::make_pair(3, 3)};
    std::vector<std::pair<int, unsigned int>>  cells79 = {std::make_pair(7, 7), std::make_pair(9, 9)};
    std::vector<std::pair<int, unsigned int>>  cells8 = {std::make_pair(8, 8)};
 
    // ID 1 = Sector overlapped
    // ID 2 = allowed overlapping (Cells)
    // ID 3, 4 = not allowed overlapping (Cells)
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells0);
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells1);
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells23);
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells79);
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(), cells8);
 
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
                         std::vector<std::pair<int, unsigned int>>({}));
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
                         std::vector<std::pair<int, unsigned int>>({}));
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
                         std::vector<std::pair<int, unsigned int>>({}));
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
                         std::vector<std::pair<int, unsigned int>>({}));
    m_collector.importTC(pass_sector_id_single, "", -1, std::vector<int>(), std::vector<int>(),
                         std::vector<std::pair<int, unsigned int>>({}));
  }

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

init()

void init	(	int	Size,
		double	xMin,
		double	xMax
	)

Initialize the fitter (the Chebyshev coefficients)

Definition at line 59 of file ChebFitter.cc.

  {
    // loading the Cheb nodes
    m_nodes = (xMax - xMin) * getNodes(Size).array() + xMin;
 
    // loding the weights for integration
    m_weights = (xMax - xMin) * getWeights(Size);
 
 
    // calculate the transformation matrix from pol coefs to grid points
    m_coefsMat = getCoefsCheb(Size).transpose();
 
    m_dataGrid = getDataGrid();
 
  }

initialize() [1/4]

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() [2/4]

void initialize

overridevirtual

Create the store arrays.

Reimplemented from ProcessingSignalListener.

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

initialize() [3/4]

void initialize

overridevirtual

Receive signal before the start of the event processing.

Reimplemented from ProcessingSignalListener.

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

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

initializeObservers() [1/3]

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]

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]

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

interpol() [1/3]

VectorXd interpol	(	const VectorXd &	xi,
		double	x
	)

Get Interpolation vector k_i for point x from the function values at points xi (polynomial interpolation) In the second step, the function value at x can be evaluated as sum_i vals_i k_i.

Definition at line 189 of file nodes.cc.

  {
    double Norm = (xi[xi.size() - 1] - xi[0]) / 2;
    VectorXd coefs(xi.size());
    for (int i = 0; i < xi.size(); ++i) {
      double num = 1, den = 1;
      for (int j = 0; j < xi.size(); ++j)
        if (j != i) {
          num *= (x     - xi(j)) / Norm;
          den *= (xi(i) - xi(j)) / Norm;
        }
      coefs(i) = num / den;
    }
    return coefs;
  }

interpol() [2/3]

double interpol	(	Eigen::VectorXd	xi,
		Eigen::VectorXd	vals,
		double	x
	)

Get interpolated function value at point x when function values vals at points xi are provided.

If the points xi are fixed and only vals are different between interpol calls, use interpol(xi, x) to speed up the evaluation.

interpol() [3/3]

double interpol	(	VectorXd	xi,
		VectorXd	vals,
		double	x
	)

Get interpolated function value at point x when function values vals at points xi are provided.

If the points xi are fixed and only vals are different between interpol calls, use interpol(xi, x) to speed up the evaluation.

Definition at line 210 of file nodes.cc.

  {
    VectorXd coefs = interpol(xi, x);
    return coefs.dot(vals);
  }

IterativeEventTimeExtractor()

IterativeEventTimeExtractor

Add the subfindlet as listener.

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

  {
    Super::addProcessingSignalListener(&m_findlet);
  }

LayerPXDRelationFilter()

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

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

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

LimitedOnStateApplier

Constructor adding the findlet as a listener.

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

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

lossFunction()

double lossFunction ( const std::vector< Atom > &  vec, int  s, int  e  ) const

private

lossFunction of the calibration interval consisting of several "atoms" stored in vector vec The atoms included in calibration interval have indices between s and e

the lossFunction formula (it can be modified according to the user's taste)

Parameters

vec	Vector of atoms, where each atom is an intervals in time
s	First index of the calib. interval
e	Last index of the calib. interval

Returns

: A value of the loss function

Definition at line 135 of file Splitter.cc.

  {
 
    //raw time
    double rawTime = vec[e].t2 - vec[s].t1;
 
    //max gap
    double maxGap = 0;
    for (int i = s; i <= e - 1; ++i) {
      double d = vec[i + 1].t1 - vec[i].t2;
      maxGap = std::max(maxGap, d);
    }
 
    //net time
    double netTime = 0;
    for (int i = s; i <= e; ++i) {
      netTime += vec[i].t2 - vec[i].t1;
    }
 
    // Number of events
    double nEv = 0;
    for (int i = s; i <= e; ++i) {
      nEv += vec[i].nEv;
    }
    if (nEv == 0) nEv = 0.1;
 
    //double loss = pow(rawTime - tBest, 2) + gapPenalty * pow(maxGap, 2);
    //double loss = 1./nEv  + timePenalty * pow(rawTime, 2);
 
    lossFun->SetParameters(rawTime, netTime, maxGap, nEv);
    double lossNew = lossFun->Eval(0);
 
    return lossNew;
  }

merge()

std::vector< std::vector< double > > merge ( std::vector< std::vector< std::vector< double > > >  toMerge )

inline

merge { vector<double> a, vector<double> b} into {a, b}

Definition at line 41 of file tools.h.

  {
    std::vector<std::vector<double>> allVecs;
    for (const auto& v : toMerge)
      allVecs.insert(allVecs.end(), v.begin(), v.end());
    return allVecs;
  }

mergeIntervals()

std::map< ExpRun, std::pair< double, double > > mergeIntervals ( std::map< ExpRun, std::pair< double, double > >  I1, std::map< ExpRun, std::pair< double, double > >  I2  )

static

Merge two subintervals into one subinterval.

Parameters

I1	First subinterval to merge
I2	Second subinterval to merge

Returns

: The resulting subinterval

Definition at line 306 of file Splitter.cc.

  {
    std::map<ExpRun, std::pair<double, double>>  I = I1;
    for (auto r : I2) {
      ExpRun run = r.first;
      if (I.count(run) == 0)
        I[run] = r.second;
      else {
        I.at(run) = std::make_pair(std::min(I1.at(run).first, I2.at(run).first),   std::max(I1.at(run).second, I2.at(run).second));
      }
    }
    return I;
  }

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!()

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!=()

bool operator!= ( ExpRun  a, ExpRun  b  )

inline

Not equal for ExpRun.

Definition at line 71 of file Splitter.h.

{ return (a.exp != b.exp || a.run != b.run); }

operator&&()

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

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

override

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

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

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

operator()() [2/7]

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

final

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

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

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

operator()() [3/7]

double operator()

(

const double *

par

)

const

Evaluate the log likelihood.

Definition at line 97 of file ChebFitter.cc.

  {
    Pars pars;
    for (unsigned i = 0; i < m_parNames.size(); ++i)
      pars[m_parNames[i]] = par[i];
 
    double LL = m_useCheb ? getLogLikelihoodFast(pars) : getLogLikelihoodSlow(pars);
 
    return LL;
  }

operator()() [4/7]

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

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

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

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

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

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

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

bool operator< ( ExpRun  a, ExpRun  b  )

inline

less than for ExpRun

Definition at line 74 of file Splitter.h.

{return ((a.exp < b.exp) || (a.exp == b.exp && a.run < b.run));}

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

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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

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

OverlapResolver

Construct this findlet and add the subfindlet as listener.

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

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

plotRuns()

void plotRuns

(

std::vector< std::pair< double, double > >

runs

)

plot runs on time axis

Definition at line 57 of file Splitter.cc.

  {
    TGraphErrors* gr = new TGraphErrors();
 
 
    for (auto r : runs) {
      double m = (r.first + r.second) / 2;
      double e = (r.second - r.first) / 2;
 
      gr->SetPoint(gr->GetN(), m, 1);
      gr->SetPointError(gr->GetN() - 1, e, 0);
    }
 
    gStyle->SetEndErrorSize(6);
 
    gr->SetLineWidth(1);
    gr->SetMarkerSize(40);
    gr->Draw("ape");
    gr->GetYaxis()->SetRangeUser(-10, 10);
    gr->GetXaxis()->SetRangeUser(0, 256);
 
    gr->GetXaxis()->SetTitle("time [hours]");
 
  }

plotSRuns()

void plotSRuns	(	std::vector< std::pair< double, double > >	runs,
		std::vector< int >	breaks,
		int	offset = 2
	)

plot clusters or runs on time axis

Definition at line 94 of file Splitter.cc.

  {
    TGraphErrors* gr = new TGraphErrors();
 
    for (int i = 0; i < int(breaks.size()) + 1; ++i) {
      int s, e;
      std::tie(s, e) = getStartEndIndexes(runs.size(), breaks, i);
      double a = runs[s].first;
      double b = runs[e].second;
 
      double m = (a + b) / 2;
      double err = (b - a) / 2;
 
      gr->SetPoint(gr->GetN(), m, offset);
      gr->SetPointError(gr->GetN() - 1, err, 0);
 
    }
 
    gr->SetLineColor(kRed);
    gr->SetMarkerColor(kRed);
    gr->Draw("pe same");
  }

print()

std::string print

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

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

printBySize()

void printBySize

(

std::vector< std::pair< double, double > >

runs

)

print sorted lenghts of the runs

Definition at line 119 of file Splitter.cc.

  {
    std::vector<double> dist;
    for (auto r : runs) {
      double d = r.second - r.first;
      dist.push_back(d);
    }
 
    sort(dist.begin(), dist.end());
 
    for (auto d : dist)
      B2INFO(d);
 
  }

printMap()

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

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 succesful, false elsewise

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

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

void resetEventT0

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

rn()

TString rn ( )

inline

Get random string.

Definition at line 38 of file tools.h.

{return Form("%d", gRandom->Integer(1000000000)); }

ROIToUnitTranslator() [1/2]

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]

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

runAlgorithm()

CalibrationData runAlgorithm ( const std::vector< Evt > &  evts, std::vector< std::map< ExpRun, std::pair< double, double > > >  range, Fun  runCalibAnalysis  )

inline

run calibration algorithm for single calibration interval

Definition at line 335 of file calibTools.h.

  {
    CalibrationData calD;
    auto& r = range;
    double rStart, rEnd;
    std::tie(rStart, rEnd) = Splitter::getStartEnd(r);
    B2INFO("Start of loop startTime endTime : " << rStart << " " << rEnd);
 
    auto breaks =  Splitter::getBreaks(r);
 
    std::vector<Evt> evtsNow;
 
    std::vector<int> Counts(breaks.size() + 1, 0);
    // Select events belonging to the interval
    for (const auto& ev : evts) {
      if (rStart <= ev.t && ev.t < rEnd) {
        evtsNow.push_back(ev);
        ++Counts.at(getID(breaks, ev.t));
      }
    }
 
    B2ASSERT("Number of intervals vs number of breakPoints", r.size()  == breaks.size() + 1);
 
    //Merge smallest interval if with low stat (try it 10times)
    for (int k = 0; k < 10; ++k)  {
      int iMin = min_element(Counts.begin(), Counts.end()) - Counts.begin();
      if (Counts.size() >= 2 &&  Counts[iMin] < 50) { //merge with neighbor if possible
        auto iM = -1;
        if (iMin == 0)
          iM = iMin + 1;
        else if (iMin == int(Counts.size()) - 1)
          iM = iMin - 1;
        else {
          if (Counts[iMin + 1] < Counts[iMin - 1])
            iM = iMin + 1;
          else
            iM = iMin - 1;
        }
        B2ASSERT("Number of intervals equal to size of counters", r.size() == Counts.size());
 
        r.at(iM) = Splitter::mergeIntervals(r[iM], r[iMin]);
        r.erase(r.begin() + iMin);
        breaks =  Splitter::getBreaks(r);
        Counts[iM] += Counts[iMin];
        Counts.erase(Counts.begin() + iMin);
      }
    }
 
    B2INFO("#events "  << " : " << evtsNow.size());
    B2INFO("Breaks size " << " : " << breaks.size());
 
    calD.breakPoints = convertSplitPoints(evtsNow, breaks);
 
    calD.subIntervals = r;
 
    if (breaks.size() > 0)
      B2INFO("StartOfCalibInterval (run,evtNo,vtxIntervalsSize) " <<   calD.breakPoints.at(0).run << " " <<
             calD.breakPoints.at(0).evt << " " << calD.breakPoints.size());
 
 
    //If too few events, let have the output empty
    //Will be filled with the closest neighbor at the next stage
    if (evtsNow.size() < 50) {
      return calD;
    }
 
    // Run the calibration
    B2INFO("Start of running calibration over calibration interval");
    tie(calD.pars.cnt, calD.pars.cntUnc, calD.pars.spreadMat) = runCalibAnalysis(evtsNow, breaks);
    calD.pars.pulls.resize(calD.pars.cnt.size());
    B2INFO("End of running analysis - SpreadMatX : " << sqrt(abs(calD.pars.spreadMat(0, 0))));
    B2ASSERT("All subintervals have calibration of the mean value", calD.pars.cnt.size() == r.size());
    B2ASSERT("All subintervals have calibration of the unc. of mean", calD.pars.cntUnc.size() == r.size());
 
    calD.isCalibrated = true;
 
    return calD;
  }

runCalibration()

CalibrationAlgorithm::EResult runCalibration	(	TTree *	tracks,
		const std::string &	calibName,
		Fun1	GetEvents,
		Fun2	calibAnalysis,
		std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd)>	calibObjCreator,
		TString	m_lossFunctionOuter,
		TString	m_lossFunctionInner
	)

Run the the calibration over the whole event sample.

Parameters

tracks	TTree object with mu-mu events
calibName	name of the calibration payload
GetEvents	function that transforms TTree to std::vector
calibAnalysis	function that performs the calibration on a single calibration interval
calibObjCreator	function that stores results to the payload class which inherits from TObject
m_lossFunctionOuter	Lost function for the calibration intervals of the spread parameters
m_lossFunctionInner	Lost function for the calibration subintervals (for the mean value parameters)

Returns

State of the calibration run, i.e. EResult::c_OK if everything OK

Definition at line 428 of file calibTools.h.

  {
    // Check that there are at least some data
    if (!tracks || tracks->GetEntries() < 15) {
      if (tracks)
        B2WARNING("Too few data : " << tracks->GetEntries());
      return CalibrationAlgorithm::EResult::c_NotEnoughData;
    }
    B2INFO("Number of tracks: " << tracks->GetEntries());
 
    // Tree to vector of Events
    auto evts = GetEvents(tracks);
 
    //Time range for each ExpRun
    std::map<ExpRun, std::pair<double, double>> runsInfoOrg = getRunInfo(evts);
    std::map<ExpRun, std::pair<double, double>> runsRemoved; //map with time intervals of very short runs
    auto runsInfo = filter(runsInfoOrg, 2. / 60, runsRemoved); //include only runs longer than 2mins
 
    // If nothing remains
    if (runsInfo.size() == 0) {
      B2WARNING("Too short run");
      return  CalibrationAlgorithm::EResult::c_NotEnoughData;
    }
 
    // Get intervals based on the input loss functions
    Splitter splt;
    auto splits = splt.getIntervals(runsInfo, evts, m_lossFunctionOuter, m_lossFunctionInner);
 
    //Loop over all calibration intervals
    std::vector<CalibrationData> calVec;
    for (auto s : splits) {
      CalibrationData calD = runAlgorithm(evts, s, calibAnalysis); // run the calibration over the interval s
      calVec.push_back(calD);
    }
 
    // extrapolate results to the low-stat intervals
    extrapolateCalibration(calVec);
 
    // Include removed short runs
    for (auto shortRun : runsRemoved) {
      addShortRun(calVec,  shortRun);
    }
 
    // Store Payloads to files
    storePayloads(evts, calVec, calibName, calibObjCreator);
 
    return CalibrationAlgorithm::EResult::c_OK;
  }

SelectionVariableNamesToFunctions() [1/4]

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]

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]

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]

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

slice() [1/2]

std::vector< Atom > slice ( std::vector< Atom >  vec, int  s, int  e  )

inline

Slice the vector to contain only elements with indexes s .. e (included)

Definition at line 85 of file Splitter.h.

  {
    return std::vector<Atom>(vec.begin() + s, vec.begin() + e + 1);
  }

slice() [2/2]

std::vector< double > slice ( std::vector< double >  v, unsigned  ind, unsigned  n  )

inline

put slice of original vector v[ind:ind+n] into new one, n is number of elements

Definition at line 106 of file tools.h.

  {
    std::vector<double> vNew;
    for (unsigned i = ind; i < ind + n && i < v.size(); ++i)
      vNew.push_back(v[i]);
    return vNew;
  }

splitToSmall()

std::vector< std::pair< double, double > > splitToSmall ( std::map< ExpRun, std::pair< double, double > >  runs, double  intSize = 1. / 60  )

staticprivate

Split the runs into small calibration intervals (atoms) of a specified size.

By definition each of these intervals spans only over single run. These will be clustered into larger intervals in the next steps

Parameters

runs	Runs to split into the atoms
intSize	Intended size of the small intervals

Returns

: A vector with resulting time boundaries of the atoms

Definition at line 173 of file Splitter.cc.

  {
    // split into small intervals
    std::vector<std::pair<double, double>> smallRuns;
 
    for (auto r : runs) {
      auto& I = r.second;
      if (intSize < 0) {
        smallRuns.push_back(I);
        continue;
      }
 
      double runTime = I.second - I.first;
      int nSplits = runTime / intSize; //1-m intervals
      nSplits = std::max(1, nSplits); //at least 1 interval
 
      for (int i = 0; i < nSplits; ++i) {
        double L = I.first + i * (runTime / nSplits);
        double H = I.first + (i + 1) * (runTime / nSplits);
        smallRuns.push_back({L, H});
      }
    }
    return smallRuns;
  }

StateRejecter()

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

storePayloads()

void storePayloads ( const std::vector< Evt > &  evts, const std::vector< CalibrationData > &  calVecConst, std::string  objName, std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd) >  getCalibObj  )

inline

Store payloads to files.

Definition at line 225 of file calibTools.h.

  {
    auto calVec = calVecConst;
 
    // Loop to store payloads
    ExpRun exprunLast(-1, -1); //last exprun
    EventDependency* intraRun = nullptr;
 
    // Loop over calibration intervals
    for (unsigned i = 0; i < calVec.size(); ++i) {
      const auto& r = calVec[i].subIntervals; //   splits[i];
      // Loop over calibration subintervals
      for (int k = 0; k < int(r.size()); ++k) {
 
        for (auto I : r[k]) { //interval required to be within single run
          ExpRun exprun = I.first;
 
          //Encode Start+End time in seconds of the payload
          if (calVec[i].pars.cntUnc.at(k).rows() == 3) {
            calVec[i].pars.cntUnc.at(k)(0, 1) = calVec[i].pars.cntUnc.at(k)(1, 0) = encodeNumber(calVec[i].pars.cntUnc.at(k)(0, 1),
                                                round(I.second.first  * 3600));
            calVec[i].pars.cntUnc.at(k)(0, 2) = calVec[i].pars.cntUnc.at(k)(2, 0) = encodeNumber(calVec[i].pars.cntUnc.at(k)(0, 2),
                                                round(I.second.second * 3600));
          } else {
            calVec[i].pars.cntUnc.at(k)(0, 0) = encodeNumber(calVec[i].pars.cntUnc.at(k)(0, 0), round(I.second.first  * 3600));
            calVec[i].pars.spreadMat(0, 0)    = encodeNumber(calVec[i].pars.spreadMat(0, 0),    round(I.second.second * 3600));
          }
 
          TObject* obj = getCalibObj(calVec[i].pars.cnt.at(k), calVec[i].pars.cntUnc.at(k), calVec[i].pars.spreadMat);
          if (exprun != exprunLast) { //if new run
            if (intraRun) { //if not first -> store
              auto m_iov = IntervalOfValidity(exprunLast.exp, exprunLast.run, exprunLast.exp, exprunLast.run);
              Database::Instance().storeData(objName, intraRun, m_iov);
            }
 
            intraRun = new EventDependency(obj);
          } else {
            int breakPoint;
            if (k - 1 >= 0) {
              breakPoint = calVec[i].breakPoints.at(k - 1).evt;
              B2ASSERT("Payload saving consistency", calVec[i].breakPoints.at(k - 1).run == exprun.run);
            } else {
              B2ASSERT("Payload saving consistency", i != 0);
              double rStart, rEnd;
              std::tie(rStart, rEnd) = Splitter::getStartEnd(r);
              auto pos = getPosition(evts, rStart);
              breakPoint = pos.evt;
              B2ASSERT("Payload saving consistency", pos.run == exprun.run);
            }
            intraRun->add(breakPoint, obj);
          }
          exprunLast = exprun;
        }
      } //end loop over calibration subintervals
 
    } //end loop over calibration intervals
 
    //Store the last entry
    auto m_iov = IntervalOfValidity(exprunLast.exp, exprunLast.run, exprunLast.exp, exprunLast.run);
    Database::Instance().storeData(objName, intraRun, m_iov);
  }

storePayloadsNoIntraRun()

void storePayloadsNoIntraRun ( const std::vector< CalibrationData > &  calVecConst, std::string  objName, std::function< TObject *(Eigen::VectorXd, Eigen::MatrixXd, Eigen::MatrixXd) >  getCalibObj  )

inline

Store payloads to files, where calib data have no intra-run dependence.

Definition at line 290 of file calibTools.h.

  {
    auto calVec = calVecConst;
 
    // Check that there is no intra-run dependence
    std::set<ExpRun> existingRuns;
    for (unsigned i = 0; i < calVec.size(); ++i) {
      const auto& r = calVec[i].subIntervals;
      // Loop over calibration subintervals
      for (int k = 0; k < int(r.size()); ++k) {
 
        for (auto I : r[k]) {
          ExpRun exprun = I.first;
          // make sure that the run isn't already in the list, to avoid duplicity
          if (existingRuns.count(exprun) != 0)
            B2FATAL("Intra-run dependence exists");
          existingRuns.insert(exprun);
        }
      }
    }
 
 
    // Loop over calibration intervals
    for (unsigned i = 0; i < calVec.size(); ++i) {
      const auto& r = calVec[i].subIntervals; //   splits[i];
      // Loop over calibration subintervals
      for (unsigned k = 0; k < r.size(); ++k) {
 
        TObject* obj = getCalibObj(calVec[i].pars.cnt.at(k), calVec[i].pars.cntUnc.at(k), calVec[i].pars.spreadMat);
 
        ExpRun start = (r[k].cbegin()->first);
        ExpRun last  = (r[k].crbegin()->first);
 
        auto iov = IntervalOfValidity(start.exp, start.run, last.exp, last.run);
        Database::Instance().storeData(objName, obj, iov);
 
 
      } //end loop over calibration subintervals
    } //end loop over calibration intervals
 
  }

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

TEST_F() [1/50]

TEST_F	(	CollectorTFInfoTest	,
		testAllInformationLoop
	)

dummy comment: testAllInformationLoop

Definition at line 579 of file collectortfinfo.h.

  {
    bool false_item = false;
    bool true_item = true;
 
    import_sectors_loop();
 
    import_clusters_loop();
 
    m_collector.updateSectors(4, 1, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
 
    m_collector.updateClusters(3, "geloescht", 0, std::vector<int>(), std::vector<int>(), 0);
 
    ASSERT_EQ("geloescht", m_collector.m_clustersTF[3].getDiedAt());
    ASSERT_EQ(false_item, m_collector.m_clustersTF[3].getActive());
 
    import_hit_loop();
 
    m_collector.updateHit(1, "geloescht", 0, std::vector<int>(), std::vector<int>(), -1, -1, std::vector<int>());
 
    ASSERT_EQ("geloescht", m_collector.m_hitTF[1].getDiedAt());
    ASSERT_EQ(false_item, m_collector.m_hitTF[1].getActive());
    ASSERT_EQ(true_item, m_collector.m_hitTF[2].getActive());
 
    import_cell_loop();
    m_collector.updateCell(3, "geloescht", 2, std::vector<int>(), std::vector<int>(), -1, -1, 0, std::vector<int>());
 
    ASSERT_EQ("geloescht", m_collector.m_cellTF[3].getDiedAt());
    ASSERT_EQ(false_item, m_collector.m_cellTF[3].getActive());
    ASSERT_EQ(true_item, m_collector.m_cellTF[1].getActive());
 
    import_tfc_loop();
 
    m_collector.updateTC(2, "geloescht", 4, std::vector<int>(), std::vector<int>());
 
    ASSERT_EQ("geloescht", m_collector.m_tfCandTF[2].getDiedAt());
    ASSERT_EQ(false_item, m_collector.m_tfCandTF[2].getActive());
    ASSERT_EQ(true_item, m_collector.m_tfCandTF[1].getActive());
  }

TEST_F() [2/50]

TEST_F	(	FilterIDTest	,
		simpleTest
	)

Test simple Setters and Getters.

Definition at line 25 of file filterID.h.

  {
    // provides a usefull filterType
    Belle2::FilterID aFilterIDTranslator;
    Belle2::FilterID::filterTypes aFilterType = aFilterIDTranslator.getFilterType(Belle2::FilterID::nameHelixParameterFit);
    EXPECT_EQ(Belle2::FilterID::nameHelixParameterFit, aFilterIDTranslator.getFilterString(aFilterType));
 
    EXPECT_EQ(aFilterType, aFilterIDTranslator.getFilterType(Belle2::FilterID::nameHelixParameterFit));
 
  }

TEST_F() [3/50]

TEST_F	(	FullSecIDTest	,
		bufferOverflowTest
	)

Unfinished test - shall test bufferOverflows...

Definition at line 176 of file fullSecID.h.

  {
    B2WARNING("TODO: FullSecIDTest:bufferOverflowTest should catch cases of bad user input");
    // WARNING TODO should catch cases of bad user input
  }

TEST_F() [4/50]

TEST_F	(	FullSecIDTest	,
		constructorAndGetterTests
	)

Test simple Setters and Getters.

Definition at line 26 of file fullSecID.h.

  {
    // first, we need a usefull vxdID:
    VxdID vxdID = VxdID(34624); // this should be a sensor on layer 4
    int vxdIDInt = vxdID;
 
    EXPECT_EQ(4, vxdID.getLayerNumber());
 
    // now we are using the constructor with a VxdID, a subLayerID and a sectorID
    bool subLayerID = true;
    unsigned short sectorID = 15;
    FullSecID aFullSecID = FullSecID(vxdID, subLayerID, sectorID);
 
    EXPECT_EQ(4, aFullSecID.getLayerID());
 
    EXPECT_EQ(subLayerID, aFullSecID.getSubLayerID());
 
    EXPECT_EQ(vxdID, aFullSecID.getVxdID());
 
    EXPECT_EQ(vxdIDInt, aFullSecID.getUniID());
 
    EXPECT_EQ(sectorID, aFullSecID.getSecID());
 
    // now we are using the second constructor using an encoded fullSecID (int) as input:
 
    FullSecID anotherFullSecID = FullSecID(aFullSecID.getFullSecID());
 
    EXPECT_EQ(4, anotherFullSecID.getLayerID());
 
    EXPECT_EQ(subLayerID, anotherFullSecID.getSubLayerID());
 
    EXPECT_EQ(vxdID, anotherFullSecID.getVxdID());
 
    EXPECT_EQ(vxdIDInt, anotherFullSecID.getUniID());
 
    EXPECT_EQ(aFullSecID.getSecID(), anotherFullSecID.getSecID());
 
    EXPECT_EQ(aFullSecID.getFullSecID(), anotherFullSecID.getFullSecID());
 
    // now we are using the third constructor using an encoded fullSecID (string) as input:
    std::stringstream aSecIDString;
    aSecIDString << aFullSecID.getLayerID() << aFullSecID.getSubLayerID() << "_" << int(aFullSecID.getVxdID()) << "_" <<
                 aFullSecID.getSecID();
 
    FullSecID aThirdFullSecID = FullSecID(aSecIDString.str());
 
    EXPECT_EQ(4, aThirdFullSecID.getLayerID());
 
    EXPECT_EQ(subLayerID, aThirdFullSecID.getSubLayerID());
 
    EXPECT_EQ(vxdID, aThirdFullSecID.getVxdID());
 
    EXPECT_EQ(vxdIDInt, aThirdFullSecID.getUniID());
 
    EXPECT_EQ(aFullSecID.getSecID(), aThirdFullSecID.getSecID());
 
    EXPECT_EQ(aFullSecID.getFullSecID(), aThirdFullSecID.getFullSecID());
 
    EXPECT_EQ(aSecIDString.str(), aThirdFullSecID.getFullSecString());
 
    // now we are using the third constructor again using an encoded short fullSecID (string, used by filterCalculator) as input:
    std::stringstream aSecIDString2;
    aSecIDString2 << aFullSecID.getLayerID() << "_" << int(aFullSecID.getVxdID()) << "_" << aFullSecID.getSecID();
 
    FullSecID aFourthFullSecID = FullSecID(aSecIDString2.str());
 
    EXPECT_EQ(4, aFourthFullSecID.getLayerID());
 
    EXPECT_FALSE(aFourthFullSecID.getSubLayerID());
 
    EXPECT_EQ(vxdID, aFourthFullSecID.getVxdID());
 
    EXPECT_EQ(vxdIDInt, aFourthFullSecID.getUniID());
 
    EXPECT_EQ(FullSecID(vxdID, false, sectorID).getSecID(), aFourthFullSecID.getSecID());
 
    EXPECT_NE(aSecIDString2.str(), aFourthFullSecID.getFullSecString()); // they should not be the same any more...
 
 
    // testing copy constructor (and C++11 range based for-loops):
    std::vector<FullSecID> testVector;
    for (int i = 0; i < 5; ++i) {
      testVector.push_back(aFullSecID);
    }
    for (auto aSecID : testVector) {
      EXPECT_EQ(aFullSecID, aSecID);
    }
  }

TEST_F() [5/50]

TEST_F	(	FullSecIDTest	,
		overloadedOperatorTests
	)

testing the overloaded operators of the FullSecID-class

Definition at line 117 of file fullSecID.h.

  {
    //preparing stuff (procedures copied from constructorAndGetterTest):
    VxdID vxdID = VxdID(34624); // this should be a sensor on layer 4
    bool subLayerID = true;
    unsigned short sectorID = 15;
    FullSecID aFullSecID = FullSecID(vxdID, subLayerID, sectorID);
    std::stringstream aSecIDString;
    aSecIDString << aFullSecID.getLayerID() << aFullSecID.getSubLayerID() << "_" << int(aFullSecID.getVxdID()) << "_" <<
                 aFullSecID.getSecID();
 
    FullSecID aFullSecID2 = FullSecID(aSecIDString.str());
 
    // now the checks:
    EXPECT_EQ(static_cast<unsigned int>(aFullSecID), aFullSecID2);  // directly comparing to an int
 
    EXPECT_EQ(aSecIDString.str(), std::string(aFullSecID2)); // directly comparing to an string - testing string cast
 
    EXPECT_EQ(aFullSecID, aFullSecID2); // direct comparison
 
 
    std::stringstream aSecIDStream, aSecIDStream2;
    aSecIDStream << aFullSecID2;
    aSecIDStream2 << aSecIDString.str();
 
    EXPECT_EQ(aSecIDString.str(), aSecIDStream.str()); // testing stream operator overloading after string-conversion
 
    FullSecID aFullSecID3 = FullSecID(vxdID, false, sectorID); // same ID as above but now, the sublayerID is false instead of true
 
    EXPECT_GT(aFullSecID2, aFullSecID3); // aFullSecID2 > aFullSecID3
 
    for (int l1 = 7; l1 != 0; --l1) { // testing layerIDs
      int l2 = l1;
      l2--;
      FullSecID biggerOne = FullSecID(l1, false, 0, 0);
      FullSecID smallerOne = FullSecID(l2, false, 0, 0);
      EXPECT_GT(biggerOne, smallerOne);
    }
    for (int s1 = 255; s1 != 0; --s1) { // testing sectorIDs
      int s2 = s1;
      s2--;
      FullSecID biggerOne = FullSecID(6, false, 0, s1);
      FullSecID smallerOne = FullSecID(6, false, 0, s2);
      EXPECT_GT(biggerOne, smallerOne); // aFullSecID2 > aFullSecID3
      int equalOne = smallerOne;
      equalOne++;
      EXPECT_EQ(int(biggerOne), equalOne);
    }
 
    EXPECT_GT(int(aFullSecID2), int(aFullSecID3));
 
 
    FullSecID aFullSecID4 = aFullSecID;
 
    EXPECT_EQ(aFullSecID4, aFullSecID); // testing assignment operator;
  }

TEST_F() [6/50]

TEST_F	(	MapHelperFunctionsTest	,
		testCreatorFunctions
	)

test the methods that are use to create the maps for the later tests

Definition at line 111 of file mapHelperFunctions.cc.

  {
    unsigned int N = _nEntries; // same number as in setup
    EXPECT_EQ(N, _nanMultiMap.size()); // test if creation worked (very basically by comparing the size of the returned _nanMap)
    EXPECT_EQ(N, _nanMap.size());
    EXPECT_EQ(N, _multimap.size());
    EXPECT_EQ(N, _map.size());
 
    ASSERT_TRUE(std::isnan(secans.operator()(0))) << "For the following tests to work properly this is expected to return a NaN (-nan)";
 
//     std::cout << printMap(_nanMap) << std::endl;
//     std::cout << printMap(_nanMultiMap) << std::endl;
//     std::cout << printMap(_multimap) << std::endl;
//     std::cout << printMap(_map) << std::endl;
 
    // do some hard-coded queries to see if the _nanMaps were filled according to specified method
    std::vector<int> possibleKeys = { 0, 1, 2, 3, 4, 5 };
    for (int key : possibleKeys) {
      std::vector<double> nanPossibleValues, possibleValues;
      for (int arg = key; arg < _nEntries; arg += 6) {
        nanPossibleValues.push_back(secans.operator()(arg));
        possibleValues.push_back(sinHalf.operator()(arg));
      }
      // test the multimap with nan first
      auto keyRange = _nanMultiMap.equal_range(key);
      // check the numbers of stored values and of possible values
      EXPECT_EQ(nanPossibleValues.size(), std::distance(keyRange.first, keyRange.second));
      i2dMultiMap::iterator multiMapIt = keyRange.first;
      for (int i = 0; i < std::distance(keyRange.first, keyRange.second); ++i) {
        if (!std::isnan(multiMapIt->second)) { // cannot find nan value with std::find (NaN == NaN is always false)
          auto findIt = std::find(nanPossibleValues.begin(), nanPossibleValues.end(), multiMapIt->second);
          EXPECT_FALSE(findIt == nanPossibleValues.end()); // all stored values have to be possible
        } else { // check if there is at least on NaN value in the possible Values
          EXPECT_TRUE(std::count_if(nanPossibleValues.begin(), nanPossibleValues.end(),
          [](const double & val) { return std::isnan(val); }) > 0);
        }
        ++multiMapIt;
      }
      keyRange = _multimap.equal_range(key);
      EXPECT_EQ(possibleValues.size(), std::distance(keyRange.first, keyRange.second));
      multiMapIt = keyRange.first;
      for (int i = 0; i < std::distance(keyRange.first, keyRange.second); ++i) {
        auto findIt = std::find(possibleValues.begin(), possibleValues.end(), multiMapIt->second);
        EXPECT_FALSE(findIt == possibleValues.end());
        ++multiMapIt;
      }
    }
 
    for (unsigned int i = 0; i < N; ++i) {
      auto range = _nanMap.equal_range(i);
      i2dMap::iterator mapIt = range.first;
      for (int j = 0; j < std::distance(range.first, range.second); ++j) {
        if (std::isnan(mapIt->second)) {
          B2INFO("Not Comparing value to key " << i << " because value is NaN, checking if the functor returns NaN for this key");
          EXPECT_TRUE(std::isnan(secans.operator()(i))); // expect a NaN value from the operator
          continue; // do not compare NaNs! (will always fail due to their nature)
        }
        EXPECT_DOUBLE_EQ(mapIt->second, secans.operator()(i));
        ++mapIt;
      }
 
      range = _map.equal_range(i);
      mapIt = range.first;
      for (int j = 0; j < std::distance(range.first, range.second); ++j) {
        EXPECT_DOUBLE_EQ(mapIt->second, sinHalf.operator()(i));
      }
    }
  }

TEST_F() [7/50]

TEST_F	(	MapHelperFunctionsTest	,
		testGetAllValues
	)

test the getAllValues() function actually returns all values that are stored in the map

Definition at line 323 of file mapHelperFunctions.cc.

  {
    // set up vectors with all values there are in the maps
    std::vector<double> possibleValues, nanPossibleValues;
    for (int i = 0; i < _nEntries; ++i) {
      possibleValues.push_back(sinHalf.operator()(i));
      nanPossibleValues.push_back(secans.operator()(i));
    }
    // sort vectors to be able to simply loop over them for comparison since the order is unimportant for this function
    std::sort(possibleValues.begin(), possibleValues.end());
    std::sort(nanPossibleValues.begin(), nanPossibleValues.end());
 
    // test normal map first
    std::vector<double> allValues = getAllValues(_map);
    EXPECT_EQ(allValues.size(), _nEntries);
    std::sort(allValues.begin(), allValues.end());
    for (int i = 0; i < _nEntries; ++i) {
      EXPECT_DOUBLE_EQ(allValues[i], possibleValues[i]);
    }
 
    // test multimap with non NaN entries
    allValues = getAllValues(_multimap);
    EXPECT_EQ(allValues.size(), _nEntries);
    std::sort(allValues.begin(), allValues.end());
    for (int i = 0; i < _nEntries; ++i) {
      EXPECT_DOUBLE_EQ(allValues[i], possibleValues[i]);
    }
 
    // TODO: does not work at the moment, FIX THIS!!
    // test the nan maps
    // allValues = getAllValues(_nanMap);
    // EXPECT_EQ(allValues.size(), _nEntries);
    // std::sort(allValues.begin(), allValues.end());
    // for(int i = 0; i < _nEntries; ++i) {
    //   EXPECT_DOUBLE_EQ(allValues[i], possibleValues[i]);
    // }
 
    // allValues = getAllValues(_nanMultiMap);
    // EXPECT_EQ(allValues.size(), _nEntries);
    // std::sort(allValues.begin(), allValues.end());
    // for(int i = 0; i < _nEntries; ++i) {
    //   EXPECT_DOUBLE_EQ(allValues[i], possibleValues[i]);
    // }
 
 
  }

TEST_F() [8/50]

TEST_F	(	MapHelperFunctionsTest	,
		testGetNValuesPerKey
	)

test the 'getNValuesPerKey' method

Definition at line 250 of file mapHelperFunctions.cc.

  {
    std::vector<std::pair<int, unsigned int> > mapKeys = getNValuesPerKey(_map);
    unsigned int oneKey2Value = std::count_if(mapKeys.begin(), mapKeys.end(),
    [](const std::pair<int, unsigned int>& pair) { return pair.second == 1; });
    EXPECT_EQ(_map.size(), oneKey2Value); // all keys should only be there once in a map!
 
    mapKeys = getNValuesPerKey(_nanMap);
    oneKey2Value = std::count_if(mapKeys.begin(), mapKeys.end(),
    [](const std::pair<int, unsigned int>& pair) { return pair.second == 1; });
    EXPECT_EQ(_nanMap.size(), oneKey2Value);
 
    // multimaps (NOTE: hardcoded expectations because of knowledge how the maps should be filled!)
    mapKeys = getNValuesPerKey(_nanMultiMap);
    EXPECT_EQ(mapKeys.size(), 6);
    for (const auto& key : mapKeys) {
      EXPECT_EQ(key.second, key.first < 2 ? 4 : 3);
    }
 
    mapKeys = getNValuesPerKey(_multimap);
    EXPECT_EQ(mapKeys.size(), 6);
    for (const auto& key : mapKeys) {
      EXPECT_EQ(key.second, key.first < 2 ? 4 : 3);
    }
  }

TEST_F() [9/50]

TEST_F	(	MapHelperFunctionsTest	,
		testGetSortedKeyValueTuples
	)

test if the 'getSortedKeyValuePairs' method actually works as advertised

Definition at line 277 of file mapHelperFunctions.cc.

  {
    // multimap without nans first
    std::vector<int> possibleKeys = { 0, 1, 2, 3, 4, 5 };
    std::vector<double> summedValues;
    std::vector<double> summedNanValues;
    for (int key : possibleKeys) {
      std::vector<double> possibleValues;
      std::vector<double> possibleNanValues;
      for (int arg = key; arg < _nEntries; arg += 6) {
        possibleValues.push_back(sinHalf.operator()(arg));
        possibleNanValues.push_back(secans.operator()(arg));
      }
      summedNanValues.push_back(std::accumulate(possibleNanValues.begin(), possibleNanValues.end(), 0.0));
      summedValues.push_back(std::accumulate(possibleValues.begin(), possibleValues.end(), 0.0));
    }
 
    std::vector<std::tuple<int, double, unsigned int> > keyValPairs = getSortedKeyValueTuples(_nanMultiMap);
 
    EXPECT_EQ(keyValPairs.size(), 6);
    // hardcoded checking here (only sampling here! not checking the whole thing!)
    EXPECT_EQ(get<0>(keyValPairs[0]), 0);
    EXPECT_TRUE(std::isnan(get<1>(keyValPairs[0])));
    EXPECT_EQ(get<2>(keyValPairs[0]), 4);
 
    // all the other checks with multimap without NaNs
    keyValPairs = getSortedKeyValueTuples(_multimap);
    EXPECT_EQ(keyValPairs.size(), 6);
 
    EXPECT_EQ(get<0>(keyValPairs[0]), 0);
    EXPECT_DOUBLE_EQ(get<1>(keyValPairs[0]), summedValues[0]);
    EXPECT_EQ(get<2>(keyValPairs[0]), 4);
 
    EXPECT_EQ(get<0>(keyValPairs[2]), 3);
    EXPECT_DOUBLE_EQ(get<1>(keyValPairs[2]), summedValues[3]);
    EXPECT_EQ(get<2>(keyValPairs[2]), 3);
 
    keyValPairs = getSortedKeyValueTuples(_map);
    EXPECT_EQ(get<0>(keyValPairs[0]), 3); // sin(x/2) has its maximum at x = n*pi, 3 is the value that comes closest to this
    EXPECT_DOUBLE_EQ(get<1>(keyValPairs[0]), sinHalf.operator()(3));
 
    EXPECT_EQ(get<0>(keyValPairs[19]), 9);
    EXPECT_DOUBLE_EQ(get<1>(keyValPairs[19]), sinHalf.operator()(9));
  }

TEST_F() [10/50]

TEST_F	(	MapHelperFunctionsTest	,
		testGetUniqueKeys
	)

test if the 'getUniqueKeys' method returns the right values

Definition at line 181 of file mapHelperFunctions.cc.

  {
    // get the unique keys for the map (assuming that the key_type is int!)
    std::vector<int> uniqueKeys = getUniqueKeys(_map);
    EXPECT_EQ(uniqueKeys.size(), _map.size()); // for the map the number of uniqueKeys has to be the same as the size!
    for (size_t i = 0; i < uniqueKeys.size(); ++i) {
      // using std::find because in this way there is no assumption on the order of the keys!
      auto findIt = std::find(uniqueKeys.begin(), uniqueKeys.end(), i);
      EXPECT_FALSE(findIt == uniqueKeys.end());
    }
 
    // get the unique keys for the multimap
    std::vector<int> uniqueMultiKeys = getUniqueKeys(_multimap);
    unsigned int expectedSize = _multimap.size() > 6 ? 6 : _multimap.size(); // (creation of the map is % 6 -> only 6 keys possible)
    EXPECT_EQ(expectedSize, uniqueMultiKeys.size());
    for (size_t i = 0; i < uniqueMultiKeys.size(); ++i) {
      // using std::find because in this way there is no assumption on the order of the keys!
      auto findIt = std::find(uniqueMultiKeys.begin(), uniqueMultiKeys.end(), i);
      EXPECT_FALSE(findIt == uniqueMultiKeys.end());
    }
  }

TEST_F() [11/50]

TEST_F	(	MapHelperFunctionsTest	,
		testGetValuesToKey
	)

test if the 'getValuesToKey' method returns the right values to a given key

Definition at line 204 of file mapHelperFunctions.cc.

  {
    // multimap
    std::vector<int> possibleKeys = { 0, 1, 2, 3, 4, 5 };
    for (int key : possibleKeys) {
      std::vector<double> expectedValues;
      for (int arg = key; arg < _nEntries; arg += 6) { expectedValues.push_back(sinHalf.operator()(arg)); }
      std::vector<double> actualValues = getValuesToKey(_multimap, key);
      EXPECT_EQ(expectedValues.size(), actualValues.size());
 
      // check if all values are present
      for (const double& d : actualValues) {
        EXPECT_FALSE(std::find(expectedValues.begin(), expectedValues.end(), d) == expectedValues.end());
      }
      expectedValues.clear();
      for (int arg = key; arg < _nEntries; arg += 6) {
        expectedValues.push_back(secans.operator()(arg));
      }
      actualValues = getValuesToKey(_nanMultiMap, key);
      EXPECT_EQ(expectedValues.size(), actualValues.size());
 
      // check if all values are present
      for (const double& d : actualValues) {
        if (std::isnan(d)) {
          B2INFO("Not comparing NaN value!");
          continue;
        }
        EXPECT_FALSE(std::find(expectedValues.begin(), expectedValues.end(), d) == expectedValues.end());
      }
    }
 
    // map
    for (int i = 0; i < _nEntries; ++i) {
      std::vector<double> values = getValuesToKey(_map, i);
      EXPECT_EQ(values.size(), 1);
      EXPECT_DOUBLE_EQ(values[0], sinHalf.operator()(i));
 
      values = getValuesToKey(_nanMap, i);
      EXPECT_EQ(values.size(), 1);
      if (!std::isnan(values[0])) { // not checking here (already checked, that the functor leads to this above)
        EXPECT_DOUBLE_EQ(values[0], secans.operator()(i));
      }
    }
  }

TEST_F() [12/50]

TEST_F	(	RecoTrackTest	,
		cdcHit
	)

Test simple Setters and Getters.

Definition at line 105 of file recoTrack.cc.

  {
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    EXPECT_FALSE(m_recoTrack->hasCDCHits());
 
    // Add three cdc hits to the track
    m_recoTrack->addCDCHit(cdcHits[0], 1);
    m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
    m_recoTrack->addCDCHit(cdcHits[2], 2);
 
    EXPECT_TRUE(m_recoTrack->hasCDCHits());
 
    EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[0]));
    EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[1]));
    EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[2]));
 
    EXPECT_FALSE(m_recoTrack->hasHit(cdcHits[4]));
 
    ASSERT_EQ(m_recoTrack->getNumberOfCDCHits(), 3);
    const std::vector<CDCHit*> addedCDCHits = m_recoTrack->getCDCHitList();
    ASSERT_EQ(addedCDCHits.size(), 3);
    EXPECT_EQ(addedCDCHits[0], cdcHits[0]);
    EXPECT_EQ(addedCDCHits[1], cdcHits[1]);
    EXPECT_EQ(addedCDCHits[2], cdcHits[2]);
 
    const std::vector<CDCHit*> sortedCDCHits = m_recoTrack->getSortedCDCHitList();
    ASSERT_EQ(sortedCDCHits.size(), 3);
    EXPECT_EQ(sortedCDCHits[0], cdcHits[1]);
    EXPECT_EQ(sortedCDCHits[1], cdcHits[0]);
    EXPECT_EQ(sortedCDCHits[2], cdcHits[2]);
 
    // Individual hit information
    CDCHit* cdcHit = cdcHits[0];
 
    RecoHitInformation* recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
    EXPECT_NE(recoHitInformation, nullptr);
    EXPECT_EQ(recoHitInformation->getTrackingDetector(), RecoHitInformation::RecoHitDetector::c_CDC);
    EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
    EXPECT_EQ(recoHitInformation->getFoundByTrackFinder(), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
    EXPECT_EQ(recoHitInformation->getSortingParameter(), 1);
 
    cdcHit = cdcHits[1];
    recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
    EXPECT_NE(recoHitInformation, nullptr);
    EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_right);
 
 
 
    // Setter and getter for the reco hit information
    // with added hits
    cdcHit = cdcHits[0];
 
    EXPECT_EQ(m_recoTrack->getTrackingDetector(cdcHit), RecoHitInformation::RecoHitDetector::c_CDC);
    EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
    EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
    EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 1);
 
    EXPECT_NO_THROW(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
    EXPECT_NO_THROW(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
    EXPECT_NO_THROW(m_recoTrack->setSortingParameter(cdcHit, 3));
 
    EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner);
    EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_left);
    EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 3);
 
    // with not added hits
    cdcHit = cdcHits[4];
 
    EXPECT_B2FATAL(m_recoTrack->getTrackingDetector(cdcHit));
    EXPECT_B2FATAL(m_recoTrack->getRightLeftInformation(cdcHit));
    EXPECT_B2FATAL(m_recoTrack->getFoundByTrackFinder(cdcHit));
    EXPECT_B2FATAL(m_recoTrack->getSortingParameter(cdcHit));
 
    EXPECT_B2FATAL(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
    EXPECT_B2FATAL(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
  }

TEST_F() [13/50]

TEST_F	(	RecoTrackTest	,
		cdcHitMCFinderCategory
	)

Test simple Correct handling fo the MCFinder hit classification.

Definition at line 184 of file recoTrack.cc.

  {
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    EXPECT_FALSE(m_recoTrack->hasCDCHits());
 
    // Add three cdc hits to the track
    m_recoTrack->addCDCHit(cdcHits[0], 1, RecoHitInformation::RightLeftInformation::c_right,
                           RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
    m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right,
                           RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
    // the mcfinder prorperty of this hit is not provided explicitly and therefore should be set to undefined
    m_recoTrack->addCDCHit(cdcHits[2], 2);
 
    // get the RecoHitInfo and check their category
    EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[0])->getFoundByTrackFinder(),
              RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
    EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[1])->getFoundByTrackFinder(),
              RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
    EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[2])->getFoundByTrackFinder(),
              RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
  }

TEST_F() [14/50]

TEST_F	(	RecoTrackTest	,
		copyRecoTrack
	)

Test copying a RecoTrack.

Definition at line 278 of file recoTrack.cc.

  {
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    // Add three cdc hits to the track
    m_recoTrack->addCDCHit(cdcHits[0], 1);
    m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
    m_recoTrack->addCDCHit(cdcHits[2], 2);
 
    // create a second RecoTrack
    StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
 
    auto recoTrack = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(), m_recoTrack->getChargeSeed(),
                                          m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
                                          m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
                                          m_storeArrayNameOfHitInformation);
    EXPECT_FALSE(recoTrack->hasCDCHits());
 
    // check if the offset computation of the hit order works as expected
    size_t offset = 3;
    recoTrack->addHitsFromRecoTrack(m_recoTrack, offset);
    ASSERT_EQ(recoTrack->getNumberOfCDCHits(), 3);
 
    size_t this_i = offset;
    for (auto pHit : recoTrack->getSortedCDCHitList()) {
      auto sortParam = recoTrack->getSortingParameter(pHit);
      ASSERT_EQ(this_i, sortParam);
      this_i++;
    }
  }

TEST_F() [15/50]

TEST_F	(	RecoTrackTest	,
		recoHitInformations
	)

Test the getRecoHitInformations() function.

Definition at line 310 of file recoTrack.cc.

  {
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    m_recoTrack->addCDCHit(cdcHits[0], 1);
 
    // create a second RecoTrack
    StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
 
    RecoTrack* recoTrack2 = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(),
                                                 m_recoTrack->getChargeSeed(),
                                                 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
                                                 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
                                                 m_storeArrayNameOfHitInformation);
    recoTrack2->addCDCHit(cdcHits[1], 2);
 
    ASSERT_EQ(m_recoTrack->getRecoHitInformations().size(), 1);
    ASSERT_EQ(m_recoTrack->getRecoHitInformations()[0]->getSortingParameter(), 1);
    ASSERT_EQ(recoTrack2->getRecoHitInformations().size(), 1);
    ASSERT_EQ(recoTrack2->getRecoHitInformations()[0]->getSortingParameter(), 2);
  }

TEST_F() [16/50]

TEST_F	(	RecoTrackTest	,
		testGenfitConversionOne
	)

Test conversion to genfit track cands.

Definition at line 208 of file recoTrack.cc.

  {
    // Create a genfit track cand
    genfit::TrackCand newCreatedTrackCand;
    ROOT::Math::XYZVector position(4, 23, 5.6);
    ROOT::Math::XYZVector momentum(4, 23, 5.6);
    short int charge = 1;
    // We can not add these parameters immediately - we hve to convert them to the perigee parameters
    newCreatedTrackCand.setPosMomSeed(XYZToTVector(position), XYZToTVector(momentum), charge);
    newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 0, -1, 0, 0));
    newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 1, -1, 1, 0));
    newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 2, -1, 2, 0));
 
    // convert it to a RecoTrack
    RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(newCreatedTrackCand, m_storeArrayNameOfRecoTracks,
                                     m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
                                     m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
                                     m_storeArrayNameOfHitInformation);
 
    // convert it back
 
    const genfit::TrackCand& exportedTrackCand = recoTrackFromGenfit->createGenfitTrackCand();
 
    // Expect equal
    ASSERT_EQ(exportedTrackCand.getNHits(), newCreatedTrackCand.getNHits());
    EXPECT_NEAR(exportedTrackCand.getPosSeed().X(), newCreatedTrackCand.getPosSeed().X(), 1E-10);
    EXPECT_NEAR(exportedTrackCand.getPosSeed().Y(), newCreatedTrackCand.getPosSeed().Y(), 1E-10);
    EXPECT_NEAR(exportedTrackCand.getPosSeed().Z(), newCreatedTrackCand.getPosSeed().Z(), 1E-10);
    EXPECT_NEAR(exportedTrackCand.getMomSeed().X(), newCreatedTrackCand.getMomSeed().X(), 1E-10);
    EXPECT_NEAR(exportedTrackCand.getMomSeed().Y(), newCreatedTrackCand.getMomSeed().Y(), 1E-10);
    EXPECT_NEAR(exportedTrackCand.getMomSeed().Z(), newCreatedTrackCand.getMomSeed().Z(), 1E-10);
    EXPECT_EQ(exportedTrackCand.getChargeSeed(), newCreatedTrackCand.getChargeSeed());
    EXPECT_EQ(exportedTrackCand.getHit(0)->getHitId(), newCreatedTrackCand.getHit(0)->getHitId());
    EXPECT_EQ(exportedTrackCand.getHit(1)->getSortingParameter(), newCreatedTrackCand.getHit(1)->getSortingParameter());
    EXPECT_EQ(exportedTrackCand.getHit(2)->getHitId(), newCreatedTrackCand.getHit(2)->getHitId());
  }

TEST_F() [17/50]

TEST_F	(	RecoTrackTest	,
		testGenfitConversionTwo
	)

Test conversion from genfit track cands.

Definition at line 246 of file recoTrack.cc.

  {
    EXPECT_FALSE(m_recoTrack->hasCDCHits());
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    // Add three cdc hits to the track
    m_recoTrack->addCDCHit(cdcHits[0], 1);
    m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
    m_recoTrack->addCDCHit(cdcHits[2], 2);
 
    EXPECT_TRUE(m_recoTrack->hasCDCHits());
 
    const genfit::TrackCand& exportedTrackCand = m_recoTrack->createGenfitTrackCand();
 
    ASSERT_EQ(exportedTrackCand.getNHits(), m_recoTrack->getNumberOfTotalHits());
    ASSERT_EQ(m_recoTrack->getNumberOfTotalHits(), 3);
 
    RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(exportedTrackCand, m_storeArrayNameOfRecoTracks,
                                     m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
                                     m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
                                     m_storeArrayNameOfHitInformation);
 
    B2INFO("kjh");
 
    ASSERT_EQ(recoTrackFromGenfit->getNumberOfCDCHits(), m_recoTrack->getNumberOfCDCHits());
    const auto& cdcHitListOne = recoTrackFromGenfit->getCDCHitList();
    const auto& cdcHitListTwo = m_recoTrack->getCDCHitList();
    ASSERT_EQ(cdcHitListOne.size(), 3);
    ASSERT_EQ(cdcHitListTwo.size(), 3);
  }

TEST_F() [18/50]

TEST_F	(	RecoTrackTest	,
		trackTime
	)

Test getOutgoingArmTime() and getIngoingArmTime() functions.

Definition at line 333 of file recoTrack.cc.

  {
    StoreArray<SVDCluster> svdHits(m_storeArrayNameOfSVDHits);
    StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
 
    //"SVDCluster(VxdID, isU, position, positionErr, clsTime, clsTimeErr, clsCharge, seedCharge, clsSize, clsSNR, clsChi2, FF)"
    svdHits.appendNew(Belle2::VxdID("3.1.2"), true, 1.0, 0.01, 0.1, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
    svdHits.appendNew(Belle2::VxdID("4.1.2"), true, 1.0, 0.01, 0.2, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
    svdHits.appendNew(Belle2::VxdID("5.1.3"), true, 1.0, 0.01, 0.3, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
    svdHits.appendNew(Belle2::VxdID("6.1.3"), true, 1.0, 0.01, 0.4, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
    svdHits.appendNew(Belle2::VxdID("6.7.7"), true, 1.0, 0.01, 1.0, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
    svdHits.appendNew(Belle2::VxdID("5.7.4"), true, 1.0, 0.01, 1.1, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
 
    ROOT::Math::XYZVector momentum(0.25, 0.25, 0.05);
 
    StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
    RecoTrack* recoTrack = recoTracks.appendNew(m_recoTrack->getPositionSeed(), momentum,
                                                m_recoTrack->getChargeSeed(),
                                                m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
                                                m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
                                                m_storeArrayNameOfHitInformation);
 
    // SVD Hits
    recoTrack->addSVDHit(svdHits[0], 0);
    recoTrack->addSVDHit(svdHits[1], 1);
    recoTrack->addSVDHit(svdHits[2], 2);
    recoTrack->addSVDHit(svdHits[3], 3);
 
    // CDC Hits
    recoTrack->addCDCHit(cdcHits[0], 4);
    recoTrack->addCDCHit(cdcHits[1], 5);
 
    // SVD Hits
    recoTrack->addSVDHit(svdHits[4], 6);
    recoTrack->addSVDHit(svdHits[5], 7);
 
    EXPECT_TRUE(recoTrack->hasSVDHits());
 
    EXPECT_FALSE(recoTrack->hasOutgoingArmTime());
    EXPECT_FALSE(recoTrack->hasIngoingArmTime());
 
    B2INFO("outgoing arm time: " << recoTrack->getOutgoingArmTime());
    B2INFO("ingoing arm time:  " << recoTrack->getIngoingArmTime());
    B2INFO("difference: " << recoTrack->getInOutArmTimeDifference());
    EXPECT_NEAR(recoTrack->getIngoingArmTime(), recoTrack->getOutgoingArmTime(), 0.8);
    EXPECT_NEAR(recoTrack->getIngoingArmTime(), 1.05, 1E-5);
 
    EXPECT_TRUE(recoTrack->hasOutgoingArmTime());
    EXPECT_TRUE(recoTrack->hasIngoingArmTime());
  }

TEST_F() [19/50]

TEST_F	(	SandBox4TestingTest	,
		JustSomePlayingAroundWithfunction
	)

test function call with auto-assigned value

Definition at line 63 of file sandBox4Testing.h.

  {
    EXPECT_TRUE(doStuffHere());
    EXPECT_FALSE(doStuffHere({23}));
 
    if (doStuffHere() == false) {
      B2WARNING("it didn't work!");
    } else {
      B2WARNING("yay, it worked!");
    }
  }

TEST_F() [20/50]

TEST_F	(	SandBox4TestingTest	,
		testingVerbosityViaTemplates
	)

test function call with auto-assigned value

Definition at line 53 of file sandBox4Testing.h.

  {
    VerbosityClass<4> class4;
    VerbosityClass<1> class1;
 
    class4.SomeCleverMethod();
    class1.SomeCleverMethod();
  }

TEST_F() [21/50]

TEST_F	(	SandBox4TestingTest	,
		TestIsNanAndIsInfBehavior
	)

shall show when to get nan and when to get inf (and that inf != nan)

Definition at line 77 of file sandBox4Testing.h.

  {
    EXPECT_TRUE(std::isinf(1. / 0.));
    EXPECT_FALSE(std::isnan(1. / 0.));
    EXPECT_TRUE(std::isnan(std::sqrt(-1)));
    EXPECT_FALSE(std::isinf(std::sqrt(-1)));
    EXPECT_TRUE(std::isnan(0. / 0.));
    EXPECT_FALSE(std::isinf(0. / 0.));
 
//  EXPECT_FALSE(std::isnan(std::pow(0.,0.))); // this should be nan, but actually it is implementation dependent, therefore here we get for 0^0 = 1, which is mathematically not correct
    EXPECT_FALSE(std::isinf(std::pow(0., 0.)));
  }

TEST_F() [22/50]

TEST_F	(	SectorTest	,
		testConstructorSettersAndGetters
	)

Test Constructor, Setters and Getters.

Definition at line 25 of file sector.h.

  {
    VxdID vxdID = VxdID(34624); // this should be a sensor on layer 4
    bool subLayerID = true;
    unsigned short sectorID = 15;
 
 
    B2INFO("creating FullSecIDs: ");
    FullSecID aFullSecID = FullSecID(vxdID, subLayerID, sectorID);
    unsigned int aFullSecInt = static_cast<unsigned int>(aFullSecID);
 
    FullSecID aFullSecID2 = FullSecID(vxdID, false, sectorID);
    unsigned int aFullSecInt2 = static_cast<unsigned int>(aFullSecID2);
 
    FullSecID aFullSecID3 = FullSecID(vxdID, subLayerID, 7);
    unsigned int aFullSecInt3 = static_cast<unsigned int>(aFullSecID3);
 
    FullSecID aFullSecID4;
    unsigned int aFullSecInt4 = static_cast<unsigned int>(aFullSecID4);
 
 
    // producing sectors which can be sorted by secID:
    Sector aSector(aFullSecInt);
    Sector aSector2(aFullSecInt2);
    Sector aSector3(aFullSecInt3);
    Sector aSector4(aFullSecInt4);
 
    EXPECT_EQ(aFullSecInt, aSector.getSecID());
    EXPECT_EQ(aFullSecInt2, aSector2.getSecID());
    EXPECT_EQ(aFullSecInt3, aSector3.getSecID());
    EXPECT_EQ(aFullSecInt4, aSector4.getSecID());
    EXPECT_EQ(0, aSector.getDistance());
    EXPECT_EQ(0, aSector2.getDistance());
    EXPECT_EQ(0, aSector3.getDistance());
    EXPECT_EQ(0, aSector4.getDistance());
 
 
    // producing sectors which can be sorted by secID:
    Sector dSector(aFullSecInt, 3.5);
    Sector dSector2(aFullSecInt2, 3.3, true);
    Sector dSector3(aFullSecInt3, 3.4);
    Sector dSector4(aFullSecInt4, 0, true);
  }

TEST_F() [23/50]

TEST_F	(	SpacePointTest	,
		testConstructorPXD
	)

Test constructor for PXDClsuters tests the constructor importing a PXDCluster and tests results by using the getters of the spacePoint...

Definition at line 58 of file spacePoint.cc.

  {
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
 
    // create new PXDCluster and fill it with Info getting a Hit which is not at the origin (here, first layer)
 
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    SpacePoint testPoint = SpacePoint(&aCluster, &sensorInfoBase);
 
    EXPECT_DOUBLE_EQ(aVxdID, testPoint.getVxdID());
 
    // needing globalized position and error:
    ROOT::Math::XYZVector aPosition = sensorInfoBase.pointToGlobal(ROOT::Math::XYZVector(aCluster.getU(), aCluster.getV(), 0), true);
    ROOT::Math::XYZVector globalizedVariances = sensorInfoBase.vectorToGlobal(
                                                  ROOT::Math::XYZVector(
                                                    aCluster.getUSigma() * aCluster.getUSigma(),
                                                    aCluster.getVSigma() * aCluster.getVSigma(),
                                                    0
                                                  ),
                                                  true
                                                );
 
    ROOT::Math::XYZVector globalError;
    globalError.SetX(sqrt(abs(globalizedVariances.X())));
    globalError.SetY(sqrt(abs(globalizedVariances.Y())));
    globalError.SetZ(sqrt(abs(globalizedVariances.Z())));
 
    EXPECT_DOUBLE_EQ(aPosition.X(), testPoint.getPosition().X());
    EXPECT_DOUBLE_EQ(aPosition.Y(), testPoint.getPosition().Y());
    EXPECT_DOUBLE_EQ(aPosition.Z(), testPoint.getPosition().Z());
    EXPECT_FLOAT_EQ(globalError.X(), testPoint.getPositionError().X());
    EXPECT_FLOAT_EQ(globalError.Y(), testPoint.getPositionError().Y());
    EXPECT_FLOAT_EQ(globalError.Z(), testPoint.getPositionError().Z());
    // normalized coordinates, center of Plane should be at 0.5:
    EXPECT_DOUBLE_EQ(0.5, testPoint.getNormalizedLocalU());
    EXPECT_DOUBLE_EQ(0.5, testPoint.getNormalizedLocalV());
 
  }

TEST_F() [24/50]

TEST_F	(	SpacePointTest	,
		testConstructorSVD
	)

Test constructor for SVDClsuters tests the constructor importing a SVDCluster and tests results by using the getters of the spacePoint...

Definition at line 104 of file spacePoint.cc.

  {
    VxdID aVxdID = VxdID(3, 3, 3), anotherVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
    VXD::SensorInfoBase anotherSensorInfoBase = createSensorInfo(anotherVxdID, 2.3, 4.2);
 
    // create new SVDClusters and fill it with Info getting a Hit which is not at the origin
    // SVDCluster (VxdID sensorID, bool isU, float position, float positionSigma, double clsTime, double clsTimeSigma, float seedCharge, float clsCharge, unsigned short clsSize, double clsSNR)
    SVDCluster clusterU1 = SVDCluster(aVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1);
    SVDCluster clusterV1 = SVDCluster(aVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1);
    SVDCluster clusterU2 = SVDCluster(aVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1);
    SVDCluster clusterU3 = SVDCluster(anotherVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1);
 
 
    // normal u+v = 2D Cluster (order of input irrelevant):
    std::vector<const SVDCluster*> good2D = { &clusterU1, &clusterV1 };
    SpacePoint testPoint2D = SpacePoint(good2D, &sensorInfoBase);
 
    // normal u-only = 1D Cluster, sensorInfoBase is normally not needed, since constructor can create it on its own, but here the geometry is not set up, therefore we have to pass the infoBase:
    std::vector<const SVDCluster*> good1D = { &clusterU3 };
    SpacePoint testPoint1D = SpacePoint(good1D, &anotherSensorInfoBase);
 
 
    // should throw, since no clusters given:
    std::vector<const SVDCluster*> badNoClusters;
    EXPECT_B2FATAL(SpacePoint(badNoClusters, &sensorInfoBase));
 
    // should throw, since too many clusters (of same sensor) given:
    std::vector<const SVDCluster*> bad3Clusters = { &clusterU1, &clusterV1, &clusterU2 };
    EXPECT_B2FATAL(SpacePoint(bad3Clusters, &sensorInfoBase));
 
    // should throw, since two clusters of same type (but on same sensor) given:
    std::vector<const SVDCluster*> badSameType = { &clusterU1, &clusterU2 };
    EXPECT_B2FATAL(SpacePoint(badSameType, &sensorInfoBase));
 
    // should throw, since two clusters of different sensors given:
    std::vector<const SVDCluster*> badDifferentSensors = { &clusterV1, &clusterU3 };
    EXPECT_B2FATAL(SpacePoint(badDifferentSensors, &sensorInfoBase));
 
 
    // check results for full 2D cluster-combi:
    ROOT::Math::XYZVector aPositionFor2D = sensorInfoBase.pointToGlobal(ROOT::Math::XYZVector(clusterU1.getPosition(),
                                           clusterV1.getPosition(), 0), true);
    ROOT::Math::XYZVector globalizedVariancesFor2D = sensorInfoBase.vectorToGlobal(
                                                       ROOT::Math::XYZVector(
                                                         clusterU1.getPositionSigma() * clusterU1.getPositionSigma(),
                                                         clusterV1.getPositionSigma() * clusterV1.getPositionSigma(),
                                                         0
                                                       ),
                                                       true
                                                     );
    ROOT::Math::XYZVector globalErrorFor2D;
    globalErrorFor2D.SetX(sqrt(abs(globalizedVariancesFor2D.X())));
    globalErrorFor2D.SetY(sqrt(abs(globalizedVariancesFor2D.Y())));
    globalErrorFor2D.SetZ(sqrt(abs(globalizedVariancesFor2D.Z())));
 
    // vxdID:
    EXPECT_EQ(aVxdID, testPoint2D.getVxdID());
    // global position:
    EXPECT_FLOAT_EQ(aPositionFor2D.X(), testPoint2D.getPosition().X());
    EXPECT_FLOAT_EQ(aPositionFor2D.Y(), testPoint2D.getPosition().Y());
    EXPECT_FLOAT_EQ(aPositionFor2D.Z(), testPoint2D.getPosition().Z());
    //global error:
    EXPECT_FLOAT_EQ(globalErrorFor2D.X(), testPoint2D.getPositionError().X());
    EXPECT_FLOAT_EQ(globalErrorFor2D.Y(), testPoint2D.getPositionError().Y());
    EXPECT_FLOAT_EQ(globalErrorFor2D.Z(), testPoint2D.getPositionError().Z());
    //local normalized position:
    EXPECT_FLOAT_EQ(0.4, testPoint2D.getNormalizedLocalU());
    EXPECT_FLOAT_EQ(0.6, testPoint2D.getNormalizedLocalV());
 
 
    // check results for single-cluster-only-case:
    ROOT::Math::XYZVector aPositionFor1D = anotherSensorInfoBase.pointToGlobal(ROOT::Math::XYZVector(clusterU3.getPosition(), 0, 0),
                                           true);
    ROOT::Math::XYZVector globalizedVariancesFor1D = anotherSensorInfoBase.vectorToGlobal(
                                                       ROOT::Math::XYZVector(
                                                         clusterU3.getPositionSigma() * clusterU3.getPositionSigma(),
                                                         anotherSensorInfoBase.getVSize() * anotherSensorInfoBase.getVSize() / 12.,
                                                         0
                                                       ),
                                                       true
                                                     );
    ROOT::Math::XYZVector globalErrorFor1D;
    globalErrorFor1D.SetX(sqrt(abs(globalizedVariancesFor1D.X())));
    globalErrorFor1D.SetY(sqrt(abs(globalizedVariancesFor1D.Y())));
    globalErrorFor1D.SetZ(sqrt(abs(globalizedVariancesFor1D.Z())));
 
 
    // vxdID:
    EXPECT_EQ(anotherVxdID, testPoint1D.getVxdID());
    // global position:
    EXPECT_FLOAT_EQ(aPositionFor1D.X(), testPoint1D.getPosition().X());
    EXPECT_FLOAT_EQ(aPositionFor1D.Y(), testPoint1D.getPosition().Y());
    EXPECT_FLOAT_EQ(aPositionFor1D.Z(), testPoint1D.getPosition().Z());
    //global error:
    EXPECT_FLOAT_EQ(globalErrorFor1D.X(), testPoint1D.getPositionError().X());
    EXPECT_FLOAT_EQ(globalErrorFor1D.Y(), testPoint1D.getPositionError().Y());
    EXPECT_FLOAT_EQ(globalErrorFor1D.Z(), testPoint1D.getPositionError().Z());
    //local normalized position:
    EXPECT_FLOAT_EQ(0.6, testPoint1D.getNormalizedLocalU());
    EXPECT_FLOAT_EQ(0.5, testPoint1D.getNormalizedLocalV()); // center of sensor since v-cluster was not given
  }

TEST_F() [25/50]

TEST_F	(	SpacePointTest	,
		testConvertLocalToNormalizedCoordinates
	)

Testing member of spacePoint: convertToNormalizedCoordinates.

convertToNormalizedCoordinates converts a local hit into sensor-independent relative coordinates defined between 0 and 1.

Definition at line 369 of file spacePoint.cc.

  {
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
 
    pair<float, float> sensorCenter = {1.15, 2.1};
 
    pair<float, float> hitLocal05 = {0, 0}; // sensorCenter is at 0, 0 in local coordinates
    pair<float, float> resultNormalized05 = {0.5, 0.5};
 
    pair<float, float> hitLocal001 = {0.023, 0.042};
    hitLocal001.first -= sensorCenter.first;
    hitLocal001.second -= sensorCenter.second;
    pair<float, float> resultNormalized001 = {0.01, 0.01};
 
    pair<float, float> hitLocal088 = {2.024, 3.696};
    hitLocal088.first -= sensorCenter.first;
    hitLocal088.second -= sensorCenter.second;
    pair<float, float> resultNormalized088 = {0.88, 0.88};
 
    pair<float, float> hitLocal001088 = {0.023, 3.696};// asymmetric example verifying that values are not accidentally switched
    hitLocal001088.first -= sensorCenter.first;
    hitLocal001088.second -= sensorCenter.second;
    pair<float, float> resultNormalized001088 = {0.01, 0.88};
 
    pair<float, float> hitLocalMinMax = { -1.16, 500}; // hit lies way beyond sensor edges (first is below lower threshold, second above higher one)
    pair<float, float> resultNormalizedMinMax = {0., 1.};
 
    pair<float, float> hitNormalized05 = SpacePoint::convertLocalToNormalizedCoordinates(hitLocal05, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultNormalized05.first, hitNormalized05.first);
    EXPECT_FLOAT_EQ(resultNormalized05.second, hitNormalized05.second);
 
    pair<float, float> hitNormalized001 = SpacePoint::convertLocalToNormalizedCoordinates(hitLocal001, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultNormalized001.first, hitNormalized001.first);
    EXPECT_NEAR(resultNormalized001.second, hitNormalized001.second, 1. / 100000.); // resolution of better than 1 nm.
 
    pair<float, float> hitNormalized088 = SpacePoint::convertLocalToNormalizedCoordinates(hitLocal088, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultNormalized088.first, hitNormalized088.first);
    EXPECT_FLOAT_EQ(resultNormalized088.second, hitNormalized088.second);
 
    pair<float, float> hitNormalized001088 = SpacePoint::convertLocalToNormalizedCoordinates(hitLocal001088, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultNormalized001088.first, hitNormalized001088.first);
    EXPECT_FLOAT_EQ(resultNormalized001088.second, hitNormalized001088.second);
 
    pair<float, float> hitNormalizedMinMax = SpacePoint::convertLocalToNormalizedCoordinates(hitLocalMinMax, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultNormalizedMinMax.first, hitNormalizedMinMax.first);
    EXPECT_FLOAT_EQ(resultNormalizedMinMax.second, hitNormalizedMinMax.second);
  }

TEST_F() [26/50]

TEST_F	(	SpacePointTest	,
		testConvertNormalizedToLocalCoordinates
	)

Testing member of spacePoint: convertToLocalCoordinates.

convertToLocalCoordinates converts a hit in sensor-independent relative (def. 0-1) coordinates into local coordinate of given sensor

Definition at line 424 of file spacePoint.cc.

  {
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
 
    pair<float, float> sensorCenter = {1.15, 2.1};
 
    pair<float, float> hitNormalized05 = {0.5, 0.5};
    pair<float, float> resultLocal05 = {0, 0}; // sensorCenter is at 0, 0 in local coordinates
 
    pair<float, float> hitNormalized001 = {0.01, 0.01};
    pair<float, float> resultLocal001 = {0.023, 0.042};
    resultLocal001.first -= sensorCenter.first;
    resultLocal001.second -= sensorCenter.second;
 
    pair<float, float> hitNormalized088 = {0.88, 0.88};
    pair<float, float> resultLocal088 = {2.024, 3.696};
    resultLocal088.first -= sensorCenter.first;
    resultLocal088.second -= sensorCenter.second;
 
    pair<float, float> hitNormalized001088 = {0.01, 0.88};
    pair<float, float> resultLocal001088 = {0.023, 3.696};// asymmetric example verifying that values are not accidentally switched
    resultLocal001088.first -= sensorCenter.first;
    resultLocal001088.second -= sensorCenter.second;
 
    pair<float, float> hitNormalizedMinMax = { -0.1, 4.2}; // hit lies way beyond sensor edges (first is below lower threshold, second above higher one)
    pair<float, float> resultLocalMinMax = { -1.15, 2.1}; // reduced to sensor borders
 
    pair<float, float> hitLocal05 = SpacePoint::convertNormalizedToLocalCoordinates(hitNormalized05, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultLocal05.first, hitLocal05.first);
    EXPECT_FLOAT_EQ(resultLocal05.second, hitLocal05.second);
 
    pair<float, float> hitLocal001 = SpacePoint::convertNormalizedToLocalCoordinates(hitNormalized001, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultLocal001.first, hitLocal001.first);
    EXPECT_FLOAT_EQ(resultLocal001.second, hitLocal001.second);
 
    pair<float, float> hitLocal088 = SpacePoint::convertNormalizedToLocalCoordinates(hitNormalized088, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultLocal088.first, hitLocal088.first);
    EXPECT_FLOAT_EQ(resultLocal088.second, hitLocal088.second);
 
    pair<float, float> hitLocal001088 = SpacePoint::convertNormalizedToLocalCoordinates(hitNormalized001088, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultLocal001088.first, hitLocal001088.first);
    EXPECT_FLOAT_EQ(resultLocal001088.second, hitLocal001088.second);
 
    pair<float, float> hitLocalMinMax = SpacePoint::convertNormalizedToLocalCoordinates(hitNormalizedMinMax, aVxdID, &sensorInfoBase);
    EXPECT_FLOAT_EQ(resultLocalMinMax.first, hitLocalMinMax.first);
    EXPECT_FLOAT_EQ(resultLocalMinMax.second, hitLocalMinMax.second);
  }

TEST_F() [27/50]

TEST_F	(	SpacePointTest	,
		testGetNClustersAssigned
	)

Test if the number of assigned Clusters is obtained correctly NOTE: using the same constructors as in previous tests!

Definition at line 479 of file spacePoint.cc.

  {
    // create a PXD SpacePoint and check if there is one Cluster assigned to it
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    SpacePoint testPoint = SpacePoint(&aCluster, &sensorInfoBase);
 
    EXPECT_EQ(testPoint.getNClustersAssigned(), 1);
 
    // create different SVD SpacePoints and check if the number of assigned Clusters is correct
    aVxdID = VxdID(3, 1, 2);
    sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2, -1, VXD::SensorInfoBase::SVD);
 
    // create new SVDClusters and fill it with Info getting a Hit which is not at the origin
    // SVDCluster (VxdID sensorID, bool isU, float position, float positionSigma, double clsTime, double clsTimeSigma, float seedCharge, float clsCharge, unsigned short clsSize)
    SVDCluster clusterU1 = SVDCluster(aVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1);
    SVDCluster clusterV1 = SVDCluster(aVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1);
 
    vector<const SVDCluster*> clusters2d = { &clusterU1, &clusterV1 };
    SpacePoint testPoint2D = SpacePoint(clusters2d, &sensorInfoBase);
    EXPECT_EQ(testPoint2D.getNClustersAssigned(), 2);
 
    vector<const SVDCluster*> clustersU = { &clusterU1 };
    SpacePoint testPoint1DU = SpacePoint(clustersU, &sensorInfoBase);
    EXPECT_EQ(testPoint1DU.getNClustersAssigned(), 1);
 
    vector<const SVDCluster*> clustersV = { &clusterV1 };
    SpacePoint testPoint1DV = SpacePoint(clustersV, &sensorInfoBase);
    EXPECT_EQ(testPoint1DV.getNClustersAssigned(), 1);
  }

TEST_F() [28/50]

TEST_F	(	SpacePointTest	,
		testRootIOB2Vector3
	)

Test if B2Vector3 writing in and reading from root files work.

create sample to be written in a root file:

test whole procedure with B2Vector3:

reopen file, read entries and check them

retrieve the B2Vector3 from file:

cleanup

Definition at line 260 of file spacePoint.cc.

  {
    string fNameVec = "demoB2Vector3s.root";
 
    B2Vector3F aVec(1.23, 2.34, 3.45);
 
 
    B2INFO("open root file: " << fNameVec);
    TFile f(fNameVec.c_str(), "recreate");
    f.cd();
    f.WriteObject(&aVec, "myVec3");
    f.Close();
 
    TFile f2(fNameVec.c_str());
    if (f2.IsZombie()) { B2ERROR("file could not be reopened!"); }
    else {
 
      B2Vector3F* retrievedVector;
      f2.GetObject("myVec3", retrievedVector);
      f2.Close();
 
      EXPECT_DOUBLE_EQ(aVec.X(), retrievedVector->X());
      EXPECT_DOUBLE_EQ(aVec.Y(), retrievedVector->Y());
      EXPECT_DOUBLE_EQ(aVec.Z(), retrievedVector->Z());
 
    }
    if (remove(fNameVec.c_str()) != 0)
    { B2ERROR("could not delete file " << fNameVec << "!"); }
    else
    { B2INFO(fNameVec << " successfully deleted"); }
  }

TEST_F() [29/50]

TEST_F	(	SpacePointTest	,
		testRootIOPXDCluster
	)

Test if cluster writing in and reading from root files work.

create samples to be written in a root file:

test whole procedure first with PXDCluster:

reopen file, read entries and check them

cleanup

Definition at line 209 of file spacePoint.cc.

  {
    string fNameCluster = "demoClusters.root";
    VxdID aVxdID = VxdID(1, 2, 3);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
 
 
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    EXPECT_EQ(aVxdID, aCluster.getSensorID());
 
    B2INFO("open root file: " << fNameCluster);
    TFile f(fNameCluster.c_str(), "recreate");
    f.cd();
    aCluster.Write();
    f.Close();
 
    TFile f2(fNameCluster.c_str());
    if (f2.IsZombie()) { B2ERROR("file could not be reopened!"); }
    else {
      PXDCluster* retrievedCluster;
      f2.GetListOfKeys()->Print();
 
      TIter next(f2.GetListOfKeys());
      TKey* key;
      while ((key = (TKey*)next())) {
 
        try {
          retrievedCluster = static_cast<PXDCluster*>(key->ReadObj());
        } catch (exception& e) {
          B2WARNING("Key was not a PXDCluster, therefore error message: " << e.what() << "\n Skipping this key...");
          continue;
        }
 
        EXPECT_EQ(retrievedCluster->getSensorID(), aCluster.getSensorID());
      }
      f2.Close();
    }
    if (remove(fNameCluster.c_str()) != 0)
    { B2ERROR("could not delete file " << fNameCluster << "!"); }
    else
    { B2INFO(fNameCluster << " successfully deleted"); }
  }

TEST_F() [30/50]

TEST_F	(	SpacePointTest	,
		testRootIOSP
	)

Test if spacePoints writing in and reading from root files work.

does not work - TODO solve!

create samples to be written in a root file:

create root file, fill spacePoint into file, store it, close

reopen file, read entries and check them

delete file from disk, cleanup}

Definition at line 301 of file spacePoint.cc.

  {
    string fNameSP = "demoSPs.root";
    VxdID aVxdID = VxdID(1, 2, 3);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
 
 
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    EXPECT_EQ(aVxdID, aCluster.getSensorID());
 
    SpacePoint testPoint = SpacePoint(&aCluster, &sensorInfoBase);
    EXPECT_EQ(aVxdID, testPoint.getVxdID());
 
 
    B2INFO("open root file:" << fNameSP);
    TFile f3(fNameSP.c_str(), "recreate");
    f3.cd();
    testPoint.Write();
    B2INFO("closing file:");
    f3.Close();
 
    TFile f4(fNameSP.c_str());
    if (f4.IsZombie()) { B2ERROR("file could not be reopened!"); }
    else {
      SpacePoint* retrievedSpacePoint;
      f4.GetListOfKeys()->Print();
 
      TIter next(f4.GetListOfKeys());
      TKey* key;
      while ((key = (TKey*)next())) {
 
        try {
          retrievedSpacePoint = static_cast<SpacePoint*>(key->ReadObj());
        } catch (exception& e) {
          B2WARNING("Key was not a SpacePoint, therefore error message: " << e.what() << "\n Skipping this key...");
          continue;
        }
 
        EXPECT_EQ(retrievedSpacePoint->getVxdID(), testPoint.getVxdID());
        EXPECT_DOUBLE_EQ(retrievedSpacePoint->getPosition().X(), testPoint.getPosition().X());
        EXPECT_DOUBLE_EQ(retrievedSpacePoint->getPosition().Y(), testPoint.getPosition().Y());
        EXPECT_DOUBLE_EQ(retrievedSpacePoint->getPosition().Z(), testPoint.getPosition().Z());
        EXPECT_FLOAT_EQ(retrievedSpacePoint->getPositionError().X(), testPoint.getPositionError().X());
        EXPECT_FLOAT_EQ(retrievedSpacePoint->getPositionError().Y(), testPoint.getPositionError().Y());
        EXPECT_FLOAT_EQ(retrievedSpacePoint->getPositionError().Z(), testPoint.getPositionError().Z());
        EXPECT_DOUBLE_EQ(retrievedSpacePoint->getNormalizedLocalU(), testPoint.getNormalizedLocalU());
        EXPECT_DOUBLE_EQ(retrievedSpacePoint->getNormalizedLocalV(), testPoint.getNormalizedLocalV());
      }
      f4.Close();
    }
    if (remove(fNameSP.c_str()) != 0)
    { B2ERROR("could not delete file " << fNameSP << "!"); }
    else
    { B2INFO(fNameSP << " successfully deleted"); }
  }

TEST_F() [31/50]

TEST_F	(	SpacePointTrackCandTest	,
		testConstructorFromVector
	)

Test the Constructor, that takes a vector of SpacePoint* as argument.

Definition at line 53 of file spacePointTrackCand.cc.

  {
    // set up some SpacePoints and group them to a vector
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase aSensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &aSensorInfoBase);
 
    VxdID anotherVxdID = VxdID(3, 3, 3);
    VXD::SensorInfoBase anotherSensorInfoBase = createSensorInfo(anotherVxdID, 2.3, 4.2);
    SVDCluster aUCluster = SVDCluster(anotherVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster = SVDCluster(anotherVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> a2HitCluster = { &aUCluster, &aVCluster };
    const SpacePoint aSVDSpacePoint = SpacePoint(a2HitCluster, &anotherSensorInfoBase);
 
    SVDCluster anotherUCluster = SVDCluster(anotherVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> a1HitCluster = { &anotherUCluster };
    const SpacePoint anotherSVDSpacePoint = SpacePoint(a1HitCluster, &anotherSensorInfoBase);
 
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint, &anotherSVDSpacePoint };
 
 
    // construct SpacePointTrackCand with (more or less arbitrary) values for pdg code, charge and MC-TrackID
    SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 11, -1, 23);
 
    // do some checks
    // check if all SpacePoints are actually in the TrackCand
    EXPECT_EQ(aSpacePointTC.getNHits(), aSpacePointVec.size());
    // check pdg, charge, etc...
    EXPECT_EQ(aSpacePointTC.getPdgCode(), Const::electron.getPDGCode());
    EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), -1);
    EXPECT_EQ(aSpacePointTC.getMcTrackID(), 23);
 
    // get SpacePoints and compare them with the original vector
    const std::vector<const SpacePoint*> returnSPVector = aSpacePointTC.getHits();
    for (unsigned int i = 0; i < aSpacePointTC.getNHits(); i++) {
      EXPECT_TRUE(returnSPVector[i] == aSpacePointVec[i]);
    }
  }

TEST_F() [32/50]

TEST_F	(	SpacePointTrackCandTest	,
		testEqualityOperator
	)

Test operator == of SpacePointTrackCand.

Definition at line 96 of file spacePointTrackCand.cc.

  {
    // set up some set up some space points and add them to SpacePointTrackCands
    // many parts copied from spacePoint.cc (tracking/tests/)
 
    VxdID aVxdID = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase);
 
    VxdID anotherVxdID = VxdID(3, 3, 3);
    VXD::SensorInfoBase anotherSensorInfoBase = createSensorInfo(anotherVxdID, 2.3, 4.2);
    SVDCluster aUCluster = SVDCluster(anotherVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster = SVDCluster(anotherVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> a2HitCluster = { &aUCluster, &aVCluster };
    const SpacePoint aSVDSpacePoint = SpacePoint(a2HitCluster, &anotherSensorInfoBase);
 
    SVDCluster anotherUCluster = SVDCluster(anotherVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> a1HitCluster = { &anotherUCluster };
    const SpacePoint anotherSVDSpacePoint = SpacePoint(a1HitCluster, &anotherSensorInfoBase);
 
    const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint };
    const std::vector<const Belle2::SpacePoint*> sameSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint };
    const std::vector<const Belle2::SpacePoint*> anotherSpacePointVec = { &aPXDSpacePoint, &anotherSVDSpacePoint };
 
    // set up two SpacePointTrackCands from the SpacePoint* vectors above
    Belle2::SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 1);
    Belle2::SpacePointTrackCand anotherSpacePointTC = SpacePointTrackCand(sameSpacePointVec);
 
    // getting undefined reference here!
    EXPECT_TRUE(aSpacePointTC == anotherSpacePointTC);
 
    // change pdg code and compare again (should not have any influence)
    anotherSpacePointTC.setPdgCode(-Const::electron.getPDGCode());
    EXPECT_TRUE(aSpacePointTC == anotherSpacePointTC);
 
    // add a space point with arbitrary sorting parameter and compare again, should now give false
    anotherSpacePointTC.addSpacePoint(&anotherSVDSpacePoint, 1.0);
 
    EXPECT_FALSE(aSpacePointTC == anotherSpacePointTC);
 
    // create another TC with different SVD SpacePoint and compare again with the previously created TCs.
    Belle2::SpacePointTrackCand changedSVDSpacePointTC = SpacePointTrackCand(anotherSpacePointVec, 2, 3, 4);
 
    EXPECT_FALSE(aSpacePointTC == changedSVDSpacePointTC);
    EXPECT_FALSE(changedSVDSpacePointTC == anotherSpacePointTC);
 
    // create an empty TC and add SpacePoints by hand and compare again with the other TCs
    Belle2::SpacePointTrackCand newSpacePointTC;
    newSpacePointTC.addSpacePoint(&aPXDSpacePoint, 1.0);
    newSpacePointTC.addSpacePoint(&aSVDSpacePoint, 1.1);
 
    EXPECT_TRUE(newSpacePointTC == aSpacePointTC);
 
    newSpacePointTC.addSpacePoint(&anotherSVDSpacePoint, 1.2);
 
    EXPECT_TRUE(newSpacePointTC == anotherSpacePointTC);
 
  }

TEST_F() [33/50]

TEST_F	(	SpacePointTrackCandTest	,
		testGetHitsInRange
	)

Test the get hits in range method.

Definition at line 178 of file spacePointTrackCand.cc.

  {
    SpacePointTrackCand fullTrackCand;
 
    // set up some SpacePoints and add them to a SpacePointTrackCand
    VxdID aVxdID1 = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
    fullTrackCand.addSpacePoint(&aPXDSpacePoint, 1.23); // add a SpacePoint with an arbitrary sorting parameter
 
    VxdID aVxdID2 = VxdID(2, 2, 2);
    VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
    SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
    std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
    std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
    const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
    fullTrackCand.addSpacePoint(&SVDSpacePoint1, 2.34);
    fullTrackCand.addSpacePoint(&SVDSpacePoint2, 3.45);
    fullTrackCand.addSpacePoint(&SVDSpacePoint3, 4.56);
 
    VxdID aVxdId3 = VxdID(3, 3, 3);
    VXD::SensorInfoBase sensorInfoBase3 = createSensorInfo(aVxdId3, 2.3, 4.2);
    SVDCluster aUCluster2 = SVDCluster(aVxdId3, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster2 = SVDCluster(aVxdId3, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> UVClusterVec2 = { &aUCluster2, &aVCluster2 };
    std::vector<const SVDCluster*> VClusterVec2 = { &aVCluster2 };
    std::vector<const SVDCluster*> UClusterVec2 = { &aUCluster2 };
    const SpacePoint SVDSpacePoint4 = SpacePoint(UVClusterVec2, &sensorInfoBase3);
    const SpacePoint SVDSpacePoint5 = SpacePoint(VClusterVec2, &sensorInfoBase3);
    const SpacePoint SVDSpacePoint6 = SpacePoint(UClusterVec2, &sensorInfoBase3);
    fullTrackCand.addSpacePoint(&SVDSpacePoint4, 5.67);
    fullTrackCand.addSpacePoint(&SVDSpacePoint5, 6.78);
    fullTrackCand.addSpacePoint(&SVDSpacePoint6, 7.89);
 
    // set up some 'shorter' SpacePointTrackCands
    SpacePointTrackCand shortTC1;
    shortTC1.addSpacePoint(&aPXDSpacePoint, 1.23);
    shortTC1.addSpacePoint(&SVDSpacePoint1, 2.34);
    shortTC1.addSpacePoint(&SVDSpacePoint2, 3.45);
 
    SpacePointTrackCand shortTC2;
    shortTC2.addSpacePoint(&SVDSpacePoint2, 3.45);
    shortTC2.addSpacePoint(&SVDSpacePoint3, 4.56);
    shortTC2.addSpacePoint(&SVDSpacePoint4, 5.67);
    shortTC2.addSpacePoint(&SVDSpacePoint5, 6.78);
 
    SpacePointTrackCand subTrackCand1 = SpacePointTrackCand(fullTrackCand.getHitsInRange(0, 3));
    EXPECT_TRUE(subTrackCand1 == shortTC1);
    std::vector<double> sortParams1 = { 1.23, 2.34, 3.45 };
    std::vector<double> sortParamsTC1 = fullTrackCand.getSortingParametersInRange(0, 3);
    EXPECT_EQ(sortParams1.size(), sortParamsTC1.size());
    for (unsigned int i = 0; i < sortParamsTC1.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams1.at(i), sortParamsTC1.at(i)); }
 
    SpacePointTrackCand subTrackCand2 = SpacePointTrackCand(fullTrackCand.getHitsInRange(2, 6));
    EXPECT_TRUE(subTrackCand2 == shortTC2);
    std::vector<double> sortParams2 = { 3.45, 4.56, 5.67, 6.78 };
    std::vector<double> sortParamsTC2 = fullTrackCand.getSortingParametersInRange(2, 6);
    EXPECT_EQ(sortParams2.size(), sortParamsTC2.size());
    for (unsigned int i = 0; i < sortParamsTC2.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams2.at(i), sortParamsTC2.at(i)); }
 
    // test throwing of exceptions
    unsigned int nHits = fullTrackCand.getNHits();
    ASSERT_THROW(fullTrackCand.getHitsInRange(0, nHits + 1),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
    ASSERT_NO_THROW(fullTrackCand.getHitsInRange(nHits - 2, nHits));
    ASSERT_THROW(fullTrackCand.getHitsInRange(-1, 3),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to negative starting index
    ASSERT_THROW(fullTrackCand.getHitsInRange(0, 10), SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
    ASSERT_THROW(fullTrackCand.getHitsInRange(10, 0),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high starting index
    ASSERT_THROW(fullTrackCand.getHitsInRange(2, -1), SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too low final index
    ASSERT_THROW(fullTrackCand.getSortingParametersInRange(-1, 2),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to negative starting index
    ASSERT_THROW(fullTrackCand.getSortingParametersInRange(0, nHits + 1),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
    ASSERT_THROW(fullTrackCand.getSortingParametersInRange(12, 3),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high starting index
    ASSERT_THROW(fullTrackCand.getSortingParametersInRange(2, -2),
                 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too low final index
    ASSERT_NO_THROW(fullTrackCand.getSortingParametersInRange(0, nHits));
  }

TEST_F() [34/50]

TEST_F	(	SpacePointTrackCandTest	,
		testGetSortedHits
	)

Test setPdgCode method, by comparing its results with the expected values for the according particles.

Definition at line 415 of file spacePointTrackCand.cc.

  {
    // set up some SpacePoints and add them to a SpacePointTrackCand
    VxdID aVxdID1 = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
 
    VxdID aVxdID2 = VxdID(2, 2, 2);
    VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
    SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
    std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
    std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
    const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
 
    VxdID aVxdId3 = VxdID(3, 3, 3);
    VXD::SensorInfoBase sensorInfoBase3 = createSensorInfo(aVxdId3, 2.3, 4.2);
    SVDCluster aUCluster2 = SVDCluster(aVxdId3, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster2 = SVDCluster(aVxdId3, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> UVClusterVec2 = { &aUCluster2, &aVCluster2 };
    std::vector<const SVDCluster*> VClusterVec2 = { &aVCluster2 };
    std::vector<const SVDCluster*> UClusterVec2 = { &aUCluster2 };
    const SpacePoint SVDSpacePoint4 = SpacePoint(UVClusterVec2, &sensorInfoBase3);
    const SpacePoint SVDSpacePoint5 = SpacePoint(VClusterVec2, &sensorInfoBase3);
    const SpacePoint SVDSpacePoint6 = SpacePoint(UClusterVec2, &sensorInfoBase3);
 
 
    SpacePointTrackCand unsortedConstructed;
    // add a SpacePoint with sorting parameter
    unsortedConstructed.addSpacePoint(&aPXDSpacePoint, 1.0);
    // add some SVD SpacePoints in logical order
    unsortedConstructed.addSpacePoint(&SVDSpacePoint1, 2.34);
    unsortedConstructed.addSpacePoint(&SVDSpacePoint2, 3.45);
    unsortedConstructed.addSpacePoint(&SVDSpacePoint3, 4.56);
    // add some SpacePoints in 'wrong' order
    unsortedConstructed.addSpacePoint(&SVDSpacePoint4, 5.67);
    unsortedConstructed.addSpacePoint(&SVDSpacePoint6, 7.89);
    unsortedConstructed.addSpacePoint(&SVDSpacePoint5, 6.78);
 
    // set up a SpacePointTrackCands already properly sorted
    SpacePointTrackCand sortedConstructed;
    sortedConstructed.addSpacePoint(&aPXDSpacePoint, 1.23);
    sortedConstructed.addSpacePoint(&SVDSpacePoint1, 2.34);
    sortedConstructed.addSpacePoint(&SVDSpacePoint2, 3.45);
    sortedConstructed.addSpacePoint(&SVDSpacePoint3, 4.56);
    sortedConstructed.addSpacePoint(&SVDSpacePoint4, 5.67);
    sortedConstructed.addSpacePoint(&SVDSpacePoint5, 6.78);
    sortedConstructed.addSpacePoint(&SVDSpacePoint6, 7.89);
 
    // test sorting
    SpacePointTrackCand sorted = SpacePointTrackCand(unsortedConstructed.getSortedHits());
    // == compares the spacepoints
    EXPECT_TRUE(sorted == sortedConstructed);
 
    SpacePointTrackCand nothingChanged = SpacePointTrackCand(sortedConstructed.getSortedHits());
    EXPECT_TRUE(nothingChanged == sortedConstructed);
 
 
    std::vector<double> sortParams1 = { 1.0, 2.0, 3.0 , 4.0, 5.0, 7.0, 6.0};
    sortedConstructed.setSortingParameters(sortParams1);
 
    // verify that sorting changed according to new sortParams
    SpacePointTrackCand unsorted = SpacePointTrackCand(sortedConstructed.getSortedHits());
    EXPECT_TRUE(unsorted == unsortedConstructed);
  }

TEST_F() [35/50]

TEST_F	(	SpacePointTrackCandTest	,
		testRefereeStatus
	)

Test the setRefereeStatus and getRefereeStatus methods.

Definition at line 268 of file spacePointTrackCand.cc.

  {
    SpacePointTrackCand trackCand; // default constructor -> should initialize the referee status to c_initialState
 
    // currently c_isActive is the initialState:
    EXPECT_EQ(trackCand.getRefereeStatus(), SpacePointTrackCand::c_isActive);
    EXPECT_EQ(SpacePointTrackCand::c_initialState, SpacePointTrackCand::c_isActive);
 
    unsigned short int initialStatus = trackCand.getRefereeStatus();
    EXPECT_EQ(initialStatus, SpacePointTrackCand::c_initialState);
 
    // design an arbitrary status and set it, then test if the returned status is the set status
    unsigned short int newStatus = 0;
    newStatus += SpacePointTrackCand::c_checkedByReferee;
    newStatus += SpacePointTrackCand::c_checkedTrueHits;
    trackCand.setRefereeStatus(newStatus);
    EXPECT_EQ(trackCand.getRefereeStatus(), newStatus);
 
    // clear the status and test if its 0
    trackCand.clearRefereeStatus();
    EXPECT_EQ(trackCand.getRefereeStatus(), 0);
 
    // reset the status and test if it's the initial state
    trackCand.resetRefereeStatus();
    EXPECT_EQ(trackCand.getRefereeStatus(), SpacePointTrackCand::c_initialState);
 
 
    trackCand.clearRefereeStatus(); // enforce empty refereeStatus
    // add several statusses one by one and test if the overall status is as expected (once with 'overall status' and once with status one by one)
    trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedClean);
    EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedClean));
    trackCand.addRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor);
    EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor));
    EXPECT_FALSE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsLowDistance));
 
    trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedByReferee);
    unsigned short int expectedStatus = SpacePointTrackCand::c_checkedClean + SpacePointTrackCand::c_hitsOnSameSensor +
                                        SpacePointTrackCand::c_checkedByReferee;
    EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
 
 
    // remove one status and test if it actuall gets removed
    trackCand.removeRefereeStatus(SpacePointTrackCand::c_checkedClean);
    expectedStatus -= SpacePointTrackCand::c_checkedClean;
    EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
    EXPECT_FALSE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedClean));
    trackCand.removeRefereeStatus(SpacePointTrackCand::c_checkedClean); // remove again and check if nothing changes
    EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
 
    EXPECT_TRUE(trackCand.hasRefereeStatus(expectedStatus));
 
    // test if the status that remains is still set
    EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor));
    EXPECT_TRUE(trackCand.hasHitsOnSameSensor()); // echeck the wrapper function
 
 
    // check if adding of the same status twice works
    trackCand.clearRefereeStatus();
    trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedSameSensors);
    trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedSameSensors);
    EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedSameSensors));
    EXPECT_TRUE(trackCand.checkedSameSensors());
 
    trackCand.addRefereeStatus(SpacePointTrackCand::c_curlingTrack);
    EXPECT_TRUE(trackCand.isCurling());
 
 
    trackCand.clearRefereeStatus();
    // test that at least n bits are present for storing stuff in the m_refereeStatus (update this test if you add a new flag to the RefereeStatusBit)
    // WARNING: hardcoded -> make sure to keep this thing up to date!
    int n = 13;
    int maxUsedStatus = pow(2, n);
    trackCand.addRefereeStatus(maxUsedStatus);
    EXPECT_TRUE(trackCand.hasRefereeStatus(maxUsedStatus));
 
    int maxN = 15; // unsigned short int has 2 bytes (-> 16 bits) to store information
    int maxPossibleStatus = pow(2, maxN); // maximum possible status to store
    trackCand.addRefereeStatus(maxPossibleStatus);
    EXPECT_TRUE(trackCand.hasRefereeStatus(maxPossibleStatus));
 
    int impossibleStatus = maxPossibleStatus * 2; // create an integer that is too big to be stored in a unsigned short integer
    trackCand.clearRefereeStatus();
    trackCand.setRefereeStatus(impossibleStatus); // this should lead to an overflow in SpacePointTrackCand::m_refereeStatus
    EXPECT_NE(trackCand.getRefereeStatus(), impossibleStatus); // -> overflow leads this test to fail
 
    trackCand.clearRefereeStatus();
    int wrongStatus = 7; // set a wrong status, that causes some of the checks to be true although they shouldn't
    trackCand.addRefereeStatus(wrongStatus);
    EXPECT_TRUE(trackCand.hasRefereeStatus(1));
    EXPECT_TRUE(trackCand.hasRefereeStatus(2));
    EXPECT_TRUE(trackCand.hasRefereeStatus(4));
    wrongStatus = 15;
    trackCand.addRefereeStatus(wrongStatus);
    EXPECT_TRUE(trackCand.hasRefereeStatus(8));
  }

TEST_F() [36/50]

TEST_F	(	SpacePointTrackCandTest	,
		testRemoveSpacePoints
	)

Test the removeSpacePoint method.

Definition at line 367 of file spacePointTrackCand.cc.

  {
    // set up SpacePointTrackCand
    SpacePointTrackCand fullTrackCand;
 
    // set up some SpacePoints and add them to a SpacePointTrackCand
    VxdID aVxdID1 = VxdID(1, 1, 1);
    VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
    PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
    const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
    fullTrackCand.addSpacePoint(&aPXDSpacePoint, 1.23); // add a SpacePoint with an arbitrary sorting parameter
 
    VxdID aVxdID2 = VxdID(2, 2, 2);
    VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
    SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
    std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
    std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
    std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
    const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
    const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
    fullTrackCand.addSpacePoint(&SVDSpacePoint1, 2.34);
    fullTrackCand.addSpacePoint(&SVDSpacePoint2, 3.45);
    fullTrackCand.addSpacePoint(&SVDSpacePoint3, 4.56);
 
    // set up a second TC, but ommit one SpacePoint
    SpacePointTrackCand expectedTC;
    expectedTC.addSpacePoint(&aPXDSpacePoint, 1.23);
    expectedTC.addSpacePoint(&SVDSpacePoint2, 3.45);
    expectedTC.addSpacePoint(&SVDSpacePoint3, 4.56);
 
    // remove SpcePoint from first TrackCand amd compare it with the expected TrackCand
    fullTrackCand.removeSpacePoint(1);
    EXPECT_TRUE(expectedTC == fullTrackCand);
 
    std::vector<double> expectedSortParams = { 1.23, 3.45, 4.56 };
    std::vector<double> sortParams = fullTrackCand.getSortingParameters();
    EXPECT_EQ(expectedSortParams.size(), sortParams.size());
    for (unsigned int i = 0; i < sortParams.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams.at(i), expectedSortParams.at(i)); }
 
    // try to remove a SpacePoint that is out of bounds
    ASSERT_THROW(fullTrackCand.removeSpacePoint(fullTrackCand.getNHits()), SpacePointTrackCand::SPTCIndexOutOfBounds);
  }

TEST_F() [37/50]

TEST_F	(	SpacePointTrackCandTest	,
		testSetPdgCode
	)

Test setPdgCode method, by comparing its results with the expected values for the according particles.

Definition at line 159 of file spacePointTrackCand.cc.

  {
    SpacePointTrackCand aSpacePointTC;
 
    // electron
    aSpacePointTC.setPdgCode(Const::electron.getPDGCode());
    EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), -1);
    // positron
    aSpacePointTC.setPdgCode(-Const::electron.getPDGCode());
    EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), 1);
 
    // B+ Meson
    aSpacePointTC.setPdgCode(521);
    EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), 1);
  }

TEST_F() [38/50]

TEST_F	(	ThreeHitFiltersTest	,
		simpleTest
	)

Test simple Setters and Getters.

Definition at line 24 of file threehitfilters.h.

  {
    // testing deltaPt-calculator:
    B2Vector3D innerHit(1., 1., 0.), centerHit(3., 3., 0.), outerHitEvil(6., 3., 0.), outerHitSimple(6., 4., 0.);
 
    ThreeHitFilters aFilter = ThreeHitFilters(outerHitSimple, centerHit, innerHit);
 
//    B2INFO("now comparing values of calcCircleDist2IP using simple outerHit: \n calcPt: " << aFilter.calcCircleDist2IP())
//    aFilter.resetValues(outerHitSimple,centerHit,innerHit);
    EXPECT_FLOAT_EQ(0.44499173338941, aFilter.calcCircleDist2IP());
 
    aFilter.resetValues(outerHitEvil, centerHit, innerHit);
//    B2INFO("now comparing values of calcCircleDist2IP using evil outerHit: \n calcPt: " << aFilter.calcPt())
//    aFilter.resetValues(outerHitEvil,centerHit,innerHit);
    EXPECT_FLOAT_EQ(0.719806016136754, aFilter.calcCircleDist2IP());
 
//    B2INFO("now tests with 0.976T (and reset between each step): \n")
    aFilter.resetMagneticField(0.976);
    aFilter.resetValues(outerHitSimple, centerHit, innerHit);
//    B2INFO("now comparing values of calcCircleDist2IP using simple outerHit: \n calcPt: " << aFilter.calcCircleDist2IP() )
//    aFilter.resetValues(outerHitSimple,centerHit,innerHit);
    EXPECT_FLOAT_EQ(0.44499173338941, aFilter.calcCircleDist2IP());
 
    aFilter.resetValues(outerHitEvil, centerHit, innerHit);
//    B2INFO("now comparing values of calcCircleDist2IP using evil outerHit: \n calcPt: " << aFilter.calcPt() )
//    aFilter.resetValues(outerHitEvil,centerHit,innerHit);
    EXPECT_FLOAT_EQ(0.719806016136754, aFilter.calcCircleDist2IP());
  }

TEST_F() [39/50]

TEST_F	(	ThreeHitFiltersTest	,
		TestAngles
	)

the correctness of the angle calculators

Definition at line 71 of file threehitfilters.h.

  {
    B2Vector3D innerHit(1., 1., 0.), centerHit(3., 3., 0.), outerHit(6., 4., 1.);
    B2Vector3D cent_inner = centerHit - innerHit, outer_center = outerHit - centerHit;
 
//    B2INFO("now tests with 1T \n")
    ThreeHitFilters aFilter = ThreeHitFilters(outerHit, centerHit, innerHit);
 
    EXPECT_DOUBLE_EQ(31.4821541052938556040832384555411729852856, aFilter.fullAngle3D());       //angle in degrees
    EXPECT_DOUBLE_EQ(0.090909090909090909091, aFilter.calcAngle3D());
 
    EXPECT_DOUBLE_EQ(26.5650511770779893515721937204532946712042, aFilter.fullAngleXY());       //angle in degrees
    EXPECT_DOUBLE_EQ(.1, aFilter.calcAngleXY());
 
    EXPECT_FLOAT_EQ(17.54840061379229806435203716652846677620, aFilter.fullAngleRZ());
    EXPECT_FLOAT_EQ(cos(17.54840061379229806435203716652846677620 * M_PI / 180.), aFilter.calcAngleRZ());
 
    EXPECT_DOUBLE_EQ(0.4636476090008061162142562314612144020285, aFilter.fullAngle2D(outer_center, cent_inner));  //angle in radians
    EXPECT_DOUBLE_EQ(0.89442719099991586, aFilter.calcAngle2D(outer_center, cent_inner));
  }

TEST_F() [40/50]

TEST_F	(	ThreeHitFiltersTest	,
		TestCalcPt
	)

test cramer method in calcPt

Definition at line 141 of file threehitfilters.h.

  {
    // calcCircleCenterV2 had problems when x_1==x_2 or y_1==y_2
    B2Vector3D innerHit(1., 2., 0.), centerHit(3., 2., 1.), outerHit(3., 4., 3.);
    B2Vector3D cent_inner = centerHit - innerHit, outer_center = outerHit - centerHit;
    ThreeHitFilters aFilter = ThreeHitFilters();
    B2Vector3D innerHit2(1., 1., 0.), centerHit2(3., 3., 0.), outerHitEvil(6., 3., 0.);
 
    double pt = 0, ptTrue = 0;
 
    aFilter.resetValues(outerHit, centerHit, innerHit);
    ptTrue = aFilter.calcPt(1.414213562373095048801688724209698078570);
    aFilter.resetValues(outerHit, centerHit, innerHit);
    pt = aFilter.calcPt();
    EXPECT_DOUBLE_EQ(ptTrue, pt);
 
    ptTrue = 0.017118925181688543;
    aFilter.resetValues(outerHitEvil, centerHit2, innerHit2);
    pt = aFilter.calcPt();
    EXPECT_DOUBLE_EQ(ptTrue, pt);
 
    aFilter.resetValues(outerHit, outerHit, innerHit);
    //B2WARNING("MUST produce errors: 2 hits are the same: " << ptTrue << ", Pt: " << pt );
    ptTrue = aFilter.calcPt(1.414213562373095048801688724209698078570);
    aFilter.resetValues(outerHit, outerHit, innerHit);
    EXPECT_ANY_THROW(aFilter.calcPt());
  }

TEST_F() [41/50]

TEST_F	(	ThreeHitFiltersTest	,
		TestDeltaSOverZ
	)

test DeltaSOverZ

Definition at line 123 of file threehitfilters.h.

  {
    B2Vector3D innerHit(1., 1., 0.), centerHit(3., 3., 1.), outerHit(6., 4., 3.);
    B2Vector3D cent_inner = centerHit - innerHit, outer_center = outerHit - centerHit;
    ThreeHitFilters aFilter = ThreeHitFilters(outerHit, centerHit, innerHit);
 
    EXPECT_FLOAT_EQ(0.31823963, aFilter.calcDeltaSlopeZOverS());
 
    outerHit.RotateZ(.4);
    centerHit.RotateZ(.4);
    innerHit.RotateZ(.4);
    aFilter.resetValues(outerHit, centerHit, innerHit); //calcDeltaSOverZV2 is invariant under rotations in the r-z plane
 
    EXPECT_FLOAT_EQ(0.31823963, aFilter.calcDeltaSlopeZOverS());
  }

TEST_F() [42/50]

TEST_F	(	ThreeHitFiltersTest	,
		TestMagneticField
	)

the correctness of the magneticField-values (important for pT-related calculations)

Definition at line 55 of file threehitfilters.h.

  {
    B2Vector3D innerHit(1., 1., 0.), centerHit(3., 3., 0.), outerHitEvil(6., 3., 0.), outerHitSimple(6., 4., 0.);
 
    ThreeHitFilters aFilter = ThreeHitFilters(outerHitSimple, centerHit, innerHit);
 
    EXPECT_DOUBLE_EQ(1.5, aFilter.getMagneticField()); // standard case
 
    aFilter.resetMagneticField(1);
    EXPECT_DOUBLE_EQ(1., aFilter.getMagneticField());
 
    EXPECT_DOUBLE_EQ(26.5650511770779893515721937204532946712042, aFilter.fullAngle3D());   //angle in degrees
  }

TEST_F() [43/50]

TEST_F	(	ThreeHitFiltersTest	,
		TestSignAndOtherFilters
	)

test sign, helixFit and calcDeltaSlopeRZ filters

Definition at line 94 of file threehitfilters.h.

  {
    B2Vector3D innerHit(1., 1., 0.), centerHit(3., 3., 0.), outerHit(6., 4., 1.), sigma(.01, .01, .01), unrealsigma(2, 2, 2),
               outerhighHit(4., 6., 1.);
 
    ThreeHitFilters aFilter = ThreeHitFilters(outerHit, centerHit, innerHit);
 
    EXPECT_DOUBLE_EQ(0.30627736916966945608, aFilter.calcDeltaSlopeRZ());
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcHelixFit());
 
    EXPECT_DOUBLE_EQ(1., aFilter.calcSign(outerHit, centerHit, innerHit, sigma, sigma, sigma));
    EXPECT_DOUBLE_EQ(-1., aFilter.calcSign(outerhighHit, centerHit, innerHit, sigma, sigma, sigma));
    EXPECT_DOUBLE_EQ(-1., aFilter.calcSign(innerHit, centerHit, outerHit, sigma, sigma, sigma));
    EXPECT_DOUBLE_EQ(0., aFilter.calcSign(outerHit, centerHit, innerHit, unrealsigma, unrealsigma,
                                          unrealsigma)); //for very large sigma, this track is approximately straight.
 
    EXPECT_LT(0., aFilter.calcSign(outerHit, centerHit, innerHit));
    EXPECT_GT(0., aFilter.calcSign(outerhighHit, centerHit, innerHit));
    EXPECT_GT(0., aFilter.calcSign(innerHit, centerHit, outerHit));
    EXPECT_LT(0., aFilter.calcSign(outerHit, centerHit, innerHit));
 
    EXPECT_DOUBLE_EQ(1., aFilter.calcSign(outerHit, centerHit, innerHit));
    EXPECT_DOUBLE_EQ(-1., aFilter.calcSign(outerhighHit, centerHit, innerHit));
    EXPECT_DOUBLE_EQ(-1., aFilter.calcSign(innerHit, centerHit, outerHit));
  }

TEST_F() [44/50]

TEST_F	(	TwoHitFiltersTest	,
		TestEmptyFilter
	)

Test simple Setters and Getters by filling zeroes.

Definition at line 23 of file twohitfilters.h.

  {
    TwoHitFilters aFilter = TwoHitFilters();
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcDist3D());
 
    EXPECT_DOUBLE_EQ(0., aFilter.fullDist3D());
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcDistXY());
 
    EXPECT_DOUBLE_EQ(0., aFilter.fullDistXY());
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcDistZ());
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcSlopeRZ());
 
    EXPECT_DOUBLE_EQ(0., aFilter.calcNormedDist3D());
 
    EXPECT_DOUBLE_EQ(42., aFilter.filterNan(42.));
 
    EXPECT_DOUBLE_EQ(42, aFilter.filterNan(42));
 
    EXPECT_DOUBLE_EQ(42., aFilter.filterNan(42));
 
    EXPECT_DOUBLE_EQ(0., aFilter.filterNan(1. / 0.));
 
  }

TEST_F() [45/50]

TEST_F	(	TwoHitFiltersTest	,
		TestFilledFilter
	)

Test simple Setters and Getters by filling non-zero-values.

Definition at line 52 of file twohitfilters.h.

  {
    B2Vector3D innerHit(1, 2, 3);
    B2Vector3D outerHit(2, 3, 4);
 
    TwoHitFilters aFilter = TwoHitFilters(outerHit, innerHit); // correct order
 
    EXPECT_DOUBLE_EQ(3., aFilter.calcDist3D()); // does calc dist (outer - innerHit)^2!
 
    EXPECT_DOUBLE_EQ(sqrt(3.), aFilter.fullDist3D()); // does calc dist (outer - innerHit)
 
    EXPECT_DOUBLE_EQ(2., aFilter.calcDistXY()); // does calc dist (outer - innerHit)^2!
 
    EXPECT_DOUBLE_EQ(sqrt(2.), aFilter.fullDistXY()); // does calc dist (outer - innerHit)calcDistXY
 
    EXPECT_DOUBLE_EQ(1., aFilter.calcDistZ());
 
    EXPECT_DOUBLE_EQ(atan(sqrt(2.)),
                     aFilter.calcSlopeRZ()); // normal slope is fullDistXY/calcDistZ = sqrt(2), here atan of slope is calculated
 
    EXPECT_DOUBLE_EQ(2. / 3., aFilter.calcNormedDist3D());
 
 
    TwoHitFilters bFilter =
      TwoHitFilters(); // initialising an empty filter first to check whether the resetting function is doing its job...
 
    bFilter.resetValues(innerHit, outerHit); // wrong order
 
    EXPECT_DOUBLE_EQ(aFilter.calcDist3D(), bFilter.calcDist3D()); // does calc dist (outer - innerHit)^2!
 
    EXPECT_DOUBLE_EQ(aFilter.fullDist3D(), bFilter.fullDist3D()); // does calc dist (outer - innerHit)
 
    EXPECT_DOUBLE_EQ(aFilter.calcDistXY(), bFilter.calcDistXY()); // does calc dist (outer - innerHit)^2!
 
    EXPECT_DOUBLE_EQ(aFilter.fullDistXY(), bFilter.fullDistXY()); // does calc dist (outer - innerHit)
 
    EXPECT_DOUBLE_EQ(-aFilter.calcDistZ(), bFilter.calcDistZ());
 
    EXPECT_DOUBLE_EQ(-aFilter.calcSlopeRZ(), bFilter.calcSlopeRZ());
 
    EXPECT_DOUBLE_EQ(aFilter.calcNormedDist3D(), bFilter.calcNormedDist3D());
  }

TEST_F() [46/50]

TEST_F	(	TwoHitFiltersTest	,
		testLargeFilter
	)

Test simple Setters and Getters by filling extreme values.

Definition at line 98 of file twohitfilters.h.

  {
    B2Vector3D innerHit(1e150, 0, 0);
    B2Vector3D outerHit(0, 0, 0);
    B2Vector3D innerHit2(1, 2, 3);
    B2Vector3D outerHit2(2, 3, 4);
 
    TwoHitFilters aFilter = TwoHitFilters(outerHit, innerHit); // correct order
 
    EXPECT_DOUBLE_EQ(1e300, aFilter.calcDist3D()); // does calc dist (outer - innerHit)^2!
 
    aFilter.resetValues(innerHit2, outerHit2);
 
    // does currently give an error at the clang-build:
    // EXPECT_DOUBLE_EQ(-atan(sqrt(2.)), aFilter.calcSlopeRZ());
  }

TEST_F() [47/50]

TEST_F	(	TwoHitFiltersTest	,
		TestOutOfRangeNormedDistFilter
	)

And now possibly the only case where TwoHitFilters produces wrong results.

However, (1e300, 0, 1e300) will never happen.

Definition at line 132 of file twohitfilters.h.

  {
    B2Vector3D innerHit(1e300, 0, 1e300);
    B2Vector3D outerHit(0, 0, 0);
    double correctResult = 1. / 2.; // this should be the result which is analytically correct
    double wrongResult = 0.; // this is the result because of out of range of double precision
 
    TwoHitFilters aFilter = TwoHitFilters(outerHit, innerHit); // correct order
 
    // however, the values exceed the range of double, therefore the result is NOT EQUAL to the correct value:
    EXPECT_NE(correctResult, aFilter.calcNormedDist3D());
    EXPECT_DOUBLE_EQ(wrongResult, aFilter.calcNormedDist3D());
  }

TEST_F() [48/50]

TEST_F	(	V0FitterTest	,
		GetTrackHypotheses
	)

Test getter for track hypotheses.

Definition at line 34 of file v0fitter.cc.

  {
    genfit::MaterialEffects::getInstance()->init(new genfit::TGeoMaterialInterface());
    genfit::FieldManager::getInstance()->init(new genfit::ConstField(0., 0., 1.5));
    V0Fitter v0Fitter;
    const auto kShortTracks = v0Fitter.getTrackHypotheses(Const::Kshort);
    const auto photonTracks = v0Fitter.getTrackHypotheses(Const::photon);
    const auto lambdaTracks = v0Fitter.getTrackHypotheses(Const::Lambda);
    const auto antiLambdaTracks = v0Fitter.getTrackHypotheses(Const::antiLambda);
 
    EXPECT_EQ(Const::pion, kShortTracks.first);
    EXPECT_EQ(Const::pion, kShortTracks.second);
 
    EXPECT_EQ(Const::electron, photonTracks.first);
    EXPECT_EQ(Const::electron, photonTracks.second);
 
    EXPECT_EQ(Const::proton, lambdaTracks.first);
    EXPECT_EQ(Const::pion, lambdaTracks.second);
 
    EXPECT_EQ(Const::pion, antiLambdaTracks.first);
    EXPECT_EQ(Const::proton, antiLambdaTracks.second);
  }

TEST_F() [49/50]

TEST_F	(	V0FitterTest	,
		InitializeCuts
	)

Test initialization of cuts.

Definition at line 58 of file v0fitter.cc.

  {
    genfit::MaterialEffects::getInstance()->init(new genfit::TGeoMaterialInterface());
    genfit::FieldManager::getInstance()->init(new genfit::ConstField(0., 0., 1.5));
    V0Fitter v0Fitter;
    v0Fitter.initializeCuts(1.0, 10000., {0.425, 0.575}, {1.09, 1.14}, {0, 0.1});
    EXPECT_EQ(1.0, v0Fitter.m_beamPipeRadius);
    EXPECT_EQ(10000., v0Fitter.m_vertexChi2CutOutside);
    EXPECT_EQ(std::make_tuple(0.425, 0.575), v0Fitter.m_invMassRangeKshort);
    EXPECT_EQ(std::make_tuple(1.09, 1.14),   v0Fitter.m_invMassRangeLambda);
    EXPECT_EQ(std::make_tuple(0, 0.1),       v0Fitter.m_invMassRangePhoton);
  }

TEST_F() [50/50]

TEST_F	(	VariablesOnTTree	,
		basic_test
	)

Basic test of the class.

Definition at line 61 of file variablesOnTTree.cc.

  {
    auto filter1 = 0 < Difference() < 1 && 0 < Sum() < 1;
    auto variables1 = VariablesTTree<>::build(filter1, tree1);
 
    auto filter2 = 0 < Difference() < 1 && 0 < Sum() < 1;
    auto variables2 = VariablesTTree<>::build(filter2, tree2);
 
    double a(0.), b(1.0);
    variables1.evaluateOn(a, b);
    tree1->Fill();
 
    double c(1.), d(0.0);
    variables2.evaluateOn(c, d);
    tree2->Fill();
 
    tree1->Scan();
    tree2->Scan();
  }

toB2Vector3()

B2Vector3D toB2Vector3 ( Eigen::VectorXd  vIn )

inline

Function that converts Eigen vector to ROOT vector.

Definition at line 54 of file calibTools.h.

  {
    return B2Vector3D(vIn(0), vIn(1), vIn(2));
  }

toTMatrixDSym()

TMatrixDSym toTMatrixDSym ( Eigen::MatrixXd  mIn )

inline

Function that converts Eigen symmetric matrix to ROOT matrix.

Definition at line 44 of file calibTools.h.

  {
    TMatrixDSym mOut(mIn.rows());
    for (int i = 0; i < mIn.rows(); ++i)
      for (int j = 0; j < mIn.cols(); ++j)
        mOut(i, j) = (mIn(i, j) + mIn(j, i)) / 2.;
    return mOut;
  }

traverseTree()

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

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

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

vec2vec() [1/2]

std::vector< double > vec2vec ( Eigen::VectorXd  v )

inline

ROOT vector -> std vector.

Definition at line 61 of file tools.h.

  {
    std::vector<double> vNew(v.rows());
    for (int i = 0; i < v.rows(); ++i)
      vNew[i] = v(i);
    return vNew;
  }

vec2vec() [2/2]

Eigen::VectorXd vec2vec ( std::vector< double >  vec )

inline

std vector -> ROOT vector

Definition at line 51 of file tools.h.

  {
    Eigen::VectorXd v(vec.size());
    for (unsigned i = 0; i < vec.size(); ++i) {
      v[i] = vec[i];
    }
    return v;
  }

vecs2mat()

Eigen::MatrixXd vecs2mat ( std::vector< std::vector< double > >  vecs )

inline

merge columns (from std::vectors) into ROOT matrix

Definition at line 72 of file tools.h.

  {
    Eigen::MatrixXd m(vecs[0].size(), vecs.size());
    for (unsigned i = 0; i < vecs[0].size(); ++i)
      for (unsigned j = 0; j < vecs.size(); ++j) {
        m(i, j) = vecs[j][i];
      }
    return m;
  }

wasSuccessful()

bool wasSuccessful

Returns true if the last run t0 extraction was successful.

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

  {
    return m_wasSuccessful;
  }

writeSamplesToStream()

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

cdcfromEclPathTruthVarNames

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

cdcfromEclStateTruthVarNames

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

cdcPathBasicVarNames

constexpr char const* const cdcPathBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 25 of file CDCPathBasicVarSet.h.

cdcPathTruthVarNames

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

cdcStateBasicVarNames

constexpr char const* const cdcStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 25 of file CDCStateBasicVarSet.h.

cdcStateTruthVarNames

constexpr char const* const cdcStateTruthVarNames[]

staticconstexpr

Initial value:

= {
    "match",
    "PDG"
  }

Names of the variables to be generated.

Definition at line 22 of file CDCStateTruthVarSet.h.

m_storeRefTCDataForTestTC

bool m_storeRefTCDataForTestTC = false

staticprotected

if true, for testTC the values of attached refTC will be stored instead of own values.

setting the static storeRefTCDataForTestTC to a standard value

• why are there values of the mcTC stored? we want to know the real data, not the guesses of the reconstructed data. Deviations of reference values to guesses of the reconstructed data will be stored in resiudals anyway.

Definition at line 64 of file AnalyzingAlgorithmBase.h.

pxdResultTruthNames

constexpr 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 27 of file PXDResultTruthVarSet.h.

pxdResultVarNames

constexpr 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 24 of file PXDResultVarSet.h.

pxdStateBasicVarNames

constexpr char const* const pxdStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 23 of file PXDStateBasicVarSet.h.

pxdStateTruthVarNames

constexpr 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 26 of file PXDStateTruthVarSet.h.

relationSVDResultVarNames

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

s_MagneticFieldFactor

DataType s_MagneticFieldFactor

static

Initial value:

= 1.5 *
      0.00299710

is factor containing speed of light (c), the magnetic field (b) and the scaling factor s for conversion of meter in cm : c*b/100 = c*b*s.

The standard value assumes a magnetic field of 1.5 Tesla. Value can be changed using the resetMagneticField-Function, where a new value for the magnetic field in Tesla has to be passed. TODO WARNING hardcoded value!

Definition at line 29 of file SelectionVariableHelper.h.

s_origin

VectorType s_origin = VectorType(0, 0, 0)

staticprotected

stores the origin used for some calculations, can be set here

setting the static origin to a standard value

Definition at line 55 of file AnalyzingAlgorithmBase.h.

svdResultTruthNames

constexpr 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 27 of file SVDResultTruthVarSet.h.

svdResultVarNames

constexpr 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 24 of file SVDResultVarSet.h.

svdStateBasicVarNames

constexpr char const* const svdStateBasicVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 23 of file SVDStateBasicVarSet.h.

svdStateTruthVarNames

constexpr 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 26 of file SVDStateTruthVarSet.h.

svdStateVarNames

constexpr char const* const svdStateVarNames[]

staticconstexpr

Names of the variables to be generated.

Definition at line 27 of file SVDStateVarSet.h.