CMS 3D CMS Logo
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
mkfit Namespace Reference

Namespaces

 Config
 
 ConfigWrapper
 
 Const
 
 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  MaterialEffects
 
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
 
struct  PropagationFlags
 
class  radix_sort
 
struct  ReducedTrack
 
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

typedef std::map< std::string, std::pair< cleanOpts, std::string > > cleanOptsMap
 
typedef std::vector< DeadRegion > DeadVec
 
typedef std::vector< Event > EventVec
 
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::MatriplexSym< float, 2, NN > MPlex2S
 
typedef Matriplex::Matriplex< float, 2, 1, NN > MPlex2V
 
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
 
using MPlexQHoT = Matriplex::Matriplex< HitOnTrack, 1, 1, NN >
 
typedef Matriplex::Matriplex< int, 1, 1, NN > MPlexQI
 
typedef Matriplex::Matriplex< unsigned int, 1, 1, NN > MPlexQUI
 
typedef std::array< int, 2 > PairIdx
 
typedef std::vector< PairIdx > PairIdxVec
 
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
 
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 }
 
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 }
 

Functions

void applyMaterialEffects (const MPlexQF &hitsRl, const MPlexQF &hitsXi, const MPlexQF &propSign, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const bool isBarrel)
 
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 getScoreCalc (const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates=false)
 
float getScoreCand (const TrackCand &cand1, bool penalizeTailMissHits=false, bool inFindCandidates=false)
 
float getScoreCand (const Track &cand1, bool penalizeTailMissHits=false, bool inFindCandidates=false)
 
float getScoreStruct (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 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, const int N_proc)
 
void helixAtZ (const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLV &outPar, MPlexLL &errorProp, 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)
 
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 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 kalmanPropagateAndComputeChi2 (const MPlexLS &psErr, const MPlexLV &psPar, const MPlexQI &inChg, const MPlexHS &msErr, const MPlexHV &msPar, MPlexQF &outChi2, MPlexLV &propPar, 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, 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, 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, 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)
 
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 label, int itrack, const Track &trk, bool print_hits=false)
 
void print (std::string label, const TrackState &s)
 
void propagateHelixToRMPlex (const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLS &outErr, MPlexLV &outPar, 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, 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::json &nlohmann_json_j, const mkfit::LayerControl &nlohmann_json_t)
 
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::SteeringParams &nlohmann_json_t)
 
void to_json (nlohmann::ordered_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

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

◆ 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 71 of file Event.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 15 of file Track.h.

◆ HitLayerMap

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

Definition at line 16 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 136 of file MatriplexPackers.h.

◆ MatriplexHoTPacker

using mkfit::MatriplexHoTPacker = typedef MatriplexPackerSlurpIn<HitOnTrack>

Definition at line 139 of file MatriplexPackers.h.

◆ MatriplexTrackPacker

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

Definition at line 137 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 56 of file Matrix.h.

◆ MPlex2S

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

Definition at line 58 of file Matrix.h.

◆ MPlex2V

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

Definition at line 57 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 61 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 63 of file Matrix.h.

◆ MPlexLH

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

Definition at line 60 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 69 of file Matrix.h.

◆ MPlexQF

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

Definition at line 65 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 66 of file Matrix.h.

◆ MPlexQUI

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

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

◆ 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 14 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.

◆ 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 588 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.

24 { 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.

11 { 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.

28 { trkParamBased, hitBased, labelBased };

◆ PropagationFlagsEnum

enum mkfit::PropagationFlagsEnum
Enumerator
PF_none 
PF_use_param_b_field 
PF_apply_material 

Definition at line 6 of file Config.h.

6 { PF_none = 0, PF_use_param_b_field = 0x1, PF_apply_material = 0x2 };

◆ seedOpts

enum mkfit::seedOpts
Enumerator
simSeeds 
cmsswSeeds 
findSeeds 

Definition at line 20 of file ConfigStandalone.h.

20 { simSeeds, cmsswSeeds, findSeeds };

◆ TkLayout

enum mkfit::TkLayout
strong
Enumerator
phase0 
phase1 
phase2 

Definition at line 8 of file LayerNumberConverter.h.

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

◆ WithinSensitiveRegion_e

enum mkfit::WithinSensitiveRegion_e
Enumerator
WSR_Undef 
WSR_Inside 
WSR_Edge 
WSR_Outside 

Definition at line 10 of file TrackerInfo.h.

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

Function Documentation

◆ applyMaterialEffects()

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

Definition at line 982 of file PropagationMPlex.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), HLT_2022v15_cff::beta, Matriplex::Matriplex< T, D1, D2, N >::constAt(), funct::cos(), plot_hgcal_utils::dEdx, MillePedeFileConverter_cfg::e, f, CustomPhysics_cfi::gamma, Exhume::I, PixelPluginsPhase0_cfi::isBarrel, 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(), and cms::cuda::wmax.

Referenced by propagateHelixToRMPlex(), and propagateHelixToZMPlex().

988  {
989 #pragma omp simd
990  for (int n = 0; n < NN; ++n) {
991  float radL = hitsRl.constAt(n, 0, 0);
992  if (radL < 1e-13f)
993  continue; //ugly, please fixme
994  const float theta = outPar.constAt(n, 5, 0);
995  const float pt = 1.f / outPar.constAt(n, 3, 0); //fixme, make sure it is positive?
996  const float p = pt / std::sin(theta);
997  const float p2 = p * p;
998  constexpr float mpi = 0.140; // m=140 MeV, pion
999  constexpr float mpi2 = mpi * mpi; // m=140 MeV, pion
1000  const float beta2 = p2 / (p2 + mpi2);
1001  const float beta = std::sqrt(beta2);
1002  //radiation lenght, corrected for the crossing angle (cos alpha from dot product of radius vector and momentum)
1003  const float invCos = (isBarrel ? p / pt : 1.f / std::abs(std::cos(theta)));
1004  radL = radL * invCos; //fixme works only for barrel geom
1005  // multiple scattering
1006  //vary independently phi and theta by the rms of the planar multiple scattering angle
1007  // XXX-KMD radL < 0, see your fixme above! Repeating bailout
1008  if (radL < 1e-13f)
1009  continue;
1010  // const float thetaMSC = 0.0136f*std::sqrt(radL)*(1.f+0.038f*std::log(radL))/(beta*p);// eq 32.15
1011  // const float thetaMSC2 = thetaMSC*thetaMSC;
1012  const float thetaMSC = 0.0136f * (1.f + 0.038f * std::log(radL)) / (beta * p); // eq 32.15
1013  const float thetaMSC2 = thetaMSC * thetaMSC * radL;
1014  outErr.At(n, 4, 4) += thetaMSC2;
1015  // outErr.At(n, 4, 5) += thetaMSC2;
1016  outErr.At(n, 5, 5) += thetaMSC2;
1017  //std::cout << "beta=" << beta << " p=" << p << std::endl;
1018  //std::cout << "multiple scattering thetaMSC=" << thetaMSC << " thetaMSC2=" << thetaMSC2 << " radL=" << radL << std::endl;
1019  // energy loss
1020  // XXX-KMD beta2 = 1 => 1 / sqrt(0)
1021  // const float gamma = 1.f/std::sqrt(1.f - std::min(beta2, 0.999999f));
1022  // const float gamma2 = gamma*gamma;
1023  const float gamma2 = (p2 + mpi2) / mpi2;
1024  const float gamma = std::sqrt(gamma2); //1.f/std::sqrt(1.f - std::min(beta2, 0.999999f));
1025  constexpr float me = 0.0005; // m=0.5 MeV, electron
1026  const float wmax = 2.f * me * beta2 * gamma2 / (1.f + 2.f * gamma * me / mpi + me * me / (mpi * mpi));
1027  constexpr float I = 16.0e-9 * 10.75;
1028  const float deltahalf = std::log(28.816e-9f * std::sqrt(2.33f * 0.498f) / I) + std::log(beta * gamma) - 0.5f;
1029  const float dEdx =
1030  beta < 1.f
1031  ? (2.f * (hitsXi.constAt(n, 0, 0) * invCos *
1032  (0.5f * std::log(2.f * me * beta2 * gamma2 * wmax / (I * I)) - beta2 - deltahalf) / beta2))
1033  : 0.f; //protect against infs and nans
1034  // dEdx = dEdx*2.;//xi in cmssw is defined with an extra factor 0.5 with respect to formula 27.1 in pdg
1035  //std::cout << "dEdx=" << dEdx << " delta=" << deltahalf << " wmax=" << wmax << " Xi=" << hitsXi.constAt(n,0,0) << std::endl;
1036  const float dP = propSign.constAt(n, 0, 0) * dEdx / beta;
1037  outPar.At(n, 3, 0) = p / (std::max(p + dP, 0.001f) * pt); //stay above 1MeV
1038  //assume 100% uncertainty
1039  outErr.At(n, 3, 3) += dP * dP / (p2 * pt * pt);
1040  }
1041  }
plot_hgcal_utils.dEdx
dEdx
Definition: plot_hgcal_utils.py:219
SiStripOfflineCRack_cfg.p2
p2
Definition: SiStripOfflineCRack_cfg.py:140
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
Matriplex::MatriplexSym::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: MatriplexSym.h:71
HLT_2022v15_cff.beta
beta
Definition: HLT_2022v15_cff.py:7357
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
PixelPluginsPhase0_cfi.isBarrel
isBarrel
Definition: PixelPluginsPhase0_cfi.py:17
CustomPhysics_cfi.gamma
gamma
Definition: CustomPhysics_cfi.py:17
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
hlt_dqm_clientPB-live_cfg.me
me
Definition: hlt_dqm_clientPB-live_cfg.py:62
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
Exhume::I
const std::complex< double > I
Definition: I.h:8
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
cms::cuda::wmax
__host__ __device__ V V wmax
Definition: HistoContainer.h:85

◆ calculateCharge() [1/2]

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

Definition at line 18 of file Track.h.

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

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

◆ 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 22 of file Track.h.

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

◆ cdist()

float mkfit::cdist ( float  a)
inline

Definition at line 67 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(), and mkfit::MkFinder::selectHitIndices().

67 { return a > Const::PI ? Const::TwoPI - a : a; }
mkfit::Const::TwoPI
constexpr float TwoPI
Definition: Config.h:43
mkfit::Const::PI
constexpr float PI
Definition: Config.h:42
a
double a
Definition: hdecay.h:119

◆ 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, c, N, and NN.

Referenced by conformalFitMPlex().

89  {
90  using idx_t = Matriplex::idx_t;
91 
92  // C = A * B, C is 3x1, A is 3x3 , B is 3x1
93 
94  typedef float T;
95  typedef float Tv;
96  const idx_t N = NN;
97 
98  const T* a = A.fArray;
99  ASSUME_ALIGNED(a, 64);
100  const Tv* b = B.fArray;
101  ASSUME_ALIGNED(b, 64);
102  Tv* c = C.fArray;
103  ASSUME_ALIGNED(c, 64);
104 
105 #include "RecoTracker/MkFitCore/standalone/CFMatrix33Vector3.ah"
106  }
B
Definition: APVGainStruct.h:7
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
correctionTermsCaloMet_cff.C
C
Definition: correctionTermsCaloMet_cff.py:34
N
#define N
Definition: blowfish.cc:9
b
double b
Definition: hdecay.h:118
a
double a
Definition: hdecay.h:119
A
Definition: APVGainStruct.h:7
T
long double T
Definition: Basic3DVectorLD.h:48
ASSUME_ALIGNED
#define ASSUME_ALIGNED(a, b)
Definition: MatriplexCommon.h:82

◆ 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 664 of file Track.h.

References diagonalOnly(), and squashPhiGeneral().

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

664  {
665  Vector diffV = recoV - simV;
666  if (diffV.kSize > 2)
667  squashPhiGeneral(diffV);
668 
669  Matrix recoM_tmp = recoM;
670  if (diagOnly)
671  diagonalOnly(recoM_tmp);
672  int invFail(0);
673  const Matrix recoMI = recoM_tmp.InverseFast(invFail);
674 
675  return ROOT::Math::Dot(diffV * recoMI, diffV) / (diffV.kSize - 1);
676  }
Vector
ROOT::Math::Plane3D::Vector Vector
Definition: EcalHitMaker.cc:29
HLT_2022v15_cff.diagonalOnly
diagonalOnly
Definition: HLT_2022v15_cff.py:9580
mkfit::squashPhiGeneral
void squashPhiGeneral(Vector &v)
Definition: Track.h:657
cudatest::Matrix
portabletest::Matrix Matrix
Definition: TestDeviceCollection.h:10

◆ 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(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), b, mkfit::Config::Bfield, correctionTermsCaloMet_cff::C, CFMap(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), dcall, debug, dprint, dprintf, f, 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.

117  {
118  bool debug(false);
119 
120  using idx_t = Matriplex::idx_t;
121  const idx_t N = NN;
122 
123  // Store positions in mplex vectors... could consider storing in a 3x3 matrix, too
124  MPlexHV x, y, z, r2;
125 #pragma omp simd
126  for (int n = 0; n < N; ++n) {
127  x.At(n, 0, 0) = msPar0.constAt(n, 0, 0);
128  x.At(n, 1, 0) = msPar1.constAt(n, 0, 0);
129  x.At(n, 2, 0) = msPar2.constAt(n, 0, 0);
130 
131  y.At(n, 0, 0) = msPar0.constAt(n, 1, 0);
132  y.At(n, 1, 0) = msPar1.constAt(n, 1, 0);
133  y.At(n, 2, 0) = msPar2.constAt(n, 1, 0);
134 
135  z.At(n, 0, 0) = msPar0.constAt(n, 2, 0);
136  z.At(n, 1, 0) = msPar1.constAt(n, 2, 0);
137  z.At(n, 2, 0) = msPar2.constAt(n, 2, 0);
138 
139  for (int i = 0; i < 3; ++i) {
140  r2.At(n, i, 0) = getRad2(x.constAt(n, i, 0), y.constAt(n, i, 0));
141  }
142  }
143 
144  // Start setting the output parameters
145 #pragma omp simd
146  for (int n = 0; n < N; ++n) {
147  outPar.At(n, 0, 0) = x.constAt(n, 0, 0);
148  outPar.At(n, 1, 0) = y.constAt(n, 0, 0);
149  outPar.At(n, 2, 0) = z.constAt(n, 0, 0);
150  }
151 
152  // Use r-phi smearing to set initial error estimation for positions
153  // trackStates already initialized to identity for seeding ... don't store off-diag 0's, zero's for fitting set outside CF
154 #pragma omp simd
155  for (int n = 0; n < N; ++n) {
156  const float varPhi = Config::varXY / r2.constAt(n, 0, 0);
157  const float invvarR2 = Config::varR / r2.constAt(n, 0, 0);
158 
159  outErr.At(n, 0, 0) =
160  x.constAt(n, 0, 0) * x.constAt(n, 0, 0) * invvarR2 + y.constAt(n, 0, 0) * y.constAt(n, 0, 0) * varPhi;
161  outErr.At(n, 0, 1) = x.constAt(n, 0, 0) * y.constAt(n, 0, 0) * (invvarR2 - varPhi);
162 
163  outErr.At(n, 1, 0) = outErr.constAt(n, 0, 1);
164  outErr.At(n, 1, 1) =
165  y.constAt(n, 0, 0) * y.constAt(n, 0, 0) * invvarR2 + x.constAt(n, 0, 0) * x.constAt(n, 0, 0) * varPhi;
166 
167  outErr.At(n, 2, 2) = Config::varZ;
168  }
169 
170  MPlexQF initPhi;
171  MPlexQI xtou; // bool to determine "split space", i.e. map x to u or v
172 #pragma omp simd
173  for (int n = 0; n < N; ++n) {
174  initPhi.At(n, 0, 0) = std::abs(getPhi(x.constAt(n, 0, 0), y.constAt(n, 0, 0)));
175  xtou.At(n, 0, 0) =
176  ((initPhi.constAt(n, 0, 0) < Const::PIOver4 || initPhi.constAt(n, 0, 0) > Const::PI3Over4) ? 1 : 0);
177  }
178 
179  MPlexHV u, v;
180 #pragma omp simd
181  for (int n = 0; n < N; ++n) {
182  if (xtou.At(n, 0, 0)) // x mapped to u
183  {
184  for (int i = 0; i < 3; ++i) {
185  u.At(n, i, 0) = x.constAt(n, i, 0) / r2.constAt(n, i, 0);
186  v.At(n, i, 0) = y.constAt(n, i, 0) / r2.constAt(n, i, 0);
187  }
188  } else // x mapped to v
189  {
190  for (int i = 0; i < 3; ++i) {
191  u.At(n, i, 0) = y.constAt(n, i, 0) / r2.constAt(n, i, 0);
192  v.At(n, i, 0) = x.constAt(n, i, 0) / r2.constAt(n, i, 0);
193  }
194  }
195  }
196 
197  MPlexHH A;
198  //#pragma omp simd // triggers an internal compiler error with icc 18.0.2!
199  for (int n = 0; n < N; ++n) {
200  for (int i = 0; i < 3; ++i) {
201  A.At(n, i, 0) = 1.0f;
202  A.At(n, i, 1) = -u.constAt(n, i, 0);
203  A.At(n, i, 2) = -u.constAt(n, i, 0) * u.constAt(n, i, 0);
204  }
205  }
206  Matriplex::invertCramer(A);
207  MPlexHV C;
208  CFMap(A, v, C);
209 
210  MPlexQF a, b;
211 #pragma omp simd
212  for (int n = 0; n < N; ++n) {
213  b.At(n, 0, 0) = 1.0f / (2.0f * C.constAt(n, 0, 0));
214  a.At(n, 0, 0) = b.constAt(n, 0, 0) * C.constAt(n, 1, 0);
215  }
216 
217  // constant used throughtout
218  const float k = (Const::sol * Config::Bfield) / 100.0f;
219 
220  MPlexQF vrx, vry, pT, px, py, pz;
221 #pragma omp simd
222  for (int n = 0; n < N; ++n) {
223  vrx.At(n, 0, 0) =
224  (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));
225  vry.At(n, 0, 0) =
226  (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));
227  pT.At(n, 0, 0) = k * hipo(vrx.constAt(n, 0, 0), vry.constAt(n, 0, 0));
228  px.At(n, 0, 0) = std::copysign(k * vry.constAt(n, 0, 0), x.constAt(n, 2, 0) - x.constAt(n, 0, 0));
229  py.At(n, 0, 0) = std::copysign(k * vrx.constAt(n, 0, 0), y.constAt(n, 2, 0) - y.constAt(n, 0, 0));
230  pz.At(n, 0, 0) = (pT.constAt(n, 0, 0) * (z.constAt(n, 2, 0) - z.constAt(n, 0, 0))) /
231  hipo((x.constAt(n, 2, 0) - x.constAt(n, 0, 0)), (y.constAt(n, 2, 0) - y.constAt(n, 0, 0)));
232  }
233 
234 #pragma omp simd
235  for (int n = 0; n < N; ++n) {
236  outPar.At(n, 3, 0) = 1.0f / pT.constAt(n, 0, 0);
237  outPar.At(n, 4, 0) = getPhi(px.constAt(n, 0, 0), py.constAt(n, 0, 0));
238  outPar.At(n, 5, 0) = getTheta(pT.constAt(n, 0, 0), pz.constAt(n, 0, 0));
239 #ifdef INWARDFIT // arctan is odd, so pz -> -pz means theta -> -theta
240  if (fitting)
241  outPar.At(n, 5, 0) *= -1.0f;
242 #endif
243  }
244 
245 #pragma omp simd
246  for (int n = 0; n < N; ++n) {
247  outErr.At(n, 3, 3) =
248  (fitting ? Config::ptinverr049 * Config::ptinverr049 : Config::ptinverr012 * Config::ptinverr012);
249  outErr.At(n, 4, 4) = (fitting ? Config::phierr049 * Config::phierr049 : Config::phierr012 * Config::phierr012);
250  outErr.At(n, 5, 5) =
251  (fitting ? Config::thetaerr049 * Config::thetaerr049 : Config::thetaerr012 * Config::thetaerr012);
252  }
253 
254  if (debug) {
255  for (int n = 0; n < N; ++n) {
256  dprintf("afterCF seedID: %1u \n", seedID.constAt(n, 0, 0));
257  // do a dumb copy out
258  TrackState updatedState;
259  for (int i = 0; i < 6; i++) {
260  updatedState.parameters[i] = outPar.constAt(n, i, 0);
261  for (int j = 0; j < 6; j++) {
262  updatedState.errors[i][j] = outErr.constAt(n, i, j);
263  }
264  }
265 
266  dcall(print("CCS", updatedState));
267  updatedState.convertFromCCSToCartesian();
268  dcall(print("Pol", updatedState));
269  dprint("--------------------------------");
270  }
271  }
272  }
mkfit::MPlexHH
Matriplex::Matriplex< float, HH, HH, NN > MPlexHH
Definition: Matrix.h:52
mps_fire.i
i
Definition: mps_fire.py:429
mkfit::MPlexHV
Matriplex::Matriplex< float, HH, 1, NN > MPlexHV
Definition: Matrix.h:53
mkfit::getTheta
float getTheta(float r, float z)
Definition: Hit.h:36
mkfit::Config::phierr012
constexpr float phierr012
Definition: ConfigStandalone.h:120
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
mkfit::Config::thetaerr049
constexpr float thetaerr049
Definition: ConfigStandalone.h:117
dcall
#define dcall(x)
Definition: Debug.h:92
mkfit::Config::varZ
constexpr float varZ
Definition: ConfigStandalone.h:81
mkfit::Config::varR
constexpr float varR
Definition: ConfigStandalone.h:82
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
mkfit::Config::Bfield
constexpr float Bfield
Definition: Config.h:88
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
print
void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)
Definition: Utilities.cc:47
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
mkfit::Config::ptinverr049
constexpr float ptinverr049
Definition: ConfigStandalone.h:114
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
correctionTermsCaloMet_cff.C
C
Definition: correctionTermsCaloMet_cff.py:34
mkfit::MPlexQI
Matriplex::Matriplex< int, 1, 1, NN > MPlexQI
Definition: Matrix.h:66
mkfit::Config::thetaerr012
constexpr float thetaerr012
Definition: ConfigStandalone.h:121
debug
#define debug
Definition: HDRShower.cc:19
mkfit::Const::sol
constexpr float sol
Definition: Config.h:48
mkfit::MPlexQF
Matriplex::Matriplex< float, 1, 1, NN > MPlexQF
Definition: Matrix.h:65
N
#define N
Definition: blowfish.cc:9
Matriplex::invertCramer
void invertCramer(MPlex< T, D, D, N > &A, double *determ=nullptr)
Definition: Matriplex.h:424
mkfit::hipo
float hipo(float x, float y)
Definition: Matrix.h:9
b
double b
Definition: hdecay.h:118
mkfit::getPhi
float getPhi(float x, float y)
Definition: Hit.h:34
multPhiCorr_741_25nsDY_cfi.py
py
Definition: multPhiCorr_741_25nsDY_cfi.py:12
multPhiCorr_741_25nsDY_cfi.px
px
Definition: multPhiCorr_741_25nsDY_cfi.py:10
dprint
#define dprint(x)
Definition: Debug.h:90
mkfit::Config::varXY
constexpr float varXY
Definition: ConfigStandalone.h:80
a
double a
Definition: hdecay.h:119
mkfit::Config::phierr049
constexpr float phierr049
Definition: ConfigStandalone.h:116
mkfit::CFMap
void CFMap(const MPlexHH &A, const MPlexHV &B, MPlexHV &C)
Definition: ConformalUtilsMPlex.cc:89
x
float x
Definition: beamSpotDipStandalone.cc:55
A
Definition: APVGainStruct.h:7
mkfit::Const::PI3Over4
constexpr float PI3Over4
Definition: Config.h:46
mkfit::Config::ptinverr012
constexpr float ptinverr012
Definition: ConfigStandalone.h:119
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54
dprintf
#define dprintf(...)
Definition: Debug.h:93
mkfit::Const::PIOver4
constexpr float PIOver4
Definition: Config.h:45

