mkfit Namespace Reference

Namespaces
	Config
	Const
	mini_propagators
	StdSeq

Classes
struct	axis
struct	axis_base
struct	axis_pow2
struct	axis_pow2_base
struct	axis_pow2_u1
struct	BeamSpot
struct	binnor
class	CandCloner
class	CcAlloc
class	CcPool
class	CombCandidate
class	ConfigJson
class	ConfigJsonPatcher
struct	DataFile
struct	DataFileHeader
struct	DeadRegion
class	Event
class	EventOfCombCandidates
class	EventOfHits
struct	ExecutionContext
class	FindingFoos
struct	FitVal
class	Hit
struct	HitMatch
struct	HitMatchPair
struct	HitOnTrack
struct	HoTNode
struct	IdxChi2List
class	IterationConfig
class	IterationLayerConfig
struct	IterationMaskIfc
struct	IterationMaskIfcBase
struct	IterationMaskIfcCmssw
class	IterationParams
class	IterationSeedPartition
class	IterationsInfo
struct	LayerControl
class	LayerInfo
class	LayerNumberConverter
class	LayerOfHits
class	MatriplexErrParPackerSlurpIn
class	MatriplexPackerSlurpIn
class	MatriplexTrackPackerPlexify
struct	MCHitInfo
struct	MeasurementState
class	MkBase
class	MkBuilder
class	MkBuilderWrapper
class	MkFinder
class	MkFitter
class	MkJob
struct	ModuleInfo
class	Pool
class	PropagationConfig
class	PropagationFlags
class	radix_sort
class	rectvec
struct	ReducedTrack
class	Shell
struct	sortTracksByPhiStruct
class	SteeringParams
class	Track
class	TrackBase
class	TrackCand
class	TrackerInfo
class	TrackExtra
struct	TrackState
class	TTreeValidation
struct	UpdateIndices
class	Validation
struct	WSR_Result

Typedefs
using	clean_duplicates_cf = void(TrackVec &, const IterationConfig &)
using	clean_duplicates_func = std::function< clean_duplicates_cf >
using	clean_seeds_cf = int(TrackVec &, const IterationConfig &, const BeamSpot &)
using	clean_seeds_func = std::function< clean_seeds_cf >
typedef std::map< std::string, std::pair< cleanOpts, std::string > >	cleanOptsMap
typedef std::vector< DeadRegion >	DeadVec
typedef std::vector< Event >	EventVec
using	filter_candidates_cf = bool(const TrackCand &, const MkJob &)
using	filter_candidates_func = std::function< filter_candidates_cf >
typedef std::map< int, FitVal >	FitValLayMap
typedef std::vector< std::pair< int, float > >	FltLayerPairVec
typedef std::vector< int >	HitIdxVec
typedef std::map< int, std::vector< int > >	HitLayerMap
using	HitVec = std::vector< Hit >
typedef std::vector< HitOnTrack >	HoTVec
typedef std::pair< int, float >	idchi2Pair
typedef std::vector< idchi2Pair >	idchi2PairVec
typedef std::map< int, std::map< int, std::vector< int > > >	LayIdxIDVecMapMap
typedef std::map< std::string, std::pair< matchOpts, std::string > >	matchOptsMap
using	MatriplexHitPacker = MatriplexErrParPackerSlurpIn< Hit, float >
using	MatriplexHoTPacker = MatriplexPackerSlurpIn< HitOnTrack >
using	MatriplexTrackPacker = MatriplexErrParPackerSlurpIn< TrackBase, float >
typedef std::vector< MCHitInfo >	MCHitInfoVec
typedef Matriplex::Matriplex< float, 2, 2, NN >	MPlex22
typedef Matriplex::Matriplex< float, 2, HH, NN >	MPlex2H
typedef Matriplex::MatriplexSym< float, 2, NN >	MPlex2S
typedef Matriplex::Matriplex< float, 2, 1, NN >	MPlex2V
typedef Matriplex::Matriplex< float, 5, 5, NN >	MPlex55
typedef Matriplex::Matriplex< float, 5, 6, NN >	MPlex56
typedef Matriplex::Matriplex< float, 6, 5, NN >	MPlex65
typedef Matriplex::Matriplex< float, HH, 2, NN >	MPlexH2
typedef Matriplex::Matriplex< float, HH, HH, NN >	MPlexHH
using	MPlexHitIdx = Matriplex::Matriplex< int, MPlexHitIdxMax, 1, NN >
typedef Matriplex::Matriplex< float, HH, LL, NN >	MPlexHL
typedef Matriplex::MatriplexSym< float, HH, NN >	MPlexHS
typedef Matriplex::Matriplex< float, HH, 1, NN >	MPlexHV
typedef Matriplex::Matriplex< float, LL, 2, NN >	MPlexL2
typedef Matriplex::Matriplex< float, LL, HH, NN >	MPlexLH
typedef Matriplex::Matriplex< float, LL, LL, NN >	MPlexLL
typedef Matriplex::MatriplexSym< float, LL, NN >	MPlexLS
typedef Matriplex::Matriplex< float, LL, 1, NN >	MPlexLV
typedef Matriplex::Matriplex< bool, 1, 1, NN >	MPlexQB
typedef Matriplex::Matriplex< float, 1, 1, NN >	MPlexQF
typedef Matriplex::Matriplex< short, 1, 1, NN >	MPlexQH
using	MPlexQHoT = Matriplex::Matriplex< HitOnTrack, 1, 1, NN >
typedef Matriplex::Matriplex< int, 1, 1, NN >	MPlexQI
typedef Matriplex::Matriplex< unsigned short, 1, 1, NN >	MPlexQUH
typedef Matriplex::Matriplex< unsigned int, 1, 1, NN >	MPlexQUI
typedef std::array< int, 2 >	PairIdx
typedef std::vector< PairIdx >	PairIdxVec
using	partition_seeds_cf = void(const TrackerInfo &, const TrackVec &, const EventOfHits &, IterationSeedPartition &)
using	partition_seeds_func = std::function< partition_seeds_cf >
typedef std::vector< ReducedTrack >	RedTrackVec
typedef std::map< std::string, std::pair< seedOpts, std::string > >	seedOptsMap
typedef std::pair< int, int >	SimTkIDInfo
typedef ROOT::Math::SMatrix< float, 2 >	SMatrix22
typedef ROOT::Math::SMatrix< float, 2, 6 >	SMatrix26
typedef ROOT::Math::SMatrix< float, 3 >	SMatrix33
typedef ROOT::Math::SMatrix< float, 3, 6 >	SMatrix36
typedef ROOT::Math::SMatrix< float, 6, 2 >	SMatrix62
typedef ROOT::Math::SMatrix< float, 6, 3 >	SMatrix63
typedef ROOT::Math::SMatrix< float, 6 >	SMatrix66
typedef ROOT::Math::SMatrix< float, 2, 2, ROOT::Math::MatRepSym< float, 2 > >	SMatrixSym22
typedef ROOT::Math::SMatrix< float, 3, 3, ROOT::Math::MatRepSym< float, 3 > >	SMatrixSym33
typedef ROOT::Math::SMatrix< float, 6, 6, ROOT::Math::MatRepSym< float, 6 > >	SMatrixSym66
typedef ROOT::Math::SVector< float, 2 >	SVector2
typedef ROOT::Math::SVector< float, 3 >	SVector3
typedef ROOT::Math::SVector< float, 6 >	SVector6
typedef std::unordered_map< int, FitValLayMap >	TkIDtoFitValLayMapMap
typedef std::unordered_map< int, int >	TkIDToTkIDMap
typedef std::unordered_map< int, std::vector< int > >	TkIDToTkIDVecMap
typedef std::unordered_map< int, TSLayerPairVec >	TkIDToTSLayerPairVecMap
typedef std::unordered_map< int, TrackState >	TkIDToTSMap
typedef std::vector< TSVec >	TkIDToTSVecVec
using	track_score_cf = float(const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates)
using	track_score_func = std::function< track_score_cf >
typedef std::vector< TrackExtra >	TrackExtraVec
using	TrackVec = std::vector< Track >
typedef std::vector< TrackVec >	TrackVecVec
typedef std::array< int, 3 >	TripletIdx
typedef std::vector< TripletIdx >	TripletIdxVec
typedef std::map< int, std::unordered_set< int > >	TrkIDLaySetMap
typedef std::vector< std::pair< int, TrackState > >	TSLayerPairVec
typedef std::vector< TrackState >	TSVec

Enumerations
enum	cleanOpts { noCleaning, cleanSeedsN2, cleanSeedsPure, cleanSeedsBadLabel }
enum	KalmanFilterOperation { KFO_Calculate_Chi2 = 1, KFO_Update_Params = 2, KFO_Local_Cov = 4 }
enum	matchOpts { trkParamBased, hitBased, labelBased }
enum	PropagationFlagsEnum { PF_none = 0, PF_use_param_b_field = 0x1, PF_apply_material = 0x2, PF_copy_input_state_on_fail = 0x4 }
enum	seedOpts { simSeeds, cmsswSeeds, findSeeds }
enum	TkLayout { TkLayout::phase0 = 0, TkLayout::phase1 = 1, TkLayout::phase2 = 2 }
enum	WithinSensitiveRegion_e {   WSR_Undef = -1, WSR_Inside = 0, WSR_Edge, WSR_Outside,   WSR_Failed }

Functions
void	applyMaterialEffects (const MPlexQF &hitsRl, const MPlexQF &hitsXi, const MPlexQF &propSign, const MPlexHV &plNrm, MPlexLS &outErr, MPlexLV &outPar, const int N_proc)
int	calculateCharge (const Hit &hit0, const Hit &hit1, const Hit &hit2)
int	calculateCharge (const float hit0_x, const float hit0_y, const float hit1_x, const float hit1_y, const float hit2_x, const float hit2_y)
float	cdist (float a)
void	CFMap (const MPlexHH &A, const MPlexHV &B, MPlexHV &C)
template<typename Vector , typename Matrix >
float	computeHelixChi2 (const Vector &simV, const Vector &recoV, const Matrix &recoM, const bool diagOnly=false)
void	conformalFitMPlex (bool fitting, MPlexQI seedID, MPlexLS &outErr, MPlexLV &outPar, const MPlexHV &msPar0, const MPlexHV &msPar1, const MPlexHV &msPar2)
template<typename Traits , typename HitCollection >
edm::ProductID	convertHits (const Traits &traits, const HitCollection &hits, mkfit::HitVec &mkFitHits, std::vector< TrackingRecHit const *> &clusterIndexToHit, std::vector< float > &clusterChargeVec, const TrackerTopology &ttopo, const TransientTrackingRecHitBuilder &ttrhBuilder, const MkFitGeometry &mkFitGeom)
template<typename T >
T	cube (T x)
template<typename Matrix >
void	diagonalOnly (Matrix &m)
double	dtime ()
template<typename Matrix >
void	dumpMatrix (Matrix m)
void	execTrackerInfoCreatorPlugin (const std::string &base, TrackerInfo &ti, IterationsInfo &ii, bool verbose)
void	findSeedsByRoadSearch (TripletIdxConVec &seed_idcs, std::vector< LayerOfHits > &evt_lay_hits, int lay1_size, Event *&ev)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::LayerControl &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::LayerControl &nlohmann_json_t)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::SteeringParams &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::SteeringParams &nlohmann_json_t)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::IterationLayerConfig &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::IterationLayerConfig &nlohmann_json_t)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::IterationParams &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::IterationParams &nlohmann_json_t)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::IterationConfig &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::IterationConfig &nlohmann_json_t)
void	from_json (const nlohmann::json &nlohmann_json_j, mkfit::IterationsInfo &nlohmann_json_t)
void	from_json (const nlohmann::ordered_json &nlohmann_json_j, mkfit::IterationsInfo &nlohmann_json_t)
float	getEta (float r, float z)
float	getEta (float theta)
float	getEta (float x, float y, float z)
float	getEtaErr2 (float x, float y, float z, float exx, float eyy, float ezz, float exy, float exz, float eyz)
float	getHypot (float x, float y)
float	getInvRad2 (float x, float y)
float	getInvRadErr2 (float x, float y, float exx, float eyy, float exy)
int	getMatchBin (const float pt)
float	getPhi (float x, float y)
float	getPhiErr2 (float x, float y, float exx, float eyy, float exy)
float	getPxPxErr2 (float ipt, float phi, float vipt, float vphi)
float	getPyPyErr2 (float ipt, float phi, float vipt, float vphi)
float	getPzPzErr2 (float ipt, float theta, float vipt, float vtheta)
float	getRad2 (float x, float y)
float	getRadErr2 (float x, float y, float exx, float eyy, float exy)
float	getScoreCand (const track_score_func &score_func, const TrackCand &cand1, bool penalizeTailMissHits=false, bool inFindCandidates=false)
float	getScoreCand (const track_score_func &score_func, const Track &cand1, bool penalizeTailMissHits=false, bool inFindCandidates=false)
float	getScoreStruct (const track_score_func &score_func, const IdxChi2List &cand1)
float	getScoreWorstPossible ()
float	getTheta (float r, float z)
float	getThetaErr2 (float x, float y, float z, float exx, float eyy, float ezz, float exy, float exz, float eyz)
void	helixAtPlane (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexHV &plPnt, const MPlexHV &plNrm, MPlexQF &pathL, MPlexLV &outPar, MPlexLL &errorProp, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags)
void	helixAtRFromIterativeCCS (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLV &outPar, MPlexLL &errorProp, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags)
void	helixAtRFromIterativeCCSFullJac (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLV &outPar, MPlexLL &errorProp, MPlexQI &outFailFlag, const int N_proc)
void	helixAtRFromIterativeCCSFullJac (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLV &outPar, MPlexLL &errorProp, const int N_proc)
void	helixAtZ (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLV &outPar, MPlexLL &errorProp, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags)
float	hipo (float x, float y)
float	hipo_sqr (float x, float y)
void	intersectThirdLayer (const float a, const float b, const float hit1_x, const float hit1_y, float &lay2_x, float &lay2_y)
constexpr bool	isFinite (float x)
bool	isStripQCompatible (int itrack, bool isBarrel, const MPlexLS &pErr, const MPlexLV &pPar, const MPlexHS &msErr, const MPlexHV &msPar)
void	kalmanComputeChi2 (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexQF &outChi2, const int N_proc)
void	kalmanComputeChi2Endcap (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexQF &outChi2, const int N_proc)
void	kalmanComputeChi2Plane (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, const MPlexHV &plNrm, const MPlexHV &plDir, MPlexQF &outChi2, const int N_proc)
void	kalmanOperation (const int kfOp, const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, MPlexQF &outChi2, const int N_proc)
void	kalmanOperationEndcap (const int kfOp, const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, MPlexQF &outChi2, const int N_proc)
void	kalmanOperationPlane (const int kfOp, const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, const MPlexHV &plNrm, const MPlexHV &plDir, MPlexLS &outErr, MPlexLV &outPar, MPlexQF &outChi2, const int N_proc)
void	kalmanPropagateAndComputeChi2 (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexQF &outChi2, MPlexLV &propPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanPropagateAndComputeChi2Endcap (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexQF &outChi2, MPlexLV &propPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanPropagateAndComputeChi2Plane (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, const MPlexHV &plNrm, const MPlexHV &plDir, MPlexQF &outChi2, MPlexLV &propPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanPropagateAndUpdate (const MPlexLS &psErr, const MPlexLV &psPar, MPlexQI &Chg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanPropagateAndUpdateEndcap (const MPlexLS &psErr, const MPlexLV &psPar, MPlexQI &Chg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanPropagateAndUpdatePlane (const MPlexLS &psErr, const MPlexLV &psPar, MPlexQI &Chg, const MPlexHS &msErr, const MPlexHV &msPar, const MPlexHV &plNrm, const MPlexHV &plDir, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &propFlags, const bool propToHit)
void	kalmanUpdate (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, const int N_proc)
void	kalmanUpdateEndcap (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, const int N_proc)
void	kalmanUpdatePlane (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, const MPlexHV &plNrm, const MPlexHV &plDir, MPlexLS &outErr, MPlexLV &outPar, const int N_proc)
template<class T , class U >
bool	operator== (const CcAlloc< T > &a, const CcAlloc< U > &b)
bool	passStripChargePCMfromTrack (int itrack, bool isBarrel, unsigned int pcm, unsigned int pcmMin, const MPlexLV &pPar, const MPlexHS &msErr)
void	print (std::string_view label, const MeasurementState &s)
void	print (const TrackState &s)
void	print (std::string pfx, int itrack, const Track &trk, bool print_hits=false)
void	print (std::string pfx, const TrackState &s)
void	print (std::string pfx, int itrack, const Track &trk, const Event &ev)
void	propagateHelixToPlaneMPlex (const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexHV &plPnt, const MPlexHV &plNrm, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags, const MPlexQI *noMatEffPtr)
void	propagateHelixToRMPlex (const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags, const MPlexQI *noMatEffPtr)
void	propagateHelixToZMPlex (const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLS &outErr, MPlexLV &outPar, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags &pflags, const MPlexQI *noMatEffPtr)
void	propagateLineToRMPlex (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexHS &msErr, const MPlexHV &msPar, MPlexLS &outErr, MPlexLV &outPar, const int N_proc)
void	run_OneIteration (const TrackerInfo &trackerInfo, const IterationConfig &itconf, const EventOfHits &eoh, const std::vector< const std::vector< bool > *> &hit_masks, MkBuilder &builder, TrackVec &seeds, TrackVec &out_tracks, bool do_seed_clean, bool do_backward_fit, bool do_remove_duplicates)
std::vector< double >	runBtpCe_MultiIter (Event &ev, const EventOfHits &eoh, MkBuilder &builder, int n)
double	runBuildingTestPlexBestHit (Event &ev, const EventOfHits &eoh, MkBuilder &builder)
double	runBuildingTestPlexCloneEngine (Event &ev, const EventOfHits &eoh, MkBuilder &builder)
void	runBuildingTestPlexDumbCMSSW (Event &ev, const EventOfHits &eoh, MkBuilder &builder)
double	runBuildingTestPlexStandard (Event &ev, const EventOfHits &eoh, MkBuilder &builder)
double	runFittingTestPlex (Event &ev, std::vector< Track > &rectracks)
void	sincos4 (const float x, float &sin, float &cos)
bool	sortByEta (const Hit &hit1, const Hit &hit2)
bool	sortByHitsChi2 (const std::pair< Track, TrackState > &cand1, const std::pair< Track, TrackState > &cand2)
bool	sortByHitsChi2 (const Track &cand1, const Track &cand2)
bool	sortByPhi (const Hit &hit1, const Hit &hit2)
bool	sortByScoreCand (const Track &cand1, const Track &cand2)
bool	sortByScoreStruct (const IdxChi2List &cand1, const IdxChi2List &cand2)
bool	sortByScoreTrackCand (const TrackCand &cand1, const TrackCand &cand2)
bool	sortByZ (const Hit &hit1, const Hit &hit2)
bool	sortIDsByChi2 (const idchi2Pair &cand1, const idchi2Pair &cand2)
bool	sortTracksByEta (const Track &track1, const Track &track2)
bool	sortTracksByPhi (const Track &track1, const Track &track2)
template<typename T >
T	sqr (T x)
float	squashPhiGeneral (float phi)
template<typename Vector >
void	squashPhiGeneral (Vector &v)
float	squashPhiMinimal (float phi)
void	squashPhiMPlex (MPlexLV &par, const int N_proc)
void	squashPhiMPlexGeneral (MPlexLV &par, const int N_proc)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::LayerControl &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::LayerControl &nlohmann_json_t)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::SteeringParams &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::SteeringParams &nlohmann_json_t)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::IterationLayerConfig &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::IterationLayerConfig &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::IterationParams &nlohmann_json_t)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::IterationParams &nlohmann_json_t)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::IterationConfig &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::IterationConfig &nlohmann_json_t)
void	to_json (nlohmann::ordered_json &nlohmann_json_j, const mkfit::IterationsInfo &nlohmann_json_t)
void	to_json (nlohmann::json &nlohmann_json_j, const mkfit::IterationsInfo &nlohmann_json_t)

Variables
bool	g_debug = true
ExecutionContext	g_exe_ctx
constexpr Matriplex::idx_t	HH = 3
constexpr Matriplex::idx_t	LL = 6
static constexpr int	MPlexHitIdxMax = 16
constexpr Matriplex::idx_t	NN = 8

Typedef Documentation

clean_duplicates_cf

using mkfit::clean_duplicates_cf = typedef void(TrackVec &, const IterationConfig &)

Definition at line 30 of file FunctionTypes.h.

clean_duplicates_func

using mkfit::clean_duplicates_func = typedef std::function<clean_duplicates_cf>

Definition at line 31 of file FunctionTypes.h.

clean_seeds_cf

using mkfit::clean_seeds_cf = typedef int(TrackVec &, const IterationConfig &, const BeamSpot &)

Definition at line 21 of file FunctionTypes.h.

clean_seeds_func

using mkfit::clean_seeds_func = typedef std::function<clean_seeds_cf>

Definition at line 22 of file FunctionTypes.h.

cleanOptsMap

typedef std::map<std::string, std::pair<cleanOpts, std::string> > mkfit::cleanOptsMap

Definition at line 25 of file ConfigStandalone.h.

DeadVec

typedef std::vector<DeadRegion> mkfit::DeadVec

Definition at line 280 of file Hit.h.

EventVec

typedef std::vector<Event> mkfit::EventVec

Definition at line 84 of file Event.h.

filter_candidates_cf

using mkfit::filter_candidates_cf = typedef bool(const TrackCand &, const MkJob &)

Definition at line 27 of file FunctionTypes.h.

filter_candidates_func

using mkfit::filter_candidates_func = typedef std::function<filter_candidates_cf>

Definition at line 28 of file FunctionTypes.h.

FitValLayMap

typedef std::map<int, FitVal> mkfit::FitValLayMap

Definition at line 24 of file TTreeValidation.h.

FltLayerPairVec

typedef std::vector<std::pair<int, float> > mkfit::FltLayerPairVec

Definition at line 121 of file TrackExtra.h.

HitIdxVec

typedef std::vector<int> mkfit::HitIdxVec

Definition at line 17 of file Track.h.

HitLayerMap

typedef std::map<int, std::vector<int> > mkfit::HitLayerMap

Definition at line 18 of file Track.h.

HitVec

typedef std::vector< Hit > mkfit::HitVec

Definition at line 11 of file MkFitHitWrapper.h.

HoTVec

typedef std::vector<HitOnTrack> mkfit::HoTVec

Definition at line 272 of file Hit.h.

idchi2Pair

typedef std::pair<int, float> mkfit::idchi2Pair

Definition at line 232 of file TrackExtra.cc.

idchi2PairVec

typedef std::vector<idchi2Pair> mkfit::idchi2PairVec

Definition at line 233 of file TrackExtra.cc.

LayIdxIDVecMapMap

typedef std::map<int, std::map<int, std::vector<int> > > mkfit::LayIdxIDVecMapMap

Definition at line 37 of file TrackExtra.h.

matchOptsMap

typedef std::map<std::string, std::pair<matchOpts, std::string> > mkfit::matchOptsMap

Definition at line 29 of file ConfigStandalone.h.

MatriplexHitPacker

using mkfit::MatriplexHitPacker = typedef MatriplexErrParPackerSlurpIn<Hit, float>

