Logo ROOT  
Reference Guide
RooDstD0BG.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitModels *
4 * @(#)root/roofit:$Id$
5 * Authors: *
6 * UE, Ulrik Egede, RAL, U.Egede@rl.ac.uk *
7 * MT, Max Turri, UC Santa Cruz turri@slac.stanford.edu *
8 * CC, Chih-hsiang Cheng, Stanford chcheng@slac.stanford.edu *
9 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
10 * *
11 * Copyright (c) 2000-2005, Regents of the University of California *
12 * RAL and Stanford University. All rights reserved.*
13 * *
14 * Redistribution and use in source and binary forms, *
15 * with or without modification, are permitted according to the terms *
16 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
17 *****************************************************************************/
18
19/** \class RooDstD0BG
20 \ingroup Roofit
21
22Special p.d.f shape that can be used to model the background of
23D*-D0 mass difference distributions. It computes
24
25\f[
26 \mathrm{RooDSTD0}(m \, | \, m_0, A, B, C) =
27 \left(1 - \exp\left(-\frac{m - m_0}{C}\right) \right)
28 \cdot \left(\frac{m}{m_0}\right)^A + B
29 \cdot \left(\frac{m}{m_0} - 1 \right)
30\f]
31**/
32
33#include "RooDstD0BG.h"
34#include "RooFit.h"
35#include "RooAbsReal.h"
36#include "RooRealVar.h"
37#include "RooIntegrator1D.h"
38#include "RooAbsFunc.h"
39#include "RooBatchCompute.h"
40
41#include "TMath.h"
42
43#include <cmath>
44using namespace std;
45
47
48////////////////////////////////////////////////////////////////////////////////
49
50RooDstD0BG::RooDstD0BG(const char *name, const char *title,
51 RooAbsReal& _dm, RooAbsReal& _dm0,
52 RooAbsReal& _c, RooAbsReal& _a, RooAbsReal& _b) :
53 RooAbsPdf(name,title),
54 dm("dm","Dstar-D0 Mass Diff",this, _dm),
55 dm0("dm0","Threshold",this, _dm0),
56 C("C","Shape Parameter",this, _c),
57 A("A","Shape Parameter 2",this, _a),
58 B("B","Shape Parameter 3",this, _b)
59{
60}
61
62////////////////////////////////////////////////////////////////////////////////
63
64RooDstD0BG::RooDstD0BG(const RooDstD0BG& other, const char *name) :
65 RooAbsPdf(other,name), dm("dm",this,other.dm), dm0("dm0",this,other.dm0),
66 C("C",this,other.C), A("A",this,other.A), B("B",this,other.B)
67{
68}
69
70////////////////////////////////////////////////////////////////////////////////
71
73{
74 Double_t arg= dm- dm0;
75 if (arg <= 0 ) return 0;
76 Double_t ratio= dm/dm0;
77 Double_t val= (1- exp(-arg/C))* TMath::Power(ratio, A) + B*(ratio-1);
78
79 return (val > 0 ? val : 0) ;
80}
81
82////////////////////////////////////////////////////////////////////////////////
83/// Compute multiple values of D*-D0 mass difference distribution.
84void RooDstD0BG::computeBatch(cudaStream_t* stream, double* output, size_t nEvents, RooBatchCompute::DataMap& dataMap) const
85{
87 dispatch->compute(stream, RooBatchCompute::DstD0BG, output, nEvents, dataMap, {&*dm,&*dm0,&*C,&*A,&*B,&*_norm});
88}
89
90////////////////////////////////////////////////////////////////////////////////
91/// if (matchArgs(allVars,analVars,dm)) return 1 ;
92
93Int_t RooDstD0BG::getAnalyticalIntegral(RooArgSet& /*allVars*/, RooArgSet& /*analVars*/, const char* /*rangeName*/) const
94{
95 return 0 ;
96}
97
98////////////////////////////////////////////////////////////////////////////////
99
100Double_t RooDstD0BG::analyticalIntegral(Int_t code, const char* rangeName) const
101{
102 switch(code) {
103 case 1:
104 {
105 Double_t min= dm.min(rangeName);
106 Double_t max= dm.max(rangeName);
107 if (max <= dm0 ) return 0;
108 else if (min < dm0) min = dm0;
109
110 Bool_t doNumerical= kFALSE;
111 if ( A != 0 ) doNumerical= kTRUE;
112 else if (B < 0) {
113 // If b<0, pdf can be negative at large dm, the integral should
114 // only up to where pdf hits zero. Better solution should be
115 // solve the zero and use it as max.
116 // Here we check this whether pdf(max) < 0. If true, let numerical
117 // integral take care of. ( kind of ugly!)
118 if ( 1- exp(-(max-dm0)/C) + B*(max/dm0 -1) < 0) doNumerical= kTRUE;
119 }
120 if ( ! doNumerical ) {
121 return (max-min)+ C* exp(dm0/C)* (exp(-max/C)- exp(-min/C)) +
122 B * (0.5* (max*max - min*min)/dm0 - (max- min));
123 } else {
124 // In principle the integral for a!=0 can be done analytically.
125 // It involves incomplete Gamma function, TMath::Gamma(a+1,m/c),
126 // which is not defined for a < -1. And the whole expression is
127 // not stable for m/c >> 1.
128 // Do numerical integral
129 RooArgSet vset(dm.arg(),"vset");
130 RooAbsFunc *func= bindVars(vset);
131 RooIntegrator1D integrator(*func,min,max);
132 return integrator.integral();
133 }
134 }
135 }
136
137 assert(0) ;
138 return 0 ;
139}
const Bool_t kFALSE
Definition: RtypesCore.h:101
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassImp(name)
Definition: Rtypes.h:364
char name[80]
Definition: TGX11.cxx:110
Abstract interface for evaluating a real-valued function of one real variable and performing numerica...
Definition: RooAbsFunc.h:27
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
RooAbsFunc * bindVars(const RooArgSet &vars, const RooArgSet *nset=0, Bool_t clipInvalid=kFALSE) const
Create an interface adaptor f(vars) that binds us to the specified variables (in arbitrary order).
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:35
virtual void compute(cudaStream_t *, Computer, RestrictArr, size_t, const DataMap &, const VarVector &, const ArgVector &={})=0
Special p.d.f shape that can be used to model the background of D*-D0 mass difference distributions.
Definition: RooDstD0BG.h:26
RooRealProxy B
Definition: RooDstD0BG.h:45
RooRealProxy dm
Definition: RooDstD0BG.h:43
RooRealProxy A
Definition: RooDstD0BG.h:45
Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
Definition: RooDstD0BG.cxx:100
RooRealProxy dm0
Definition: RooDstD0BG.h:44
void computeBatch(cudaStream_t *, double *output, size_t nEvents, RooBatchCompute::DataMap &) const
Compute multiple values of D*-D0 mass difference distribution.
Definition: RooDstD0BG.cxx:84
RooRealProxy C
Definition: RooDstD0BG.h:45
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=0) const
if (matchArgs(allVars,analVars,dm)) return 1 ;
Definition: RooDstD0BG.cxx:93
Double_t evaluate() const
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
Definition: RooDstD0BG.cxx:72
RooIntegrator1D implements an adaptive one-dimensional numerical integration algorithm.
virtual Double_t integral(const Double_t *yvec=0)
Calculate numeric integral at given set of function binding parameters.
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.
static double B[]
static double A[]
static double C[]
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...
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:685
static void output(int code)
Definition: gifencode.c:226