◆ 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, submitPVResolutionJobs::err, Exception, f, hfClusterShapes_cfi::hits, edm::ProductID::id(), TrackerTopology::isStereo(), TrackerTopology::layer(), LogTrace, MkFitGeometry::mkFitLayerNumber(), DetId::rawId(), findQualityFiles::size, DetId::subdetId(), MkFitGeometry::uniqueIdInLayer(), and UNLIKELY.

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

32  {
33  if (hits.empty())
34  return edm::ProductID{};
35 
36  edm::ProductID clusterID;
37  {
38  const auto& lastClusterRef = hits.data().back().firstClusterRef();
39  clusterID = lastClusterRef.id();
40  if (lastClusterRef.index() >= mkFitHits.size()) {
41  auto const size = lastClusterRef.index();
42  mkFitHits.resize(size);
43  clusterIndexToHit.resize(size, nullptr);
44  if constexpr (Traits::applyCCC()) {
45  clusterChargeVec.resize(size, -1.f);
46  }
47  }
48  }
49 
50  for (const auto& detset : hits) {
51  const DetId detid = detset.detId();
52  const auto ilay = mkFitGeom.mkFitLayerNumber(detid);
53 
54  for (const auto& hit : detset) {
55  const auto charge = traits.clusterCharge(hit, detid);
56  if (!traits.passCCC(charge))
57  continue;
58 
59  const auto& gpos = hit.globalPosition();
60  SVector3 pos(gpos.x(), gpos.y(), gpos.z());
61  const auto& gerr = hit.globalPositionError();
62  SMatrixSym33 err;
63  err.At(0, 0) = gerr.cxx();
64  err.At(1, 1) = gerr.cyy();
65  err.At(2, 2) = gerr.czz();
66  err.At(0, 1) = gerr.cyx();
67  err.At(0, 2) = gerr.czx();
68  err.At(1, 2) = gerr.czy();
69 
70  auto clusterRef = hit.firstClusterRef();
71  if UNLIKELY (clusterRef.id() != clusterID) {
72  throw cms::Exception("LogicError")
73  << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID
74  << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId();
75  }
76  const auto clusterIndex = clusterRef.index();
77  LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << detid.subdetId()
78  << " layer " << ttopo.layer(detid) << " isStereo " << ttopo.isStereo(detid)
79  << " zplus "
80  << " index " << clusterIndex << " ilay " << ilay;
81 
82  if UNLIKELY (clusterIndex >= mkFitHits.size()) {
83  mkFitHits.resize(clusterIndex + 1);
84  clusterIndexToHit.resize(clusterIndex + 1, nullptr);
85  if constexpr (Traits::applyCCC()) {
86  clusterChargeVec.resize(clusterIndex + 1, -1.f);
87  }
88  }
89  mkFitHits[clusterIndex] = mkfit::Hit(pos, err);
90  clusterIndexToHit[clusterIndex] = &hit;
91  if constexpr (Traits::applyCCC()) {
92  clusterChargeVec[clusterIndex] = charge;
93  }
94 
95  const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId());
96  traits.setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge);
97  }
98  }
99  return clusterID;
100  }
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
MkFitGeometry::uniqueIdInLayer
unsigned int uniqueIdInLayer(int layer, unsigned int detId) const
Definition: MkFitGeometry.h:36
TrackerTopology::isStereo
bool isStereo(const DetId &id) const
Definition: TrackerTopology.cc:158
TrackerTopology::layer
unsigned int layer(const DetId &id) const
Definition: TrackerTopology.cc:47
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
Hit
SeedingHitSet::ConstRecHitPointer Hit
Definition: SeedGeneratorFromProtoTracksEDProducer.cc:31
edm::ProductID::id
ProductIndex id() const
Definition: ProductID.h:35
DetId
Definition: DetId.h:17
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
MkFitGeometry::mkFitLayerNumber
int mkFitLayerNumber(DetId detId) const
Definition: MkFitGeometry.cc:61
UNLIKELY
#define UNLIKELY(x)
Definition: Likely.h:21
SVector3
ROOT::Math::SVector< double, 3 > SVector3
Definition: V0Fitter.cc:47
mkfit::SMatrixSym33
ROOT::Math::SMatrix< float, 3, 3, ROOT::Math::MatRepSym< float, 3 > > SMatrixSym33
Definition: MatrixSTypes.h:13

◆ cube()

template<typename T >
T mkfit::cube ( T  x)
inline

Definition at line 18 of file Hit.h.

References x.

Referenced by getInvRadErr2().

18  {
19  return x * x * x;
20  }
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ diagonalOnly()

template<typename Matrix >
void mkfit::diagonalOnly ( Matrix &  m)
inline

Definition at line 27 of file MatrixSTypes.h.

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

Referenced by computeHelixChi2().

27  {
28  for (int r = 0; r < m.kRows; r++) {
29  for (int c = 0; c < m.kCols; c++) {
30  if (r != c)
31  m[r][c] = 0.f;
32  }
33  }
34  }
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:80

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

23  {
24  double tseconds = 0.0;
25  struct timeval mytime;
26  gettimeofday(&mytime, (struct timezone*)nullptr);
27  tseconds = (double)(mytime.tv_sec + mytime.tv_usec * 1.0e-6);
28  return (tseconds);
29  }

◆ dumpMatrix()

template<typename Matrix >
void mkfit::dumpMatrix ( Matrix  m)

Definition at line 37 of file MatrixSTypes.h.

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

Referenced by print().

37  {
38  for (int r = 0; r < m.kRows; ++r) {
39  for (int c = 0; c < m.kCols; ++c) {
40  std::cout << std::setw(12) << m.At(r, c) << " ";
41  }
42  std::cout << std::endl;
43  }
44  }
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:80
gather_cfg.cout
cout
Definition: gather_cfg.py:144

◆ 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(), 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().

92  {
93  const std::string soname = base + ".so";
94  const std::string binname = base + ".bin";
95  struct stat st;
96 
97  int si = 0;
98  while (search_path[si]) {
99  std::string path;
100  const char *envpath = std::getenv("MKFIT_BASE");
101  if (envpath != nullptr) {
102  path += envpath;
103  path += "/";
104  }
105  path += search_path[si];
106  std::string sopath = path + soname;
107  if (stat(sopath.c_str(), &st) == 0) {
108  printf("execTrackerInfoCreatorPlugin processing '%s'\n", sopath.c_str());
109 
110  void *h = dlopen(sopath.c_str(), RTLD_LAZY);
111  if (!h) {
112  perror("dlopen failed");
113  exit(2);
114  }
115 
116  long long *p2f = (long long *)dlsym(h, "TrackerInfoCreator_ptr");
117  if (!p2f) {
118  perror("dlsym failed");
119  exit(2);
120  }
121 
122  std::string binpath = path + binname;
123  int binsr = stat(binpath.c_str(), &st);
124  printf("execTrackerInfoCreatorPlugin has%s found TrackerInfo binary file '%s'\n",
125  binsr ? " NOT" : "",
126  binpath.c_str());
127  if (binsr == 0)
128  ti.read_bin_file(binpath);
129 
130  TrackerInfoCreator_foo foo = (TrackerInfoCreator_foo)(*p2f);
131  foo(ti, ii, verbose);
132 
133  return;
134  }
135 
136  ++si;
137  }
138 
139  fprintf(stderr, "TrackerInfo plugin '%s' not found in search path.\n", soname.c_str());
140  exit(2);
141  }
castor_dqm_sourceclient_file_cfg.path
path
Definition: castor_dqm_sourceclient_file_cfg.py:37
verbose
bool verbose
Definition: beamSpotDipStandalone.cc:87
newFWLiteAna.base
base
Main Program
Definition: newFWLiteAna.py:92
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm_modernize_messagelogger.stat
stat
Definition: edm_modernize_messagelogger.py:27
cuy.ii
ii
Definition: cuy.py:589
h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:52

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

37  {
38 #ifdef DEBUG
39  bool debug(false);
40 #endif
41 
42  // MIMI hack: Config::nlayers_per_seed = 4
43  // const float seed_z2cut = (Config::nlayers_per_seed * Config::fRadialSpacing) / std::tan(2.0f*std::atan(std::exp(-1.0f*Config::dEtaSeedTrip)));
44 #ifdef DEBUG
45  const float seed_z2cut =
46  (4 * Config::fRadialSpacing) / std::tan(2.0f * std::atan(std::exp(-1.0f * Config::dEtaSeedTrip)));
47 #endif
48 
49  // 0 = first layer, 1 = second layer, 2 = third layer
50  const LayerOfHits& lay1_hits = evt_lay_hits[1];
51  LayerOfHits& lay0_hits = evt_lay_hits[0];
52  LayerOfHits& lay2_hits = evt_lay_hits[2];
53 
54  tbb::parallel_for(
55  tbb::blocked_range<int>(0, lay1_size, std::max(1, Config::numHitsPerTask)),
56  [&](const tbb::blocked_range<int>& i) {
57  TripletIdxVec temp_thr_seed_idcs;
58  for (int ihit1 = i.begin(); ihit1 < i.end(); ++ihit1) {
59  const Hit& hit1 = lay1_hits.refHit(ihit1);
60  const float hit1_z = hit1.z();
61 
62  dprint("ihit1: " << ihit1 << " mcTrackID: " << hit1.mcTrackID(ev->simHitsInfo_) << " phi: " << hit1.phi()
63  << " z: " << hit1.z());
64  dprint(" predphi: " << hit1.phi() << "+/-" << Config::lay01angdiff << " predz: " << hit1.z() / 2.0f << "+/-"
65  << Config::seed_z0cut / 2.0f << std::endl);
66 
67  std::vector<int> cand_hit0_indices; // pass by reference
68  // MIMI lay0_hits.selectHitIndices(hit1_z/2.0f,hit1.phi(),Config::seed_z0cut/2.0f,Config::lay01angdiff,cand_hit0_indices,true,false);
69  // loop over first layer hits
70  for (auto&& ihit0 : cand_hit0_indices) {
71  const Hit& hit0 = lay0_hits.refHit(ihit0);
72  const float hit0_z = hit0.z();
73  const float hit0_x = hit0.x();
74  const float hit0_y = hit0.y();
75  const float hit1_x = hit1.x();
76  const float hit1_y = hit1.y();
77  const float hit01_r2 = getRad2(hit0_x - hit1_x, hit0_y - hit1_y);
78 
79  const float quad = std::sqrt((4.0f * Config::maxCurvR * Config::maxCurvR - hit01_r2) / hit01_r2);
80 
81  // center of negative curved track
82  const float aneg = 0.5f * ((hit0_x + hit1_x) - (hit0_y - hit1_y) * quad);
83  const float bneg = 0.5f * ((hit0_y + hit1_y) + (hit0_x - hit1_x) * quad);
84 
85  // negative points of intersection with third layer
86  float lay2_negx = 0.0f, lay2_negy = 0.0f;
87  intersectThirdLayer(aneg, bneg, hit1_x, hit1_y, lay2_negx, lay2_negy);
88 #ifdef DEBUG
89  const float lay2_negphi = getPhi(lay2_negx, lay2_negy);
90 #endif
91 
92  // center of positive curved track
93  const float apos = 0.5f * ((hit0_x + hit1_x) + (hit0_y - hit1_y) * quad);
94  const float bpos = 0.5f * ((hit0_y + hit1_y) - (hit0_x - hit1_x) * quad);
95 
96  // positive points of intersection with third layer
97  float lay2_posx = 0.0f, lay2_posy = 0.0f;
98  intersectThirdLayer(apos, bpos, hit1_x, hit1_y, lay2_posx, lay2_posy);
99 #ifdef DEBUG
100  const float lay2_posphi = getPhi(lay2_posx, lay2_posy);
101 #endif
102 
103  std::vector<int> cand_hit2_indices;
104  // MIMI lay2_hits.selectHitIndices((2.0f*hit1_z-hit0_z),(lay2_posphi+lay2_negphi)/2.0f,
105  // MIMI seed_z2cut,(lay2_posphi-lay2_negphi)/2.0f,
106  // MIMI cand_hit2_indices,true,false);
107 
108  dprint(" ihit0: " << ihit0 << " mcTrackID: " << hit0.mcTrackID(ev->simHitsInfo_) << " phi: " << hit0.phi()
109  << " z: " << hit0.z());
110  dprint(" predphi: " << (lay2_posphi + lay2_negphi) / 2.0f << "+/-" << (lay2_posphi - lay2_negphi) / 2.0f
111  << " predz: " << 2.0f * hit1_z - hit0_z << "+/-" << seed_z2cut << std::endl);
112 
113  // loop over candidate third layer hits
114  //temp_thr_seed_idcs.reserve(temp_thr_seed_idcs.size()+cand_hit2_indices.size());
115 #pragma omp simd
116  for (size_t idx = 0; idx < cand_hit2_indices.size(); ++idx) {
117  const int ihit2 = cand_hit2_indices[idx];
118  const Hit& hit2 = lay2_hits.refHit(ihit2);
119 
120  const float lay1_predz = (hit0_z + hit2.z()) / 2.0f;
121  // filter by residual of second layer hit
122  if (std::abs(lay1_predz - hit1_z) > Config::seed_z1cut)
123  continue;
124 
125  const float hit2_x = hit2.x();
126  const float hit2_y = hit2.y();
127 
128  // now fit a circle, extract pT and d0 from center and radius
129  const float mr = (hit1_y - hit0_y) / (hit1_x - hit0_x);
130  const float mt = (hit2_y - hit1_y) / (hit2_x - hit1_x);
131  const float a = (mr * mt * (hit2_y - hit0_y) + mr * (hit1_x + hit2_x) - mt * (hit0_x + hit1_x)) /
132  (2.0f * (mr - mt));
133  const float b = -1.0f * (a - (hit0_x + hit1_x) / 2.0f) / mr + (hit0_y + hit1_y) / 2.0f;
134  const float r = getHypot(hit0_x - a, hit0_y - b);
135 
136  // filter by d0 cut 5mm, pT cut 0.5 GeV (radius of 0.5 GeV track)
137  if ((r < Config::maxCurvR) || (std::abs(getHypot(a, b) - r) > Config::seed_d0cut))
138  continue;
139 
140  dprint(" ihit2: " << ihit2 << " mcTrackID: " << hit2.mcTrackID(ev->simHitsInfo_)
141  << " phi: " << hit2.phi() << " z: " << hit2.z());
142 
143  temp_thr_seed_idcs.emplace_back(TripletIdx{{ihit0, ihit1, ihit2}});
144  } // end loop over third layer matches
145  } // end loop over first layer matches
146  } // end chunk of hits for parallel for
147  seed_idcs.grow_by(temp_thr_seed_idcs.begin(), temp_thr_seed_idcs.end());
148  }); // end parallel for loop over second layer hits
149  }
mkfit::Config::dEtaSeedTrip
constexpr float dEtaSeedTrip
Definition: ConfigStandalone.h:97
Hit::z
double z
global z - AlignmentGeometry::z0, mm
Definition: HitCollection.h:27
mps_fire.i
i
Definition: mps_fire.py:429
mkfit::Config::lay01angdiff
constexpr float lay01angdiff
Definition: ConfigStandalone.h:94
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
mkfit::intersectThirdLayer
void intersectThirdLayer(const float a, const float b, const float hit1_x, const float hit1_y, float &lay2_x, float &lay2_y)
Definition: seedtestMPlex.cc:9
mkfit::TripletIdx
std::array< int, 3 > TripletIdx
Definition: TrackExtra.h:41
HLTObjectMonitor_cfi.mr
mr
Definition: HLTObjectMonitor_cfi.py:366
mkfit::Config::seed_d0cut
constexpr float seed_d0cut
Definition: ConfigStandalone.h:105
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::getHypot
float getHypot(float x, float y)
Definition: Hit.h:47
debug
#define debug
Definition: HDRShower.cc:19
mkfit::Config::seed_z1cut
constexpr float seed_z1cut
Definition: ConfigStandalone.h:104
b
double b
Definition: hdecay.h:118
mkfit::getPhi
float getPhi(float x, float y)
Definition: Hit.h:34
dprint
#define dprint(x)
Definition: Debug.h:90
a
double a
Definition: hdecay.h:119
mkfit::Config::seed_z0cut
constexpr float seed_z0cut
Definition: ConfigStandalone.h:103
mkfit::Config::maxCurvR
constexpr float maxCurvR
Definition: ConfigStandalone.h:109
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
mkfit::TripletIdxVec
std::vector< TripletIdx > TripletIdxVec
Definition: TrackExtra.h:42
TtSemiLepEvtBuilder_cfi.mt
mt
Definition: TtSemiLepEvtBuilder_cfi.py:47

