npstat::Private Namespace Reference

Classes
struct	AbsHelper
struct	AbsHelper< T, 1 >
struct	AbsReturnType
struct	AbsReturnType< const std::complex< T > >
struct	AbsReturnType< const volatile std::complex< T > >
struct	AbsReturnType< std::complex< T > >
struct	AbsReturnType< volatile std::complex< T > >

Functions
template<class Axis >
std::vector< Axis >	addAxis (const std::vector< Axis > &axes, const Axis &newAxis, const unsigned newAxisNumber)
template<class Axis >
std::vector< Axis >	axesOfASlice (const std::vector< Axis > &axes, const unsigned *fixedIndices, const unsigned nFixedIndices)
void	h_badargs (const char *method)
template<typename Float , class Axis >
void	iHND_checkArgs (const HistoND< Float, Axis > &histo, const unsigned xDim, const unsigned interpolationDegree)
double	lind_interpolateSimple (const double x0, const double x1, const double y0, const double y1, const double x)
template<typename Numeric , class Axis >
void	lind_invert1DSlice (const ArrayND< Numeric > &fromSlice, const Axis &fromAxis, const Axis &toAxis, const bool leftLinear, const bool rightLinear, ArrayND< Numeric > *toSlice)
template<class Axis >
ArrayShape	makeHistoShape (const std::vector< Axis > &axes)
template<class Axis >
ArrayShape	makeHistoShape (const Axis &xAxis)
template<class Axis >
ArrayShape	makeHistoShape (const Axis &xAxis, const Axis &yAxis)
template<class Axis >
ArrayShape	makeHistoShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis)
template<class Axis >
ArrayShape	makeHistoShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis)
template<class Axis >
ArrayShape	makeHistoShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis, const Axis &vAxis)
template<class Axis >
ArrayShape	makeTableShape (const std::vector< Axis > &axes)
template<class Axis >
ArrayShape	makeTableShape (const Axis &xAxis)
template<class Axis >
ArrayShape	makeTableShape (const Axis &xAxis, const Axis &yAxis)
template<class Axis >
ArrayShape	makeTableShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis)
template<class Axis >
ArrayShape	makeTableShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis)
template<class Axis >
ArrayShape	makeTableShape (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis, const Axis &vAxis)
template<class Axis >
std::vector< Axis >	rebinAxes (const std::vector< Axis > &axes, const unsigned *newBins, const unsigned lenNewBins)
template<class Axis >
ArrayShape	shapeOfASlice (const std::vector< Axis > &axes, const unsigned *fixedIndices, const unsigned nFixedIndices)
template<class Axis >
ArrayShape	shapeWithExtraAxis (const std::vector< Axis > &axes, const Axis &newAxis, const unsigned newAxisNumber)

Function Documentation

addAxis()

template<class Axis >

std::vector<Axis> npstat::Private::addAxis	(	const std::vector< Axis > &	axes,
		const Axis &	newAxis,
		const unsigned	newAxisNumber
	)

Definition at line 1156 of file HistoND.h.

References mps_fire::i, and mitigatedMETSequence_cff::U.

                                                                                                            {
      const unsigned dim = axes.size();
      std::vector<Axis> newAxes;
      newAxes.reserve(dim + 1U);
      unsigned iadd = 0;
      for (unsigned i = 0; i < dim; ++i) {
        if (newAxisNumber == i)
          newAxes.push_back(newAxis);
        else
          newAxes.push_back(axes[iadd++]);
      }
      if (iadd == dim)
        newAxes.push_back(newAxis);
      else
        newAxes.push_back(axes[iadd]);
      return newAxes;
    }

axesOfASlice()

template<class Axis >

std::vector<Axis> npstat::Private::axesOfASlice	(	const std::vector< Axis > &	axes,
		const unsigned *	fixedIndices,
		const unsigned	nFixedIndices
	)

Definition at line 1087 of file HistoND.h.

