LimitSetting/RooPDF_BKG_DeltaAdditionTest.cxx at main · IMSA-CMS/LimitSetting · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/*****************************************************************************
 * Project: RooFit                                                           *
 *                                                                           *
 * This code was autogenerated by RooClassFactory                            *
 *****************************************************************************/

// Your description goes here...
// Test background class for adding in systematics

#include "RooPDF_BKG_DeltaAdditionTest.h"

#include <RooAbsReal.h>
#include <RooAbsCategory.h>

#include <Riostream.h>
#include <TMath.h>

#include <cmath>

ClassImp(RooPDF_BKG_DeltaAdditionTest);

RooPDF_BKG_DeltaAdditionTest::RooPDF_BKG_DeltaAdditionTest(const char *name, const char *title,
                        RooAbsReal& _x, const double _delta, const std::vector<std::vector<double>>& _bkg_params,
                        const std::vector<std::vector<double>>& _bkg_paramUpperValues,
                        const std::vector<std::vector<double>>& _bkg_paramLowerValues,
                        const std::string _channel_name)
   : RooAbsPdf(name,title),
   x("x","x",this,_x)
   bkg_params(_bkg_params),
   bkg_paramUpperValues(_bkg_paramUpperValues),
   bkg_paramLowerValues(_bkg_paramLowerValues),
   channel_name(_channel_name),
   delta(_delta)
{
}

RooPDF_BKG_DeltaAdditionTest::RooPDF_BKG_DeltaAdditionTest(RooPDF_BKG_DeltaAdditionTest const &other, const char *name)
   : RooAbsPdf(other,name),
   x("x",this,other.x)
   bkg_params(other.bkg_params),
   bkg_paramUpperValues(other.bkg_paramUpperValues),
   bkg_paramLowerValues(other.bkg_paramLowerValues),
   channel_name(other.channel_name)
   delta(other.delta)

{
}

RooPDF_BKG_DeltaAdditionTest::AddUncertaintyToParams(std::vector<double> nominalParams, std::vector<double> paramUpperValues, std::vector<double>paramLowerValues)
{

   // Check if there is a corresponding upper and lower value for each parameter
   if (nominalParams.size() != paramUpperValues.size() || nominalParams.size() != paramLowerValues.size() || paramLowerValues.size() != paramUpperValues.size())
   {
      throw std::runtime_error("Not equal number of params, upper values for params, and lower values for params");
   }

   std::vector<double> adjustedParams;
   if (delta > 0)
   {
      for (int param = 0; param < nominalParams.size(); param++)
      {
         adjustedParams.push_back(nominalParams[param] + delta * (paramUpperValues[param] - nominalParams[param]));
      }
   }
   else
   {
      for (int param = 0; param < nominalParams.size(); param++)
      {
         adjustedParams.push_back(nominalParams[param] - delta * (paramLowerValues[param] - nominalParams[param]));
      }
      // for (double param : nominalParams)
      // {
      //    adjustedParams.push_back(param - delta * (lowerValue - param))
      // }
   }
   return adjustedParams;

}

 RooGenericPdf RooPDF_BKG_DeltaAdditionTest::ttbar()
 {
  std::vector<double> bkg_type = AddUncertaintyToParams(bkg_params[0], bkg_paramUpperValues[0], bkg_paramLowerValues[0]);
  std::string bkg_Function = std::to_string(bkg_type[0]) + "* (@0-" + std::to_string(bkg_type[1]) + ")^" + std::to_string(bkg_type[2]);
  RooGenericPdf bkg_ttbar((channel_name + "_bkg_ttbar").c_str(), bkg_Function.c_str(), RooArgSet(*x.absArg()));
  return bkg_ttbar;
 }

 RooGenericPdf RooPDF_BKG_DeltaAdditionTest::ZZ()
 {
  std::vector<double> bkg_type = AddUncertaintyToParams(bkg_params[1], bkg_paramUpperValues[1], bkg_paramLowerValues[1]);
  std::string bkg_Function = std::to_string(bkg_type[0]) + "* (@0-" + std::to_string(bkg_type[1]) + ")^" + std::to_string(bkg_type[2]);
  RooGenericPdf bkg_ZZ((channel_name + "_bkg_ZZ").c_str(), bkg_Function.c_str(), RooArgSet(*x.absArg()));
  return bkg_ZZ;
 }

 RooGenericPdf RooPDF_BKG_DeltaAdditionTest::DY()
 {
  std::vector<double> bkg_type = AddUncertaintyToParams(bkg_params[2], bkg_paramUpperValues[2], bkg_paramLowerValues[2]);
  std::string bkg_Function = std::to_string(bkg_type[0]) + "* (@0-" + std::to_string(bkg_type[1]) + ")^" + std::to_string(bkg_type[2]);
  RooGenericPdf bkg_DY((channel_name + "_bkg_DY").c_str(), bkg_Function.c_str(), RooArgSet(*x.absArg()));
  return bkg_DY;
 }

 RooGenericPdf RooPDF_BKG_DeltaAdditionTest::TTZ()
 {
  std::vector<double> bkg_type = AddUncertaintyToParams(bkg_params[3], bkg_paramUpperValues[3], bkg_paramLowerValues[3]);
  std::string bkg_Function = std::to_string(bkg_type[0]) + "* (@0-" + std::to_string(bkg_type[1]) + ")^" + std::to_string(bkg_type[2]);
  RooGenericPdf bkg_TTZ((channel_name + "_bkg_TTZ").c_str(), bkg_Function.c_str(), RooArgSet(*x.absArg()));
  return bkg_TTZ;
 }


 Double_t RooPDF_BKG_DeltaAdditionTest::evaluate() const
 {
  std::vector<double> component_functions;
  double function_sum = 0;
	for (std::vector<double> bkg_type : bkg_params)
	{
	  double bkg_component = bkg_type[0] * std::pow((x - bkg_type[1]),bkg_type[2]);
		component_functions.push_back(bkg_component);
    function_sum += bkg_component;
	}

  return function_sum;
 }