Definition at line 138 of file MatriplexPackers.h.

MatriplexHoTPacker

using mkfit::MatriplexHoTPacker = typedef MatriplexPackerSlurpIn<HitOnTrack>

Definition at line 141 of file MatriplexPackers.h.

MatriplexTrackPacker

using mkfit::MatriplexTrackPacker = typedef MatriplexErrParPackerSlurpIn<TrackBase, float>

Definition at line 139 of file MatriplexPackers.h.

MCHitInfoVec

typedef std::vector<MCHitInfo> mkfit::MCHitInfoVec

Definition at line 119 of file Hit.h.

MPlex22

typedef Matriplex::Matriplex<float, 2, 2, NN> mkfit::MPlex22

Definition at line 60 of file Matrix.h.

MPlex2H

typedef Matriplex::Matriplex<float, 2, HH, NN> mkfit::MPlex2H

Definition at line 69 of file Matrix.h.

MPlex2S

typedef Matriplex::MatriplexSym<float, 2, NN> mkfit::MPlex2S

Definition at line 62 of file Matrix.h.

MPlex2V

typedef Matriplex::Matriplex<float, 2, 1, NN> mkfit::MPlex2V

Definition at line 61 of file Matrix.h.

MPlex55

typedef Matriplex::Matriplex<float, 5, 5, NN> mkfit::MPlex55

Definition at line 56 of file Matrix.h.

MPlex56

typedef Matriplex::Matriplex<float, 5, 6, NN> mkfit::MPlex56

Definition at line 57 of file Matrix.h.

MPlex65

typedef Matriplex::Matriplex<float, 6, 5, NN> mkfit::MPlex65

Definition at line 58 of file Matrix.h.

MPlexH2

typedef Matriplex::Matriplex<float, HH, 2, NN> mkfit::MPlexH2

Definition at line 68 of file Matrix.h.

MPlexHH

typedef Matriplex::Matriplex<float, HH, HH, NN> mkfit::MPlexHH

Definition at line 52 of file Matrix.h.

MPlexHitIdx

using mkfit::MPlexHitIdx = typedef Matriplex::Matriplex<int, MPlexHitIdxMax, 1, NN>

Definition at line 13 of file MkFitter.h.

MPlexHL

typedef Matriplex::Matriplex<float, HH, LL, NN> mkfit::MPlexHL

Definition at line 65 of file Matrix.h.

MPlexHS

typedef Matriplex::MatriplexSym<float, HH, NN> mkfit::MPlexHS

Definition at line 54 of file Matrix.h.

MPlexHV

typedef Matriplex::Matriplex<float, HH, 1, NN> mkfit::MPlexHV

Definition at line 53 of file Matrix.h.

MPlexL2

typedef Matriplex::Matriplex<float, LL, 2, NN> mkfit::MPlexL2

Definition at line 67 of file Matrix.h.

MPlexLH

typedef Matriplex::Matriplex<float, LL, HH, NN> mkfit::MPlexLH

Definition at line 64 of file Matrix.h.

MPlexLL

typedef Matriplex::Matriplex<float, LL, LL, NN> mkfit::MPlexLL

Definition at line 48 of file Matrix.h.

MPlexLS

typedef Matriplex::MatriplexSym<float, LL, NN> mkfit::MPlexLS

Definition at line 50 of file Matrix.h.

MPlexLV

typedef Matriplex::Matriplex<float, LL, 1, NN> mkfit::MPlexLV

Definition at line 49 of file Matrix.h.

MPlexQB

typedef Matriplex::Matriplex<bool, 1, 1, NN> mkfit::MPlexQB

Definition at line 77 of file Matrix.h.

MPlexQF

typedef Matriplex::Matriplex<float, 1, 1, NN> mkfit::MPlexQF

Definition at line 71 of file Matrix.h.

MPlexQH

typedef Matriplex::Matriplex<short, 1, 1, NN> mkfit::MPlexQH

Definition at line 74 of file Matrix.h.

MPlexQHoT

using mkfit::MPlexQHoT = typedef Matriplex::Matriplex<HitOnTrack, 1, 1, NN>

Definition at line 14 of file MkFitter.h.

MPlexQI

typedef Matriplex::Matriplex<int, 1, 1, NN> mkfit::MPlexQI

Definition at line 72 of file Matrix.h.

MPlexQUH

typedef Matriplex::Matriplex<unsigned short, 1, 1, NN> mkfit::MPlexQUH

Definition at line 75 of file Matrix.h.

MPlexQUI

typedef Matriplex::Matriplex<unsigned int, 1, 1, NN> mkfit::MPlexQUI

Definition at line 73 of file Matrix.h.

PairIdx

typedef std::array<int, 2> mkfit::PairIdx

Definition at line 39 of file TrackExtra.h.

PairIdxVec

typedef std::vector<PairIdx> mkfit::PairIdxVec

Definition at line 40 of file TrackExtra.h.

partition_seeds_cf

using mkfit::partition_seeds_cf = typedef void(const TrackerInfo &, const TrackVec &, const EventOfHits &, IterationSeedPartition &)

Definition at line 24 of file FunctionTypes.h.

partition_seeds_func

using mkfit::partition_seeds_func = typedef std::function<partition_seeds_cf>

Definition at line 25 of file FunctionTypes.h.

RedTrackVec

typedef std::vector<ReducedTrack> mkfit::RedTrackVec

Definition at line 35 of file TrackExtra.h.

seedOptsMap

typedef std::map<std::string, std::pair<seedOpts, std::string> > mkfit::seedOptsMap

Definition at line 21 of file ConfigStandalone.h.

SimTkIDInfo

typedef std::pair<int, int> mkfit::SimTkIDInfo

Definition at line 16 of file Track.h.

SMatrix22

typedef ROOT::Math::SMatrix<float, 2> mkfit::SMatrix22

Definition at line 16 of file MatrixSTypes.h.

SMatrix26

typedef ROOT::Math::SMatrix<float, 2, 6> mkfit::SMatrix26

Definition at line 23 of file MatrixSTypes.h.

SMatrix33

typedef ROOT::Math::SMatrix<float, 3> mkfit::SMatrix33

Definition at line 12 of file MatrixSTypes.h.

SMatrix36

typedef ROOT::Math::SMatrix<float, 3, 6> mkfit::SMatrix36

Definition at line 20 of file MatrixSTypes.h.

SMatrix62

typedef ROOT::Math::SMatrix<float, 6, 2> mkfit::SMatrix62

Definition at line 24 of file MatrixSTypes.h.

SMatrix63

typedef ROOT::Math::SMatrix<float, 6, 3> mkfit::SMatrix63

Definition at line 21 of file MatrixSTypes.h.

SMatrix66

typedef ROOT::Math::SMatrix<float, 6> mkfit::SMatrix66

Definition at line 9 of file MatrixSTypes.h.

SMatrixSym22

typedef ROOT::Math::SMatrix<float, 2, 2, ROOT::Math::MatRepSym<float, 2> > mkfit::SMatrixSym22

Definition at line 17 of file MatrixSTypes.h.

SMatrixSym33

typedef ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3> > mkfit::SMatrixSym33

Definition at line 13 of file MatrixSTypes.h.

SMatrixSym66

typedef ROOT::Math::SMatrix<float, 6, 6, ROOT::Math::MatRepSym<float, 6> > mkfit::SMatrixSym66

Definition at line 8 of file MatrixSTypes.h.

SVector2

typedef ROOT::Math::SVector<float, 2> mkfit::SVector2

Definition at line 18 of file MatrixSTypes.h.

SVector3

typedef ROOT::Math::SVector<float, 3> mkfit::SVector3

Definition at line 14 of file MatrixSTypes.h.

SVector6

typedef ROOT::Math::SVector<float, 6> mkfit::SVector6

Definition at line 10 of file MatrixSTypes.h.

TkIDtoFitValLayMapMap

typedef std::unordered_map<int, FitValLayMap> mkfit::TkIDtoFitValLayMapMap

Definition at line 25 of file TTreeValidation.h.

TkIDToTkIDMap

typedef std::unordered_map<int, int> mkfit::TkIDToTkIDMap

Definition at line 124 of file TrackExtra.h.

TkIDToTkIDVecMap

typedef std::unordered_map<int, std::vector<int> > mkfit::TkIDToTkIDVecMap

Definition at line 125 of file TrackExtra.h.

TkIDToTSLayerPairVecMap

typedef std::unordered_map<int, TSLayerPairVec> mkfit::TkIDToTSLayerPairVecMap

Definition at line 127 of file TrackExtra.h.

TkIDToTSMap

typedef std::unordered_map<int, TrackState> mkfit::TkIDToTSMap

Definition at line 126 of file TrackExtra.h.

TkIDToTSVecVec

typedef std::vector<TSVec> mkfit::TkIDToTSVecVec

Definition at line 119 of file TrackExtra.h.

track_score_cf

using mkfit::track_score_cf = typedef float(const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates)

Definition at line 39 of file FunctionTypes.h.

track_score_func

using mkfit::track_score_func = typedef std::function<track_score_cf>

Definition at line 40 of file FunctionTypes.h.

TrackExtraVec

typedef std::vector< TrackExtra > mkfit::TrackExtraVec

Definition at line 13 of file MkStandaloneSeqs.h.

TrackVec

typedef std::vector< Track > mkfit::TrackVec

Definition at line 8 of file MkFitOutputWrapper.h.

TrackVecVec

typedef std::vector<TrackVec> mkfit::TrackVecVec

Definition at line 597 of file Track.h.

TripletIdx

typedef std::array<int, 3> mkfit::TripletIdx

Definition at line 41 of file TrackExtra.h.

TripletIdxVec

typedef std::vector<TripletIdx> mkfit::TripletIdxVec

Definition at line 42 of file TrackExtra.h.

TrkIDLaySetMap

typedef std::map<int, std::unordered_set<int> > mkfit::TrkIDLaySetMap

Definition at line 38 of file TrackExtra.h.

TSLayerPairVec

typedef std::vector<std::pair<int, TrackState> > mkfit::TSLayerPairVec

Definition at line 120 of file TrackExtra.h.

TSVec

typedef std::vector<TrackState> mkfit::TSVec

Definition at line 118 of file TrackExtra.h.

Enumeration Type Documentation

cleanOpts

enum mkfit::cleanOpts

Enumerator
noCleaning
cleanSeedsN2
cleanSeedsPure
cleanSeedsBadLabel

Definition at line 24 of file ConfigStandalone.h.

{ noCleaning, cleanSeedsN2, cleanSeedsPure, cleanSeedsBadLabel };

KalmanFilterOperation

enum mkfit::KalmanFilterOperation

Enumerator
KFO_Calculate_Chi2
KFO_Update_Params
KFO_Local_Cov

Definition at line 11 of file KalmanUtilsMPlex.h.

{ KFO_Calculate_Chi2 = 1, KFO_Update_Params = 2, KFO_Local_Cov = 4 };

matchOpts

enum mkfit::matchOpts

Enumerator
trkParamBased
hitBased
labelBased

Definition at line 28 of file ConfigStandalone.h.

{ trkParamBased, hitBased, labelBased };

PropagationFlagsEnum

enum mkfit::PropagationFlagsEnum

Enumerator
PF_none
PF_use_param_b_field
PF_apply_material
PF_copy_input_state_on_fail

Definition at line 8 of file PropagationConfig.h.

                            {
    PF_none = 0,
    PF_use_param_b_field = 0x1,
    PF_apply_material = 0x2,
    PF_copy_input_state_on_fail = 0x4
  };

seedOpts

enum mkfit::seedOpts

Enumerator
simSeeds
cmsswSeeds
findSeeds

Definition at line 20 of file ConfigStandalone.h.

{ simSeeds, cmsswSeeds, findSeeds };

TkLayout

enum mkfit::TkLayout

strong

Enumerator
phase0
phase1
phase2

Definition at line 8 of file LayerNumberConverter.h.

{ phase0 = 0, phase1 = 1, phase2 = 2 };

WithinSensitiveRegion_e

enum mkfit::WithinSensitiveRegion_e

Enumerator
WSR_Undef
WSR_Inside
WSR_Edge
WSR_Outside
WSR_Failed

Definition at line 17 of file TrackerInfo.h.

{ WSR_Undef = -1, WSR_Inside = 0, WSR_Edge, WSR_Outside, WSR_Failed };

Function Documentation

applyMaterialEffects()

void mkfit::applyMaterialEffects	(	const MPlexQF &	hitsRl,
		const MPlexQF &	hitsXi,
		const MPlexQF &	propSign,
		const MPlexHV &	plNrm,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 1243 of file PropagationMPlex.cc.

References funct::abs(), HLT_2024v12_cff::beta, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), plot_hgcal_utils::dEdx, MillePedeFileConverter_cfg::e, f, CustomPhysics_cfi::gamma, Exhume::I, dqm-mbProfile::log, SiStripPI::max, hlt_dqm_clientPB-live_cfg::me, dqmiodumpmetadata::n, NN, AlCaHLTBitMon_ParallelJobs::p, SiStripOfflineCRack_cfg::p2, DiDispStaMuonMonitor_cfi::pt, funct::sin(), mathSSE::sqrt(), theta(), mkfit::Config::usePtMultScat, and cms::cuda::wmax.

Referenced by propagateHelixToPlaneMPlex(), propagateHelixToRMPlex(), and propagateHelixToZMPlex().

                                              {
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      if (n >= N_proc)
        continue;
      float radL = hitsRl.constAt(n, 0, 0);
      if (radL < 1e-13f)
        continue;  //ugly, please fixme
      const float theta = outPar.constAt(n, 5, 0);
      // const float pt = 1.f / outPar.constAt(n, 3, 0);  //fixme, make sure it is positive?
      const float ipt = outPar.constAt(n, 3, 0);
      const float pt = 1.f / ipt;  //fixme, make sure it is positive?
      const float ipt2 = ipt * ipt;
      const float p = pt / std::sin(theta);
      const float pz = p * std::cos(theta);
      const float p2 = p * p;
      constexpr float mpi = 0.140;       // m=140 MeV, pion
      constexpr float mpi2 = mpi * mpi;  // m=140 MeV, pion
      const float beta2 = p2 / (p2 + mpi2);
      const float beta = std::sqrt(beta2);
      //radiation lenght, corrected for the crossing angle (cos alpha from dot product of radius vector and momentum)
      const float invCos =
          p / std::abs(pt * std::cos(outPar.constAt(n, 4, 0)) * plNrm.constAt(n, 0, 0) +
                       pt * std::sin(outPar.constAt(n, 4, 0)) * plNrm.constAt(n, 1, 0) + pz * plNrm.constAt(n, 2, 0));
      radL = radL * invCos;  //fixme works only for barrel geom
      // multiple scattering
      //vary independently phi and theta by the rms of the planar multiple scattering angle
      // XXX-KMD radL < 0, see your fixme above! Repeating bailout
      if (radL < 1e-13f)
        continue;
      // const float thetaMSC = 0.0136f*std::sqrt(radL)*(1.f+0.038f*std::log(radL))/(beta*p);// eq 32.15
      // const float thetaMSC2 = thetaMSC*thetaMSC;
      const float thetaMSC = 0.0136f * (1.f + 0.038f * std::log(radL)) / (beta * p);  // eq 32.15
      const float thetaMSC2 = thetaMSC * thetaMSC * radL;
      if (Config::usePtMultScat) {
        outErr.At(n, 3, 3) += thetaMSC2 * pz * pz * ipt2 * ipt2;
        outErr.At(n, 3, 5) -= thetaMSC2 * pz * ipt2;
        outErr.At(n, 4, 4) += thetaMSC2 * p2 * ipt2;
        outErr.At(n, 5, 5) += thetaMSC2;
      } else {
        outErr.At(n, 4, 4) += thetaMSC2;
        outErr.At(n, 5, 5) += thetaMSC2;
      }
      //std::cout << "beta=" << beta << " p=" << p << std::endl;
      //std::cout << "multiple scattering thetaMSC=" << thetaMSC << " thetaMSC2=" << thetaMSC2 << " radL=" << radL << std::endl;
      // energy loss
      // XXX-KMD beta2 = 1 => 1 / sqrt(0)
      // const float gamma = 1.f/std::sqrt(1.f - std::min(beta2, 0.999999f));
      // const float gamma2 = gamma*gamma;
      const float gamma2 = (p2 + mpi2) / mpi2;
      const float gamma = std::sqrt(gamma2);  //1.f/std::sqrt(1.f - std::min(beta2, 0.999999f));
      constexpr float me = 0.0005;            // m=0.5 MeV, electron
      const float wmax = 2.f * me * beta2 * gamma2 / (1.f + 2.f * gamma * me / mpi + me * me / (mpi * mpi));
      constexpr float I = 16.0e-9 * 10.75;
      const float deltahalf = std::log(28.816e-9f * std::sqrt(2.33f * 0.498f) / I) + std::log(beta * gamma) - 0.5f;
      const float dEdx =
          beta < 1.f
              ? (2.f * (hitsXi.constAt(n, 0, 0) * invCos *
                        (0.5f * std::log(2.f * me * beta2 * gamma2 * wmax / (I * I)) - beta2 - deltahalf) / beta2))
              : 0.f;  //protect against infs and nans
      // dEdx = dEdx*2.;//xi in cmssw is defined with an extra factor 0.5 with respect to formula 27.1 in pdg
      //std::cout << "dEdx=" << dEdx << " delta=" << deltahalf << " wmax=" << wmax << " Xi=" << hitsXi.constAt(n,0,0) << std::endl;
      const float dP = propSign.constAt(n, 0, 0) * dEdx / beta;
      outPar.At(n, 3, 0) = p / (std::max(p + dP, 0.001f) * pt);  //stay above 1MeV
      //assume 100% uncertainty
      outErr.At(n, 3, 3) += dP * dP / (p2 * pt * pt);
    }
  }

calculateCharge() [1/2]

int mkfit::calculateCharge ( const Hit &  hit0, const Hit &  hit1, const Hit &  hit2  )

inline

Definition at line 20 of file Track.h.

References mkfit::Hit::x(), and mkfit::Hit::y().

                                                                                {
    return ((hit2.y() - hit0.y()) * (hit2.x() - hit1.x()) > (hit2.y() - hit1.y()) * (hit2.x() - hit0.x()) ? 1 : -1);
  }

calculateCharge() [2/2]

int mkfit::calculateCharge ( const float  hit0_x, const float  hit0_y, const float  hit1_x, const float  hit1_y, const float  hit2_x, const float  hit2_y  )

inline

Definition at line 24 of file Track.h.

                                                 {
    return ((hit2_y - hit0_y) * (hit2_x - hit1_x) > (hit2_y - hit1_y) * (hit2_x - hit0_x) ? 1 : -1);
  }

cdist()

float mkfit::cdist ( float  a )

inline

Definition at line 32 of file Config.h.

References a, mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by mkfit::Event::clean_cms_seedtracks(), mkfit::StdSeq::clean_cms_seedtracks_iter(), mkfit::MkFinder::selectHitIndices(), and mkfit::MkFinder::selectHitIndicesV2().

{ return a > Const::PI ? Const::TwoPI - a : a; }

CFMap()

void mkfit::CFMap ( const MPlexHH &  A, const MPlexHV &  B, MPlexHV &  C  )

inline

Definition at line 89 of file ConformalUtilsMPlex.cc.

References A, a, ASSUME_ALIGNED, B, b, correctionTermsCaloMet_cff::C, HltBtagPostValidation_cff::c, N, and NN.

Referenced by conformalFitMPlex().

                                                                    {
    using idx_t = Matriplex::idx_t;

    // C = A * B, C is 3x1, A is 3x3 , B is 3x1

    typedef float T;
    typedef float Tv;
    const idx_t N = NN;

    const T* a = A.fArray;
    ASSUME_ALIGNED(a, 64);
    const Tv* b = B.fArray;
    ASSUME_ALIGNED(b, 64);
    Tv* c = C.fArray;
    ASSUME_ALIGNED(c, 64);

#include "RecoTracker/MkFitCore/standalone/CFMatrix33Vector3.ah"
  }

computeHelixChi2()

template<typename Vector , typename Matrix >

float mkfit::computeHelixChi2	(	const Vector &	simV,
		const Vector &	recoV,
		const Matrix &	recoM,
		const bool	diagOnly = false
	)

Definition at line 652 of file Track.h.

References diagonalOnly(), and squashPhiGeneral().

Referenced by mkfit::TTreeValidation::fillEfficiencyTree(), mkfit::TTreeValidation::fillFakeRateTree(), mkfit::TrackExtra::setCMSSWTrackIDInfoByHits(), and mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams().

                                                                                                                    {
    Vector diffV = recoV - simV;
    if (diffV.kSize > 2)
      squashPhiGeneral(diffV);

    Matrix recoM_tmp = recoM;
    if (diagOnly)
      diagonalOnly(recoM_tmp);
    int invFail(0);
    const Matrix recoMI = recoM_tmp.InverseFast(invFail);

    return ROOT::Math::Dot(diffV * recoMI, diffV) / (diffV.kSize - 1);
  }

conformalFitMPlex()

void mkfit::conformalFitMPlex	(	bool	fitting,
		MPlexQI	seedID,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const MPlexHV &	msPar0,
		const MPlexHV &	msPar1,
		const MPlexHV &	msPar2
	)

Definition at line 111 of file ConformalUtilsMPlex.cc.

