 ROOT   Reference Guide RooArgusBG.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 *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
15 *****************************************************************************/
16
17/** \class RooArgusBG
18 \ingroup Roofit
19
20RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape.
21\f[
22 \mathrm{Argus}(m, m_0, c, p) = \mathcal{N} \cdot m \cdot \left[ 1 - \left( \frac{m}{m_0} \right)^2 \right]^p
23 \cdot \exp\left[ c \cdot \left(1 - \left(\frac{m}{m_0}\right)^2 \right) \right]
24\f]
25\image html RooArgusBG.png
26*/
27
28#include "RooArgusBG.h"
29#include "RooRealVar.h"
30#include "RooRealConstant.h"
31#include "RooMath.h"
32#include "RooBatchCompute.h"
33
34#include "TMath.h"
35
36#include <cmath>
37using namespace std;
38
40
41////////////////////////////////////////////////////////////////////////////////
42/// Constructor.
43
44RooArgusBG::RooArgusBG(const char *name, const char *title,
45 RooAbsReal& _m, RooAbsReal& _m0, RooAbsReal& _c) :
46 RooAbsPdf(name, title),
47 m("m","Mass",this,_m),
48 m0("m0","Resonance mass",this,_m0),
49 c("c","Slope parameter",this,_c),
50 p("p","Power",this,(RooRealVar&)RooRealConstant::value(0.5))
51{
52}
53
54////////////////////////////////////////////////////////////////////////////////
55/// Constructor.
56
57RooArgusBG::RooArgusBG(const char *name, const char *title,
58 RooAbsReal& _m, RooAbsReal& _m0, RooAbsReal& _c, RooAbsReal& _p) :
59 RooAbsPdf(name, title),
60 m("m","Mass",this,_m),
61 m0("m0","Resonance mass",this,_m0),
62 c("c","Slope parameter",this,_c),
63 p("p","Power",this,_p)
64{
65}
66
67////////////////////////////////////////////////////////////////////////////////
68/// Constructor.
69
70RooArgusBG::RooArgusBG(const RooArgusBG& other, const char* name) :
71 RooAbsPdf(other,name),
72 m("m",this,other.m),
73 m0("m0",this,other.m0),
74 c("c",this,other.c),
75 p("p",this,other.p)
76{
77}
78
79////////////////////////////////////////////////////////////////////////////////
80
82 Double_t t= m/m0;
83 if(t >= 1) return 0;
84
85 Double_t u= 1 - t*t;
86 return m*TMath::Power(u,p)*exp(c*u) ;
87}
88
89////////////////////////////////////////////////////////////////////////////////
90
91void RooArgusBG::computeBatch(cudaStream_t* stream, double* output, size_t nEvents, RooBatchCompute::DataMap& dataMap) const
92{
94 dispatch->compute(stream, RooBatchCompute::ArgusBG, output, nEvents, dataMap, {&*m,&*m0,&*c,&*p,&*_norm});
95}
96
97////////////////////////////////////////////////////////////////////////////////
98
99Int_t RooArgusBG::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* /*rangeName*/) const
100{
101 if (p.arg().isConstant()) {
102 // We can integrate over m if power = 0.5
103 if (matchArgs(allVars,analVars,m) && p == 0.5) return 1;
104 }
105 return 0;
106
107}
108
109////////////////////////////////////////////////////////////////////////////////
110
111Double_t RooArgusBG::analyticalIntegral(Int_t code, const char* rangeName) const
112{
113 R__ASSERT(code==1);
114 // Formula for integration over m when p=0.5
115 static const Double_t pi = atan2(0.0,-1.0);
116 Double_t min = (m.min(rangeName) < m0) ? m.min(rangeName) : m0;
117 Double_t max = (m.max(rangeName) < m0) ? m.max(rangeName) : m0;
118 Double_t f1 = (1.-TMath::Power(min/m0,2));
119 Double_t f2 = (1.-TMath::Power(max/m0,2));
120 Double_t aLow, aHigh ;
121 if ( c < 0. ) {
122 aLow = -0.5*m0*m0*(exp(c*f1)*sqrt(f1)/c + 0.5/TMath::Power(-c,1.5)*sqrt(pi)*RooMath::erf(sqrt(-c*f1)));
123 aHigh = -0.5*m0*m0*(exp(c*f2)*sqrt(f2)/c + 0.5/TMath::Power(-c,1.5)*sqrt(pi)*RooMath::erf(sqrt(-c*f2)));
124 } else if ( c == 0. ) {
125 aLow = -m0*m0/3.*f1*sqrt(f1);
126 aHigh = -m0*m0/3.*f1*sqrt(f2);
127 } else {
128 aLow = 0.5*m0*m0*exp(c*f1)/(c*sqrt(c)) * (0.5*sqrt(pi)*(RooMath::faddeeva(sqrt(c*f1))).imag() - sqrt(c*f1));
129 aHigh = 0.5*m0*m0*exp(c*f2)/(c*sqrt(c)) * (0.5*sqrt(pi)*(RooMath::faddeeva(sqrt(c*f2))).imag() - sqrt(c*f2));
130 }
131 Double_t area = aHigh - aLow;
132 //cout << "c = " << c << "aHigh = " << aHigh << " aLow = " << aLow << " area = " << area << endl ;
133 return area;
134
135}
#define c(i)
Definition: RSha256.hxx:101
#define ClassImp(name)
Definition: Rtypes.h:364
#define R__ASSERT(e)
Definition: TError.h:118
char name
Definition: TGX11.cxx:110
Bool_t isConstant() const
Check if the "Constant" attribute is set.
Definition: RooAbsArg.h:382
RooAbsReal * _norm
Definition: RooAbsPdf.h:364
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:63
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
RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape.
Definition: RooArgusBG.h:22
RooRealProxy m
Definition: RooArgusBG.h:37
Double_t evaluate() const
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
Definition: RooArgusBG.cxx:81
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=0) const
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
Definition: RooArgusBG.cxx:99
RooRealProxy c
Definition: RooArgusBG.h:39
RooRealProxy p
Definition: RooArgusBG.h:40
Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooArgusBG.cxx:111
RooRealProxy m0
Definition: RooArgusBG.h:38
void computeBatch(cudaStream_t *, double *output, size_t size, RooBatchCompute::DataMap &) const
Base function for computing multiple values of a RooAbsReal.
Definition: RooArgusBG.cxx:91
virtual void compute(cudaStream_t *, Computer, RestrictArr, size_t, const DataMap &, const VarVector &, const ArgVector &={})=0
static std::complex< double > erf(const std::complex< double > z)
complex erf function
Definition: RooMath.cxx:575
__roodevice__ static __roohost__ std::complex< double > faddeeva(std::complex< double > z)
evaluate Faddeeva function for complex argument
Definition: RooMath.cxx:537
RooRealConstant provides static functions to create and keep track of RooRealVar constants.
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
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.
const T & arg() const
Return reference to object held in proxy.
TF1 * f1
Definition: legend1.C:11
VecExpr< UnaryOp< Sqrt< T >, VecExpr< A, T, D >, T >, T, D > sqrt(const VecExpr< A, T, D > &rhs)
R__EXTERN RooBatchComputeInterface * dispatchCUDA
std::map< DataKey, RooSpan< const double > > DataMap
R__EXTERN RooBatchComputeInterface * dispatchCPU
This dispatch pointer points to an implementation of the compute library, provided one has been loade...
static constexpr double pi
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:685
auto * m
Definition: textangle.C:8
static void output(int code)
Definition: gifencode.c:226