References cms::cuda::assert(), alignBH_cfg::fixed, mps_fire::i, dqmiolumiharvest::j, and mitigatedMETSequence_cff::U.

                                                                 {
      const unsigned dim = axes.size();
      std::vector<Axis> newAxes;
      if (nFixedIndices == 0U)
        throw npstat::NpstatInvalidArgument(
            "In npstat::Private::axesOfASlice: "
            "at least one fixed index must be specified");
      if (nFixedIndices > dim)
        throw npstat::NpstatInvalidArgument("In npstat::Private::axesOfASlice: too many fixed indices");
      assert(fixedIndices);
      for (unsigned i = 0; i < nFixedIndices; ++i)
        if (fixedIndices[i] >= dim)
          throw npstat::NpstatInvalidArgument("In npstat::Private::axesOfASlice: fixed index out of range");
      newAxes.reserve(dim - nFixedIndices);
      for (unsigned i = 0; i < dim; ++i) {
        bool fixed = false;
        for (unsigned j = 0; j < nFixedIndices; ++j)
          if (fixedIndices[j] == i) {
            fixed = true;
            break;
          }
        if (!fixed)
          newAxes.push_back(axes[i]);
      }
      if (newAxes.size() != dim - nFixedIndices)
        throw npstat::NpstatInvalidArgument("In npstat::Private::axesOfASlice: duplicate fixed index");
      return newAxes;
    }

h_badargs()

void npstat::Private::h_badargs ( const char *  method )

inline

Definition at line 1193 of file HistoND.h.

References AlcaSiPixelAliHarvester0T_cff::method.

Referenced by npstat::HistoND< Numeric, Axis >::closestBin(), npstat::HistoND< Numeric, Axis >::dispatch(), npstat::HistoND< Numeric, Axis >::examine(), npstat::HistoND< Numeric, Axis >::fill(), and npstat::HistoND< Numeric, Axis >::fillC().

                                              {
      std::ostringstream os;
      os << "In npstat::HistoND::" << method << ": number of arguments"
         << " is incompatible with histogram dimensionality";
      throw npstat::NpstatInvalidArgument(os.str());
    }

iHND_checkArgs()

template<typename Float , class Axis >

void npstat::Private::iHND_checkArgs	(	const HistoND< Float, Axis > &	histo,
		const unsigned	xDim,
		const unsigned	interpolationDegree
	)

Definition at line 135 of file interpolateHistoND.h.

References timingPdfMaker::histo, and mitigatedMETSequence_cff::U.

Referenced by npstat::interpolateHistoND().

                                                                                                                    {
      if (xDim != histo.dim())
        throw npstat::NpstatInvalidArgument(
            "In npstat::interpolateHistoND: incompatible "
            "dimensionality of input coordinates");
      if (xDim == 0U)
        throw npstat::NpstatInvalidArgument(
            "In npstat::interpolateHistoND: can not interpolate "
            "zero-dimensional histograms");
      if (!(interpolationDegree == 0U || interpolationDegree == 1U || interpolationDegree == 3U))
        throw npstat::NpstatInvalidArgument(
            "In npstat::interpolateHistoND: "
            "unsupported interpolation degree");
      if (interpolationDegree == 3U && !histo.isUniformlyBinned())
        throw npstat::NpstatInvalidArgument(
            "In npstat::interpolateHistoND: unsupported "
            "interpolation degree for non-uniform binning");
    }

lind_interpolateSimple()

double npstat::Private::lind_interpolateSimple ( const double  x0, const double  x1, const double  y0, const double  y1, const double  x  )

inline

Definition at line 343 of file LinInterpolatedTableND.h.

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

Referenced by lind_invert1DSlice(), and npstat::LinInterpolatedTableND< Numeric, Axis >::solveForRatioArg().

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

lind_invert1DSlice()

template<typename Numeric , class Axis >

void npstat::Private::lind_invert1DSlice	(	const ArrayND< Numeric > &	fromSlice,
		const Axis &	fromAxis,
		const Axis &	toAxis,
		const bool	leftLinear,
		const bool	rightLinear,
		ArrayND< Numeric > *	toSlice
	)

Definition at line 349 of file LinInterpolatedTableND.h.

