HGCUncalibratedRecHit.cc

Go to the documentation of this file.

#include "DataFormats/HGCRecHit/interface/HGCUncalibratedRecHit.h"
#include <cmath>
 
HGCUncalibratedRecHit::HGCUncalibratedRecHit()
    : amplitude_(0.),
      pedestal_(0.),
      jitter_(0.),
      chi2_(10000.),
      OOTamplitude_(0.),
      OOTchi2_(10000.),
      flags_(0),
      aux_(0) {}
 
HGCUncalibratedRecHit::HGCUncalibratedRecHit(
    const DetId& id, float ampl, float ped, float jit, float chi2, uint32_t flags, uint32_t aux)
    : amplitude_(ampl),
      pedestal_(ped),
      jitter_(jit),
      chi2_(chi2),
      OOTamplitude_(0.),
      OOTchi2_(10000.),
      flags_(flags),
      aux_(aux),
      id_(id) {}
 
HGCUncalibratedRecHit::~HGCUncalibratedRecHit() {}
 
bool HGCUncalibratedRecHit::isSaturated() const { return HGCUncalibratedRecHit::checkFlag(kSaturated); }
 
float HGCUncalibratedRecHit::jitterError() const {
  // stored in ps, but return BXs to match with jitter units
  uint32_t jitterErrorBits = 0xFF & aux_;
  // all bits off --> time reco bailed out (return negative value)
  if ((0xFF & jitterErrorBits) == 0x00)
    return -1;
  // all bits on  --> time error over 5 ns (return large value)
  if ((0xFF & jitterErrorBits) == 0xFF)
    return 10000;
 
  float LSB = 1.26008;
  uint8_t exponent = jitterErrorBits >> 5;
  uint8_t significand = jitterErrorBits & ~(0x7 << 5);
  return (float)(pow(2., exponent) * significand * LSB) / (25. * 1000);
}
 
void HGCUncalibratedRecHit::setJitterError(float jitterErr) {
  // use 8 bits (3 exp, 5 mant) and store in ps
  // has range of 5 ps - 5000 ps
  // expect input in BX units
  // all bits off --> time reco bailed out
  if (jitterErr < 0) {
    aux_ = (~0xFF & aux_);
    return;
  }
  // all bits on  --> time error over 5 ns
  if (25 * jitterErr >= 5) {
    aux_ = (0xFF | aux_);
    return;
  }
 
  float LSB = 1.26008;
  float quantityInLSB = (1000 * 25 * jitterErr) / LSB;
  int log2OfQuantity = (int)(log2(quantityInLSB));
  int exponentTmp = log2OfQuantity - 4;
  uint8_t exponent = 0;
  if (exponentTmp > 0)
    exponent = exponentTmp;
  uint8_t significand = (int)(lround(quantityInLSB / pow(2., exponent)));
  uint32_t jitterErrorBits = exponent << 5 | significand;
 
  if ((0xFF & jitterErrorBits) == 0xFF)
    jitterErrorBits = 0xFE;
  if ((0xFF & jitterErrorBits) == 0x00)
    jitterErrorBits = 0x01;
 
  aux_ = (~0xFF & aux_) | (jitterErrorBits & 0xFF);
}
 
bool HGCUncalibratedRecHit::isJitterValid() const {
  if (jitterError() <= 0)
    return false;
  else
    return true;
}
 
bool HGCUncalibratedRecHit::isJitterErrorValid() const {
  if (!isJitterValid())
    return false;
  if (jitterError() >= 10000)
    return false;
 
  return true;
}
 
uint8_t HGCUncalibratedRecHit::jitterErrorBits() const {
  uint8_t jitterErrorBits = 0xFF & aux_;
  return jitterErrorBits;
}
 
void HGCUncalibratedRecHit::setFlagBit(HGCUncalibratedRecHit::Flags flag) {
  if (flag == kGood) {
    //then set all bits to zero;
    flags_ = 0;
    return;
  }
  // else set the flagbit
  flags_ |= 0x1 << flag;
}
 
bool HGCUncalibratedRecHit::checkFlag(HGCUncalibratedRecHit::Flags flag) const {
  if (flag == kGood) {
    if (!flags_)
      return true;
    else
      return false;
  }  // if all flags are unset, then hit is good
  return flags_ & (0x1 << flag);
}