◆ 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 46 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 46 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 65 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 65 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 77 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 77 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 109 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 109 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 112 of file IterationConfig.cc.

118 {

◆ from_json() [12/12]

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

Definition at line 112 of file IterationConfig.cc.

118 {

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

38 { return -1.0f * std::log(std::tan(getTheta(r, z) / 2.0f)); }
mkfit::getTheta
float getTheta(float r, float z)
Definition: Hit.h:36
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78

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

40 { return -1.0f * std::log(std::tan(theta / 2.0f)); }
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150

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

42  {
43  const float theta = std::atan2(std::sqrt(x * x + y * y), z);
44  return -1.0f * std::log(std::tan(theta / 2.0f));
45  }
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
x
float x
Definition: beamSpotDipStandalone.cc:55
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150

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

74  {
75  const float rad2 = getRad2(x, y);
76  const float detadx = -x / (rad2 * std::sqrt(1 + rad2 / (z * z)));
77  const float detady = -y / (rad2 * std::sqrt(1 + rad2 / (z * z)));
78  const float detadz = 1.0f / (z * std::sqrt(1 + rad2 / (z * z)));
79  return detadx * detadx * exx + detady * detady * eyy + detadz * detadz * ezz + 2.0f * detadx * detady * exy +
80  2.0f * detadx * detadz * exz + 2.0f * detady * detadz * eyz;
81  }
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ 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::Track::swimPhiToR().

47 { return std::sqrt(x * x + y * y); }
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ getInvRad2()

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

Definition at line 32 of file Hit.h.

References x.

32 { return 1.0f / (x * x + y * y); }
x
float x
Definition: beamSpotDipStandalone.cc:55

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

53  {
54  return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / cube(getRad2(x, y));
55  }
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::cube
T cube(T x)
Definition: Hit.h:18
x
float x
Definition: beamSpotDipStandalone.cc:55

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

237  {
238  if (pt < 0.75f)
239  return 0;
240  else if (pt < 1.f)
241  return 1;
242  else if (pt < 2.f)
243  return 2;
244  else if (pt < 5.f)
245  return 3;
246  else if (pt < 10.f)
247  return 4;
248  else
249  return 5;
250  }
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
f
double f[11][100]
Definition: MuScleFitUtils.cc:78

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

34 { return std::atan2(y, x); }
x
float x
Definition: beamSpotDipStandalone.cc:55

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

57  {
58  const float rad2 = getRad2(x, y);
59  return (y * y * exx + x * x * eyy - 2.0f * x * y * exy) / (rad2 * rad2);
60  }
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
x
float x
Definition: beamSpotDipStandalone.cc:55

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

83  { // ipt = 1/pT, v = variance
84  const float iipt2 = 1.0f / (ipt * ipt); //iipt = 1/(1/pT) = pT
85  const float cosP = std::cos(phi);
86  const float sinP = std::sin(phi);
87  return iipt2 * (iipt2 * cosP * cosP * vipt + sinP * sinP * vphi);
88  }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22

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

90  { // ipt = 1/pT, v = variance
91  const float iipt2 = 1.0f / (ipt * ipt); //iipt = 1/(1/pT) = pT
92  const float cosP = std::cos(phi);
93  const float sinP = std::sin(phi);
94  return iipt2 * (iipt2 * sinP * sinP * vipt + cosP * cosP * vphi);
95  }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22

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

97  { // ipt = 1/pT, v = variance
98  const float iipt2 = 1.0f / (ipt * ipt); //iipt = 1/(1/pT) = pT
99  const float cotT = 1.0f / std::tan(theta);
100  const float cscT = 1.0f / std::sin(theta);
101  return iipt2 * (iipt2 * cotT * cotT * vipt + cscT * cscT * cscT * cscT * vtheta);
102  }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150

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

30 { return x * x + y * y; }
x
float x
Definition: beamSpotDipStandalone.cc:55

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

49  {
50  return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / getRad2(x, y);
51  }
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ getScoreCalc()

float mkfit::getScoreCalc ( const int  nfoundhits,
const int  ntailholes,
const int  noverlaphits,
const int  nmisshits,
const float  chi2,
const float  pt,
const bool  inFindCandidates = false 
)
inline

Definition at line 606 of file Track.h.

References hltPixelTracks_cff::chi2, f, SiStripPI::min, mkfit::Config::missingHitPenalty_, mkfit::Config::overlapHitBonus_, DiDispStaMuonMonitor_cfi::pt, mkfit::Config::tailMissingHitPenalty_, mkfit::Config::validHitBonus_, and mkfit::Config::validHitSlope_.

Referenced by getScoreCand(), and getScoreStruct().

612  {
614  // if(chi2<0) chi2=0.f;
615 
616  float maxBonus = 8.0;
617  float bonus = Config::validHitSlope_ * nfoundhits + Config::validHitBonus_;
618  float penalty = Config::missingHitPenalty_;
619  float tailPenalty = Config::tailMissingHitPenalty_;
620  float overlapBonus = Config::overlapHitBonus_;
621  if (pt < 0.9) {
622  penalty *= inFindCandidates ? 1.7f : 1.5f;
623  bonus = std::min(bonus * (inFindCandidates ? 0.9f : 1.0f), maxBonus);
624  }
625  float score_ =
626  bonus * nfoundhits + overlapBonus * noverlaphits - penalty * nmisshits - tailPenalty * ntailholes - chi2;
627  return score_;
628  }
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
mkfit::Config::validHitSlope_
constexpr float validHitSlope_
Definition: Config.h:109
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
mkfit::Config::tailMissingHitPenalty_
constexpr float tailMissingHitPenalty_
Definition: Config.h:112
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::Config::overlapHitBonus_
constexpr float overlapHitBonus_
Definition: Config.h:110
mkfit::Config::validHitBonus_
constexpr float validHitBonus_
Definition: Config.h:108
mkfit::Config::missingHitPenalty_
constexpr float missingHitPenalty_
Definition: Config.h:111

◆ getScoreCand() [1/2]

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

Definition at line 258 of file TrackStructures.h.

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

258  {
259  int nfoundhits = cand1.nFoundHits();
260  int noverlaphits = cand1.nOverlapHits();
261  int nmisshits = cand1.nInsideMinusOneHits();
262  int ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
263  float pt = cand1.pT();
264  float chi2 = cand1.chi2();
265  // Do not allow for chi2<0 in score calculation
266  if (chi2 < 0)
267  chi2 = 0.f;
268  return getScoreCalc(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
269  }
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
mkfit::getScoreCalc
float getScoreCalc(const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates=false)
Definition: Track.h:606
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39

◆ getScoreCand() [2/2]

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

Definition at line 630 of file Track.h.

References hltPixelTracks_cff::chi2, mkfit::TrackBase::chi2(), getScoreCalc(), 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::MkFinder::findCandidates(), mkfit::CombCandidate::importSeed(), mkfit::CombCandidate::mergeCandsAndBestShortOne(), mkfit::Event::print_tracks(), mkfit::StdSeq::score_tracks(), and mkfit::TTreeValidation::setTrackScoresDumbCMSSW().

630  {
631  int nfoundhits = cand1.nFoundHits();
632  int noverlaphits = cand1.nOverlapHits();
633  int nmisshits = cand1.nInsideMinusOneHits();
634  float ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
635  float pt = cand1.pT();
636  float chi2 = cand1.chi2();
637  // Do not allow for chi2<0 in score calculation
638  if (chi2 < 0)
639  chi2 = 0.f;
640  return getScoreCalc(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
641  }
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
mkfit::getScoreCalc
float getScoreCalc(const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates=false)
Definition: Track.h:606
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39

◆ getScoreStruct()

float mkfit::getScoreStruct ( const IdxChi2List &  cand1)
inline

Definition at line 643 of file Track.h.

References hltPixelTracks_cff::chi2, mkfit::IdxChi2List::chi2, getScoreCalc(), mkfit::IdxChi2List::nhits, mkfit::IdxChi2List::nholes, mkfit::IdxChi2List::noverlaps, mkfit::IdxChi2List::ntailholes, DiDispStaMuonMonitor_cfi::pt, and mkfit::IdxChi2List::pt.

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

643  {
644  int nfoundhits = cand1.nhits;
645  int ntailholes = cand1.ntailholes;
646  int noverlaphits = cand1.noverlaps;
647  int nmisshits = cand1.nholes;
648  float pt = cand1.pt;
649  float chi2 = cand1.chi2;
650  // Do not allow for chi2<0 in score calculation
651  if (chi2 < 0)
652  chi2 = 0.f;
653  return getScoreCalc(nfoundhits, ntailholes, noverlaphits, nmisshits, chi2, pt, true /*inFindCandidates*/);
654  }
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
mkfit::getScoreCalc
float getScoreCalc(const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates=false)
Definition: Track.h:606
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39

◆ getScoreWorstPossible()

float mkfit::getScoreWorstPossible ( )
inline

Definition at line 602 of file Track.h.

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

602  {
603  return -1e16; // somewhat arbitrary value, used for handling of best short track during finding (will try to take it out)
604  }

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

36 { return std::atan2(r, z); }
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14

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

63  {
64  const float rad2 = getRad2(x, y);
65  const float rad = std::sqrt(rad2);
66  const float hypot2 = rad2 + z * z;
67  const float dthetadx = x * z / (rad * hypot2);
68  const float dthetady = y * z / (rad * hypot2);
69  const float dthetadz = -rad / hypot2;
70  return dthetadx * dthetadx * exx + dthetady * dthetady * eyy + dthetadz * dthetadz * ezz +
71  2.0f * dthetadx * dthetady * exy + 2.0f * dthetadx * dthetadz * exz + 2.0f * dthetady * dthetadz * eyz;
72  }
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::getRad2
float getRad2(float x, float y)
Definition: Hit.h:30
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ 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 473 of file PropagationMPlex.cc.

References f, NN, and Matriplex::Matriplex< T, D1, D2, N >::setVal().

Referenced by propagateHelixToRMPlex().

480  {
481  errorProp.setVal(0.f);
482  outFailFlag.setVal(0.f);
483 
484  helixAtRFromIterativeCCS_impl(inPar, inChg, msRad, outPar, errorProp, outFailFlag, 0, NN, N_proc, pflags);
485  }
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
Matriplex::Matriplex::setVal
void setVal(T v)
Definition: Matriplex.h:31

◆ helixAtRFromIterativeCCSFullJac()

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

Definition at line 290 of file PropagationMPlex.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::Config::Bfield, CMS_UNROLL_LOOP_COUNT, Matriplex::Matriplex< T, D1, D2, N >::constAt(), funct::cos(), gather_cfg::cout, dprint_np, f, hipo(), mps_fire::i, dqmdumpme::k, dqmiodumpmetadata::n, mkfit::Config::Niter, NN, Matriplex::Matriplex< T, D1, D2, N >::setVal(), funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), and mkfit::Config::useTrigApprox.

295  {
296  errorProp.setVal(0.f);
297  MPlexLL errorPropTmp(0.f); //initialize to zero
298  MPlexLL errorPropSwap(0.f); //initialize to zero
299 
300 #pragma omp simd
301  for (int n = 0; n < NN; ++n) {
302  //initialize erroProp to identity matrix
303  errorProp(n, 0, 0) = 1.f;
304  errorProp(n, 1, 1) = 1.f;
305  errorProp(n, 2, 2) = 1.f;
306  errorProp(n, 3, 3) = 1.f;
307  errorProp(n, 4, 4) = 1.f;
308  errorProp(n, 5, 5) = 1.f;
309 
310  const float k = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
311  const float r = msRad.constAt(n, 0, 0);
312  float r0 = hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0));
313 
314  if (std::abs(r - r0) < 0.0001f) {
315  dprint_np(n, "distance less than 1mum, skip");
316  continue;
317  }
318 
319  const float ipt = inPar.constAt(n, 3, 0);
320  const float phiin = inPar.constAt(n, 4, 0);
321  const float theta = inPar.constAt(n, 5, 0);
322 
323  //set those that are 1. before iterations
324  errorPropTmp(n, 2, 2) = 1.f;
325  errorPropTmp(n, 3, 3) = 1.f;
326  errorPropTmp(n, 4, 4) = 1.f;
327  errorPropTmp(n, 5, 5) = 1.f;
328 
329  float cosah = 0., sinah = 0.;
330  //no trig approx here, phi and theta can be large
331  float cosP = std::cos(phiin), sinP = std::sin(phiin);
332  const float cosT = std::cos(theta), sinT = std::sin(theta);
333  float pxin = cosP / ipt;
334  float pyin = sinP / ipt;
335 
336  CMS_UNROLL_LOOP_COUNT(Config::Niter)
337  for (int i = 0; i < Config::Niter; ++i) {
338  dprint_np(n,
339  std::endl
340  << "attempt propagation from r=" << r0 << " to r=" << r << std::endl
341  << "x=" << outPar.At(n, 0, 0) << " y=" << outPar.At(n, 1, 0) << " z=" << outPar.At(n, 2, 0)
342  << " px=" << std::cos(phiin) / ipt << " py=" << std::sin(phiin) / ipt
343  << " pz=" << 1.f / (ipt * tan(theta)) << " q=" << inChg.constAt(n, 0, 0) << std::endl);
344 
345  r0 = hipo(outPar.constAt(n, 0, 0), outPar.constAt(n, 1, 0));
346  const float ialpha = (r - r0) * ipt / k;
347  //alpha+=ialpha;
348 
349  if constexpr (Config::useTrigApprox) {
350  sincos4(ialpha * 0.5f, sinah, cosah);
351  } else {
352  cosah = std::cos(ialpha * 0.5f);
353  sinah = std::sin(ialpha * 0.5f);
354  }
355  const float cosa = 1.f - 2.f * sinah * sinah;
356  const float sina = 2.f * sinah * cosah;
357 
358  //derivatives of alpha
359  const float dadx = -outPar.At(n, 0, 0) * ipt / (k * r0);
360  const float dady = -outPar.At(n, 1, 0) * ipt / (k * r0);
361  const float dadipt = (r - r0) / k;
362 
363  outPar.At(n, 0, 0) = outPar.constAt(n, 0, 0) + 2.f * k * sinah * (pxin * cosah - pyin * sinah);
364  outPar.At(n, 1, 0) = outPar.constAt(n, 1, 0) + 2.f * k * sinah * (pyin * cosah + pxin * sinah);
365  const float pxinold = pxin; //copy before overwriting
366  pxin = pxin * cosa - pyin * sina;
367  pyin = pyin * cosa + pxinold * sina;
368 
369  //need phi at origin, so this goes before redefining phi
370  //no trig approx here, phi can be large
371  cosP = std::cos(outPar.At(n, 4, 0));
372  sinP = std::sin(outPar.At(n, 4, 0));
373 
374  outPar.At(n, 2, 0) = outPar.constAt(n, 2, 0) + k * ialpha * cosT / (ipt * sinT);
375  outPar.At(n, 3, 0) = ipt;
376  outPar.At(n, 4, 0) = outPar.constAt(n, 4, 0) + ialpha;
377  outPar.At(n, 5, 0) = theta;
378 
379  errorPropTmp(n, 0, 0) = 1.f + k * (cosP * dadx * cosa - sinP * dadx * sina) / ipt;
380  errorPropTmp(n, 0, 1) = k * (cosP * dady * cosa - sinP * dady * sina) / ipt;
381  errorPropTmp(n, 0, 3) =
382  k * (cosP * (ipt * dadipt * cosa - sina) + sinP * ((1.f - cosa) - ipt * dadipt * sina)) / (ipt * ipt);
383  errorPropTmp(n, 0, 4) = -k * (sinP * sina + cosP * (1.f - cosa)) / ipt;
384 
385  errorPropTmp(n, 1, 0) = k * (sinP * dadx * cosa + cosP * dadx * sina) / ipt;
386  errorPropTmp(n, 1, 1) = 1.f + k * (sinP * dady * cosa + cosP * dady * sina) / ipt;
387  errorPropTmp(n, 1, 3) =
388  k * (sinP * (ipt * dadipt * cosa - sina) + cosP * (ipt * dadipt * sina - (1.f - cosa))) / (ipt * ipt);
389  errorPropTmp(n, 1, 4) = k * (cosP * sina - sinP * (1.f - cosa)) / ipt;
390 
391  errorPropTmp(n, 2, 0) = k * cosT * dadx / (ipt * sinT);
392  errorPropTmp(n, 2, 1) = k * cosT * dady / (ipt * sinT);
393  errorPropTmp(n, 2, 3) = k * cosT * (ipt * dadipt - ialpha) / (ipt * ipt * sinT);
394  errorPropTmp(n, 2, 5) = -k * ialpha / (ipt * sinT * sinT);
395 
396  errorPropTmp(n, 4, 0) = dadx;
397  errorPropTmp(n, 4, 1) = dady;
398  errorPropTmp(n, 4, 3) = dadipt;
399 
400  MultHelixPropTemp(errorProp, errorPropTmp, errorPropSwap, n);
401  errorProp = errorPropSwap;
402  }
403 
404  dprint_np(
405  n,
406  "propagation end, dump parameters"
407  << std::endl
408  << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
409  << "mom = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
410  << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
411  << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
412  << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
413  << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);
414 
415 #ifdef DEBUG
416  if (n < N_proc) {
417  dmutex_guard;
418  std::cout << n << " jacobian" << std::endl;
419  printf("%5f %5f %5f %5f %5f %5f\n",
420  errorProp(n, 0, 0),
421  errorProp(n, 0, 1),
422  errorProp(n, 0, 2),
423  errorProp(n, 0, 3),
424  errorProp(n, 0, 4),
425  errorProp(n, 0, 5));
426  printf("%5f %5f %5f %5f %5f %5f\n",
427  errorProp(n, 1, 0),
428  errorProp(n, 1, 1),
429  errorProp(n, 1, 2),
430  errorProp(n, 1, 3),
431  errorProp(n, 1, 4),
432  errorProp(n, 1, 5));
433  printf("%5f %5f %5f %5f %5f %5f\n",
434  errorProp(n, 2, 0),
435  errorProp(n, 2, 1),
436  errorProp(n, 2, 2),
437  errorProp(n, 2, 3),
438  errorProp(n, 2, 4),
439  errorProp(n, 2, 5));
440  printf("%5f %5f %5f %5f %5f %5f\n",
441  errorProp(n, 3, 0),
442  errorProp(n, 3, 1),
443  errorProp(n, 3, 2),
444  errorProp(n, 3, 3),
445  errorProp(n, 3, 4),
446  errorProp(n, 3, 5));
447  printf("%5f %5f %5f %5f %5f %5f\n",
448  errorProp(n, 4, 0),
449  errorProp(n, 4, 1),
450  errorProp(n, 4, 2),
451  errorProp(n, 4, 3),
452  errorProp(n, 4, 4),
453  errorProp(n, 4, 5));
454  printf("%5f %5f %5f %5f %5f %5f\n",
455  errorProp(n, 5, 0),
456  errorProp(n, 5, 1),
457  errorProp(n, 5, 2),
458  errorProp(n, 5, 3),
459  errorProp(n, 5, 4),
460  errorProp(n, 5, 5));
461  }
462 #endif
463  }
464  }
mps_fire.i
i
Definition: mps_fire.py:429
dprint_np
#define dprint_np(n, x)
Definition: Debug.h:91
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
CMS_UNROLL_LOOP_COUNT
#define CMS_UNROLL_LOOP_COUNT(N)
Definition: CMSUnrollLoop.h:48
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
mkfit::Config::Bfield
constexpr float Bfield
Definition: Config.h:88
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::Config::useTrigApprox
constexpr bool useTrigApprox
Definition: Config.h:85
mkfit::Const::sol
constexpr float sol
Definition: Config.h:48
mkfit::hipo
float hipo(float x, float y)
Definition: Matrix.h:9
gather_cfg.cout
cout
Definition: gather_cfg.py:144
Matriplex::Matriplex::setVal
void setVal(T v)
Definition: Matriplex.h:31
mkfit::sincos4
void sincos4(const float x, float &sin, float &cos)
Definition: Matrix.h:13
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54
mkfit::Config::Niter
constexpr int Niter
Definition: Config.h:84

◆ helixAtZ()

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

Definition at line 697 of file PropagationMPlex.cc.

References funct::abs(), alpha, Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::Config::Bfield, mkfit::Config::bFieldFromZR(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), funct::cos(), gather_cfg::cout, l1tTrackerHTMiss_cfi::deltaZ, dprint_np, f, hipo(), dqmdumpme::k, dqmiodumpmetadata::n, NN, DiDispStaMuonMonitor_cfi::pt, Matriplex::Matriplex< T, D1, D2, N >::setVal(), funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), mkfit::PropagationFlags::use_param_b_field, and mkfit::Config::useTrigApprox.