References cms::cuda::assert(), npstat::ArrayND< Numeric, StackLen, StackDim >::data(), mps_fire::i, npstat::isStrictlyMonotonous(), npstat::ArrayND< Numeric, StackLen, StackDim >::length(), lind_interpolateSimple(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, npstat::ArrayND< Numeric, StackLen, StackDim >::rank(), and mitigatedMETSequence_cff::U.

Referenced by npstat::LinInterpolatedTableND< Numeric, Axis >::invertWRTAxis().

                                                       {
      assert(toSlice);
      assert(fromSlice.rank() == 1U);
      assert(toSlice->rank() == 1U);

      const Numeric* fromData = fromSlice.data();
      const unsigned fromLen = fromSlice.length();
      assert(fromLen > 1U);
      assert(fromLen == fromAxis.nCoords());
      const Numeric* fromDataEnd = fromData + fromLen;
      if (!isStrictlyMonotonous(fromData, fromDataEnd))
        throw npstat::NpstatInvalidArgument(
            "In npstat::Private::lind_invert1DSlice: "
            "slice data is not monotonous and can not be inverted");

      const Numeric yfirst = fromData[0];
      const Numeric ylast = fromData[fromLen - 1U];
      const bool increasing = yfirst < ylast;

      Numeric* toD = const_cast<Numeric*>(toSlice->data());
      const unsigned nAxisPoints = toAxis.nCoords();
      assert(toSlice->length() == nAxisPoints);

      for (unsigned ipt = 0; ipt < nAxisPoints; ++ipt) {
        const Numeric y = static_cast<Numeric>(toAxis.coordinate(ipt));
        if (increasing) {
          if (y <= yfirst) {
            if (leftLinear)
              toD[ipt] = Private::lind_interpolateSimple(
                  yfirst, fromData[1], fromAxis.coordinate(0), fromAxis.coordinate(1), y);
            else
              toD[ipt] = fromAxis.coordinate(0);
          } else if (y >= ylast) {
            if (rightLinear)
              toD[ipt] = Private::lind_interpolateSimple(ylast,
                                                         fromData[fromLen - 2U],
                                                         fromAxis.coordinate(fromLen - 1U),
                                                         fromAxis.coordinate(fromLen - 2U),
                                                         y);
            else
              toD[ipt] = fromAxis.coordinate(fromLen - 1U);
          } else {
            const unsigned i = std::lower_bound(fromData, fromDataEnd, y) - fromData;
            toD[ipt] = Private::lind_interpolateSimple(
                fromData[i - 1U], fromData[i], fromAxis.coordinate(i - 1U), fromAxis.coordinate(i), y);
          }
        } else {
          // The role of left and right are exchanged
          // with respect to first and last point
          if (y <= ylast) {
            if (leftLinear)
              toD[ipt] = Private::lind_interpolateSimple(ylast,
                                                         fromData[fromLen - 2U],
                                                         fromAxis.coordinate(fromLen - 1U),
                                                         fromAxis.coordinate(fromLen - 2U),
                                                         y);
            else
              toD[ipt] = fromAxis.coordinate(fromLen - 1U);
          } else if (y >= yfirst) {
            if (rightLinear)
              toD[ipt] = Private::lind_interpolateSimple(
                  yfirst, fromData[1], fromAxis.coordinate(0), fromAxis.coordinate(1), y);
            else
              toD[ipt] = fromAxis.coordinate(0);
          } else {
            const unsigned i = std::lower_bound(fromData, fromDataEnd, y, std::greater<Numeric>()) - fromData;
            toD[ipt] = Private::lind_interpolateSimple(
                fromData[i - 1U], fromData[i], fromAxis.coordinate(i - 1U), fromAxis.coordinate(i), y);
          }
        }
      }
    }

makeHistoShape() [1/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape

(

const std::vector< Axis > &

axes

)

Definition at line 1011 of file HistoND.h.

References mps_fire::i, dqmiodumpmetadata::n, and mps_fire::result.

                                                           {
      const unsigned n = axes.size();
      ArrayShape result;
      result.reserve(n);
      for (unsigned i = 0; i < n; ++i)
        result.push_back(axes[i].nBins());
      return result;
    }

makeHistoShape() [2/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape

(

const Axis &

xAxis

)

Definition at line 1021 of file HistoND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, and HLT_2022v12_cff::xAxis.

                                                 {
      ArrayShape result;
      result.reserve(1U);
      result.push_back(xAxis.nBins());
      return result;
    }

makeHistoShape() [3/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape	(	const Axis &	xAxis,
		const Axis &	yAxis
	)

Definition at line 1029 of file HistoND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, and HLT_2022v12_cff::yAxis.

                                                                    {
      ArrayShape result;
      result.reserve(2U);
      result.push_back(xAxis.nBins());
      result.push_back(yAxis.nBins());
      return result;
    }

makeHistoShape() [4/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis
	)

Definition at line 1038 of file HistoND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                       {
      ArrayShape result;
      result.reserve(3U);
      result.push_back(xAxis.nBins());
      result.push_back(yAxis.nBins());
      result.push_back(zAxis.nBins());
      return result;
    }

makeHistoShape() [5/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis
	)

Definition at line 1048 of file HistoND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                                          {
      ArrayShape result;
      result.reserve(4U);
      result.push_back(xAxis.nBins());
      result.push_back(yAxis.nBins());
      result.push_back(zAxis.nBins());
      result.push_back(tAxis.nBins());
      return result;
    }

makeHistoShape() [6/6]

template<class Axis >

ArrayShape npstat::Private::makeHistoShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis,
		const Axis &	vAxis
	)

Definition at line 1059 of file HistoND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                                       {
      ArrayShape result;
      result.reserve(5U);
      result.push_back(xAxis.nBins());
      result.push_back(yAxis.nBins());
      result.push_back(zAxis.nBins());
      result.push_back(tAxis.nBins());
      result.push_back(vAxis.nBins());
      return result;
    }

makeTableShape() [1/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape

(

const std::vector< Axis > &

axes

)

Definition at line 283 of file LinInterpolatedTableND.h.

References mps_fire::i, dqmiodumpmetadata::n, and mps_fire::result.

                                                           {
      const unsigned n = axes.size();
      ArrayShape result;
      result.reserve(n);
      for (unsigned i = 0; i < n; ++i)
        result.push_back(axes[i].nCoords());
      return result;
    }

makeTableShape() [2/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape

(

const Axis &

xAxis

)

Definition at line 293 of file LinInterpolatedTableND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, and HLT_2022v12_cff::xAxis.

                                                 {
      ArrayShape result;
      result.reserve(1U);
      result.push_back(xAxis.nCoords());
      return result;
    }

makeTableShape() [3/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape	(	const Axis &	xAxis,
		const Axis &	yAxis
	)

Definition at line 301 of file LinInterpolatedTableND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, and HLT_2022v12_cff::yAxis.

                                                                    {
      ArrayShape result;
      result.reserve(2U);
      result.push_back(xAxis.nCoords());
      result.push_back(yAxis.nCoords());
      return result;
    }

makeTableShape() [4/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis
	)

Definition at line 310 of file LinInterpolatedTableND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                       {
      ArrayShape result;
      result.reserve(3U);
      result.push_back(xAxis.nCoords());
      result.push_back(yAxis.nCoords());
      result.push_back(zAxis.nCoords());
      return result;
    }

makeTableShape() [5/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis
	)

Definition at line 320 of file LinInterpolatedTableND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                                          {
      ArrayShape result;
      result.reserve(4U);
      result.push_back(xAxis.nCoords());
      result.push_back(yAxis.nCoords());
      result.push_back(zAxis.nCoords());
      result.push_back(tAxis.nCoords());
      return result;
    }

makeTableShape() [6/6]

template<class Axis >

ArrayShape npstat::Private::makeTableShape	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis,
		const Axis &	vAxis
	)

Definition at line 331 of file LinInterpolatedTableND.h.

References mps_fire::result, mitigatedMETSequence_cff::U, HLT_2022v12_cff::xAxis, HLT_2022v12_cff::yAxis, and HLT_2022v12_cff::zAxis.

                                                                                                       {
      ArrayShape result;
      result.reserve(5U);
      result.push_back(xAxis.nCoords());
      result.push_back(yAxis.nCoords());
      result.push_back(zAxis.nCoords());
      result.push_back(tAxis.nCoords());
      result.push_back(vAxis.nCoords());
      return result;
    }

rebinAxes()

template<class Axis >

std::vector<Axis> npstat::Private::rebinAxes	(	const std::vector< Axis > &	axes,
		const unsigned *	newBins,
		const unsigned	lenNewBins
	)

Definition at line 1072 of file HistoND.h.

References cms::cuda::assert(), and mps_fire::i.

                                                                                                               {
      const unsigned dim = axes.size();
      if (lenNewBins != dim)
        throw npstat::NpstatInvalidArgument(
            "In npstat::Private::rebinAxes: invalid length "
            "of the new bins array");
      assert(newBins);
      std::vector<Axis> newAxes;
      newAxes.reserve(dim);
      for (unsigned i = 0; i < dim; ++i)
        newAxes.push_back(axes[i].rebin(newBins[i]));
      return newAxes;
    }

shapeOfASlice()

template<class Axis >

ArrayShape npstat::Private::shapeOfASlice	(	const std::vector< Axis > &	axes,
		const unsigned *	fixedIndices,
		const unsigned	nFixedIndices
	)

Definition at line 1119 of file HistoND.h.

References cms::cuda::assert(), alignBH_cfg::fixed, mps_fire::i, dqmiolumiharvest::j, seedmultiplicitymonitor_newtracking_cfi::nBins, and mitigatedMETSequence_cff::U.

                                                           {
      const unsigned dim = axes.size();
      if (nFixedIndices == 0U)
        throw npstat::NpstatInvalidArgument(
            "In npstat::Private::shapeOfASlice: "
            "at least one fixed index must be specified");
      if (nFixedIndices > dim)
        throw npstat::NpstatInvalidArgument("In npstat::Private::shapeOfASlice: too many fixed indices");
      assert(fixedIndices);

      // Check that the fixed indices are within range
      for (unsigned j = 0; j < nFixedIndices; ++j)
        if (fixedIndices[j] >= dim)
          throw npstat::NpstatInvalidArgument("In npstat::Private::shapeOfASlice: fixed index out of range");

      // Build the shape for the slice
      ArrayShape sh;
      if (nFixedIndices < dim)
        sh.reserve(dim - nFixedIndices);
      for (unsigned i = 0; i < dim; ++i) {
        bool fixed = false;
        for (unsigned j = 0; j < nFixedIndices; ++j)
          if (fixedIndices[j] == i) {
            fixed = true;
            break;
          }
        if (!fixed)
          sh.push_back(axes[i].nBins());
      }
      if (sh.size() != dim - nFixedIndices)
        throw npstat::NpstatInvalidArgument("In npstat::Private::shapeOfASlice: duplicate fixed index");
      return sh;
    }

shapeWithExtraAxis()

template<class Axis >

ArrayShape npstat::Private::shapeWithExtraAxis	(	const std::vector< Axis > &	axes,
		const Axis &	newAxis,
		const unsigned	newAxisNumber
	)

Definition at line 1175 of file HistoND.h.

References mps_fire::i, seedmultiplicitymonitor_newtracking_cfi::nBins, mps_fire::result, and mitigatedMETSequence_cff::U.

                                                                                                                  {
      const unsigned dim = axes.size();
      ArrayShape result;
      result.reserve(dim + 1U);
      unsigned iadd = 0;
      for (unsigned i = 0; i < dim; ++i) {
        if (newAxisNumber == i)
          result.push_back(newAxis.nBins());
        else
          result.push_back(axes[iadd++].nBins());
      }
      if (iadd == dim)
        result.push_back(newAxis.nBins());
      else
        result.push_back(axes[iadd].nBins());
      return result;
    }