Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-10-17 22:59:04

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 MPlexQI& Chg,
0122                          const MPlexHS& msErr,
0123                          const MPlexHV& msPar,
0124                          const MPlexHV& plNrm,
0125                          const MPlexHV& plDir,
0126                          const MPlexHV& plPnt,
0127                          MPlexLS& outErr,
0128                          MPlexLV& outPar,
0129                          const int N_proc);
0130 
0131   void kalmanPropagateAndUpdatePlane(const MPlexLS& psErr,
0132                                      const MPlexLV& psPar,
0133                                      MPlexQI& Chg,
0134                                      const MPlexHS& msErr,
0135                                      const MPlexHV& msPar,
0136                                      const MPlexHV& plNrm,
0137                                      const MPlexHV& plDir,
0138                                      const MPlexHV& plPnt,
0139                                      MPlexLS& outErr,
0140                                      MPlexLV& outPar,
0141                                      MPlexQI& outFailFlag,
0142                                      const int N_proc,
0143                                      const PropagationFlags& propFlags,
0144                                      const bool propToHit);
0145 
0146   void kalmanComputeChi2Plane(const MPlexLS& psErr,
0147                               const MPlexLV& psPar,
0148                               const MPlexQI& inChg,
0149                               const MPlexHS& msErr,
0150                               const MPlexHV& msPar,
0151                               const MPlexHV& plNrm,
0152                               const MPlexHV& plDir,
0153                               const MPlexHV& plPnt,
0154                               MPlexQF& outChi2,
0155                               const int N_proc);
0156 
0157   void kalmanPropagateAndComputeChi2Plane(const MPlexLS& psErr,
0158                                           const MPlexLV& psPar,
0159                                           const MPlexQI& inChg,
0160                                           const MPlexHS& msErr,
0161                                           const MPlexHV& msPar,
0162                                           const MPlexHV& plNrm,
0163                                           const MPlexHV& plDir,
0164                                           const MPlexHV& plPnt,
0165                                           MPlexQF& outChi2,
0166                                           MPlexLV& propPar,
0167                                           MPlexQI& outFailFlag,
0168                                           const int N_proc,
0169                                           const PropagationFlags& propFlags,
0170                                           const bool propToHit);
0171 
0172   void kalmanOperationPlane(const int kfOp,
0173                             const MPlexLS& psErr,
0174                             const MPlexLV& psPar,
0175                             const MPlexQI& Chg,
0176                             const MPlexHS& msErr,
0177                             const MPlexHV& msPar,
0178                             const MPlexHV& plNrm,
0179                             const MPlexHV& plDir,
0180                             const MPlexHV& plPnt,
0181                             MPlexLS& outErr,
0182                             MPlexLV& outPar,
0183                             MPlexQF& outChi2,
0184                             const int N_proc);
0185 
0186   void kalmanOperationPlaneLocal(const int kfOp,
0187                                  const MPlexLS& psErr,
0188                                  const MPlexLV& psPar,
0189                                  const MPlexQI& Chg,
0190                                  const MPlexHS& msErr,
0191                                  const MPlexHV& msPar,
0192                                  const MPlexHV& plNrm,
0193                                  const MPlexHV& plDir,
0194                                  const MPlexHV& plPnt,
0195                                  MPlexLS& outErr,
0196                                  MPlexLV& outPar,
0197                                  MPlexQF& outChi2,
0198                                  const int N_proc);
0199 
0200 }  // end namespace mkfit
0201 #endif