Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-07-03 04:18:03 

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     static L1TGT_Common3Vector from_GTObject(const P2GTCandidate& gtObject) {
0061       return L1TGT_Common3Vector(1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta());
0062     }
0063 
0064     P2GTCandidate to_GTObject() const override {
0065       P2GTCandidate gt_object;
0066       gt_object.setHwPT(pT);
0067       gt_object.setHwPhi(phi);
0068       gt_object.setHwEta(eta);
0069 
0070       return gt_object;
0071     }
0072   };
0073 
0074   struct L1TGT_CommonSum : public L1TGT_Interface<64> {
0075     ap_uint<1> valid;
0076     ap_uint<16> pT;
0077     ap_int<13> phi;
0078     ap_uint<16> scalarSumPT;
0079 
0080     L1TGT_CommonSum(int valid = 0, int pT = 0, int phi = 0, int scalarSumPT = 0)
0081         : valid(valid), pT(pT), phi{phi}, scalarSumPT(scalarSumPT) {}
0082 
0083     ap_uint<46> pack_common() const { return l1t_pack_int<ap_uint<46>>(valid, pT, phi, scalarSumPT); }
0084 
0085     ap_uint<64> pack() const override { return pack_common(); }
0086 
0087     static L1TGT_CommonSum from_GTObject(const P2GTCandidate& gtObject) {
0088       return L1TGT_CommonSum(1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwScalarSumPT());
0089     }
0090 
0091     P2GTCandidate to_GTObject() const override {
0092       P2GTCandidate gt_object;
0093       gt_object.setHwPT(pT);
0094       gt_object.setHwPhi(phi);
0095       gt_object.setHwScalarSumPT(scalarSumPT);
0096 
0097       return gt_object;
0098     }
0099   };
0100 
0101   // Global Calorimeter Trigger
0102 
0103   struct L1TGT_GCT_EgammaNonIsolated6p6 : public L1TGT_Common3Vector<64> {
0104     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0105   };
0106 
0107   struct L1TGT_GCT_EgammaIsolated6p6 : public L1TGT_Common3Vector<64> {
0108     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0109   };
0110 
0111   struct L1TGT_GCT_jet6p6 : public L1TGT_Common3Vector<64> {
0112     using L1TGT_Common3Vector::L1TGT_Common3Vector;
0113   };
0114 
0115   struct L1TGT_GCT_tau6p6 : public L1TGT_Common3Vector<64> {
0116     ap_uint<10> seed_pT;
0117 
0118     L1TGT_GCT_tau6p6(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int seed_pT = 0)
0119         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT) {}
0120 
0121     ap_uint<WIDTH> pack() const override {
0122       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT);
0123     }
0124 
0125     static L1TGT_GCT_tau6p6 from_GTObject(const P2GTCandidate& gtObject) {
0126       return L1TGT_GCT_tau6p6(1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwSeed_pT());
0127     }
0128 
0129     P2GTCandidate to_GTObject() const override {
0130       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0131       gt_object.setHwSeed_pT(seed_pT);
0132 
0133       return gt_object;
0134     }
0135   };
0136 
0137   struct L1TGT_GCT_Sum2 : public L1TGT_CommonSum {
0138     using L1TGT_CommonSum::L1TGT_CommonSum;
0139   };
0140 
0141   // Global Muon Trigger
0142 
0143   struct L1TGT_GMT_PromptDisplacedMuon : public L1TGT_Common3Vector<64> {
0144     ap_uint<5> z0;
0145     ap_int<7> d0;
0146     ap_uint<1> charge;
0147     ap_uint<4> qualityScore;
0148 
0149     L1TGT_GMT_PromptDisplacedMuon(int valid = 0,
0150                                   int pT = 0,
0151                                   int phi = 0,
0152                                   int eta = 0,
0153                                   int z0 = 0,
0154                                   int d0 = 0,
0155                                   int charge = 0,
0156                                   int qualityScore = 0)
0157         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), d0(d0), charge(charge), qualityScore(qualityScore) {}
0158 
0159     ap_uint<WIDTH> pack() const override {
0160       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0, d0, charge, qualityScore);
0161     }
0162 
0163     static L1TGT_GMT_PromptDisplacedMuon from_GTObject(const P2GTCandidate& gtObject) {
0164       return L1TGT_GMT_PromptDisplacedMuon(1,
0165                                            gtObject.hwPT(),
0166                                            gtObject.hwPhi(),
0167                                            gtObject.hwEta(),
0168                                            gtObject.hwZ0() >> 12,
0169                                            gtObject.hwD0() >> 5,
0170                                            gtObject.hwCharge(),
0171                                            gtObject.hwQualityScore());
0172     }
0173 
0174     P2GTCandidate to_GTObject() const override {
0175       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0176       gt_object.setHwZ0(static_cast<int>(z0) << 12);
0177       gt_object.setHwD0(static_cast<int>(d0) << 5);
0178       gt_object.setHwCharge(charge);
0179       gt_object.setHwQualityScore(qualityScore);
0180 
0181       return gt_object;
0182     }
0183   };
0184 
0185   struct L1TGT_GMT_TrackMatchedmuon : public L1TGT_Common3Vector<96> {
0186     ap_int<10> z0;
0187     ap_int<10> d0;
0188     ap_uint<1> charge;
0189     ap_uint<6> qualityFlags;
0190     ap_uint<6> isolationPT;
0191     ap_uint<4> beta;
0192 
0193     L1TGT_GMT_TrackMatchedmuon(int valid = 0,
0194                                int pT = 0,
0195                                int phi = 0,
0196                                int eta = 0,
0197                                int z0 = 0,
0198                                int d0 = 0,
0199                                int charge = 0,
0200                                int qualityFlags = 0,
0201                                int isolationPT = 0,
0202                                int beta = 0)
0203         : L1TGT_Common3Vector(valid, pT, phi, eta),
0204           z0(z0),
0205           d0(d0),
0206           charge(charge),
0207           qualityFlags(qualityFlags),
0208           isolationPT(isolationPT),
0209           beta(beta) {}
0210 
0211     ap_uint<WIDTH> pack() const override {
0212       return l1t_pack_int<ap_uint<WIDTH>>(
0213           L1TGT_Common3Vector::pack_common(), z0, d0, charge, qualityFlags, isolationPT, beta);
0214     }
0215 
0216     static L1TGT_GMT_TrackMatchedmuon from_GTObject(const P2GTCandidate& gtObject) {
0217       return L1TGT_GMT_TrackMatchedmuon(1,
0218                                         gtObject.hwPT(),
0219                                         gtObject.hwPhi(),
0220                                         gtObject.hwEta(),
0221                                         gtObject.hwZ0() >> 7,
0222                                         gtObject.hwD0() >> 2,
0223                                         gtObject.hwCharge(),
0224                                         gtObject.hwQualityFlags(),
0225                                         gtObject.hwIsolationPT(),
0226                                         gtObject.hwBeta());
0227     }
0228 
0229     P2GTCandidate to_GTObject() const override {
0230       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0231       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0232       gt_object.setHwD0(static_cast<int>(d0) << 2);
0233       gt_object.setHwCharge(charge);
0234       gt_object.setHwQualityFlags(static_cast<int>(qualityFlags));
0235       gt_object.setHwIsolationPT(static_cast<int>(isolationPT));
0236       gt_object.setHwBeta(beta);
0237 
0238       return gt_object;
0239     }
0240   };
0241 
0242   struct L1TGT_GMT_TopoObject : public L1TGT_Interface<64> {
0243     ap_uint<1> valid;
0244     ap_uint<8> pT;  // TODO
0245     ap_int<8> eta;
0246     ap_int<8> phi;
0247     ap_uint<8> mass;
0248     ap_uint<6> qualityFlags;
0249     // ap_uint<16> /* Index of 3 prongs */;
0250     // ap_uint<3> /* Some other quality */;
0251 
0252     L1TGT_GMT_TopoObject(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int mass = 0, int qualityFlags = 0)
0253         : valid(valid), pT(pT), eta(eta), phi(phi), mass(mass), qualityFlags(qualityFlags) {}
0254 
0255     ap_uint<WIDTH> pack() const override {
0256       return l1t_pack_int<ap_uint<WIDTH>>(valid, pT, eta, phi, mass, qualityFlags);
0257     }
0258 
0259     static L1TGT_GMT_TopoObject from_GTObject(const P2GTCandidate& gtObject) {
0260       return L1TGT_GMT_TopoObject(1,
0261                                   gtObject.hwPT() / 5,
0262                                   gtObject.hwPhi() >> 5,
0263                                   gtObject.hwEta() >> 5,
0264                                   gtObject.hwMass(),
0265                                   gtObject.hwQualityFlags());
0266     }
0267 
0268     P2GTCandidate to_GTObject() const override {
0269       P2GTCandidate gt_object;
0270       gt_object.setHwPT(static_cast<int>(pT) * 5);  // TODO
0271       gt_object.setHwPhi(static_cast<int>(phi) << 5);
0272       gt_object.setHwEta(static_cast<int>(eta) << 5);
0273       gt_object.setHwMass(mass);
0274       gt_object.setHwQualityFlags(qualityFlags);
0275 
0276       return gt_object;
0277     }
0278   };
0279 
0280   // Global Track Trigger
0281 
0282   struct L1TGT_GTT_PromptJet : public L1TGT_Common3Vector<128> {
0283     ap_int<10> z0;
0284     ap_uint<5> number_of_tracks;
0285     // ap_uint<5> /* unassigned */;
0286 
0287     L1TGT_GTT_PromptJet(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0, int number_of_tracks = 0)
0288         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), number_of_tracks(number_of_tracks) {}
0289 
0290     ap_uint<WIDTH> pack() const override {
0291       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0, number_of_tracks);
0292     }
0293 
0294     static L1TGT_GTT_PromptJet from_GTObject(const P2GTCandidate& gtObject) {
0295       return L1TGT_GTT_PromptJet(
0296           1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwZ0() >> 7, gtObject.hwNumber_of_tracks());
0297     }
0298 
0299     P2GTCandidate to_GTObject() const override {
0300       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0301       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0302       gt_object.setHwNumber_of_tracks(number_of_tracks);
0303 
0304       return gt_object;
0305     }
0306   };
0307 
0308   struct L1TGT_GTT_DisplacedJet : public L1TGT_Common3Vector<128> {
0309     ap_int<10> z0;
0310     ap_uint<5> number_of_tracks;
0311     // ap_uint<5> /* unassigned */;
0312     ap_int<12> d0;
0313 
0314     L1TGT_GTT_DisplacedJet(
0315         int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0, int number_of_tracks = 0, int d0 = 0)
0316         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0), number_of_tracks(number_of_tracks), d0(d0) {}
0317 
0318     ap_uint<WIDTH> pack() const override {
0319       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0, number_of_tracks, ap_uint<5>(0), d0);
0320     }
0321 
0322     static L1TGT_GTT_DisplacedJet from_GTObject(const P2GTCandidate& gtObject) {
0323       return L1TGT_GTT_DisplacedJet(1,
0324                                     gtObject.hwPT(),
0325                                     gtObject.hwPhi(),
0326                                     gtObject.hwEta(),
0327                                     gtObject.hwZ0() >> 7,
0328                                     gtObject.hwNumber_of_tracks(),
0329                                     gtObject.hwD0());
0330     }
0331 
0332     P2GTCandidate to_GTObject() const override {
0333       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0334       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0335       gt_object.setHwNumber_of_tracks(number_of_tracks);
0336       gt_object.setHwD0(d0);
0337 
0338       return gt_object;
0339     }
0340   };
0341 
0342   struct L1TGT_GTT_Sum : public L1TGT_CommonSum {
0343     using L1TGT_CommonSum::L1TGT_CommonSum;
0344   };
0345 
0346   struct L1TGT_GTT_HadronicTau : public L1TGT_Common3Vector<96> {
0347     ap_uint<10> seed_pT;
0348     ap_int<10> seed_z0;
0349     ap_uint<1> charge;
0350     ap_uint<2> type;
0351 
0352     L1TGT_GTT_HadronicTau(int valid = 0,
0353                           int pT = 0,
0354                           int phi = 0,
0355                           int eta = 0,
0356                           int seed_pT = 0,
0357                           int seed_z0 = 0,
0358                           int charge = 0,
0359                           int type = 0)
0360         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT), seed_z0(seed_z0), charge(charge), type(type) {}
0361 
0362     ap_uint<WIDTH> pack() const override {
0363       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT, seed_z0, charge, type);
0364     }
0365 
0366     static L1TGT_GTT_HadronicTau from_GTObject(const P2GTCandidate& gtObject) {
0367       return L1TGT_GTT_HadronicTau(1,
0368                                    gtObject.hwPT(),
0369                                    gtObject.hwPhi(),
0370                                    gtObject.hwEta(),
0371                                    gtObject.hwSeed_pT(),
0372                                    gtObject.hwSeed_z0(),
0373                                    gtObject.hwCharge(),
0374                                    gtObject.hwType());
0375     }
0376 
0377     P2GTCandidate to_GTObject() const override {
0378       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0379       gt_object.setHwSeed_pT(seed_pT);
0380       gt_object.setHwSeed_z0(seed_z0);
0381       gt_object.setHwCharge(charge);
0382       gt_object.setHwType(type);
0383 
0384       return gt_object;
0385     }
0386   };
0387 
0388   struct L1TGT_GTT_LightMeson : public L1TGT_Common3Vector<96> {
0389     ap_int<10> z0;
0390     //ap_uint<10> /* candidate mass */;
0391     //ap_uint<2> /* candidate type */;
0392     //ap_uint<3> /* nbr of tracks */;
0393 
0394     L1TGT_GTT_LightMeson(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0)
0395         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0) {}
0396 
0397     ap_uint<WIDTH> pack() const override {
0398       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0);
0399     }
0400 
0401     static L1TGT_GTT_LightMeson from_GTObject(const P2GTCandidate& gtObject) {
0402       return L1TGT_GTT_LightMeson(1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwZ0() >> 7);
0403     }
0404 
0405     P2GTCandidate to_GTObject() const override {
0406       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0407       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0408 
0409       return gt_object;
0410     }
0411   };
0412 
0413   struct L1TGT_GTT_Track : public L1TGT_Interface<96> {
0414     //TODO
0415 
0416     L1TGT_GTT_Track(){};
0417 
0418     ap_uint<WIDTH> pack() const override { return ap_uint<WIDTH>(0); }
0419 
0420     static L1TGT_GTT_Track from_GTObject(const P2GTCandidate& gtObject) { return L1TGT_GTT_Track(); }
0421 
0422     P2GTCandidate to_GTObject() const override { return P2GTCandidate(); }
0423   };
0424 
0425   struct L1TGT_GTT_PrimaryVert : public L1TGT_Interface<64> {
0426     ap_uint<1> valid;
0427     ap_int<15> z0;
0428     ap_uint<8> number_of_tracks_in_pv;
0429     ap_uint<12> sum_pT_pv;
0430     ap_uint<3> qualityScore;
0431     ap_uint<10> number_of_tracks_not_in_pv;
0432     // ap_uint<15> /* unassigned */;
0433 
0434     L1TGT_GTT_PrimaryVert(int valid = 0,
0435                           int z0 = 0,
0436                           int number_of_tracks_in_pv = 0,
0437                           int sum_pT_pv = 0,
0438                           int qualityScore = 0,
0439                           int number_of_tracks_not_in_pv = 0)
0440         : valid(valid),
0441           z0(z0),
0442           number_of_tracks_in_pv(number_of_tracks_in_pv),
0443           sum_pT_pv(sum_pT_pv),
0444           qualityScore(qualityScore),
0445           number_of_tracks_not_in_pv(number_of_tracks_not_in_pv) {}
0446 
0447     ap_uint<WIDTH> pack() const override {
0448       return l1t_pack_int<ap_uint<WIDTH>>(
0449           valid, z0, number_of_tracks_in_pv, sum_pT_pv, qualityScore, number_of_tracks_not_in_pv);
0450     }
0451 
0452     static L1TGT_GTT_PrimaryVert from_GTObject(const P2GTCandidate& gtObject) {
0453       return L1TGT_GTT_PrimaryVert(1,
0454                                    gtObject.hwZ0() / 5,
0455                                    gtObject.hwNumber_of_tracks_in_pv(),
0456                                    gtObject.hwSum_pT_pv(),
0457                                    gtObject.hwQualityScore(),
0458                                    gtObject.hwNumber_of_tracks_not_in_pv());
0459     }
0460 
0461     P2GTCandidate to_GTObject() const override {
0462       P2GTCandidate gt_object;
0463       gt_object.setHwZ0(static_cast<int>(z0) * 5);
0464       gt_object.setHwNumber_of_tracks_in_pv(number_of_tracks_in_pv);
0465       gt_object.setHwSum_pT_pv(sum_pT_pv);
0466       gt_object.setHwQualityScore(qualityScore);
0467       gt_object.setHwNumber_of_tracks_not_in_pv(number_of_tracks_not_in_pv);
0468 
0469       return gt_object;
0470     }
0471   };
0472 
0473   // Correlator Layer-2
0474 
0475   struct L1TGT_CL2_Jet : public L1TGT_Common3Vector<128> {
0476     ap_int<10> z0;
0477 
0478     L1TGT_CL2_Jet(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int z0 = 0)
0479         : L1TGT_Common3Vector(valid, pT, phi, eta), z0(z0) {}
0480 
0481     ap_uint<WIDTH> pack() const override {
0482       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), z0);
0483     }
0484 
0485     static L1TGT_CL2_Jet from_GTObject(const P2GTCandidate& gtObject) {
0486       return L1TGT_CL2_Jet(1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwZ0() >> 7);
0487     }
0488 
0489     P2GTCandidate to_GTObject() const override {
0490       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0491       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0492 
0493       return gt_object;
0494     }
0495   };
0496 
0497   struct L1TGT_CL2_Sum : public L1TGT_CommonSum {
0498     using L1TGT_CommonSum::L1TGT_CommonSum;
0499   };
0500 
0501   struct L1TGT_CL2_Tau : public L1TGT_Common3Vector<96> {
0502     ap_uint<10> seed_pT;
0503     ap_int<10> seed_z0;
0504     ap_uint<1> charge;
0505     ap_uint<2> type;
0506     //ap_uint<10> /* MVA Id / Isol */;
0507     //ap_uint<2> /* Id vs Mu */;
0508     //ap_uint<2> /* Id vs Mu */;
0509 
0510     L1TGT_CL2_Tau(int valid = 0,
0511                   int pT = 0,
0512                   int phi = 0,
0513                   int eta = 0,
0514                   int seed_pT = 0,
0515                   int seed_z0 = 0,
0516                   int charge = 0,
0517                   int type = 0)
0518         : L1TGT_Common3Vector(valid, pT, phi, eta), seed_pT(seed_pT), seed_z0(seed_z0), charge(charge), type(type) {}
0519 
0520     ap_uint<WIDTH> pack() const override {
0521       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), seed_pT, seed_z0, charge, type);
0522     }
0523 
0524     static L1TGT_CL2_Tau from_GTObject(const P2GTCandidate& gtObject) {
0525       return L1TGT_CL2_Tau(1,
0526                            gtObject.hwPT(),
0527                            gtObject.hwPhi(),
0528                            gtObject.hwEta(),
0529                            gtObject.hwSeed_pT(),
0530                            gtObject.hwSeed_z0(),
0531                            gtObject.hwCharge(),
0532                            gtObject.hwType());
0533     }
0534 
0535     P2GTCandidate to_GTObject() const override {
0536       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0537       gt_object.setHwSeed_pT(seed_pT);
0538       gt_object.setHwSeed_z0(seed_z0);
0539       gt_object.setHwCharge(charge);
0540       gt_object.setHwType(type);
0541 
0542       return gt_object;
0543     }
0544   };
0545 
0546   struct L1TGT_CL2_Electron : public L1TGT_Common3Vector<96> {
0547     ap_uint<4> qualityFlags;
0548     ap_uint<11> isolationPT;
0549     ap_uint<1> charge;
0550     ap_int<10> z0;
0551 
0552     L1TGT_CL2_Electron(int valid = 0,
0553                        int pT = 0,
0554                        int phi = 0,
0555                        int eta = 0,
0556                        int qualityFlags = 0,
0557                        int isolationPT = 0,
0558                        int charge = 0,
0559                        int z0 = 0)
0560         : L1TGT_Common3Vector(valid, pT, phi, eta),
0561           qualityFlags(qualityFlags),
0562           isolationPT(isolationPT),
0563           charge(charge),
0564           z0(z0) {}
0565 
0566     ap_uint<WIDTH> pack() const override {
0567       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), qualityFlags, isolationPT, charge, z0);
0568     }
0569 
0570     static L1TGT_CL2_Electron from_GTObject(const P2GTCandidate& gtObject) {
0571       return L1TGT_CL2_Electron(1,
0572                                 gtObject.hwPT(),
0573                                 gtObject.hwPhi(),
0574                                 gtObject.hwEta(),
0575                                 gtObject.hwQualityFlags(),
0576                                 gtObject.hwIsolationPT(),
0577                                 gtObject.hwCharge(),
0578                                 gtObject.hwZ0() >> 7);
0579     }
0580 
0581     P2GTCandidate to_GTObject() const override {
0582       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0583       gt_object.setHwQualityFlags(qualityFlags);
0584       gt_object.setHwIsolationPT(isolationPT);
0585       gt_object.setHwCharge(charge);
0586       gt_object.setHwZ0(static_cast<int>(z0) << 7);
0587 
0588       return gt_object;
0589     }
0590   };
0591 
0592   struct L1TGT_CL2_Photon : public L1TGT_Common3Vector<96> {
0593     ap_uint<4> qualityFlags;
0594     ap_uint<11> isolationPT;
0595 
0596     L1TGT_CL2_Photon(int valid = 0, int pT = 0, int phi = 0, int eta = 0, int qualityFlags = 0, int isolationPT = 0)
0597         : L1TGT_Common3Vector(valid, pT, phi, eta), qualityFlags(qualityFlags), isolationPT(isolationPT) {}
0598 
0599     ap_uint<WIDTH> pack() const override {
0600       return l1t_pack_int<ap_uint<WIDTH>>(L1TGT_Common3Vector::pack_common(), qualityFlags, isolationPT);
0601     }
0602 
0603     static L1TGT_CL2_Photon from_GTObject(const P2GTCandidate& gtObject) {
0604       return L1TGT_CL2_Photon(
0605           1, gtObject.hwPT(), gtObject.hwPhi(), gtObject.hwEta(), gtObject.hwQualityFlags(), gtObject.hwIsolationPT());
0606     }
0607 
0608     P2GTCandidate to_GTObject() const override {
0609       P2GTCandidate gt_object(L1TGT_Common3Vector::to_GTObject());
0610       gt_object.setHwQualityFlags(qualityFlags);
0611       gt_object.setHwIsolationPT(isolationPT);
0612 
0613       return gt_object;
0614     }
0615   };
0616 }  // namespace l1t
0617 
0618 #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!