Cordic Class Reference

#include <Cordic.h>

Public Member Functions
	Cordic (const uint32_t &aPhiScale, const uint32_t &aMagnitudeBits, const uint32_t &aSteps)
	Cordic ()
	Cordic (const int aSteps, bool debug)
template<typename T >
void	cordic_subfunc (T &x, T &y, T &z) const
int32_t	IntegerizeMagnitude (const double &aMagnitude) const
double	NormalizeMagnitude (const uint32_t &aMagnitude) const
double	NormalizePhi (const uint32_t &aPhi) const
void	operator() (int32_t aX, int32_t aY, int32_t &aPhi, uint32_t &aMagnitude) const
l1tmetemu::EtMiss	toPolar (l1tmetemu::Et_t x, l1tmetemu::Et_t y) const
virtual	~Cordic ()

Private Member Functions
uint32_t	tower (const double &aRadians) const

Private Attributes
std::vector< l1tmetemu::atan_lut_fixed_t >	atanLUT
const int	cordicSteps
const bool	debug
std::vector< l1tmetemu::atan_lut_fixed_t >	magNormalisationLUT
uint32_t	mMagnitudeBits
uint64_t	mMagnitudeRenormalization
uint32_t	mMagnitudeScale
uint32_t	mPhiScale
const double	mPi
std::vector< uint32_t >	mRotations
uint32_t	mSteps

Detailed Description

Definition at line 7 of file Cordic.h.

Constructor & Destructor Documentation

Cordic() [1/3]

Cordic::Cordic	(	const uint32_t &	aPhiScale,
		const uint32_t &	aMagnitudeBits,
		const uint32_t &	aSteps
	)

Definition at line 9 of file Cordic.cc.

References mMagnitudeRenormalization, mMagnitudeScale, mRotations, mSteps, funct::pow(), mathSSE::sqrt(), and tower().

    : mPhiScale(aPhiScale),
      mMagnitudeScale(1 << aMagnitudeBits),
      mMagnitudeBits(aMagnitudeBits),
      mSteps(aSteps),
      mPi(3.1415926535897932384626433832795) {
  mRotations.reserve(mSteps);

  double lValue(1.0);

  for (uint32_t lStep(0); lStep != mSteps; ++lStep) {
    lValue /= sqrt(1.0 + pow(4.0, -double(lStep)));
    mRotations.push_back(tower(atan(pow(2.0, -double(lStep)))));
  }
  mMagnitudeRenormalization = uint32_t(round(mMagnitudeScale * lValue));
}

~Cordic()

Cordic::~Cordic ( )

virtual

Definition at line 26 of file Cordic.cc.

{}

Cordic() [2/3]

Cordic::Cordic

(

)

Cordic() [3/3]

Cordic::Cordic	(	const int	aSteps,
		bool	debug
	)

Definition at line 9 of file Cordic.cc.

References atanLUT, debug, mps_fire::i, dqmiolumiharvest::j, magNormalisationLUT, funct::pow(), and heppy_batch::val.

                                           : cordicSteps(aSteps), debug(debug) {
  atanLUT.reserve(aSteps);
  magNormalisationLUT.reserve(aSteps);

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator") << "=====atan LUT=====";
  }

  for (int i = 0; i < aSteps; i++) {
    atanLUT.push_back(l1tmetemu::atan_lut_fixed_t(atan(pow(2, -i))));
    if (debug) {
      edm::LogVerbatim("L1TkEtMissEmulator") << atanLUT[i] << " | ";
    }
  }
  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator") << "\n=====Normalisation LUT=====";
  }

  double val = 1.0;
  for (int j = 0; j < aSteps; j++) {
    val = val / (pow(1 + pow(4, -j), 0.5));
    magNormalisationLUT.push_back(l1tmetemu::atan_lut_fixed_t(val));
    if (debug) {
      edm::LogVerbatim("L1TkEtMissEmulator") << magNormalisationLUT[j] << " | ";
    }
  }
}

