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
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::EvaluateFuncs::poissonEvaluate", xName, mean));
74}
75
76////////////////////////////////////////////////////////////////////////////////
77/// Compute multiple values of the Poisson distribution.
78void RooPoisson::computeBatch(double *output, size_t nEvents,
79 RooFit::Detail::DataMap const &dataMap) const
80{
81 RooBatchCompute::ArgVector extraArgs{static_cast<double>(_protectNegative), static_cast<double>(_noRounding)};
83 {dataMap.at(x), dataMap.at(mean)}, extraArgs);
84}
85
86////////////////////////////////////////////////////////////////////////////////
87
88Int_t RooPoisson::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* /*rangeName*/) const
89{
90 if (matchArgs(allVars,analVars,x)) return 1 ;
91 if (matchArgs(allVars, analVars, mean)) return 2;
92 return 0 ;
93}
94
95////////////////////////////////////////////////////////////////////////////////
96
97double RooPoisson::analyticalIntegral(Int_t code, const char* rangeName) const
98{
99 R__ASSERT(code == 1 || code == 2) ;
100
101 RooRealProxy const &integrand = code == 1 ? x : mean;
103 code, mean, _noRounding ? x : std::floor(x), integrand.min(rangeName), integrand.max(rangeName), _protectNegative);
104}
105
106std::string
108{
109 R__ASSERT(code == 1 || code == 2);
110 std::string xName = ctx.getResult(x);
111 if (!_noRounding)
112 xName = "std::floor(" + xName + ")";
113
114 RooRealProxy const &integrand = code == 1 ? x : mean;
115 // Since the integral function is the same for both codes, we need to make sure the indexed observables do not appear
116 // in the function if they are not required.
117 xName = code == 1 ? "0" : xName;
118 return ctx.buildCall("RooFit::Detail::AnalyticalIntegrals::poissonIntegral", code, mean, xName,
119 integrand.min(rangeName), integrand.max(rangeName), _protectNegative);
120}
121
122////////////////////////////////////////////////////////////////////////////////
123/// Advertise internal generator in x
124
125Int_t RooPoisson::getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, bool /*staticInitOK*/) const
126{
127 if (matchArgs(directVars,generateVars,x)) return 1 ;
128 return 0 ;
129}
130
131////////////////////////////////////////////////////////////////////////////////
132/// Implement internal generator using TRandom::Poisson
133
135{
136 R__ASSERT(code==1) ;
137 double xgen ;
138 while(true) {
140 if (xgen<=x.max() && xgen>=x.min()) {
141 x = xgen ;
142 break;
143 }
144 }
145 return;
146}
#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.
RooBatchCompute::Config config(RooAbsArg const *arg) const
Definition DataMap.cxx:40
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.
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.
void computeBatch(double *output, size_t nEvents, RooFit::Detail::DataMap const &) const override
Compute multiple values of the Poisson distribution.
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:51
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 Int_t Poisson(Double_t mean)
Generates a random integer N according to a Poisson law.
Definition TRandom.cxx:402
Double_t x[n]
Definition legend1.C:17
std::vector< double > ArgVector
void compute(Config cfg, Computer comp, RestrictArr output, size_t size, const VarVector &vars, ArgVector &extraArgs)
double poissonIntegral(int code, double mu, double x, double integrandMin, double integrandMax, unsigned int protectNegative)
double poissonEvaluate(double x, double par)
Little struct that can pack a float into the unused bits of the mantissa of a NaN double.
static void output()