Referenced by propagateHelixToZMPlex().

703  {
704  errorProp.setVal(0.f);
705 
706 #pragma omp simd
707  for (int n = 0; n < NN; ++n) {
708  //initialize erroProp to identity matrix, except element 2,2 which is zero
709  errorProp(n, 0, 0) = 1.f;
710  errorProp(n, 1, 1) = 1.f;
711  errorProp(n, 3, 3) = 1.f;
712  errorProp(n, 4, 4) = 1.f;
713  errorProp(n, 5, 5) = 1.f;
714  }
715  float zout[NN];
716  float zin[NN];
717  float ipt[NN];
718  float phiin[NN];
719  float theta[NN];
720 #pragma omp simd
721  for (int n = 0; n < NN; ++n) {
722  //initialize erroProp to identity matrix, except element 2,2 which is zero
723  zout[n] = msZ.constAt(n, 0, 0);
724  zin[n] = inPar.constAt(n, 2, 0);
725  ipt[n] = inPar.constAt(n, 3, 0);
726  phiin[n] = inPar.constAt(n, 4, 0);
727  theta[n] = inPar.constAt(n, 5, 0);
728  }
729 
730  float k[NN];
731  if (pflags.use_param_b_field) {
732 #pragma omp simd
733  for (int n = 0; n < NN; ++n) {
734  k[n] = inChg.constAt(n, 0, 0) * 100.f /
735  (-Const::sol * Config::bFieldFromZR(zin[n], hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0))));
736  }
737  } else {
738 #pragma omp simd
739  for (int n = 0; n < NN; ++n) {
740  k[n] = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
741  }
742  }
743 
744  float kinv[NN];
745 #pragma omp simd
746  for (int n = 0; n < NN; ++n) {
747  kinv[n] = 1.f / k[n];
748  }
749 
750 #pragma omp simd
751  for (int n = 0; n < NN; ++n) {
752  dprint_np(n,
753  std::endl
754  << "input parameters"
755  << " inPar.constAt(n, 0, 0)=" << std::setprecision(9) << inPar.constAt(n, 0, 0)
756  << " inPar.constAt(n, 1, 0)=" << std::setprecision(9) << inPar.constAt(n, 1, 0)
757  << " inPar.constAt(n, 2, 0)=" << std::setprecision(9) << inPar.constAt(n, 2, 0)
758  << " inPar.constAt(n, 3, 0)=" << std::setprecision(9) << inPar.constAt(n, 3, 0)
759  << " inPar.constAt(n, 4, 0)=" << std::setprecision(9) << inPar.constAt(n, 4, 0)
760  << " inPar.constAt(n, 5, 0)=" << std::setprecision(9) << inPar.constAt(n, 5, 0));
761  }
762 
763  float pt[NN];
764 #pragma omp simd
765  for (int n = 0; n < NN; ++n) {
766  pt[n] = 1.f / ipt[n];
767  }
768 
769  //no trig approx here, phi can be large
770  float cosP[NN];
771  float sinP[NN];
772 #pragma omp simd
773  for (int n = 0; n < NN; ++n) {
774  cosP[n] = std::cos(phiin[n]);
775  }
776 
777 #pragma omp simd
778  for (int n = 0; n < NN; ++n) {
779  sinP[n] = std::sin(phiin[n]);
780  }
781 
782  float cosT[NN];
783  float sinT[NN];
784 #pragma omp simd
785  for (int n = 0; n < NN; ++n) {
786  cosT[n] = std::cos(theta[n]);
787  }
788 
789 #pragma omp simd
790  for (int n = 0; n < NN; ++n) {
791  sinT[n] = std::sin(theta[n]);
792  }
793 
794  float tanT[NN];
795  float icos2T[NN];
796  float pxin[NN];
797  float pyin[NN];
798 #pragma omp simd
799  for (int n = 0; n < NN; ++n) {
800  tanT[n] = sinT[n] / cosT[n];
801  icos2T[n] = 1.f / (cosT[n] * cosT[n]);
802  pxin[n] = cosP[n] * pt[n];
803  pyin[n] = sinP[n] * pt[n];
804  }
805 #pragma omp simd
806  for (int n = 0; n < NN; ++n) {
807  //fixme, make this printout useful for propagation to z
808  dprint_np(n,
809  std::endl
810  << "k=" << std::setprecision(9) << k[n] << " pxin=" << std::setprecision(9) << pxin[n]
811  << " pyin=" << std::setprecision(9) << pyin[n] << " cosP=" << std::setprecision(9) << cosP[n]
812  << " sinP=" << std::setprecision(9) << sinP[n] << " pt=" << std::setprecision(9) << pt[n]);
813  }
814  float deltaZ[NN];
815  float alpha[NN];
816 #pragma omp simd
817  for (int n = 0; n < NN; ++n) {
818  deltaZ[n] = zout[n] - zin[n];
819  alpha[n] = deltaZ[n] * tanT[n] * ipt[n] * kinv[n];
820  }
821 
822  float cosahTmp[NN];
823  float sinahTmp[NN];
824  if constexpr (Config::useTrigApprox) {
825 #if !defined(__INTEL_COMPILER)
826 #pragma omp simd
827 #endif
828  for (int n = 0; n < NN; ++n) {
829  sincos4(alpha[n] * 0.5f, sinahTmp[n], cosahTmp[n]);
830  }
831  } else {
832 #if !defined(__INTEL_COMPILER)
833 #pragma omp simd
834 #endif
835  for (int n = 0; n < NN; ++n) {
836  cosahTmp[n] = std::cos(alpha[n] * 0.5f);
837  }
838 #if !defined(__INTEL_COMPILER)
839 #pragma omp simd
840 #endif
841  for (int n = 0; n < NN; ++n) {
842  sinahTmp[n] = std::sin(alpha[n] * 0.5f);
843  }
844  }
845 
846  float cosah[NN];
847  float sinah[NN];
848  float cosa[NN];
849  float sina[NN];
850 #pragma omp simd
851  for (int n = 0; n < NN; ++n) {
852  cosah[n] = cosahTmp[n];
853  sinah[n] = sinahTmp[n];
854  cosa[n] = 1.f - 2.f * sinah[n] * sinah[n];
855  sina[n] = 2.f * sinah[n] * cosah[n];
856  }
857 //update parameters
858 #pragma omp simd
859  for (int n = 0; n < NN; ++n) {
860  outPar.At(n, 0, 0) = outPar.At(n, 0, 0) + 2.f * k[n] * sinah[n] * (pxin[n] * cosah[n] - pyin[n] * sinah[n]);
861  outPar.At(n, 1, 0) = outPar.At(n, 1, 0) + 2.f * k[n] * sinah[n] * (pyin[n] * cosah[n] + pxin[n] * sinah[n]);
862  outPar.At(n, 2, 0) = zout[n];
863  outPar.At(n, 4, 0) = phiin[n] + alpha[n];
864  }
865 
866 #pragma omp simd
867  for (int n = 0; n < NN; ++n) {
868  dprint_np(n,
869  std::endl
870  << "outPar.At(n, 0, 0)=" << outPar.At(n, 0, 0) << " outPar.At(n, 1, 0)=" << outPar.At(n, 1, 0)
871  << " pxin=" << pxin[n] << " pyin=" << pyin[n]);
872  }
873 
874  float pxcaMpysa[NN];
875 #pragma omp simd
876  for (int n = 0; n < NN; ++n) {
877  pxcaMpysa[n] = pxin[n] * cosa[n] - pyin[n] * sina[n];
878  }
879 
880 #pragma omp simd
881  for (int n = 0; n < NN; ++n) {
882  errorProp(n, 0, 2) = -tanT[n] * ipt[n] * pxcaMpysa[n];
883  errorProp(n, 0, 3) =
884  k[n] * pt[n] * pt[n] *
885  (cosP[n] * (alpha[n] * cosa[n] - sina[n]) + sinP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
886  errorProp(n, 0, 4) = -2.f * k[n] * pt[n] * sinah[n] * (sinP[n] * cosah[n] + cosP[n] * sinah[n]);
887  errorProp(n, 0, 5) = deltaZ[n] * ipt[n] * pxcaMpysa[n] * icos2T[n];
888  }
889 
890  float pycaPpxsa[NN];
891 #pragma omp simd
892  for (int n = 0; n < NN; ++n) {
893  pycaPpxsa[n] = pyin[n] * cosa[n] + pxin[n] * sina[n];
894  }
895 
896 #pragma omp simd
897  for (int n = 0; n < NN; ++n) {
898  errorProp(n, 1, 2) = -tanT[n] * ipt[n] * pycaPpxsa[n];
899  errorProp(n, 1, 3) =
900  k[n] * pt[n] * pt[n] *
901  (sinP[n] * (alpha[n] * cosa[n] - sina[n]) - cosP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
902  errorProp(n, 1, 4) = 2.f * k[n] * pt[n] * sinah[n] * (cosP[n] * cosah[n] - sinP[n] * sinah[n]);
903  errorProp(n, 1, 5) = deltaZ[n] * ipt[n] * pycaPpxsa[n] * icos2T[n];
904  }
905 
906 #pragma omp simd
907  for (int n = 0; n < NN; ++n) {
908  errorProp(n, 4, 2) = -ipt[n] * tanT[n] * kinv[n];
909  errorProp(n, 4, 3) = tanT[n] * deltaZ[n] * kinv[n];
910  errorProp(n, 4, 5) = ipt[n] * deltaZ[n] * kinv[n] * icos2T[n];
911  }
912 
913 #pragma omp simd
914  for (int n = 0; n < NN; ++n) {
915  dprint_np(
916  n,
917  "propagation end, dump parameters"
918  << std::endl
919  << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
920  << "mom = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
921  << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
922  << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
923  << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
924  << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);
925  }
926 
927 #ifdef DEBUG
928 #pragma omp simd
929  for (int n = 0; n < NN; ++n) {
930  if (n < N_proc) {
931  dmutex_guard;
932  std::cout << n << ": jacobian" << std::endl;
933  printf("%5f %5f %5f %5f %5f %5f\n",
934  errorProp(n, 0, 0),
935  errorProp(n, 0, 1),
936  errorProp(n, 0, 2),
937  errorProp(n, 0, 3),
938  errorProp(n, 0, 4),
939  errorProp(n, 0, 5));
940  printf("%5f %5f %5f %5f %5f %5f\n",
941  errorProp(n, 1, 0),
942  errorProp(n, 1, 1),
943  errorProp(n, 1, 2),
944  errorProp(n, 1, 3),
945  errorProp(n, 1, 4),
946  errorProp(n, 1, 5));
947  printf("%5f %5f %5f %5f %5f %5f\n",
948  errorProp(n, 2, 0),
949  errorProp(n, 2, 1),
950  errorProp(n, 2, 2),
951  errorProp(n, 2, 3),
952  errorProp(n, 2, 4),
953  errorProp(n, 2, 5));
954  printf("%5f %5f %5f %5f %5f %5f\n",
955  errorProp(n, 3, 0),
956  errorProp(n, 3, 1),
957  errorProp(n, 3, 2),
958  errorProp(n, 3, 3),
959  errorProp(n, 3, 4),
960  errorProp(n, 3, 5));
961  printf("%5f %5f %5f %5f %5f %5f\n",
962  errorProp(n, 4, 0),
963  errorProp(n, 4, 1),
964  errorProp(n, 4, 2),
965  errorProp(n, 4, 3),
966  errorProp(n, 4, 4),
967  errorProp(n, 4, 5));
968  printf("%5f %5f %5f %5f %5f %5f\n",
969  errorProp(n, 5, 0),
970  errorProp(n, 5, 1),
971  errorProp(n, 5, 2),
972  errorProp(n, 5, 3),
973  errorProp(n, 5, 4),
974  errorProp(n, 5, 5));
975  }
976  }
977 #endif
978  }
alpha
float alpha
Definition: AMPTWrapper.h:105
dprint_np
#define dprint_np(n, x)
Definition: Debug.h:91
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
l1tTrackerHTMiss_cfi.deltaZ
deltaZ
Definition: l1tTrackerHTMiss_cfi.py:13
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
mkfit::Config::Bfield
constexpr float Bfield
Definition: Config.h:88
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::Config::useTrigApprox
constexpr bool useTrigApprox
Definition: Config.h:85
mkfit::Const::sol
constexpr float sol
Definition: Config.h:48
mkfit::hipo
float hipo(float x, float y)
Definition: Matrix.h:9
mkfit::Config::bFieldFromZR
float bFieldFromZR(const float z, const float r)
Definition: Config.h:159
gather_cfg.cout
cout
Definition: gather_cfg.py:144
Matriplex::Matriplex::setVal
void setVal(T v)
Definition: Matriplex.h:31
mkfit::sincos4
void sincos4(const float x, float &sin, float &cos)
Definition: Matrix.h:13
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ 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(), and propagateLineToRMPlex().

9 { return std::sqrt(x * x + y * y); }
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
x
float x
Definition: beamSpotDipStandalone.cc:55

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

11 { return x * x + y * y; }
x
float x
Definition: beamSpotDipStandalone.cc:55

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

10  {
11  const float a2 = a * a;
12  const float b2 = b * b;
13  const float a2b2 = a2 + b2;
14  const float lay2rad2 = (Config::fRadialSpacing * Config::fRadialSpacing) * 9.0f; // average third radius squared
15  const float maxCurvR2 = Config::maxCurvR * Config::maxCurvR;
16 
17  const float quad =
18  std::sqrt(2.0f * maxCurvR2 * (a2b2 + lay2rad2) - (a2b2 - lay2rad2) * (a2b2 - lay2rad2) - maxCurvR2 * maxCurvR2);
19  const float pos[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) - b * quad) / a2b2,
20  (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) + a * quad) / a2b2};
21  const float neg[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) + b * quad) / a2b2,
22  (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) - a * quad) / a2b2};
23 
24  // since we have two intersection points, arbitrate which one is closer to layer2 hit
25  if (getHypot(pos[0] - hit1_x, pos[1] - hit1_y) < getHypot(neg[0] - hit1_x, neg[1] - hit1_y)) {
26  lay2_x = pos[0];
27  lay2_y = pos[1];
28  } else {
29  lay2_x = neg[0];
30  lay2_y = neg[1];
31  }
32  }
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
testProducerWithPsetDescEmpty_cfi.a2
a2
Definition: testProducerWithPsetDescEmpty_cfi.py:35
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
mkfit::getHypot
float getHypot(float x, float y)
Definition: Hit.h:47
b2
weight_default_t b2[10]
Definition: b2.h:9
b
double b
Definition: hdecay.h:118
a
double a
Definition: hdecay.h:119
mkfit::Config::maxCurvR
constexpr float maxCurvR
Definition: ConfigStandalone.h:109

