Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooPoisson.cxx
Go to the documentation of this file.
1 /*****************************************************************************
2 * Project: RooFit *
3 * *
4 * Simple Poisson PDF
5 * author: Kyle Cranmer <cranmer@cern.ch>
6 * *
7 *****************************************************************************/
8
9/** \class RooPoisson
10 \ingroup Roofit
11
12Poisson pdf
13**/
14
15#include "RooPoisson.h"
16#include "RooRandom.h"
17#include "RooMath.h"
18#include "RooNaNPacker.h"
19#include "RooBatchCompute.h"
20
22
23#include <array>
24
26
27////////////////////////////////////////////////////////////////////////////////
28/// Constructor
29
30RooPoisson::RooPoisson(const char *name, const char *title,
32 RooAbsReal::Ref _mean,
33 bool noRounding) :
34 RooAbsPdf(name,title),
35 x("x","x",this,_x),
36 mean("mean","mean",this,_mean),
37 _noRounding(noRounding)
38{
39}
40
41////////////////////////////////////////////////////////////////////////////////
42/// Copy constructor
43
44 RooPoisson::RooPoisson(const RooPoisson& other, const char* name) :
45 RooAbsPdf(other,name),
46 x("x",this,other.x),
47 mean("mean",this,other.mean),
48 _noRounding(other._noRounding),
49 _protectNegative(other._protectNegative)
50{
51}
52
53////////////////////////////////////////////////////////////////////////////////
54/// Implementation in terms of the TMath::Poisson() function.
55
57{
58 double k = _noRounding ? x : floor(x);
59 if(_protectNegative && mean<0) {
61 np.setPayload(-mean);
62 return np._payload;
63 }
65}
66
68{
69 std::string xName = ctx.getResult(x);
70 if (!_noRounding)
71 xName = "std::floor(" + xName + ")";
72
73 ctx.addResult(this, ctx.buildCall("RooFit::Detail::MathFuncs::poisson", xName, mean));
74}
75
76////////////////////////////////////////////////////////////////////////////////
77/// Compute multiple values of the Poisson distribution.
79{
80 std::array<double, 2> extraArgs{static_cast<double>(_protectNegative), static_cast<double>(_noRounding)};
81 RooBatchCompute::compute(ctx.config(this), RooBatchCompute::Poisson, ctx.output(), {ctx.at(x), ctx.at(mean)},
82 extraArgs);
83}
84
85////////////////////////////////////////////////////////////////////////////////
86
87Int_t RooPoisson::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* /*rangeName*/) const
88{
89 if (matchArgs(allVars,analVars,x)) return 1 ;
90 if (matchArgs(allVars, analVars, mean)) return 2;
91 return 0 ;
92}
93
94////////////////////////////////////////////////////////////////////////////////
95
96double RooPoisson::analyticalIntegral(Int_t code, const char* rangeName) const
97{
98 R__ASSERT(code == 1 || code == 2) ;
99
100 RooRealProxy const &integrand = code == 1 ? x : mean;
102 code, mean, _noRounding ? x : std::floor(x), integrand.min(rangeName), integrand.max(rangeName), _protectNegative);
103}
104
105std::string
107{
108 R__ASSERT(code == 1 || code == 2);
109 std::string xName = ctx.getResult(x);
110 if (!_noRounding)
111 xName = "std::floor(" + xName + ")";
112
113 RooRealProxy const &integrand = code == 1 ? x : mean;
114 // Since the integral function is the same for both codes, we need to make sure the indexed observables do not appear
115 // in the function if they are not required.
116 xName = code == 1 ? "0" : xName;
117 return ctx.buildCall("RooFit::Detail::MathFuncs::poissonIntegral", code, mean, xName,
118 integrand.min(rangeName), integrand.max(rangeName), _protectNegative);
119}
120
121////////////////////////////////////////////////////////////////////////////////
122/// Advertise internal generator in x
123
124Int_t RooPoisson::getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, bool /*staticInitOK*/) const
125{
126 if (matchArgs(directVars,generateVars,x)) return 1 ;
127 return 0 ;
128}
129
130////////////////////////////////////////////////////////////////////////////////
131/// Implement internal generator using TRandom::Poisson
132
134{
135 R__ASSERT(code==1) ;
136 double xgen ;
137 while(true) {
139 if (xgen<=x.max() && xgen>=x.min()) {
140 x = xgen ;
141 break;
142 }
143 }
144 return;
145}
#define ClassImp(name)
Definition Rtypes.h:377
#define R__ASSERT(e)
Definition TError.h:118
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t np
char name[80]
Definition TGX11.cxx:110
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:40
A RooAbsReal::Ref can be constructed from a RooAbsReal& or a double that will be implicitly converted...
Definition RooAbsReal.h:68
bool 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:55
A class to maintain the context for squashing of RooFit models into code.
std::string buildCall(std::string const &funcname, Args_t const &...args)
Build the code to call the function with name funcname, passing some arguments.
void addResult(RooAbsArg const *key, std::string const &value)
A function to save an expression that includes/depends on the result of the input node.
std::string const & getResult(RooAbsArg const &arg)
Gets the result for the given node using the node name.
std::span< double > output()
RooBatchCompute::Config config(RooAbsArg const *arg) const
Poisson pdf.
Definition RooPoisson.h:19
RooRealProxy x
Definition RooPoisson.h:54
bool _noRounding
Definition RooPoisson.h:56
double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const override
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
void translate(RooFit::Detail::CodeSquashContext &ctx) const override
This function defines a translation for each RooAbsReal based object that can be used to express the ...
bool _protectNegative
Definition RooPoisson.h:57
void generateEvent(Int_t code) override
Implement internal generator using TRandom::Poisson.
void doEval(RooFit::EvalContext &) const override
Compute multiple values of the Poisson distribution.
Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, bool staticInitOK=true) const override
Advertise internal generator in x.
double evaluate() const override
Implementation in terms of the TMath::Poisson() function.
RooRealProxy mean
Definition RooPoisson.h:55
std::string buildCallToAnalyticIntegral(int code, const char *rangeName, RooFit::Detail::CodeSquashContext &ctx) const override
This function defines the analytical integral translation for the class.
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=nullptr) const override
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
static TRandom * randomGenerator()
Return a pointer to a singleton random-number generator implementation.
Definition RooRandom.cxx:48
double max(const char *rname=nullptr) const
Query upper limit of range. This requires the payload to be RooAbsRealLValue or derived.
double min(const char *rname=nullptr) const
Query lower limit of range. This requires the payload to be RooAbsRealLValue or derived.
virtual ULong64_t Poisson(Double_t mean)
Generates a random integer N according to a Poisson law.
Definition TRandom.cxx:404
Double_t x[n]
Definition legend1.C:17
void compute(Config cfg, Computer comp, std::span< double > output, VarSpan vars, ArgSpan extraArgs={})
double poisson(double x, double par)
Definition MathFuncs.h:198
double poissonIntegral(int code, double mu, double x, double integrandMin, double integrandMax, unsigned int protectNegative)
Definition MathFuncs.h:580
Little struct that can pack a float into the unused bits of the mantissa of a NaN double.