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

Definition at line 11 of file KalmanUtilsMPlex.h.

11 { KFO_Calculate_Chi2 = 1, KFO_Update_Params = 2 };

◆ 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 

Definition at line 6 of file LayerNumberConverter.h.

6 { phase0 = 0, phase1 = 1 };

◆ 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_2022v12_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
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
HLT_2022v12_cff.beta
beta
Definition: HLT_2022v12_cff.py:6966
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  }
HLT_2022v12_cff.diagonalOnly
diagonalOnly
Definition: HLT_2022v12_cff.py:9187
Vector
ROOT::Math::Plane3D::Vector Vector
Definition: EcalHitMaker.cc:29
hitfit::Matrix
CLHEP::HepMatrix Matrix
Definition: matutil.h:62
mkfit::squashPhiGeneral
void squashPhiGeneral(Vector &v)
Definition: Track.h:657

◆ 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(), PVValHelper::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:428
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:35
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:65
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, visualization-live-secondInstance_cfg::m, and alignCSCRings::r.

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, visualization-live-secondInstance_cfg::m, and alignCSCRings::r.

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(), alignCSCRings::r, 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:428
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 32 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 32 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 41 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 41 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 59 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 59 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 84 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 84 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 103 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 103 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 106 of file IterationConfig.cc.

◆ from_json() [12/12]

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

Definition at line 106 of file IterationConfig.cc.

◆ getEta() [1/3]

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

Definition at line 38 of file Hit.h.

References f, getTheta(), dqm-mbProfile::log, alignCSCRings::r, 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.

References alignCSCRings::r.

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, alignCSCRings::r, 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:428
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, L1TkHTMissProducer_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
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
L1TkHTMissProducer_cfi.deltaZ
deltaZ
Definition: L1TkHTMissProducer_cfi.py:14
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
b
double b
Definition: hdecay.h:118
a
double a
Definition: hdecay.h:119
mkfit::Config::maxCurvR
constexpr float maxCurvR
Definition: ConfigStandalone.h:109
b2
static constexpr float b2
Definition: L1EGammaCrystalsEmulatorProducer.cc:80

◆ isStripQCompatible()

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

Definition at line 797 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().

798  {
799  //check module compatibility via long strip side = L/sqrt(12)
800  if (isBarrel) { //check z direction only
801  const float res = std::abs(msPar.constAt(itrack, 2, 0) - pPar.constAt(itrack, 2, 0));
802  const float hitHL = sqrt(msErr.constAt(itrack, 2, 2) * 3.f); //half-length
803  const float qErr = sqrt(pErr.constAt(itrack, 2, 2));
804  dprint("qCompat " << hitHL << " + " << 3.f * qErr << " vs " << res);
805  return hitHL + std::max(3.f * qErr, 0.5f) > res;
806  } else { //project on xy, assuming the strip Length >> Width
807  const float res[2]{msPar.constAt(itrack, 0, 0) - pPar.constAt(itrack, 0, 0),
808  msPar.constAt(itrack, 1, 0) - pPar.constAt(itrack, 1, 0)};
809  const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
810  const float hitT2inv = 1.f / hitT2;
811  const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
812  msErr.constAt(itrack, 0, 1) * hitT2inv,
813  msErr.constAt(itrack, 1, 1) * hitT2inv};
814  const float qErr =
815  sqrt(std::abs(pErr.constAt(itrack, 0, 0) * proj[0] + 2.f * pErr.constAt(itrack, 0, 1) * proj[1] +
816  pErr.constAt(itrack, 1, 1) * proj[2])); //take abs to avoid non-pos-def cases
817  const float resProj =
818  sqrt(res[0] * proj[0] * res[0] + 2.f * res[1] * proj[1] * res[0] + res[1] * proj[2] * res[1]);
819  dprint("qCompat " << sqrt(hitT2 * 3.f) << " + " << 3.f * qErr << " vs " << resProj);
820  return sqrt(hitT2 * 3.f) + std::max(3.f * qErr, 0.5f) > resProj;
821  }
822  }
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 466 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), and KFO_Calculate_Chi2.

