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