◆ isStripQCompatible()

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

Definition at line 837 of file MkFinder.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), dprint, f, PixelPluginsPhase0_cfi::isBarrel, SiStripPI::max, amptDefault_cfi::proj, and mathSSE::sqrt().

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

838  {
839  //check module compatibility via long strip side = L/sqrt(12)
840  if (isBarrel) { //check z direction only
841  const float res = std::abs(msPar.constAt(itrack, 2, 0) - pPar.constAt(itrack, 2, 0));
842  const float hitHL = sqrt(msErr.constAt(itrack, 2, 2) * 3.f); //half-length
843  const float qErr = sqrt(pErr.constAt(itrack, 2, 2));
844  dprint("qCompat " << hitHL << " + " << 3.f * qErr << " vs " << res);
845  return hitHL + std::max(3.f * qErr, 0.5f) > res;
846  } else { //project on xy, assuming the strip Length >> Width
847  const float res[2]{msPar.constAt(itrack, 0, 0) - pPar.constAt(itrack, 0, 0),
848  msPar.constAt(itrack, 1, 0) - pPar.constAt(itrack, 1, 0)};
849  const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
850  const float hitT2inv = 1.f / hitT2;
851  const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
852  msErr.constAt(itrack, 0, 1) * hitT2inv,
853  msErr.constAt(itrack, 1, 1) * hitT2inv};
854  const float qErr =
855  sqrt(std::abs(pErr.constAt(itrack, 0, 0) * proj[0] + 2.f * pErr.constAt(itrack, 0, 1) * proj[1] +
856  pErr.constAt(itrack, 1, 1) * proj[2])); //take abs to avoid non-pos-def cases
857  const float resProj =
858  sqrt(res[0] * proj[0] * res[0] + 2.f * res[1] * proj[1] * res[0] + res[1] * proj[2] * res[1]);
859  dprint("qCompat " << sqrt(hitT2 * 3.f) << " + " << 3.f * qErr << " vs " << resProj);
860  return sqrt(hitT2 * 3.f) + std::max(3.f * qErr, 0.5f) > resProj;
861  }
862  }
res
Definition: Electron.h:6
PixelPluginsPhase0_cfi.isBarrel
isBarrel
Definition: PixelPluginsPhase0_cfi.py:17
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
dprint
#define dprint(x)
Definition: Debug.h:90
amptDefault_cfi.proj
proj
Definition: amptDefault_cfi.py:13

◆ 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 510 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), and KFO_Calculate_Chi2.

516  {
517  kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
518  }
mkfit::kalmanOperation
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)
Definition: KalmanUtilsMPlex.cc:549

◆ 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 774 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Calculate_Chi2.

780  {
781  kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
782  }
mkfit::kalmanOperationEndcap
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)
Definition: KalmanUtilsMPlex.cc:813

◆ 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 549 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, squashPhiMPlex(), and Matriplex::MatriplexSym< T, D, N >::subtract().

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

557  {
558 #ifdef DEBUG
559  {
560  dmutex_guard;
561  printf("psPar:\n");
562  for (int i = 0; i < 6; ++i) {
563  printf("%8f ", psPar.constAt(0, 0, i));
564  printf("\n");
565  }
566  printf("\n");
567  printf("psErr:\n");
568  for (int i = 0; i < 6; ++i) {
569  for (int j = 0; j < 6; ++j)
570  printf("%8f ", psErr.constAt(0, i, j));
571  printf("\n");
572  }
573  printf("\n");
574  printf("msPar:\n");
575  for (int i = 0; i < 3; ++i) {
576  printf("%8f ", msPar.constAt(0, 0, i));
577  printf("\n");
578  }
579  printf("\n");
580  printf("msErr:\n");
581  for (int i = 0; i < 3; ++i) {
582  for (int j = 0; j < 3; ++j)
583  printf("%8f ", msErr.constAt(0, i, j));
584  printf("\n");
585  }
586  printf("\n");
587  }
588 #endif
589 
590  // Rotate global point on tangent plane to cylinder
591  // Tangent point is half way between hit and propagate position
592 
593  // Rotation matrix
594  // rotT00 0 rotT01
595  // rotT01 0 -rotT00
596  // 0 1 0
597  // Minimize temporaries: only two float are needed!
598 
599  MPlexQF rotT00;
600  MPlexQF rotT01;
601  for (int n = 0; n < NN; ++n) {
602  const float r = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
603  rotT00.At(n, 0, 0) = -(msPar.constAt(n, 1, 0) + psPar.constAt(n, 1, 0)) / (2 * r);
604  rotT01.At(n, 0, 0) = (msPar.constAt(n, 0, 0) + psPar.constAt(n, 0, 0)) / (2 * r);
605  }
606 
607  MPlexHV res_glo; //position residual in global coordinates
608  SubtractFirst3(msPar, psPar, res_glo);
609 
610  MPlexHS resErr_glo; //covariance sum in global position coordinates
611  AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);
612 
613  MPlex2V res_loc; //position residual in local coordinates
614  RotateResidualsOnTangentPlane(rotT00, rotT01, res_glo, res_loc);
615  MPlex2S resErr_loc; //covariance sum in local position coordinates
616  MPlexHH tempHH;
617  ProjectResErr(rotT00, rotT01, resErr_glo, tempHH);
618  ProjectResErrTransp(rotT00, rotT01, tempHH, resErr_loc);
619 
620 #ifdef DEBUG
621  {
622  dmutex_guard;
623  printf("resErr_loc:\n");
624  for (int i = 0; i < 2; ++i) {
625  for (int j = 0; j < 2; ++j)
626  printf("%8f ", resErr_loc.At(0, i, j));
627  printf("\n");
628  }
629  printf("\n");
630  }
631 #endif
632 
633  //invert the 2x2 matrix
634  Matriplex::invertCramerSym(resErr_loc);
635 
636  if (kfOp & KFO_Calculate_Chi2) {
637  Chi2Similarity(res_loc, resErr_loc, outChi2);
638 
639 #ifdef DEBUG
640  {
641  dmutex_guard;
642  printf("resErr_loc (Inv):\n");
643  for (int i = 0; i < 2; ++i) {
644  for (int j = 0; j < 2; ++j)
645  printf("%8f ", resErr_loc.At(0, i, j));
646  printf("\n");
647  }
648  printf("\n");
649  printf("chi2: %8f\n", outChi2.At(0, 0, 0));
650  }
651 #endif
652  }
653 
654  if (kfOp & KFO_Update_Params) {
655  MPlexLS psErrLoc = psErr;
656  if (kfOp & KFO_Local_Cov)
657  CovXYconstrain(rotT00, rotT01, psErr, psErrLoc);
658 
659  MPlexLH K; // kalman gain, fixme should be L2
660  KalmanHTG(rotT00, rotT01, resErr_loc, tempHH); // intermediate term to get kalman gain (H^T*G)
661  KalmanGain(psErrLoc, tempHH, K);
662 
663  MultResidualsAdd(K, psPar, res_loc, outPar);
664  MPlexLL tempLL;
665 
666  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
667 
668  KHMult(K, rotT00, rotT01, tempLL);
669  KHC(tempLL, psErrLoc, outErr);
670  outErr.subtract(psErrLoc, outErr);
671 
672 #ifdef DEBUG
673  {
674  dmutex_guard;
675  if (kfOp & KFO_Local_Cov) {
676  printf("psErrLoc:\n");
677  for (int i = 0; i < 6; ++i) {
678  for (int j = 0; j < 6; ++j)
679  printf("% 8e ", psErrLoc.At(0, i, j));
680  printf("\n");
681  }
682  printf("\n");
683  }
684  printf("res_glo:\n");
685  for (int i = 0; i < 3; ++i) {
686  printf("%8f ", res_glo.At(0, i, 0));
687  }
688  printf("\n");
689  printf("res_loc:\n");
690  for (int i = 0; i < 2; ++i) {
691  printf("%8f ", res_loc.At(0, i, 0));
692  }
693  printf("\n");
694  printf("resErr_loc (Inv):\n");
695  for (int i = 0; i < 2; ++i) {
696  for (int j = 0; j < 2; ++j)
697  printf("%8f ", resErr_loc.At(0, i, j));
698  printf("\n");
699  }
700  printf("\n");
701  printf("K:\n");
702  for (int i = 0; i < 6; ++i) {
703  for (int j = 0; j < 3; ++j)
704  printf("%8f ", K.At(0, i, j));
705  printf("\n");
706  }
707  printf("\n");
708  printf("outPar:\n");
709  for (int i = 0; i < 6; ++i) {
710  printf("%8f ", outPar.At(0, i, 0));
711  }
712  printf("\n");
713  printf("outErr:\n");
714  for (int i = 0; i < 6; ++i) {
715  for (int j = 0; j < 6; ++j)
716  printf("%8f ", outErr.At(0, i, j));
717  printf("\n");
718  }
719  printf("\n");
720  }
721 #endif
722  }
723  }
Matriplex::MatriplexSym::subtract
MatriplexSym & subtract(const MatriplexSym &a, const MatriplexSym &b)
Definition: MatriplexSym.h:212
mps_fire.i
i
Definition: mps_fire.py:429
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
Matriplex::MatriplexSym::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: MatriplexSym.h:71
mkfit::squashPhiMPlex
void squashPhiMPlex(MPlexLV &par, const int N_proc)
Definition: PropagationMPlex.h:8
Matriplex::invertCramerSym
void invertCramerSym(MPlexSym< T, D, N > &A, double *determ=nullptr)
Definition: MatriplexSym.h:410
Matriplex::MatriplexSym::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: MatriplexSym.h:69
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ 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 813 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Update_Params, squashPhiMPlex(), and Matriplex::MatriplexSym< T, D, N >::subtract().

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

821  {
822 #ifdef DEBUG
823  {
824  dmutex_guard;
825  printf("updateParametersEndcapMPlex\n");
826  printf("psPar:\n");
827  for (int i = 0; i < 6; ++i) {
828  printf("%8f ", psPar.constAt(0, 0, i));
829  printf("\n");
830  }
831  printf("\n");
832  printf("msPar:\n");
833  for (int i = 0; i < 3; ++i) {
834  printf("%8f ", msPar.constAt(0, 0, i));
835  printf("\n");
836  }
837  printf("\n");
838  printf("psErr:\n");
839  for (int i = 0; i < 6; ++i) {
840  for (int j = 0; j < 6; ++j)
841  printf("%8f ", psErr.constAt(0, i, j));
842  printf("\n");
843  }
844  printf("\n");
845  printf("msErr:\n");
846  for (int i = 0; i < 3; ++i) {
847  for (int j = 0; j < 3; ++j)
848  printf("%8f ", msErr.constAt(0, i, j));
849  printf("\n");
850  }
851  printf("\n");
852  }
853 #endif
854 
855  MPlex2V res;
856  SubtractFirst2(msPar, psPar, res);
857 
858  MPlex2S resErr;
859  AddIntoUpperLeft2x2(psErr, msErr, resErr);
860 
861 #ifdef DEBUG
862  {
863  dmutex_guard;
864  printf("resErr:\n");
865  for (int i = 0; i < 2; ++i) {
866  for (int j = 0; j < 2; ++j)
867  printf("%8f ", resErr.At(0, i, j));
868  printf("\n");
869  }
870  printf("\n");
871  }
872 #endif
873 
874  //invert the 2x2 matrix
875  Matriplex::invertCramerSym(resErr);
876 
877  if (kfOp & KFO_Calculate_Chi2) {
878  Chi2Similarity(res, resErr, outChi2);
879 
880 #ifdef DEBUG
881  {
882  dmutex_guard;
883  printf("resErr_loc (Inv):\n");
884  for (int i = 0; i < 2; ++i) {
885  for (int j = 0; j < 2; ++j)
886  printf("%8f ", resErr.At(0, i, j));
887  printf("\n");
888  }
889  printf("\n");
890  printf("chi2: %8f\n", outChi2.At(0, 0, 0));
891  }
892 #endif
893  }
894 
895  if (kfOp & KFO_Update_Params) {
896  MPlexL2 K;
897  KalmanGain(psErr, resErr, K);
898 
899  MultResidualsAdd(K, psPar, res, outPar);
900 
901  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
902 
903  KHC(K, psErr, outErr);
904 
905 #ifdef DEBUG
906  {
907  dmutex_guard;
908  printf("outErr before subtract:\n");
909  for (int i = 0; i < 6; ++i) {
910  for (int j = 0; j < 6; ++j)
911  printf("%8f ", outErr.At(0, i, j));
912  printf("\n");
913  }
914  printf("\n");
915  }
916 #endif
917 
918  outErr.subtract(psErr, outErr);
919 
920 #ifdef DEBUG
921  {
922  dmutex_guard;
923  printf("res:\n");
924  for (int i = 0; i < 2; ++i) {
925  printf("%8f ", res.At(0, i, 0));
926  }
927  printf("\n");
928  printf("resErr (Inv):\n");
929  for (int i = 0; i < 2; ++i) {
930  for (int j = 0; j < 2; ++j)
931  printf("%8f ", resErr.At(0, i, j));
932  printf("\n");
933  }
934  printf("\n");
935  printf("K:\n");
936  for (int i = 0; i < 6; ++i) {
937  for (int j = 0; j < 2; ++j)
938  printf("%8f ", K.At(0, i, j));
939  printf("\n");
940  }
941  printf("\n");
942  printf("outPar:\n");
943  for (int i = 0; i < 6; ++i) {
944  printf("%8f ", outPar.At(0, i, 0));
945  }
946  printf("\n");
947  printf("outErr:\n");
948  for (int i = 0; i < 6; ++i) {
949  for (int j = 0; j < 6; ++j)
950  printf("%8f ", outErr.At(0, i, j));
951  printf("\n");
952  }
953  printf("\n");
954  }
955 #endif
956  }
957  }
Matriplex::MatriplexSym::subtract
MatriplexSym & subtract(const MatriplexSym &a, const MatriplexSym &b)
Definition: MatriplexSym.h:212
mps_fire.i
i
Definition: mps_fire.py:429
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
Matriplex::MatriplexSym::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: MatriplexSym.h:71
res
Definition: Electron.h:6
mkfit::squashPhiMPlex
void squashPhiMPlex(MPlexLV &par, const int N_proc)
Definition: PropagationMPlex.h:8
Matriplex::invertCramerSym
void invertCramerSym(MPlexSym< T, D, N > &A, double *determ=nullptr)
Definition: MatriplexSym.h:410
Matriplex::MatriplexSym::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: MatriplexSym.h:69
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ kalmanPropagateAndComputeChi2()

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

Definition at line 520 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), kalmanOperation(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

529  {
530  propPar = psPar;
531  if (propToHit) {
532  MPlexLS propErr;
533  MPlexQF msRad;
534 #pragma omp simd
535  for (int n = 0; n < NN; ++n) {
536  msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
537  }
538 
539  propagateHelixToRMPlex(psErr, psPar, inChg, msRad, propErr, propPar, N_proc, propFlags);
540 
541  kalmanOperation(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
542  } else {
543  kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
544  }
545  }
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
mkfit::propagateHelixToRMPlex
void propagateHelixToRMPlex(const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const PropagationFlags pflags, const MPlexQI *noMatEffPtr)
Definition: PropagationMPlex.cc:487
mkfit::kalmanOperation
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)
Definition: KalmanUtilsMPlex.cc:549
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ kalmanPropagateAndComputeChi2Endcap()

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

Definition at line 784 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), kalmanOperationEndcap(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

793  {
794  propPar = psPar;
795  if (propToHit) {
796  MPlexLS propErr;
797  MPlexQF msZ;
798 #pragma omp simd
799  for (int n = 0; n < NN; ++n) {
800  msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
801  }
802 
803  propagateHelixToZMPlex(psErr, psPar, inChg, msZ, propErr, propPar, N_proc, propFlags);
804 
805  kalmanOperationEndcap(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
806  } else {
807  kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
808  }
809  }
mkfit::kalmanOperationEndcap
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)
Definition: KalmanUtilsMPlex.cc:813
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
mkfit::propagateHelixToZMPlex
void propagateHelixToZMPlex(const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const PropagationFlags pflags, const MPlexQI *noMatEffPtr)
Definition: PropagationMPlex.cc:595
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ kalmanPropagateAndUpdate()

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

Definition at line 473 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), kalmanOperation(), KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

