#include <GaussianTail.h>

Public Member Functions
	GaussianTail (double sigma=1., double threshold=2.)

void	setParameters (double sigma, double threshold)

double	shoot (RandomEngineAndDistribution const *) const

	~GaussianTail ()

Private Attributes
double	s_

double	sigma_

double	ssquare_

double	threshold_

Detailed Description

Definition at line 10 of file GaussianTail.h.

Constructor & Destructor Documentation

◆ GaussianTail()

GaussianTail::GaussianTail	(	double	sigma = `1.`,
		double	threshold = `2.`
	)

Definition at line 5 of file GaussianTail.cc.

References s_, sigma_, ssquare_, and threshold_.

                                                          : sigma_(sigma), threshold_(threshold) {
   s_ = threshold_ / sigma_;
   ssquare_ = s_ * s_;
 }

◆ ~GaussianTail()

GaussianTail::~GaussianTail ( )

Definition at line 10 of file GaussianTail.cc.

10 { ; }

Member Function Documentation

◆ setParameters()

void GaussianTail::setParameters	(	double	sigma,
		double	threshold
	)

inline

Definition at line 14 of file GaussianTail.h.

References s_, sigma_, ssquare_, DiMuonV_cfg::threshold, and threshold_.

                                                             {
     sigma_ = sigma;
     threshold_ = threshold;
     s_ = threshold_ / sigma_;
     ssquare_ = s_ * s_;
   };

◆ shoot()

double GaussianTail::shoot ( RandomEngineAndDistribution const * random ) const

Definition at line 12 of file GaussianTail.cc.

References RandomEngineAndDistribution::flatShoot(), RandomEngineAndDistribution::gaussShoot(), CrabHelper::log, s_, sigma_, mathSSE::sqrt(), ssquare_, findQualityFiles::v, and x.

                                                                           {
   // in the zero suppresion case, s is usually >2
   if (s_ > 1.) {
     /* Use the "supertail" deviates from the last two steps
        * of Marsaglia's rectangle-wedge-tail method, as described
        * in Knuth, v2, 3rd ed, pp 123-128.  (See also exercise 11, p139,
        * and the solution, p586.)
        */
 
     double u, v, x;
 
     do {
       u = random->flatShoot();
       do {
         v = random->flatShoot();
       } while (v == 0.0);
       x = std::sqrt(ssquare_ - 2 * std::log(v));
     } while (x * u > s_);
     return x * sigma_;
   } else {
     /* For small s, use a direct rejection method. The limit s < 1
          can be adjusted to optimise the overall efficiency 
        */
 
     double x;
 
     do {
       x = random->gaussShoot();
     } while (x < s_);
     return x * sigma_;
   }
 }