RandArrayFunction Class Reference

#include <RandArrayFunction.h>

Public Member Functions
double	Fire () const
void	FireArray (int size, double *array) const
double	operator() () const
void	PrepareTable (const double *aProbFunc)
	RandArrayFunction (const double *aProbFunc, int theProbSize, int interpolationType=0)
	RandArrayFunction (int probSize, int interpolationType=0)
double	Shoot () const
void	ShootArray (int size, double *array) const

Private Member Functions
double	MapRandom (double rand) const
double	StandardRand () const
void	UseFlatDistribution ()

Private Attributes
std::vector< double >	fIntegralPdf
int	fInterpolationType
int	fNBins
double	fOneOverNbins

Detailed Description

Definition at line 73 of file RandArrayFunction.h.

Constructor & Destructor Documentation

RandArrayFunction() [1/2]

RandArrayFunction::RandArrayFunction	(	const double *	aProbFunc,
		int	theProbSize,
		int	interpolationType = 0
	)

Definition at line 12 of file RandArrayFunction.cc.

    : fNBins(theProbSize), fInterpolationType(intType) {
  PrepareTable(aProbFunc);
}

References PrepareTable().

RandArrayFunction() [2/2]

RandArrayFunction::RandArrayFunction	(	int	probSize,
		int	interpolationType = 0
	)

Definition at line 17 of file RandArrayFunction.cc.

: fNBins(theProbSize), fInterpolationType(intType) {}

Member Function Documentation

Fire()

double RandArrayFunction::Fire ( ) const

inline

Definition at line 100 of file RandArrayFunction.h.

{ return MapRandom(StandardRand()); }

References MapRandom(), and StandardRand().

Referenced by FireArray(), operator()(), and Shoot().

FireArray()

void RandArrayFunction::FireArray	(	int	size,
		double *	array
	)		const

Definition at line 110 of file RandArrayFunction.cc.

                                                              {
  for (int i = 0; i < size; ++i)
    vect[i] = Fire();
}

References Fire(), mps_fire::i, and findQualityFiles::size.

Referenced by ShootArray().

MapRandom()

double RandArrayFunction::MapRandom ( double  rand ) const

private

Definition at line 71 of file RandArrayFunction.cc.

                                                     {
  // Private method to take the random (however it is created) and map it
  // according to the distribution.
 
  int nBelow = 0;       // largest k such that I[k] is known to be <= rand
  int nAbove = fNBins;  // largest k such that I[k] is known to be >  rand
  int middle;
 
  while (nAbove > nBelow + 1) {
    middle = (nAbove + nBelow + 1) >> 1;
    rand >= fIntegralPdf[middle] ? nBelow = middle : nAbove = middle;
  }  // after this loop, nAbove is always nBelow+1 and they straddle rad:
 
  /*assert ( nAbove = nBelow+1 );
    assert ( fIntegralPdf[nBelow] <= rand );
    assert ( fIntegralPdf[nAbove] >= rand );*/
  // If a defective engine produces rand=1, that will
  // still give sensible results so we relax the > rand assertion
 
  if (fInterpolationType == 1) {
    return nBelow * fOneOverNbins;
  } else {
    double binMeasure = fIntegralPdf[nAbove] - fIntegralPdf[nBelow];
    // binMeasure is always aProbFunc[nBelow],
    // but we don't have aProbFunc any more so we subtract.
 
    if (!binMeasure) {
      // rand lies right in a bin of measure 0.  Simply return the center
      // of the range of that bin.  (Any value between k/N and (k+1)/N is
      // equally good, in this rare case.)
      return (nBelow + .5) * fOneOverNbins;
    }
 
    double binFraction = (rand - fIntegralPdf[nBelow]) / binMeasure;
 
    return (nBelow + binFraction) * fOneOverNbins;
  }
}

References fIntegralPdf, fInterpolationType, fNBins, and fOneOverNbins.

Referenced by Fire().

operator()()

double RandArrayFunction::operator() ( ) const

inline

Definition at line 104 of file RandArrayFunction.h.

{ return Fire(); }

References Fire().

PrepareTable()

void RandArrayFunction::PrepareTable

