fftjetcms::LinInterpolatedTable1D Class Reference

#include <LinInterpolatedTable1D.h>

Inheritance diagram for fftjetcms::LinInterpolatedTable1D:

Public Member Functions
const double *	data () const
std::unique_ptr< LinInterpolatedTable1D >	inverse (unsigned npoints, bool leftExtrapolationLinear, bool rightExtrapolationLinear) const
bool	isMonotonous () const
bool	leftExtrapolationLinear () const
template<typename RealN >
	LinInterpolatedTable1D (const RealN *data, unsigned npoints, double x_min, double x_max, bool leftExtrapolationLinear, bool rightExtrapolationLinear)
template<typename RealN >
	LinInterpolatedTable1D (const std::vector< std::pair< RealN, RealN > > &v, unsigned npoints, bool leftExtrapolationLinear, bool rightExtrapolationLinear)
	LinInterpolatedTable1D (double c)
unsigned	npoints () const
bool	operator!= (const LinInterpolatedTable1D &r) const
double	operator() (const double &x) const override
bool	operator== (const LinInterpolatedTable1D &r) const
bool	rightExtrapolationLinear () const
double	xmax () const
double	xmin () const
	~LinInterpolatedTable1D () override

Static Private Member Functions
static double	interpolateSimple (const double x0, const double x1, const double y0, const double y1, const double x)

Private Attributes
double	binwidth_
std::vector< double >	data_
bool	leftExtrapolationLinear_
bool	monotonicityKnown_
bool	monotonous_
unsigned	npoints_
bool	rightExtrapolationLinear_
double	xmax_
double	xmin_

Detailed Description

Definition at line 24 of file LinInterpolatedTable1D.h.

Constructor & Destructor Documentation

LinInterpolatedTable1D() [1/3]

template<typename RealN >

fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D ( const RealN *  data, unsigned  npoints, double  x_min, double  x_max, bool  leftExtrapolationLinear, bool  rightExtrapolationLinear  )

inline

Definition at line 108 of file LinInterpolatedTable1D.h.

      : data_(data, data + npoints),
        xmin_(x_min),
        xmax_(x_max),
        binwidth_((x_max - x_min) / (npoints - 1U)),
        npoints_(npoints),
        leftExtrapolationLinear_(leftExtrapolationLinear),
        rightExtrapolationLinear_(rightExtrapolationLinear),
        monotonous_(false),
        monotonicityKnown_(false) {
    if (!data)
      throw cms::Exception("FFTJetBadConfig") << "No data configured" << std::endl;
    if (npoints <= 1U)
      throw cms::Exception("FFTJetBadConfig") << "Not enough data points" << std::endl;
  }

References data(), Exception, npoints(), and mitigatedMETSequence_cff::U.

LinInterpolatedTable1D() [2/3]

template<typename RealN >

fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D	(	const std::vector< std::pair< RealN, RealN > > &	v,
		unsigned	npoints,
		bool	leftExtrapolationLinear,
		bool	rightExtrapolationLinear
	)

