doc/hackathon/rf210__angularconv_8C.html

#include "RooRealVar.h"

#include "RooDataSet.h"

#include "RooGaussian.h"

#include "RooGenericPdf.h"

#include "RooFormulaVar.h"

#include "RooFFTConvPdf.h"

#include "RooPlot.h"

#include "TCanvas.h"

#include "TAxis.h"

#include "TH1.h"

using namespace RooFit;


void rf210_angularconv()

{

   // S e t u p   c o m p o n e n t   p d f s

   // ---------------------------------------


   // Define angle psi

   RooRealVar psi("psi", "psi", 0, 3.14159268);


   // Define physics pdf T(psi)

   RooGenericPdf Tpsi("Tpsi", "1+sin(2*@0)", psi);


   // Define resolution R(psi)

   RooRealVar gbias("gbias", "gbias", 0.2, 0., 1);

   RooRealVar greso("greso", "greso", 0.3, 0.1, 1.0);

   RooGaussian Rpsi("Rpsi", "Rpsi", psi, gbias, greso);


   // Define cos(psi) and function psif that calculates psi from cos(psi)

   RooRealVar cpsi("cpsi", "cos(psi)", -1, 1);

   RooFormulaVar psif("psif", "acos(cpsi)", cpsi);


   // Define physics pdf also as function of cos(psi): T(psif(cpsi)) = T(cpsi) ;

   RooGenericPdf Tcpsi("T", "1+sin(2*@0)", psif);


   // C o n s t r u c t   c o n v o l u t i o n   p d f  i n   p s i

   // --------------------------------------------------------------


   // Define convoluted pdf as function of psi: M=[T(x)R](psi) = M(psi)

   RooFFTConvPdf Mpsi("Mf", "Mf", psi, Tpsi, Rpsi);


   // Set the buffer fraction to zero to obtain a true cyclical convolution

   Mpsi.setBufferFraction(0);


   // S a m p l e ,   f i t   a n d   p l o t   c o n v o l u t e d   p d f  ( p s i )

   // --------------------------------------------------------------------------------


   // Generate some events in observable psi

   std::unique_ptr<RooDataSet> data_psi{Mpsi.generate(psi, 10000)};


   // Fit convoluted model as function of angle psi

   Mpsi.fitTo(*data_psi, PrintLevel(-1));


   // Plot cos(psi) frame with Mf(cpsi)

   RooPlot *frame1 = psi.frame(Title("Cyclical convolution in angle psi"));

   data_psi->plotOn(frame1);

   Mpsi.plotOn(frame1);


   // Overlay comparison to unsmeared physics pdf T(psi)

   Tpsi.plotOn(frame1, LineColor(kRed));


   // C o n s t r u c t   c o n v o l u t i o n   p d f   i n   c o s ( p s i )

   // --------------------------------------------------------------------------


   // Define convoluted pdf as function of cos(psi): M=[T(x)R](psif(cpsi)) = M(cpsi)

   //

   // Need to give both observable psi here (for definition of convolution)

   // and function psif here (for definition of observables, ultimately in cpsi)

   RooFFTConvPdf Mcpsi("Mf", "Mf", psif, psi, Tpsi, Rpsi);


   // Set the buffer fraction to zero to obtain a true cyclical convolution

   Mcpsi.setBufferFraction(0);


   // S a m p l e ,   f i t   a n d   p l o t   c o n v o l u t e d   p d f  ( c o s p s i )

   // --------------------------------------------------------------------------------


   // Generate some events

   std::unique_ptr<RooDataSet> data_cpsi{Mcpsi.generate(cpsi, 10000)};


   // set psi constant to exclude to be a parameter of the fit

   psi.setConstant(true);


   // Fit convoluted model as function of cos(psi)

   Mcpsi.fitTo(*data_cpsi, PrintLevel(-1));


   // Plot cos(psi) frame with Mf(cpsi)

   RooPlot *frame2 = cpsi.frame(Title("Same convolution in psi, expressed in cos(psi)"));

   data_cpsi->plotOn(frame2);

   Mcpsi.plotOn(frame2);


   // Overlay comparison to unsmeared physics pdf Tf(cpsi)

   Tcpsi.plotOn(frame2, LineColor(kRed));


   // Draw frame on canvas

   TCanvas *c = new TCanvas("rf210_angularconv", "rf210_angularconv", 800, 400);

   c->Divide(2);

   c->cd(1);

   gPad->SetLeftMargin(0.15);

   frame1->GetYaxis()->SetTitleOffset(1.4);

   frame1->Draw();

   c->cd(2);

   gPad->SetLeftMargin(0.15);

   frame2->GetYaxis()->SetTitleOffset(1.4);

   frame2->Draw();

}

c
#define c(i)
Definition RSha256.hxx:101

RooDataSet.h

RooFFTConvPdf.h

RooFormulaVar.h

RooGaussian.h

RooGenericPdf.h

RooPlot.h

RooRealVar.h

kRed
@ kRed
Definition Rtypes.h:67

TAxis.h

TCanvas.h

TH1.h

gPad
#define gPad
Definition TVirtualPad.h:322

RooFFTConvPdf
PDF for the numerical (FFT) convolution of two PDFs.
Definition RooFFTConvPdf.h:25

RooFormulaVar
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition RooFormulaVar.h:30

RooGaussian
Plain Gaussian p.d.f.
Definition RooGaussian.h:24

RooGenericPdf
Implementation of a probability density function that takes a RooArgList of servers and a C++ express...
Definition RooGenericPdf.h:25

RooPlot
Plot frame and a container for graphics objects within that frame.
Definition RooPlot.h:43

RooPlot::frame
static RooPlot * frame(const RooAbsRealLValue &var, double xmin, double xmax, Int_t nBins)
Create a new frame for a given variable in x.
Definition RooPlot.cxx:185

RooPlot::GetYaxis
TAxis * GetYaxis() const
Definition RooPlot.cxx:1230

RooPlot::Draw
void Draw(Option_t *options=nullptr) override
Draw this plot and all of the elements it contains.
Definition RooPlot.cxx:597

RooRealVar
Variable that can be changed from the outside.
Definition RooRealVar.h:37

TAttAxis::SetTitleOffset
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title.
Definition TAttAxis.cxx:279

TCanvas
The Canvas class.
Definition TCanvas.h:23

RooFit::Title
RooCmdArg Title(const char *name)
Definition RooGlobalFunc.cxx:532

RooFit::PrintLevel
RooCmdArg PrintLevel(Int_t code)
Definition RooGlobalFunc.cxx:659

RooFit::LineColor
RooCmdArg LineColor(TColorNumber color)
Definition RooGlobalFunc.cxx:229

RooFit
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:72

rf210_angularconv
Definition rf210_angularconv.py:1