L1MuScale.h

Go to the documentation of this file.

//-------------------------------------------------
//
//   \class L1MuScale
//
//   Description:  A Scale for use in the L1 muon trigger
//                 
//                  
//                
//   $Date: 2008/04/16 23:25:10 $
//   $Revision: 1.6 $ 
//
//   Original Author :
//   Hannes Sakulin      HEPHY / Vienna
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------
#ifndef CondFormatsL1TObjects_L1MuScale_h
#define CondFormatsL1TObjects_L1MuScale_h

#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <math.h>
#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:
};

//
// define default scale implementations
//


class L1MuBinnedScale : public L1MuScale {
 public:

      L1MuBinnedScale() {}

    //  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 ) ;
  };

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

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

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

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

  virtual unsigned getPacked(float value) const {
    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) ) ;
  };

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

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

  virtual unsigned getNBins() const { return m_NBins; }

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

  virtual std::string print() const {
    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;
};

class L1MuSymmetricBinnedScale : public L1MuScale {
 public:
  

      L1MuSymmetricBinnedScale() {}

    //  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 ) ;
  };

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

  virtual float getCenter(unsigned packed) const {
    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;
  };

  virtual float getLowEdge(unsigned packed) const{ // === 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;
  };

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

  virtual unsigned getPacked(float value) const {
    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);
  };
  virtual float getScaleMax() const { return m_Scale[m_NBins]; }

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

  virtual unsigned getNBins() const { return m_NBins; }

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

  virtual std::string print() const {
    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;
};
#endif