Member Function Documentation

cordic_subfunc()

template<typename T >

void Cordic::cordic_subfunc	(	T &	x,
		T &	y,
		T &	z
	)		const

Definition at line 38 of file Cordic.cc.

References atanLUT, cordicSteps, debug, l1tmetemu::kStepMETwordPhi, magNormalisationLUT, x, y, and z.

Referenced by toPolar().

                                                  {
  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator") << "\n=====Cordic Initial Conditions=====\n"
                                           << "Cordic x: " << x << " Cordic y: " << y << " Cordic z: " << z << "\n"
                                           << "\n=====Cordic Steps=====";
  }

  T tx, ty, tz;

  for (int step = 0; step < cordicSteps; step++) {
    if (y < 0) {
      tx = x - (y >> step);
      ty = y + (x >> step);
      tz = z - atanLUT[step];
    } else {
      tx = x + (y >> step);
      ty = y - (x >> step);
      tz = z + atanLUT[step];
    }

    x = tx;
    y = ty;
    z = tz;

    if (debug) {
      edm::LogVerbatim("L1TkEtMissEmulator")
          << "Cordic x: " << x << " Cordic y: " << y << " Cordic phi: " << z << "\n"
          << " Cordic gain: " << magNormalisationLUT[step] << " kStepMETwordPhi: " << kStepMETwordPhi << "\n";
    }
  }
}

IntegerizeMagnitude()

int32_t Cordic::IntegerizeMagnitude

(

const double &

aMagnitude

)

const

Definition at line 34 of file Cordic.cc.

References mMagnitudeScale.

{ return int32_t(aMagnitude * mMagnitudeScale); }

NormalizeMagnitude()

double Cordic::NormalizeMagnitude

(

const uint32_t &

aMagnitude

)

const

Definition at line 30 of file Cordic.cc.

References mMagnitudeScale.

                                                                  {
  return double(aMagnitude) / double(mMagnitudeScale);
}

NormalizePhi()

double Cordic::NormalizePhi

(

const uint32_t &

aPhi

)

const

Definition at line 28 of file Cordic.cc.

References simKBmtfDigis_cfi::aPhi, and mPhiScale.

{ return double(aPhi) / double(mPhiScale); }

operator()()

void Cordic::operator()	(	int32_t	aX,
		int32_t	aY,
		int32_t &	aPhi,
		uint32_t &	aMagnitude
	)		const

Definition at line 38 of file Cordic.cc.

References simKBmtfDigis_cfi::aPhi, mMagnitudeBits, mMagnitudeRenormalization, mPi, mRotations, mSteps, tower(), testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::x2.

                                                                                         {
  bool lSign(true);

  switch (((aY >= 0) ? 0x0 : 0x2) | ((aX >= 0) ? 0x0 : 0x1)) {
    case 0:
      aPhi = tower(mPi);
      break;
    case 1:
      aPhi = tower(2 * mPi);
      lSign = false;
      aX = -aX;
      break;
    case 2:
      aPhi = tower(mPi);
      lSign = false;
      aY = -aY;
      break;
    case 3:
      aPhi = 0;
      aX = -aX;
      aY = -aY;
      break;
    default:
      throw 0;
  }

  for (uint32_t lStep(0); lStep != mSteps; ++lStep) {
    if ((aY < 0) == lSign) {
      aPhi -= mRotations[lStep];
    } else {
      aPhi += mRotations[lStep];
    }

    int32_t lX(aX), lY(aY);
    if (lY < 0) {
      aX = lX - (lY >> lStep);
      aY = lY + (lX >> lStep);
    } else {
      aX = lX + (lY >> lStep);
      aY = lY - (lX >> lStep);
    }
  }

  aMagnitude = (aX * mMagnitudeRenormalization) >> mMagnitudeBits;
}

toPolar()

