HGCalVFECompressionImpl Class Reference

#include <HGCalVFECompressionImpl.h>

Public Member Functions
void	compress (const std::unordered_map< uint32_t, uint32_t > &, std::unordered_map< uint32_t, std::array< uint64_t, 2 > > &)
void	compressSingle (const uint64_t value, uint32_t &compressedCode, uint64_t &compressedValue) const
	HGCalVFECompressionImpl (const edm::ParameterSet &conf)

Private Attributes
uint32_t	exponentBits_
uint32_t	mantissaBits_
bool	rounding_
uint32_t	saturationCode_
uint64_t	saturationValue_
uint32_t	truncationBits_

Detailed Description

Definition at line 9 of file HGCalVFECompressionImpl.h.

Constructor & Destructor Documentation

HGCalVFECompressionImpl()

HGCalVFECompressionImpl::HGCalVFECompressionImpl

(

const edm::ParameterSet &

conf

)

Definition at line 7 of file HGCalVFECompressionImpl.cc.

References Exception, exponentBits_, mantissaBits_, saturationCode_, saturationValue_, and truncationBits_.

    : exponentBits_(conf.getParameter<uint32_t>("exponentBits")),
      mantissaBits_(conf.getParameter<uint32_t>("mantissaBits")),
      truncationBits_(conf.getParameter<uint32_t>("truncationBits")),
      rounding_(conf.getParameter<bool>("rounding")) {
  if (((1 << exponentBits_) + mantissaBits_ - 1) >= 64) {
    throw cms::Exception("CodespaceCannotFit") << "The code space cannot fit into the unsigned 64-bit space.\n";
  }
  saturationCode_ = (1 << (exponentBits_ + mantissaBits_)) - 1;
  saturationValue_ = (exponentBits_ == 0)
                         ? saturationCode_
                         : ((1ULL << (mantissaBits_ + truncationBits_ + 1)) - 1) << ((1 << exponentBits_) - 2);
}

Member Function Documentation

compress()

void HGCalVFECompressionImpl::compress	(	const std::unordered_map< uint32_t, uint32_t > &	payload,
		std::unordered_map< uint32_t, std::array< uint64_t, 2 > > &	compressed_payload
	)

Definition at line 76 of file HGCalVFECompressionImpl.cc.

References compressSingle(), B2GTnPMonitor_cfi::item, and jetsAK4_Puppi_cff::payload.

                                                                                                               {
  for (const auto& item : payload) {
    const uint64_t value = static_cast<uint64_t>(item.second);
    uint32_t code(0);
    uint64_t compressed_value(0);
    compressSingle(value, code, compressed_value);
    std::array<uint64_t, 2> compressed_item = {{static_cast<uint64_t>(code), compressed_value}};
    compressed_payload.emplace(item.first, compressed_item);
  }
}

compressSingle()

void HGCalVFECompressionImpl::compressSingle	(	const uint64_t	value,
		uint32_t &	compressedCode,
		uint64_t &	compressedValue
	)		const

Definition at line 21 of file HGCalVFECompressionImpl.cc.

References cms::cuda::assert(), HLT_2024v14_cff::exponent, mantissaBits_, rounding_, saturationCode_, saturationValue_, and truncationBits_.

Referenced by HGCalConcentratorCoarsenerImpl::assignCoarseTriggerCellEnergy(), compress(), and HGCalConcentratorSuperTriggerCellImpl::getCompressedSTCEnergy().

                                                                              {
  // check for saturation
  if (value > saturationValue_) {
    compressedCode = saturationCode_;
    compressedValue = saturationValue_;
    return;
  }

  // count bit length
  uint32_t bitlen;
  uint64_t shifted_value = value >> truncationBits_;
  uint64_t valcopy = shifted_value;
  for (bitlen = 0; valcopy != 0; valcopy >>= 1, bitlen++) {
  }
  if (bitlen <= mantissaBits_) {
    compressedCode = shifted_value;
    compressedValue = shifted_value << truncationBits_;
    return;
  }

  // build exponent and mantissa
  const uint32_t exponent = bitlen - mantissaBits_;
  assert(exponent - 1 < 64);
  const uint64_t mantissa = (shifted_value >> (exponent - 1)) & ~(1ULL << mantissaBits_);

  // assemble floating-point
  const uint32_t floatval = (exponent << mantissaBits_) | mantissa;

  // we will never want to round up maximum code here
  // Also, rounding doesn't apply if exponent==1 since there is no actual compression
  // from the conversion to floating point in that case
  if (!rounding_ || floatval == saturationCode_ || exponent <= 1) {
    compressedCode = floatval;
    compressedValue = ((1ULL << mantissaBits_) | mantissa) << (exponent - 1);
  } else {
    const bool roundup = ((shifted_value >> (exponent - 2)) & 1ULL) == 1ULL;
    if (!roundup) {
      compressedCode = floatval;
      compressedValue = ((1ULL << mantissaBits_) | mantissa) << (exponent - 1);
    } else {
      compressedCode = floatval + 1;
      uint64_t rmantissa = mantissa + 1;
      uint32_t rexponent = exponent;
      if (rmantissa >= (1ULL << mantissaBits_)) {
        rexponent++;
        rmantissa &= ~(1ULL << mantissaBits_);
      }
      compressedValue = ((1ULL << mantissaBits_) | rmantissa) << (rexponent - 1);
    }
  }
  compressedValue <<= truncationBits_;
}

Member Data Documentation

exponentBits_

uint32_t HGCalVFECompressionImpl::exponentBits_

private

Definition at line 17 of file HGCalVFECompressionImpl.h.

Referenced by HGCalVFECompressionImpl().

mantissaBits_

uint32_t HGCalVFECompressionImpl::mantissaBits_

private

Definition at line 18 of file HGCalVFECompressionImpl.h.

Referenced by compressSingle(), and HGCalVFECompressionImpl().

rounding_

bool HGCalVFECompressionImpl::rounding_

private

Definition at line 20 of file HGCalVFECompressionImpl.h.

Referenced by compressSingle().

saturationCode_

uint32_t HGCalVFECompressionImpl::saturationCode_

private

Definition at line 21 of file HGCalVFECompressionImpl.h.

Referenced by compressSingle(), and HGCalVFECompressionImpl().

saturationValue_

uint64_t HGCalVFECompressionImpl::saturationValue_

private

Definition at line 22 of file HGCalVFECompressionImpl.h.

Referenced by compressSingle(), and HGCalVFECompressionImpl().

truncationBits_

uint32_t HGCalVFECompressionImpl::truncationBits_

private

Definition at line 19 of file HGCalVFECompressionImpl.h.

Referenced by compressSingle(), and HGCalVFECompressionImpl().