L1TMuon/src/L1TMuonGlobalParamsHelper.cc

0001 #include <iomanip>
0002
0003 #include "L1Trigger/L1TMuon/interface/L1TMuonGlobalParamsHelper.h"
0004 #include "L1Trigger/L1TCommon/interface/ConvertToLUT.h"
0005 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0006
0007 L1TMuonGlobalParamsHelper::L1TMuonGlobalParamsHelper(const L1TMuonGlobalParams &p)
0008     : L1TMuonGlobalParams_PUBLIC(cast_to_L1TMuonGlobalParams_PUBLIC(p)) {
0009   if (pnodes_.size() != NUM_GMTPARAMNODES) {
0010     pnodes_.resize(NUM_GMTPARAMNODES);
0011   }
0012 }
0013
0014 std::bitset<72> L1TMuonGlobalParamsHelper::inputFlags(const int &nodeIdx) const {
0015   std::bitset<72> inputFlags;
0016   if (pnodes_[nodeIdx].uparams_.size() != 4) {
0017     return inputFlags;
0018   }
0019
0020   for (size_t i = 0; i < 28; ++i) {
0021     inputFlags[CALOLINK1 + i] = ((pnodes_[nodeIdx].uparams_[CALOINPUTS] >> i) & 0x1);
0022     if (i < CALOLINK1) {
0023       // disable unused inputs
0024       inputFlags[i] = true;
0025     }
0026     if (i < 12) {
0027       inputFlags[BMTFLINK1 + i] = ((pnodes_[nodeIdx].uparams_[BMTFINPUTS] >> i) & 0x1);
0028       if (i < 6) {
0029         inputFlags[EMTFPLINK1 + i] = ((pnodes_[nodeIdx].uparams_[EMTFINPUTS] >> i) & 0x1);
0030         inputFlags[OMTFPLINK1 + i] = ((pnodes_[nodeIdx].uparams_[OMTFINPUTS] >> i) & 0x1);
0031         inputFlags[OMTFNLINK1 + i] = ((pnodes_[nodeIdx].uparams_[OMTFINPUTS] >> (i + 6)) & 0x1);
0032         inputFlags[EMTFNLINK1 + i] = ((pnodes_[nodeIdx].uparams_[EMTFINPUTS] >> (i + 6)) & 0x1);
0033       }
0034     }
0035   }
0036   return inputFlags;
0037 }
0038
0039 std::bitset<28> L1TMuonGlobalParamsHelper::caloInputFlags(const int &nodeIdx) const {
0040   if (pnodes_[nodeIdx].uparams_.size() == 4) {
0041     return std::bitset<28>(pnodes_[nodeIdx].uparams_[CALOINPUTS]);
0042   } else {
0043     return std::bitset<28>();
0044   }
0045 }
0046
0047 std::bitset<12> L1TMuonGlobalParamsHelper::tfInputFlags(const int &nodeIdx, const int &tfIdx) const {
0048   if (pnodes_[nodeIdx].uparams_.size() == 4) {
0049     return std::bitset<12>(pnodes_[nodeIdx].uparams_[tfIdx]);
0050   } else {
0051     return std::bitset<12>();
0052   }
0053 }
0054
0055 std::bitset<6> L1TMuonGlobalParamsHelper::eomtfInputFlags(const int &nodeIdx,
0056                                                           const size_t &startIdx,
0057                                                           const int &tfIdx) const {
0058   std::bitset<6> inputFlags;
0059   if (pnodes_[nodeIdx].uparams_.size() == 4) {
0060     for (size_t i = 0; i < 6; ++i) {
0061       inputFlags[i] = ((pnodes_[nodeIdx].uparams_[tfIdx] >> (i + startIdx)) & 0x1);
0062     }
0063   }
0064   return inputFlags;
0065 }
0066
0067 void L1TMuonGlobalParamsHelper::setFwVersion(unsigned fwVersion) {
0068   pnodes_[FWVERSION].uparams_.resize(1);
0069   pnodes_[FWVERSION].uparams_[FWVERSION_IDX] = fwVersion;
0070 }
0071
0072 void L1TMuonGlobalParamsHelper::setInputFlags(const int &nodeIdx, const std::bitset<72> &inputFlags) {
0073   pnodes_[nodeIdx].uparams_.resize(4);
0074   for (size_t i = 0; i < 28; ++i) {
0075     pnodes_[nodeIdx].uparams_[CALOINPUTS] += (inputFlags.test(CALOLINK1 + i) << i);
0076     if (i < 12) {
0077       pnodes_[nodeIdx].uparams_[BMTFINPUTS] += (inputFlags.test(BMTFLINK1 + i) << i);
0078       if (i < 6) {
0079         pnodes_[nodeIdx].uparams_[OMTFINPUTS] += (inputFlags.test(OMTFPLINK1 + i) << i);
0080         pnodes_[nodeIdx].uparams_[OMTFINPUTS] += (inputFlags.test(OMTFNLINK1 + i) << (i + 6));
0081         pnodes_[nodeIdx].uparams_[EMTFINPUTS] += (inputFlags.test(EMTFPLINK1 + i) << i);
0082         pnodes_[nodeIdx].uparams_[EMTFINPUTS] += (inputFlags.test(EMTFNLINK1 + i) << (i + 6));
0083       }
0084     }
0085   }
0086 }
0087
0088 void L1TMuonGlobalParamsHelper::setCaloInputFlags(const int &nodeIdx, const std::bitset<28> &inputFlags) {
0089   pnodes_[nodeIdx].uparams_.resize(4);
0090   for (size_t i = 0; i < 28; ++i) {
0091     pnodes_[nodeIdx].uparams_[CALOINPUTS] += (inputFlags.test(i) << i);
0092   }
0093 }
0094
0095 void L1TMuonGlobalParamsHelper::setTfInputFlags(const int &nodeIdx,
0096                                                 const int &tfIdx,
0097                                                 const std::bitset<12> &inputFlags) {
0098   pnodes_[nodeIdx].uparams_.resize(4);
0099   for (size_t i = 0; i < 12; ++i) {
0100     pnodes_[nodeIdx].uparams_[tfIdx] += (inputFlags.test(i) << i);
0101   }
0102 }
0103
0104 void L1TMuonGlobalParamsHelper::setEOmtfInputFlags(const int &nodeIdx,
0105                                                    const size_t &startIdx,
0106                                                    const int &tfIdx,
0107                                                    const std::bitset<6> &inputFlags) {
0108   pnodes_[nodeIdx].uparams_.resize(4);
0109   for (size_t i = 0; i < 6; ++i) {
0110     pnodes_[nodeIdx].uparams_[tfIdx] += (inputFlags.test(i) << (i + startIdx));
0111   }
0112 }
0113
0114 void L1TMuonGlobalParamsHelper::loadFromOnline(l1t::TriggerSystem &trgSys, const std::string &processorId) {
0115   std::string procId = processorId;
0116   // if the procId is an empty string use the one from the TrigSystem (the uGMT only has one processor)
0117   if (procId.empty()) {
0118     const std::map<std::string, std::string> &procRoleMap = trgSys.getProcToRoleAssignment();
0119     if (procRoleMap.size() != 1) {
0120       if (procRoleMap.empty()) {
0121         edm::LogError("uGMT config from online") << "No processor id found for uGMT HW configuration.";
0122       } else {
0123         edm::LogError("uGMT config from online") << "More than one processor id found for uGMT HW configuration.";
0124       }
0125     } else {
0126       procId = procRoleMap.cbegin()->first;
0127     }
0128   }
0129
0130   // get the settings and masks for the processor id
0131   std::map<std::string, l1t::Parameter> settings = trgSys.getParameters(procId.c_str());
0132   //std::map<std::string, l1t::Mask> masks = trgSys.getMasks(procId.c_str());
0133   //for (auto& it: settings) {
0134   //   std::cout << "Key: " << it.first << ", procRole: " << it.second.getProcRole() << ", type: " << it.second.getType() << ", id: " << it.second.getId() << ", value as string: [" << it.second.getValueAsStr() << "]" << std::endl;
0135   //}
0136   //for (auto& it: masks) {
0137   //   std::cout << "Key: " << it.first << ", procRole: " << it.second.getProcRole() << ", id: " << it.second.getId() << std::endl;
0138   //}
0139
0140   // Use FW version from online config if it is found there. Otherwise set it to 1
0141   unsigned fwVersion = 1;
0142   if (settings.count("algoRev") > 0) {
0143     fwVersion = settings["algoRev"].getValue<unsigned int>();
0144   }
0145   setFwVersion(fwVersion);
0146
0147   std::stringstream ss;
0148   // uGMT disabled inputs
0149   bool disableCaloInputs = settings["caloInputsDisable"].getValue<bool>();
0150   std::string bmtfInputsToDisableStr = settings["bmtfInputsToDisable"].getValueAsStr();
0151   std::string omtfInputsToDisableStr = settings["omtfInputsToDisable"].getValueAsStr();
0152   std::string emtfInputsToDisableStr = settings["emtfInputsToDisable"].getValueAsStr();
0153   std::vector<unsigned> bmtfInputsToDisable(12, 0);
0154   std::vector<unsigned> omtfInputsToDisable(12, 0);
0155   std::vector<unsigned> emtfInputsToDisable(12, 0);
0156   // translate the bool and the strings to the vectors
0157   for (unsigned i = 0; i < 12; ++i) {
0158     ss.str("");
0159     ss << "BMTF" << i + 1;
0160     if (bmtfInputsToDisableStr.find(ss.str()) != std::string::npos) {
0161       bmtfInputsToDisable[i] = 1;
0162     }
0163     ss.str("");
0164     ss << "OMTF";
0165     if (i < 6) {
0166       ss << "p" << i + 1;
0167     } else {
0168       ss << "n" << i - 5;
0169     }
0170     if (omtfInputsToDisableStr.find(ss.str()) != std::string::npos) {
0171       omtfInputsToDisable[i] = 1;
0172     }
0173     ss.str("");
0174     ss << "EMTF";
0175     if (i < 6) {
0176       ss << "p" << i + 1;
0177     } else {
0178       ss << "n" << i - 5;
0179     }
0180     if (emtfInputsToDisableStr.find(ss.str()) != std::string::npos) {
0181       emtfInputsToDisable[i] = 1;
0182     }
0183   }
0184
0185   // set the condFormats parameters for uGMT disabled inputs
0186   if (disableCaloInputs) {
0187     setCaloInputsToDisable(std::bitset<28>(0xFFFFFFF));
0188   } else {
0189     setCaloInputsToDisable(std::bitset<28>());
0190   }
0191
0192   std::bitset<12> bmtfDisables;
0193   for (size_t i = 0; i < bmtfInputsToDisable.size(); ++i) {
0194     bmtfDisables.set(i, bmtfInputsToDisable[i] > 0);
0195   }
0196   setBmtfInputsToDisable(bmtfDisables);
0197
0198   std::bitset<6> omtfpDisables;
0199   std::bitset<6> omtfnDisables;
0200   for (size_t i = 0; i < omtfInputsToDisable.size(); ++i) {
0201     if (i < 6) {
0202       omtfpDisables.set(i, omtfInputsToDisable[i] > 0);
0203     } else {
0204       omtfnDisables.set(i - 6, omtfInputsToDisable[i] > 0);
0205     }
0206   }
0207   setOmtfpInputsToDisable(omtfpDisables);
0208   setOmtfnInputsToDisable(omtfnDisables);
0209
0210   std::bitset<6> emtfpDisables;
0211   std::bitset<6> emtfnDisables;
0212   for (size_t i = 0; i < emtfInputsToDisable.size(); ++i) {
0213     if (i < 6) {
0214       emtfpDisables.set(i, emtfInputsToDisable[i] > 0);
0215     } else {
0216       emtfnDisables.set(i - 6, emtfInputsToDisable[i] > 0);
0217     }
0218   }
0219   setEmtfpInputsToDisable(emtfpDisables);
0220   setEmtfnInputsToDisable(emtfnDisables);
0221
0222   // uGMT masked inputs
0223   bool caloInputsMasked = true;
0224   std::vector<unsigned> maskedBmtfInputs(12, 0);
0225   std::vector<unsigned> maskedOmtfInputs(12, 0);
0226   std::vector<unsigned> maskedEmtfInputs(12, 0);
0227   ss << std::setfill('0');
0228   // translate the bool and the strings to the vectors
0229   for (unsigned i = 0; i < 28; ++i) {
0230     ss.str("");
0231     ss << "inputPorts.CaloL2_" << std::setw(2) << i + 1;
0232     // for now set as unmasked if one input is not masked
0233     if (!trgSys.isMasked(procId.c_str(), ss.str().c_str())) {
0234       caloInputsMasked = false;
0235     }
0236     if (i < 12) {
0237       ss.str("");
0238       ss << "inputPorts.BMTF_" << std::setw(2) << i + 1;
0239       if (trgSys.isMasked(procId.c_str(), ss.str().c_str())) {
0240         maskedBmtfInputs[i] = 1;
0241       }
0242       ss.str("");
0243       ss << "inputPorts.OMTF";
0244       if (i < 6) {
0245         ss << "+_" << std::setw(2) << i + 1;
0246       } else {
0247         ss << "-_" << std::setw(2) << i - 5;
0248       }
0249       if (trgSys.isMasked(procId.c_str(), ss.str().c_str())) {
0250         maskedOmtfInputs[i] = 1;
0251       }
0252       ss.str("");
0253       ss << "inputPorts.EMTF";
0254       if (i < 6) {
0255         ss << "+_" << std::setw(2) << i + 1;
0256       } else {
0257         ss << "-_" << std::setw(2) << i - 5;
0258       }
0259       if (trgSys.isMasked(procId.c_str(), ss.str().c_str())) {
0260         maskedEmtfInputs[i] = 1;
0261       }
0262     }
0263   }
0264   ss << std::setfill(' ');
0265
0266   // set the condFormats parameters for uGMT masked inputs
0267   if (caloInputsMasked) {
0268     setMaskedCaloInputs(std::bitset<28>(0xFFFFFFF));
0269   } else {
0270     setMaskedCaloInputs(std::bitset<28>());
0271   }
0272
0273   std::bitset<12> bmtfMasked;
0274   for (size_t i = 0; i < maskedBmtfInputs.size(); ++i) {
0275     bmtfMasked.set(i, maskedBmtfInputs[i] > 0);
0276   }
0277   setMaskedBmtfInputs(bmtfMasked);
0278
0279   std::bitset<6> omtfpMasked;
0280   std::bitset<6> omtfnMasked;
0281   for (size_t i = 0; i < maskedOmtfInputs.size(); ++i) {
0282     if (i < 6) {
0283       omtfpMasked.set(i, maskedOmtfInputs[i] > 0);
0284     } else {
0285       omtfnMasked.set(i - 6, maskedOmtfInputs[i] > 0);
0286     }
0287   }
0288   setMaskedOmtfpInputs(omtfpMasked);
0289   setMaskedOmtfnInputs(omtfnMasked);
0290
0291   std::bitset<6> emtfpMasked;
0292   std::bitset<6> emtfnMasked;
0293   for (size_t i = 0; i < maskedEmtfInputs.size(); ++i) {
0294     if (i < 6) {
0295       emtfpMasked.set(i, maskedEmtfInputs[i] > 0);
0296     } else {
0297       emtfnMasked.set(i - 6, maskedEmtfInputs[i] > 0);
0298     }
0299   }
0300   setMaskedEmtfpInputs(emtfpMasked);
0301   setMaskedEmtfnInputs(emtfnMasked);
0302
0303   // LUTs from settings with with automatic detection of address width and 31 bit output width
0304   setAbsIsoCheckMemLUT(l1t::convertToLUT(settings["AbsIsoCheckMem"].getVector<unsigned int>()));
0305   setRelIsoCheckMemLUT(l1t::convertToLUT(settings["RelIsoCheckMem"].getVector<unsigned int>()));
0306   setIdxSelMemPhiLUT(l1t::convertToLUT(settings["IdxSelMemPhi"].getVector<unsigned int>()));
0307   setIdxSelMemEtaLUT(l1t::convertToLUT(settings["IdxSelMemEta"].getVector<unsigned int>()));
0308   setFwdPosSingleMatchQualLUT(l1t::convertToLUT(settings["EmtfPosSingleMatchQual"].getVector<unsigned int>()));
0309   setFwdNegSingleMatchQualLUT(l1t::convertToLUT(settings["EmtfNegSingleMatchQual"].getVector<unsigned int>()));
0310   setOvlPosSingleMatchQualLUT(l1t::convertToLUT(settings["OmtfPosSingleMatchQual"].getVector<unsigned int>()));
0311   setOvlNegSingleMatchQualLUT(l1t::convertToLUT(settings["OmtfNegSingleMatchQual"].getVector<unsigned int>()));
0312   setBOPosMatchQualLUT(l1t::convertToLUT(settings["BOPosMatchQual"].getVector<unsigned int>()));
0313   setBONegMatchQualLUT(l1t::convertToLUT(settings["BONegMatchQual"].getVector<unsigned int>()));
0314   setFOPosMatchQualLUT(l1t::convertToLUT(settings["EOPosMatchQual"].getVector<unsigned int>()));
0315   setFONegMatchQualLUT(l1t::convertToLUT(settings["EONegMatchQual"].getVector<unsigned int>()));
0316   setBPhiExtrapolationLUT(l1t::convertToLUT(settings["BPhiExtrapolation"].getVector<unsigned int>()));
0317   setOPhiExtrapolationLUT(l1t::convertToLUT(settings["OPhiExtrapolation"].getVector<unsigned int>()));
0318   setFPhiExtrapolationLUT(l1t::convertToLUT(settings["EPhiExtrapolation"].getVector<unsigned int>()));
0319   setBEtaExtrapolationLUT(l1t::convertToLUT(settings["BEtaExtrapolation"].getVector<unsigned int>()));
0320   setOEtaExtrapolationLUT(l1t::convertToLUT(settings["OEtaExtrapolation"].getVector<unsigned int>()));
0321   setFEtaExtrapolationLUT(l1t::convertToLUT(settings["EEtaExtrapolation"].getVector<unsigned int>()));
0322   setSortRankLUT(l1t::convertToLUT(settings["SortRank"].getVector<unsigned int>()));
0323 }
0324
0325 // setters for cancel out LUT parameters
0326 void L1TMuonGlobalParamsHelper::setFwdPosSingleMatchQualLUTMaxDR(double maxDR, double fEta, double fPhi) {
0327   pnodes_[fwdPosSingleMatchQual].dparams_.push_back(maxDR);
0328   pnodes_[fwdPosSingleMatchQual].dparams_.push_back(fEta);
0329   pnodes_[fwdPosSingleMatchQual].dparams_.push_back(fEta);
0330   pnodes_[fwdPosSingleMatchQual].dparams_.push_back(fPhi);
0331 }
0332
0333 void L1TMuonGlobalParamsHelper::setFwdNegSingleMatchQualLUTMaxDR(double maxDR, double fEta, double fPhi) {
0334   pnodes_[fwdNegSingleMatchQual].dparams_.push_back(maxDR);
0335   pnodes_[fwdNegSingleMatchQual].dparams_.push_back(fEta);
0336   pnodes_[fwdNegSingleMatchQual].dparams_.push_back(fEta);
0337   pnodes_[fwdNegSingleMatchQual].dparams_.push_back(fPhi);
0338 }
0339
0340 void L1TMuonGlobalParamsHelper::setOvlPosSingleMatchQualLUTMaxDR(double maxDR,
0341                                                                  double fEta,
0342                                                                  double fEtaCoarse,
0343                                                                  double fPhi) {
0344   pnodes_[ovlPosSingleMatchQual].dparams_.push_back(maxDR);
0345   pnodes_[ovlPosSingleMatchQual].dparams_.push_back(fEta);
0346   pnodes_[ovlPosSingleMatchQual].dparams_.push_back(fEtaCoarse);
0347   pnodes_[ovlPosSingleMatchQual].dparams_.push_back(fPhi);
0348 }
0349
0350 void L1TMuonGlobalParamsHelper::setOvlNegSingleMatchQualLUTMaxDR(double maxDR,
0351                                                                  double fEta,
0352                                                                  double fEtaCoarse,
0353                                                                  double fPhi) {
0354   pnodes_[ovlNegSingleMatchQual].dparams_.push_back(maxDR);
0355   pnodes_[ovlNegSingleMatchQual].dparams_.push_back(fEta);
0356   pnodes_[ovlNegSingleMatchQual].dparams_.push_back(fEtaCoarse);
0357   pnodes_[ovlNegSingleMatchQual].dparams_.push_back(fPhi);
0358 }
0359
0360 void L1TMuonGlobalParamsHelper::setBOPosMatchQualLUTMaxDR(double maxDR, double fEta, double fEtaCoarse, double fPhi) {
0361   pnodes_[bOPosMatchQual].dparams_.push_back(maxDR);
0362   pnodes_[bOPosMatchQual].dparams_.push_back(fEta);
0363   pnodes_[bOPosMatchQual].dparams_.push_back(fEtaCoarse);
0364   pnodes_[bOPosMatchQual].dparams_.push_back(fPhi);
0365 }
0366
0367 void L1TMuonGlobalParamsHelper::setBONegMatchQualLUTMaxDR(double maxDR, double fEta, double fEtaCoarse, double fPhi) {
0368   pnodes_[bONegMatchQual].dparams_.push_back(maxDR);
0369   pnodes_[bONegMatchQual].dparams_.push_back(fEta);
0370   pnodes_[bONegMatchQual].dparams_.push_back(fEtaCoarse);
0371   pnodes_[bONegMatchQual].dparams_.push_back(fPhi);
0372 }
0373
0374 void L1TMuonGlobalParamsHelper::setFOPosMatchQualLUTMaxDR(double maxDR, double fEta, double fEtaCoarse, double fPhi) {
0375   pnodes_[fOPosMatchQual].dparams_.push_back(maxDR);
0376   pnodes_[fOPosMatchQual].dparams_.push_back(fEta);
0377   pnodes_[fOPosMatchQual].dparams_.push_back(fEtaCoarse);
0378   pnodes_[fOPosMatchQual].dparams_.push_back(fPhi);
0379 }
0380
0381 void L1TMuonGlobalParamsHelper::setFONegMatchQualLUTMaxDR(double maxDR, double fEta, double fEtaCoarse, double fPhi) {
0382   pnodes_[fONegMatchQual].dparams_.push_back(maxDR);
0383   pnodes_[fONegMatchQual].dparams_.push_back(fEta);
0384   pnodes_[fONegMatchQual].dparams_.push_back(fEtaCoarse);
0385   pnodes_[fONegMatchQual].dparams_.push_back(fPhi);
0386 }
0387
0388 void L1TMuonGlobalParamsHelper::print(std::ostream &out) const {
0389   out << "L1 MicroGMT Parameters" << std::endl;
0390
0391   out << "Firmware version: " << this->fwVersion() << std::endl;
0392
0393   out << "InputsToDisable: " << this->inputsToDisable() << std::endl;
0394   out << "                 EMTF-|OMTF-|   BMTF    |OMTF+|EMTF+|            CALO           |  res  0" << std::endl;
0395
0396   out << "Masked Inputs:   " << this->maskedInputs() << std::endl;
0397   out << "                 EMTF-|OMTF-|   BMTF    |OMTF+|EMTF+|            CALO           |  res  0" << std::endl;
0398
0399   out << "LUT paths (LUTs are generated analytically if path is empty)" << std::endl;
0400   out << " Abs isolation checkMem LUT path: " << this->absIsoCheckMemLUTPath() << std::endl;
0401   out << " Rel isolation checkMem LUT path: " << this->relIsoCheckMemLUTPath() << std::endl;
0402   out << " Index selMem phi LUT path: " << this->idxSelMemPhiLUTPath() << std::endl;
0403   out << " Index selMem eta LUT path: " << this->idxSelMemEtaLUTPath() << std::endl;
0404   out << " Forward pos MatchQual LUT path: " << this->fwdPosSingleMatchQualLUTPath()
0405       << ", max dR (Used when LUT path empty): " << this->fwdPosSingleMatchQualLUTMaxDR() << std::endl;
0406   out << " Forward neg MatchQual LUT path: " << this->fwdNegSingleMatchQualLUTPath()
0407       << ", max dR (Used when LUT path empty): " << this->fwdNegSingleMatchQualLUTMaxDR() << std::endl;
0408   out << " Overlap pos MatchQual LUT path: " << this->ovlPosSingleMatchQualLUTPath()
0409       << ", max dR (Used when LUT path empty): " << this->ovlPosSingleMatchQualLUTMaxDR() << std::endl;
0410   out << " Overlap neg MatchQual LUT path: " << this->ovlNegSingleMatchQualLUTPath()
0411       << ", max dR (Used when LUT path empty): " << this->ovlNegSingleMatchQualLUTMaxDR() << std::endl;
0412   out << " Barrel-Overlap pos MatchQual LUT path: " << this->bOPosMatchQualLUTPath()
0413       << ", max dR (Used when LUT path empty): " << this->bOPosMatchQualLUTMaxDR()
0414       << ", fEta: " << this->bOPosMatchQualLUTfEta()
0415       << ", fEta when eta-fine bit isn't set: " << this->bOPosMatchQualLUTfEtaCoarse()
0416       << ", fPhi: " << this->bOPosMatchQualLUTfEta() << std::endl;
0417   out << " Barrel-Overlap neg MatchQual LUT path: " << this->bONegMatchQualLUTPath()
0418       << ", max dR (Used when LUT path empty): " << this->bONegMatchQualLUTMaxDR()
0419       << ", fEta: " << this->bONegMatchQualLUTfEta()
0420       << ", fEta when eta-fine bit isn't set: " << this->bONegMatchQualLUTfEtaCoarse()
0421       << ", fPhi: " << this->bONegMatchQualLUTfPhi() << std::endl;
0422   out << " Forward-Overlap pos MatchQual LUT path: " << this->fOPosMatchQualLUTPath()
0423       << ", max dR (Used when LUT path empty): " << this->fOPosMatchQualLUTMaxDR() << std::endl;
0424   out << " Forward-Overlap neg MatchQual LUT path: " << this->fONegMatchQualLUTPath()
0425       << ", max dR (Used when LUT path empty): " << this->fONegMatchQualLUTMaxDR() << std::endl;
0426   out << " Barrel phi extrapolation LUT path: " << this->bPhiExtrapolationLUTPath() << std::endl;
0427   out << " Overlap phi extrapolation LUT path: " << this->oPhiExtrapolationLUTPath() << std::endl;
0428   out << " Forward phi extrapolation LUT path: " << this->fPhiExtrapolationLUTPath() << std::endl;
0429   out << " Barrel eta extrapolation LUT path: " << this->bEtaExtrapolationLUTPath() << std::endl;
0430   out << " Overlap eta extrapolation LUT path: " << this->oEtaExtrapolationLUTPath() << std::endl;
0431   out << " Forward eta extrapolation LUT path: " << this->fEtaExtrapolationLUTPath() << std::endl;
0432   out << " Sort rank LUT path: " << this->sortRankLUTPath()
0433       << ", pT and quality factors (Used when LUT path empty): pT factor: " << this->sortRankLUTPtFactor()
0434       << ", quality factor: " << this->sortRankLUTQualFactor() << std::endl;
0435 }