Logo ROOT  
Reference Guide
RooGaussian.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitModels *
4 * @(#)root/roofit:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17/** \class RooGaussian
18 \ingroup Roofit
19
20Plain Gaussian p.d.f
21**/
22
23#include "RooGaussian.h"
24
25#include "RooRandom.h"
26#include "RooMath.h"
27#include "RooHelpers.h"
28#include "RooBatchCompute.h"
29
30
32
33////////////////////////////////////////////////////////////////////////////////
34
35RooGaussian::RooGaussian(const char *name, const char *title,
36 RooAbsReal& _x, RooAbsReal& _mean,
37 RooAbsReal& _sigma) :
38 RooAbsPdf(name,title),
39 x("x","Observable",this,_x),
40 mean("mean","Mean",this,_mean),
41 sigma("sigma","Width",this,_sigma)
42{
43 RooHelpers::checkRangeOfParameters(this, {&_sigma}, 0);
44}
45
46////////////////////////////////////////////////////////////////////////////////
47
48RooGaussian::RooGaussian(const RooGaussian& other, const char* name) :
49 RooAbsPdf(other,name), x("x",this,other.x), mean("mean",this,other.mean),
50 sigma("sigma",this,other.sigma)
51{
52}
53
54////////////////////////////////////////////////////////////////////////////////
55
57{
58 const double arg = x - mean;
59 const double sig = sigma;
60 return std::exp(-0.5*arg*arg/(sig*sig));
61}
62
63
64////////////////////////////////////////////////////////////////////////////////
65/// Compute multiple values of Gaussian distribution.
67 return RooBatchCompute::dispatch->computeGaussian(this, evalData, x->getValues(evalData, normSet), mean->getValues(evalData, normSet), sigma->getValues(evalData, normSet));
68}
69
70////////////////////////////////////////////////////////////////////////////////
71
72Int_t RooGaussian::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* /*rangeName*/) const
73{
74 if (matchArgs(allVars,analVars,x)) return 1 ;
75 if (matchArgs(allVars,analVars,mean)) return 2 ;
76 return 0 ;
77}
78
79////////////////////////////////////////////////////////////////////////////////
80
81Double_t RooGaussian::analyticalIntegral(Int_t code, const char* rangeName) const
82{
83 assert(code==1 || code==2);
84
85 //The normalisation constant 1./sqrt(2*pi*sigma^2) is left out in evaluate().
86 //Therefore, the integral is scaled up by that amount to make RooFit normalise
87 //correctly.
88 const double resultScale = std::sqrt(TMath::TwoPi()) * sigma;
89
90 //Here everything is scaled and shifted into a standard normal distribution:
91 const double xscale = TMath::Sqrt2() * sigma;
92 double max = 0.;
93 double min = 0.;
94 if (code == 1){
95 max = (x.max(rangeName)-mean)/xscale;
96 min = (x.min(rangeName)-mean)/xscale;
97 } else { //No == 2 test because of assert
98 max = (mean.max(rangeName)-x)/xscale;
99 min = (mean.min(rangeName)-x)/xscale;
100 }
101
102
103 //Here we go for maximum precision: We compute all integrals in the UPPER
104 //tail of the Gaussian, because erfc has the highest precision there.
105 //Therefore, the different cases for range limits in the negative hemisphere are mapped onto
106 //the equivalent points in the upper hemisphere using erfc(-x) = 2. - erfc(x)
107 const double ecmin = std::erfc(std::abs(min));
108 const double ecmax = std::erfc(std::abs(max));
109
110
111 return resultScale * 0.5 * (
112 min*max < 0.0 ? 2.0 - (ecmin + ecmax)
113 : max <= 0. ? ecmax - ecmin : ecmin - ecmax
114 );
115}
116
117////////////////////////////////////////////////////////////////////////////////
118
119Int_t RooGaussian::getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t /*staticInitOK*/) const
120{
121 if (matchArgs(directVars,generateVars,x)) return 1 ;
122 if (matchArgs(directVars,generateVars,mean)) return 2 ;
123 return 0 ;
124}
125
126////////////////////////////////////////////////////////////////////////////////
127
129{
130 assert(code==1 || code==2) ;
131 Double_t xgen ;
132 if(code==1){
133 while(1) {
135 if (xgen<x.max() && xgen>x.min()) {
136 x = xgen ;
137 break;
138 }
139 }
140 } else if(code==2){
141 while(1) {
143 if (xgen<mean.max() && xgen>mean.min()) {
144 mean = xgen ;
145 break;
146 }
147 }
148 } else {
149 std::cout << "error in RooGaussian generateEvent"<< std::endl;
150 }
151
152 return;
153}
int Int_t
Definition: CPyCppyy.h:43
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
#define ClassImp(name)
Definition: Rtypes.h:364
double sqrt(double)
double exp(double)
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
virtual RooSpan< const double > getValues(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet=nullptr) const
by this change, please consult the release notes for ROOT 6.24 for guidance on how to make this trans...
Definition: RooAbsReal.cxx:310
Bool_t matchArgs(const RooArgSet &allDeps, RooArgSet &numDeps, const RooArgProxy &a) const
Utility function for use in getAnalyticalIntegral().
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:35
virtual RooSpan< double > computeGaussian(const RooAbsReal *, RunContext &, RooSpan< const double > x, RooSpan< const double > mean, RooSpan< const double > sigma)=0
Plain Gaussian p.d.f.
Definition: RooGaussian.h:24
RooRealProxy mean
Definition: RooGaussian.h:44
void generateEvent(Int_t code) override
Interface for generation of an event using the algorithm corresponding to the specified code.
Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const override
Load generatedVars with the subset of directVars that we can generate events for, and return a code t...
RooRealProxy sigma
Definition: RooGaussian.h:45
RooSpan< double > evaluateSpan(RooBatchCompute::RunContext &evalData, const RooArgSet *normSet) const override
Compute multiple values of Gaussian distribution.
Definition: RooGaussian.cxx:66
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=0) const override
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
Definition: RooGaussian.cxx:72
Double_t evaluate() const override
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
Definition: RooGaussian.cxx:56
RooRealProxy x
Definition: RooGaussian.h:43
Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const override
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooGaussian.cxx:81
static TRandom * randomGenerator()
Return a pointer to a singleton random-number generator implementation.
Definition: RooRandom.cxx:53
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
double min(const char *rname=0) const
Query lower limit of range. This requires the payload to be RooAbsRealLValue or derived.
double max(const char *rname=0) const
Query upper limit of range. This requires the payload to be RooAbsRealLValue or derived.
virtual Double_t Gaus(Double_t mean=0, Double_t sigma=1)
Samples a random number from the standard Normal (Gaussian) Distribution with the given mean and sigm...
Definition: TRandom.cxx:274
double erfc(double x)
Complementary error function.
const Double_t sigma
Double_t x[n]
Definition: legend1.C:17
static const std::string name("name")
R__EXTERN RooBatchComputeInterface * dispatch
This dispatch pointer points to an implementation of the compute library, provided one has been loade...
void checkRangeOfParameters(const RooAbsReal *callingClass, std::initializer_list< const RooAbsReal * > pars, double min=-std::numeric_limits< double >::max(), double max=std::numeric_limits< double >::max(), bool limitsInAllowedRange=false, std::string const &extraMessage="")
Check if the parameters have a range, and warn if the range extends below / above the set limits.
Definition: RooHelpers.cxx:141
constexpr Double_t Sqrt2()
Definition: TMath.h:88
constexpr Double_t TwoPi()
Definition: TMath.h:44
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31