Definition at line 130 of file LinInterpolatedTable1D.h.

      : xmin_(v[0].first),
        xmax_(v[v.size() - 1U].first),
        binwidth_((xmax_ - xmin_) / (npoints - 1U)),
        npoints_(npoints),
        leftExtrapolationLinear_(leftExtrapolationLinear),
        rightExtrapolationLinear_(rightExtrapolationLinear),
        monotonous_(false),
        monotonicityKnown_(false) {
    const unsigned len = v.size();
    if (len <= 1U)
      throw cms::Exception("FFTJetBadConfig") << "Not enough data for interpolation" << std::endl;
 
    if (npoints <= 1U)
      throw cms::Exception("FFTJetBadConfig") << "Not enough interpolation table entries" << std::endl;
 
    const std::pair<RealN, RealN>* vdata = &v[0];
    for (unsigned i = 1; i < len; ++i)
      if (vdata[i - 1U].first >= vdata[i].first)
        throw cms::Exception("FFTJetBadConfig") << "Input data is not sorted properly" << std::endl;
 
    unsigned shift = 0U;
    if (leftExtrapolationLinear) {
      ++npoints_;
      xmin_ -= binwidth_;
      shift = 1U;
    }
    if (rightExtrapolationLinear) {
      ++npoints_;
      xmax_ += binwidth_;
    }
 
    data_.resize(npoints_);
 
    if (leftExtrapolationLinear) {
      data_[0] = interpolateSimple(vdata[0].first, vdata[1].first, vdata[0].second, vdata[1].second, xmin_);
    }
    if (rightExtrapolationLinear) {
      data_[npoints_ - 1U] = interpolateSimple(
          vdata[len - 2U].first, vdata[len - 1U].first, vdata[len - 2U].second, vdata[len - 1U].second, xmax_);
    }
 
    data_[shift] = vdata[0].second;
    data_[npoints - 1U + shift] = vdata[len - 1U].second;
    unsigned ibelow = 0, iabove = 1;
    for (unsigned i = 1; i < npoints - 1; ++i) {
      const double x = xmin_ + (i + shift) * binwidth_;
      while (static_cast<double>(v[iabove].first) <= x) {
        ++ibelow;
        ++iabove;
      }
      if (v[ibelow].first == v[iabove].first)
        data_[i + shift] = (v[ibelow].second + v[iabove].second) / 2.0;
      else
        data_[i + shift] = interpolateSimple(v[ibelow].first, v[iabove].first, v[ibelow].second, v[iabove].second, x);
    }
  }

References binwidth_, data_, Exception, first, mps_fire::i, interpolateSimple(), leftExtrapolationLinear(), npoints(), npoints_, rightExtrapolationLinear(), edm::second(), edm::shift, mitigatedMETSequence_cff::U, findQualityFiles::v, xmax_, and xmin_.

LinInterpolatedTable1D() [3/3]

fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D ( double  c )

explicit

Definition at line 6 of file LinInterpolatedTable1D.cc.

      : data_(2, c),
        xmin_(0.0),
        xmax_(1.0),
        binwidth_(1.0),
        npoints_(2U),
        leftExtrapolationLinear_(false),
        rightExtrapolationLinear_(false),
        monotonous_(false),
        monotonicityKnown_(true) {}

~LinInterpolatedTable1D()

fftjetcms::LinInterpolatedTable1D::~LinInterpolatedTable1D ( )

inlineoverride

Definition at line 51 of file LinInterpolatedTable1D.h.

{}

Member Function Documentation

data()

const double* fftjetcms::LinInterpolatedTable1D::data ( ) const

inline

Definition at line 66 of file LinInterpolatedTable1D.h.

{ return &data_[0]; }

References data_.

Referenced by LinInterpolatedTable1D().

interpolateSimple()

static double fftjetcms::LinInterpolatedTable1D::interpolateSimple ( const double  x0, const double  x1, const double  y0, const double  y1, const double  x  )

inlinestaticprivate

Definition at line 88 of file LinInterpolatedTable1D.h.

                                                                                            {
      return y0 + (y1 - y0) * ((x - x0) / (x1 - x0));
    }

References testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::y1.

Referenced by LinInterpolatedTable1D().

inverse()

std::unique_ptr< LinInterpolatedTable1D > fftjetcms::LinInterpolatedTable1D::inverse	(	unsigned	npoints,
		bool	leftExtrapolationLinear,
		bool	rightExtrapolationLinear
	)		const

