L1TMuon/src/RegionalMuonRawDigiTranslator.cc

0001 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0002 #include "L1Trigger/L1TMuon/interface/RegionalMuonRawDigiTranslator.h"
0003
0004 void l1t::RegionalMuonRawDigiTranslator::fillRegionalMuonCand(RegionalMuonCand& mu,
0005                                                               const uint32_t raw_data_00_31,
0006                                                               const uint32_t raw_data_32_63,
0007                                                               const int proc,
0008                                                               const tftype tf,
0009                                                               const bool isKbmtf,
0010                                                               const bool useOmtfDisplacementInfo,
0011                                                               const bool useEmtfDisplacementInfo) {
0012   // translations as defined in DN-15-017
0013   mu.setHwPt((raw_data_00_31 >> ptShift_) & ptMask_);
0014   mu.setHwQual((raw_data_00_31 >> qualShift_) & qualMask_);
0015
0016   // eta is coded as two's complement
0017   int abs_eta = (raw_data_00_31 >> absEtaShift_) & absEtaMask_;
0018   if ((raw_data_00_31 >> etaSignShift_) & 0x1) {
0019     mu.setHwEta(abs_eta - (1 << (etaSignShift_ - absEtaShift_)));
0020   } else {
0021     mu.setHwEta(abs_eta);
0022   }
0023
0024   // phi is coded as two's complement
0025   int abs_phi = (raw_data_00_31 >> absPhiShift_) & absPhiMask_;
0026   if ((raw_data_00_31 >> phiSignShift_) & 0x1) {
0027     mu.setHwPhi(abs_phi - (1 << (phiSignShift_ - absPhiShift_)));
0028   } else {
0029     mu.setHwPhi(abs_phi);
0030   }
0031
0032   // sign is coded as -1^signBit
0033   mu.setHwSign((raw_data_32_63 >> signShift_) & 0x1);
0034   mu.setHwSignValid((raw_data_32_63 >> signValidShift_) & 0x1);
0035   mu.setHwHF((raw_data_00_31 >> hfShift_) & hfMask_);
0036
0037   // set track address with subaddresses
0038   int rawTrackAddress = (raw_data_32_63 >> trackAddressShift_) & trackAddressMask_;
0039   if (tf == bmtf) {
0040     int detSide = (rawTrackAddress >> bmtfTrAddrDetSideShift_) & 0x1;
0041     int wheelNum = (rawTrackAddress >> bmtfTrAddrWheelShift_) & bmtfTrAddrWheelMask_;
0042     int statAddr1 = ((rawTrackAddress >> bmtfTrAddrStat1Shift_) & bmtfTrAddrStat1Mask_);
0043     int statAddr2 = ((rawTrackAddress >> bmtfTrAddrStat2Shift_) & bmtfTrAddrStat2Mask_);
0044     int statAddr3 = ((rawTrackAddress >> bmtfTrAddrStat3Shift_) & bmtfTrAddrStat3Mask_);
0045     int statAddr4 = ((rawTrackAddress >> bmtfTrAddrStat4Shift_) & bmtfTrAddrStat4Mask_);
0046
0047     mu.setTrackSubAddress(RegionalMuonCand::kWheelSide, detSide);
0048     mu.setTrackSubAddress(RegionalMuonCand::kWheelNum, wheelNum);
0049     if (!isKbmtf) {  // The Run-2 standard configuration for BMTF
0050       mu.setTrackSubAddress(RegionalMuonCand::kStat1, statAddr1);
0051       mu.setTrackSubAddress(RegionalMuonCand::kStat2, statAddr2);
0052       mu.setTrackSubAddress(RegionalMuonCand::kStat3, statAddr3);
0053       mu.setTrackSubAddress(RegionalMuonCand::kStat4, statAddr4);
0054     } else {
0055       // For Run-3 track address encoding has changed as the Kalman Filter tracks from outside in.
0056       // As a result station assignment is inverted
0057       // (i.e. the field that contained the station 1 information for Run-2 now contains station 4 information and so on.)
0058       mu.setTrackSubAddress(RegionalMuonCand::kStat1, statAddr4);
0059       mu.setTrackSubAddress(RegionalMuonCand::kStat2, statAddr3);
0060       mu.setTrackSubAddress(RegionalMuonCand::kStat3, statAddr2);
0061       mu.setTrackSubAddress(RegionalMuonCand::kStat4, statAddr1);
0062       // Additionally we now have displacement information from the BMTF
0063       mu.setHwPtUnconstrained((raw_data_32_63 >> bmtfPtUnconstrainedShift_) & ptUnconstrainedMask_);
0064       mu.setHwDXY((raw_data_32_63 >> bmtfDxyShift_) & dxyMask_);
0065     }
0066     mu.setTrackSubAddress(RegionalMuonCand::kSegSelStat1, 0);
0067     mu.setTrackSubAddress(RegionalMuonCand::kSegSelStat2, 0);
0068     mu.setTrackSubAddress(RegionalMuonCand::kSegSelStat3, 0);
0069     mu.setTrackSubAddress(RegionalMuonCand::kSegSelStat4, 0);
0070     //mu.setTrackSubAddress(RegionalMuonCand::kNumBmtfSubAddr, 0);
0071   } else if (tf == emtf_neg || tf == emtf_pos) {
0072     mu.setTrackSubAddress(RegionalMuonCand::kME1Seg, (rawTrackAddress >> emtfTrAddrMe1SegShift_) & 0x1);
0073     mu.setTrackSubAddress(RegionalMuonCand::kME1Ch, (rawTrackAddress >> emtfTrAddrMe1ChShift_) & emtfTrAddrMe1ChMask_);
0074     mu.setTrackSubAddress(RegionalMuonCand::kME2Seg, (rawTrackAddress >> emtfTrAddrMe2SegShift_) & 0x1);
0075     mu.setTrackSubAddress(RegionalMuonCand::kME2Ch, (rawTrackAddress >> emtfTrAddrMe2ChShift_) & emtfTrAddrMe2ChMask_);
0076     mu.setTrackSubAddress(RegionalMuonCand::kME3Seg, (rawTrackAddress >> emtfTrAddrMe3SegShift_) & 0x1);
0077     mu.setTrackSubAddress(RegionalMuonCand::kME3Ch, (rawTrackAddress >> emtfTrAddrMe3ChShift_) & emtfTrAddrMe3ChMask_);
0078     mu.setTrackSubAddress(RegionalMuonCand::kME4Seg, (rawTrackAddress >> emtfTrAddrMe4SegShift_) & 0x1);
0079     mu.setTrackSubAddress(RegionalMuonCand::kME4Ch, (rawTrackAddress >> emtfTrAddrMe4ChShift_) & emtfTrAddrMe4ChMask_);
0080     if (useEmtfDisplacementInfo) {  // In Run-3 we receive displaced muon information from EMTF
0081       mu.setHwPtUnconstrained((raw_data_32_63 >> emtfPtUnconstrainedShift_) & ptUnconstrainedMask_);
0082       mu.setHwDXY((raw_data_32_63 >> emtfDxyShift_) & dxyMask_);
0083       mu.setTrackSubAddress(RegionalMuonCand::kTrkNum, 0);
0084       mu.setTrackSubAddress(RegionalMuonCand::kBX, 0);
0085     } else {
0086       mu.setTrackSubAddress(RegionalMuonCand::kTrkNum,
0087                             (rawTrackAddress >> emtfTrAddrTrkNumShift_) & emtfTrAddrTrkNumMask_);
0088       mu.setTrackSubAddress(RegionalMuonCand::kBX, (rawTrackAddress >> emtfTrAddrBxShift_) & emtfTrAddrBxMask_);
0089     }
0090   } else if (tf == omtf_neg || tf == omtf_pos) {
0091     if (useOmtfDisplacementInfo) {  // In Run-3 2024 we receive displaced muon information from OMTF
0092       mu.setHwPtUnconstrained((raw_data_32_63 >> kOmtfPtUnconstrainedShift_) & ptUnconstrainedMask_);
0093     }
0094     mu.setTrackSubAddress(RegionalMuonCand::kLayers,
0095                           (rawTrackAddress >> omtfTrAddrLayersShift_) & omtfTrAddrLayersMask_);
0096     mu.setTrackSubAddress(RegionalMuonCand::kZero, 0);
0097     mu.setTrackSubAddress(RegionalMuonCand::kWeight,
0098                           (rawTrackAddress >> omtfTrAddrWeightShift_) & omtfTrAddrWeightMask_);
0099   } else {
0100     std::map<int, int> trackAddr;
0101     trackAddr[0] = rawTrackAddress;
0102     mu.setTrackAddress(trackAddr);
0103   }
0104
0105   mu.setTFIdentifiers(proc, tf);
0106   mu.setDataword(raw_data_32_63, raw_data_00_31);
0107 }
0108
0109 void l1t::RegionalMuonRawDigiTranslator::fillRegionalMuonCand(RegionalMuonCand& mu,
0110                                                               const uint64_t dataword,
0111                                                               const int proc,
0112                                                               const tftype tf,
0113                                                               const bool isKbmtf,
0114                                                               const bool useOmtfDisplacementInfo,
0115                                                               const bool useEmtfDisplacementInfo) {
0116   fillRegionalMuonCand(mu,
0117                        (uint32_t)(dataword & 0xFFFFFFFF),
0118                        (uint32_t)((dataword >> 32) & 0xFFFFFFFF),
0119                        proc,
0120                        tf,
0121                        isKbmtf,
0122                        useOmtfDisplacementInfo,
0123                        useEmtfDisplacementInfo);
0124 }
0125
0126 bool l1t::RegionalMuonRawDigiTranslator::fillRegionalMuonShower(RegionalMuonShower& muShower,
0127                                                                 const std::vector<uint32_t> bxPayload,
0128                                                                 const int proc,
0129                                                                 const tftype tf,
0130                                                                 const bool useEmtfNominalTightShowers,
0131                                                                 const bool useEmtfLooseShowers) {
0132   muShower.setTFIdentifiers(proc, tf);
0133   bool showerValid{false};
0134   if (useEmtfNominalTightShowers && (tf == emtf_pos || tf == emtf_neg)) {
0135     muShower.setOneNominalInTime(((bxPayload[kEmtfShowerStandardFrame] >> kEmtfShowerOneNominalShift) & 1) == 1);
0136     muShower.setOneTightInTime(((bxPayload[kEmtfShowerStandardFrame] >> kEmtfShowerOneTightShift) & 1) == 1);
0137
0138     showerValid = muShower.isValid();
0139   }
0140   if (useEmtfLooseShowers && (tf == emtf_pos || tf == emtf_neg)) {
0141     muShower.setOneLooseInTime(((bxPayload[kEmtfShowerExtendedFrame] >> kEmtfShowerOneLooseShift) & 1) == 1);
0142
0143     showerValid = muShower.isValid();
0144   }
0145   return showerValid;
0146 }
0147
0148 void l1t::RegionalMuonRawDigiTranslator::generatePackedShowerPayload(const RegionalMuonShower& shower,
0149                                                                      std::array<uint32_t, 6>& payload,
0150                                                                      const bool useEmtfNominalTightShowers,
0151                                                                      const bool useEmtfLooseShowers) {
0152   if (!useEmtfNominalTightShowers || !useEmtfLooseShowers || !shower.isValid()) {
0153     return;
0154   }
0155   // First we check whether we're going to overwrite something in the payload.
0156   if ((((payload.at(kEmtfShowerStandardFrame) >> kEmtfShowerOneNominalShift) & kEmtfShowerMask) != 0) ||
0157       (((payload.at(kEmtfShowerStandardFrame) >> kEmtfShowerOneTightShift) & kEmtfShowerMask) != 0) ||
0158       (((payload.at(kEmtfShowerExtendedFrame) >> kEmtfShowerOneLooseShift) & kEmtfShowerMask) != 0)) {
0159     edm::LogError("L1T") << "Check constants for RegionalMuonShower fields! It looks like we're in danger of "
0160                             "overwriting muon data in the packer! StandardFrame is "
0161                          << payload.at(kEmtfShowerStandardFrame) << ", ExtendedFrame is "
0162                          << payload.at(kEmtfShowerExtendedFrame);
0163     return;
0164   }
0165   payload.at(kEmtfShowerStandardFrame) |= (shower.isOneNominalInTime() & 1) << kEmtfShowerOneNominalShift |
0166                                           (shower.isOneTightInTime() & 1) << kEmtfShowerOneTightShift;
0167   payload.at(kEmtfShowerExtendedFrame) |= (shower.isOneNominalOutOfTime() & 1) << kEmtfShowerOneNominalShift |
0168                                           (shower.isOneTightOutOfTime() & 1) << kEmtfShowerOneTightShift;
0169 }
0170
0171 void l1t::RegionalMuonRawDigiTranslator::generatePackedDataWords(const RegionalMuonCand& mu,
0172                                                                  uint32_t& raw_data_00_31,
0173                                                                  uint32_t& raw_data_32_63,
0174                                                                  const bool isKbmtf,
0175                                                                  const bool useOmtfDisplacementInfo,
0176                                                                  const bool useEmtfDisplacementInfo) {
0177   int abs_eta = mu.hwEta();
0178   if (abs_eta < 0) {
0179     abs_eta += (1 << (etaSignShift_ - absEtaShift_));
0180   }
0181   int abs_phi = mu.hwPhi();
0182   if (abs_phi < 0) {
0183     abs_phi += (1 << (phiSignShift_ - absPhiShift_));
0184   }
0185   raw_data_00_31 = (mu.hwPt() & ptMask_) << ptShift_ | (mu.hwQual() & qualMask_) << qualShift_ |
0186                    (abs_eta & absEtaMask_) << absEtaShift_ | (mu.hwEta() < 0) << etaSignShift_ |
0187                    (mu.hwHF() & hfMask_) << hfShift_ | (abs_phi & absPhiMask_) << absPhiShift_ |
0188                    (mu.hwPhi() < 0) << phiSignShift_;
0189
0190   // generate the raw track address from the subaddresses
0191   int rawTrkAddr = generateRawTrkAddress(mu, isKbmtf);
0192
0193   raw_data_32_63 = mu.hwSign() << signShift_ | mu.hwSignValid() << signValidShift_ |
0194                    (rawTrkAddr & trackAddressMask_) << trackAddressShift_;
0195   if (isKbmtf && mu.trackFinderType() == bmtf) {
0196     raw_data_32_63 |= (mu.hwPtUnconstrained() & ptUnconstrainedMask_) << bmtfPtUnconstrainedShift_ |
0197                       (mu.hwDXY() & dxyMask_) << bmtfDxyShift_;
0198   } else if (useOmtfDisplacementInfo && (mu.trackFinderType() == omtf_pos || mu.trackFinderType() == omtf_neg)) {
0199     raw_data_32_63 |= (mu.hwPtUnconstrained() & ptUnconstrainedMask_) << kOmtfPtUnconstrainedShift_;
0200   } else if (useEmtfDisplacementInfo && (mu.trackFinderType() == emtf_pos || mu.trackFinderType() == emtf_neg)) {
0201     raw_data_32_63 |= (mu.hwPtUnconstrained() & ptUnconstrainedMask_) << emtfPtUnconstrainedShift_ |
0202                       (mu.hwDXY() & dxyMask_) << emtfDxyShift_;
0203   }
0204 }
0205
0206 uint64_t l1t::RegionalMuonRawDigiTranslator::generate64bitDataWord(const RegionalMuonCand& mu,
0207                                                                    const bool isKbmtf,
0208                                                                    const bool useOmtfDisplacementInfo,
0209                                                                    const bool useEmtfDisplacementInfo) {
0210   uint32_t lsw;
0211   uint32_t msw;
0212
0213   generatePackedDataWords(mu, lsw, msw, isKbmtf, useOmtfDisplacementInfo, useEmtfDisplacementInfo);
0214   return (((uint64_t)msw) << 32) + lsw;
0215 }
0216
0217 int l1t::RegionalMuonRawDigiTranslator::generateRawTrkAddress(const RegionalMuonCand& mu, const bool isKalman) {
0218   int tf = mu.trackFinderType();
0219   int rawTrkAddr = 0;
0220   if (tf == bmtf) {
0221     // protection against a track address map with the wrong size
0222     if (mu.trackAddress().size() == RegionalMuonCand::kNumBmtfSubAddr) {
0223       int detSide = mu.trackSubAddress(RegionalMuonCand::kWheelSide);
0224       int wheelNum = mu.trackSubAddress(RegionalMuonCand::kWheelNum);
0225       int stat1 = mu.trackSubAddress(RegionalMuonCand::kStat1);
0226       int stat2 = mu.trackSubAddress(RegionalMuonCand::kStat2);
0227       int stat3 = mu.trackSubAddress(RegionalMuonCand::kStat3);
0228       int stat4 = mu.trackSubAddress(RegionalMuonCand::kStat4);
0229       if (isKalman) {
0230         stat1 = mu.trackSubAddress(RegionalMuonCand::kStat4);
0231         stat2 = mu.trackSubAddress(RegionalMuonCand::kStat3);
0232         stat3 = mu.trackSubAddress(RegionalMuonCand::kStat2);
0233         stat4 = mu.trackSubAddress(RegionalMuonCand::kStat1);
0234       }
0235
0236       rawTrkAddr = (detSide & 0x1) << bmtfTrAddrDetSideShift_ |
0237                    (wheelNum & bmtfTrAddrWheelMask_) << bmtfTrAddrWheelShift_ |
0238                    (stat1 & bmtfTrAddrStat1Mask_) << bmtfTrAddrStat1Shift_ |
0239                    (stat2 & bmtfTrAddrStat2Mask_) << bmtfTrAddrStat2Shift_ |
0240                    (stat3 & bmtfTrAddrStat3Mask_) << bmtfTrAddrStat3Shift_ |
0241                    (stat4 & bmtfTrAddrStat4Mask_) << bmtfTrAddrStat4Shift_;
0242     } else {
0243       edm::LogWarning("L1T") << "BMTF muon track address map contains " << mu.trackAddress().size()
0244                              << " instead of the expected " << RegionalMuonCand::kNumBmtfSubAddr
0245                              << " subaddresses. Check the data format. Setting track address to 0.";
0246       rawTrkAddr = 0;
0247     }
0248   } else if (tf == emtf_neg || tf == emtf_pos) {
0249     // protection against a track address map with the wrong size
0250     if (mu.trackAddress().size() == RegionalMuonCand::kNumEmtfSubAddr) {
0251       rawTrkAddr = (mu.trackSubAddress(RegionalMuonCand::kME1Seg) & 0x1) << emtfTrAddrMe1SegShift_ |
0252                    (mu.trackSubAddress(RegionalMuonCand::kME1Ch) & emtfTrAddrMe1ChMask_) << emtfTrAddrMe1ChShift_ |
0253                    (mu.trackSubAddress(RegionalMuonCand::kME2Seg) & 0x1) << emtfTrAddrMe2SegShift_ |
0254                    (mu.trackSubAddress(RegionalMuonCand::kME2Ch) & emtfTrAddrMe2ChMask_) << emtfTrAddrMe2ChShift_ |
0255                    (mu.trackSubAddress(RegionalMuonCand::kME3Seg) & 0x1) << emtfTrAddrMe3SegShift_ |
0256                    (mu.trackSubAddress(RegionalMuonCand::kME3Ch) & emtfTrAddrMe3ChMask_) << emtfTrAddrMe3ChShift_ |
0257                    (mu.trackSubAddress(RegionalMuonCand::kME4Seg) & 0x1) << emtfTrAddrMe4SegShift_ |
0258                    (mu.trackSubAddress(RegionalMuonCand::kME4Ch) & emtfTrAddrMe4ChMask_) << emtfTrAddrMe4ChShift_;
0259
0260     } else {
0261       edm::LogWarning("L1T") << "EMTF muon track address map contains " << mu.trackAddress().size()
0262                              << " instead of the expected " << RegionalMuonCand::kNumEmtfSubAddr
0263                              << " subaddresses. Check the data format. Setting track address to 0.";
0264       rawTrkAddr = 0;
0265     }
0266   } else if (tf == omtf_neg || tf == omtf_pos) {
0267     // protection against a track address map with the wrong size
0268     if (mu.trackAddress().size() == RegionalMuonCand::kNumOmtfSubAddr) {
0269       rawTrkAddr = (mu.trackSubAddress(RegionalMuonCand::kLayers) & omtfTrAddrLayersMask_) << omtfTrAddrLayersShift_ |
0270                    (mu.trackSubAddress(RegionalMuonCand::kWeight) & omtfTrAddrWeightMask_) << omtfTrAddrWeightShift_;
0271
0272     } else {
0273       edm::LogWarning("L1T") << "OMTF muon track address map contains " << mu.trackAddress().size()
0274                              << " instead of the expected " << RegionalMuonCand::kNumOmtfSubAddr
0275                              << " subaddresses. Check the data format. Setting track address to 0.";
0276       rawTrkAddr = 0;
0277     }
0278   } else {
0279     rawTrkAddr = mu.trackAddress().at(0);
0280   }
0281
0282   return rawTrkAddr;
0283 }