References A, a, funct::abs(), b, mkfit::Config::Bfield, correctionTermsCaloMet_cff::C, CFMap(), dcall, debug, dprint, dprintf, f, g_debug, getPhi(), getRad2(), getTheta(), hipo(), mps_fire::i, Matriplex::invertCramer(), dqmiolumiharvest::j, dqmdumpme::k, N, dqmiodumpmetadata::n, NN, mkfit::TrackState::parameters, mkfit::Config::phierr012, mkfit::Config::phierr049, mkfit::Const::PI3Over4, mkfit::Const::PIOver4, print(), pv::pT, mkfit::Config::ptinverr012, mkfit::Config::ptinverr049, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, diffTwoXMLs::r2, mkfit::Const::sol, mkfit::Config::thetaerr012, mkfit::Config::thetaerr049, findQualityFiles::v, mkfit::Config::varR, mkfit::Config::varXY, mkfit::Config::varZ, and x.

                                                {
    bool debug(false);

    using idx_t = Matriplex::idx_t;
    const idx_t N = NN;

    // Store positions in mplex vectors... could consider storing in a 3x3 matrix, too
    MPlexHV x, y, z, r2;
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      x.At(n, 0, 0) = msPar0.constAt(n, 0, 0);
      x.At(n, 1, 0) = msPar1.constAt(n, 0, 0);
      x.At(n, 2, 0) = msPar2.constAt(n, 0, 0);

      y.At(n, 0, 0) = msPar0.constAt(n, 1, 0);
      y.At(n, 1, 0) = msPar1.constAt(n, 1, 0);
      y.At(n, 2, 0) = msPar2.constAt(n, 1, 0);

      z.At(n, 0, 0) = msPar0.constAt(n, 2, 0);
      z.At(n, 1, 0) = msPar1.constAt(n, 2, 0);
      z.At(n, 2, 0) = msPar2.constAt(n, 2, 0);

      for (int i = 0; i < 3; ++i) {
        r2.At(n, i, 0) = getRad2(x.constAt(n, i, 0), y.constAt(n, i, 0));
      }
    }

    // Start setting the output parameters
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      outPar.At(n, 0, 0) = x.constAt(n, 0, 0);
      outPar.At(n, 1, 0) = y.constAt(n, 0, 0);
      outPar.At(n, 2, 0) = z.constAt(n, 0, 0);
    }

    // Use r-phi smearing to set initial error estimation for positions
    // trackStates already initialized to identity for seeding ... don't store off-diag 0's, zero's for fitting set outside CF
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      const float varPhi = Config::varXY / r2.constAt(n, 0, 0);
      const float invvarR2 = Config::varR / r2.constAt(n, 0, 0);

      outErr.At(n, 0, 0) =
          x.constAt(n, 0, 0) * x.constAt(n, 0, 0) * invvarR2 + y.constAt(n, 0, 0) * y.constAt(n, 0, 0) * varPhi;
      outErr.At(n, 0, 1) = x.constAt(n, 0, 0) * y.constAt(n, 0, 0) * (invvarR2 - varPhi);

      outErr.At(n, 1, 0) = outErr.constAt(n, 0, 1);
      outErr.At(n, 1, 1) =
          y.constAt(n, 0, 0) * y.constAt(n, 0, 0) * invvarR2 + x.constAt(n, 0, 0) * x.constAt(n, 0, 0) * varPhi;

      outErr.At(n, 2, 2) = Config::varZ;
    }

    MPlexQF initPhi;
    MPlexQI xtou;  // bool to determine "split space", i.e. map x to u or v
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      initPhi.At(n, 0, 0) = std::abs(getPhi(x.constAt(n, 0, 0), y.constAt(n, 0, 0)));
      xtou.At(n, 0, 0) =
          ((initPhi.constAt(n, 0, 0) < Const::PIOver4 || initPhi.constAt(n, 0, 0) > Const::PI3Over4) ? 1 : 0);
    }

    MPlexHV u, v;
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      if (xtou.At(n, 0, 0))  // x mapped to u
      {
        for (int i = 0; i < 3; ++i) {
          u.At(n, i, 0) = x.constAt(n, i, 0) / r2.constAt(n, i, 0);
          v.At(n, i, 0) = y.constAt(n, i, 0) / r2.constAt(n, i, 0);
        }
      } else  // x mapped to v
      {
        for (int i = 0; i < 3; ++i) {
          u.At(n, i, 0) = y.constAt(n, i, 0) / r2.constAt(n, i, 0);
          v.At(n, i, 0) = x.constAt(n, i, 0) / r2.constAt(n, i, 0);
        }
      }
    }

    MPlexHH A;
    //#pragma omp simd // triggers an internal compiler error with icc 18.0.2!
    for (int n = 0; n < N; ++n) {
      for (int i = 0; i < 3; ++i) {
        A.At(n, i, 0) = 1.0f;
        A.At(n, i, 1) = -u.constAt(n, i, 0);
        A.At(n, i, 2) = -u.constAt(n, i, 0) * u.constAt(n, i, 0);
      }
    }
    Matriplex::invertCramer(A);
    MPlexHV C;
    CFMap(A, v, C);

    MPlexQF a, b;
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      b.At(n, 0, 0) = 1.0f / (2.0f * C.constAt(n, 0, 0));
      a.At(n, 0, 0) = b.constAt(n, 0, 0) * C.constAt(n, 1, 0);
    }

    // constant used throughtout
    const float k = (Const::sol * Config::Bfield) / 100.0f;

    MPlexQF vrx, vry, pT, px, py, pz;
#pragma omp simd
    for (int n = 0; n < N; ++n) {
      vrx.At(n, 0, 0) =
          (xtou.constAt(n, 0, 0) ? x.constAt(n, 0, 0) - a.constAt(n, 0, 0) : x.constAt(n, 0, 0) - b.constAt(n, 0, 0));
      vry.At(n, 0, 0) =
          (xtou.constAt(n, 0, 0) ? y.constAt(n, 0, 0) - b.constAt(n, 0, 0) : y.constAt(n, 0, 0) - a.constAt(n, 0, 0));
      pT.At(n, 0, 0) = k * hipo(vrx.constAt(n, 0, 0), vry.constAt(n, 0, 0));
      px.At(n, 0, 0) = std::copysign(k * vry.constAt(n, 0, 0), x.constAt(n, 2, 0) - x.constAt(n, 0, 0));
      py.At(n, 0, 0) = std::copysign(k * vrx.constAt(n, 0, 0), y.constAt(n, 2, 0) - y.constAt(n, 0, 0));
      pz.At(n, 0, 0) = (pT.constAt(n, 0, 0) * (z.constAt(n, 2, 0) - z.constAt(n, 0, 0))) /
                       hipo((x.constAt(n, 2, 0) - x.constAt(n, 0, 0)), (y.constAt(n, 2, 0) - y.constAt(n, 0, 0)));
    }

#pragma omp simd
    for (int n = 0; n < N; ++n) {
      outPar.At(n, 3, 0) = 1.0f / pT.constAt(n, 0, 0);
      outPar.At(n, 4, 0) = getPhi(px.constAt(n, 0, 0), py.constAt(n, 0, 0));
      outPar.At(n, 5, 0) = getTheta(pT.constAt(n, 0, 0), pz.constAt(n, 0, 0));
#ifdef INWARDFIT  // arctan is odd, so pz -> -pz means theta -> -theta
      if (fitting)
        outPar.At(n, 5, 0) *= -1.0f;
#endif
    }

#pragma omp simd
    for (int n = 0; n < N; ++n) {
      outErr.At(n, 3, 3) =
          (fitting ? Config::ptinverr049 * Config::ptinverr049 : Config::ptinverr012 * Config::ptinverr012);
      outErr.At(n, 4, 4) = (fitting ? Config::phierr049 * Config::phierr049 : Config::phierr012 * Config::phierr012);
      outErr.At(n, 5, 5) =
          (fitting ? Config::thetaerr049 * Config::thetaerr049 : Config::thetaerr012 * Config::thetaerr012);
    }

    if (debug && g_debug) {
      for (int n = 0; n < N; ++n) {
        dprintf("afterCF seedID: %1u \n", seedID.constAt(n, 0, 0));
        // do a dumb copy out
        TrackState updatedState;
        for (int i = 0; i < 6; i++) {
          updatedState.parameters[i] = outPar.constAt(n, i, 0);
          for (int j = 0; j < 6; j++) {
            updatedState.errors[i][j] = outErr.constAt(n, i, j);
          }
        }

        dcall(print("CCS", updatedState));
        updatedState.convertFromCCSToCartesian();
        dcall(print("Pol", updatedState));
        dprint("--------------------------------");
      }
    }
  }

convertHits()

template<typename Traits , typename HitCollection >

edm::ProductID mkfit::convertHits	(	const Traits &	traits,
		const HitCollection &	hits,
		mkfit::HitVec &	mkFitHits,
		std::vector< TrackingRecHit const *> &	clusterIndexToHit,
		std::vector< float > &	clusterChargeVec,
		const TrackerTopology &	ttopo,
		const TransientTrackingRecHitBuilder &	ttrhBuilder,
		const MkFitGeometry &	mkFitGeom
	)

Definition at line 25 of file convertHits.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), submitPVResolutionJobs::err, Exception, f, hfClusterShapes_cfi::hits, edm::ProductID::id(), TrackerTopology::isStereo(), TrackerTopology::layer(), LogTrace, MkFitGeometry::mkFitLayerNumber(), DetId::rawId(), DetId::subdetId(), MkFitGeometry::uniqueIdInLayer(), and UNLIKELY.

Referenced by MkFitSiPixelHitConverter::produce(), and MkFitSiStripHitConverter::produce().

                                                             {
    if (hits.empty())
      return edm::ProductID{};

    edm::ProductID clusterID;
    {
      const auto& lastClusterRef = hits.data().back().firstClusterRef();
      clusterID = lastClusterRef.id();
      if (lastClusterRef.index() >= mkFitHits.size()) {
        auto const size = lastClusterRef.index();
        mkFitHits.resize(size);
        clusterIndexToHit.resize(size, nullptr);
        if constexpr (Traits::applyCCC()) {
          clusterChargeVec.resize(size, -1.f);
        }
      }
    }

    for (const auto& detset : hits) {
      const DetId detid = detset.detId();
      const auto ilay = mkFitGeom.mkFitLayerNumber(detid);

      for (const auto& hit : detset) {
        const auto charge = traits.clusterCharge(hit, detid);
        if (!traits.passCCC(charge))
          continue;

        const auto& gpos = hit.globalPosition();
        SVector3 pos(gpos.x(), gpos.y(), gpos.z());
        const auto& gerr = hit.globalPositionError();
        SMatrixSym33 err;
        err.At(0, 0) = gerr.cxx();
        err.At(1, 1) = gerr.cyy();
        err.At(2, 2) = gerr.czz();
        err.At(0, 1) = gerr.cyx();
        err.At(0, 2) = gerr.czx();
        err.At(1, 2) = gerr.czy();

        auto clusterRef = hit.firstClusterRef();
        if UNLIKELY (clusterRef.id() != clusterID) {
          throw cms::Exception("LogicError")
              << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID
              << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId();
        }
        const auto clusterIndex = clusterRef.index();
        LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << detid.subdetId()
                                      << " layer " << ttopo.layer(detid) << " isStereo " << ttopo.isStereo(detid)
                                      << " zplus "
                                      << " index " << clusterIndex << " ilay " << ilay;

        if UNLIKELY (clusterIndex >= mkFitHits.size()) {
          mkFitHits.resize(clusterIndex + 1);
          clusterIndexToHit.resize(clusterIndex + 1, nullptr);
          if constexpr (Traits::applyCCC()) {
            clusterChargeVec.resize(clusterIndex + 1, -1.f);
          }
        }
        mkFitHits[clusterIndex] = mkfit::Hit(pos, err);
        clusterIndexToHit[clusterIndex] = &hit;
        if constexpr (Traits::applyCCC()) {
          clusterChargeVec[clusterIndex] = charge;
        }

        const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId());
        traits.setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge);
      }
    }
    return clusterID;
  }

cube()

template<typename T >

T mkfit::cube ( T  x )

inline

Definition at line 18 of file Hit.h.

References x.

Referenced by getInvRadErr2().

                     {
    return x * x * x;
  }

diagonalOnly()

template<typename Matrix >

void mkfit::diagonalOnly ( Matrix &  m )

inline

Definition at line 27 of file MatrixSTypes.h.

References HltBtagPostValidation_cff::c, and visualization-live-secondInstance_cfg::m.

Referenced by computeHelixChi2().

                                      {
    for (int r = 0; r < m.kRows; r++) {
      for (int c = 0; c < m.kCols; c++) {
        if (r != c)
          m[r][c] = 0.f;
      }
    }
  }

dtime()

double mkfit::dtime ( )

inline

Definition at line 23 of file buildtestMPlex.h.

Referenced by mkfit::CandCloner::begin_eta_bin(), mkfit::CandCloner::begin_layer(), mkfit::CandCloner::end_eta_bin(), mkfit::CandCloner::end_layer(), popcon::RPCObPVSSmapData::getNewObjects(), popcon::RpcDataT::getNewObjects(), popcon::RpcDataGasMix::getNewObjects(), popcon::RpcDataUXC::getNewObjects(), popcon::RpcDataV::getNewObjects(), popcon::RpcDataI::getNewObjects(), popcon::RpcDataFebmap::getNewObjects(), popcon::RpcDataS::getNewObjects(), popcon::RpcObGasData::getNewObjects(), runBtpCe_MultiIter(), runBuildingTestPlexBestHit(), runBuildingTestPlexCloneEngine(), runBuildingTestPlexStandard(), runFittingTestPlex(), and test_standard().

                        {
    double tseconds = 0.0;
    struct timeval mytime;
    gettimeofday(&mytime, (struct timezone*)nullptr);
    tseconds = (double)(mytime.tv_sec + mytime.tv_usec * 1.0e-6);
    return (tseconds);
  }

dumpMatrix()

template<typename Matrix >

void mkfit::dumpMatrix

(

Matrix

m

)

Definition at line 37 of file MatrixSTypes.h.

References HltBtagPostValidation_cff::c, gather_cfg::cout, and visualization-live-secondInstance_cfg::m.

Referenced by print().

                            {
    for (int r = 0; r < m.kRows; ++r) {
      for (int c = 0; c < m.kCols; ++c) {
        std::cout << std::setw(12) << m.At(r, c) << " ";
      }
      std::cout << std::endl;
    }
  }

execTrackerInfoCreatorPlugin()

void mkfit::execTrackerInfoCreatorPlugin	(	const std::string &	base,
		TrackerInfo &	ti,
		IterationsInfo &	ii,
		bool	verbose
	)

Definition at line 92 of file ConfigStandalone.cc.

References newFWLiteAna::base, beamvalidation::exit(), custom_jme_cff::foo, h, cuy::ii, castor_dqm_sourceclient_file_cfg::path, mkfit::TrackerInfo::read_bin_file(), edm_modernize_messagelogger::stat, submitPVResolutionJobs::stderr, AlCaHLTBitMon_QueryRunRegistry::string, and verbose.

Referenced by initGeom().

                                                                                                              {
    const std::string soname = base + ".so";
    const std::string binname = base + ".bin";
    struct stat st;

    int si = 0;
    while (search_path[si]) {
      std::string path;
      const char *envpath = std::getenv("MKFIT_BASE");
      if (envpath != nullptr) {
        path += envpath;
        path += "/";
      }
      path += search_path[si];
      std::string sopath = path + soname;
      if (stat(sopath.c_str(), &st) == 0) {
        printf("execTrackerInfoCreatorPlugin processing '%s'\n", sopath.c_str());

        void *h = dlopen(sopath.c_str(), RTLD_LAZY);
        if (!h) {
          perror("dlopen failed");
          exit(2);
        }

        long long *p2f = (long long *)dlsym(h, "TrackerInfoCreator_ptr");
        if (!p2f) {
          perror("dlsym failed");
          exit(2);
        }

        std::string binpath = path + binname;
        int binsr = stat(binpath.c_str(), &st);
        printf("execTrackerInfoCreatorPlugin has%s found TrackerInfo binary file '%s'\n",
               binsr ? " NOT" : "",
               binpath.c_str());
        if (binsr == 0)
          ti.read_bin_file(binpath);

        TrackerInfoCreator_foo foo = (TrackerInfoCreator_foo)(*p2f);
        foo(ti, ii, verbose);

        return;
      }

      ++si;
    }

    fprintf(stderr, "TrackerInfo plugin '%s' not found in search path.\n", soname.c_str());
    exit(2);
  }

findSeedsByRoadSearch()

void mkfit::findSeedsByRoadSearch	(	TripletIdxConVec &	seed_idcs,
		std::vector< LayerOfHits > &	evt_lay_hits,
		int	lay1_size,
		Event *&	ev
	)

Definition at line 34 of file seedtestMPlex.cc.

References a, funct::abs(), b, debug, mkfit::Config::dEtaSeedTrip, dprint, makeMEIFBenchmarkPlots::ev, JetChargeProducer_cfi::exp, f, getHypot(), getPhi(), getRad2(), mps_fire::i, heavyIonCSV_trainingSettings::idx, intersectThirdLayer(), mkfit::Config::lay01angdiff, SiStripPI::max, mkfit::Config::maxCurvR, mkfit::Hit::mcTrackID(), HLTObjectMonitor_cfi::mr, TtSemiLepEvtBuilder_cfi::mt, mkfit::Config::numHitsPerTask, mkfit::Hit::phi(), mkfit::LayerOfHits::refHit(), mkfit::Config::seed_d0cut, mkfit::Config::seed_z0cut, mkfit::Config::seed_z1cut, mathSSE::sqrt(), funct::tan(), mkfit::Hit::x(), mkfit::Hit::y(), and mkfit::Hit::z().

                                         {
#ifdef DEBUG
    bool debug(false);
#endif

    // MIMI hack: Config::nlayers_per_seed = 4
    // const float seed_z2cut = (Config::nlayers_per_seed * Config::fRadialSpacing) / std::tan(2.0f*std::atan(std::exp(-1.0f*Config::dEtaSeedTrip)));
#ifdef DEBUG
    const float seed_z2cut =
        (4 * Config::fRadialSpacing) / std::tan(2.0f * std::atan(std::exp(-1.0f * Config::dEtaSeedTrip)));
#endif

    // 0 = first layer, 1 = second layer, 2 = third layer
    const LayerOfHits& lay1_hits = evt_lay_hits[1];
    LayerOfHits& lay0_hits = evt_lay_hits[0];
    LayerOfHits& lay2_hits = evt_lay_hits[2];

    tbb::parallel_for(
        tbb::blocked_range<int>(0, lay1_size, std::max(1, Config::numHitsPerTask)),
        [&](const tbb::blocked_range<int>& i) {
          TripletIdxVec temp_thr_seed_idcs;
          for (int ihit1 = i.begin(); ihit1 < i.end(); ++ihit1) {
            const Hit& hit1 = lay1_hits.refHit(ihit1);
            const float hit1_z = hit1.z();

            dprint("ihit1: " << ihit1 << " mcTrackID: " << hit1.mcTrackID(ev->simHitsInfo_) << " phi: " << hit1.phi()
                             << " z: " << hit1.z());
            dprint(" predphi: " << hit1.phi() << "+/-" << Config::lay01angdiff << " predz: " << hit1.z() / 2.0f << "+/-"
                                << Config::seed_z0cut / 2.0f << std::endl);

            std::vector<int> cand_hit0_indices;  // pass by reference
            // MIMI lay0_hits.selectHitIndices(hit1_z/2.0f,hit1.phi(),Config::seed_z0cut/2.0f,Config::lay01angdiff,cand_hit0_indices,true,false);
            // loop over first layer hits
            for (auto&& ihit0 : cand_hit0_indices) {
              const Hit& hit0 = lay0_hits.refHit(ihit0);
              const float hit0_z = hit0.z();
              const float hit0_x = hit0.x();
              const float hit0_y = hit0.y();
              const float hit1_x = hit1.x();
              const float hit1_y = hit1.y();
              const float hit01_r2 = getRad2(hit0_x - hit1_x, hit0_y - hit1_y);

              const float quad = std::sqrt((4.0f * Config::maxCurvR * Config::maxCurvR - hit01_r2) / hit01_r2);

              // center of negative curved track
              const float aneg = 0.5f * ((hit0_x + hit1_x) - (hit0_y - hit1_y) * quad);
              const float bneg = 0.5f * ((hit0_y + hit1_y) + (hit0_x - hit1_x) * quad);

              // negative points of intersection with third layer
              float lay2_negx = 0.0f, lay2_negy = 0.0f;
              intersectThirdLayer(aneg, bneg, hit1_x, hit1_y, lay2_negx, lay2_negy);
#ifdef DEBUG
              const float lay2_negphi = getPhi(lay2_negx, lay2_negy);
#endif

              // center of positive curved track
              const float apos = 0.5f * ((hit0_x + hit1_x) + (hit0_y - hit1_y) * quad);
              const float bpos = 0.5f * ((hit0_y + hit1_y) - (hit0_x - hit1_x) * quad);

              // positive points of intersection with third layer
              float lay2_posx = 0.0f, lay2_posy = 0.0f;
              intersectThirdLayer(apos, bpos, hit1_x, hit1_y, lay2_posx, lay2_posy);
#ifdef DEBUG
              const float lay2_posphi = getPhi(lay2_posx, lay2_posy);
#endif

              std::vector<int> cand_hit2_indices;
              // MIMI lay2_hits.selectHitIndices((2.0f*hit1_z-hit0_z),(lay2_posphi+lay2_negphi)/2.0f,
              // MIMI seed_z2cut,(lay2_posphi-lay2_negphi)/2.0f,
              // MIMI cand_hit2_indices,true,false);

              dprint(" ihit0: " << ihit0 << " mcTrackID: " << hit0.mcTrackID(ev->simHitsInfo_) << " phi: " << hit0.phi()
                                << " z: " << hit0.z());
              dprint("  predphi: " << (lay2_posphi + lay2_negphi) / 2.0f << "+/-" << (lay2_posphi - lay2_negphi) / 2.0f
                                   << " predz: " << 2.0f * hit1_z - hit0_z << "+/-" << seed_z2cut << std::endl);

          // loop over candidate third layer hits
          //temp_thr_seed_idcs.reserve(temp_thr_seed_idcs.size()+cand_hit2_indices.size());
#pragma omp simd
              for (size_t idx = 0; idx < cand_hit2_indices.size(); ++idx) {
                const int ihit2 = cand_hit2_indices[idx];
                const Hit& hit2 = lay2_hits.refHit(ihit2);

                const float lay1_predz = (hit0_z + hit2.z()) / 2.0f;
                // filter by residual of second layer hit
                if (std::abs(lay1_predz - hit1_z) > Config::seed_z1cut)
                  continue;

                const float hit2_x = hit2.x();
                const float hit2_y = hit2.y();

                // now fit a circle, extract pT and d0 from center and radius
                const float mr = (hit1_y - hit0_y) / (hit1_x - hit0_x);
                const float mt = (hit2_y - hit1_y) / (hit2_x - hit1_x);
                const float a = (mr * mt * (hit2_y - hit0_y) + mr * (hit1_x + hit2_x) - mt * (hit0_x + hit1_x)) /
                                (2.0f * (mr - mt));
                const float b = -1.0f * (a - (hit0_x + hit1_x) / 2.0f) / mr + (hit0_y + hit1_y) / 2.0f;
                const float r = getHypot(hit0_x - a, hit0_y - b);

                // filter by d0 cut 5mm, pT cut 0.5 GeV (radius of 0.5 GeV track)
                if ((r < Config::maxCurvR) || (std::abs(getHypot(a, b) - r) > Config::seed_d0cut))
                  continue;

                dprint(" ihit2: " << ihit2 << " mcTrackID: " << hit2.mcTrackID(ev->simHitsInfo_)
                                  << " phi: " << hit2.phi() << " z: " << hit2.z());

                temp_thr_seed_idcs.emplace_back(TripletIdx{{ihit0, ihit1, ihit2}});
              }  // end loop over third layer matches
            }    // end loop over first layer matches
          }      // end chunk of hits for parallel for
          seed_idcs.grow_by(temp_thr_seed_idcs.begin(), temp_thr_seed_idcs.end());
        });  // end parallel for loop over second layer hits
  }

from_json() [1/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::LayerControl &  nlohmann_json_t  )

inline

Definition at line 37 of file IterationConfig.cc.

Referenced by mkfit::ConfigJson::load_File(), mkfit::ConfigJsonPatcher::save(), and mkfit::ConfigJson::test_Direct().

from_json() [2/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::LayerControl &  nlohmann_json_t  )

inline

Definition at line 37 of file IterationConfig.cc.

from_json() [3/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::SteeringParams &  nlohmann_json_t  )

inline

Definition at line 45 of file IterationConfig.cc.

from_json() [4/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::SteeringParams &  nlohmann_json_t  )

inline

Definition at line 45 of file IterationConfig.cc.

from_json() [5/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::IterationLayerConfig &  nlohmann_json_t  )

inline

Definition at line 54 of file IterationConfig.cc.

from_json() [6/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::IterationLayerConfig &  nlohmann_json_t  )

inline

Definition at line 54 of file IterationConfig.cc.

