Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2023-11-19 23:58:42

0001 #ifndef RecoTracker_MkFitCore_src_KalmanUtilsMPlex_h
0002 #define RecoTracker_MkFitCore_src_KalmanUtilsMPlex_h
0003 
0004 #include "RecoTracker/MkFitCore/interface/Track.h"
0005 #include "Matrix.h"
0006 
0007 namespace mkfit {
0008 
0009   //------------------------------------------------------------------------------
0010 
0011   enum KalmanFilterOperation { KFO_Calculate_Chi2 = 1, KFO_Update_Params = 2, KFO_Local_Cov = 4 };
0012 
0013   //------------------------------------------------------------------------------
0014 
0015   void kalmanUpdate(const MPlexLS& psErr,
0016                     const MPlexLV& psPar,
0017                     const MPlexHS& msErr,
0018                     const MPlexHV& msPar,
0019                     MPlexLS& outErr,
0020                     MPlexLV& outPar,
0021                     const int N_proc);
0022 
0023   void kalmanPropagateAndUpdate(const MPlexLS& psErr,
0024                                 const MPlexLV& psPar,
0025                                 MPlexQI& Chg,
0026                                 const MPlexHS& msErr,
0027                                 const MPlexHV& msPar,
0028                                 MPlexLS& outErr,
0029                                 MPlexLV& outPar,
0030                                 MPlexQI& outFailFlag,
0031                                 const int N_proc,
0032                                 const PropagationFlags& propFlags,
0033                                 const bool propToHit);
0034 
0035   void kalmanComputeChi2(const MPlexLS& psErr,
0036                          const MPlexLV& psPar,
0037                          const MPlexQI& inChg,
0038                          const MPlexHS& msErr,
0039                          const MPlexHV& msPar,
0040                          MPlexQF& outChi2,
0041                          const int N_proc);
0042 
0043   void kalmanPropagateAndComputeChi2(const MPlexLS& psErr,
0044                                      const MPlexLV& psPar,
0045                                      const MPlexQI& inChg,
0046                                      const MPlexHS& msErr,
0047                                      const MPlexHV& msPar,
0048                                      MPlexQF& outChi2,
0049                                      MPlexLV& propPar,
0050                                      MPlexQI& outFailFlag,
0051                                      const int N_proc,
0052                                      const PropagationFlags& propFlags,
0053                                      const bool propToHit);
0054 
0055   void kalmanOperation(const int kfOp,
0056                        const MPlexLS& psErr,
0057                        const MPlexLV& psPar,
0058                        const MPlexHS& msErr,
0059                        const MPlexHV& msPar,
0060                        MPlexLS& outErr,
0061                        MPlexLV& outPar,
0062                        MPlexQF& outChi2,
0063                        const int N_proc);
0064 
0065   //------------------------------------------------------------------------------
0066 
0067   void kalmanUpdateEndcap(const MPlexLS& psErr,
0068                           const MPlexLV& psPar,
0069                           const MPlexHS& msErr,
0070                           const MPlexHV& msPar,
0071                           MPlexLS& outErr,
0072                           MPlexLV& outPar,
0073                           const int N_proc);
0074 
0075   void kalmanPropagateAndUpdateEndcap(const MPlexLS& psErr,
0076                                       const MPlexLV& psPar,
0077                                       MPlexQI& Chg,
0078                                       const MPlexHS& msErr,
0079                                       const MPlexHV& msPar,
0080                                       MPlexLS& outErr,
0081                                       MPlexLV& outPar,
0082                                       MPlexQI& outFailFlag,
0083                                       const int N_proc,
0084                                       const PropagationFlags& propFlags,
0085                                       const bool propToHit);
0086 
0087   void kalmanComputeChi2Endcap(const MPlexLS& psErr,
0088                                const MPlexLV& psPar,
0089                                const MPlexQI& inChg,
0090                                const MPlexHS& msErr,
0091                                const MPlexHV& msPar,
0092                                MPlexQF& outChi2,
0093                                const int N_proc);
0094 
0095   void kalmanPropagateAndComputeChi2Endcap(const MPlexLS& psErr,
0096                                            const MPlexLV& psPar,
0097                                            const MPlexQI& inChg,
0098                                            const MPlexHS& msErr,
0099                                            const MPlexHV& msPar,
0100                                            MPlexQF& outChi2,
0101                                            MPlexLV& propPar,
0102                                            MPlexQI& outFailFlag,
0103                                            const int N_proc,
0104                                            const PropagationFlags& propFlags,
0105                                            const bool propToHit);
0106 
0107   void kalmanOperationEndcap(const int kfOp,
0108                              const MPlexLS& psErr,
0109                              const MPlexLV& psPar,
0110                              const MPlexHS& msErr,
0111                              const MPlexHV& msPar,
0112                              MPlexLS& outErr,
0113                              MPlexLV& outPar,
0114                              MPlexQF& outChi2,
0115                              const int N_proc);
0116 
0117   //------------------------------------------------------------------------------
0118 
0119   void kalmanUpdatePlane(const MPlexLS& psErr,
0120                          const MPlexLV& psPar,
0121                          const MPlexHS& msErr,
0122                          const MPlexHV& msPar,
0123                          const MPlexHV& plNrm,
0124                          const MPlexHV& plDir,
0125                          MPlexLS& outErr,
0126                          MPlexLV& outPar,
0127                          const int N_proc);
0128 
0129   void kalmanPropagateAndUpdatePlane(const MPlexLS& psErr,
0130                                      const MPlexLV& psPar,
0131                                      MPlexQI& Chg,
0132                                      const MPlexHS& msErr,
0133                                      const MPlexHV& msPar,
0134                                      const MPlexHV& plNrm,
0135                                      const MPlexHV& plDir,
0136                                      MPlexLS& outErr,
0137                                      MPlexLV& outPar,
0138                                      MPlexQI& outFailFlag,
0139                                      const int N_proc,
0140                                      const PropagationFlags& propFlags,
0141                                      const bool propToHit);
0142 
0143   void kalmanComputeChi2Plane(const MPlexLS& psErr,
0144                               const MPlexLV& psPar,
0145                               const MPlexQI& inChg,
0146                               const MPlexHS& msErr,
0147                               const MPlexHV& msPar,
0148                               const MPlexHV& plNrm,
0149                               const MPlexHV& plDir,
0150                               MPlexQF& outChi2,
0151                               const int N_proc);
0152 
0153   void kalmanPropagateAndComputeChi2Plane(const MPlexLS& psErr,
0154                                           const MPlexLV& psPar,
0155                                           const MPlexQI& inChg,
0156                                           const MPlexHS& msErr,
0157                                           const MPlexHV& msPar,
0158                                           const MPlexHV& plNrm,
0159                                           const MPlexHV& plDir,
0160                                           MPlexQF& outChi2,
0161                                           MPlexLV& propPar,
0162                                           MPlexQI& outFailFlag,
0163                                           const int N_proc,
0164                                           const PropagationFlags& propFlags,
0165                                           const bool propToHit);
0166 
0167   void kalmanOperationPlane(const int kfOp,
0168                             const MPlexLS& psErr,
0169                             const MPlexLV& psPar,
0170                             const MPlexHS& msErr,
0171                             const MPlexHV& msPar,
0172                             const MPlexHV& plNrm,
0173                             const MPlexHV& plDir,
0174                             MPlexLS& outErr,
0175                             MPlexLV& outPar,
0176                             MPlexQF& outChi2,
0177                             const int N_proc);
0178 
0179 }  // end namespace mkfit
0180 #endif