TrackerTFP/interface/CleanTrackBuilder.h

0001 #ifndef L1Trigger_TrackerTFP_CleanTrackBuilder_h
0002 #define L1Trigger_TrackerTFP_CleanTrackBuilder_h
0003
0004 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0005 #include "L1Trigger/TrackTrigger/interface/Setup.h"
0006 #include "L1Trigger/TrackerTFP/interface/DataFormats.h"
0007 #include "L1Trigger/TrackerTFP/interface/LayerEncoding.h"
0008 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0009
0010 #include <vector>
0011 #include <deque>
0012
0013 namespace trackerTFP {
0014
0015   // Class to clean and transform stream of stubs into a stream of tracks with one stub stream per kf layer
0016   class CleanTrackBuilder {
0017   public:
0018     CleanTrackBuilder(const tt::Setup* setup,
0019                       const DataFormats* dataFormats,
0020                       const LayerEncoding* layerEncoding,
0021                       const DataFormat& cot,
0022                       std::vector<StubCTB>& stubs,
0023                       std::vector<TrackCTB>& tracks);
0024     ~CleanTrackBuilder() = default;
0025     // fill output products
0026     void produce(const std::vector<std::vector<StubHT*>>& streamsIn,
0027                  std::vector<std::deque<TrackCTB*>>& regionTracks,
0028                  std::vector<std::vector<std::deque<StubCTB*>>>& regionStubs);
0029     void put(TrackCTB* track, const std::vector<std::vector<StubCTB*>>& stubs, int region, tt::TTTracks& ttTracks) const;
0030
0031   private:
0032     // struct to represent internal stubs
0033     struct Stub {
0034       // construct Stub from StubHT
0035       Stub(StubHT* stub, int trackId, const TTBV& hitsPhi, const TTBV& hitsZ, int layerId, double dPhi, double dZ)
0036           : stubHT_(stub),
0037             trackId_(trackId),
0038             hitsPhi_(hitsPhi),
0039             hitsZ_(hitsZ),
0040             layerId_(layerId),
0041             dPhi_(dPhi),
0042             dZ_(dZ) {}
0043       //
0044       void update(const TTBV& phi, const TTBV& z, std::vector<int>& ids, int max);
0045       // original ht stub
0046       StubHT* stubHT_;
0047       //
0048       bool valid_ = true;
0049       //
0050       int trackId_;
0051       //
0052       int stubId_ = -1;
0053       //
0054       TTBV hitsPhi_;
0055       //
0056       TTBV hitsZ_;
0057       //
0058       int layerId_;
0059       //
0060       double dPhi_;
0061       //
0062       double dZ_;
0063     };
0064
0065     // struct to represent internal tracks
0066     struct Track {
0067       // construct Track from Stubs
0068       Track(const tt::Setup* setup,
0069             int trackId,
0070             const TTBV& hitsPhi,
0071             const TTBV& hitsZ,
0072             const std::vector<Stub*>& stubs,
0073             double inv2R);
0074       //
0075       bool valid_;
0076       // stubs
0077       std::vector<Stub*> stubs_;
0078       // track id
0079       int trackId_;
0080       //
0081       TTBV hitsPhi_;
0082       //
0083       TTBV hitsZ_;
0084       //
0085       double inv2R_;
0086       // size: number of stubs on most occupied layer
0087       int size_;
0088     };
0089     //
0090     void cleanStream(const std::vector<StubHT*>& input,
0091                      std::deque<Track*>& tracks,
0092                      std::deque<Stub*>& stubs,
0093                      int channelId);
0094     // run single track through r-phi and r-z hough transform
0095     void cleanTrack(const std::vector<StubHT*>& track,
0096                     std::deque<Track*>& tracks,
0097                     std::deque<Stub*>& stubs,
0098                     double inv2R,
0099                     int zT,
0100                     int trackId);
0101     //
0102     void route(std::vector<std::deque<Track*>>& inputs, std::deque<Track*>& output) const;
0103     //
0104     void route(std::vector<std::deque<Stub*>>& input, std::vector<std::deque<Stub*>>& outputs) const;
0105     //
0106     void sort(std::deque<Track*>& track, std::vector<std::deque<Stub*>>& stubs) const;
0107     //
0108     void convert(const std::deque<Track*>& iTracks,
0109                  const std::vector<std::deque<Stub*>>& iStubs,
0110                  std::deque<TrackCTB*>& oTracks,
0111                  std::vector<std::deque<StubCTB*>>& oStubs);
0112     // remove and return first element of deque, returns nullptr if empty
0113     template <class T>
0114     T* pop_front(std::deque<T*>& ts) const;
0115     // provides run-time constants
0116     const tt::Setup* setup_;
0117     // provides dataformats
0118     const DataFormats* dataFormats_;
0119     //
0120     const LayerEncoding* layerEncoding_;
0121     //
0122     DataFormat cot_;
0123     // container of internal stubs
0124     std::vector<Stub> stubs_;
0125     // container of internal tracks
0126     std::vector<Track> tracks_;
0127     // container of output stubs
0128     std::vector<StubCTB>& stubsCTB_;
0129     // container of output tracks
0130     std::vector<TrackCTB>& tracksCTB_;
0131     // number of output channel
0132     int numChannelOut_;
0133     // number of channel
0134     int numChannel_;
0135     // number of processing regions
0136     int numRegions_;
0137     // number of kf layers
0138     int numLayers_;
0139     int wlayer_;
0140     const DataFormat& r_;
0141     const DataFormat& phi_;
0142     const DataFormat& z_;
0143     const DataFormat& phiT_;
0144     const DataFormat& zT_;
0145     int numBinsInv2R_;
0146     int numBinsPhiT_;
0147     int numBinsCot_;
0148     int numBinsZT_;
0149     double baseInv2R_;
0150     double basePhiT_;
0151     double baseCot_;
0152     double baseZT_;
0153   };
0154
0155 }  // namespace trackerTFP
0156
0157 #endif