Project CMSSW displayed by LXR CMSSW_15_1_X_2025-07-02-2300/​DataFormats/​L1TrackTrigger/​interface/​TTBV.h	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_1_X_2025-07-02-2300 CMSSW_15_1_X_2025-06-30-2300 CMSSW_15_1_X_2025-06-29-2300 CMSSW_15_1_X_2025-06-27-2300 CMSSW_15_1_X_2025-06-26-2300 CMSSW_15_0_4 CMSSW_15_0_3_patch1 CMSSW_14_0_21_patch1 Revert   Change

File indexing completed on 2025-06-11 02:59:55

 #ifndef DataFormats_L1TrackTrigger_TTBV_h
 #define DataFormats_L1TrackTrigger_TTBV_h
 
 #include "FWCore/Utilities/interface/Exception.h"
 
 #include <bitset>
 #include <array>
 #include <string>
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 #include <iostream>
 
 /*! 
  * \class  TTBV
  * \brief  Bit vector used by Track Trigger emulators. Mainly used to convert
  *         integers into arbitrary (within margin) sized two's complement strings.
  * \author Thomas Schuh
  * \date   2020, Jan
  */
 class TTBV {
 public:
   static constexpr int S_ = 64;  // Frame width of emp infrastructure f/w, max number of bits a TTBV can handle
 private:
   bool twos_;           // Two's complement (true) or binary (false)
   int size_;            // number or bits
   std::bitset<S_> bs_;  // underlying storage
 public:
   // constructor: default
   TTBV() : twos_(false), size_(0), bs_() {}
   // constructor: double precision (IEEE 754); from most to least significant bit: 1 bit sign + 11 bit binary exponent + 52 bit binary mantisse
   TTBV(const double d) : twos_(false), size_(S_) {
     int index(0);
     const char* c = reinterpret_cast<const char*>(&d);
     for (int iByte = 0; iByte < (int)sizeof(d); iByte++) {
       const std::bitset<std::numeric_limits<unsigned char>::digits> byte(*(c + iByte));
       for (int bit = 0; bit < std::numeric_limits<unsigned char>::digits; bit++)
         bs_[index++] = byte[bit];
     }
   }
 
   // constructor: unsigned int value
   TTBV(unsigned long long int value, int size) : twos_(false), size_(size), bs_(value) { checkU(value); }
 
   // constructor: int value
   TTBV(int value, int size, bool twos = false)
       : twos_(twos), size_(size), bs_((!twos || value >= 0) ? value : value + iMax()) {
     checkI(value);
   }
 
   // constructor: double value + precision, biased (floor) representation
   TTBV(double value, double base, int size, bool twos = false)
       : TTBV((int)std::floor(value / base + 1.e-12), size, twos) {}
 
   // constructor: string
   TTBV(const std::string& str, bool twos = false) : twos_(twos), size_(str.size()), bs_(str) {}
 
   // constructor: bitset
   TTBV(const std::bitset<S_>& bs, bool twos = false) : twos_(twos), size_(S_), bs_(bs) {}
 
   // constructor: slice reinterpret sign
   TTBV(const TTBV& ttBV, int begin, int end = 0, bool twos = false) : twos_(twos), size_(begin - end), bs_(ttBV.bs_) {
     bs_ <<= S_ - begin;
     bs_ >>= S_ - begin + end;
   }
 
   // Two's complement (true) or binary (false)
   bool twos() const { return twos_; }
   // number or bits
   int size() const { return size_; }
   // underlying storage
   const std::bitset<S_>& bs() const { return bs_; }
 
   // access: single bit value
   bool operator[](int pos) const { return bs_[pos]; }
 
   // access: single bit reference
   std::bitset<S_>::reference operator[](int pos) { return bs_[pos]; }
 
   // access: single bit value with bounds check
   bool test(int pos) const { return bs_.test(pos); }
 
   // access: most significant bit copy
   bool msb() const { return bs_[size_ - 1]; }
 
   // access: most significant bit reference
   std::bitset<S_>::reference msb() { return bs_[size_ - 1]; }
 
   // access: members of underlying bitset
 
   bool all() const { return bs_.all(); }
   bool any() const { return bs_.any(); }
   bool none() const { return bs_.none(); }
   int count() const { return bs_.count(); }
 
   // operator: comparisons equal
   bool operator==(const TTBV& rhs) const { return bs_ == rhs.bs_; }
 
   // operator: comparisons not equal
   bool operator!=(const TTBV& rhs) const { return bs_ != rhs.bs_; }
 
   // operator: boolean and
   TTBV& operator&=(const TTBV& rhs) {
     bs_ &= rhs.bs_;
     return *this;
   }
 
   // operator: boolean and
   TTBV operator&&(const TTBV& rhs) {
     TTBV copy(*this);
     return copy &= rhs;
   }
 
   // operator: boolean or
   TTBV& operator|=(const TTBV& rhs) {
     bs_ |= rhs.bs_;
     return *this;
   }
 
   // operator: boolean or
   TTBV operator||(const TTBV& rhs) {
     TTBV copy(*this);
     return copy |= rhs;
   }
 
   // operator: boolean xor
   TTBV& operator^=(const TTBV& rhs) {
     bs_ ^= rhs.bs_;
     return *this;
   }
 
   // operator: not
   TTBV operator~() const {
     TTBV bv(*this);
     return bv.flip();
   }
 
   // reference operator: bit remove right
   TTBV& operator>>=(int pos) {
     bs_ >>= pos;
     size_ -= pos;
     return *this;
   }
 
   // reference operator: bit remove left
   TTBV& operator<<=(int pos) {
     bs_ <<= S_ - size_ + pos;
     bs_ >>= S_ - size_ + pos;
     size_ -= pos;
     return *this;
   }
 
   // operator: bit remove left copy
   TTBV operator<<(int pos) const {
     TTBV bv(*this);
     return bv <<= pos;
   }
 
   // operator: bit remove right copy
   TTBV operator>>(int pos) const {
     TTBV bv(*this);
     return bv >>= pos;
   }
 
   // reference operator: concatenation
   TTBV& operator+=(const TTBV& rhs) {
     bs_ <<= rhs.size();
     bs_ |= rhs.bs_;
     size_ += rhs.size();
     return *this;
   }
 
   // operator: concatenation copy
   TTBV operator+(const TTBV& rhs) const {
     TTBV lhs(*this);
     return lhs += rhs;
   }
 
   // operator: value increment, overflow protected
   TTBV& operator++() {
     bs_ = std::bitset<S_>(bs_.to_ullong() + 1);
     this->resize(size_);
     return *this;
   }
 
   // manipulation: all bits set to 0
   TTBV& reset() {
     bs_.reset();
     return *this;
   }
 
   // manipulation: all bits set to 1
   TTBV& set() {
     for (int n = 0; n < size_; n++)
       bs_.set(n);
     return *this;
   }
 
   // manipulation: all bits flip 1 to 0 and vice versa
   TTBV& flip() {
     for (int n = 0; n < size_; n++)
       bs_.flip(n);
     return *this;
   }
 
   // manipulation: single bit set to 0
   TTBV& reset(int pos) {
     bs_.reset(pos);
     return *this;
   }
 
   // manipulation: single bit set to 1
   TTBV& set(int pos) {
     bs_.set(pos);
     return *this;
   }
 
   // manipulation: multiple bit set to 1
   TTBV& set(std::vector<int> vpos) {
     for (int pos : vpos)
       bs_.set(pos);
     return *this;
   }
 
   // manipulation: single bit flip 1 to 0 and vice versa
   TTBV& flip(int pos) {
     bs_.flip(pos);
     return *this;
   }
 
   // manipulation: absolute value of biased twos' complement. Converts twos' complenet into binary.
   TTBV& abs() {
     if (twos_) {
       twos_ = false;
       if (this->msb())
         this->flip();
       size_--;
     }
     return *this;
   }
 
   // manipulation: resize
   TTBV& resize(int size) {
     bool msb = this->msb();
     if (size > size_) {
       if (twos_)
         for (int n = size_; n < size; n++)
           bs_.set(n, msb);
       size_ = size;
     } else if (size < size_ && size > 0) {
       this->operator<<=(size_ - size);
       if (twos_)
         this->msb() = msb;
     }
     return *this;
   }
 
   // conversion: to string
   std::string str() const { return bs_.to_string().substr(S_ - size_, S_); }
 
   // conversion: range based to string
   std::string str(int start, int end = 0) const { return this->str().substr(size_ - start, size_ - end); }
 
   // conversion: to int
   int val() const { return (twos_ && this->msb()) ? (int)bs_.to_ullong() - iMax() : bs_.to_ullong(); }
 
   // conversion: to int, reinterpret sign
   int val(bool twos) const { return (twos && this->msb()) ? (int)bs_.to_ullong() - iMax() : bs_.to_ullong(); }
 
   // conversion: range based to int, reinterpret sign
   int val(int start, int end = 0, bool twos = false) const { return TTBV(*this, start, end).val(twos); }
 
   // conversion: to double for given precision assuming biased (floor) representation
   double val(double base) const { return (this->val() + .5) * base; }
 
   // conversion: range based to double for given precision assuming biased (floor) representation, reinterpret sign
   double val(double base, int start, int end = 0, bool twos = false) const {
     return (this->val(start, end, twos) + .5) * base;
   }
 
   // maniplulation and conversion: extracts range based to double reinterpret sign and removes these bits
   double extract(double base, int size, bool twos = false) {
     double val = this->val(base, size, 0, twos);
     this->operator>>=(size);
     return val;
   }
 
   // maniplulation and conversion: extracts range based to int reinterpret sign and removes these bits
   int extract(int size, bool twos = false) {
     int val = this->val(size, 0, twos);
     this->operator>>=(size);
     return val;
   }
 
   // maniplulation and conversion: extracts bool and removes this bit
   bool extract() {
     bool val = bs_[0];
     this->operator>>=(1);
     return val;
   }
 
   // manipulation: extracts slice and removes these bits
   TTBV slice(int size, bool twos = false) {
     TTBV ttBV(*this, size, 0, twos);
     this->operator>>=(size);
     return ttBV;
   }
 
   // range based count of '1's or '0's
   int count(int begin, int end, bool b = true) const {
     int c(0);
     for (int i = begin; i < end; i++)
       if (bs_[i] == b)
         c++;
     return c;
   }
 
   // position of least significant '1' or '0'
   int plEncode(bool b = true) const {
     for (int e = 0; e < size_; e++)
       if (bs_[e] == b)
         return e;
     return size_;
   }
 
   // position of least significant '1' or '0' in range [begin, end)
   int plEncode(int begin, int end, bool b = true) const {
     for (int e = begin; e < end; e++)
       if (bs_.test(e) == b)
         return e;
     return size_;
   }
 
   // position of most significant '1' or '0'
   int pmEncode(bool b = true) const {
     for (int e = size_ - 1; e > -1; e--)
       if (bs_[e] == b)
         return e;
     return size_;
   }
 
   // position of most significant '1' or '0' in range [begin, end)
   int pmEncode(int begin, int end, bool b = true) const {
     for (int e = end - 1; e >= begin; e--)
       if (bs_.test(e) == b)
         return e;
     return end;
   }
 
   // position for n'th '1' or '0' counted from least to most significant bit
   int encode(int n, bool b = true) const {
     int sum(0);
     for (int e = 0; e < size_; e++) {
       if (bs_[e] == b) {
         sum++;
         if (sum == n)
           return e;
       }
     }
     return size_;
   }
 
   std::vector<int> ids(bool b = true, bool singed = false) const {
     std::vector<int> v;
     v.reserve(bs_.count());
     for (int i = 0; i < size_; i++)
       if (bs_[i] == b)
         v.push_back(singed ? i + size_ / 2 : i);
     return v;
   }
 
   friend std::ostream& operator<<(std::ostream& os, const TTBV& ttBV) { return os << ttBV.str(); }
 
 private:
   // look up table initializer for powers of 2
   constexpr std::array<double, S_ + 1> powersOfTwo() const {
     std::array<double, S_ + 1> lut = {};
     for (int i = 0; i <= S_; i++)
       lut[i] = std::pow(2, i);
     return lut;
   }
 
   // returns 2 ** size_
   double iMax() const {
     static const std::array<double, S_ + 1> lut = powersOfTwo();
     return std::round(lut[size_]);
   }
 
   // check if value fits into binary BV
   void checkU(unsigned long long int value) {
     if (size_ <= 0 || size_ > S_)
       throwSize();
     if (value < iMax())
       return;
     cms::Exception exception("RunTimeError.");
     exception << "Value " << value << " does not fit into a " << size_ << "b binary.";
     exception.addContext("TTBV::checkU");
     throw exception;
   }
 
   // check if value fits into twos's complement BV
   void checkT(int value) {
     static const std::array<double, S_ + 1> lut = powersOfTwo();
     auto abs = [](int val) { return val < 0 ? std::abs(val) - 1 : val; };
     if (abs(value) < std::round(lut[size_ - 1]))
       return;
     cms::Exception exception("RunTimeError.");
     exception << "Value " << value << " does not fit into a " << size_ << "b two's complement.";
     exception.addContext("TTBV::checkT");
     throw exception;
   }
 
   // check if value fits into twos complement / binary BV
   void checkI(int value) {
     if (size_ <= 0 || size_ > S_)
       throwSize();
     if (twos_)
       checkT(value);
     else if (value < 0) {
       cms::Exception exception("RunTimeError.");
       exception << size_ << "b Binary TTBV constructor called with negative value (" << value << ").";
       exception.addContext("TTBV::checkI");
       throw exception;
     } else
       checkU(value);
   }
 
   // nonsensical bitwith of smaller equal 0 or unsupported size, bigger 64, deteced
   void throwSize() const {
     cms::Exception exception("RunTimeError.");
     exception << "TTBV constructor called with bad bit width (" << size_ << ").";
     throw exception;
   }
 };
 
 #endif

This page was automatically generated by the 2.2.1 LXR engine. The LXR team