482  {
483  if (propToHit) {
484  MPlexLS propErr;
485  MPlexLV propPar;
486  MPlexQF msRad;
487 #pragma omp simd
488  for (int n = 0; n < NN; ++n) {
489  msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
490  }
491 
492  propagateHelixToRMPlex(psErr, psPar, Chg, msRad, propErr, propPar, N_proc, propFlags);
493 
494  kalmanOperation(
495  KFO_Update_Params | KFO_Local_Cov, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
496  } else {
497  kalmanOperation(
498  KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
499  }
500  for (int n = 0; n < NN; ++n) {
501  if (outPar.At(n, 3, 0) < 0) {
502  Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
503  outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
504  }
505  }
506  }
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
mkfit::propagateHelixToRMPlex
void propagateHelixToRMPlex(const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const PropagationFlags pflags, const MPlexQI *noMatEffPtr)
Definition: PropagationMPlex.cc:487
mkfit::kalmanOperation
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)
Definition: KalmanUtilsMPlex.cc:549
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ kalmanPropagateAndUpdateEndcap()

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

Definition at line 739 of file KalmanUtilsMPlex.cc.

References Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), kalmanOperationEndcap(), KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

748  {
749  if (propToHit) {
750  MPlexLS propErr;
751  MPlexLV propPar;
752  MPlexQF msZ;
753 #pragma omp simd
754  for (int n = 0; n < NN; ++n) {
755  msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
756  }
757 
758  propagateHelixToZMPlex(psErr, psPar, Chg, msZ, propErr, propPar, N_proc, propFlags);
759 
760  kalmanOperationEndcap(KFO_Update_Params, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
761  } else {
762  kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
763  }
764  for (int n = 0; n < NN; ++n) {
765  if (outPar.At(n, 3, 0) < 0) {
766  Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
767  outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
768  }
769  }
770  }
mkfit::kalmanOperationEndcap
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)
Definition: KalmanUtilsMPlex.cc:813
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
mkfit::propagateHelixToZMPlex
void propagateHelixToZMPlex(const MPlexLS &inErr, const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const PropagationFlags pflags, const MPlexQI *noMatEffPtr)
Definition: PropagationMPlex.cc:595
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54

◆ 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 463 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), KFO_Local_Cov, and KFO_Update_Params.

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

469  {
470  kalmanOperation(KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
471  }
mkfit::kalmanOperation
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)
Definition: KalmanUtilsMPlex.cc:549

◆ 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 729 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Update_Params.

735  {
736  kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
737  }
mkfit::kalmanOperationEndcap
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)
Definition: KalmanUtilsMPlex.cc:813

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

151  {
152  return a.pool_id() == b.pool_id();
153  }
b
double b
Definition: hdecay.h:118
a
double a
Definition: hdecay.h:119

◆ passStripChargePCMfromTrack()

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

Definition at line 869 of file MkFinder.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), 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().

870  {
871  //skip the overflow case
872  if (pcm >= Hit::maxChargePerCM())
873  return true;
874 
875  float qSF;
876  if (isBarrel) { //project in x,y, assuming zero-error direction is in this plane
877  const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
878  const float hitT2inv = 1.f / hitT2;
879  const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
880  msErr.constAt(itrack, 0, 1) * hitT2inv,
881  msErr.constAt(itrack, 1, 1) * hitT2inv};
882  const bool detXY_OK =
883  std::abs(proj[0] * proj[2] - proj[1] * proj[1]) < 0.1f; //check that zero-direction is close
884  const float cosP = cos(pPar.constAt(itrack, 4, 0));
885  const float sinP = sin(pPar.constAt(itrack, 4, 0));
886  const float sinT = std::abs(sin(pPar.constAt(itrack, 5, 0)));
887  //qSF = sqrt[(px,py)*(1-proj)*(px,py)]/p = sinT*sqrt[(cosP,sinP)*(1-proj)*(cosP,sinP)].
888  qSF = detXY_OK ? sinT * std::sqrt(std::abs(1.f + cosP * cosP * proj[0] + sinP * sinP * proj[2] -
889  2.f * cosP * sinP * proj[1]))
890  : 1.f;
891  } else { //project on z
892  // p_zLocal/p = p_z/p = cosT
893  qSF = std::abs(cos(pPar.constAt(itrack, 5, 0)));
894  }
895 
896  const float qCorr = pcm * qSF;
897  dprint("pcm " << pcm << " * " << qSF << " = " << qCorr << " vs " << pcmMin);
898  return qCorr > pcmMin;
899  }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
PixelPluginsPhase0_cfi.isBarrel
isBarrel
Definition: PixelPluginsPhase0_cfi.py:17
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
dprint
#define dprint(x)
Definition: Debug.h:90
amptDefault_cfi.proj
proj
Definition: amptDefault_cfi.py:13

◆ print() [1/4]

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 conformalFitMPlex(), print(), mkfit::MkBuilder::seed_post_cleaning(), and mkfit::StdSeq::track_print().

8  {
9  std::cout << label << std::endl;
10  std::cout << "x: " << s.parameters()[0] << " y: " << s.parameters()[1] << " z: " << s.parameters()[2] << std::endl
11  << "errors: " << std::endl;
12  dumpMatrix(s.errors());
13  std::cout << std::endl;
14  }
label
char const * label
Definition: PFTauDecayModeTools.cc:11
mkfit::dumpMatrix
void dumpMatrix(Matrix m)
Definition: MatrixSTypes.h:37
gather_cfg.cout
cout
Definition: gather_cfg.py:144

◆ print() [2/4]

void mkfit::print ( const TrackState &  s)

Definition at line 402 of file Track.cc.

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

402  {
403  std::cout << " x: " << s.parameters[0] << " y: " << s.parameters[1] << " z: " << s.parameters[2] << std::endl
404  << " px: " << s.parameters[3] << " py: " << s.parameters[4] << " pz: " << s.parameters[5] << std::endl
405  << "valid: " << s.valid << " errors: " << std::endl;
406  dumpMatrix(s.errors);
407  std::cout << std::endl;
408  }
mkfit::dumpMatrix
void dumpMatrix(Matrix m)
Definition: MatrixSTypes.h:37
gather_cfg.cout
cout
Definition: gather_cfg.py:144

◆ print() [3/4]

void mkfit::print ( std::string  label,
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, label, mkfit::Track::nFoundHits(), mkfit::Track::nTotalHits(), print(), and mkfit::TrackBase::state().

410  {
411  std::cout << std::endl << label << ": " << itrack << " hits: " << trk.nFoundHits() << " State" << std::endl;
412  print(trk.state());
413  if (print_hits) {
414  for (int i = 0; i < trk.nTotalHits(); ++i)
415  printf(" %2d: lyr %2d idx %d\n", i, trk.getHitLyr(i), trk.getHitIdx(i));
416  }
417  }
mps_fire.i
i
Definition: mps_fire.py:429
label
char const * label
Definition: PFTauDecayModeTools.cc:11
print
void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)
Definition: Utilities.cc:47
gather_cfg.cout
cout
Definition: gather_cfg.py:144

◆ print() [4/4]

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

Definition at line 419 of file Track.cc.

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

419  {
420  std::cout << label << std::endl;
421  print(s);
422  }
label
char const * label
Definition: PFTauDecayModeTools.cc:11
print
void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)
Definition: Utilities.cc:47
gather_cfg.cout
cout
Definition: gather_cfg.py:144

◆ propagateHelixToRMPlex()

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

Definition at line 487 of file PropagationMPlex.cc.

References mkfit::PropagationFlags::apply_material, applyMaterialEffects(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::Matriplex< T, D1, D2, N >::copySlot(), Matriplex::MatriplexSym< T, D, N >::copySlot(), dprintf, helixAtRFromIterativeCCS(), hipo(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::Config::materialEff, dqmiodumpmetadata::n, mkfit::Config::nBinsRME, NN, squashPhiMPlex(), and groupFilesInBlocks::temp.

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

495  {
496  // bool debug = true;
497 
498  // This is used further down when calculating similarity with errorProp (and before in DEBUG).
499  // MT: I don't think this really needed if we use inErr where required.
500  outErr = inErr;
501  // This requirement for helixAtRFromIterativeCCS_impl() and for helixAtRFromIterativeCCSFullJac().
502  // MT: This should be properly handled in both functions (expecting input in output parameters sucks).
503  outPar = inPar;
504 
505  MPlexLL errorProp;
506  MPlexQI failFlag;
507 
508  helixAtRFromIterativeCCS(inPar, inChg, msRad, outPar, errorProp, failFlag, N_proc, pflags);
509 
510 #ifdef DEBUG
511  {
512  for (int kk = 0; kk < N_proc; ++kk) {
513  dprintf("outErr before prop %d\n", kk);
514  for (int i = 0; i < 6; ++i) {
515  for (int j = 0; j < 6; ++j)
516  dprintf("%8f ", outErr.At(kk, i, j));
517  printf("\n");
518  }
519  dprintf("\n");
520 
521  dprintf("errorProp %d\n", kk);
522  for (int i = 0; i < 6; ++i) {
523  for (int j = 0; j < 6; ++j)
524  dprintf("%8f ", errorProp.At(kk, i, j));
525  printf("\n");
526  }
527  dprintf("\n");
528  }
529  }
530 #endif
531 
532  if (pflags.apply_material) {
533  MPlexQF hitsRl;
534  MPlexQF hitsXi;
535  MPlexQF propSign;
536 #pragma omp simd
537  for (int n = 0; n < NN; ++n) {
538  if (n >= N_proc || (failFlag(n, 0, 0) || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0)))) {
539  hitsRl(n, 0, 0) = 0.f;
540  hitsXi(n, 0, 0) = 0.f;
541  } else {
542  const int zbin = Config::materialEff.getZbin(outPar(n, 2, 0));
543  const int rbin = Config::materialEff.getRbin(msRad(n, 0, 0));
544  hitsRl(n, 0, 0) = (zbin >= 0 && zbin < Config::nBinsZME && rbin >= 0 && rbin < Config::nBinsRME)
545  ? Config::materialEff.getRlVal(zbin, rbin)
546  : 0.f; // protect against crazy propagations
547  hitsXi(n, 0, 0) = (zbin >= 0 && zbin < Config::nBinsZME && rbin >= 0 && rbin < Config::nBinsRME)
548  ? Config::materialEff.getXiVal(zbin, rbin)
549  : 0.f; // protect against crazy propagations
550  }
551  const float r0 = hipo(inPar(n, 0, 0), inPar(n, 1, 0));
552  const float r = msRad(n, 0, 0);
553  propSign(n, 0, 0) = (r > r0 ? 1. : -1.);
554  }
555  applyMaterialEffects(hitsRl, hitsXi, propSign, outErr, outPar, N_proc, true);
556  }
557 
558  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
559 
560  // Matriplex version of:
561  // result.errors = ROOT::Math::Similarity(errorProp, outErr);
562 
563  // MultHelixProp can be optimized for CCS coordinates, see GenMPlexOps.pl
564  MPlexLL temp;
565  MultHelixProp(errorProp, outErr, temp);
566  MultHelixPropTransp(errorProp, temp, outErr);
567 
568  /*
569  // To be used with: MPT_DIM = 1
570  if (fabs(sqrt(outPar[0]*outPar[0]+outPar[1]*outPar[1]) - msRad[0]) > 0.0001)
571  {
572  std::cout << "DID NOT GET TO R, FailFlag=" << failFlag[0]
573  << " dR=" << msRad[0] - std::hypot(outPar[0],outPar[1])
574  << " r=" << msRad[0] << " rin=" << std::hypot(inPar[0],inPar[1]) << " rout=" << std::hypot(outPar[0],outPar[1])
575  << std::endl;
576  // std::cout << " pt=" << pt << " pz=" << inPar.At(n, 2) << std::endl;
577  }
578  */
579 
580  // FIXUP BOTCHED (low pT) propagations.
581  // For now let's enforce reseting output to input for failed cases. But:
582  // - perhaps this should be optional;
583  // - alternatively, it could also be an extra output parameter;
584  // - if we pass fail outwards, we might *not* need to also reset botched output.
585  for (int i = 0; i < N_proc; ++i) {
586  if (failFlag(i, 0, 0)) {
587  outPar.copySlot(i, inPar);
588  outErr.copySlot(i, inErr);
589  }
590  }
591  }
mps_fire.i
i
Definition: mps_fire.py:429
Matriplex::MatriplexSym::copySlot
void copySlot(idx_t n, const MatriplexSym &m)
Definition: MatriplexSym.h:81
mkfit::Config::materialEff
const MaterialEffects materialEff
Definition: MaterialEffects.cc:49
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
Matriplex::MatriplexSym::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: MatriplexSym.h:71
mkfit::squashPhiMPlex
void squashPhiMPlex(MPlexLV &par, const int N_proc)
Definition: PropagationMPlex.h:8
mkfit::Config::nBinsRME
constexpr int nBinsRME
Definition: MaterialEffects.h:15
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
mkfit::hipo
float hipo(float x, float y)
Definition: Matrix.h:9
mkfit::applyMaterialEffects
void applyMaterialEffects(const MPlexQF &hitsRl, const MPlexQF &hitsXi, const MPlexQF &propSign, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const bool isBarrel)
Definition: PropagationMPlex.cc:982
GetRecoTauVFromDQM_MC_cff.kk
kk
Definition: GetRecoTauVFromDQM_MC_cff.py:84
Matriplex::Matriplex::copySlot
void copySlot(idx_t n, const Matriplex &m)
Definition: Matriplex.h:64
mkfit::helixAtRFromIterativeCCS
void helixAtRFromIterativeCCS(const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msRad, MPlexLV &outPar, MPlexLL &errorProp, MPlexQI &outFailFlag, const int N_proc, const PropagationFlags pflags)
Definition: PropagationMPlex.cc:473
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54
dprintf
#define dprintf(...)
Definition: Debug.h:93

◆ propagateHelixToZMPlex()

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

