L1MuScale.h

Go to the documentation of this file.

//-------------------------------------------------
//
//   \class L1MuScale
//
//   Description:  A Scale for use in the L1 muon trigger
//
//
//
//   $Date: 2011/05/30 04:59:35 $
//   $Revision: 1.8 $
//
//   Original Author :
//   Hannes Sakulin      HEPHY / Vienna
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------
#ifndef CondFormatsL1TObjects_L1MuScale_h
#define CondFormatsL1TObjects_L1MuScale_h

#include "CondFormats/Serialization/interface/Serializable.h"

#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <cmath>
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "CondFormats/L1TObjects/interface/L1MuPacking.h"

class L1MuScale {
public:
  L1MuScale() {}

  virtual ~L1MuScale() {}

  virtual float getCenter(unsigned packed) const = 0;

  virtual float getLowEdge(unsigned packed) const = 0;

  virtual float getHighEdge(unsigned packed) const = 0;

  virtual float getScaleMax() const = 0;

  virtual float getScaleMin() const = 0;

  virtual unsigned getPacked(float value) const = 0;

  virtual unsigned getNBins() const = 0;

  virtual float getValue(unsigned i) const = 0;

  virtual std::string print() const = 0;

private:
  COND_SERIALIZABLE;
};

//
// define default scale implementations
//

class L1MuBinnedScale : public L1MuScale {
public:
  L1MuBinnedScale() : m_nbits(0), m_signedPacking(false), m_NBins(0), m_idxoffset(0) {}

  //  L1MuBinnedScale(unsigned int nbits, bool signedPacking, int NBins, const float* Scale, int idx_offset=0)
  L1MuBinnedScale(
      unsigned int nbits, bool signedPacking, int NBins, const std::vector<double>& Scale, int idx_offset = 0)
      : m_nbits(nbits), m_signedPacking(signedPacking) {
    m_NBins = NBins;
    m_idxoffset = idx_offset;

    m_Scale.reserve(m_NBins + 1);
    for (int i = 0; i < m_NBins + 1; i++)
      //m_Scale[i] = Scale[i];
      m_Scale.push_back(Scale[i]);
  };

  L1MuBinnedScale(unsigned int nbits, bool signedPacking, int NBins, float xmin, float xmax, int idx_offset = 0)
      : m_nbits(nbits), m_signedPacking(signedPacking) {
    m_NBins = NBins;
    m_idxoffset = idx_offset;

    m_Scale.reserve(m_NBins + 1);
    for (int i = 0; i < m_NBins + 1; i++)
      //      m_Scale[i] = xmin + i * (xmax-xmin) / m_NBins;
      m_Scale.push_back(xmin + i * (xmax - xmin) / m_NBins);
  };

  ~L1MuBinnedScale() override {
    //    delete m_packing;
  };

  float getCenter(unsigned packed) const override {
    int idx = get_idx(packed);
    return (m_Scale[idx] + m_Scale[idx + 1]) / 2.;
  };

  float getLowEdge(unsigned packed) const override { return m_Scale[get_idx(packed)]; };

  float getHighEdge(unsigned packed) const override { return m_Scale[get_idx(packed) + 1]; };


  unsigned getPacked(float value) const override {
    if (value < m_Scale[0] || value > m_Scale[m_NBins])
      edm::LogWarning("ScaleRangeViolation")
          << "L1MuBinnedScale::getPacked: value out of scale range: " << value << std::endl;
    int idx = 0;
    if (value < m_Scale[0])
      idx = 0;
    else if (value >= m_Scale[m_NBins])
      idx = m_NBins - 1;
    else {
      for (; idx < m_NBins; idx++)
        if (value >= m_Scale[idx] && value < m_Scale[idx + 1])
          break;
    }

    return (m_signedPacking ? L1MuSignedPackingGeneric::packedFromIdx(idx - m_idxoffset, m_nbits)
                            : L1MuUnsignedPackingGeneric::packedFromIdx(idx - m_idxoffset, m_nbits));
  };

  float getScaleMax() const override { return m_Scale[m_NBins]; }

  float getScaleMin() const override { return m_Scale[0]; }

  unsigned getNBins() const override { return m_NBins; }

  float getValue(unsigned i) const override { return m_Scale[i]; }