EtMiss Cordic::toPolar	(	l1tmetemu::Et_t	x,
		l1tmetemu::Et_t	y
	)		const

Definition at line 70 of file Cordic.cc.

References cordic_subfunc(), cordicSteps, debug, l1tmetemu::EtMiss::Et, mps_fire::i, l1tmetemu::kBinsInPi, l1tmetemu::kStepMETwordPhi, M_PI, magNormalisationLUT, l1tmetemu::EtMiss::Phi, pi, pi2, ApeEstimator_cff::width, x, and y.

                                           {
  EtMiss ret_etmiss;

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator") << "\n=====toPolar input=====\n"
                                           << "x: " << x << " y: " << y;
  }

  // Some needed constants
  const ap_fixed<l1tmetemu::Et_t::width + 1, 3> pi = M_PI;                   // pi
  const ap_fixed<l1tmetemu::Et_t::width + 2, 3> pi2 = M_PI / 2.;             // pi/2
  const l1tmetemu::METWordphi_t pistep = M_PI / l1tmetemu::kStepMETwordPhi;  // (pi) / l1tmetemu::kStepMETwordPhi
  const l1tmetemu::METWordphi_t pi2step = pistep / 2.;                       // (pi/2) / l1tmetemu::kStepMETwordPhi

  // Find the sign of the inputs
  ap_uint<2> signx = (x > 0) ? 2 : (x == 0) ? 1 : 0;
  ap_uint<2> signy = (y > 0) ? 2 : (y == 0) ? 1 : 0;

  // Corner cases
  if (signy == 1 && signx == 2) {  // y == 0 and x > 0
    ret_etmiss.Et = x;
    ret_etmiss.Phi = 0;
    return ret_etmiss;
  } else if (signy == 1 && signx == 0) {  // y == 0 and x < 0
    ret_etmiss.Et = -x;
    ret_etmiss.Phi = pistep;
    return ret_etmiss;
  } else if (signy == 2 && signx == 1) {  // y > 0 and x == 0
    ret_etmiss.Et = y;
    ret_etmiss.Phi = pi2step;
    return ret_etmiss;
  } else if (signy == 0 && signx == 1) {  // y < 0 and x == 0
    ret_etmiss.Et = -y;
    ret_etmiss.Phi = -pi2step;
    return ret_etmiss;
  }

  // Take absolute values to operate on the range (0, pi/2)
  ap_fixed<Et_t::width + 1, Et_t::iwidth + 1, Et_t::qmode, Et_t::omode> absx, absy;
  if (signy == 0) {
    absy = -y;
  } else {
    absy = y;
  }

  if (signx == 0) {
    absx = -x;
  } else {
    absx = x;
  }

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator") << "\n=====Abs input=====\n"
                                           << "abs(x): " << absx.to_double() << " abs(y): " << absy.to_double();
  }

  // Normalization (operate on a unit circle)
  ap_fixed<Et_t::width + 1, 2, Et_t::qmode, Et_t::omode> absx_sft, absy_sft;
  for (int i = 0; i < Et_t::width + 1; i++) {
    absx_sft[i] = absx[i];
    absy_sft[i] = absy[i];
  }

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator")
        << "\n=====Normalized input=====\n"
        << "norm(abs(x)): " << absx_sft.to_double() << " norm(abs(y)): " << absy_sft.to_double();
  }

  // Setup the CORDIC inputs/outputs
  ap_fixed<Et_t::width + 7, 3, Et_t::qmode, Et_t::omode> cx, cy, cphi;
  if (absy > absx) {
    cx = absy_sft;
    cy = absx_sft;
    cphi = 0;
  } else {
    cx = absx_sft;
    cy = absy_sft;
    cphi = 0;
  }

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator")
        << "\n=====CORDIC function arguments=====\n"
        << "x: " << cx.to_double() << " y: " << cy.to_double() << " phi: " << cphi.to_double();
  }

  // Perform the CORDIC (vectoring) function
  cordic_subfunc(cx, cy, cphi);

  // Reorient the outputs to their appropriate quadrant
  if (absy > absx) {
    cphi = pi2 - cphi;
  }

  ap_fixed<Et_t::width, 3, Et_t::qmode, Et_t::omode> ophi;
  if (signx == 0 && signy == 2) {  // x < 0 and y > 0
    ophi = pi - cphi;
  } else if (signx == 0 && signy == 0) {  // x < 0 and y < 0
    ophi = cphi - pi;
  } else if (signx == 2 && signy == 0) {  // x > 0 and y < 0
    ophi = -cphi;
  } else {
    ophi = cphi;
  }

  // Re-scale the outputs
  Et_t magnitude = ((ap_fixed<Et_t::width + Et_t::iwidth + 3 + 1, Et_t::iwidth, Et_t::qmode, Et_t::omode>)cx)
                   << (Et_t::iwidth + 1 - 2);
  ret_etmiss.Et = l1tmetemu::Et_t(magnitude * magNormalisationLUT[cordicSteps - 1]);
  ret_etmiss.Phi = ophi * pi_bins_fixed_t(kBinsInPi);

  if (debug) {
    edm::LogVerbatim("L1TkEtMissEmulator")
        << "\n=====toPolar output=====\n"
        << std::setprecision(8) << "magnitude: " << magnitude.to_double() << " phi: " << ophi.to_double()
        << " kBinsInPi: " << pi_bins_fixed_t(kBinsInPi).to_double() << "\n"
        << "Et: " << ret_etmiss.Et.to_double() << " phi (int): " << ret_etmiss.Phi.to_int() << "\n";
  }

  return ret_etmiss;
}

