Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-03-05 03:16:38 

0001 #ifndef L1Trigger_Phase2L1GT_L1GTEvaluationInterface_h
0002 #define L1Trigger_Phase2L1GT_L1GTEvaluationInterface_h
0003 
0004 #include "DataFormats/L1Trigger/interface/P2GTCandidate.h"
0005 
0006 #include <ap_int.h>
0007 
0008 #include <array>
0009 #include <cstddef>
0010 #include <cstdint>
0011 
0012 /**
0013  *  Source: CMS level-1 trigger interface specification: Global trigger
0014  **/
0015 namespace l1t {
0016 
0017   template <typename A, typename... Args>
0018   A l1t_pack_int(const Args&... args) {
0019     A result = 0;
0020     std::size_t shift = 0;
0021     (
0022         [&result, &shift](const auto& arg) {
0023           result(shift + arg.width - 1, shift) = arg;
0024           shift += arg.width;
0025         }(args),
0026         ...);
0027 
0028     return result;
0029   }
0030 
0031   struct L1TGT_BaseInterface {
0032     virtual std::size_t packed_width() const = 0;
0033     virtual P2GTCandidate to_GTObject() const = 0;
0034     virtual ~L1TGT_BaseInterface() {}
0035   };
0036 
0037   template <std::size_t N>
0038   struct L1TGT_Interface : public L1TGT_BaseInterface {
0039     virtual ap_uint<N> pack() const = 0;
0040 
0041     static constexpr std::size_t WIDTH = N;
0042 
0043     std::size_t packed_width() const override { return WIDTH; }
0044   };
0045 
0046   template <std::size_t N>
0047   struct L1TGT_Common3Vector : public L1TGT_Interface<N> {
0048     ap_uint<1> valid;
0049     ap_uint<16> pT;
0050     ap_int<13> phi;
0051     ap_int<14> eta;
0052 
0053     L1TGT_Common3Vector(int valid = 0, int pT = 0, int phi = 0, int eta = 0)
0054         : valid(valid), pT(pT), phi(phi), eta(eta) {};
0055 
0056     virtual ap_uint<44> pack_common() const { return l1t_pack_int<ap_uint<44>>(valid, pT, phi, eta); }
0057 
0058     ap_uint<N> pack() const override { return pack_common(); }
0059 
0060     P2GTCandidate to_GTObject() const override {
0061       P2GTCandidate gt_object;
0062       gt_object.setHwPT(pT);
0063       gt_object.setHwPhi(phi);
0064       gt_object.setHwEta(eta);
0065 
0066       return gt_object;
0067     }
0068   };
0069 
0070   struct L1TGT_CommonSum : public L1TGT_Interface<64> {
0071     ap_uint<1> valid;
0072     ap_uint<16> pT;
0073     ap_int<13> phi;
0074     ap_uint<16> scalarSumPT;
0075 
0076     L1TGT_CommonSum(int valid = 0, int pT = 0, int phi = 0, int scalarSumPT = 0)
0077         : valid(valid), pT(pT), phi{phi}, scalarSumPT(scalarSumPT) {}
0078 
0079     ap_uint<46> pack_common() const { return l1t_pack_int<ap_uint<46>>(valid, pT, phi, scalarSumPT); }
0080 
0081     ap_uint<64> pack() const override { return pack_common(); }
0082 
0083     P2GTCandidate to_GTObject() const override {
0084       P2GTCandidate gt_object;
0085       gt_object.setHwPT(pT);
0086       gt_object.setHwPhi(phi);
0087       gt_object.setHwScalarSumPT(scalarSumPT);
0088 
0089       return gt_object;
0090     }
0091   };
0092 
0093   // Global Calorimeter Trigger
0094 
0095   struct L1TGT_GCT_EgammaNonIsolated6p6 : public L1TGT_Common3Vector<64> {
0096     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0097   };
0098 
0099   struct L1TGT_GCT_EgammaIsolated6p6 : public L1TGT_Common3Vector<64> {
0100     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0101   };
0102 
0103   struct L1TGT_GCT_jet6p6 : public L1TGT_Common3Vector<64> {
0104     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0105   };
0106 
0107   struct L1TGT_GCT_tau6p6 : public L1TGT_Common3Vector<64> {
0108     ap_uint<10> seed_pT;
0109 
0110     L1TGT_GCT_tau6p6(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int seed_pT = 0)
0111         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT) {}
0112 
0113     ap_uint<WIDTH> pack() const override {
0114       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT);
0115     }
0116 
0117     P2GTCandidate to_GTObject() const override {
0118       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0119       gt_object.setHwSeed_pT(seed_pT);
0120 
0121       return gt_object;
0122     }
0123   };
0124 
0125   struct L1TGT_GCT_Sum2 : public L1TGT_CommonSum {
0126     using L1TGT_CommonSum::L1TGT_CommonSum;
0127   };
0128 
0129   // Global Muon Trigger
0130 
0131   struct L1TGT_GMT_PromptDisplacedMuon : public L1TGT_Common3Vector<64> {
0132     ap_int<5> z0;
0133     ap_int<7> d0;
0134     ap_uint<1> charge;
0135     ap_uint<4> qualityScore;
0136 
0137     L1TGT_GMT_PromptDisplacedMuon(int valid = 0,
0138                                   int pT = 0,
0139                                   int phi = 0,
0140                                   int eta = 0,
0141                                   int z0 = 0,
0142                                   int d0 = 0,
0143                                   int charge = 0,
0144                                   int qualityScore = 0)
0145         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), d0(d0), charge(charge), qualityScore(qualityScore) {}
0146 
0147     ap_uint<WIDTH> pack() const override {
0148       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0, d0, charge, qualityScore);
0149     }
0150 
0151     P2GTCandidate to_GTObject() const override {
0152       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0153       gt_object.setHwZ0(static_cast<int>(z0) << 12);
0154       gt_object.setHwD0(static_cast<int>(d0) << 5);
0155       gt_object.setHwCharge(charge);
0156       gt_object.setHwQualityScore(qualityScore);
0157 
0158       return gt_object;
0159     }
0160   };
0161 
0162   struct L1TGT_GMT_TrackMatchedmuon : public L1TGT_Common3Vector<96> {
0163     ap_int<10> z0;
0164     ap_int<10> d0;
0165     ap_uint<1> charge;
0166     ap_uint<6> qualityFlags;
0167     ap_uint<6> isolationPT;
0168     ap_uint<4> beta;
0169 
0170     L1TGT_GMT_TrackMatchedmuon(int valid = 0,
0171                                int pT = 0,
0172                                int phi = 0,
0173                                int eta = 0,
0174                                int z0 = 0,
0175                                int d0 = 0,
0176                                int charge = 0,
0177                                int qualityFlags = 0,
0178                                int isolationPT = 0,
0179                                int beta = 0)
0180         : L1TGT_Common3Vector(valid, pT, phi, eta),
0181           z0(z0),
0182           d0(d0),
0183           charge(charge),
0184           qualityFlags(qualityFlags),
0185           isolationPT(isolationPT),
0186           beta(beta) {}
0187 
0188     ap_uint<WIDTH> pack() const override {
0189       return l1t_pack_int<ap_uint<WIDTH>>(
0190           L1TGT_Common3Vector::pack_common(), z0, d0, charge, qualityFlags, isolationPT, beta);
0191     }
0192 
0193     P2GTCandidate to_GTObject() const override {
0194       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0195       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0196       gt_object.setHwD0(static_cast<int>(d0) << 2);
0197       gt_object.setHwCharge(charge);
0198       gt_object.setHwQualityFlags(static_cast<int>(qualityFlags));
0199       gt_object.setHwIsolationPT(static_cast<int>(isolationPT));
0200       gt_object.setHwBeta(beta);
0201 
0202       return gt_object;
0203     }
0204   };
0205 
0206   struct L1TGT_GMT_TopoObject : public L1TGT_Interface<64> {
0207     ap_uint<1> valid;
0208     ap_uint<8> pT;  // TODO
0209     ap_int<8> eta;
0210     ap_int<8> phi;
0211     ap_uint<8> mass;
0212     ap_uint<6> qualityFlags;
0213     // ap_uint<16> /* Index of 3 prongs */;
0214     // ap_uint<3> /* Some other quality */;
0215 
0216     L1TGT_GMT_TopoObject(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int mass = 0, int qualityFlags = 0)
0217         : valid(valid), pT(pT), eta(eta), phi(phi), mass(mass), qualityFlags(qualityFlags) {}
0218 
0219     ap_uint<WIDTH> pack() const override {
0220       return l1t_pack_int<ap_uint<WIDTH>>(valid, pT, eta, phi, mass, qualityFlags);
0221     }
0222 
0223     P2GTCandidate to_GTObject() const override {
0224       P2GTCandidate gt_object;
0225       gt_object.setHwPT(static_cast<int>(pT) * 5);  // TODO
0226       gt_object.setHwPhi(static_cast<int>(phi) << 5);
0227       gt_object.setHwEta(static_cast<int>(eta) << 5);
0228       gt_object.setHwMass(mass);
0229       gt_object.setHwQualityFlags(qualityFlags);
0230 
0231       return gt_object;
0232     }
0233   };
0234 
0235   // Global Track Trigger
0236 
0237   struct L1TGT_GTT_PromptJet : public L1TGT_Common3Vector<128> {
0238     ap_int<10> z0;
0239     ap_uint<5> number_of_tracks;
0240     ap_uint<4> number_of_displaced_tracks;
0241 
0242     L1TGT_GTT_PromptJet(int valid = 0,
0243                         int pT = 0,
0244                         int phi = 0,
0245                         int eta = 0,
0246                         int z0 = 0,
0247                         int number_of_tracks = 0,
0248                         int number_of_displaced_tracks = 0)
0249         : L1TGT_Common3Vector(valid, pT, phi, eta),
0250           z0(z0),
0251           number_of_tracks(number_of_tracks),
0252           number_of_displaced_tracks(number_of_displaced_tracks) {}
0253 
0254     ap_uint<WIDTH> pack() const override {
0255       return l1t_pack_int<ap_uint<WIDTH>>(
0256           L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, number_of_displaced_tracks);
0257     }
0258 
0259     P2GTCandidate to_GTObject() const override {
0260       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0261       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0262       gt_object.setHwNumber_of_tracks(number_of_tracks);
0263       gt_object.setHwNumber_of_displaced_tracks(number_of_displaced_tracks);
0264 
0265       return gt_object;
0266     }
0267   };
0268 
0269   struct L1TGT_GTT_DisplacedJet : public L1TGT_Common3Vector<128> {
0270     ap_int<10> z0;
0271     ap_uint<5> number_of_tracks;
0272     ap_uint<4> number_of_displaced_tracks;
0273 
0274     L1TGT_GTT_DisplacedJet(int valid = 0,
0275                            int pT = 0,
0276                            int phi = 0,
0277                            int eta = 0,
0278                            int z0 = 0,
0279                            int number_of_tracks = 0,
0280                            int number_of_displaced_tracks = 0)
0281         : L1TGT_Common3Vector(valid, pT, phi, eta),
0282           z0(z0),
0283           number_of_tracks(number_of_tracks),
0284           number_of_displaced_tracks(number_of_displaced_tracks) {}
0285 
0286     ap_uint<WIDTH> pack() const override {
0287       return l1t_pack_int<ap_uint<WIDTH>>(
0288           L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, number_of_displaced_tracks);
0289     }
0290 
0291     P2GTCandidate to_GTObject() const override {
0292       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0293       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0294       gt_object.setHwNumber_of_tracks(number_of_tracks);
0295       gt_object.setHwNumber_of_displaced_tracks(number_of_displaced_tracks);
0296 
0297       return gt_object;
0298     }
0299   };
0300 
0301   struct L1TGT_GTT_Sum : public L1TGT_CommonSum {
0302     using L1TGT_CommonSum::L1TGT_CommonSum;
0303   };
0304 
0305   struct L1TGT_GTT_HadronicTau : public L1TGT_Common3Vector<96> {
0306     ap_uint<10> seed_pT;
0307     ap_int<10> seed_z0;
0308     ap_uint<1> charge;
0309     ap_uint<2> type;
0310 
0311     L1TGT_GTT_HadronicTau(int valid = 0,
0312                           int pT = 0,
0313                           int phi = 0,
0314                           int eta = 0,
0315                           int seed_pT = 0,
0316                           int seed_z0 = 0,
0317                           int charge = 0,
0318                           int type = 0)
0319         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT), seed_z0(seed_z0), charge(charge), type(type) {}
0320 
0321     ap_uint<WIDTH> pack() const override {
0322       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT, seed_z0, charge, type);
0323     }
0324 
0325     P2GTCandidate to_GTObject() const override {
0326       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0327       gt_object.setHwSeed_pT(seed_pT);
0328       gt_object.setHwSeed_z0(seed_z0);
0329       gt_object.setHwCharge(charge);
0330       gt_object.setHwType(type);
0331 
0332       return gt_object;
0333     }
0334   };
0335 
0336   struct L1TGT_GTT_LightMeson : public L1TGT_Common3Vector<96> {
0337     ap_int<10> z0;
0338     //ap_uint<10> /* candidate mass */;
0339     //ap_uint<2> /* candidate type */;
0340     //ap_uint<3> /* nbr of tracks */;
0341 
0342     L1TGT_GTT_LightMeson(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0)
0343         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0) {}
0344 
0345     ap_uint<WIDTH> pack() const override {
0346       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0);
0347     }
0348 
0349     P2GTCandidate to_GTObject() const override {
0350       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0351       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0352 
0353       return gt_object;
0354     }
0355   };
0356 
0357   struct L1TGT_GTT_Track : public L1TGT_Interface<96> {
0358     //TODO
0359 
0360     L1TGT_GTT_Track() {};
0361 
0362     ap_uint<WIDTH> pack() const override { return ap_uint<WIDTH>(0); }
0363 
0364     P2GTCandidate to_GTObject() const override { return P2GTCandidate(); }
0365   };
0366 
0367   struct L1TGT_GTT_PrimaryVert : public L1TGT_Interface<64> {
0368     ap_uint<1> valid;
0369     ap_int<15> z0;
0370     ap_uint<8> number_of_tracks_in_pv;
0371     ap_uint<12> sum_pT_pv;
0372     ap_uint<3> qualityScore;
0373     ap_uint<10> number_of_tracks_not_in_pv;
0374     // ap_uint<15> /* unassigned */;
0375 
0376     L1TGT_GTT_PrimaryVert(int valid = 0,
0377                           int z0 = 0,
0378                           int number_of_tracks_in_pv = 0,
0379                           int sum_pT_pv = 0,
0380                           int qualityScore = 0,
0381                           int number_of_tracks_not_in_pv = 0)
0382         : valid(valid),
0383           z0(z0),
0384           number_of_tracks_in_pv(number_of_tracks_in_pv),
0385           sum_pT_pv(sum_pT_pv),
0386           qualityScore(qualityScore),
0387           number_of_tracks_not_in_pv(number_of_tracks_not_in_pv) {}
0388 
0389     ap_uint<WIDTH> pack() const override {
0390       return l1t_pack_int<ap_uint<WIDTH>>(
0391           valid, z0, number_of_tracks_in_pv, sum_pT_pv, qualityScore, number_of_tracks_not_in_pv);
0392     }
0393 
0394     P2GTCandidate to_GTObject() const override {
0395       P2GTCandidate gt_object;
0396       gt_object.setHwZ0(static_cast<int>(z0) * 5);
0397       gt_object.setHwNumber_of_tracks_in_pv(number_of_tracks_in_pv);
0398       gt_object.setHwSum_pT_pv(sum_pT_pv);
0399       gt_object.setHwQualityScore(qualityScore);
0400       gt_object.setHwNumber_of_tracks_not_in_pv(number_of_tracks_not_in_pv);
0401 
0402       return gt_object;
0403     }
0404   };
0405 
0406   // Correlator Layer-2
0407 
0408   struct L1TGT_CL2_Jet : public L1TGT_Common3Vector<128> {
0409     ap_int<10> z0;
0410 
0411     L1TGT_CL2_Jet(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0)
0412         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0) {}
0413 
0414     ap_uint<WIDTH> pack() const override {
0415       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0);
0416     }
0417 
0418     P2GTCandidate to_GTObject() const override {
0419       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0420       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0421 
0422       return gt_object;
0423     }
0424   };
0425 
0426   struct L1TGT_CL2_Sum : public L1TGT_CommonSum {
0427     using L1TGT_CommonSum::L1TGT_CommonSum;
0428   };
0429 
0430   struct L1TGT_CL2_Tau : public L1TGT_Common3Vector<96> {
0431     ap_uint<10> seed_pT;
0432     ap_int<10> seed_z0;
0433     ap_uint<1> charge;
0434     ap_uint<2> type;
0435     //ap_uint<10> /* MVA Id / Isol */;
0436     //ap_uint<2> /* Id vs Mu */;
0437     //ap_uint<2> /* Id vs Mu */;
0438 
0439     L1TGT_CL2_Tau(int valid = 0,
0440                   int pT = 0,
0441                   int phi = 0,
0442                   int eta = 0,
0443                   int seed_pT = 0,
0444                   int seed_z0 = 0,
0445                   int charge = 0,
0446                   int type = 0)
0447         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT), seed_z0(seed_z0), charge(charge), type(type) {}
0448 
0449     ap_uint<WIDTH> pack() const override {
0450       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT, seed_z0, charge, type);
0451     }
0452 
0453     P2GTCandidate to_GTObject() const override {
0454       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0455       gt_object.setHwSeed_pT(seed_pT);
0456       gt_object.setHwSeed_z0(seed_z0);
0457       gt_object.setHwCharge(charge);
0458       gt_object.setHwType(type);
0459 
0460       return gt_object;
0461     }
0462   };
0463 
0464   struct L1TGT_CL2_Electron : public L1TGT_Common3Vector<96> {
0465     ap_uint<4> qualityFlags;
0466     ap_uint<11> isolationPT;
0467     ap_uint<1> charge;
0468     ap_int<10> z0;
0469 
0470     L1TGT_CL2_Electron(int valid = 0,
0471                        int pT = 0,
0472                        int phi = 0,
0473                        int eta = 0,
0474                        int qualityFlags = 0,
0475                        int isolationPT = 0,
0476                        int charge = 0,
0477                        int z0 = 0)
0478         : L1TGT_Common3Vector(valid, pT, phi, eta),
0479           qualityFlags(qualityFlags),
0480           isolationPT(isolationPT),
0481           charge(charge),
0482           z0(z0) {}
0483 
0484     ap_uint<WIDTH> pack() const override {
0485       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), qualityFlags, isolationPT, charge, z0);
0486     }
0487 
0488     P2GTCandidate to_GTObject() const override {
0489       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0490       gt_object.setHwQualityFlags(qualityFlags);
0491       gt_object.setHwIsolationPT(isolationPT);
0492       gt_object.setHwCharge(charge);
0493       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0494 
0495       return gt_object;
0496     }
0497   };
0498 
0499   struct L1TGT_CL2_Photon : public L1TGT_Common3Vector<96> {
0500     ap_uint<4> qualityFlags;
0501     ap_uint<11> isolationPT;
0502 
0503     L1TGT_CL2_Photon(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int qualityFlags = 0, int isolationPT = 0)
0504         : L1TGT_Common3Vector(valid, pT, phi, eta), qualityFlags(qualityFlags), isolationPT(isolationPT) {}
0505 
0506     ap_uint<WIDTH> pack() const override {
0507       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), qualityFlags, isolationPT);
0508     }
0509 
0510     P2GTCandidate to_GTObject() const override {
0511       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0512       gt_object.setHwQualityFlags(qualityFlags);
0513       gt_object.setHwIsolationPT(isolationPT);
0514 
0515       return gt_object;
0516     }
0517   };
0518 }  // namespace l1t
0519 
0520 #endif  // L1Trigger_Phase2L1GT_L1GTEvaluationInterface_h
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!