Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-10-25 09:55:21 

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