  std::string print() const override {
    std::ostringstream str;

    str << " ind |   low edge |     center |  high edge" << std::endl;
    str << "-------------------------------------------" << std::endl;
    for (int i = 0; i < m_NBins; i++) {
      unsigned int ipack = getPacked(m_Scale[i]);
      str << std::setw(4) << ipack << " | " << std::setw(10) << getLowEdge(ipack) << " | " << std::setw(10)
          << getCenter(ipack) << " | " << std::setw(10) << getHighEdge(ipack) << std::endl;
    }

    return str.str();
  }

protected:
  int get_idx(unsigned packed) const {
    int idxFromPacked = m_signedPacking ? L1MuSignedPackingGeneric::idxFromPacked(packed, m_nbits)
                                        : L1MuUnsignedPackingGeneric::idxFromPacked(packed, m_nbits);
    int idx = idxFromPacked + m_idxoffset;
    if (idx < 0)
      idx = 0;
    if (idx >= m_NBins)
      idx = m_NBins - 1;
    return idx;
  }

  unsigned int m_nbits;
  bool m_signedPacking;
  int m_NBins;
  int m_idxoffset;
  std::vector<float> m_Scale;

  COND_SERIALIZABLE;
};

class L1MuSymmetricBinnedScale : public L1MuScale {
public:

  L1MuSymmetricBinnedScale() : m_NBins(0) {}

  //  L1MuSymmetricBinnedScale(int nbits, int NBins, const float* Scale)
  L1MuSymmetricBinnedScale(int nbits, int NBins, const std::vector<double>& Scale)
      : m_packing(L1MuPseudoSignedPacking(nbits)) {
    m_NBins = NBins;
    m_Scale.reserve(m_NBins + 1);
    for (int i = 0; i < m_NBins + 1; i++)
      //      m_Scale[i] = Scale[i];
      m_Scale.push_back(Scale[i]);
  };

  L1MuSymmetricBinnedScale(int nbits, int NBins, float xmin, float xmax) : m_packing(L1MuPseudoSignedPacking(nbits)) {
    m_NBins = NBins;
    m_Scale.reserve(m_NBins + 1);
    for (int i = 0; i < m_NBins + 1; i++)
      //      m_Scale[i] = xmin + i * (xmax-xmin) / m_NBins;
      m_Scale.push_back(xmin + i * (xmax - xmin) / m_NBins);
  };

  ~L1MuSymmetricBinnedScale() override {
    //    delete m_packing;
  };

  float getCenter(unsigned packed) const override {
    int absidx = abs(m_packing.idxFromPacked(packed));
    if (absidx >= m_NBins)
      absidx = m_NBins - 1;
    float center = (m_Scale[absidx] + m_Scale[absidx + 1]) / 2.;
    float fsign = m_packing.signFromPacked(packed) == 0 ? 1. : -1.;
    return center * fsign;
  };

  float getLowEdge(unsigned packed) const override {  // === edge towards 0
    int absidx = abs(m_packing.idxFromPacked(packed));
    if (absidx >= m_NBins)
      absidx = m_NBins - 1;
    float low = m_Scale[absidx];
    float fsign = m_packing.signFromPacked(packed) == 0 ? 1. : -1.;
    return low * fsign;
  };

  float getHighEdge(unsigned packed) const override {
    edm::LogWarning("NotImplemented") << "L1MuSymmetricBinnedScale::getHighEdge not implemented" << std::endl;
    return 0;
  };

  unsigned getPacked(float value) const override {
    float absval = fabs(value);
    if (absval < m_Scale[0] || absval > m_Scale[m_NBins])
      edm::LogWarning("ScaleRangeViolation")
          << "L1MuSymmetricBinnedScale::getPacked: value out of scale range!!! abs(val) = " << absval
          << " min= " << m_Scale[0] << " max = " << m_Scale[m_NBins] << std::endl;
    int idx = 0;
    for (; idx < m_NBins; idx++)
      if (absval >= m_Scale[idx] && absval < m_Scale[idx + 1])
        break;
    if (idx >= m_NBins)
      idx = m_NBins - 1;
    return m_packing.packedFromIdx(idx, (value >= 0) ? 0 : 1);
  };
  float getScaleMax() const override { return m_Scale[m_NBins]; }

  float getScaleMin() const override { return m_Scale[0]; }

  unsigned getNBins() const override { return m_NBins; }

  float getValue(unsigned i) const override { return m_Scale[i]; }

  std::string print() const override {
    std::ostringstream str;

    str << " ind |   low edge |     center" << std::endl;
    str << "-------------------------------------------" << std::endl;
    for (int i = 0; i < m_NBins; i++) {
      unsigned int ipack = getPacked(m_Scale[i]);
      str << std::setw(4) << ipack << " | " << std::setw(10) << getLowEdge(ipack) << " | " << std::setw(10)
          << getCenter(ipack) << std::endl;
    }

    return str.str();
  }

protected:
  L1MuPseudoSignedPacking m_packing;
  int m_NBins;
  std::vector<float> m_Scale;

  COND_SERIALIZABLE;
};
#endif