tower()

uint32_t Cordic::tower ( const double &  aRadians ) const

private

Definition at line 36 of file Cordic.cc.

References mPhiScale, and mPi.

Referenced by Cordic(), and operator()().

{ return uint32_t(round(mPhiScale * 0.5 * aRadians / mPi)); }

Member Data Documentation

atanLUT

std::vector<l1tmetemu::atan_lut_fixed_t> Cordic::atanLUT

private

Definition at line 30 of file Cordic.h.

Referenced by Cordic(), and cordic_subfunc().

cordicSteps

const int Cordic::cordicSteps

private

Definition at line 25 of file Cordic.h.

Referenced by cordic_subfunc(), and toPolar().

debug

const bool Cordic::debug

private

Definition at line 27 of file Cordic.h.

Referenced by Cordic(), cordic_subfunc(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), and toPolar().

magNormalisationLUT

std::vector<l1tmetemu::atan_lut_fixed_t> Cordic::magNormalisationLUT

private

Definition at line 32 of file Cordic.h.

Referenced by Cordic(), cordic_subfunc(), and toPolar().

mMagnitudeBits

uint32_t Cordic::mMagnitudeBits

private

Definition at line 24 of file Cordic.h.

Referenced by operator()().

mMagnitudeRenormalization

uint64_t Cordic::mMagnitudeRenormalization

private

Definition at line 26 of file Cordic.h.

Referenced by Cordic(), and operator()().

mMagnitudeScale

uint32_t Cordic::mMagnitudeScale

private

Definition at line 23 of file Cordic.h.

Referenced by Cordic(), IntegerizeMagnitude(), and NormalizeMagnitude().

mPhiScale

uint32_t Cordic::mPhiScale

private

Definition at line 22 of file Cordic.h.

Referenced by NormalizePhi(), and tower().

mPi

const double Cordic::mPi

private

Definition at line 29 of file Cordic.h.

Referenced by operator()(), and tower().

mRotations

std::vector<uint32_t> Cordic::mRotations

private

Definition at line 27 of file Cordic.h.

Referenced by Cordic(), and operator()().

mSteps

uint32_t Cordic::mSteps

private

Definition at line 25 of file Cordic.h.

Referenced by Cordic(), and operator()().