Definition at line 38 of file LinInterpolatedTable1D.cc.

                                                                                                                     {
    if (!isMonotonous())
      return std::unique_ptr<LinInterpolatedTable1D>(nullptr);
 
    std::vector<std::pair<double, double> > points;
    points.reserve(npoints_);
 
    if (data_[npoints_ - 1U] > data_[0]) {
      points.push_back(std::pair<double, double>(data_[0], xmin_));
      for (unsigned i = 1; i < npoints_ - 1U; ++i)
        points.push_back(std::pair<double, double>(data_[i], xmin_ + i * binwidth_));
      points.push_back(std::pair<double, double>(data_[npoints_ - 1U], xmax_));
    } else {
      points.push_back(std::pair<double, double>(data_[npoints_ - 1U], xmax_));
      for (unsigned i = npoints_ - 2U; i > 0; --i)
        points.push_back(std::pair<double, double>(data_[i], xmin_ + i * binwidth_));
      points.push_back(std::pair<double, double>(data_[0], xmin_));
    }
 
    return std::make_unique<LinInterpolatedTable1D>(points, npoints, leftExtrapolationLinear, rightExtrapolationLinear);
  }

References binwidth_, data_, mps_fire::i, isMonotonous(), leftExtrapolationLinear(), npoints(), npoints_, HLT_FULL_cff::points, rightExtrapolationLinear(), mitigatedMETSequence_cff::U, xmax_, and xmin_.

isMonotonous()

bool fftjetcms::LinInterpolatedTable1D::isMonotonous

(

)

const

Definition at line 23 of file LinInterpolatedTable1D.cc.

                                                  {
    if (!monotonicityKnown_) {
      monotonous_ = true;
      const double delta = data_[npoints_ - 1U] - data_[0];
      if (delta == 0.0)
        monotonous_ = false;
      const double sg = delta > 0.0 ? 1.0 : -1.0;
      for (unsigned i = 1; i < npoints_ && monotonous_; ++i)
        if ((data_[i] - data_[i - 1]) * sg <= 0.0)
          monotonous_ = false;
      monotonicityKnown_ = true;
    }
    return monotonous_;
  }

References data_, dumpMFGeometry_cfg::delta, mps_fire::i, monotonicityKnown_, monotonous_, npoints_, and mitigatedMETSequence_cff::U.

Referenced by inverse().

leftExtrapolationLinear()

bool fftjetcms::LinInterpolatedTable1D::leftExtrapolationLinear ( ) const

inline

Definition at line 64 of file LinInterpolatedTable1D.h.

{ return leftExtrapolationLinear_; }

References leftExtrapolationLinear_.

Referenced by inverse(), and LinInterpolatedTable1D().

npoints()

unsigned fftjetcms::LinInterpolatedTable1D::npoints ( ) const

inline

Definition at line 63 of file LinInterpolatedTable1D.h.

{ return npoints_; }

References npoints_.

Referenced by inverse(), and LinInterpolatedTable1D().

operator!=()

bool fftjetcms::LinInterpolatedTable1D::operator!= ( const LinInterpolatedTable1D &  r ) const

inline

Definition at line 58 of file LinInterpolatedTable1D.h.

{ return !(*this == r); }

References alignCSCRings::r.

operator()()

double fftjetcms::LinInterpolatedTable1D::operator() ( const double &  x ) const

override

Definition at line 62 of file LinInterpolatedTable1D.cc.

                                                                 {
    if (x <= xmin_) {
      if (leftExtrapolationLinear_)
        return data_[0] + (data_[1] - data_[0]) * ((x - xmin_) / binwidth_);
      else
        return data_[0];
    } else if (x >= xmax_) {
      if (rightExtrapolationLinear_)
        return data_[npoints_ - 1U] - (data_[npoints_ - 2U] - data_[npoints_ - 1U]) * ((x - xmax_) / binwidth_);
      else
        return data_[npoints_ - 1U];
    } else {
      const unsigned ux = static_cast<unsigned>((x - xmin_) / binwidth_);
      if (ux >= npoints_ - 1U)
        return data_[npoints_ - 1U];
      const double delta = x - (ux * binwidth_ + xmin_);
      return data_[ux] + (data_[ux + 1U] - data_[ux]) * delta / binwidth_;
    }
  }

References binwidth_, data_, dumpMFGeometry_cfg::delta, leftExtrapolationLinear_, npoints_, rightExtrapolationLinear_, mitigatedMETSequence_cff::U, xmax_, and xmin_.

operator==()