from_json() [7/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::IterationParams &  nlohmann_json_t  )

inline

Definition at line 68 of file IterationConfig.cc.

from_json() [8/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::IterationParams &  nlohmann_json_t  )

inline

Definition at line 68 of file IterationConfig.cc.

from_json() [9/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::IterationConfig &  nlohmann_json_t  )

inline

Definition at line 101 of file IterationConfig.cc.

from_json() [10/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::IterationConfig &  nlohmann_json_t  )

inline

Definition at line 101 of file IterationConfig.cc.

from_json() [11/12]

void mkfit::from_json ( const nlohmann::json &  nlohmann_json_j, mkfit::IterationsInfo &  nlohmann_json_t  )

inline

Definition at line 104 of file IterationConfig.cc.

{

from_json() [12/12]

void mkfit::from_json ( const nlohmann::ordered_json &  nlohmann_json_j, mkfit::IterationsInfo &  nlohmann_json_t  )

inline

Definition at line 104 of file IterationConfig.cc.

{

getEta() [1/3]

float mkfit::getEta ( float  r, float  z  )

inline

Definition at line 38 of file Hit.h.

References f, getTheta(), dqm-mbProfile::log, and funct::tan().

Referenced by MuonTrackValidator::analyze(), mkfit::Hit::eta(), GflashEMShowerProfile::getDistanceToOut(), HcalGeomParameters::loadfinal(), mkfit::TrackState::momEta(), mkfit::TrackState::posEta(), mkfit::TrackBase::posEta(), mkfit::MkFinder::selectHitIndices(), and HcalNumberingFromPS::unitID().

{ return -1.0f * std::log(std::tan(getTheta(r, z) / 2.0f)); }

getEta() [2/3]

float mkfit::getEta ( float  theta )

inline

Definition at line 40 of file Hit.h.

References f, dqm-mbProfile::log, funct::tan(), and theta().

{ return -1.0f * std::log(std::tan(theta / 2.0f)); }

getEta() [3/3]

float mkfit::getEta ( float  x, float  y, float  z  )

inline

Definition at line 42 of file Hit.h.

References f, dqm-mbProfile::log, mathSSE::sqrt(), funct::tan(), theta(), and x.

                                                 {
    const float theta = std::atan2(std::sqrt(x * x + y * y), z);
    return -1.0f * std::log(std::tan(theta / 2.0f));
  }

getEtaErr2()

float mkfit::getEtaErr2 ( float  x, float  y, float  z, float  exx, float  eyy, float  ezz, float  exy, float  exz, float  eyz  )

inline

Definition at line 74 of file Hit.h.

References getRad2(), mathSSE::sqrt(), and x.

Referenced by mkfit::Hit::eeta(), and mkfit::TrackState::eposEta().

                                                                                                                       {
    const float rad2 = getRad2(x, y);
    const float detadx = -x / (rad2 * std::sqrt(1 + rad2 / (z * z)));
    const float detady = -y / (rad2 * std::sqrt(1 + rad2 / (z * z)));
    const float detadz = 1.0f / (z * std::sqrt(1 + rad2 / (z * z)));
    return detadx * detadx * exx + detady * detady * eyy + detadz * detadz * ezz + 2.0f * detadx * detady * exy +
           2.0f * detadx * detadz * exz + 2.0f * detady * detadz * eyz;
  }

getHypot()

float mkfit::getHypot ( float  x, float  y  )

inline

Definition at line 47 of file Hit.h.

References mathSSE::sqrt(), and x.

Referenced by findSeedsByRoadSearch(), intersectThirdLayer(), mkfit::TrackState::posR(), mkfit::TrackBase::posR(), and mkfit::TrackBase::swimPhiToR().

{ return std::sqrt(x * x + y * y); }

getInvRad2()

float mkfit::getInvRad2 ( float  x, float  y  )

inline

Definition at line 32 of file Hit.h.

References x.

{ return 1.0f / (x * x + y * y); }

getInvRadErr2()

float mkfit::getInvRadErr2 ( float  x, float  y, float  exx, float  eyy, float  exy  )

inline

Definition at line 53 of file Hit.h.

References cube(), f, getRad2(), and x.

                                                                                {
    return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / cube(getRad2(x, y));
  }

getMatchBin()

int mkfit::getMatchBin ( const float  pt )

inline

Definition at line 237 of file TrackExtra.cc.

References f, and DiDispStaMuonMonitor_cfi::pt.

Referenced by mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams().

                                         {
    if (pt < 0.75f)
      return 0;
    else if (pt < 1.f)
      return 1;
    else if (pt < 2.f)
      return 2;
    else if (pt < 5.f)
      return 3;
    else if (pt < 10.f)
      return 4;
    else
      return 5;
  }

getPhi()

float mkfit::getPhi ( float  x, float  y  )

inline

Definition at line 34 of file Hit.h.

References x.

Referenced by conformalFitMPlex(), mkfit::TrackState::convertFromCartesianToCCS(), mkfit::TrackState::convertFromGlbCurvilinearToCCS(), findSeedsByRoadSearch(), mkfit::Hit::phi(), mkfit::TrackState::posPhi(), mkfit::TrackBase::posPhi(), TrackFitter::run(), mkfit::MkFinder::selectHitIndices(), and HcalNumberingFromPS::unitID().

{ return std::atan2(y, x); }

getPhiErr2()

float mkfit::getPhiErr2 ( float  x, float  y, float  exx, float  eyy, float  exy  )

inline

Definition at line 57 of file Hit.h.

References f, getRad2(), and x.

Referenced by mkfit::Hit::ephi(), and mkfit::TrackState::eposPhi().

                                                                             {
    const float rad2 = getRad2(x, y);
    return (y * y * exx + x * x * eyy - 2.0f * x * y * exy) / (rad2 * rad2);
  }

getPxPxErr2()

float mkfit::getPxPxErr2 ( float  ipt, float  phi, float  vipt, float  vphi  )

inline

Definition at line 83 of file Hit.h.

References funct::cos(), and funct::sin().

Referenced by mkfit::TrackState::epxpx().

                                                                         {  // ipt = 1/pT, v = variance
    const float iipt2 = 1.0f / (ipt * ipt);                                 //iipt = 1/(1/pT) = pT
    const float cosP = std::cos(phi);
    const float sinP = std::sin(phi);
    return iipt2 * (iipt2 * cosP * cosP * vipt + sinP * sinP * vphi);
  }

getPyPyErr2()

float mkfit::getPyPyErr2 ( float  ipt, float  phi, float  vipt, float  vphi  )

inline

Definition at line 90 of file Hit.h.

References funct::cos(), and funct::sin().

Referenced by mkfit::TrackState::epypy(), and mkfit::TrackState::epzpz().

                                                                         {  // ipt = 1/pT, v = variance
    const float iipt2 = 1.0f / (ipt * ipt);                                 //iipt = 1/(1/pT) = pT
    const float cosP = std::cos(phi);
    const float sinP = std::sin(phi);
    return iipt2 * (iipt2 * sinP * sinP * vipt + cosP * cosP * vphi);
  }

getPzPzErr2()

float mkfit::getPzPzErr2 ( float  ipt, float  theta, float  vipt, float  vtheta  )

inline

Definition at line 97 of file Hit.h.

References funct::sin(), funct::tan(), and theta().

                                                                             {  // ipt = 1/pT, v = variance
    const float iipt2 = 1.0f / (ipt * ipt);                                     //iipt = 1/(1/pT) = pT
    const float cotT = 1.0f / std::tan(theta);
    const float cscT = 1.0f / std::sin(theta);
    return iipt2 * (iipt2 * cotT * cotT * vipt + cscT * cscT * cscT * cscT * vtheta);
  }

getRad2()

float mkfit::getRad2 ( float  x, float  y  )

inline

Definition at line 30 of file Hit.h.

References x.

Referenced by conformalFitMPlex(), findSeedsByRoadSearch(), getEtaErr2(), getInvRadErr2(), getPhiErr2(), getRadErr2(), and getThetaErr2().

{ return x * x + y * y; }

getRadErr2()

float mkfit::getRadErr2 ( float  x, float  y, float  exx, float  eyy, float  exy  )

inline

Definition at line 49 of file Hit.h.

References f, getRad2(), and x.

Referenced by mkfit::TrackState::eposR().

                                                                             {
    return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / getRad2(x, y);
  }

getScoreCand() [1/2]

float mkfit::getScoreCand ( const track_score_func &  score_func, const TrackCand &  cand1, bool  penalizeTailMissHits = false, bool  inFindCandidates = false  )

inline

Definition at line 259 of file TrackStructures.h.

References mkfit::TrackBase::chi2(), nano_mu_local_reco_cff::chi2, mkfit::TrackCand::nFoundHits(), mkfit::TrackCand::nInsideMinusOneHits(), mkfit::TrackCand::nOverlapHits(), mkfit::TrackCand::nTailMinusOneHits(), DiDispStaMuonMonitor_cfi::pt, and mkfit::TrackBase::pT().

                                                           {
    int nfoundhits = cand1.nFoundHits();
    int noverlaphits = cand1.nOverlapHits();
    int nmisshits = cand1.nInsideMinusOneHits();
    int ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
    float pt = cand1.pT();
    float chi2 = cand1.chi2();
    // Do not allow for chi2<0 in score calculation
    if (chi2 < 0)
      chi2 = 0.f;
    return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
  }

getScoreCand() [2/2]

float mkfit::getScoreCand ( const track_score_func &  score_func, const Track &  cand1, bool  penalizeTailMissHits = false, bool  inFindCandidates = false  )

inline

Definition at line 615 of file Track.h.

References mkfit::TrackBase::chi2(), nano_mu_local_reco_cff::chi2, mkfit::Track::nFoundHits(), mkfit::Track::nInsideMinusOneHits(), mkfit::Track::nOverlapHits(), mkfit::Track::nTailMinusOneHits(), DiDispStaMuonMonitor_cfi::pt, and mkfit::TrackBase::pT().

Referenced by mkfit::MkFinder::bkFitOutputTracks(), mkfit::MkBuilder::find_tracks_in_layers(), mkfit::MkFinder::findCandidates(), mkfit::CombCandidate::importSeed(), mkfit::CombCandidate::mergeCandsAndBestShortOne(), mkfit::Event::print_tracks(), mkfit::StdSeq::score_tracks(), and mkfit::TTreeValidation::setTrackScoresDumbCMSSW().

                                                           {
    int nfoundhits = cand1.nFoundHits();
    int noverlaphits = cand1.nOverlapHits();
    int nmisshits = cand1.nInsideMinusOneHits();
    float ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
    float pt = cand1.pT();
    float chi2 = cand1.chi2();
    // Do not allow for chi2<0 in score calculation
    if (chi2 < 0)
      chi2 = 0.f;
    return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
  }

getScoreStruct()

float mkfit::getScoreStruct ( const track_score_func &  score_func, const IdxChi2List &  cand1  )

inline

Definition at line 631 of file Track.h.

References mkfit::IdxChi2List::chi2, nano_mu_local_reco_cff::chi2, mkfit::IdxChi2List::nhits, mkfit::IdxChi2List::nholes, mkfit::IdxChi2List::noverlaps, mkfit::IdxChi2List::ntailholes, DiDispStaMuonMonitor_cfi::pt, and mkfit::IdxChi2List::pt.

Referenced by mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                            {
    int nfoundhits = cand1.nhits;
    int ntailholes = cand1.ntailholes;
    int noverlaphits = cand1.noverlaps;
    int nmisshits = cand1.nholes;
    float pt = cand1.pt;
    float chi2 = cand1.chi2;
    // Do not allow for chi2<0 in score calculation
    if (chi2 < 0)
      chi2 = 0.f;
    return score_func(nfoundhits, ntailholes, noverlaphits, nmisshits, chi2, pt, true /*inFindCandidates*/);
  }

getScoreWorstPossible()

float mkfit::getScoreWorstPossible ( )

inline

Definition at line 611 of file Track.h.

References SiStripPI::max.

Referenced by mkfit::CombCandidate::reset(), and mkfit::TrackCand::resetShortTrack().

                                       {
    return -std::numeric_limits<float>::max();  // used for handling of best short track during finding
  }

getTheta()

float mkfit::getTheta ( float  r, float  z  )

inline

Definition at line 36 of file Hit.h.

Referenced by conformalFitMPlex(), mkfit::TrackState::convertFromCartesianToCCS(), mkfit::TrackState::convertFromGlbCurvilinearToCCS(), and getEta().

{ return std::atan2(r, z); }

getThetaErr2()

float mkfit::getThetaErr2 ( float  x, float  y, float  z, float  exx, float  eyy, float  ezz, float  exy, float  exz, float  eyz  )

inline

Definition at line 62 of file Hit.h.

References getRad2(), mathSSE::sqrt(), and x.

                                                                                                   {
    const float rad2 = getRad2(x, y);
    const float rad = std::sqrt(rad2);
    const float hypot2 = rad2 + z * z;
    const float dthetadx = x * z / (rad * hypot2);
    const float dthetady = y * z / (rad * hypot2);
    const float dthetadz = -rad / hypot2;
    return dthetadx * dthetadx * exx + dthetady * dthetady * eyy + dthetadz * dthetadz * ezz +
           2.0f * dthetadx * dthetady * exy + 2.0f * dthetadx * dthetadz * exz + 2.0f * dthetady * dthetadz * eyz;
  }

helixAtPlane()

void mkfit::helixAtPlane	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexHV &	plPnt,
		const MPlexHV &	plNrm,
		MPlexQF &	pathL,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 1070 of file PropagationMPlex.cc.

References f, and NN.

Referenced by propagateHelixToPlaneMPlex().

                                                    {
    errorProp.setVal(0.f);
    outFailFlag.setVal(0.f);

    helixAtPlane_impl(inPar, inChg, plPnt, plNrm, pathL, outPar, errorProp, outFailFlag, 0, NN, N_proc, pflags);
  }

helixAtRFromIterativeCCS()

void mkfit::helixAtRFromIterativeCCS	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 480 of file PropagationMPlex.cc.

References f, and NN.

Referenced by propagateHelixToRMPlex().

                                                                {
    errorProp.setVal(0.f);
    outFailFlag.setVal(0.f);

    helixAtRFromIterativeCCS_impl(inPar, inChg, msRad, outPar, errorProp, outFailFlag, 0, NN, N_proc, pflags);
  }

helixAtRFromIterativeCCSFullJac() [1/2]

void mkfit::helixAtRFromIterativeCCSFullJac	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc
	)

helixAtRFromIterativeCCSFullJac() [2/2]

void mkfit::helixAtRFromIterativeCCSFullJac	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		const int	N_proc
	)

Definition at line 292 of file PropagationMPlex.cc.

References funct::abs(), mkfit::Config::Bfield, CMS_UNROLL_LOOP_COUNT, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), gather_cfg::cout, debug, dprint_np, f, g_debug, hipo(), mps_fire::i, dqmdumpme::k, dqmiodumpmetadata::n, mkfit::Config::Niter, NN, funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), and mkfit::Config::useTrigApprox.

                                                         {
    errorProp.setVal(0.f);
    MPlexLL errorPropTmp(0.f);   //initialize to zero
    MPlexLL errorPropSwap(0.f);  //initialize to zero

    // loop does not vectorize with llvm16, and it issues a warning
    // that apparently can't be suppressed with a pragma.  Needs to
    // be rechecked if future llvm versions improve vectorization.
#if !defined(__clang__)
#pragma omp simd
#endif
    for (int n = 0; n < NN; ++n) {
      //initialize erroProp to identity matrix
      errorProp(n, 0, 0) = 1.f;
      errorProp(n, 1, 1) = 1.f;
      errorProp(n, 2, 2) = 1.f;
      errorProp(n, 3, 3) = 1.f;
      errorProp(n, 4, 4) = 1.f;
      errorProp(n, 5, 5) = 1.f;

      const float k = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
      const float r = msRad.constAt(n, 0, 0);
      float r0 = hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0));

      if (std::abs(r - r0) < 0.0001f) {
        dprint_np(n, "distance less than 1mum, skip");
        continue;
      }

      const float ipt = inPar.constAt(n, 3, 0);
      const float phiin = inPar.constAt(n, 4, 0);
      const float theta = inPar.constAt(n, 5, 0);

      //set those that are 1. before iterations
      errorPropTmp(n, 2, 2) = 1.f;
      errorPropTmp(n, 3, 3) = 1.f;
      errorPropTmp(n, 4, 4) = 1.f;
      errorPropTmp(n, 5, 5) = 1.f;

      float cosah = 0., sinah = 0.;
      //no trig approx here, phi and theta can be large
      float cosP = std::cos(phiin), sinP = std::sin(phiin);
      const float cosT = std::cos(theta), sinT = std::sin(theta);
      float pxin = cosP / ipt;
      float pyin = sinP / ipt;

      CMS_UNROLL_LOOP_COUNT(Config::Niter)
      for (int i = 0; i < Config::Niter; ++i) {
        dprint_np(n,
                  std::endl
                      << "attempt propagation from r=" << r0 << " to r=" << r << std::endl
                      << "x=" << outPar.At(n, 0, 0) << " y=" << outPar.At(n, 1, 0) << " z=" << outPar.At(n, 2, 0)
                      << " px=" << std::cos(phiin) / ipt << " py=" << std::sin(phiin) / ipt
                      << " pz=" << 1.f / (ipt * tan(theta)) << " q=" << inChg.constAt(n, 0, 0) << std::endl);

        r0 = hipo(outPar.constAt(n, 0, 0), outPar.constAt(n, 1, 0));
        const float ialpha = (r - r0) * ipt / k;
        //alpha+=ialpha;

        if constexpr (Config::useTrigApprox) {
          sincos4(ialpha * 0.5f, sinah, cosah);
        } else {
          cosah = std::cos(ialpha * 0.5f);
          sinah = std::sin(ialpha * 0.5f);
        }
        const float cosa = 1.f - 2.f * sinah * sinah;
        const float sina = 2.f * sinah * cosah;

        //derivatives of alpha
        const float dadx = -outPar.At(n, 0, 0) * ipt / (k * r0);
        const float dady = -outPar.At(n, 1, 0) * ipt / (k * r0);
        const float dadipt = (r - r0) / k;

        outPar.At(n, 0, 0) = outPar.constAt(n, 0, 0) + 2.f * k * sinah * (pxin * cosah - pyin * sinah);
        outPar.At(n, 1, 0) = outPar.constAt(n, 1, 0) + 2.f * k * sinah * (pyin * cosah + pxin * sinah);
        const float pxinold = pxin;  //copy before overwriting
        pxin = pxin * cosa - pyin * sina;
        pyin = pyin * cosa + pxinold * sina;

        //need phi at origin, so this goes before redefining phi
        //no trig approx here, phi can be large
        cosP = std::cos(outPar.At(n, 4, 0));
        sinP = std::sin(outPar.At(n, 4, 0));

        outPar.At(n, 2, 0) = outPar.constAt(n, 2, 0) + k * ialpha * cosT / (ipt * sinT);
        outPar.At(n, 3, 0) = ipt;
        outPar.At(n, 4, 0) = outPar.constAt(n, 4, 0) + ialpha;
        outPar.At(n, 5, 0) = theta;

        errorPropTmp(n, 0, 0) = 1.f + k * (cosP * dadx * cosa - sinP * dadx * sina) / ipt;
        errorPropTmp(n, 0, 1) = k * (cosP * dady * cosa - sinP * dady * sina) / ipt;
        errorPropTmp(n, 0, 3) =
            k * (cosP * (ipt * dadipt * cosa - sina) + sinP * ((1.f - cosa) - ipt * dadipt * sina)) / (ipt * ipt);
        errorPropTmp(n, 0, 4) = -k * (sinP * sina + cosP * (1.f - cosa)) / ipt;

        errorPropTmp(n, 1, 0) = k * (sinP * dadx * cosa + cosP * dadx * sina) / ipt;
        errorPropTmp(n, 1, 1) = 1.f + k * (sinP * dady * cosa + cosP * dady * sina) / ipt;
        errorPropTmp(n, 1, 3) =
            k * (sinP * (ipt * dadipt * cosa - sina) + cosP * (ipt * dadipt * sina - (1.f - cosa))) / (ipt * ipt);
        errorPropTmp(n, 1, 4) = k * (cosP * sina - sinP * (1.f - cosa)) / ipt;

        errorPropTmp(n, 2, 0) = k * cosT * dadx / (ipt * sinT);
        errorPropTmp(n, 2, 1) = k * cosT * dady / (ipt * sinT);
        errorPropTmp(n, 2, 3) = k * cosT * (ipt * dadipt - ialpha) / (ipt * ipt * sinT);
        errorPropTmp(n, 2, 5) = -k * ialpha / (ipt * sinT * sinT);

        errorPropTmp(n, 4, 0) = dadx;
        errorPropTmp(n, 4, 1) = dady;
        errorPropTmp(n, 4, 3) = dadipt;

        MultHelixPropTemp(errorProp, errorPropTmp, errorPropSwap, n);
        errorProp = errorPropSwap;
      }

      dprint_np(
          n,
          "propagation end, dump parameters"
              << std::endl
              << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
              << "mom = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
              << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
              << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
              << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
              << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);

#ifdef DEBUG
      if (debug && g_debug && n < N_proc) {
        dmutex_guard;
        std::cout << n << " jacobian" << std::endl;
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 0, 0),
               errorProp(n, 0, 1),
               errorProp(n, 0, 2),
               errorProp(n, 0, 3),
               errorProp(n, 0, 4),
               errorProp(n, 0, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 1, 0),
               errorProp(n, 1, 1),
               errorProp(n, 1, 2),
               errorProp(n, 1, 3),
               errorProp(n, 1, 4),
               errorProp(n, 1, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 2, 0),
               errorProp(n, 2, 1),
               errorProp(n, 2, 2),
               errorProp(n, 2, 3),
               errorProp(n, 2, 4),
               errorProp(n, 2, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 3, 0),
               errorProp(n, 3, 1),
               errorProp(n, 3, 2),
               errorProp(n, 3, 3),
               errorProp(n, 3, 4),
               errorProp(n, 3, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 4, 0),
               errorProp(n, 4, 1),
               errorProp(n, 4, 2),
               errorProp(n, 4, 3),
               errorProp(n, 4, 4),
               errorProp(n, 4, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 5, 0),
               errorProp(n, 5, 1),
               errorProp(n, 5, 2),
               errorProp(n, 5, 3),
               errorProp(n, 5, 4),
               errorProp(n, 5, 5));
      }
#endif
    }
  }

helixAtZ()

void mkfit::helixAtZ	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msZ,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 748 of file PropagationMPlex.cc.

References funct::abs(), simBeamSpotPI::alpha, mkfit::Config::Bfield, mkfit::Config::bFieldFromZR(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), gather_cfg::cout, debug, l1tTrackerHTMiss_cfi::deltaZ, dprint_np, f, g_debug, hipo(), dqmdumpme::k, dqmiodumpmetadata::n, NN, DiDispStaMuonMonitor_cfi::pt, funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), mkfit::PropagationFlags::use_param_b_field, and mkfit::Config::useTrigApprox.