472  {
473  kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
474  }
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:505

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

References kalmanOperationEndcap(), and KFO_Calculate_Chi2.

723  {
724  kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
725  }
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:756

◆ 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 505 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, dqmiodumpmetadata::n, NN, alignCSCRings::r, squashPhiMPlex(), and Matriplex::MatriplexSym< T, D, N >::subtract().

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

513  {
514 #ifdef DEBUG
515  {
516  dmutex_guard;
517  printf("psPar:\n");
518  for (int i = 0; i < 6; ++i) {
519  printf("%8f ", psPar.constAt(0, 0, i));
520  printf("\n");
521  }
522  printf("\n");
523  printf("psErr:\n");
524  for (int i = 0; i < 6; ++i) {
525  for (int j = 0; j < 6; ++j)
526  printf("%8f ", psErr.constAt(0, i, j));
527  printf("\n");
528  }
529  printf("\n");
530  printf("msPar:\n");
531  for (int i = 0; i < 3; ++i) {
532  printf("%8f ", msPar.constAt(0, 0, i));
533  printf("\n");
534  }
535  printf("\n");
536  printf("msErr:\n");
537  for (int i = 0; i < 3; ++i) {
538  for (int j = 0; j < 3; ++j)
539  printf("%8f ", msErr.constAt(0, i, j));
540  printf("\n");
541  }
542  printf("\n");
543  }
544 #endif
545 
546  // Rotate global point on tangent plane to cylinder
547  // Tangent point is half way between hit and propagate position
548 
549  // Rotation matrix
550  // rotT00 0 rotT01
551  // rotT01 0 -rotT00
552  // 0 1 0
553  // Minimize temporaries: only two float are needed!
554 
555  MPlexQF rotT00;
556  MPlexQF rotT01;
557  for (int n = 0; n < NN; ++n) {
558  const float r = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
559  rotT00.At(n, 0, 0) = -(msPar.constAt(n, 1, 0) + psPar.constAt(n, 1, 0)) / (2 * r);
560  rotT01.At(n, 0, 0) = (msPar.constAt(n, 0, 0) + psPar.constAt(n, 0, 0)) / (2 * r);
561  }
562 
563  MPlexHV res_glo; //position residual in global coordinates
564  SubtractFirst3(msPar, psPar, res_glo);
565 
566  MPlexHS resErr_glo; //covariance sum in global position coordinates
567  AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);
568 
569  MPlex2V res_loc; //position residual in local coordinates
570  RotateResidualsOnTangentPlane(rotT00, rotT01, res_glo, res_loc);
571  MPlex2S resErr_loc; //covariance sum in local position coordinates
572  MPlexHH tempHH;
573  ProjectResErr(rotT00, rotT01, resErr_glo, tempHH);
574  ProjectResErrTransp(rotT00, rotT01, tempHH, resErr_loc);
575 
576 #ifdef DEBUG
577  {
578  dmutex_guard;
579  printf("resErr_loc:\n");
580  for (int i = 0; i < 2; ++i) {
581  for (int j = 0; j < 2; ++j)
582  printf("%8f ", resErr_loc.At(0, i, j));
583  printf("\n");
584  }
585  printf("\n");
586  }
587 #endif
588 
589  //invert the 2x2 matrix
590  Matriplex::invertCramerSym(resErr_loc);
591 
592  if (kfOp & KFO_Calculate_Chi2) {
593  Chi2Similarity(res_loc, resErr_loc, outChi2);
594 
595 #ifdef DEBUG
596  {
597  dmutex_guard;
598  printf("resErr_loc (Inv):\n");
599  for (int i = 0; i < 2; ++i) {
600  for (int j = 0; j < 2; ++j)
601  printf("%8f ", resErr_loc.At(0, i, j));
602  printf("\n");
603  }
604  printf("\n");
605  printf("chi2: %8f\n", outChi2.At(0, 0, 0));
606  }
607 #endif
608  }
609 
610  if (kfOp & KFO_Update_Params) {
611  MPlexLH K; // kalman gain, fixme should be L2
612  KalmanHTG(rotT00, rotT01, resErr_loc, tempHH); // intermediate term to get kalman gain (H^T*G)
613  KalmanGain(psErr, tempHH, K);
614 
615  MultResidualsAdd(K, psPar, res_loc, outPar);
616  MPlexLL tempLL;
617 
618  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
619 
620  KHMult(K, rotT00, rotT01, tempLL);
621  KHC(tempLL, psErr, outErr);
622  outErr.subtract(psErr, outErr);
623 
624 #ifdef DEBUG
625  {
626  dmutex_guard;
627  printf("res_glo:\n");
628  for (int i = 0; i < 3; ++i) {
629  printf("%8f ", res_glo.At(0, i, 0));
630  }
631  printf("\n");
632  printf("res_loc:\n");
633  for (int i = 0; i < 2; ++i) {
634  printf("%8f ", res_loc.At(0, i, 0));
635  }
636  printf("\n");
637  printf("resErr_loc (Inv):\n");
638  for (int i = 0; i < 2; ++i) {
639  for (int j = 0; j < 2; ++j)
640  printf("%8f ", resErr_loc.At(0, i, j));
641  printf("\n");
642  }
643  printf("\n");
644  printf("K:\n");
645  for (int i = 0; i < 6; ++i) {
646  for (int j = 0; j < 3; ++j)
647  printf("%8f ", K.At(0, i, j));
648  printf("\n");
649  }
650  printf("\n");
651  printf("outPar:\n");
652  for (int i = 0; i < 6; ++i) {
653  printf("%8f ", outPar.At(0, i, 0));
654  }
655  printf("\n");
656  printf("outErr:\n");
657  for (int i = 0; i < 6; ++i) {
658  for (int j = 0; j < 6; ++j)
659  printf("%8f ", outErr.At(0, i, j));
660  printf("\n");
661  }
662  printf("\n");
663  }
664 #endif
665  }
666  }
Matriplex::MatriplexSym::subtract
MatriplexSym & subtract(const MatriplexSym &a, const MatriplexSym &b)
Definition: MatriplexSym.h:212
mps_fire.i
i
Definition: mps_fire.py:428
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 756 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().