Definition at line 595 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), dprintf, helixAtZ(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::Config::materialEff, dqmiodumpmetadata::n, mkfit::Config::nBinsRME, NN, squashPhiMPlex(), and groupFilesInBlocks::temp.

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

603  {
604  // debug = true;
605 
606  outErr = inErr;
607  outPar = inPar;
608 
609  MPlexLL errorProp;
610 
611  helixAtZ(inPar, inChg, msZ, outPar, errorProp, N_proc, pflags);
612 
613 #ifdef DEBUG
614  {
615  for (int kk = 0; kk < N_proc; ++kk) {
616  dprintf("inErr %d\n", kk);
617  for (int i = 0; i < 6; ++i) {
618  for (int j = 0; j < 6; ++j)
619  dprintf("%8f ", inErr.constAt(kk, i, j));
620  printf("\n");
621  }
622  dprintf("\n");
623 
624  dprintf("errorProp %d\n", kk);
625  for (int i = 0; i < 6; ++i) {
626  for (int j = 0; j < 6; ++j)
627  dprintf("%8f ", errorProp.At(kk, i, j));
628  printf("\n");
629  }
630  dprintf("\n");
631  }
632  }
633 #endif
634 
635  if (pflags.apply_material) {
636  MPlexQF hitsRl;
637  MPlexQF hitsXi;
638  MPlexQF propSign;
639 #pragma omp simd
640  for (int n = 0; n < NN; ++n) {
641  if (n >= N_proc || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
642  hitsRl(n, 0, 0) = 0.f;
643  hitsXi(n, 0, 0) = 0.f;
644  } else {
645  const int zbin = Config::materialEff.getZbin(msZ(n, 0, 0));
646  const int rbin = Config::materialEff.getRbin(std::hypot(outPar(n, 0, 0), outPar(n, 1, 0)));
647  hitsRl(n, 0, 0) = (zbin >= 0 && zbin < Config::nBinsZME && rbin >= 0 && rbin < Config::nBinsRME)
648  ? Config::materialEff.getRlVal(zbin, rbin)
649  : 0.f; // protect against crazy propagations
650  hitsXi(n, 0, 0) = (zbin >= 0 && zbin < Config::nBinsZME && rbin >= 0 && rbin < Config::nBinsRME)
651  ? Config::materialEff.getXiVal(zbin, rbin)
652  : 0.f; // protect against crazy propagations
653  }
654  const float zout = msZ.constAt(n, 0, 0);
655  const float zin = inPar.constAt(n, 2, 0);
656  propSign(n, 0, 0) = (std::abs(zout) > std::abs(zin) ? 1. : -1.);
657  }
658  applyMaterialEffects(hitsRl, hitsXi, propSign, outErr, outPar, N_proc, false);
659  }
660 
661  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
662 
663  // Matriplex version of:
664  // result.errors = ROOT::Math::Similarity(errorProp, outErr);
665  MPlexLL temp;
666  MultHelixPropEndcap(errorProp, outErr, temp);
667  MultHelixPropTranspEndcap(errorProp, temp, outErr);
668 
669  // This dump is now out of its place as similarity is done with matriplex ops.
670  /*
671 #ifdef DEBUG
672  {
673  dmutex_guard;
674  for (int kk = 0; kk < N_proc; ++kk)
675  {
676  dprintf("outErr %d\n", kk);
677  for (int i = 0; i < 6; ++i) { for (int j = 0; j < 6; ++j)
678  dprintf("%8f ", outErr.At(kk,i,j)); printf("\n");
679  } dprintf("\n");
680 
681  dprintf("outPar %d\n", kk);
682  for (int i = 0; i < 6; ++i) {
683  dprintf("%8f ", outPar.At(kk,i,0)); printf("\n");
684  } dprintf("\n");
685  if (std::abs(outPar.At(kk,2,0) - msZ.constAt(kk, 0, 0)) > 0.0001) {
686  float pt = 1.0f / inPar.constAt(kk,3,0);
687  dprint_np(kk, "DID NOT GET TO Z, dZ=" << std::abs(outPar.At(kk,2,0) - msZ.constAt(kk, 0, 0))
688  << " z=" << msZ.constAt(kk, 0, 0) << " zin=" << inPar.constAt(kk,2,0) << " zout=" << outPar.At(kk,2,0) << std::endl
689  << "pt=" << pt << " pz=" << pt/std::tan(inPar.constAt(kk,5,0)));
690  }
691  }
692  }
693 #endif
694  */
695  }
mps_fire.i
i
Definition: mps_fire.py:429
mkfit::Config::materialEff
const MaterialEffects materialEff
Definition: MaterialEffects.cc:49
Matriplex::Matriplex::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: Matriplex.h:52
mkfit::squashPhiMPlex
void squashPhiMPlex(MPlexLV &par, const int N_proc)
Definition: PropagationMPlex.h:8
Matriplex::MatriplexSym::constAt
const T & constAt(idx_t n, idx_t i, idx_t j) const
Definition: MatriplexSym.h:69
mkfit::Config::nBinsRME
constexpr int nBinsRME
Definition: MaterialEffects.h:15
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
mkfit::applyMaterialEffects
void applyMaterialEffects(const MPlexQF &hitsRl, const MPlexQF &hitsXi, const MPlexQF &propSign, MPlexLS &outErr, MPlexLV &outPar, const int N_proc, const bool isBarrel)
Definition: PropagationMPlex.cc:982
GetRecoTauVFromDQM_MC_cff.kk
kk
Definition: GetRecoTauVFromDQM_MC_cff.py:84
Matriplex::Matriplex::At
T & At(idx_t n, idx_t i, idx_t j)
Definition: Matriplex.h:54
dprintf
#define dprintf(...)
Definition: Debug.h:93
mkfit::helixAtZ
void helixAtZ(const MPlexLV &inPar, const MPlexQI &inChg, const MPlexQF &msZ, MPlexLV &outPar, MPlexLL &errorProp, const int N_proc, const PropagationFlags pflags)
Definition: PropagationMPlex.cc:697

◆ 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 17 of file PropagationMPlex.cc.

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

23  {
24  // XXX Regenerate parts below with a script.
25 
26  const idx_t N = NN;
27 
28 #pragma omp simd
29  for (int n = 0; n < NN; ++n) {
30  const float cosA = (psPar[0 * N + n] * psPar[3 * N + n] + psPar[1 * N + n] * psPar[4 * N + n]) /
31  (std::sqrt((psPar[0 * N + n] * psPar[0 * N + n] + psPar[1 * N + n] * psPar[1 * N + n]) *
32  (psPar[3 * N + n] * psPar[3 * N + n] + psPar[4 * N + n] * psPar[4 * N + n])));
33  const float dr = (hipo(msPar[0 * N + n], msPar[1 * N + n]) - hipo(psPar[0 * N + n], psPar[1 * N + n])) / cosA;
34 
35  dprint_np(n, "propagateLineToRMPlex dr=" << dr);
36 
37  const float pt = hipo(psPar[3 * N + n], psPar[4 * N + n]);
38  const float p = dr / pt; // path
39  const float psq = p * p;
40 
41  outPar[0 * N + n] = psPar[0 * N + n] + p * psPar[3 * N + n];
42  outPar[1 * N + n] = psPar[1 * N + n] + p * psPar[4 * N + n];
43  outPar[2 * N + n] = psPar[2 * N + n] + p * psPar[5 * N + n];
44  outPar[3 * N + n] = psPar[3 * N + n];
45  outPar[4 * N + n] = psPar[4 * N + n];
46  outPar[5 * N + n] = psPar[5 * N + n];
47 
48  {
49  const MPlexLS& A = psErr;
50  MPlexLS& B = outErr;
51 
52  B.fArray[0 * N + n] = A.fArray[0 * N + n];
53  B.fArray[1 * N + n] = A.fArray[1 * N + n];
54  B.fArray[2 * N + n] = A.fArray[2 * N + n];
55  B.fArray[3 * N + n] = A.fArray[3 * N + n];
56  B.fArray[4 * N + n] = A.fArray[4 * N + n];
57  B.fArray[5 * N + n] = A.fArray[5 * N + n];
58  B.fArray[6 * N + n] = A.fArray[6 * N + n] + p * A.fArray[0 * N + n];
59  B.fArray[7 * N + n] = A.fArray[7 * N + n] + p * A.fArray[1 * N + n];
60  B.fArray[8 * N + n] = A.fArray[8 * N + n] + p * A.fArray[3 * N + n];
61  B.fArray[9 * N + n] =
62  A.fArray[9 * N + n] + p * (A.fArray[6 * N + n] + A.fArray[6 * N + n]) + psq * A.fArray[0 * N + n];
63  B.fArray[10 * N + n] = A.fArray[10 * N + n] + p * A.fArray[1 * N + n];
64  B.fArray[11 * N + n] = A.fArray[11 * N + n] + p * A.fArray[2 * N + n];
65  B.fArray[12 * N + n] = A.fArray[12 * N + n] + p * A.fArray[4 * N + n];
66  B.fArray[13 * N + n] =
67  A.fArray[13 * N + n] + p * (A.fArray[7 * N + n] + A.fArray[10 * N + n]) + psq * A.fArray[1 * N + n];
68  B.fArray[14 * N + n] =
69  A.fArray[14 * N + n] + p * (A.fArray[11 * N + n] + A.fArray[11 * N + n]) + psq * A.fArray[2 * N + n];
70  B.fArray[15 * N + n] = A.fArray[15 * N + n] + p * A.fArray[3 * N + n];
71  B.fArray[16 * N + n] = A.fArray[16 * N + n] + p * A.fArray[4 * N + n];
72  B.fArray[17 * N + n] = A.fArray[17 * N + n] + p * A.fArray[5 * N + n];
73  B.fArray[18 * N + n] =
74  A.fArray[18 * N + n] + p * (A.fArray[8 * N + n] + A.fArray[15 * N + n]) + psq * A.fArray[3 * N + n];
75  B.fArray[19 * N + n] =
76  A.fArray[19 * N + n] + p * (A.fArray[12 * N + n] + A.fArray[16 * N + n]) + psq * A.fArray[4 * N + n];
77  B.fArray[20 * N + n] =
78  A.fArray[20 * N + n] + p * (A.fArray[17 * N + n] + A.fArray[17 * N + n]) + psq * A.fArray[5 * N + n];
79  }
80 
81  dprint_np(n, "propagateLineToRMPlex arrive at r=" << hipo(outPar[0 * N + n], outPar[1 * N + n]));
82  }
83  }
B
Definition: APVGainStruct.h:7
dprint_np
#define dprint_np(n, x)
Definition: Debug.h:91
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
N
#define N
Definition: blowfish.cc:9
mkfit::hipo
float hipo(float x, float y)
Definition: Matrix.h:9
l1ctLayer1_cff.dr
dr
Definition: l1ctLayer1_cff.py:87
A
Definition: APVGainStruct.h:7
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153

◆ 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 DetachedQuadStep_cff::seeds.

Referenced by MkFitProducer::produce().

38  {
39  IterationMaskIfcCmssw it_mask_ifc(trackerInfo, hit_masks);
40 
41  MkJob job({trackerInfo, itconf, eoh, eoh.refBeamSpot(), &it_mask_ifc});
42 
43  builder.begin_event(&job, nullptr, __func__);
44 
45  // Seed cleaning not done on all iterations.
46  do_seed_clean = do_seed_clean && itconf.m_seed_cleaner;
47 
48  if (do_seed_clean)
49  itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());
50 
51  // Check nans in seeds -- this should not be needed when Slava fixes
52  // the track parameter coordinate transformation.
53  builder.seed_post_cleaning(seeds);
54 
55  if (itconf.m_requires_seed_hit_sorting) {
56  for (auto &s : seeds)
57  s.sortHitsByLayer(); // sort seed hits for the matched hits (I hope it works here)
58  }
59 
60  builder.find_tracks_load_seeds(seeds, do_seed_clean);
61 
62  builder.findTracksCloneEngine();
63 
64  if (itconf.m_pre_bkfit_filter) {
65  builder.filter_comb_cands(itconf.m_pre_bkfit_filter);
66  }
67 
68  job.switch_to_backward();
69 
70  if (do_backward_fit) {
71  if (itconf.m_backward_search) {
72  builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
73  }
74 
75  builder.backwardFit();
76 
77  if (itconf.m_backward_search) {
78  builder.beginBkwSearch();
79  builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
80  builder.endBkwSearch();
81  }
82 
83  if (itconf.m_post_bkfit_filter) {
84  builder.filter_comb_cands(itconf.m_post_bkfit_filter);
85  }
86  }
87 
88  builder.filter_comb_cands(StdSeq::qfilter_nan_n_silly<TrackCand>);
89 
90  builder.export_best_comb_cands(out_tracks, true);
91 
92  if (do_remove_duplicates && itconf.m_duplicate_cleaner) {
93  itconf.m_duplicate_cleaner(out_tracks, itconf);
94  }
95 
96  builder.end_event();
97  builder.release_memory();
98  }
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:199

◆ runBtpCe_MultiIter()

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

Definition at line 395 of file buildtestMPlex.cc.

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFit(), mkfit::Config::backwardSearch, mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), electrons_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(), 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(), DetachedQuadStep_cff::seeds, mkfit::MkBuilder::select_best_comb_cands(), mkfit::Config::sim_val, submitPVValidationJobs::t, protons_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

395  {
396  std::vector<double> timevec;
397  if (n <= 0)
398  return timevec;
399  timevec.resize(n + 1, 0.0);
400 
401  const bool validation_on = (Config::sim_val || Config::quality_val);
402 
403  TrackVec seeds_used;
404  TrackVec seeds1;
405 
406  unsigned int algorithms[] = {4, 22, 23, 5, 24, 7, 8, 9, 10, 6}; //9 iterations
407 
408  if (validation_on) {
409  for (auto const &s : ev.seedTracks_) {
410  //keep seeds form the first n iterations for processing
411  if (std::find(algorithms, algorithms + n, s.algoint()) != algorithms + n)
412  seeds1.push_back(s);
413  }
414  ev.seedTracks_.swap(seeds1); //necessary for the validation - PrepareSeeds
415  ev.relabel_bad_seedtracks(); //necessary for the validation - PrepareSeeds
416  }
417 
418  IterationMaskIfc mask_ifc;
419  TrackVec seeds;
420  TrackVec tmp_tvec;
421 
422  for (int it = 0; it <= n - 1; ++it) {
423  const IterationConfig &itconf = Config::ItrInfo[it];
424 
425  // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
426  // and optionally comment out ev.fill_hitmask_bool_vectors() call.
427 
428  ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
429 
430  MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
431 
432  builder.begin_event(&job, &ev, __func__);
433 
434  { // We could partition seeds once, store beg, end for each iteration in a map or vector.
435  seeds.clear();
436  int nc = 0;
437  for (auto &s : ev.seedTracks_) {
438  if (s.algoint() == itconf.m_track_algorithm) {
439  if (itconf.m_requires_seed_hit_sorting) {
440  s.sortHitsByLayer();
441  }
442  seeds.push_back(s);
443  ++nc;
444  } else if (nc > 0)
445  break;
446  }
447  }
448 
449  bool do_seed_clean = bool(itconf.m_seed_cleaner);
450 
451  if (do_seed_clean)
452  itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());
453 
454  builder.seed_post_cleaning(seeds);
455 
456  // Add protection in case no seeds are found for iteration
457  if (seeds.size() <= 0)
458  continue;
459 
460  builder.find_tracks_load_seeds(seeds, do_seed_clean);
461 
462  double time = dtime();
463 
464  builder.findTracksCloneEngine();
465 
466  timevec[it] = dtime() - time;
467  timevec[n] += timevec[it];
468 
469  // Print min and max size of hots vectors of CombCands.
470  // builder.find_min_max_hots_size();
471 
472  if (validation_on)
473  seeds_used.insert(seeds_used.end(), seeds.begin(), seeds.end()); //cleaned seeds need to be stored somehow
474 
475  if (itconf.m_pre_bkfit_filter) {
476  builder.filter_comb_cands(itconf.m_pre_bkfit_filter);
477  }
478 
479  builder.select_best_comb_cands();
480 
481  {
482  builder.export_tracks(tmp_tvec);
483  if (itconf.m_duplicate_cleaner)
484  itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);
485  ev.candidateTracks_.reserve(ev.candidateTracks_.size() + tmp_tvec.size());
486  for (auto &&t : tmp_tvec)
487  ev.candidateTracks_.emplace_back(std::move(t));
488  tmp_tvec.clear();
489  }
490 
491  job.switch_to_backward();
492 
493  // now do backwards fit... do we want to time this section?
494  if (Config::backwardFit) {
495  // a) TrackVec version:
496  // builder.backwardFitBH();
497 
498  // b) Version that runs on CombCand / TrackCand
499  const bool do_backward_search = Config::backwardSearch && itconf.m_backward_search;
500 
501  // We copy seed-hits into Candidates ... now we have to remove them so backward fit stops
502  // before reaching seeding region. Ideally, we wouldn't add them in the first place but
503  // if we want to export full tracks above we need to hold on to them (alternatively, we could
504  // have a pointer to seed track in CombCandidate and copy them from there).
505  if (do_backward_search) {
506  builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
507  }
508 
509  builder.backwardFit();
510 
511  if (do_backward_search) {
512  builder.beginBkwSearch();
513  builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
514  builder.endBkwSearch();
515  }
516 
517  if (itconf.m_post_bkfit_filter) {
518  builder.filter_comb_cands(itconf.m_post_bkfit_filter);
519  }
520 
521  builder.filter_comb_cands(StdSeq::qfilter_nan_n_silly<TrackCand>);
522 
523  builder.select_best_comb_cands(true); // true -> clear m_tracks as they were already filled once above
524 
525  if (itconf.m_duplicate_cleaner)
526  itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);
527 
528  builder.export_tracks(ev.fitTracks_);
529  }
530 
531  builder.end_event();
532  }
533 
534  // MIMI - Fake back event pointer for final processing (that should be done elsewhere)
535  MkJob job({Config::TrkInfo, Config::ItrInfo[0], eoh, eoh.refBeamSpot()});
536  builder.begin_event(&job, &ev, __func__);
537 
538  if (validation_on) {
539  StdSeq::prep_simtracks(&ev);
540  //swap for the cleaned seeds
541  ev.seedTracks_.swap(seeds_used);
542  }
543 
544  check_nan_n_silly_candidates(ev);
545 
546  if (Config::backwardFit)
547  check_nan_n_silly_bkfit(ev);
548 
549  // validation section
550  if (Config::quality_val) {
551  StdSeq::Quality qval;
552  qval.quality_val(&ev);
553  } else if (Config::sim_val || Config::cmssw_val) {
554  StdSeq::root_val(&ev);
555  }
556 
557  // ev.print_tracks(ev.candidateTracks_, true);
558 
559  // MIMI Unfake.
560  builder.end_event();
561 
562  // In CMSSW runOneIter we now release memory for comb-cands:
563  builder.release_memory();
564 
565  return timevec;
566  }
Quality
pixelTrack::Quality Quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:30
mkfit::StdSeq::root_val
void root_val(Event *event)
Definition: MkStandaloneSeqs.cc:264
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
mkfit::StdSeq::prep_simtracks
void prep_simtracks(Event *event)
Definition: MkStandaloneSeqs.cc:298
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:199
mkfit::Config::TrkInfo
TrackerInfo TrkInfo
Definition: ConfigStandalone.cc:14
mkfit::Config::ItrInfo
IterationsInfo ItrInfo
Definition: ConfigStandalone.cc:15
electrons_cff.bool
bool
Definition: electrons_cff.py:319
protons_cff.time
time
Definition: protons_cff.py:25
mkfit::TrackVec
std::vector< Track > TrackVec
Definition: MkFitOutputWrapper.h:8
analysisFilters_cff.algorithms
algorithms
Definition: analysisFilters_cff.py:30
mkfit::dtime
double dtime()
Definition: buildtestMPlex.h:23
eostools.move
def move(src, dest)
Definition: eostools.py:511

◆ 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, protons_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

108  {
109  const IterationConfig &itconf = Config::ItrInfo[0];
110 
111  const bool validation_on = (Config::sim_val || Config::quality_val);
112 
113  if (validation_on) {
114  TrackVec seeds1;
115 
116  unsigned int algorithms[] = {4}; //only initialStep
117 
118  for (auto const &s : ev.seedTracks_) {
119  //keep seeds form the first iteration for processing
120  if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
121  seeds1.push_back(s);
122  }
123  ev.seedTracks_.swap(seeds1); //necessary for the validation - PrepareSeeds
124  ev.relabel_bad_seedtracks(); //necessary for the validation - PrepareSeeds
125  }
126 
127  IterationMaskIfc mask_ifc;
128 
129  // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
130  // and optionally comment out ev.fill_hitmask_bool_vectors() call.
131 
132  ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
133 
134  MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
135 
136  builder.begin_event(&job, &ev, __func__);
137 
138  bool seeds_sorted = false;
139  // CCCC builder.PrepareSeeds();
140 
141  // EventOfCandidates event_of_cands;
142  builder.find_tracks_load_seeds_BH(ev.seedTracks_, seeds_sorted);
143 
144 #ifdef USE_VTUNE_PAUSE
145  __SSC_MARK(0x111); // use this to resume Intel SDE at the same point
146  __itt_resume();
147 #endif
148 
149  double time = dtime();
150 
151  builder.findTracksBestHit();
152 
153  time = dtime() - time;
154 
155 #ifdef USE_VTUNE_PAUSE
156  __itt_pause();
157  __SSC_MARK(0x222); // use this to pause Intel SDE at the same point
158 #endif
159 
160  // Hack, get the tracks out.
161  ev.candidateTracks_ = builder.ref_tracks();
162 
163  // For best hit, the candidateTracks_ vector is the direct input to the backward fit so only need to do clean_duplicates once
164  if (Config::quality_val || Config::sim_val || Config::cmssw_val) {
165  //Mark tracks as duplicates; if within CMSSW, remove duplicate tracks before backward fit
166  // CCCC if (Config::removeDuplicates) {
167  // CCCC StdSeq::clean_duplicates(ev.candidateTracks_);
168  // CCCC }
169  }
170 
171  job.switch_to_backward();
172 
173  // now do backwards fit... do we want to time this section?
174  if (Config::backwardFit) {
175  builder.backwardFitBH();
176  ev.fitTracks_ = builder.ref_tracks();
177  }
178 
179  if (Config::quality_val) {
180  StdSeq::Quality qval;
181  qval.quality_val(&ev);
182  } else if (Config::sim_val || Config::cmssw_val) {
183  StdSeq::root_val(&ev);
184  }
185 
186  builder.end_event();
187 
188  // ev.print_tracks(ev.candidateTracks_, true);
189 
190  return time;
191  }
Quality
pixelTrack::Quality Quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:30
mkfit::StdSeq::root_val
void root_val(Event *event)
Definition: MkStandaloneSeqs.cc:264
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
mkfit::Config::TrkInfo
TrackerInfo TrkInfo
Definition: ConfigStandalone.cc:14
mkfit::Config::ItrInfo
IterationsInfo ItrInfo
Definition: ConfigStandalone.cc:15
protons_cff.time
time
Definition: protons_cff.py:25
mkfit::TrackVec
std::vector< Track > TrackVec
Definition: MkFitOutputWrapper.h:8
analysisFilters_cff.algorithms
algorithms
Definition: analysisFilters_cff.py:30
mkfit::dtime
double dtime()
Definition: buildtestMPlex.h:23