bool fftjetcms::LinInterpolatedTable1D::operator==

(

const LinInterpolatedTable1D &

r

)

const

Definition at line 17 of file LinInterpolatedTable1D.cc.

                                                                               {
    return xmin_ == r.xmin_ && xmax_ == r.xmax_ && binwidth_ == r.binwidth_ && npoints_ == r.npoints_ &&
           leftExtrapolationLinear_ == r.leftExtrapolationLinear_ &&
           rightExtrapolationLinear_ == r.rightExtrapolationLinear_ && data_ == r.data_;
  }

References binwidth_, data_, leftExtrapolationLinear_, npoints_, alignCSCRings::r, rightExtrapolationLinear_, xmax_, and xmin_.

rightExtrapolationLinear()

bool fftjetcms::LinInterpolatedTable1D::rightExtrapolationLinear ( ) const

inline

Definition at line 65 of file LinInterpolatedTable1D.h.

{ return rightExtrapolationLinear_; }

References rightExtrapolationLinear_.

Referenced by inverse(), and LinInterpolatedTable1D().

xmax()

double fftjetcms::LinInterpolatedTable1D::xmax ( ) const

inline

Definition at line 62 of file LinInterpolatedTable1D.h.

{ return xmax_; }

References xmax_.

Referenced by svgfig.XAxis::__repr__().

xmin()

double fftjetcms::LinInterpolatedTable1D::xmin ( ) const

inline

Definition at line 61 of file LinInterpolatedTable1D.h.

{ return xmin_; }

References xmin_.

Referenced by svgfig.XAxis::__repr__(), svgfig.Axes::__repr__(), svgfig.HGrid::__repr__(), svgfig.Grid::__repr__(), and svgfig.Axes::SVG().

Member Data Documentation

binwidth_

double fftjetcms::LinInterpolatedTable1D::binwidth_

private

Definition at line 96 of file LinInterpolatedTable1D.h.

Referenced by inverse(), LinInterpolatedTable1D(), operator()(), and operator==().

data_

std::vector<double> fftjetcms::LinInterpolatedTable1D::data_

private

Definition at line 93 of file LinInterpolatedTable1D.h.

Referenced by data(), inverse(), isMonotonous(), LinInterpolatedTable1D(), operator()(), and operator==().

leftExtrapolationLinear_

bool fftjetcms::LinInterpolatedTable1D::leftExtrapolationLinear_

private

Definition at line 98 of file LinInterpolatedTable1D.h.

Referenced by leftExtrapolationLinear(), operator()(), and operator==().

monotonicityKnown_

bool fftjetcms::LinInterpolatedTable1D::monotonicityKnown_

mutableprivate

Definition at line 101 of file LinInterpolatedTable1D.h.

Referenced by isMonotonous().

monotonous_

bool fftjetcms::LinInterpolatedTable1D::monotonous_

mutableprivate

Definition at line 100 of file LinInterpolatedTable1D.h.

Referenced by isMonotonous().

npoints_

unsigned fftjetcms::LinInterpolatedTable1D::npoints_

private

Definition at line 97 of file LinInterpolatedTable1D.h.

Referenced by inverse(), isMonotonous(), LinInterpolatedTable1D(), npoints(), operator()(), and operator==().

rightExtrapolationLinear_

bool fftjetcms::LinInterpolatedTable1D::rightExtrapolationLinear_

private

Definition at line 99 of file LinInterpolatedTable1D.h.

Referenced by operator()(), operator==(), and rightExtrapolationLinear().

xmax_

double fftjetcms::LinInterpolatedTable1D::xmax_

private

Definition at line 95 of file LinInterpolatedTable1D.h.

Referenced by inverse(), LinInterpolatedTable1D(), operator()(), operator==(), and xmax().

xmin_

double fftjetcms::LinInterpolatedTable1D::xmin_

private

Definition at line 94 of file LinInterpolatedTable1D.h.

Referenced by inverse(), LinInterpolatedTable1D(), operator()(), operator==(), and xmin().