L1TGEM/src/ME0StubAlgoSubfunction.cc

0001 #include "L1Trigger/L1TGEM/interface/ME0StubAlgoSubfunction.h"
0002
0003 using namespace l1t::me0;
0004
0005 //define functions to generate patterns
0006 HiLo l1t::me0::mirrorHiLo(const HiLo& layer) {
0007   HiLo mirrored{-1 * (layer.lo), -1 * (layer.hi)};
0008   return mirrored;
0009 }
0010 PatternDefinition l1t::me0::mirrorPatternDefinition(const PatternDefinition& pattern, int id) {
0011   std::vector<HiLo> layers_;
0012   layers_.reserve(pattern.layers.size());
0013   for (HiLo l : pattern.layers) {
0014     layers_.push_back(mirrorHiLo(l));
0015   }
0016   PatternDefinition mirrored{id, layers_};
0017   return mirrored;
0018 }
0019 std::vector<HiLo> l1t::me0::createPatternLayer(double lower, double upper) {
0020   std::vector<HiLo> layerList;
0021   double hi, lo;
0022   int hi_i, lo_i;
0023   for (int i = 0; i < 6; ++i) {
0024     if (i < 3) {
0025       hi = lower * (i - 2.5);
0026       lo = upper * (i - 2.5);
0027     } else {
0028       hi = upper * (i - 2.5);
0029       lo = lower * (i - 2.5);
0030     }
0031     if (std::abs(hi) < 0.1) {
0032       hi = 0.0f;
0033     }
0034     if (std::abs(lo) < 0.1) {
0035       lo = 0.0f;
0036     }
0037     hi_i = std::ceil(hi);
0038     lo_i = std::floor(lo);
0039     layerList.push_back(HiLo{hi_i, lo_i});
0040   }
0041   return layerList;
0042 }
0043 int l1t::me0::countOnes(uint64_t x) {
0044   int cnt = 0;
0045   while (x > 0) {
0046     if (x & 1) {
0047       ++cnt;
0048     }
0049     x = (x >> 1);
0050   }
0051   return cnt;
0052 }
0053 int l1t::me0::maxClusterSize(uint64_t x) {
0054   int size = 0;
0055   int maxSize = 0;
0056   while (x > 0) {
0057     if ((x & 1) == 1) {
0058       size++;
0059     } else {
0060       if (size > maxSize) {
0061         maxSize = size;
0062       }
0063       size = 0;
0064     }
0065     x = x >> 1;
0066   }
0067   if (size > maxSize) {
0068     maxSize = size;
0069   }
0070   return maxSize;
0071 }
0072 UInt192 l1t::me0::setBit(int index, UInt192 num1 = UInt192(0)) {
0073   UInt192 num2 = (UInt192(1) << index);
0074   UInt192 final_v = num1 | num2;
0075   return final_v;
0076 }
0077 UInt192 l1t::me0::clearBit(int index, UInt192 num) {
0078   UInt192 bit = UInt192(1) & (num >> index);
0079   return num ^ (bit << index);
0080 }
0081 uint64_t l1t::me0::oneBitMask(int num) {
0082   uint64_t oMask = 0;
0083   int bitNum = 0;
0084   while (num != 0) {
0085     oMask |= (1 << bitNum);
0086     num = (num >> 1);
0087     ++bitNum;
0088   }
0089   return oMask;
0090 }
0091 std::vector<int> l1t::me0::findOnes(uint64_t& data) {
0092   std::vector<int> ones;
0093   int cnt = 0;
0094   while (data > 0) {
0095     if ((data & 1)) {
0096       ones.push_back(cnt + 1);
0097     }
0098     data >>= 1;
0099     ++cnt;
0100   }
0101   return ones;
0102 }
0103 std::pair<double, std::vector<int>> l1t::me0::findCentroid(uint64_t& data) {
0104   std::vector<int> ones = findOnes(data);
0105   if (static_cast<int>(ones.size()) == 0) {
0106     return {0.0, ones};
0107   }
0108   int sum = 0;
0109   for (int n : ones) {
0110     sum += n;
0111   }
0112   return {static_cast<double>(sum) / static_cast<double>(ones.size()), ones};
0113 }
0114 std::vector<std::vector<ME0StubPrimitive>> l1t::me0::chunk(const std::vector<ME0StubPrimitive>& inList, int n) {
0115   std::vector<std::vector<ME0StubPrimitive>> chunks;
0116   int size = inList.size();
0117   for (int i = 0; i < (size + n - 1) / n; ++i) {
0118     std::vector<ME0StubPrimitive> chunk(inList.begin() + i * n, inList.begin() + std::min((i + 1) * n, size));
0119     chunks.push_back(chunk);
0120   }
0121   return chunks;
0122 }
0123 void l1t::me0::segmentSorter(std::vector<ME0StubPrimitive>& segs, int n) {
0124   std::sort(segs.begin(), segs.end(), [](const ME0StubPrimitive& lhs, const ME0StubPrimitive& rhs) {
0125     return (lhs.quality() > rhs.quality());
0126   });
0127   segs = std::vector<ME0StubPrimitive>(segs.begin(), std::min(segs.begin() + n, segs.end()));
0128 }
0129 std::vector<int> l1t::me0::concatVector(const std::vector<std::vector<int>>& vec) {
0130   std::vector<int> cat;
0131   for (auto v : vec) {
0132     cat.insert(cat.end(), v.begin(), v.end());
0133   }
0134   return cat;
0135 }
0136 std::vector<ME0StubPrimitive> l1t::me0::concatVector(const std::vector<std::vector<ME0StubPrimitive>>& vec) {
0137   std::vector<ME0StubPrimitive> cat;
0138   for (auto v : vec) {
0139     cat.insert(cat.end(), v.begin(), v.end());
0140   }
0141   return cat;
0142 }