(

const double *

aProbFunc

)

Definition at line 19 of file RandArrayFunction.cc.

                                                            {
  //Prepares fIntegralPdf.
  if (fNBins < 1) {
    edm::LogError("RandArrayFunction") << "RandArrayFunction constructed with no bins - will use flat distribution";
    UseFlatDistribution();
    return;
  }
 
  fIntegralPdf.resize(fNBins + 1);
  fIntegralPdf[0] = 0;
  int ptn;
  for (ptn = 0; ptn < fNBins; ++ptn) {
    double weight = aProbFunc[ptn];
    if (weight < 0.) {
      // We can't stomach negative bin contents, they invalidate the
      // search algorithm when the distribution is fired.
      edm::LogWarning("RandArrayFunction") << "RandArrayFunction constructed with negative-weight bin " << ptn
                                           << " == " << weight << " -- will substitute 0 weight";
      weight = 0.;
    }
    fIntegralPdf[ptn + 1] = fIntegralPdf[ptn] + weight;
  }
 
  if (fIntegralPdf[fNBins] <= 0.) {
    edm::LogWarning("RandArrayFunction")
        << "RandArrayFunction constructed with nothing in bins - will use flat distribution";
    UseFlatDistribution();
    return;
  }
 
  for (ptn = 0; ptn < fNBins + 1; ++ptn)
    fIntegralPdf[ptn] /= fIntegralPdf[fNBins];
 
  // And another useful variable is ...
  fOneOverNbins = 1.0 / fNBins;
  // One last chore:
  if (fInterpolationType && fInterpolationType != 1) {
    edm::LogInfo("RandArrayFunction") << "RandArrayFunction does not recognize fInterpolationType "
                                      << fInterpolationType << " Will use type 0 (continuous linear interpolation)";
    fInterpolationType = 0;
  }
}

References fIntegralPdf, fInterpolationType, fNBins, fOneOverNbins, UseFlatDistribution(), and mps_merge::weight.

Referenced by gen::Hydjet2Hadronizer::generatePartonsAndHadronize(), and RandArrayFunction().

Shoot()

double RandArrayFunction::Shoot ( ) const

inline

Definition at line 102 of file RandArrayFunction.h.

{ return Fire(); }

References Fire().

ShootArray()

void RandArrayFunction::ShootArray ( int  size, double *  array  ) const

inline

Definition at line 106 of file RandArrayFunction.h.

{ FireArray(size, array); }

References mps_check::array, FireArray(), and findQualityFiles::size.

StandardRand()

double RandArrayFunction::StandardRand ( ) const

inlineprivate

Definition at line 98 of file RandArrayFunction.h.

{ return CLHEP::RandFlat::shoot(hjRandomEngine); }

References hjRandomEngine.

Referenced by Fire().

UseFlatDistribution()

void RandArrayFunction::UseFlatDistribution ( )

private

Definition at line 62 of file RandArrayFunction.cc.

                                            {
  //Called only by PrepareTable in case of user error.
  fNBins = 1;
  fIntegralPdf.resize(2);
  fIntegralPdf[0] = 0;
  fIntegralPdf[1] = 1;
  fOneOverNbins = 1.0;
}

References fIntegralPdf, fNBins, and fOneOverNbins.

Referenced by PrepareTable().

Member Data Documentation

fIntegralPdf

std::vector<double> RandArrayFunction::fIntegralPdf

private

Definition at line 75 of file RandArrayFunction.h.

Referenced by MapRandom(), PrepareTable(), and UseFlatDistribution().

fInterpolationType

int RandArrayFunction::fInterpolationType

private

Definition at line 78 of file RandArrayFunction.h.

Referenced by MapRandom(), and PrepareTable().

fNBins

int RandArrayFunction::fNBins

private

Definition at line 76 of file RandArrayFunction.h.

Referenced by MapRandom(), PrepareTable(), and UseFlatDistribution().

fOneOverNbins

double RandArrayFunction::fOneOverNbins

private

Definition at line 77 of file RandArrayFunction.h.

Referenced by MapRandom(), PrepareTable(), and UseFlatDistribution().