TrackerTFP/interface/KalmanFilter.h

0001 #ifndef L1Trigger_TrackerTFP_KalmanFilter_h
0002 #define L1Trigger_TrackerTFP_KalmanFilter_h
0003
0004 #include "L1Trigger/TrackTrigger/interface/Setup.h"
0005 #include "L1Trigger/TrackerTFP/interface/DataFormats.h"
0006 #include "L1Trigger/TrackerTFP/interface/LayerEncoding.h"
0007 #include "L1Trigger/TrackerTFP/interface/KalmanFilterFormats.h"
0008 #include "L1Trigger/TrackerTFP/interface/State.h"
0009 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0010
0011 #include <vector>
0012 #include <deque>
0013 #include <utility>
0014
0015 namespace trackerTFP {
0016
0017   // Class to do helix fit to all tracks in a region.
0018   class KalmanFilter {
0019   public:
0020     typedef State::Stub Stub;
0021     KalmanFilter(const tt::Setup* setup,
0022                  const DataFormats* dataFormats,
0023                  const LayerEncoding* layerEncoding,
0024                  KalmanFilterFormats* kalmanFilterFormats,
0025                  std::vector<TrackKF>& tracks,
0026                  std::vector<StubKF>& stubs);
0027     ~KalmanFilter() = default;
0028
0029     // fill output products
0030     void produce(const std::vector<std::vector<TrackCTB*>>& tracksIn,
0031                  const std::vector<std::vector<Stub*>>& stubsIn,
0032                  std::vector<std::vector<TrackKF*>>& tracksOut,
0033                  std::vector<std::vector<std::vector<StubKF*>>>& stubsOut,
0034                  int& numAcceptedStates,
0035                  int& numLostStates,
0036                  std::deque<std::pair<double, double>>& chi2s);
0037
0038   private:
0039     //
0040     struct Track {
0041       Track() {}
0042       Track(int trackId,
0043             int numConsistent,
0044             int numConsistentPS,
0045             double inv2R,
0046             double phiT,
0047             double cot,
0048             double zT,
0049             double chi20,
0050             double chi21,
0051             const TTBV& hitPattern,
0052             TrackCTB* track,
0053             const std::vector<StubCTB*>& stubs,
0054             const std::vector<double>& phi,
0055             const std::vector<double>& z)
0056           : trackId_(trackId),
0057             numConsistent_(numConsistent),
0058             numConsistentPS_(numConsistentPS),
0059             inv2R_(inv2R),
0060             phiT_(phiT),
0061             cot_(cot),
0062             zT_(zT),
0063             chi20_(chi20),
0064             chi21_(chi21),
0065             hitPattern_(hitPattern),
0066             track_(track),
0067             stubs_(stubs),
0068             phi_(phi),
0069             z_(z) {}
0070       int trackId_;
0071       int numConsistent_;
0072       int numConsistentPS_;
0073       double inv2R_;
0074       double phiT_;
0075       double cot_;
0076       double zT_;
0077       double chi20_;
0078       double chi21_;
0079       TTBV hitPattern_;
0080       TrackCTB* track_;
0081       std::vector<StubCTB*> stubs_;
0082       std::vector<double> phi_;
0083       std::vector<double> z_;
0084     };
0085     // remove and return first element of deque, returns nullptr if empty
0086     template <class T>
0087     T* pop_front(std::deque<T*>& ts) const;
0088     // constraints double precision
0089     double digi(VariableKF var, double val) const { return kalmanFilterFormats_->format(var).digi(val); }
0090     //
0091     int integer(VariableKF var, double val) const { return kalmanFilterFormats_->format(var).integer(val); }
0092     //
0093     void updateRangeActual(VariableKF var, double val) {
0094       return kalmanFilterFormats_->format(var).updateRangeActual(val);
0095     }
0096     //
0097     double base(VariableKF var) const { return kalmanFilterFormats_->format(var).base(); }
0098     //
0099     int width(VariableKF var) const { return kalmanFilterFormats_->format(var).width(); }
0100     //
0101     int inRange(VariableKF var, double val) const { return kalmanFilterFormats_->format(var).inRange(val); }
0102
0103     // create Proto States
0104     void createProtoStates(const std::vector<std::vector<TrackCTB*>>& tracksIn,
0105                            const std::vector<std::vector<Stub*>>& stubsIn,
0106                            int channel,
0107                            std::deque<State*>& stream);
0108     // calulcate seed parameter
0109     void calcSeeds(std::deque<State*>& stream);
0110     // apply final cuts
0111     void finalize(const std::deque<State*>& stream, std::vector<Track>& finals);
0112     // Transform States into Tracks
0113     void conv(const std::vector<Track*>& best, std::vector<TrackKF*>& tracks, std::vector<std::vector<StubKF*>>& stubs);
0114     // adds a layer to states
0115     void addLayer(std::deque<State*>& stream);
0116     // adds a layer to states to build seeds
0117     void addSeedLayer(std::deque<State*>& stream);
0118     // Assign next combinatoric (i.e. not first in layer) stub to state
0119     void comb(State*& state);
0120     // best state selection
0121     void accumulator(std::vector<Track>& finals, std::vector<Track*>& best);
0122     // updates state
0123     void update(State*& state);
0124
0125     // provides run-time constants
0126     const tt::Setup* setup_;
0127     // provides dataformats
0128     const DataFormats* dataFormats_;
0129     // provides layer Encoding
0130     const LayerEncoding* layerEncoding_;
0131     // provides dataformats of Kalman filter internals
0132     KalmanFilterFormats* kalmanFilterFormats_;
0133     // container of output tracks
0134     std::vector<TrackKF>& tracks_;
0135     // container of output stubs
0136     std::vector<StubKF>& stubs_;
0137     // container of all Kalman Filter states
0138     std::deque<State> states_;
0139     //
0140     std::vector<Track> finals_;
0141     // current layer used during state propagation
0142     int layer_;
0143   };
0144
0145 }  // namespace trackerTFP
0146
0147 #endif