Referenced by propagateHelixToZMPlex().

                                                {
    errorProp.setVal(0.f);
    outFailFlag.setVal(0.f);

    // debug = true;
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      //initialize erroProp to identity matrix, except element 2,2 which is zero
      errorProp(n, 0, 0) = 1.f;
      errorProp(n, 1, 1) = 1.f;
      errorProp(n, 3, 3) = 1.f;
      errorProp(n, 4, 4) = 1.f;
      errorProp(n, 5, 5) = 1.f;
    }
    float zout[NN];
    float zin[NN];
    float ipt[NN];
    float phiin[NN];
    float theta[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      //initialize erroProp to identity matrix, except element 2,2 which is zero
      zout[n] = msZ.constAt(n, 0, 0);
      zin[n] = inPar.constAt(n, 2, 0);
      ipt[n] = inPar.constAt(n, 3, 0);
      phiin[n] = inPar.constAt(n, 4, 0);
      theta[n] = inPar.constAt(n, 5, 0);
    }

    float k[NN];
    if (pflags.use_param_b_field) {
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        k[n] = inChg.constAt(n, 0, 0) * 100.f /
               (-Const::sol * Config::bFieldFromZR(zin[n], hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0))));
      }
    } else {
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        k[n] = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
      }
    }

    float kinv[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      kinv[n] = 1.f / k[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      dprint_np(n,
                std::endl
                    << "input parameters"
                    << " inPar.constAt(n, 0, 0)=" << std::setprecision(9) << inPar.constAt(n, 0, 0)
                    << " inPar.constAt(n, 1, 0)=" << std::setprecision(9) << inPar.constAt(n, 1, 0)
                    << " inPar.constAt(n, 2, 0)=" << std::setprecision(9) << inPar.constAt(n, 2, 0)
                    << " inPar.constAt(n, 3, 0)=" << std::setprecision(9) << inPar.constAt(n, 3, 0)
                    << " inPar.constAt(n, 4, 0)=" << std::setprecision(9) << inPar.constAt(n, 4, 0)
                    << " inPar.constAt(n, 5, 0)=" << std::setprecision(9) << inPar.constAt(n, 5, 0)
                    << " inChg.constAt(n, 0, 0)=" << std::setprecision(9) << inChg.constAt(n, 0, 0));
    }
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      dprint_np(n,
                "propagation start, dump parameters"
                    << std::endl
                    << "pos = " << inPar.constAt(n, 0, 0) << " " << inPar.constAt(n, 1, 0) << " "
                    << inPar.constAt(n, 2, 0) << std::endl
                    << "mom (cart) = " << std::cos(inPar.constAt(n, 4, 0)) / inPar.constAt(n, 3, 0) << " "
                    << std::sin(inPar.constAt(n, 4, 0)) / inPar.constAt(n, 3, 0) << " "
                    << 1. / (inPar.constAt(n, 3, 0) * tan(inPar.constAt(n, 5, 0))) << " r="
                    << std::sqrt(inPar.constAt(n, 0, 0) * inPar.constAt(n, 0, 0) +
                                 inPar.constAt(n, 1, 0) * inPar.constAt(n, 1, 0))
                    << " pT=" << 1. / std::abs(inPar.constAt(n, 3, 0)) << " q=" << inChg.constAt(n, 0, 0)
                    << " targetZ=" << msZ.constAt(n, 0, 0) << std::endl);
    }

    float pt[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      pt[n] = 1.f / ipt[n];
    }

    //no trig approx here, phi can be large
    float cosP[NN];
    float sinP[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      cosP[n] = std::cos(phiin[n]);
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      sinP[n] = std::sin(phiin[n]);
    }

    float cosT[NN];
    float sinT[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      cosT[n] = std::cos(theta[n]);
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      sinT[n] = std::sin(theta[n]);
    }

    float tanT[NN];
    float icos2T[NN];
    float pxin[NN];
    float pyin[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      tanT[n] = sinT[n] / cosT[n];
      icos2T[n] = 1.f / (cosT[n] * cosT[n]);
      pxin[n] = cosP[n] * pt[n];
      pyin[n] = sinP[n] * pt[n];
    }

    float deltaZ[NN];
    float alpha[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      deltaZ[n] = zout[n] - zin[n];
      alpha[n] = deltaZ[n] * tanT[n] * ipt[n] * kinv[n];
    }

    float cosahTmp[NN];
    float sinahTmp[NN];
    if constexpr (Config::useTrigApprox) {
#if !defined(__INTEL_COMPILER)
#pragma omp simd
#endif
      for (int n = 0; n < NN; ++n) {
        sincos4(alpha[n] * 0.5f, sinahTmp[n], cosahTmp[n]);
      }
    } else {
#if !defined(__INTEL_COMPILER)
#pragma omp simd
#endif
      for (int n = 0; n < NN; ++n) {
        cosahTmp[n] = std::cos(alpha[n] * 0.5f);
      }
#if !defined(__INTEL_COMPILER)
#pragma omp simd
#endif
      for (int n = 0; n < NN; ++n) {
        sinahTmp[n] = std::sin(alpha[n] * 0.5f);
      }
    }

    float cosah[NN];
    float sinah[NN];
    float cosa[NN];
    float sina[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      cosah[n] = cosahTmp[n];
      sinah[n] = sinahTmp[n];
      cosa[n] = 1.f - 2.f * sinah[n] * sinah[n];
      sina[n] = 2.f * sinah[n] * cosah[n];
    }

//update parameters
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      outPar.At(n, 0, 0) = outPar.At(n, 0, 0) + 2.f * k[n] * sinah[n] * (pxin[n] * cosah[n] - pyin[n] * sinah[n]);
      outPar.At(n, 1, 0) = outPar.At(n, 1, 0) + 2.f * k[n] * sinah[n] * (pyin[n] * cosah[n] + pxin[n] * sinah[n]);
      outPar.At(n, 2, 0) = zout[n];
      outPar.At(n, 4, 0) = phiin[n] + alpha[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      dprint_np(n,
                "propagation to Z end (OLD), dump parameters\n"
                    << "   pos = " << outPar(n, 0, 0) << " " << outPar(n, 1, 0) << " " << outPar(n, 2, 0) << "\t\t r="
                    << std::sqrt(outPar(n, 0, 0) * outPar(n, 0, 0) + outPar(n, 1, 0) * outPar(n, 1, 0)) << std::endl
                    << "   mom = " << outPar(n, 3, 0) << " " << outPar(n, 4, 0) << " " << outPar(n, 5, 0) << std::endl
                    << " cart= " << std::cos(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
                    << std::sin(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
                    << 1. / (outPar(n, 3, 0) * tan(outPar(n, 5, 0))) << "\t\tpT=" << 1. / std::abs(outPar(n, 3, 0))
                    << std::endl);
    }

    float pxcaMpysa[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      pxcaMpysa[n] = pxin[n] * cosa[n] - pyin[n] * sina[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      errorProp(n, 0, 2) = -tanT[n] * ipt[n] * pxcaMpysa[n];
      errorProp(n, 0, 3) =
          k[n] * pt[n] * pt[n] *
          (cosP[n] * (alpha[n] * cosa[n] - sina[n]) + sinP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
      errorProp(n, 0, 4) = -2.f * k[n] * pt[n] * sinah[n] * (sinP[n] * cosah[n] + cosP[n] * sinah[n]);
      errorProp(n, 0, 5) = deltaZ[n] * ipt[n] * pxcaMpysa[n] * icos2T[n];
    }

    float pycaPpxsa[NN];
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      pycaPpxsa[n] = pyin[n] * cosa[n] + pxin[n] * sina[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      errorProp(n, 1, 2) = -tanT[n] * ipt[n] * pycaPpxsa[n];
      errorProp(n, 1, 3) =
          k[n] * pt[n] * pt[n] *
          (sinP[n] * (alpha[n] * cosa[n] - sina[n]) - cosP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
      errorProp(n, 1, 4) = 2.f * k[n] * pt[n] * sinah[n] * (cosP[n] * cosah[n] - sinP[n] * sinah[n]);
      errorProp(n, 1, 5) = deltaZ[n] * ipt[n] * pycaPpxsa[n] * icos2T[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      errorProp(n, 4, 2) = -ipt[n] * tanT[n] * kinv[n];
      errorProp(n, 4, 3) = tanT[n] * deltaZ[n] * kinv[n];
      errorProp(n, 4, 5) = ipt[n] * deltaZ[n] * kinv[n] * icos2T[n];
    }

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      dprint_np(
          n,
          "propagation end, dump parameters"
              << std::endl
              << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
              << "mom (cart) = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
              << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
              << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
              << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
              << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);
    }

    // PROP-FAIL-ENABLE Disabled to keep physics changes minimal.
    // To be reviewed, enabled and processed accordingly elsewhere.
    /*
    // Check for errors, set fail-flag.
    for (int n = 0; n < NN; ++n) {
      // We propagate for alpha: mark fail when prop angle more than pi/2
      if (std::abs(alpha[n]) > 1.57) {
        dprintf("helixAtZ: more than quarter turn, alpha = %f\n", alpha[n]);
        outFailFlag[n] = 1;
      } else {
        // Have we reached desired z? We can't know, we copy desired z to actual z.
        // Are we close to apex? Same condition as in propToR, 12.5 deg, cos(78.5deg) = 0.2
        float dotp = (outPar.At(n, 0, 0) * std::cos(outPar.At(n, 4, 0)) +
                      outPar.At(n, 1, 0) * std::sin(outPar.At(n, 4, 0))) /
                     std::hypot(outPar.At(n, 0, 0), outPar.At(n, 1, 0));
        if (dotp < 0.2 || dotp < 0) {
          dprintf("helixAtZ: dot product bad, dotp = %f\n", dotp);
          outFailFlag[n] = 1;
        }
      }
    }
    */

#ifdef DEBUG
    if (debug && g_debug) {
      for (int n = 0; n < N_proc; ++n) {
        dmutex_guard;
        std::cout << n << ": jacobian" << std::endl;
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 0, 0),
               errorProp(n, 0, 1),
               errorProp(n, 0, 2),
               errorProp(n, 0, 3),
               errorProp(n, 0, 4),
               errorProp(n, 0, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 1, 0),
               errorProp(n, 1, 1),
               errorProp(n, 1, 2),
               errorProp(n, 1, 3),
               errorProp(n, 1, 4),
               errorProp(n, 1, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 2, 0),
               errorProp(n, 2, 1),
               errorProp(n, 2, 2),
               errorProp(n, 2, 3),
               errorProp(n, 2, 4),
               errorProp(n, 2, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 3, 0),
               errorProp(n, 3, 1),
               errorProp(n, 3, 2),
               errorProp(n, 3, 3),
               errorProp(n, 3, 4),
               errorProp(n, 3, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 4, 0),
               errorProp(n, 4, 1),
               errorProp(n, 4, 2),
               errorProp(n, 4, 3),
               errorProp(n, 4, 4),
               errorProp(n, 4, 5));
        printf("%5f %5f %5f %5f %5f %5f\n",
               errorProp(n, 5, 0),
               errorProp(n, 5, 1),
               errorProp(n, 5, 2),
               errorProp(n, 5, 3),
               errorProp(n, 5, 4),
               errorProp(n, 5, 5));
      }
    }
#endif
  }

hipo()

float mkfit::hipo ( float  x, float  y  )

inline

Definition at line 9 of file Matrix.h.

References mathSSE::sqrt(), and x.

Referenced by conformalFitMPlex(), helixAtRFromIterativeCCSFullJac(), helixAtZ(), propagateHelixToRMPlex(), propagateLineToRMPlex(), and mkfit::MkBase::radius().

{ return std::sqrt(x * x + y * y); }

hipo_sqr()

float mkfit::hipo_sqr ( float  x, float  y  )

inline

Definition at line 11 of file Matrix.h.

References x.

Referenced by mkfit::MkBase::radiusSqr().

{ return x * x + y * y; }

intersectThirdLayer()

void mkfit::intersectThirdLayer ( const float  a, const float  b, const float  hit1_x, const float  hit1_y, float &  lay2_x, float &  lay2_y  )

inline

Definition at line 9 of file seedtestMPlex.cc.

References a, testProducerWithPsetDescEmpty_cfi::a2, b, b2, f, getHypot(), mkfit::Config::maxCurvR, and mathSSE::sqrt().

Referenced by findSeedsByRoadSearch().

                                                                                                          {
    const float a2 = a * a;
    const float b2 = b * b;
    const float a2b2 = a2 + b2;
    const float lay2rad2 = (Config::fRadialSpacing * Config::fRadialSpacing) * 9.0f;  // average third radius squared
    const float maxCurvR2 = Config::maxCurvR * Config::maxCurvR;

    const float quad =
        std::sqrt(2.0f * maxCurvR2 * (a2b2 + lay2rad2) - (a2b2 - lay2rad2) * (a2b2 - lay2rad2) - maxCurvR2 * maxCurvR2);
    const float pos[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) - b * quad) / a2b2,
                          (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) + a * quad) / a2b2};
    const float neg[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) + b * quad) / a2b2,
                          (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) - a * quad) / a2b2};

    // since we have two intersection points, arbitrate which one is closer to layer2 hit
    if (getHypot(pos[0] - hit1_x, pos[1] - hit1_y) < getHypot(neg[0] - hit1_x, neg[1] - hit1_y)) {
      lay2_x = pos[0];
      lay2_y = pos[1];
    } else {
      lay2_x = neg[0];
      lay2_y = neg[1];
    }
  }

isFinite()

constexpr bool mkfit::isFinite

(

float

x

)

Definition at line 13 of file cms_common_macros.h.

References ztail::d, edm::isFinite(), MainPageGenerator::l, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, findQualityFiles::v, and x.

Referenced by mkfit::MkFinder::bkFitOutputTracks(), mkfit::TrackBase::hasNanNSillyValues(), mkfit::TrackBase::hasSillyValues(), and mkfit::MkFinder::selectHitIndices().

                                   {
#ifdef MKFIT_STANDALONE
    const unsigned int mask = 0x7f800000;
    union {
      unsigned int l;
      float d;
    } v = {.d = x};
    return (v.l & mask) != mask;
#else
    return edm::isFinite(x);
#endif
  }

isStripQCompatible()

bool mkfit::isStripQCompatible	(	int	itrack,
		bool	isBarrel,
		const MPlexLS &	pErr,
		const MPlexLV &	pPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar
	)

Definition at line 1202 of file MkFinder.cc.

References funct::abs(), dprint, f, PixelPluginsPhase0_cfi::isBarrel, SiStripPI::max, amptDefault_cfi::proj, and mathSSE::sqrt().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                                                       {
    //check module compatibility via long strip side = L/sqrt(12)
    if (isBarrel) {  //check z direction only
      const float res = std::abs(msPar.constAt(itrack, 2, 0) - pPar.constAt(itrack, 2, 0));
      const float hitHL = sqrt(msErr.constAt(itrack, 2, 2) * 3.f);  //half-length
      const float qErr = sqrt(pErr.constAt(itrack, 2, 2));
      dprint("qCompat " << hitHL << " + " << 3.f * qErr << " vs " << res);
      return hitHL + std::max(3.f * qErr, 0.5f) > res;
    } else {  //project on xy, assuming the strip Length >> Width
      const float res[2]{msPar.constAt(itrack, 0, 0) - pPar.constAt(itrack, 0, 0),
                         msPar.constAt(itrack, 1, 0) - pPar.constAt(itrack, 1, 0)};
      const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
      const float hitT2inv = 1.f / hitT2;
      const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
                             msErr.constAt(itrack, 0, 1) * hitT2inv,
                             msErr.constAt(itrack, 1, 1) * hitT2inv};
      const float qErr =
          sqrt(std::abs(pErr.constAt(itrack, 0, 0) * proj[0] + 2.f * pErr.constAt(itrack, 0, 1) * proj[1] +
                        pErr.constAt(itrack, 1, 1) * proj[2]));  //take abs to avoid non-pos-def cases
      const float resProj =
          sqrt(res[0] * proj[0] * res[0] + 2.f * res[1] * proj[1] * res[0] + res[1] * proj[2] * res[1]);
      dprint("qCompat " << sqrt(hitT2 * 3.f) << " + " << 3.f * qErr << " vs " << resProj);
      return sqrt(hitT2 * 3.f) + std::max(3.f * qErr, 0.5f) > resProj;
    }
  }

kalmanComputeChi2()

void mkfit::kalmanComputeChi2	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 753 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), and KFO_Calculate_Chi2.

                                           {
    kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
  }

kalmanComputeChi2Endcap()

void mkfit::kalmanComputeChi2Endcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1380 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Calculate_Chi2.

                                                 {
    kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
  }

kalmanComputeChi2Plane()

