TrackFindingTracklet/interface/DRin.h

0001 #ifndef L1Trigger_TrackFindingTracklet_DRin_h
0002 #define L1Trigger_TrackFindingTracklet_DRin_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/TrackFindingTracklet/interface/ChannelAssignment.h"
0008 #include "L1Trigger/TrackFindingTracklet/interface/Settings.h"
0009
0010 #include <vector>
0011 #include <deque>
0012
0013 namespace trklet {
0014
0015   /*! \class  trklet::DRin
0016    *  \brief  Class to emulate transformation of tracklet tracks and stubs into TMTT format
0017    *          and routing of seed type streams into inv2R streams
0018    *  \author Thomas Schuh
0019    *  \date   2023, Jan
0020    */
0021   class DRin {
0022   public:
0023     DRin(const edm::ParameterSet& iConfig,
0024          const tt::Setup* setup_,
0025          const trackerTFP::DataFormats* dataFormats,
0026          const trackerTFP::LayerEncoding* layerEncoding,
0027          const ChannelAssignment* channelAssignment,
0028          const Settings* settings,
0029          int region);
0030     ~DRin() {}
0031     // read in and organize input tracks and stubs
0032     void consume(const tt::StreamsTrack& streamsTrack, const tt::StreamsStub& streamsStub);
0033     // fill output products
0034     void produce(tt::StreamsStub& accpetedStubs,
0035                  tt::StreamsTrack& acceptedTracks,
0036                  tt::StreamsStub& lostStubs,
0037                  tt::StreamsTrack& lostTracks);
0038
0039   private:
0040     // truncates double precision of val into base precision, +1.e-12 restores robustness of addition of 2 digitised values
0041     double digi(double val, double base) const { return (floor(val / base + 1.e-12) + .5) * base; }
0042     // basetransformation of val from baseLow into baseHigh using widthMultiplier bit multiplication
0043     double redigi(double val, double baseLow, double baseHigh, int widthMultiplier) const;
0044     struct Stub {
0045       Stub(const TTStubRef& ttStubRef,
0046            int layer,
0047            int layerDet,
0048            bool seed,
0049            int stubId,
0050            double r,
0051            double phi,
0052            double z,
0053            bool psTilt)
0054           : valid_(true),
0055             ttStubRef_(ttStubRef),
0056             layer_(layer),
0057             layerDet_(layerDet),
0058             layerKF_(-1),
0059             seed_(seed),
0060             stubId_(stubId),
0061             r_(r),
0062             phi_(phi),
0063             z_(z),
0064             psTilt_(psTilt) {}
0065       bool valid_;
0066       TTStubRef ttStubRef_;
0067       // layers a seed types can project to using default layer id [barrel: 1-6, discs: 11-15]
0068       int layer_;
0069       // layer id [0-5] barrel [6-10] end cap discs
0070       int layerDet_;
0071       // layer id [0-6] counted from inside-out along track
0072       int layerKF_;
0073       // true if stub was part of the seed
0074       bool seed_;
0075       // traclet stub id
0076       int stubId_;
0077       // radius w.r.t. chosenRofPhi in cm
0078       double r_;
0079       // phi residual in rad
0080       double phi_;
0081       // z residual in cm
0082       double z_;
0083       // true if barrel tilted module or encap PS module
0084       bool psTilt_;
0085     };
0086     struct Track {
0087       static constexpr int max_ = 8;
0088       Track() { stubs_.reserve(max_); }
0089       Track(const TTTrackRef& ttTrackRef,
0090             bool valid,
0091             double inv2R,
0092             double phiT,
0093             double cot,
0094             double zT,
0095             const std::vector<Stub*>& stubs)
0096           : ttTrackRef_(ttTrackRef),
0097             valid_(valid),
0098             sector_(-1),
0099             inv2R_(inv2R),
0100             phiT_(phiT),
0101             cot_(cot),
0102             zT_(zT),
0103             stubs_(stubs) {}
0104       TTTrackRef ttTrackRef_;
0105       bool valid_;
0106       TTBV maybe_;
0107       int sector_;
0108       double inv2R_;
0109       double phiT_;
0110       double cot_;
0111       double zT_;
0112       std::vector<Stub*> stubs_;
0113     };
0114     // remove and return first element of deque, returns nullptr if empty
0115     template <class T>
0116     T* pop_front(std::deque<T*>& ts) const;
0117     // true if truncation is enbaled
0118     bool enableTruncation_;
0119     // stub residuals are recalculated from seed parameter and TTStub position
0120     bool useTTStubResiduals_;
0121     // provides run-time constants
0122     const tt::Setup* setup_;
0123     // provides dataformats
0124     const trackerTFP::DataFormats* dataFormats_;
0125     // helper class to encode layer
0126     const trackerTFP::LayerEncoding* layerEncoding_;
0127     // helper class to assign tracks to channel
0128     const ChannelAssignment* channelAssignment_;
0129     // provides tracklet constants
0130     const Settings* settings_;
0131     // processing region (0 - 8) aka processing phi nonant
0132     const int region_;
0133     // storage of input tracks
0134     std::vector<Track> tracks_;
0135     // storage of input stubs
0136     std::vector<Stub> stubs_;
0137     // h/w liked organized pointer to input tracks
0138     std::vector<std::vector<Track*>> input_;
0139     // unified tracklet digitisation granularity
0140     double baseUinv2R_;
0141     double baseUphiT_;
0142     double baseUcot_;
0143     double baseUzT_;
0144     double baseUr_;
0145     double baseUphi_;
0146     double baseUz_;
0147     // KF input format digitisation granularity (identical to TMTT)
0148     double baseLinv2R_;
0149     double baseLphiT_;
0150     double baseLcot_;
0151     double baseLzT_;
0152     double baseLr_;
0153     double baseLphi_;
0154     double baseLz_;
0155     // Finer granularity (by powers of 2) than the TMTT one. Used to transform from Tracklet to TMTT base.
0156     double baseHinv2R_;
0157     double baseHphiT_;
0158     double baseHcot_;
0159     double baseHzT_;
0160     double baseHr_;
0161     double baseHphi_;
0162     double baseHz_;
0163     // digitisation granularity used for inverted cot(theta)
0164     double baseInvCot_;
0165   };
0166
0167 }  // namespace trklet
0168
0169 #endif