764  {
765 #ifdef DEBUG
766  {
767  dmutex_guard;
768  printf("updateParametersEndcapMPlex\n");
769  printf("psPar:\n");
770  for (int i = 0; i < 6; ++i) {
771  printf("%8f ", psPar.constAt(0, 0, i));
772  printf("\n");
773  }
774  printf("\n");
775  printf("msPar:\n");
776  for (int i = 0; i < 3; ++i) {
777  printf("%8f ", msPar.constAt(0, 0, i));
778  printf("\n");
779  }
780  printf("\n");
781  printf("psErr:\n");
782  for (int i = 0; i < 6; ++i) {
783  for (int j = 0; j < 6; ++j)
784  printf("%8f ", psErr.constAt(0, i, j));
785  printf("\n");
786  }
787  printf("\n");
788  printf("msErr:\n");
789  for (int i = 0; i < 3; ++i) {
790  for (int j = 0; j < 3; ++j)
791  printf("%8f ", msErr.constAt(0, i, j));
792  printf("\n");
793  }
794  printf("\n");
795  }
796 #endif
797 
798  MPlex2V res;
799  SubtractFirst2(msPar, psPar, res);
800 
801  MPlex2S resErr;
802  AddIntoUpperLeft2x2(psErr, msErr, resErr);
803 
804 #ifdef DEBUG
805  {
806  dmutex_guard;
807  printf("resErr:\n");
808  for (int i = 0; i < 2; ++i) {
809  for (int j = 0; j < 2; ++j)
810  printf("%8f ", resErr.At(0, i, j));
811  printf("\n");
812  }
813  printf("\n");
814  }
815 #endif
816 
817  //invert the 2x2 matrix
818  Matriplex::invertCramerSym(resErr);
819 
820  if (kfOp & KFO_Calculate_Chi2) {
821  Chi2Similarity(res, resErr, outChi2);
822 
823 #ifdef DEBUG
824  {
825  dmutex_guard;
826  printf("resErr_loc (Inv):\n");
827  for (int i = 0; i < 2; ++i) {
828  for (int j = 0; j < 2; ++j)
829  printf("%8f ", resErr.At(0, i, j));
830  printf("\n");
831  }
832  printf("\n");
833  printf("chi2: %8f\n", outChi2.At(0, 0, 0));
834  }
835 #endif
836  }
837 
838  if (kfOp & KFO_Update_Params) {
839  MPlexL2 K;
840  KalmanGain(psErr, resErr, K);
841 
842  MultResidualsAdd(K, psPar, res, outPar);
843 
844  squashPhiMPlex(outPar, N_proc); // ensure phi is between |pi|
845 
846  KHC(K, psErr, outErr);
847 
848 #ifdef DEBUG
849  {
850  dmutex_guard;
851  printf("outErr before subtract:\n");
852  for (int i = 0; i < 6; ++i) {
853  for (int j = 0; j < 6; ++j)
854  printf("%8f ", outErr.At(0, i, j));
855  printf("\n");
856  }
857  printf("\n");
858  }
859 #endif
860 
861  outErr.subtract(psErr, outErr);
862 
863 #ifdef DEBUG
864  {
865  dmutex_guard;
866  printf("res:\n");
867  for (int i = 0; i < 2; ++i) {
868  printf("%8f ", res.At(0, i, 0));
869  }
870  printf("\n");
871  printf("resErr (Inv):\n");
872  for (int i = 0; i < 2; ++i) {
873  for (int j = 0; j < 2; ++j)
874  printf("%8f ", resErr.At(0, i, j));
875  printf("\n");
876  }
877  printf("\n");
878  printf("K:\n");
879  for (int i = 0; i < 6; ++i) {
880  for (int j = 0; j < 2; ++j)
881  printf("%8f ", K.At(0, i, j));
882  printf("\n");
883  }
884  printf("\n");
885  printf("outPar:\n");
886  for (int i = 0; i < 6; ++i) {
887  printf("%8f ", outPar.At(0, i, 0));
888  }
889  printf("\n");
890  printf("outErr:\n");
891  for (int i = 0; i < 6; ++i) {
892  for (int j = 0; j < 6; ++j)
893  printf("%8f ", outErr.At(0, i, j));
894  printf("\n");
895  }
896  printf("\n");
897  }
898 #endif
899  }
900  }
Matriplex::MatriplexSym::subtract
MatriplexSym & subtract(const MatriplexSym &a, const MatriplexSym &b)
Definition: MatriplexSym.h:212
mps_fire.i
i
Definition: mps_fire.py:428
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 476 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().