◆ runBuildingTestPlexCloneEngine()

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

Definition at line 286 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, protons_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

286  {
287  const IterationConfig &itconf = Config::ItrInfo[0];
288 
289  const bool validation_on = (Config::sim_val || Config::quality_val);
290 
291  if (validation_on) {
292  TrackVec seeds1;
293 
294  unsigned int algorithms[] = {4}; //only initialStep
295 
296  for (auto const &s : ev.seedTracks_) {
297  //keep seeds form the first iteration for processing
298  if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
299  seeds1.push_back(s);
300  }
301  ev.seedTracks_.swap(seeds1); //necessary for the validation - PrepareSeeds
302  ev.relabel_bad_seedtracks(); //necessary for the validation - PrepareSeeds
303  }
304 
305  IterationMaskIfc mask_ifc;
306 
307  // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
308  // and optionally comment out ev.fill_hitmask_bool_vectors() call.
309 
310  ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
311 
312  MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
313 
314  builder.begin_event(&job, &ev, __func__);
315 
316  bool seeds_sorted = false;
317  // CCCC builder.PrepareSeeds();
318 
319  builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);
320 
321 #ifdef USE_VTUNE_PAUSE
322  __SSC_MARK(0x111); // use this to resume Intel SDE at the same point
323  __itt_resume();
324 #endif
325 
326  double time = dtime();
327 
328  builder.findTracksCloneEngine();
329 
330  time = dtime() - time;
331 
332 #ifdef USE_VTUNE_PAUSE
333  __itt_pause();
334  __SSC_MARK(0x222); // use this to pause Intel SDE at the same point
335 #endif
336 
337  check_nan_n_silly_candidates(ev);
338 
339  // first store candidate tracks - needed for BH backward fit and root_validation
340  builder.export_best_comb_cands(ev.candidateTracks_);
341 
342  job.switch_to_backward();
343 
344  // now do backwards fit... do we want to time this section?
345  if (Config::backwardFit) {
346  // a) TrackVec version:
347  builder.select_best_comb_cands();
348  builder.backwardFitBH();
349  ev.fitTracks_ = builder.ref_tracks();
350 
351  // b) Version that runs on CombCand / TrackCand
352  // builder.backwardFit();
353  // builder.quality_store_tracks(ev.fitTracks_);
354 
355  check_nan_n_silly_bkfit(ev);
356  }
357 
358  // CCCC StdSeq::handle_duplicates(&ev);
359 
360  // validation section
361  if (Config::quality_val) {
362  StdSeq::Quality qval;
363  qval.quality_val(&ev);
364  } else if (Config::sim_val || Config::cmssw_val) {
365  StdSeq::root_val(&ev);
366  }
367 
368  builder.end_event();
369 
370  // ev.print_tracks(ev.candidateTracks_, true);
371 
372  return time;
373  }
Quality
pixelTrack::Quality Quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:30
mkfit::StdSeq::root_val
void root_val(Event *event)
Definition: MkStandaloneSeqs.cc:264
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
mkfit::Config::TrkInfo
TrackerInfo TrkInfo
Definition: ConfigStandalone.cc:14
mkfit::Config::ItrInfo
IterationsInfo ItrInfo
Definition: ConfigStandalone.cc:15
protons_cff.time
time
Definition: protons_cff.py:25
mkfit::TrackVec
std::vector< Track > TrackVec
Definition: MkFitOutputWrapper.h:8
analysisFilters_cff.algorithms
algorithms
Definition: analysisFilters_cff.py:30
mkfit::dtime
double dtime()
Definition: buildtestMPlex.h:23

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

90  {
91  const IterationConfig &itconf = Config::ItrInfo[0];
92 
93  MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot()});
94 
95  builder.begin_event(&job, &ev, __func__);
96 
97  if (Config::sim_val_for_cmssw) {
98  StdSeq::root_val_dumb_cmssw(&ev);
99  }
100 
101  builder.end_event();
102  }
mkfit::Config::TrkInfo
TrackerInfo TrkInfo
Definition: ConfigStandalone.cc:14
mkfit::Config::ItrInfo
IterationsInfo ItrInfo
Definition: ConfigStandalone.cc:15
mkfit::StdSeq::root_val_dumb_cmssw
void root_val_dumb_cmssw(Event *event)
Definition: MkStandaloneSeqs.cc:243

◆ runBuildingTestPlexStandard()

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

Definition at line 197 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, protons_cff::time, and mkfit::Config::TrkInfo.

Referenced by test_standard().

197  {
198  const IterationConfig &itconf = Config::ItrInfo[0];
199 
200  const bool validation_on = (Config::sim_val || Config::quality_val);
201 
202  if (validation_on) {
203  TrackVec seeds1;
204 
205  unsigned int algorithms[] = {4}; //only initialStep
206 
207  for (auto const &s : ev.seedTracks_) {
208  //keep seeds form the first iteration for processing
209  if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
210  seeds1.push_back(s);
211  }
212  ev.seedTracks_.swap(seeds1); //necessary for the validation - PrepareSeeds
213  ev.relabel_bad_seedtracks(); //necessary for the validation - PrepareSeeds
214  }
215 
216  IterationMaskIfc mask_ifc;
217 
218  // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
219  // and optionally comment out ev.fill_hitmask_bool_vectors() call.
220 
221  ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
222 
223  MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
224 
225  builder.begin_event(&job, &ev, __func__);
226 
227  bool seeds_sorted = false;
228  // CCCC builder.PrepareSeeds();
229 
230  builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);
231 
232 #ifdef USE_VTUNE_PAUSE
233  __SSC_MARK(0x111); // use this to resume Intel SDE at the same point
234  __itt_resume();
235 #endif
236 
237  double time = dtime();
238 
239  builder.findTracksStandard();
240 
241  time = dtime() - time;
242 
243 #ifdef USE_VTUNE_PAUSE
244  __itt_pause();
245  __SSC_MARK(0x222); // use this to pause Intel SDE at the same point
246 #endif
247 
248  check_nan_n_silly_candidates(ev);
249 
250  // first store candidate tracks
251  builder.export_best_comb_cands(ev.candidateTracks_);
252 
253  job.switch_to_backward();
254 
255  // now do backwards fit... do we want to time this section?
256  if (Config::backwardFit) {
257  // Using the TrackVec version until we home in on THE backward fit etc.
258  // builder.backwardFit();
259  builder.select_best_comb_cands();
260  builder.backwardFitBH();
261  ev.fitTracks_ = builder.ref_tracks();
262 
263  check_nan_n_silly_bkfit(ev);
264  }
265 
266  // CCCC StdSeq::handle_duplicates(&ev);
267 
268  if (Config::quality_val) {
269  StdSeq::Quality qval;
270  qval.quality_val(&ev);
271  } else if (Config::sim_val || Config::cmssw_val) {
272  StdSeq::root_val(&ev);
273  }
274 
275  builder.end_event();
276 
277  // ev.print_tracks(ev.candidateTracks_, true);
278 
279  return time;
280  }
Quality
pixelTrack::Quality Quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:30
mkfit::StdSeq::root_val
void root_val(Event *event)
Definition: MkStandaloneSeqs.cc:264
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
mkfit::Config::TrkInfo
TrackerInfo TrkInfo
Definition: ConfigStandalone.cc:14
mkfit::Config::ItrInfo
IterationsInfo ItrInfo
Definition: ConfigStandalone.cc:15
protons_cff.time
time
Definition: protons_cff.py:25
mkfit::TrackVec
std::vector< Track > TrackVec
Definition: MkFitOutputWrapper.h:8
analysisFilters_cff.algorithms
algorithms
Definition: analysisFilters_cff.py:30
mkfit::dtime
double dtime()
Definition: buildtestMPlex.h:23

◆ 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, mkfit::ExecutionContext::m_fitters, SiStripPI::max, mkfit::Config::nLayers, NN, mkfit::Config::numSeedsPerTask, mkfit::Config::numThreadsFinder, mkfit::ExecutionContext::populate(), and protons_cff::time.

40  {
41  g_exe_ctx.populate(Config::numThreadsFinder);
42  std::vector<Track>& simtracks = ev.simTracks_;
43 
44  const int Nhits = Config::nLayers;
45  // XXX What if there's a missing / double layer?
46  // Eventually, should sort track vector by number of hits!
47  // And pass the number in on each "setup" call.
48  // Reserves should be made for maximum possible number (but this is just
49  // measurments errors, params).
50 
51  int theEnd = simtracks.size();
52  int count = (theEnd + NN - 1) / NN;
53 
54 #ifdef USE_VTUNE_PAUSE
55  __SSC_MARK(0x111); // use this to resume Intel SDE at the same point
56  __itt_resume();
57 #endif
58 
59  double time = dtime();
60 
61  tbb::parallel_for(tbb::blocked_range<int>(0, count, std::max(1, Config::numSeedsPerTask / NN)),
62  [&](const tbb::blocked_range<int>& i) {
63  std::unique_ptr<MkFitter, decltype(retfitr)> mkfp(g_exe_ctx.m_fitters.GetFromPool(), retfitr);
64  mkfp->setNhits(Nhits);
65  for (int it = i.begin(); it < i.end(); ++it) {
66  int itrack = it * NN;
67  int end = itrack + NN;
68  /*
69  * MT, trying to slurp and fit at the same time ...
70  if (theEnd < end) {
71  end = theEnd;
72  mkfp->inputTracksAndHits(simtracks, ev.layerHits_, itrack, end);
73  } else {
74  mkfp->slurpInTracksAndHits(simtracks, ev.layerHits_, itrack, end); // only safe for a full matriplex
75  }
76 
77  if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);
78  mkfp->FitTracks(end - itrack, &ev, true);
79  */
80 
81  mkfp->inputTracksForFit(simtracks, itrack, end);
82 
83  // XXXX MT - for this need 3 points in ... right
84  // XXXX if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);
85 
86  mkfp->fitTracksWithInterSlurp(ev.layerHits_, end - itrack);
87 
88  mkfp->outputFittedTracks(rectracks, itrack, end);
89  }
90  });
91 
92  time = dtime() - time;
93 
94 #ifdef USE_VTUNE_PAUSE
95  __itt_pause();
96  __SSC_MARK(0x222); // use this to pause Intel SDE at the same point
97 #endif
98 
99  if (Config::fit_val)
100  ev.validate();
101 
102  return time;
103  }
mps_fire.i
i
Definition: mps_fire.py:429
MuonTCMETValueMapProducer_cff.nLayers
nLayers
Definition: MuonTCMETValueMapProducer_cff.py:38
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
mkfit::g_exe_ctx
ExecutionContext g_exe_ctx
Definition: MkBuilder.cc:52
mkfit::Config::numThreadsFinder
constexpr int numThreadsFinder
Definition: Config.h:120
protons_cff.time
time
Definition: protons_cff.py:25
mps_fire.end
end
Definition: mps_fire.py:242
mkfit::ExecutionContext::m_fitters
Pool< MkFitter > m_fitters
Definition: MkBuilder.cc:42
mkfit::ExecutionContext::populate
void populate(int n_thr)
Definition: MkBuilder.cc:45
mkfit::dtime
double dtime()
Definition: buildtestMPlex.h:23
mkfit::Config::numSeedsPerTask
constexpr int numSeedsPerTask
Definition: Config.h:122

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

13  {
14  // Had this writen with explicit division by factorial.
15  // The *whole* fitting test ran like 2.5% slower on MIC, sigh.
16 
17  const float x2 = x * x;
18  cos = 1.f - 0.5f * x2 + 0.04166667f * x2 * x2;
19  sin = x - 0.16666667f * x * x2;
20  }
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
testProducerWithPsetDescEmpty_cfi.x2
x2
Definition: testProducerWithPsetDescEmpty_cfi.py:28
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ sortByEta()

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

Definition at line 25 of file buildtestMPlex.cc.

References mkfit::Hit::eta().

25 { 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.

14  {
15  if (cand1.first.nFoundHits() == cand2.first.nFoundHits())
16  return cand1.first.chi2() < cand2.first.chi2();
17 
18  return cand1.first.nFoundHits() > cand2.first.nFoundHits();
19  }

◆ sortByHitsChi2() [2/2]

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

Definition at line 590 of file Track.h.

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

590  {
591  if (cand1.nFoundHits() == cand2.nFoundHits())
592  return cand1.chi2() < cand2.chi2();
593  return cand1.nFoundHits() > cand2.nFoundHits();
594  }

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

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

◆ sortByScoreCand()

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

Definition at line 596 of file Track.h.

References mkfit::TrackBase::score().

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

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

◆ sortByScoreStruct()

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

Definition at line 598 of file Track.h.

References mkfit::IdxChi2List::score.

598  {
599  return cand1.score > cand2.score;
600  }

◆ sortByScoreTrackCand()

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

Definition at line 254 of file TrackStructures.h.

References mkfit::TrackBase::score().

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

254  {
255  return cand1.score() > cand2.score();
256  }

◆ sortByZ()

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

Definition at line 43 of file buildtestMPlex.cc.

References mkfit::Hit::z().

43 { return hit1.z() < hit2.z(); }
Hit::z
double z
global z - AlignmentGeometry::z0, mm
Definition: HitCollection.h:27

◆ sortIDsByChi2()

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

Definition at line 235 of file TrackExtra.cc.

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

235 { 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().

27 { 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().

29 { 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.

14  {
15  return x * x;
16  }
x
float x
Definition: beamSpotDipStandalone.cc:55

◆ 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::Track::swimPhiToR().

22  {
23  return phi - floor(0.5 * Const::InvPI * (phi + Const::PI)) * Const::TwoPI;
24  }
mkfit::Const::TwoPI
constexpr float TwoPI
Definition: Config.h:43
PI
#define PI
Definition: QcdUeDQM.h:37
mkfit::Const::InvPI
constexpr float InvPI
Definition: Config.h:47

◆ squashPhiGeneral() [2/2]

template<typename Vector >
void mkfit::squashPhiGeneral ( Vector &  v)
inline

Definition at line 657 of file Track.h.

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

657  {
658  const int i = v.kSize - 2; // phi index
659  v[i] = squashPhiGeneral(v[i]);
660  }
mps_fire.i
i
Definition: mps_fire.py:429
mkfit::squashPhiGeneral
void squashPhiGeneral(Vector &v)
Definition: Track.h:657

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

26  {
27  return phi >= Const::PI ? phi - Const::TwoPI : (phi < -Const::PI ? phi + Const::TwoPI : phi);
28  }
mkfit::Const::TwoPI
constexpr float TwoPI
Definition: Config.h:43
PI
#define PI
Definition: QcdUeDQM.h:37

◆ squashPhiMPlex()

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

Definition at line 8 of file PropagationMPlex.h.

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

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

8  {
9 #pragma omp simd
10  for (int n = 0; n < NN; ++n) {
11  if (par(n, 4, 0) >= Const::PI)
12  par(n, 4, 0) -= Const::TwoPI;
13  if (par(n, 4, 0) < -Const::PI)
14  par(n, 4, 0) += Const::TwoPI;
15  }
16  }
mkfit::Const::TwoPI
constexpr float TwoPI
Definition: Config.h:43
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
PI
#define PI
Definition: QcdUeDQM.h:37

◆ squashPhiMPlexGeneral()

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

Definition at line 18 of file PropagationMPlex.h.

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

18  {
19 #pragma omp simd
20  for (int n = 0; n < NN; ++n) {
21  par(n, 4, 0) -= std::floor(0.5f * Const::InvPI * (par(n, 4, 0) + Const::PI)) * Const::TwoPI;
22  }
23  }
mkfit::Const::TwoPI
constexpr float TwoPI
Definition: Config.h:43
mkfit::NN
constexpr Matriplex::idx_t NN
Definition: Matrix.h:43
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
PI
#define PI
Definition: QcdUeDQM.h:37
mkfit::Const::InvPI
constexpr float InvPI
Definition: Config.h:47

◆ to_json() [1/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() [2/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() [3/12]

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

Definition at line 46 of file IterationConfig.cc.

◆ to_json() [4/12]

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

Definition at line 46 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 65 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 65 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 77 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 77 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 109 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 109 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 112 of file IterationConfig.cc.

References CMS_SA_ALLOW, and mutex.

118 {

◆ to_json() [12/12]

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

Definition at line 112 of file IterationConfig.cc.

118 {

Variable Documentation

◆ g_exe_ctx

ExecutionContext mkfit::g_exe_ctx

Definition at line 52 of file MkBuilder.cc.

Referenced by mkfit::MkBuilder::backwardFit(), mkfit::MkBuilder::backwardFitBH(), 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(), CFMap(), conformalFitMPlex(), 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(), helixAtRFromIterativeCCS(), helixAtRFromIterativeCCSFullJac(), helixAtZ(), kalmanOperation(), kalmanPropagateAndComputeChi2(), kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdate(), kalmanPropagateAndUpdateEndcap(), mkfit::MatriplexPackerSlurpIn< D >::pack(), mkfit::MatriplexErrParPackerSlurpIn< T, D >::pack(), mkfit::MkFitter::printPt(), 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(), squashPhiMPlex(), and squashPhiMPlexGeneral().

Generated for CMSSW Reference Manual by doxygen 1.8.14