void mkfit::kalmanComputeChi2Plane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1075 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), and KFO_Calculate_Chi2.

                                                {
    kalmanOperationPlane(
        KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
  }

kalmanOperation()

void mkfit::kalmanOperation	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 797 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and squashPhiMPlex().

Referenced by mkfit::MkFinder::bkFitFitTracks(), mkfit::MkFinder::bkFitFitTracksBH(), kalmanComputeChi2(), kalmanPropagateAndComputeChi2(), kalmanPropagateAndUpdate(), and kalmanUpdate().

                                         {
#ifdef DEBUG
    {
      dmutex_guard;
      printf("psPar:\n");
      for (int i = 0; i < 6; ++i) {
        printf("%8f ", psPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("psErr:\n");
      for (int i = 0; i < 6; ++i) {
        for (int j = 0; j < 6; ++j)
          printf("%8f ", psErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("msPar:\n");
      for (int i = 0; i < 3; ++i) {
        printf("%8f ", msPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("msErr:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", msErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    // Rotate global point on tangent plane to cylinder
    // Tangent point is half way between hit and propagate position

    // Rotation matrix
    //  rotT00  0  rotT01
    //  rotT01  0 -rotT00
    //     0    1    0
    // Minimize temporaries: only two float are needed!

    MPlexQF rotT00;
    MPlexQF rotT01;
    for (int n = 0; n < NN; ++n) {
      if (n < N_proc) {
        const float r = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
        rotT00.At(n, 0, 0) = -(msPar.constAt(n, 1, 0) + psPar.constAt(n, 1, 0)) / (2 * r);
        rotT01.At(n, 0, 0) = (msPar.constAt(n, 0, 0) + psPar.constAt(n, 0, 0)) / (2 * r);
      } else {
        rotT00.At(n, 0, 0) = 0.0f;
        rotT01.At(n, 0, 0) = 0.0f;
      }
    }

    MPlexHV res_glo;  //position residual in global coordinates
    SubtractFirst3(msPar, psPar, res_glo);

    MPlexHS resErr_glo;  //covariance sum in global position coordinates
    AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);

    MPlex2V res_loc;  //position residual in local coordinates
    RotateResidualsOnTangentPlane(rotT00, rotT01, res_glo, res_loc);
    MPlex2S resErr_loc;  //covariance sum in local position coordinates
    MPlexHH tempHH;
    ProjectResErr(rotT00, rotT01, resErr_glo, tempHH);
    ProjectResErrTransp(rotT00, rotT01, tempHH, resErr_loc);

#ifdef DEBUG
    {
      dmutex_guard;
      printf("res_glo:\n");
      for (int i = 0; i < 3; ++i) {
        printf("%8f ", res_glo.At(0, i, 0));
      }
      printf("\n");
      printf("resErr_glo:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", resErr_glo.At(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("res_loc:\n");
      for (int i = 0; i < 2; ++i) {
        printf("%8f ", res_loc.At(0, i, 0));
      }
      printf("\n");
      printf("tempHH:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", tempHH.At(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("resErr_loc:\n");
      for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j)
          printf("%8f ", resErr_loc.At(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    //invert the 2x2 matrix
    Matriplex::invertCramerSym(resErr_loc);

    if (kfOp & KFO_Calculate_Chi2) {
      Chi2Similarity(res_loc, resErr_loc, outChi2);

#ifdef DEBUG
      {
        dmutex_guard;
        printf("resErr_loc (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr_loc.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("chi2: %8f\n", outChi2.At(0, 0, 0));
      }
#endif
    }

    if (kfOp & KFO_Update_Params) {
      MPlexLS psErrLoc = psErr;
      if (kfOp & KFO_Local_Cov)
        CovXYconstrain(rotT00, rotT01, psErr, psErrLoc);

      MPlexLH K;                                      // kalman gain, fixme should be L2
      KalmanHTG(rotT00, rotT01, resErr_loc, tempHH);  // intermediate term to get kalman gain (H^T*G)
      KalmanGain(psErrLoc, tempHH, K);

      MultResidualsAdd(K, psPar, res_loc, outPar);

      squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

      MPlexLL tempLL;
      KHMult(K, rotT00, rotT01, tempLL);
      KHC(tempLL, psErrLoc, outErr);
      outErr.subtract(psErrLoc, outErr);

#ifdef DEBUG
      {
        dmutex_guard;
        if (kfOp & KFO_Local_Cov) {
          printf("psErrLoc:\n");
          for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 6; ++j)
              printf("% 8e ", psErrLoc.At(0, i, j));
            printf("\n");
          }
          printf("\n");
        }
        printf("resErr_loc (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr_loc.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("tempHH:\n");
        for (int i = 0; i < 3; ++i) {
          for (int j = 0; j < 3; ++j)
            printf("%8f ", tempHH.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("K:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 3; ++j)
            printf("%8f ", K.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("tempLL:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", tempLL.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("outPar:\n");
        for (int i = 0; i < 6; ++i) {
          printf("%8f  ", outPar.At(0, i, 0));
        }
        printf("\n");
        printf("outErr:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", outErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
      }
#endif
    }
  }

kalmanOperationEndcap()

void mkfit::kalmanOperationEndcap	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1420 of file KalmanUtilsMPlex.cc.

References mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Update_Params, and squashPhiMPlex().

Referenced by mkfit::MkFinder::bkFitFitTracks(), mkfit::MkFinder::bkFitFitTracksBH(), kalmanComputeChi2Endcap(), kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdateEndcap(), and kalmanUpdateEndcap().

                                               {
#ifdef DEBUG
    {
      dmutex_guard;
      printf("updateParametersEndcapMPlex\n");
      printf("psPar:\n");
      for (int i = 0; i < 6; ++i) {
        printf("%8f ", psPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("msPar:\n");
      for (int i = 0; i < 3; ++i) {
        printf("%8f ", msPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("psErr:\n");
      for (int i = 0; i < 6; ++i) {
        for (int j = 0; j < 6; ++j)
          printf("%8f ", psErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("msErr:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", msErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    MPlex2V res;
    SubtractFirst2(msPar, psPar, res);

    MPlex2S resErr;
    AddIntoUpperLeft2x2(psErr, msErr, resErr);

#ifdef DEBUG
    {
      dmutex_guard;
      printf("resErr:\n");
      for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j)
          printf("%8f ", resErr.At(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    //invert the 2x2 matrix
    Matriplex::invertCramerSym(resErr);

    if (kfOp & KFO_Calculate_Chi2) {
      Chi2Similarity(res, resErr, outChi2);

#ifdef DEBUG
      {
        dmutex_guard;
        printf("resErr_loc (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("chi2: %8f\n", outChi2.At(0, 0, 0));
      }
#endif
    }

    if (kfOp & KFO_Update_Params) {
      MPlexL2 K;
      KalmanGain(psErr, resErr, K);

      MultResidualsAdd(K, psPar, res, outPar);

      squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

      KHC(K, psErr, outErr);

#ifdef DEBUG
      {
        dmutex_guard;
        printf("outErr before subtract:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", outErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
      }
#endif

      outErr.subtract(psErr, outErr);

#ifdef DEBUG
      {
        dmutex_guard;
        printf("res:\n");
        for (int i = 0; i < 2; ++i) {
          printf("%8f ", res.At(0, i, 0));
        }
        printf("\n");
        printf("resErr (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("K:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", K.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("outPar:\n");
        for (int i = 0; i < 6; ++i) {
          printf("%8f  ", outPar.At(0, i, 0));
        }
        printf("\n");
        printf("outErr:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", outErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
      }
#endif
    }
  }

kalmanOperationPlane()

void mkfit::kalmanOperationPlane	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1116 of file KalmanUtilsMPlex.cc.

References mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and squashPhiMPlex().

Referenced by kalmanComputeChi2Plane(), kalmanPropagateAndComputeChi2Plane(), kalmanPropagateAndUpdatePlane(), and kalmanUpdatePlane().

                                              {
#ifdef DEBUG
    {
      dmutex_guard;
      printf("psPar:\n");
      for (int i = 0; i < 6; ++i) {
        printf("%8f ", psPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("psErr:\n");
      for (int i = 0; i < 6; ++i) {
        for (int j = 0; j < 6; ++j)
          printf("%8f ", psErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("msPar:\n");
      for (int i = 0; i < 3; ++i) {
        printf("%8f ", msPar.constAt(0, 0, i));
        printf("\n");
      }
      printf("\n");
      printf("msErr:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", msErr.constAt(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    // Rotate global point on tangent plane to cylinder
    // Tangent point is half way between hit and propagate position

    // Rotation matrix
    //    D0  D1   D2
    //    X0  X1   X2
    //    N0  N1   N2
    // where D is the strip direction vector plDir, N is the normal plNrm, and X is the cross product between the two

    MPlex2H prj;
    for (int n = 0; n < NN; ++n) {
      prj(n, 0, 0) = plDir(n, 0, 0);
      prj(n, 0, 1) = plDir(n, 1, 0);
      prj(n, 0, 2) = plDir(n, 2, 0);
      prj(n, 1, 0) = plNrm(n, 1, 0) * plDir(n, 2, 0) - plNrm(n, 2, 0) * plDir(n, 1, 0);
      prj(n, 1, 1) = plNrm(n, 2, 0) * plDir(n, 0, 0) - plNrm(n, 0, 0) * plDir(n, 2, 0);
      prj(n, 1, 2) = plNrm(n, 0, 0) * plDir(n, 1, 0) - plNrm(n, 1, 0) * plDir(n, 0, 0);
    }

    MPlexHV res_glo;  //position residual in global coordinates
    SubtractFirst3(msPar, psPar, res_glo);

    MPlexHS resErr_glo;  //covariance sum in global position coordinates
    AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);

    MPlex2V res_loc;  //position residual in local coordinates
    RotateResidualsOnPlane(prj, res_glo, res_loc);
    MPlex2S resErr_loc;  //covariance sum in local position coordinates
    MPlex2H temp2H;
    ProjectResErr(prj, resErr_glo, temp2H);
    ProjectResErrTransp(prj, temp2H, resErr_loc);

#ifdef DEBUG
    {
      dmutex_guard;
      printf("prj:\n");
      for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", prj.At(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("res_glo:\n");
      for (int i = 0; i < 3; ++i) {
        printf("%8f ", res_glo.At(0, i, 0));
      }
      printf("\n");
      printf("resErr_glo:\n");
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", resErr_glo.At(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("res_loc:\n");
      for (int i = 0; i < 2; ++i) {
        printf("%8f ", res_loc.At(0, i, 0));
      }
      printf("\n");
      printf("temp2H:\n");
      for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j)
          printf("%8f ", temp2H.At(0, i, j));
        printf("\n");
      }
      printf("\n");
      printf("resErr_loc:\n");
      for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j)
          printf("%8f ", resErr_loc.At(0, i, j));
        printf("\n");
      }
      printf("\n");
    }
#endif

    //invert the 2x2 matrix
    Matriplex::invertCramerSym(resErr_loc);

    if (kfOp & KFO_Calculate_Chi2) {
      Chi2Similarity(res_loc, resErr_loc, outChi2);

#ifdef DEBUG
      {
        dmutex_guard;
        printf("resErr_loc (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr_loc.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("chi2: %8f\n", outChi2.At(0, 0, 0));
      }
#endif
    }

    if (kfOp & KFO_Update_Params) {
      MPlexLS psErrLoc = psErr;

      MPlexH2 tempH2;
      MPlexL2 K;                           // kalman gain, fixme should be L2
      KalmanHTG(prj, resErr_loc, tempH2);  // intermediate term to get kalman gain (H^T*G)
      KalmanGain(psErrLoc, tempH2, K);

      MultResidualsAdd(K, psPar, res_loc, outPar);

      squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

      MPlexLL tempLL;
      KHMult(K, prj, tempLL);
      KHC(tempLL, psErrLoc, outErr);
      outErr.subtract(psErrLoc, outErr);

#ifdef DEBUG
      {
        dmutex_guard;
        if (kfOp & KFO_Local_Cov) {
          printf("psErrLoc:\n");
          for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 6; ++j)
              printf("% 8e ", psErrLoc.At(0, i, j));
            printf("\n");
          }
          printf("\n");
        }
        printf("resErr_loc (Inv):\n");
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", resErr_loc.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("tempH2:\n");
        for (int i = 0; i < 3; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", tempH2.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("K:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 2; ++j)
            printf("%8f ", K.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("tempLL:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", tempLL.At(0, i, j));
          printf("\n");
        }
        printf("\n");
        printf("outPar:\n");
        for (int i = 0; i < 6; ++i) {
          printf("%8f  ", outPar.At(0, i, 0));
        }
        printf("\n");
        printf("outErr:\n");
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            printf("%8f ", outErr.At(0, i, j));
          printf("\n");
        }
        printf("\n");
      }
#endif
    }
  }

kalmanPropagateAndComputeChi2()

void mkfit::kalmanPropagateAndComputeChi2	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 763 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), kalmanOperation(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

                                                           {
    propPar = psPar;
    if (propToHit) {
      MPlexLS propErr;
      MPlexQF msRad;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        if (n < N_proc) {
          msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
        } else {
          msRad.At(n, 0, 0) = 0.0f;
        }
      }

      propagateHelixToRMPlex(psErr, psPar, inChg, msRad, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperation(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
    } else {
      kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
    }
  }

kalmanPropagateAndComputeChi2Endcap()

void mkfit::kalmanPropagateAndComputeChi2Endcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1390 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

                                                                 {
    propPar = psPar;
    if (propToHit) {
      MPlexLS propErr;
      MPlexQF msZ;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
      }

      propagateHelixToZMPlex(psErr, psPar, inChg, msZ, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperationEndcap(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
    } else {
      kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
    }
  }

kalmanPropagateAndComputeChi2Plane()

void mkfit::kalmanPropagateAndComputeChi2Plane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1088 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Calculate_Chi2, and propagateHelixToPlaneMPlex().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                {
    propPar = psPar;
    if (propToHit) {
      MPlexLS propErr;
      propagateHelixToPlaneMPlex(psErr, psPar, inChg, msPar, plNrm, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperationPlane(
          KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
    } else {
      kalmanOperationPlane(
          KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
    }
  }

kalmanPropagateAndUpdate()

void mkfit::kalmanPropagateAndUpdate	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 715 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), kalmanOperation(), KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

                                                      {
    if (propToHit) {
      MPlexLS propErr;
      MPlexLV propPar;
      MPlexQF msRad;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
      }

      propagateHelixToRMPlex(psErr, psPar, Chg, msRad, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperation(
          KFO_Update_Params | KFO_Local_Cov, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
    } else {
      kalmanOperation(
          KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
    }
    for (int n = 0; n < NN; ++n) {
      if (n < N_proc && outPar.At(n, 3, 0) < 0) {
        Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
        outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
      }
    }
  }

kalmanPropagateAndUpdateEndcap()

void mkfit::kalmanPropagateAndUpdateEndcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1344 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

                                                            {
    if (propToHit) {
      MPlexLS propErr;
      MPlexLV propPar;
      MPlexQF msZ;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
      }

      propagateHelixToZMPlex(psErr, psPar, Chg, msZ, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperationEndcap(KFO_Update_Params, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
    } else {
      kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
    }
    for (int n = 0; n < NN; ++n) {
      if (n < N_proc && outPar.At(n, 3, 0) < 0) {
        Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
        outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
      }
    }
  }

kalmanPropagateAndUpdatePlane()

void mkfit::kalmanPropagateAndUpdatePlane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1023 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToPlaneMPlex().

Referenced by mkfit::MkFinder::updateWithLoadedHit().

                                                           {
    if (propToHit) {
      MPlexLS propErr;
      MPlexLV propPar;
      propagateHelixToPlaneMPlex(psErr, psPar, Chg, msPar, plNrm, propErr, propPar, outFailFlag, N_proc, propFlags);

      kalmanOperationPlane(KFO_Update_Params | KFO_Local_Cov,
                           propErr,
                           propPar,
                           msErr,
                           msPar,
                           plNrm,
                           plDir,
                           outErr,
                           outPar,
                           dummy_chi2,
                           N_proc);
    } else {
      kalmanOperationPlane(KFO_Update_Params | KFO_Local_Cov,
                           psErr,
                           psPar,
                           msErr,
                           msPar,
                           plNrm,
                           plDir,
                           outErr,
                           outPar,
                           dummy_chi2,
                           N_proc);
    }
    for (int n = 0; n < NN; ++n) {
      if (outPar.At(n, 3, 0) < 0) {
        Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
        outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
      }
    }
  }

kalmanUpdate()

void mkfit::kalmanUpdate	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 705 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), KFO_Local_Cov, and KFO_Update_Params.

Referenced by mkfit::MkFitter::fitTracksWithInterSlurp().

                                      {
    kalmanOperation(KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
  }

kalmanUpdateEndcap()

void mkfit::kalmanUpdateEndcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 1334 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Update_Params.

                                            {
    kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
  }

kalmanUpdatePlane()

void mkfit::kalmanUpdatePlane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 1010 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Local_Cov, and KFO_Update_Params.

                                           {
    kalmanOperationPlane(
        KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, plNrm, plDir, outErr, outPar, dummy_chi2, N_proc);
  }

operator==()

template<class T , class U >

bool mkfit::operator==	(	const CcAlloc< T > &	a,
		const CcAlloc< U > &	b
	)

Definition at line 151 of file TrackStructures.h.

References a, and b.

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

passStripChargePCMfromTrack()

bool mkfit::passStripChargePCMfromTrack	(	int	itrack,
		bool	isBarrel,
		unsigned int	pcm,
		unsigned int	pcmMin,
		const MPlexLV &	pPar,
		const MPlexHS &	msErr
	)

Definition at line 1234 of file MkFinder.cc.

References funct::abs(), funct::cos(), dprint, f, PixelPluginsPhase0_cfi::isBarrel, mkfit::Hit::maxChargePerCM(), amptDefault_cfi::proj, funct::sin(), and mathSSE::sqrt().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                                                   {
    //skip the overflow case
    if (pcm >= Hit::maxChargePerCM())
      return true;

    float qSF;
    if (isBarrel) {  //project in x,y, assuming zero-error direction is in this plane
      const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
      const float hitT2inv = 1.f / hitT2;
      const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
                             msErr.constAt(itrack, 0, 1) * hitT2inv,
                             msErr.constAt(itrack, 1, 1) * hitT2inv};
      const bool detXY_OK =
          std::abs(proj[0] * proj[2] - proj[1] * proj[1]) < 0.1f;  //check that zero-direction is close
      const float cosP = cos(pPar.constAt(itrack, 4, 0));
      const float sinP = sin(pPar.constAt(itrack, 4, 0));
      const float sinT = std::abs(sin(pPar.constAt(itrack, 5, 0)));
      //qSF = sqrt[(px,py)*(1-proj)*(px,py)]/p = sinT*sqrt[(cosP,sinP)*(1-proj)*(cosP,sinP)].
      qSF = detXY_OK ? sinT * std::sqrt(std::abs(1.f + cosP * cosP * proj[0] + sinP * sinP * proj[2] -
                                                 2.f * cosP * sinP * proj[1]))
                     : 1.f;
    } else {  //project on z
      // p_zLocal/p = p_z/p = cosT
      qSF = std::abs(cos(pPar.constAt(itrack, 5, 0)));
    }

    const float qCorr = pcm * qSF;
    dprint("pcm " << pcm << " * " << qSF << " = " << qCorr << " vs " << pcmMin);
    return qCorr > pcmMin;
  }

print() [1/5]

void mkfit::print	(	std::string_view	label,
		const MeasurementState &	s
	)

Definition at line 8 of file Hit.cc.

References gather_cfg::cout, dumpMatrix(), label, and alignCSCRings::s.

Referenced by mkfit::Shell::Compare(), conformalFitMPlex(), print(), and mkfit::StdSeq::track_print().

                                                              {
    std::cout << label << std::endl;
    std::cout << "x: " << s.parameters()[0] << " y: " << s.parameters()[1] << " z: " << s.parameters()[2] << std::endl
              << "errors: " << std::endl;
    dumpMatrix(s.errors());
    std::cout << std::endl;
  }

print() [2/5]

void mkfit::print

(

const TrackState &

s

)

Definition at line 402 of file Track.cc.

References gather_cfg::cout, dumpMatrix(), and alignCSCRings::s.

                                  {
    std::cout << " x:  " << s.parameters[0] << " y:  " << s.parameters[1] << " z:  " << s.parameters[2] << std::endl
              << " px: " << s.parameters[3] << " py: " << s.parameters[4] << " pz: " << s.parameters[5] << std::endl
              << "valid: " << s.valid << " errors: " << std::endl;
    dumpMatrix(s.errors);
    std::cout << std::endl;
  }

print() [3/5]

void mkfit::print	(	std::string	pfx,
		int	itrack,
		const Track &	trk,
		bool	print_hits = false
	)

Definition at line 410 of file Track.cc.

References gather_cfg::cout, mkfit::Track::getHitIdx(), mkfit::Track::getHitLyr(), mps_fire::i, mkfit::TrackBase::label(), mkfit::Track::nFoundHits(), mkfit::Track::nTotalHits(), geometryDiffVisualizer::pfx, print(), and mkfit::TrackBase::state().

                                                                           {
    std::cout << std::endl
              << pfx << ": " << itrack << " hits: " << trk.nFoundHits() << " label: " << trk.label() << " State"
              << std::endl;
    print(trk.state());
    if (print_hits) {
      for (int i = 0; i < trk.nTotalHits(); ++i)
        printf("  %2d: lyr %2d idx %d\n", i, trk.getHitLyr(i), trk.getHitIdx(i));
    }
  }

print() [4/5]

void mkfit::print	(	std::string	pfx,
		const TrackState &	s
	)

Definition at line 421 of file Track.cc.

References gather_cfg::cout, geometryDiffVisualizer::pfx, print(), and alignCSCRings::s.

                                                 {
    std::cout << pfx << std::endl;
    print(s);
  }

print() [5/5]

void mkfit::print	(	std::string	pfx,
		int	itrack,
		const Track &	trk,
		const Event &	ev
	)

Definition at line 1065 of file Event.cc.

References gather_cfg::cout, makeMEIFBenchmarkPlots::ev, mkfit::Track::getHitOnTrack(), h, mps_fire::i, mkfit::TrackBase::label(), mkfit::Track::nFoundHits(), mkfit::Track::nTotalHits(), geometryDiffVisualizer::pfx, print(), and mkfit::TrackBase::state().

                                                                           {
    std::cout << std::endl
              << pfx << ": " << itrack << " hits: " << trk.nFoundHits() << " label: " << trk.label()
              << " State:" << std::endl;
    print(trk.state());

    for (int i = 0; i < trk.nTotalHits(); ++i) {
      auto hot = trk.getHitOnTrack(i);
      printf("  %2d: lyr %2d idx %5d", i, hot.layer, hot.index);
      if (hot.index >= 0) {
        auto &h = ev.layerHits_[hot.layer][hot.index];
        int hl = ev.simHitsInfo_[h.mcHitID()].mcTrackID_;
        printf("  %4d  %8.3f %8.3f %8.3f  r=%.3f\n", hl, h.x(), h.y(), h.z(), h.r());
      } else {
        printf("\n");
      }
    }
  }

propagateHelixToPlaneMPlex()

void mkfit::propagateHelixToPlaneMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexHV &	plPnt,
		const MPlexHV &	plNrm,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 1086 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), funct::cos(), debug, dprint_np, dprintf, g_debug, helixAtPlane(), Matriplex::hypot(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, funct::sin(), mathSSE::sqrt(), squashPhiMPlex(), funct::tan(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2Plane(), and kalmanPropagateAndUpdatePlane().

                                                              {
    // debug = true;

    outErr = inErr;
    outPar = inPar;

    MPlexQF pathL;
    MPlexLL errorProp;

    helixAtPlane(inPar, inChg, plPnt, plNrm, pathL, outPar, errorProp, outFailFlag, N_proc, pflags);

    for (int n = 0; n < NN; ++n) {
      dprint_np(
          n,
          "propagation to plane end, dump parameters\n"
              //<< "   D = " << s[n] << " alpha = " << s[n] * std::sin(inPar(n, 5, 0)) * inPar(n, 3, 0) * kinv[n] << " kinv = " << kinv[n] << std::endl
              << "   pos = " << outPar(n, 0, 0) << " " << outPar(n, 1, 0) << " " << outPar(n, 2, 0) << "\t\t r="
              << std::sqrt(outPar(n, 0, 0) * outPar(n, 0, 0) + outPar(n, 1, 0) * outPar(n, 1, 0)) << std::endl
              << "   mom = " << outPar(n, 3, 0) << " " << outPar(n, 4, 0) << " " << outPar(n, 5, 0) << std::endl
              << " cart= " << std::cos(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
              << std::sin(outPar(n, 4, 0)) / outPar(n, 3, 0) << " " << 1. / (outPar(n, 3, 0) * tan(outPar(n, 5, 0)))
              << "\t\tpT=" << 1. / std::abs(outPar(n, 3, 0)) << std::endl);
    }

#ifdef DEBUG
    if (debug && g_debug) {
      for (int kk = 0; kk < N_proc; ++kk) {
        dprintf("inPar %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          dprintf("%8f ", inPar.constAt(kk, i, 0));
        }
        dprintf("\n");
        dprintf("inErr %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", inErr.constAt(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");

        for (int kk = 0; kk < N_proc; ++kk) {
          dprintf("plNrm %d\n", kk);
          for (int j = 0; j < 3; ++j)
            dprintf("%8f ", plNrm.constAt(kk, 0, j));
        }
        dprintf("\n");

        for (int kk = 0; kk < N_proc; ++kk) {
          dprintf("pathL %d\n", kk);
          for (int j = 0; j < 1; ++j)
            dprintf("%8f ", pathL.constAt(kk, 0, j));
        }
        dprintf("\n");

        dprintf("errorProp %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", errorProp.At(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");
      }
    }
#endif

    // Matriplex version of:
    // result.errors = ROOT::Math::Similarity(errorProp, outErr);
    MPlexLL temp;
    MultHelixPropFull(errorProp, outErr, temp);
    MultHelixPropTranspFull(errorProp, temp, outErr);

#ifdef DEBUG
    if (debug && g_debug) {
      for (int kk = 0; kk < N_proc; ++kk) {
        dprintf("outErr %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", outErr.constAt(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");
      }
    }
#endif

    if (pflags.apply_material) {
      MPlexQF hitsRl;
      MPlexQF hitsXi;
      MPlexQF propSign;

      const TrackerInfo& tinfo = *pflags.tracker_info;

#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        if (n >= N_proc || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
          hitsRl(n, 0, 0) = 0.f;
          hitsXi(n, 0, 0) = 0.f;
        } else {
          const float hypo = std::hypot(outPar(n, 0, 0), outPar(n, 1, 0));
          auto mat = tinfo.material_checked(std::abs(outPar(n, 2, 0)), hypo);
          hitsRl(n, 0, 0) = mat.radl;
          hitsXi(n, 0, 0) = mat.bbxi;
        }
        propSign(n, 0, 0) = (pathL(n, 0, 0) > 0.f ? 1.f : -1.f);
      }
      applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
#ifdef DEBUG
      if (debug && g_debug) {
        for (int kk = 0; kk < N_proc; ++kk) {
          dprintf("propSign %d\n", kk);
          for (int i = 0; i < 1; ++i) {
            dprintf("%8f ", propSign.constAt(kk, i, 0));
          }
          dprintf("\n");
          dprintf("plNrm %d\n", kk);
          for (int i = 0; i < 3; ++i) {
            dprintf("%8f ", plNrm.constAt(kk, i, 0));
          }
          dprintf("\n");
          dprintf("outErr(after material) %d\n", kk);
          for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 6; ++j)
              dprintf("%8f ", outErr.constAt(kk, i, j));
            dprintf("\n");
          }
          dprintf("\n");
        }
      }
#endif
    }

    squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

    // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
    // state to input when propagation fails -- as was the default before.
    // if (pflags.copy_input_state_on_fail) {
    for (int i = 0; i < N_proc; ++i) {
      if (outFailFlag(i, 0, 0)) {
        outPar.copySlot(i, inPar);
        outErr.copySlot(i, inErr);
      }
    }
    // }
  }

propagateHelixToRMPlex()

void mkfit::propagateHelixToRMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 494 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), funct::cos(), debug, dprintf, g_debug, helixAtRFromIterativeCCS(), hipo(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, funct::sin(), squashPhiMPlex(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2(), kalmanPropagateAndUpdate(), mkfit::MkBase::propagateTracksToHitR(), and mkfit::MkBase::propagateTracksToR().

                                                          {
    // bool debug = true;

    // This is used further down when calculating similarity with errorProp (and before in DEBUG).
    // MT: I don't think this really needed if we use inErr where required.
    outErr = inErr;
    // This requirement for helixAtRFromIterativeCCS_impl() and for helixAtRFromIterativeCCSFullJac().
    // MT: This should be properly handled in both functions (expecting input in output parameters sucks).
    outPar = inPar;

    MPlexLL errorProp;

    helixAtRFromIterativeCCS(inPar, inChg, msRad, outPar, errorProp, outFailFlag, N_proc, pflags);

#ifdef DEBUG
    if (debug && g_debug) {
      for (int kk = 0; kk < N_proc; ++kk) {
        dprintf("outErr before prop %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", outErr.At(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");

        dprintf("errorProp %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", errorProp.At(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");
      }
    }
#endif

    // MultHelixProp can be optimized for CCS coordinates, see GenMPlexOps.pl
    MPlexLL temp;
    MultHelixProp(errorProp, outErr, temp);
    MultHelixPropTransp(errorProp, temp, outErr);
    // can replace with: MultHelixPropFull(errorProp, outErr, temp); MultHelixPropTranspFull(errorProp, temp, outErr);

    if (pflags.apply_material) {
      MPlexQF hitsRl;
      MPlexQF hitsXi;
      MPlexQF propSign;

      const TrackerInfo& tinfo = *pflags.tracker_info;

#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        if (n < N_proc) {
          if (outFailFlag(n, 0, 0) || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
            hitsRl(n, 0, 0) = 0.f;
            hitsXi(n, 0, 0) = 0.f;
          } else {
            auto mat = tinfo.material_checked(std::abs(outPar(n, 2, 0)), msRad(n, 0, 0));
            hitsRl(n, 0, 0) = mat.radl;
            hitsXi(n, 0, 0) = mat.bbxi;
          }
          const float r0 = hipo(inPar(n, 0, 0), inPar(n, 1, 0));
          const float r = msRad(n, 0, 0);
          propSign(n, 0, 0) = (r > r0 ? 1. : -1.);
        }
      }
      MPlexHV plNrm;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        plNrm(n, 0, 0) = std::cos(outPar.constAt(n, 4, 0));
        plNrm(n, 1, 0) = std::sin(outPar.constAt(n, 4, 0));
        plNrm(n, 2, 0) = 0.f;
      }
      applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
    }

    squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

    // Matriplex version of:
    // result.errors = ROOT::Math::Similarity(errorProp, outErr);

    /*
     // To be used with: MPT_DIM = 1
     if (fabs(sqrt(outPar[0]*outPar[0]+outPar[1]*outPar[1]) - msRad[0]) > 0.0001)
     {
       std::cout << "DID NOT GET TO R, FailFlag=" << failFlag[0]
                 << " dR=" << msRad[0] - std::hypot(outPar[0],outPar[1])
                 << " r="  << msRad[0] << " rin=" << std::hypot(inPar[0],inPar[1]) << " rout=" << std::hypot(outPar[0],outPar[1])
                 << std::endl;
       // std::cout << "    pt=" << pt << " pz=" << inPar.At(n, 2) << std::endl;
     }
   */

    // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
    // state to input when propagation fails -- as was the default before.
    // if (pflags.copy_input_state_on_fail) {
    for (int i = 0; i < N_proc; ++i) {
      if (outFailFlag(i, 0, 0)) {
        outPar.copySlot(i, inPar);
        outErr.copySlot(i, inErr);
      }
    }
    // }
  }

propagateHelixToZMPlex()

void mkfit::propagateHelixToZMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msZ,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 609 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), debug, dprintf, g_debug, helixAtZ(), Matriplex::hypot(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, squashPhiMPlex(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdateEndcap(), mkfit::MkBase::propagateTracksToHitZ(), mkfit::MkBase::propagateTracksToPCAZ(), and mkfit::MkBase::propagateTracksToZ().

                                                          {
    // debug = true;

    outErr = inErr;
    outPar = inPar;

    MPlexLL errorProp;

    //helixAtZ_new(inPar, inChg, msZ, outPar, errorProp, outFailFlag, N_proc, pflags);
    helixAtZ(inPar, inChg, msZ, outPar, errorProp, outFailFlag, N_proc, pflags);

#ifdef DEBUG
    if (debug && g_debug) {
      for (int kk = 0; kk < N_proc; ++kk) {
        dprintf("inPar %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          dprintf("%8f ", inPar.constAt(kk, i, 0));
        }
        dprintf("\n");

        dprintf("inErr %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", inErr.constAt(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");

        dprintf("errorProp %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", errorProp.At(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");
      }
    }
#endif

#ifdef DEBUG
    if (debug && g_debug) {
      for (int kk = 0; kk < N_proc; ++kk) {
        dprintf("outErr %d\n", kk);
        for (int i = 0; i < 6; ++i) {
          for (int j = 0; j < 6; ++j)
            dprintf("%8f ", outErr.constAt(kk, i, j));
          dprintf("\n");
        }
        dprintf("\n");
      }
    }
#endif

    // Matriplex version of: result.errors = ROOT::Math::Similarity(errorProp, outErr);
    MPlexLL temp;
    MultHelixPropEndcap(errorProp, outErr, temp);
    MultHelixPropTranspEndcap(errorProp, temp, outErr);
    // can replace with: MultHelixPropFull(errorProp, outErr, temp); MultHelixPropTranspFull(errorProp, temp, outErr);

    if (pflags.apply_material) {
      MPlexQF hitsRl;
      MPlexQF hitsXi;
      MPlexQF propSign;

      const TrackerInfo& tinfo = *pflags.tracker_info;

#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        if (n >= N_proc || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
          hitsRl(n, 0, 0) = 0.f;
          hitsXi(n, 0, 0) = 0.f;
        } else {
          const float hypo = std::hypot(outPar(n, 0, 0), outPar(n, 1, 0));
          auto mat = tinfo.material_checked(std::abs(msZ(n, 0, 0)), hypo);
          hitsRl(n, 0, 0) = mat.radl;
          hitsXi(n, 0, 0) = mat.bbxi;
        }
        if (n < N_proc) {
          const float zout = msZ.constAt(n, 0, 0);
          const float zin = inPar.constAt(n, 2, 0);
          propSign(n, 0, 0) = (std::abs(zout) > std::abs(zin) ? 1.f : -1.f);
        }
      }
      MPlexHV plNrm;
#pragma omp simd
      for (int n = 0; n < NN; ++n) {
        plNrm(n, 0, 0) = 0.f;
        plNrm(n, 1, 0) = 0.f;
        plNrm(n, 2, 0) = 1.f;
      }
      applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
#ifdef DEBUG
      if (debug && g_debug) {
        for (int kk = 0; kk < N_proc; ++kk) {
          dprintf("propSign %d\n", kk);
          for (int i = 0; i < 1; ++i) {
            dprintf("%8f ", propSign.constAt(kk, i, 0));
          }
          dprintf("\n");
          dprintf("plNrm %d\n", kk);
          for (int i = 0; i < 3; ++i) {
            dprintf("%8f ", plNrm.constAt(kk, i, 0));
          }
          dprintf("\n");
          dprintf("outErr(after material) %d\n", kk);
          for (int i = 0; i < 6; ++i) {
            for (int j = 0; j < 6; ++j)
              dprintf("%8f ", outErr.constAt(kk, i, j));
            dprintf("\n");
          }
          dprintf("\n");
        }
      }
#endif
    }

    squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|

    // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
    // state to input when propagation fails -- as was the default before.
    // if (pflags.copy_input_state_on_fail) {
    for (int i = 0; i < N_proc; ++i) {
      if (outFailFlag(i, 0, 0)) {
        outPar.copySlot(i, inPar);
        outErr.copySlot(i, inErr);
      }
    }
    // }
  }

propagateLineToRMPlex()

void mkfit::propagateLineToRMPlex	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 19 of file PropagationMPlex.cc.

References A, B, dprint_np, hipo(), N, dqmiodumpmetadata::n, NN, AlCaHLTBitMon_ParallelJobs::p, DiDispStaMuonMonitor_cfi::pt, and mathSSE::sqrt().

                                               {
    // XXX Regenerate parts below with a script.

    const Matriplex::idx_t N = NN;

#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      const float cosA = (psPar[0 * N + n] * psPar[3 * N + n] + psPar[1 * N + n] * psPar[4 * N + n]) /
                         (std::sqrt((psPar[0 * N + n] * psPar[0 * N + n] + psPar[1 * N + n] * psPar[1 * N + n]) *
                                    (psPar[3 * N + n] * psPar[3 * N + n] + psPar[4 * N + n] * psPar[4 * N + n])));
      const float dr = (hipo(msPar[0 * N + n], msPar[1 * N + n]) - hipo(psPar[0 * N + n], psPar[1 * N + n])) / cosA;

      dprint_np(n, "propagateLineToRMPlex dr=" << dr);

      const float pt = hipo(psPar[3 * N + n], psPar[4 * N + n]);
      const float p = dr / pt;  // path
      const float psq = p * p;

      outPar[0 * N + n] = psPar[0 * N + n] + p * psPar[3 * N + n];
      outPar[1 * N + n] = psPar[1 * N + n] + p * psPar[4 * N + n];
      outPar[2 * N + n] = psPar[2 * N + n] + p * psPar[5 * N + n];
      outPar[3 * N + n] = psPar[3 * N + n];
      outPar[4 * N + n] = psPar[4 * N + n];
      outPar[5 * N + n] = psPar[5 * N + n];

      {
        const MPlexLS& A = psErr;
        MPlexLS& B = outErr;

        B.fArray[0 * N + n] = A.fArray[0 * N + n];
        B.fArray[1 * N + n] = A.fArray[1 * N + n];
        B.fArray[2 * N + n] = A.fArray[2 * N + n];
        B.fArray[3 * N + n] = A.fArray[3 * N + n];
        B.fArray[4 * N + n] = A.fArray[4 * N + n];
        B.fArray[5 * N + n] = A.fArray[5 * N + n];
        B.fArray[6 * N + n] = A.fArray[6 * N + n] + p * A.fArray[0 * N + n];
        B.fArray[7 * N + n] = A.fArray[7 * N + n] + p * A.fArray[1 * N + n];
        B.fArray[8 * N + n] = A.fArray[8 * N + n] + p * A.fArray[3 * N + n];
        B.fArray[9 * N + n] =
            A.fArray[9 * N + n] + p * (A.fArray[6 * N + n] + A.fArray[6 * N + n]) + psq * A.fArray[0 * N + n];
        B.fArray[10 * N + n] = A.fArray[10 * N + n] + p * A.fArray[1 * N + n];
        B.fArray[11 * N + n] = A.fArray[11 * N + n] + p * A.fArray[2 * N + n];
        B.fArray[12 * N + n] = A.fArray[12 * N + n] + p * A.fArray[4 * N + n];
        B.fArray[13 * N + n] =
            A.fArray[13 * N + n] + p * (A.fArray[7 * N + n] + A.fArray[10 * N + n]) + psq * A.fArray[1 * N + n];
        B.fArray[14 * N + n] =
            A.fArray[14 * N + n] + p * (A.fArray[11 * N + n] + A.fArray[11 * N + n]) + psq * A.fArray[2 * N + n];
        B.fArray[15 * N + n] = A.fArray[15 * N + n] + p * A.fArray[3 * N + n];
        B.fArray[16 * N + n] = A.fArray[16 * N + n] + p * A.fArray[4 * N + n];
        B.fArray[17 * N + n] = A.fArray[17 * N + n] + p * A.fArray[5 * N + n];
        B.fArray[18 * N + n] =
            A.fArray[18 * N + n] + p * (A.fArray[8 * N + n] + A.fArray[15 * N + n]) + psq * A.fArray[3 * N + n];
        B.fArray[19 * N + n] =
            A.fArray[19 * N + n] + p * (A.fArray[12 * N + n] + A.fArray[16 * N + n]) + psq * A.fArray[4 * N + n];
        B.fArray[20 * N + n] =
            A.fArray[20 * N + n] + p * (A.fArray[17 * N + n] + A.fArray[17 * N + n]) + psq * A.fArray[5 * N + n];
      }

      dprint_np(n, "propagateLineToRMPlex arrive at r=" << hipo(outPar[0 * N + n], outPar[1 * N + n]));
    }
  }

run_OneIteration()

void mkfit::run_OneIteration	(	const TrackerInfo &	trackerInfo,
		const IterationConfig &	itconf,
		const EventOfHits &	eoh,
		const std::vector< const std::vector< bool > *> &	hit_masks,
		MkBuilder &	builder,
		TrackVec &	seeds,
		TrackVec &	out_tracks,
		bool	do_seed_clean,
		bool	do_backward_fit,
		bool	do_remove_duplicates
	)

Definition at line 29 of file runFunctions.cc.

References mkfit::MkBuilder::backwardFit(), mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), mkfit::MkBuilder::compactifyHitStorageForBestCand(), mkfit::MkBuilder::end_event(), mkfit::MkBuilder::endBkwSearch(), mkfit::MkBuilder::export_best_comb_cands(), mkfit::MkBuilder::filter_comb_cands(), mkfit::MkBuilder::find_tracks_load_seeds(), mkfit::MkBuilder::findTracksCloneEngine(), mkfit::SteeringParams::IT_BkwSearch, mkfit::IterationConfig::m_backward_drop_seed_hits, mkfit::IterationConfig::m_backward_fit_min_hits, mkfit::IterationConfig::m_backward_search, mkfit::IterationConfig::m_duplicate_cleaner, mkfit::IterationConfig::m_post_bkfit_filter, mkfit::IterationConfig::m_pre_bkfit_filter, mkfit::IterationConfig::m_requires_seed_hit_sorting, mkfit::IterationConfig::m_seed_cleaner, mkfit::EventOfHits::refBeamSpot(), mkfit::MkBuilder::release_memory(), alignCSCRings::s, mkfit::MkBuilder::seed_post_cleaning(), and HLT_2024v12_cff::seeds.

Referenced by MkFitProducer::produce().

                                                   {
    IterationMaskIfcCmssw it_mask_ifc(trackerInfo, hit_masks);

    MkJob job({trackerInfo, itconf, eoh, eoh.refBeamSpot(), &it_mask_ifc});

    builder.begin_event(&job, nullptr, __func__);

    // Seed cleaning not done on all iterations.
    do_seed_clean = do_seed_clean && itconf.m_seed_cleaner;

    if (do_seed_clean)
      itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());

    // Check nans in seeds -- this should not be needed when Slava fixes
    // the track parameter coordinate transformation.
    builder.seed_post_cleaning(seeds);

    if (itconf.m_requires_seed_hit_sorting) {
      for (auto &s : seeds)
        s.sortHitsByLayer();  // sort seed hits for the matched hits (I hope it works here)
    }

    builder.find_tracks_load_seeds(seeds, do_seed_clean);

    builder.findTracksCloneEngine();

    // Pre backward-fit filtering.
    filter_candidates_func pre_filter;
    if (do_backward_fit && itconf.m_pre_bkfit_filter)
      pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
        return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
      };
    else if (itconf.m_pre_bkfit_filter)
      pre_filter = itconf.m_pre_bkfit_filter;
    else if (do_backward_fit)
      pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
    // pre_filter can be null if we are not doing backward fit as nan_n_silly will be run below.
    if (pre_filter)
      builder.filter_comb_cands(pre_filter, true);

    job.switch_to_backward();

    if (do_backward_fit) {
      if (itconf.m_backward_search) {
        builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
      }

      builder.backwardFit();

      if (itconf.m_backward_search) {
        builder.beginBkwSearch();
        builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
      }
    }

    // Post backward-fit filtering.
    filter_candidates_func post_filter;
    if (do_backward_fit && itconf.m_post_bkfit_filter)
      post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
        return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
      };
    else
      post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
    // post_filter is always at least doing nan_n_silly filter.
    builder.filter_comb_cands(post_filter, true);

    if (do_backward_fit && itconf.m_backward_search)
      builder.endBkwSearch();

    builder.export_best_comb_cands(out_tracks, true);

    if (do_remove_duplicates && itconf.m_duplicate_cleaner) {
      itconf.m_duplicate_cleaner(out_tracks, itconf);
    }

    builder.end_event();
    builder.release_memory();
  }

runBtpCe_MultiIter()

std::vector< double > mkfit::runBtpCe_MultiIter	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder,
		int	n
	)

Definition at line 417 of file buildtestMPlex.cc.

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFit(), mkfit::Config::backwardSearch, mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), nano_mu_local_reco_cff::bool, mkfit::Config::cmssw_val, mkfit::MkBuilder::compactifyHitStorageForBestCand(), dtime(), mkfit::MkBuilder::end_event(), mkfit::MkBuilder::endBkwSearch(), makeMEIFBenchmarkPlots::ev, mkfit::MkBuilder::export_tracks(), mkfit::MkBuilder::filter_comb_cands(), spr::find(), mkfit::MkBuilder::find_tracks_load_seeds(), mkfit::MkBuilder::findTracksCloneEngine(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, mkfit::SteeringParams::IT_BkwSearch, mkfit::Config::ItrInfo, mkfit::IterationConfig::m_backward_drop_seed_hits, mkfit::IterationConfig::m_backward_fit_min_hits, mkfit::IterationConfig::m_backward_search, mkfit::IterationConfig::m_duplicate_cleaner, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_post_bkfit_filter, mkfit::IterationConfig::m_pre_bkfit_filter, mkfit::IterationConfig::m_requires_seed_hit_sorting, mkfit::IterationConfig::m_seed_cleaner, mkfit::IterationConfig::m_track_algorithm, eostools::move(), dqmiodumpmetadata::n, mkfit::StdSeq::prep_simtracks(), mkfit::StdSeq::Quality::quality_val(), mkfit::Config::quality_val, mkfit::MkBuilder::ref_tracks_nc(), mkfit::EventOfHits::refBeamSpot(), mkfit::MkBuilder::release_memory(), mkfit::StdSeq::root_val(), alignCSCRings::s, mkfit::MkBuilder::seed_post_cleaning(), HLT_2024v12_cff::seeds, mkfit::MkBuilder::select_best_comb_cands(), mkfit::Config::sim_val, submitPVValidationJobs::t, hcalRecHitTable_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                                     {
    std::vector<double> timevec;
    if (n <= 0)
      return timevec;
    timevec.resize(n + 1, 0.0);

    const bool validation_on = (Config::sim_val || Config::quality_val);

    TrackVec seeds_used;
    TrackVec seeds1;

    if (validation_on) {
      for (auto const &s : ev.seedTracks_) {
        //keep seeds form the first n iterations for processing
        if (std::find(algorithms, algorithms + n, s.algoint()) != algorithms + n)
          seeds1.push_back(s);
      }
      ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
      ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
    }

    IterationMaskIfc mask_ifc;
    TrackVec seeds;
    TrackVec tmp_tvec;

    for (int it = 0; it <= n - 1; ++it) {
      const IterationConfig &itconf = Config::ItrInfo[it];

      // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
      // and optionally comment out ev.fill_hitmask_bool_vectors() call.

      ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);

      MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});

      builder.begin_event(&job, &ev, __func__);

      {  // We could partition seeds once, store beg, end for each iteration in a map or vector.
        seeds.clear();
        int nc = 0;
        for (auto &s : ev.seedTracks_) {
          if (s.algoint() == itconf.m_track_algorithm) {
            if (itconf.m_requires_seed_hit_sorting) {
              s.sortHitsByLayer();
            }
            seeds.push_back(s);
            ++nc;
          } else if (nc > 0)
            break;
        }
      }

      bool do_seed_clean = bool(itconf.m_seed_cleaner);

      if (do_seed_clean)
        itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());

      builder.seed_post_cleaning(seeds);

      // Add protection in case no seeds are found for iteration
      if (seeds.size() <= 0)
        continue;
      ev.setCurrentSeedTracks(seeds);
      ev.simLabelForCurrentSeed(0);

      builder.find_tracks_load_seeds(seeds, do_seed_clean);

      double time = dtime();

      builder.findTracksCloneEngine();

      timevec[it] = dtime() - time;
      timevec[n] += timevec[it];

      // Print min and max size of hots vectors of CombCands.
      // builder.find_min_max_hots_size();

      if (validation_on)
        seeds_used.insert(seeds_used.end(), seeds.begin(), seeds.end());  //cleaned seeds need to be stored somehow

      // Pre backward-fit filtering.
      // Note -- slightly different logic than run_OneIteration as we always do nan filters for
      // export for validation.
      filter_candidates_func pre_filter;
      if (itconf.m_pre_bkfit_filter)
        pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
          return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
        };
      else
        pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
      // pre_filter is always at least doing nan_n_silly filter.
      builder.filter_comb_cands(pre_filter, true);

      builder.select_best_comb_cands();

      {
        builder.export_tracks(tmp_tvec);
        if (itconf.m_duplicate_cleaner)
          itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);
        ev.candidateTracks_.reserve(ev.candidateTracks_.size() + tmp_tvec.size());
        for (auto &&t : tmp_tvec)
          ev.candidateTracks_.emplace_back(std::move(t));
        tmp_tvec.clear();
      }

      job.switch_to_backward();

      // now do backwards fit... do we want to time this section?
      if (Config::backwardFit) {
        // a) TrackVec version:
        // builder.backwardFitBH();

        // b) Version that runs on CombCand / TrackCand
        const bool do_backward_search = Config::backwardSearch && itconf.m_backward_search;

        // We copy seed-hits into Candidates ... now we have to remove them so backward fit stops
        // before reaching seeding region. Ideally, we wouldn't add them in the first place but
        // if we want to export full tracks above we need to hold on to them (alternatively, we could
        // have a pointer to seed track in CombCandidate and copy them from there).
        if (do_backward_search)
          builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);

        builder.backwardFit();

        if (do_backward_search) {
          builder.beginBkwSearch();
          builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
        }

        // Post backward-fit filtering.
        // Note -- slightly different logic than run_OneIteration as we export both pre and post
        // backward-fit tracks.
        filter_candidates_func post_filter;
        if (itconf.m_post_bkfit_filter)
          post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
            return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
          };
        else
          post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
        // post_filter is always at least doing nan_n_silly filter.
        builder.filter_comb_cands(post_filter, true);

        if (do_backward_search)
          builder.endBkwSearch();

        builder.select_best_comb_cands(true);  // true -> clear m_tracks as they were already filled once above

        if (itconf.m_duplicate_cleaner)
          itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);

        builder.export_tracks(ev.fitTracks_);
      }
      ev.resetCurrentSeedTracks();

      builder.end_event();
    }

    // MIMI - Fake back event pointer for final processing (that should be done elsewhere)
    MkJob job({Config::TrkInfo, Config::ItrInfo[0], eoh, eoh.refBeamSpot()});
    builder.begin_event(&job, &ev, __func__);

    if (validation_on) {
      StdSeq::prep_simtracks(&ev);
      //swap for the cleaned seeds
      ev.seedTracks_.swap(seeds_used);
    }

    check_nan_n_silly_candidates(ev);

    if (Config::backwardFit)
      check_nan_n_silly_bkfit(ev);

    // validation section
    if (Config::quality_val) {
      StdSeq::Quality qval;
      qval.quality_val(&ev);
    } else if (Config::sim_val || Config::cmssw_val) {
      StdSeq::root_val(&ev);
    }

    // ev.print_tracks(ev.candidateTracks_, true);

    // MIMI Unfake.
    builder.end_event();

    // In CMSSW runOneIter we now release memory for comb-cands:
    builder.release_memory();

    return timevec;
  }

runBuildingTestPlexBestHit()

double mkfit::runBuildingTestPlexBestHit	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 108 of file buildtestMPlex.cc.

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFitBH(), mkfit::MkBuilder::begin_event(), mkfit::Config::cmssw_val, dtime(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, spr::find(), mkfit::MkBuilder::find_tracks_load_seeds_BH(), mkfit::MkBuilder::findTracksBestHit(), mkfit::Config::ItrInfo, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_track_algorithm, mkfit::StdSeq::Quality::quality_val(), mkfit::Config::quality_val, mkfit::MkBuilder::ref_tracks(), mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val(), alignCSCRings::s, mkfit::Config::sim_val, hcalRecHitTable_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                           {
    const IterationConfig &itconf = Config::ItrInfo[0];

    const bool validation_on = (Config::sim_val || Config::quality_val);

    TrackVec seeds1;
    if (validation_on) {
      unsigned int algorithms[] = {4};  //only initialStep

      for (auto const &s : ev.seedTracks_) {
        //keep seeds form the first iteration for processing
        if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
          seeds1.push_back(s);
      }
      ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
      ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
    }

    IterationMaskIfc mask_ifc;

    // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
    // and optionally comment out ev.fill_hitmask_bool_vectors() call.

    ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);

    MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});

    builder.begin_event(&job, &ev, __func__);

    bool seeds_sorted = false;
    // CCCC builder.PrepareSeeds();

    // EventOfCandidates event_of_cands;
    builder.find_tracks_load_seeds_BH(ev.seedTracks_, seeds_sorted);

#ifdef USE_VTUNE_PAUSE
    __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
    __itt_resume();
#endif

    double time = dtime();

    builder.findTracksBestHit();

    time = dtime() - time;

#ifdef USE_VTUNE_PAUSE
    __itt_pause();
    __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
#endif

    // Hack, get the tracks out.
    ev.candidateTracks_ = builder.ref_tracks();

    // For best hit, the candidateTracks_ vector is the direct input to the backward fit so only need to do clean_duplicates once
    if (Config::quality_val || Config::sim_val || Config::cmssw_val) {
      //Mark tracks as duplicates; if within CMSSW, remove duplicate tracks before backward fit
      // CCCC if (Config::removeDuplicates) {
      // CCCC   StdSeq::clean_duplicates(ev.candidateTracks_);
      // CCCC }
    }

    job.switch_to_backward();

    // now do backwards fit... do we want to time this section?
    if (Config::backwardFit) {
      builder.backwardFitBH();
      ev.fitTracks_ = builder.ref_tracks();
    }

    if (Config::quality_val) {
      StdSeq::Quality qval;
      qval.quality_val(&ev);
    } else if (Config::sim_val || Config::cmssw_val) {
      StdSeq::root_val(&ev);
    }

    builder.end_event();

    // ev.print_tracks(ev.candidateTracks_, true);

    if (validation_on) {
      ev.seedTracks_.swap(seeds1);
    }

    return time;
  }

runBuildingTestPlexCloneEngine()

double mkfit::runBuildingTestPlexCloneEngine	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 297 of file buildtestMPlex.cc.

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFitBH(), mkfit::MkBuilder::begin_event(), mkfit::Config::cmssw_val, dtime(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, mkfit::MkBuilder::export_best_comb_cands(), spr::find(), mkfit::MkBuilder::find_tracks_load_seeds(), mkfit::MkBuilder::findTracksCloneEngine(), mkfit::Config::ItrInfo, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_track_algorithm, mkfit::StdSeq::Quality::quality_val(), mkfit::Config::quality_val, mkfit::MkBuilder::ref_tracks(), mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val(), alignCSCRings::s, mkfit::MkBuilder::select_best_comb_cands(), mkfit::Config::sim_val, hcalRecHitTable_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                               {
    const IterationConfig &itconf = Config::ItrInfo[0];

    const bool validation_on = (Config::sim_val || Config::quality_val);

    TrackVec seeds1;
    if (validation_on) {
      unsigned int algorithms[] = {4};  //only initialStep

      for (auto const &s : ev.seedTracks_) {
        //keep seeds form the first iteration for processing
        if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
          seeds1.push_back(s);
      }
      ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
      ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
    }

    IterationMaskIfc mask_ifc;

    // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
    // and optionally comment out ev.fill_hitmask_bool_vectors() call.

    ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);

    MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});

    builder.begin_event(&job, &ev, __func__);

    bool seeds_sorted = false;
    // CCCC builder.PrepareSeeds();
    ev.setCurrentSeedTracks(ev.seedTracks_);

    builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);

#ifdef USE_VTUNE_PAUSE
    __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
    __itt_resume();
#endif

    double time = dtime();

    builder.findTracksCloneEngine();

    time = dtime() - time;

#ifdef USE_VTUNE_PAUSE
    __itt_pause();
    __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
#endif

    check_nan_n_silly_candidates(ev);

    // first store candidate tracks - needed for BH backward fit and root_validation
    ev.candidateTracks_.clear();
    builder.export_best_comb_cands(ev.candidateTracks_);

    job.switch_to_backward();

    // now do backwards fit... do we want to time this section?
    if (Config::backwardFit) {
      // a) TrackVec version:
      builder.select_best_comb_cands();
      builder.backwardFitBH();
      ev.fitTracks_ = builder.ref_tracks();

      // b) Version that runs on CombCand / TrackCand
      // builder.backwardFit();
      // builder.quality_store_tracks(ev.fitTracks_);

      check_nan_n_silly_bkfit(ev);
    }

    // CCCC StdSeq::handle_duplicates(&ev);

    // validation section
    if (Config::quality_val) {
      StdSeq::Quality qval;
      qval.quality_val(&ev);
    } else if (Config::sim_val || Config::cmssw_val) {
      StdSeq::root_val(&ev);
    }

    ev.resetCurrentSeedTracks();

    builder.end_event();

    // ev.print_tracks(ev.candidateTracks_, true);

    if (validation_on) {
      ev.seedTracks_.swap(seeds1);
    }

    return time;
  }

runBuildingTestPlexDumbCMSSW()

void mkfit::runBuildingTestPlexDumbCMSSW	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 90 of file buildtestMPlex.cc.

References mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, mkfit::Config::ItrInfo, mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val_dumb_cmssw(), mkfit::Config::sim_val_for_cmssw, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                           {
    const IterationConfig &itconf = Config::ItrInfo[0];

    MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot()});

    builder.begin_event(&job, &ev, __func__);

    if (Config::sim_val_for_cmssw) {
      StdSeq::root_val_dumb_cmssw(&ev);
    }

    builder.end_event();
  }

runBuildingTestPlexStandard()

double mkfit::runBuildingTestPlexStandard	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 200 of file buildtestMPlex.cc.

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFitBH(), mkfit::MkBuilder::begin_event(), mkfit::Config::cmssw_val, dtime(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, mkfit::MkBuilder::export_best_comb_cands(), spr::find(), mkfit::MkBuilder::find_tracks_load_seeds(), mkfit::MkBuilder::findTracksStandard(), mkfit::Config::ItrInfo, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_track_algorithm, mkfit::StdSeq::Quality::quality_val(), mkfit::Config::quality_val, mkfit::MkBuilder::ref_tracks(), mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val(), alignCSCRings::s, mkfit::MkBuilder::select_best_comb_cands(), mkfit::Config::sim_val, hcalRecHitTable_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                            {
    const IterationConfig &itconf = Config::ItrInfo[0];

    const bool validation_on = (Config::sim_val || Config::quality_val);

    TrackVec seeds1;
    if (validation_on) {
      unsigned int algorithms[] = {4};  //only initialStep

      for (auto const &s : ev.seedTracks_) {
        //keep seeds form the first iteration for processing
        if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
          seeds1.push_back(s);
      }
      ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
      ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
    }

    IterationMaskIfc mask_ifc;

    // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
    // and optionally comment out ev.fill_hitmask_bool_vectors() call.

    ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);

    MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});

    builder.begin_event(&job, &ev, __func__);

    bool seeds_sorted = false;
    // CCCC builder.PrepareSeeds();
    ev.setCurrentSeedTracks(ev.seedTracks_);
    ev.simLabelForCurrentSeed(0);

    builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);

#ifdef USE_VTUNE_PAUSE
    __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
    __itt_resume();
#endif

    double time = dtime();

    builder.findTracksStandard();

    time = dtime() - time;

#ifdef USE_VTUNE_PAUSE
    __itt_pause();
    __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
#endif

    check_nan_n_silly_candidates(ev);

    // first store candidate tracks
    ev.candidateTracks_.clear();
    builder.export_best_comb_cands(ev.candidateTracks_);

    job.switch_to_backward();

    // now do backwards fit... do we want to time this section?
    if (Config::backwardFit) {
      // Using the TrackVec version until we home in on THE backward fit etc.
      // builder.backwardFit();
      builder.select_best_comb_cands();
      builder.backwardFitBH();
      ev.fitTracks_ = builder.ref_tracks();

      check_nan_n_silly_bkfit(ev);
    }

    // CCCC StdSeq::handle_duplicates(&ev);

    if (Config::quality_val) {
      StdSeq::Quality qval;
      qval.quality_val(&ev);
    } else if (Config::sim_val || Config::cmssw_val) {
      StdSeq::root_val(&ev);
    }

    ev.resetCurrentSeedTracks();

    builder.end_event();

    // ev.print_tracks(ev.candidateTracks_, true);

    if (validation_on) {
      ev.seedTracks_.swap(seeds1);
    }

    return time;
  }

runFittingTestPlex()

double mkfit::runFittingTestPlex	(	Event &	ev,
		std::vector< Track > &	rectracks
	)

Definition at line 40 of file fittestMPlex.cc.

References submitPVResolutionJobs::count, dtime(), makeMEIFBenchmarkPlots::ev, mkfit::Config::fit_val, g_exe_ctx, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, mkfit::ExecutionContext::m_fitters, SiStripPI::max, mkfit::Config::nLayers, NN, mkfit::Config::numSeedsPerTask, mkfit::Config::numThreadsFinder, mkfit::ExecutionContext::populate(), and hcalRecHitTable_cff::time.

                                                                    {
    g_exe_ctx.populate(Config::numThreadsFinder);
    std::vector<Track>& simtracks = ev.simTracks_;

    const int Nhits = Config::nLayers;
    // XXX What if there's a missing / double layer?
    // Eventually, should sort track vector by number of hits!
    // And pass the number in on each "setup" call.
    // Reserves should be made for maximum possible number (but this is just
    // measurments errors, params).

    int theEnd = simtracks.size();
    int count = (theEnd + NN - 1) / NN;

#ifdef USE_VTUNE_PAUSE
    __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
    __itt_resume();
#endif

    double time = dtime();

    tbb::parallel_for(tbb::blocked_range<int>(0, count, std::max(1, Config::numSeedsPerTask / NN)),
                      [&](const tbb::blocked_range<int>& i) {
                        std::unique_ptr<MkFitter, decltype(retfitr)> mkfp(g_exe_ctx.m_fitters.GetFromPool(), retfitr);
                        mkfp->setNhits(Nhits);
                        for (int it = i.begin(); it < i.end(); ++it) {
                          int itrack = it * NN;
                          int end = itrack + NN;
                          /*
         * MT, trying to slurp and fit at the same time ...
      if (theEnd < end) {
        end = theEnd;
        mkfp->inputTracksAndHits(simtracks, ev.layerHits_, itrack, end);
      } else {
        mkfp->slurpInTracksAndHits(simtracks, ev.layerHits_, itrack, end); // only safe for a full matriplex
      }
      
      if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);
      mkfp->FitTracks(end - itrack, &ev, true);
        */

                          mkfp->inputTracksForFit(simtracks, itrack, end);

                          // XXXX MT - for this need 3 points in ... right
                          // XXXX if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);

                          mkfp->fitTracksWithInterSlurp(ev.layerHits_, end - itrack);

                          mkfp->outputFittedTracks(rectracks, itrack, end);
                        }
                      });

    time = dtime() - time;

#ifdef USE_VTUNE_PAUSE
    __itt_pause();
    __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
#endif

    if (Config::fit_val)
      ev.validate();

    return time;
  }

sincos4()

void mkfit::sincos4 ( const float  x, float &  sin, float &  cos  )

inline

Definition at line 13 of file Matrix.h.

References funct::cos(), funct::sin(), and x.

Referenced by helixAtRFromIterativeCCSFullJac(), and helixAtZ().

                                                             {
    // Had this writen with explicit division by factorial.
    // The *whole* fitting test ran like 2.5% slower on MIC, sigh.

    const float x2 = x * x;
    cos = 1.f - 0.5f * x2 + 0.04166667f * x2 * x2;
    sin = x - 0.16666667f * x * x2;
  }

sortByEta()

bool mkfit::sortByEta ( const Hit &  hit1, const Hit &  hit2  )

inline

Definition at line 25 of file buildtestMPlex.cc.

References mkfit::Hit::eta().

{ return hit1.eta() < hit2.eta(); }

sortByHitsChi2() [1/2]

bool mkfit::sortByHitsChi2 ( const std::pair< Track, TrackState > &  cand1, const std::pair< Track, TrackState > &  cand2  )

inline

Definition at line 14 of file buildtestMPlex.cc.

                                                                                                               {
    if (cand1.first.nFoundHits() == cand2.first.nFoundHits())
      return cand1.first.chi2() < cand2.first.chi2();

    return cand1.first.nFoundHits() > cand2.first.nFoundHits();
  }

sortByHitsChi2() [2/2]

bool mkfit::sortByHitsChi2 ( const Track &  cand1, const Track &  cand2  )

inline

Definition at line 599 of file Track.h.

References mkfit::TrackBase::chi2(), and mkfit::Track::nFoundHits().

                                                                     {
    if (cand1.nFoundHits() == cand2.nFoundHits())
      return cand1.chi2() < cand2.chi2();
    return cand1.nFoundHits() > cand2.nFoundHits();
  }

sortByPhi()

bool mkfit::sortByPhi ( const Hit &  hit1, const Hit &  hit2  )

inline

Definition at line 21 of file buildtestMPlex.cc.

References mkfit::Hit::x(), and mkfit::Hit::y().

                                                          {
    return std::atan2(hit1.y(), hit1.x()) < std::atan2(hit2.y(), hit2.x());
  }

sortByScoreCand()

bool mkfit::sortByScoreCand ( const Track &  cand1, const Track &  cand2  )

inline

Definition at line 605 of file Track.h.

References mkfit::TrackBase::score().

Referenced by mkfit::TTreeValidation::mapRefTkToRecoTks().

{ return cand1.score() > cand2.score(); }

sortByScoreStruct()

bool mkfit::sortByScoreStruct ( const IdxChi2List &  cand1, const IdxChi2List &  cand2  )

inline

Definition at line 607 of file Track.h.

References mkfit::IdxChi2List::score.

                                                                                    {
    return cand1.score > cand2.score;
  }

sortByScoreTrackCand()

bool mkfit::sortByScoreTrackCand ( const TrackCand &  cand1, const TrackCand &  cand2  )

inline

Definition at line 255 of file TrackStructures.h.

References mkfit::TrackBase::score().

Referenced by mkfit::CombCandidate::mergeCandsAndBestShortOne(), and mkfit::CandCloner::processSeedRange().

                                                                                   {
    return cand1.score() > cand2.score();
  }

sortByZ()

bool mkfit::sortByZ ( const Hit &  hit1, const Hit &  hit2  )

inline

Definition at line 43 of file buildtestMPlex.cc.

References mkfit::Hit::z().

{ return hit1.z() < hit2.z(); }

sortIDsByChi2()

bool mkfit::sortIDsByChi2 ( const idchi2Pair &  cand1, const idchi2Pair &  cand2  )

inline

Definition at line 235 of file TrackExtra.cc.

Referenced by mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams().

{ return cand1.second < cand2.second; }

sortTracksByEta()

bool mkfit::sortTracksByEta ( const Track &  track1, const Track &  track2  )

inline

Definition at line 27 of file buildtestMPlex.cc.

References mkfit::TrackBase::momEta().

{ return track1.momEta() < track2.momEta(); }

sortTracksByPhi()

bool mkfit::sortTracksByPhi ( const Track &  track1, const Track &  track2  )

inline

Definition at line 29 of file buildtestMPlex.cc.

References mkfit::TrackBase::momPhi().

{ return track1.momPhi() < track2.momPhi(); }

sqr()

template<typename T >

T mkfit::sqr ( T  x )

inline

Definition at line 14 of file Hit.h.

References x.

                    {
    return x * x;
  }

squashPhiGeneral() [1/2]

float mkfit::squashPhiGeneral ( float  phi )

inline

Definition at line 22 of file Hit.h.

References mkfit::Const::InvPI, mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by computeHelixChi2(), mkfit::TrackExtra::setCMSSWTrackIDInfoByHits(), mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams(), mkfit::TrackExtra::setMCTrackIDInfo(), squashPhiGeneral(), and mkfit::TrackBase::swimPhiToR().

                                           {
    return phi - floor(0.5 * Const::InvPI * (phi + Const::PI)) * Const::TwoPI;
  }

squashPhiGeneral() [2/2]

template<typename Vector >

void mkfit::squashPhiGeneral ( Vector &  v )

inline

Definition at line 645 of file Track.h.

References mps_fire::i, squashPhiGeneral(), and findQualityFiles::v.

                                          {
    const int i = v.kSize - 2;  // phi index
    v[i] = squashPhiGeneral(v[i]);
  }

squashPhiMinimal()

float mkfit::squashPhiMinimal ( float  phi )

inline

Definition at line 26 of file Hit.h.

References mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by mkfit::StdSeq::clean_duplicates(), mkfit::StdSeq::clean_duplicates_sharedhits(), and mkfit::StdSeq::clean_duplicates_sharedhits_pixelseed().

                                           {
    return phi >= Const::PI ? phi - Const::TwoPI : (phi < -Const::PI ? phi + Const::TwoPI : phi);
  }

squashPhiMPlex()

void mkfit::squashPhiMPlex ( MPlexLV &  par, const int  N_proc  )

inline

Definition at line 10 of file PropagationMPlex.h.

References dqmiodumpmetadata::n, NN, mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by kalmanOperation(), kalmanOperationEndcap(), kalmanOperationPlane(), propagateHelixToPlaneMPlex(), propagateHelixToRMPlex(), and propagateHelixToZMPlex().

                                                             {
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      if (n < N_proc) {
        if (par(n, 4, 0) >= Const::PI)
          par(n, 4, 0) -= Const::TwoPI;
        if (par(n, 4, 0) < -Const::PI)
          par(n, 4, 0) += Const::TwoPI;
      }
    }
  }

squashPhiMPlexGeneral()

void mkfit::squashPhiMPlexGeneral ( MPlexLV &  par, const int  N_proc  )

inline

Definition at line 22 of file PropagationMPlex.h.

References f, mkfit::Const::InvPI, dqmiodumpmetadata::n, NN, mkfit::Const::PI, and mkfit::Const::TwoPI.

                                                                    {
#pragma omp simd
    for (int n = 0; n < NN; ++n) {
      par(n, 4, 0) -= std::floor(0.5f * Const::InvPI * (par(n, 4, 0) + Const::PI)) * Const::TwoPI;
    }
  }

to_json() [1/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::LayerControl &  nlohmann_json_t  )

inline

Definition at line 37 of file IterationConfig.cc.

to_json() [2/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::LayerControl &  nlohmann_json_t  )

inline

Definition at line 37 of file IterationConfig.cc.

Referenced by mkfit::ConfigJson::save_Iterations().

to_json() [3/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::SteeringParams &  nlohmann_json_t  )

inline

Definition at line 45 of file IterationConfig.cc.

to_json() [4/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::SteeringParams &  nlohmann_json_t  )

inline

Definition at line 45 of file IterationConfig.cc.

to_json() [5/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::IterationLayerConfig &  nlohmann_json_t  )

inline

Definition at line 54 of file IterationConfig.cc.

to_json() [6/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::IterationLayerConfig &  nlohmann_json_t  )

inline

Definition at line 54 of file IterationConfig.cc.

to_json() [7/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::IterationParams &  nlohmann_json_t  )

inline

Definition at line 68 of file IterationConfig.cc.

to_json() [8/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::IterationParams &  nlohmann_json_t  )

inline

Definition at line 68 of file IterationConfig.cc.

to_json() [9/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::IterationConfig &  nlohmann_json_t  )

inline

Definition at line 101 of file IterationConfig.cc.

to_json() [10/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::IterationConfig &  nlohmann_json_t  )

inline

Definition at line 101 of file IterationConfig.cc.

to_json() [11/12]

void mkfit::to_json ( nlohmann::ordered_json &  nlohmann_json_j, const mkfit::IterationsInfo &  nlohmann_json_t  )

inline

Definition at line 104 of file IterationConfig.cc.

References CMS_SA_ALLOW, and mutex.

{

to_json() [12/12]

void mkfit::to_json ( nlohmann::json &  nlohmann_json_j, const mkfit::IterationsInfo &  nlohmann_json_t  )

inline

Definition at line 104 of file IterationConfig.cc.

{

Variable Documentation

g_debug

bool mkfit::g_debug = true

Definition at line 2 of file Debug.cc.

Referenced by conformalFitMPlex(), helixAtRFromIterativeCCSFullJac(), helixAtZ(), propagateHelixToPlaneMPlex(), propagateHelixToRMPlex(), propagateHelixToZMPlex(), mkfit::Shell::SetDebug(), and mkfit::Shell::Status().

g_exe_ctx

ExecutionContext mkfit::g_exe_ctx

Definition at line 55 of file MkBuilder.cc.

Referenced by mkfit::MkBuilder::backwardFit(), mkfit::MkBuilder::backwardFitBH(), mkfit::MkBuilder::clear(), mkfit::MkBuilder::findTracksBestHit(), mkfit::MkBuilder::findTracksCloneEngine(), mkfit::MkBuilder::findTracksStandard(), mkfit::MkBuilder::populate(), and runFittingTestPlex().

HH

constexpr Matriplex::idx_t mkfit::HH = 3

Definition at line 46 of file Matrix.h.

Referenced by L1TConfigDumper::analyze().

LL

constexpr Matriplex::idx_t mkfit::LL = 6

Definition at line 45 of file Matrix.h.

Referenced by mkfit::TrackBase::hasNanNSillyValues(), and mkfit::TrackBase::hasSillyValues().

MPlexHitIdxMax

constexpr int mkfit::MPlexHitIdxMax = 16

static

Definition at line 12 of file MkFitter.h.

NN

constexpr Matriplex::idx_t mkfit::NN = 8

Definition at line 43 of file Matrix.h.

Referenced by mkfit::MkFinder::addBestHit(), L1NNTauProducer::addTau(), L1TConfigDumper::analyze(), applyMaterialEffects(), mkfit::MkFinder::bkFitFitTracks(), mkfit::MkFinder::bkFitFitTracksBH(), CFMap(), conformalFitMPlex(), mkfit::MkFinder::copyOutParErr(), mkfit::MkBuilder::find_tracks_in_layers(), mkfit::MkFinder::findCandidates(), mkfit::MkFinder::findCandidatesCloneEngine(), mkfit::MkBuilder::findTracksBestHit(), mkfit::MkBuilder::findTracksStandard(), mkfit::MkBuilder::fit_cands(), mkfit::MkBuilder::fit_cands_BH(), helixAtPlane(), helixAtRFromIterativeCCS(), helixAtRFromIterativeCCSFullJac(), helixAtZ(), kalmanOperation(), kalmanOperationPlane(), kalmanPropagateAndComputeChi2(), kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdate(), kalmanPropagateAndUpdateEndcap(), kalmanPropagateAndUpdatePlane(), mkfit::MatriplexPackerSlurpIn< D >::pack(), mkfit::MatriplexErrParPackerSlurpIn< T, D >::pack(), mkfit::MkFinder::packModuleNormDir(), mkfit::MkFitter::printPt(), L1BJetProducer::produce(), propagateHelixToPlaneMPlex(), propagateHelixToRMPlex(), propagateHelixToZMPlex(), propagateLineToRMPlex(), mkfit::MkBase::propagateTracksToHitR(), mkfit::MkBase::propagateTracksToHitZ(), mkfit::MkBase::propagateTracksToPCAZ(), mkfit::MkBase::propagateTracksToR(), mkfit::MkBase::propagateTracksToZ(), runFittingTestPlex(), gen::TauolappInterface::selectHadronic(), mkfit::MkFinder::selectHitIndices(), mkfit::MkFinder::selectHitIndicesV2(), squashPhiMPlex(), and squashPhiMPlexGeneral().