485  {
486  propPar = psPar;
487  if (propToHit) {
488  MPlexLS propErr;
489  MPlexQF msRad;
490 #pragma omp simd
491  for (int n = 0; n < NN; ++n) {
492  msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
493  }
494 
495  propagateHelixToRMPlex(psErr, psPar, inChg, msRad, propErr, propPar, N_proc, propFlags);
496 
497  kalmanOperation(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
498  } else {
499  kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
500  }
501  }
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:505
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 727 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().

736  {
737  propPar = psPar;
738  if (propToHit) {
739  MPlexLS propErr;
740  MPlexQF msZ;
741 #pragma omp simd
742  for (int n = 0; n < NN; ++n) {
743  msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
744  }
745 
746  propagateHelixToZMPlex(psErr, psPar, inChg, msZ, propErr, propPar, N_proc, propFlags);
747 
748  kalmanOperationEndcap(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
749  } else {
750  kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
751  }
752  }
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:756
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 431 of file KalmanUtilsMPlex.cc.

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

440  {
441  if (propToHit) {
442  MPlexLS propErr;
443  MPlexLV propPar;
444  MPlexQF msRad;
445 #pragma omp simd
446  for (int n = 0; n < NN; ++n) {
447  msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
448  }
449 
450  propagateHelixToRMPlex(psErr, psPar, Chg, msRad, propErr, propPar, N_proc, propFlags);
451 
452  kalmanOperation(KFO_Update_Params, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
453  } else {
454  kalmanOperation(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
455  }
456  for (int n = 0; n < NN; ++n) {
457  if (outPar.At(n, 3, 0) < 0) {
458  Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
459  outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
460  }
461  }
462  }
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:505
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 682 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().

691  {
692  if (propToHit) {
693  MPlexLS propErr;
694  MPlexLV propPar;
695  MPlexQF msZ;
696 #pragma omp simd
697  for (int n = 0; n < NN; ++n) {
698  msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
699  }
700 
701  propagateHelixToZMPlex(psErr, psPar, Chg, msZ, propErr, propPar, N_proc, propFlags);
702 
703  kalmanOperationEndcap(KFO_Update_Params, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
704  } else {
705  kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
706  }
707  for (int n = 0; n < NN; ++n) {
708  if (outPar.At(n, 3, 0) < 0) {
709  Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
710  outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
711  }
712  }
713  }
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:756
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 421 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), and KFO_Update_Params.

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

427  {
428  kalmanOperation(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
429  }
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:505

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

References kalmanOperationEndcap(), and KFO_Update_Params.

678  {
679  kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
680  }
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:756

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

830  {
831  //skip the overflow case
832  if (pcm >= Hit::maxChargePerCM())
833  return true;
834 
835  float qSF;
836  if (isBarrel) { //project in x,y, assuming zero-error direction is in this plane
837  const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
838  const float hitT2inv = 1.f / hitT2;
839  const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
840  msErr.constAt(itrack, 0, 1) * hitT2inv,
841  msErr.constAt(itrack, 1, 1) * hitT2inv};
842  const bool detXY_OK =
843  std::abs(proj[0] * proj[2] - proj[1] * proj[1]) < 0.1f; //check that zero-direction is close
844  const float cosP = cos(pPar.constAt(itrack, 4, 0));
845  const float sinP = sin(pPar.constAt(itrack, 4, 0));
846  const float sinT = std::abs(sin(pPar.constAt(itrack, 5, 0)));
847  //qSF = sqrt[(px,py)*(1-proj)*(px,py)]/p = sinT*sqrt[(cosP,sinP)*(1-proj)*(cosP,sinP)].
848  qSF = detXY_OK ? sinT * std::sqrt(std::abs(1.f + cosP * cosP * proj[0] + sinP * sinP * proj[2] -
849  2.f * cosP * sinP * proj[1]))
850  : 1.f;
851  } else { //project on z
852  // p_zLocal/p = p_z/p = cosT
853  qSF = std::abs(cos(pPar.constAt(itrack, 5, 0)));
854  }
855 
856  const float qCorr = pcm * qSF;
857  dprint("pcm " << pcm << " * " << qSF << " = " << qCorr << " vs " << pcmMin);
858  return qCorr > pcmMin;
859  }
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:428
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, mkfit::MaterialEffects::getRbin(), mkfit::MaterialEffects::getZbin(), helixAtRFromIterativeCCS(), hipo(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::Config::materialEff, dqmiodumpmetadata::n, mkfit::Config::nBinsRME, alignCSCRings::r, 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 < N_proc; ++n) {
538  if (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:428
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::MaterialEffects::getRbin
int getRbin(const float r) const
Definition: MaterialEffects.h:23
mkfit::Config::nBinsRME
constexpr int nBinsRME
Definition: MaterialEffects.h:15
mkfit::MaterialEffects::getZbin
int getZbin(const float z) const
Definition: MaterialEffects.h:22
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, mkfit::MaterialEffects::getRbin(), mkfit::MaterialEffects::getZbin(), helixAtZ(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::Config::materialEff, dqmiodumpmetadata::n, mkfit::Config::nBinsRME, 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 < N_proc; ++n) {
641  if (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:428
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
mkfit::MaterialEffects::getRbin
int getRbin(const float r) const
Definition: MaterialEffects.h:23
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
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
mkfit::MaterialEffects::getZbin
int getZbin(const float z) const
Definition: MaterialEffects.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, flavorHistoryFilter_cfi::dr, 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
A
Definition: APVGainStruct.h:7
flavorHistoryFilter_cfi.dr
dr
Definition: flavorHistoryFilter_cfi.py:37
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 ntupleEnum::Algo, mkfit::MkBuilder::backwardFit(), mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), mkfit::StdSeq::clean_cms_seedtracks_iter(), mkfit::MkBuilder::compactifyHitStorageForBestCand(), DetachedTripletStep_cff::detachedTripletStep, mkfit::MkBuilder::end_event(), mkfit::MkBuilder::endBkwSearch(), mkfit::MkBuilder::export_best_comb_cands(), mkfit::MkBuilder::filter_comb_cands(), mkfit::StdSeq::find_and_remove_duplicates(), 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_params, mkfit::IterationConfig::m_requires_dupclean_tight, mkfit::IterationConfig::m_requires_quality_filter, mkfit::IterationConfig::m_requires_seed_hit_sorting, mkfit::IterationConfig::m_track_algorithm, mkfit::IterationParams::minHitsQF, PixelLessStep_cff::pixelLessStep, PixelPairStep_cff::pixelPairStep, mkfit::StdSeq::qfilter_n_hits(), mkfit::StdSeq::qfilter_n_hits_pixseed(), mkfit::StdSeq::qfilter_n_layers(), mkfit::StdSeq::qfilter_nan_n_silly(), mkfit::StdSeq::qfilter_pixelLessBkwd(), mkfit::StdSeq::qfilter_pixelLessFwd(), mkfit::EventOfHits::refBeamSpot(), mkfit::MkBuilder::release_memory(), alignCSCRings::s, mkfit::MkBuilder::seed_post_cleaning(), DetachedQuadStep_cff::seeds, and submitPVValidationJobs::t.

Referenced by MkFitProducer::produce().

38  {
39  IterationMaskIfcCmssw it_mask_ifc(trackerInfo, hit_masks);
40 
41  MkJob job({trackerInfo, itconf, eoh, &it_mask_ifc});
42 
43  builder.begin_event(&job, nullptr, __func__);
44 
45  if (do_seed_clean) {
46  // Seed cleaning not done on pixelLess / tobTec iters
47  if (itconf.m_requires_dupclean_tight)
48  StdSeq::clean_cms_seedtracks_iter(&seeds, itconf, eoh.refBeamSpot());
49  }
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  using Algo = TrackBase::TrackAlgorithm;
65  if (itconf.m_requires_quality_filter && Algo(itconf.m_track_algorithm) != Algo::detachedTripletStep) {
66  if (Algo(itconf.m_track_algorithm) == Algo::pixelPairStep) {
67  builder.filter_comb_cands([&](const TrackCand &t) { return StdSeq::qfilter_n_hits_pixseed(t, 3); });
68  } else if (Algo(itconf.m_track_algorithm) == Algo::pixelLessStep) {
69  builder.filter_comb_cands(
70  [&](const TrackCand &t) { return StdSeq::qfilter_pixelLessFwd(t, eoh.refBeamSpot(), trackerInfo); });
71  } else {
72  builder.filter_comb_cands(
73  [&](const TrackCand &t) { return StdSeq::qfilter_n_hits(t, itconf.m_params.minHitsQF); });
74  }
75  }
76 
77  if (do_backward_fit) {
78  if (itconf.m_backward_search) {
79  builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
80  }
81 
82  builder.backwardFit();
83 
84  if (itconf.m_backward_search) {
85  builder.beginBkwSearch();
86  builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
87  builder.endBkwSearch();
88  }
89 
90  if (itconf.m_requires_quality_filter && (Algo(itconf.m_track_algorithm) == Algo::detachedTripletStep ||
91  Algo(itconf.m_track_algorithm) == Algo::pixelLessStep)) {
92  if (Algo(itconf.m_track_algorithm) == Algo::detachedTripletStep) {
93  builder.filter_comb_cands(
94  [&](const TrackCand &t) { return StdSeq::qfilter_n_layers(t, eoh.refBeamSpot(), trackerInfo); });
95  } else if (Algo(itconf.m_track_algorithm) == Algo::pixelLessStep) {
96  builder.filter_comb_cands(
97  [&](const TrackCand &t) { return StdSeq::qfilter_pixelLessBkwd(t, eoh.refBeamSpot(), trackerInfo); });
98  }
99  }
100  }
101 
102  builder.filter_comb_cands([&](const TrackCand &t) { return StdSeq::qfilter_nan_n_silly(t); });
103 
104  builder.export_best_comb_cands(out_tracks, true);
105 
106  if (do_remove_duplicates) {
107  StdSeq::find_and_remove_duplicates(out_tracks, itconf);
108  }
109 
110  builder.end_event();
111  builder.release_memory();
112  }
mkfit::StdSeq::find_and_remove_duplicates
void find_and_remove_duplicates(TrackVec &tracks, const IterationConfig &itconf)
Definition: MkStdSeqs.cc:591
mkfit::StdSeq::qfilter_n_hits_pixseed
bool qfilter_n_hits_pixseed(const TRACK &t, int nMinHits)
Definition: MkStdSeqs.h:50
mkfit::StdSeq::qfilter_pixelLessFwd
bool qfilter_pixelLessFwd(const TRACK &t, const BeamSpot &bspot, const TrackerInfo &tk_info)
quality filter tuned for pixelLess iteration during forward search
Definition: MkStdSeqs.h:78
DetachedTripletStep_cff.detachedTripletStep
detachedTripletStep
Definition: DetachedTripletStep_cff.py:285
mkfit::StdSeq::qfilter_n_hits
bool qfilter_n_hits(const TRACK &t, int nMinHits)
Definition: MkStdSeqs.h:42
mkfit::StdSeq::qfilter_n_layers
bool qfilter_n_layers(const TRACK &t, const BeamSpot &bspot, const TrackerInfo &trk_inf)
Definition: MkStdSeqs.h:56
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:199
PixelLessStep_cff.pixelLessStep
pixelLessStep
Definition: PixelLessStep_cff.py:382
PixelPairStep_cff.pixelPairStep
pixelPairStep
Definition: PixelPairStep_cff.py:369
mkfit::StdSeq::qfilter_pixelLessBkwd
bool qfilter_pixelLessBkwd(const TRACK &t, const BeamSpot &bspot, const TrackerInfo &tk_info)
quality filter tuned for pixelLess iteration during backward search
Definition: MkStdSeqs.h:104
TrackAlgorithm
TrackBase::TrackAlgorithm TrackAlgorithm
Definition: WriteMemoryFile.cc:14
mkfit::StdSeq::qfilter_nan_n_silly
bool qfilter_nan_n_silly(const TRACK &t)
Definition: MkStdSeqs.h:128
Algo
Definition: fakeMenu.h:6
mkfit::StdSeq::clean_cms_seedtracks_iter
int clean_cms_seedtracks_iter(TrackVec *seed_ptr, const IterationConfig &itrcfg, const BeamSpot &bspot)
Definition: MkStdSeqs.cc:84
HLT_2022v12_cff.TrackCand
TrackCand
Definition: HLT_2022v12_cff.py:17961

◆ runBtpCe_MultiIter()

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

Definition at line 389 of file buildtestMPlex.cc.

References ntupleEnum::Algo, analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFit(), mkfit::Config::backwardSearch, mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), mkfit::StdSeq::clean_cms_seedtracks_iter(), mkfit::Config::cmssw_val, mkfit::MkBuilder::compactifyHitStorageForBestCand(), DetachedTripletStep_cff::detachedTripletStep, dtime(), mkfit::MkBuilder::end_event(), mkfit::MkBuilder::endBkwSearch(), makeMEIFBenchmarkPlots::ev, mkfit::MkBuilder::export_tracks(), mkfit::MkBuilder::filter_comb_cands(), spr::find(), mkfit::StdSeq::find_and_remove_duplicates(), 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::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_params, mkfit::IterationConfig::m_requires_dupclean_tight, mkfit::IterationConfig::m_requires_quality_filter, mkfit::IterationConfig::m_requires_seed_hit_sorting, mkfit::IterationConfig::m_track_algorithm, mkfit::IterationParams::minHitsQF, eostools::move(), dqmiodumpmetadata::n, PixelLessStep_cff::pixelLessStep, PixelPairStep_cff::pixelPairStep, mkfit::StdSeq::prep_simtracks(), mkfit::StdSeq::qfilter_n_hits(), mkfit::StdSeq::qfilter_n_hits_pixseed(), mkfit::StdSeq::qfilter_n_layers(), mkfit::StdSeq::qfilter_nan_n_silly(), mkfit::StdSeq::qfilter_pixelLessBkwd(), mkfit::StdSeq::qfilter_pixelLessFwd(), 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().

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

◆ 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::StdSeq::find_duplicates(), 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::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, &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 find_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  if (Config::removeDuplicates) {
167  StdSeq::find_duplicates(ev.candidateTracks_);
168  }
169  }
170 
171  // now do backwards fit... do we want to time this section?
172  if (Config::backwardFit) {
173  builder.backwardFitBH();
174  ev.fitTracks_ = builder.ref_tracks();
175  }
176 
177  if (Config::quality_val) {
178  StdSeq::Quality qval;
179  qval.quality_val(&ev);
180  } else if (Config::sim_val || Config::cmssw_val) {
181  StdSeq::root_val(&ev);
182  }
183 
184  builder.end_event();
185 
186  // ev.print_tracks(ev.candidateTracks_, true);
187 
188  return time;
189  }
Quality
pixelTrack::Quality Quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:30
mkfit::StdSeq::find_duplicates
void find_duplicates(TrackVec &tracks)
Definition: MkStdSeqs.cc:335
mkfit::StdSeq::root_val
void root_val(Event *event)
Definition: MkStandaloneSeqs.cc:262
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:36
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 282 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::StdSeq::handle_duplicates(), 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::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().

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

◆ 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::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});
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:241

◆ runBuildingTestPlexStandard()

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

Definition at line 195 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::StdSeq::handle_duplicates(), 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::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().

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

◆ runFittingTestPlex()

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

Definition at line 40 of file fittestMPlex.cc.

References submitPVResolutionJobs::count, dtime(), mps_fire::end, 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:428
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:51
mkfit::Config::numThreadsFinder
constexpr int numThreadsFinder
Definition: Config.h:120
protons_cff.time
time
Definition: protons_cff.py:36
mps_fire.end
end
Definition: mps_fire.py:242
mkfit::ExecutionContext::m_fitters
Pool< MkFitter > m_fitters
Definition: MkBuilder.cc:41
mkfit::ExecutionContext::populate
void populate(int n_thr)
Definition: MkBuilder.cc:44
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(), x, and testProducerWithPsetDescEmpty_cfi::x2.

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:428
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::find_duplicates(), mkfit::StdSeq::find_duplicates_sharedhits(), and mkfit::StdSeq::find_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 32 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 32 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 41 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 41 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 59 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 59 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 84 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 84 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 103 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 103 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 106 of file IterationConfig.cc.

◆ to_json() [12/12]

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

Definition at line 106 of file IterationConfig.cc.

Variable Documentation

◆ g_exe_ctx

ExecutionContext mkfit::g_exe_ctx

Definition at line 51 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(), 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