CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Functions.h
Go to the documentation of this file.
1 #ifndef FUNCTIONS_H
2 #define FUNCTIONS_H
3 
4 #include <iostream>
5 #include <vector>
6 #include <cmath>
7 #include "TMath.h"
8 #include "TString.h"
9 #include "TF1.h"
10 #include "TRandom.h"
11 #include "MuonAnalysis/MomentumScaleCalibration/interface/SigmaPtDiff.h"
12 
16 struct ParameterSet
17 {
18  ParameterSet() {}
19  ParameterSet(const TString & inputName, const double & inputStep, const double & inputMini, const double & inputMaxi) :
20  step(inputStep),
21  mini(inputMini),
22  maxi(inputMaxi)
23  {
24  std::cout << "setting name = " << inputName << std::endl;
25  name = inputName;
26  }
27  TString name;
28  double step, mini, maxi;
29 };
30 
31 // ----------------------- //
32 // Bias and scale functors //
33 // ----------------------- //
43 template <class T>
44 class scaleFunctionBase {
45  public:
46  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const = 0;
47  virtual ~scaleFunctionBase() = 0;
49  virtual void resetParameters(std::vector<double> * scaleVec) const {
50  std::cout << "ERROR: the resetParameters method must be defined in each scale function" << std::endl;
51  std::cout << "Please add it to the scaleFunction you are using" << std::endl;
52  exit(1);
53  }
55  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) = 0;
56  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
57  const T & parResol, const std::vector<int> & parResolOrder,
58  const std::vector<double> & parStep,
59  const std::vector<double> & parMin,
60  const std::vector<double> & parMax,
61  const int muonType)
62  {
63  std::cout << "The method setParameters must be implemented for this scale function" << std::endl;
64  exit(1);
65  }
66  virtual int parNum() const { return parNum_; }
67  protected:
68  int parNum_;
70  virtual void setPar(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
71  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder,
72  double* thisStep, double* thisMini, double* thisMaxi, TString* thisParName ) {
73  for( int iPar=0; iPar<this->parNum_; ++iPar ) {
74  Start[iPar] = parScale[iPar];
75  Step[iPar] = thisStep[iPar];
76  Mini[iPar] = thisMini[iPar];
77  Maxi[iPar] = thisMaxi[iPar];
78  ind[iPar] = parScaleOrder[iPar];
79  parname[iPar] = thisParName[iPar];
80  }
81  }
82  virtual void setPar(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
83  TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const std::vector<ParameterSet> & parSet ) {
84  if( int(parSet.size()) != this->parNum_ ) {
85  std::cout << "Error: wrong number of parameter initializations = " << parSet.size() << ". Number of parameters is " << this->parNum_ << std::endl;
86  exit(1);
87  }
88  for( int iPar=0; iPar<this->parNum_; ++iPar ) {
89  Start[iPar] = parResol[iPar];
90  Step[iPar] = parSet[iPar].step;
91  Mini[iPar] = parSet[iPar].mini;
92  Maxi[iPar] = parSet[iPar].maxi;
93  ind[iPar] = parResolOrder[iPar];
94  parname[iPar] = parSet[iPar].name;
95  }
96  }
97 };
98 
99 template <class T> inline scaleFunctionBase<T>::~scaleFunctionBase() { } // defined even though it's pure virtual; should be faster this way.
100 // No scale
101 // --------
102 template <class T>
103 class scaleFunctionType0 : public scaleFunctionBase<T> {
104 public:
105  scaleFunctionType0() {
106  // One of the two is required. This follows from when templates are used by the compiler and the names lookup rules in c++.
107  // scaleFunctionBase<T>::parNum_ = 0;
108  this->parNum_ = 0;
109  }
110  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const { return pt; }
111  virtual void resetParameters(std::vector<double> * scaleVec) const {}
112  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {}
113 };
114 // Linear in pt
115 // ------------
116 template <class T>
117 class scaleFunctionType1 : public scaleFunctionBase<T> {
118 public:
119  scaleFunctionType1() { this->parNum_ = 2; }
120  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
121  return ( (parScale[0] + parScale[1]*pt)*pt );
122  }
123  // Fill the scaleVec with neutral parameters
124  virtual void resetParameters(std::vector<double> * scaleVec) const {
125  scaleVec->push_back(1);
126  for( int i=1; i<this->parNum_; ++i ) {
127  scaleVec->push_back(0);
128  }
129  }
130  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
131  double thisStep[] = {0.001, 0.01};
132  TString thisParName[] = {"Pt offset", "Pt slope"};
133  if( muonType == 1 ) {
134  double thisMini[] = {0.97, -0.1};
135  double thisMaxi[] = {1.03, 0.1};
136  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
137  } else {
138  double thisMini[] = {0.97, -0.1};
139  double thisMaxi[] = {1.03, 0.1};
140  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
141  }
142  }
143 
144  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
145  const T & parResol, const std::vector<int> & parResolOrder,
146  const std::vector<double> & parStep,
147  const std::vector<double> & parMin,
148  const std::vector<double> & parMax,
149  const int muonType)
150  {
151  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
152  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
153  std::cout << "parNum = " << this->parNum_ << std::endl;
154  std::cout << "parStep.size() = " << parStep.size() << std::endl;
155  std::cout << "parMin.size() = " << parMin.size() << std::endl;
156  std::cout << "parMax.size() = " << parMax.size() << std::endl;
157  exit(1);
158  }
159  std::vector<ParameterSet> parSet(this->parNum_);
160  // name, step, mini, maxi
161 
162  parSet[0] = ParameterSet( "Pt offset", parStep[0], parMin[0], parMax[0] );
163  parSet[1] = ParameterSet( "Pt slope" , parStep[1], parMin[1], parMax[1] );
164 
165 
166  std::cout << "setting parameters" << std::endl;
167  for( int i=0; i<this->parNum_; ++i ) {
168  std::cout << "parStep["<<i<<"] = " << parStep[i]
169  << ", parMin["<<i<<"] = " << parMin[i]
170  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
171  }
172  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
173  }
174 };
175 // Linear in |eta|
176 // ---------------
177 template <class T>
178 class scaleFunctionType2 : public scaleFunctionBase<T> {
179 public:
180  scaleFunctionType2() { this->parNum_ = 2; }
181  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
182  return ( (parScale[0] + parScale[1]*std::fabs(eta))*pt );
183  }
184  // Fill the scaleVec with neutral parameters
185  virtual void resetParameters(std::vector<double> * scaleVec) const {
186  scaleVec->push_back(1);
187  for( int i=1; i<this->parNum_; ++i ) {
188  scaleVec->push_back(0);
189  }
190  }
191  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
192  double thisStep[] = {0.001, 0.01};
193  TString thisParName[] = {"Eta offset", "Eta slope"};
194  if( muonType == 1 ) {
195  double thisMini[] = {0.9, -0.3};
196  double thisMaxi[] = {1.1, 0.3};
197  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
198  } else {
199  double thisMini[] = {0.97, -0.1};
200  double thisMaxi[] = {1.03, 0.1};
201  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
202  }
203  }
204 };
205 // Sinusoidal in phi
206 // -----------------
207 template <class T>
208 class scaleFunctionType3 : public scaleFunctionBase<T> {
209 public:
210  scaleFunctionType3() { this->parNum_ = 4; }
211  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
212  return( (parScale[0] + parScale[1]*sin(parScale[2]*phi + parScale[3]))*pt );
213  }
214  // Fill the scaleVec with neutral parameters
215  virtual void resetParameters(std::vector<double> * scaleVec) const {
216  scaleVec->push_back(1);
217  for( int i=1; i<this->parNum_; ++i ) {
218  scaleVec->push_back(0);
219  }
220  }
221  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
222  double thisStep[] = {0.001, 0.01, 0.01, 0.01};
223  TString thisParName[] = {"Phi offset", "Phi ampl", "Phi freq", "Phi phase"};
224  if( muonType == 1 ) {
225  double thisMini[] = {0.9, -0.1, -0.1, -0.1};
226  double thisMaxi[] = {1.1, 0.1, 0.1, 0.1};
227  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
228  } else {
229  double thisMini[] = {0.97, -0.05, 6, -3.14};
230  double thisMaxi[] = {1.03, 0.05, 0.1, 3.14};
231  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
232  }
233  }
234 };
235 // Linear in pt and |eta|
236 // ----------------------
237 template <class T>
238 class scaleFunctionType4 : public scaleFunctionBase<T> {
239 public:
240  scaleFunctionType4() { this->parNum_ = 3; }
241  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
242  return( (parScale[0] + parScale[1]*pt +
243  parScale[2]*std::fabs(eta))*pt );
244  }
245  // Fill the scaleVec with neutral parameters
246  virtual void resetParameters(std::vector<double> * scaleVec) const {
247  scaleVec->push_back(1);
248  for( int i=1; i<this->parNum_; ++i ) {
249  scaleVec->push_back(0);
250  }
251  }
252  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
253  double thisStep[] = {0.001, 0.01, 0.01};
254  TString thisParName[] = {"Pt offset", "Pt slope", "Eta slope"};
255  if( muonType == 1 ) {
256  double thisMini[] = {0.9, -0.1, -0.1};
257  double thisMaxi[] = {1.1, 0.1, 0.1};
258  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
259  } else {
260  double thisMini[] = {0.97, -0.02, -0.02};
261  double thisMaxi[] = {1.03, 0.02, 0.02};
262  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
263  }
264  }
265 };
266 // Linear in pt and sinusoidal in phi
267 // ----------------------------------
268 template <class T>
269 class scaleFunctionType5 : public scaleFunctionBase<T> {
270 public:
271  scaleFunctionType5() { this->parNum_ = 3; }
272  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
273  return( (parScale[0] + parScale[1]*pt +
274  parScale[2]*sin(phi))*pt );
275  }
276  // Fill the scaleVec with neutral parameters
277  virtual void resetParameters(std::vector<double> * scaleVec) const {
278  scaleVec->push_back(1);
279  for( int i=1; i<this->parNum_; ++i ) {
280  scaleVec->push_back(0);
281  }
282  }
283  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
284  double thisStep[] = {0.001, 0.01, 0.01};
285  TString thisParName[] = {"Pt offset", "Pt slope", "Phi ampl"};
286  if( muonType == 1 ) {
287  double thisMini[] = {0.9, -0.1, -0.3};
288  double thisMaxi[] = {1.1, 0.1, 0.3};
289  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
290  } else {
291  double thisMini[] = {0.97, -0.02, -0.3};
292  double thisMaxi[] = {1.03, 0.02, 0.3};
293  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
294  }
295  }
296 };
297 // Linear in |eta| and sinusoidal in phi
298 // -------------------------------------
299 template <class T>
300 class scaleFunctionType6 : public scaleFunctionBase<T> {
301 public:
302  scaleFunctionType6() { this->parNum_ = 3; }
303  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
304  return (parScale[0] + parScale[1]*std::fabs(eta) +
305  parScale[2]*sin(phi))*pt;
306  }
307  // Fill the scaleVec with neutral parameters
308  virtual void resetParameters(std::vector<double> * scaleVec) const {
309  // scaleVec->push_back(1);
310  for( int i=1; i<this->parNum_; ++i ) {
311  scaleVec->push_back(0);
312  }
313  }
314  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
315  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
316  double thisStep[] = {0.001, 0.01, 0.01};
317  TString thisParName[] = {"Eta offset", "Eta slope", "Phi ampl"};
318  if( muonType == 1 ) {
319  double thisMini[] = {0.9, -0.1, -0.3};
320  double thisMaxi[] = {1.1, 0.1, 0.3};
321  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
322  } else {
323  double thisMini[] = {0.97, -0.02, -0.3};
324  double thisMaxi[] = {1.03, 0.02, 0.3};
325  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
326  }
327  }
328 
329  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
330  const T & parScale, const std::vector<int> & parScaleOrder,
331  const std::vector<double> & parStep,
332  const std::vector<double> & parMin,
333  const std::vector<double> & parMax,
334  const int muonType)
335  {
336  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
337  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
338  std::cout << "parNum = " << this->parNum_ << std::endl;
339  std::cout << "parStep.size() = " << parStep.size() << std::endl;
340  std::cout << "parMin.size() = " << parMin.size() << std::endl;
341  std::cout << "parMax.size() = " << parMax.size() << std::endl;
342  exit(1);
343  }
344  std::vector<ParameterSet> parSet(this->parNum_);
345  // name, step, mini, maxi
346  parSet[0] = ParameterSet( "Eta offset", parStep[0], parMin[0], parMax[0] );
347  parSet[1] = ParameterSet( "Eta slope", parStep[1], parMin[1], parMax[1] );
348  parSet[2] = ParameterSet( "Phi ampl", parStep[2], parMin[2], parMax[2] );
349 
350  std::cout << "setting parameters" << std::endl;
351  for( int i=0; i<this->parNum_; ++i ) {
352  std::cout << "parStep["<<i<<"] = " << parStep[i]
353  << ", parMin["<<i<<"] = " << parMin[i]
354  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
355  }
356  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
357  }
358 
359 };
360 // Linear in pt and |eta| and sinusoidal in phi
361 // --------------------------------------------
362 template <class T>
363 class scaleFunctionType7 : public scaleFunctionBase<T> {
364 public:
365  scaleFunctionType7() { this->parNum_ = 4; }
366  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
367  return( (parScale[0] + parScale[1]*pt +
368  parScale[2]*std::fabs(eta) +
369  parScale[3]*sin(phi))*pt );
370  }
371  // Fill the scaleVec with neutral parameters
372  virtual void resetParameters(std::vector<double> * scaleVec) const {
373  scaleVec->push_back(1);
374  for( int i=1; i<this->parNum_; ++i ) {
375  scaleVec->push_back(0);
376  }
377  }
378  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
379  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
380  double thisStep[] = {0.001, 0.01, 0.01, 0.01};
381  TString thisParName[] = {"Pt offset", "Pt slope", "Eta slope", "Phi ampl"};
382  if( muonType == 1 ) {
383  double thisMini[] = {0.9, -0.1, -0.3, -0.3};
384  double thisMaxi[] = {1.1, 0.1, 0.3, 0.3};
385  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
386  } else {
387  double thisMini[] = {0.97, -0.02, -0.3, -0.3};
388  double thisMaxi[] = {1.03, 0.02, 0.3, 0.3};
389  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
390  }
391  }
392 };
393 // Linear in pt and parabolic in |eta|
394 // -----------------------------------
395 template <class T>
396 class scaleFunctionType8 : public scaleFunctionBase<T> {
397 public:
398  scaleFunctionType8() { this->parNum_ = 4; }
399  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
400  return( (parScale[0] + parScale[1]*pt +
401  parScale[2]*std::fabs(eta) +
402  parScale[3]*eta*eta)*pt );
403  }
404  // Fill the scaleVec with neutral parameters
405  virtual void resetParameters(std::vector<double> * scaleVec) const {
406  scaleVec->push_back(1);
407  for( int i=1; i<this->parNum_; ++i ) {
408  scaleVec->push_back(0);
409  }
410  }
411  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
412  double thisStep[] = {0.00001, 0.000001, 0.0000001, 0.0000001};
413  TString thisParName[] = {"Pt offset", "Pt slope", "Eta slope", "Eta quadr"};
414  if( muonType == 1 ) {
415  double thisMini[] = {0.9, -0.3, -0.3, -0.3};
416  double thisMaxi[] = {1.1, 0.3, 0.3, 0.3};
417  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
418  } else {
419  // double thisMini[] = {0.985, -0.002, -0.005, -0.005};
420  // double thisMaxi[] = {1.015, 0.002, 0.005, 0.005};
421  double thisMini[] = {0.9, -0.002, -0.01, -0.005};
422  double thisMaxi[] = {1.1, 0.002, 0.01, 0.005};
423  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
424  }
425  }
426 };
427 // Exponential in pt
428 // -----------------
429 template <class T>
430 class scaleFunctionType9 : public scaleFunctionBase<T> {
431 public:
432  scaleFunctionType9() { this->parNum_ = 2; }
433  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
434  return( (parScale[0] + exp(parScale[1]*pt))*pt );
435  }
436  // Fill the scaleVec with neutral parameters
437  virtual void resetParameters(std::vector<double> * scaleVec) const {
438  scaleVec->push_back(1);
439  for( int i=1; i<this->parNum_; ++i ) {
440  scaleVec->push_back(0);
441  }
442  }
443  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
444  double thisStep[] = {0.001, 0.01};
445  TString thisParName[] = {"Pt offset", "Pt expon"};
446  double thisMini[] = {0.97, -0.1};
447  double thisMaxi[] = {1.03, 0.1};
448  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
449  }
450 };
451 // Parabolic in pt
452 // ---------------
453 template <class T>
454 class scaleFunctionType10 : public scaleFunctionBase<T> {
455 public:
456  scaleFunctionType10() { this->parNum_ = 3; }
457  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
458  return( (parScale[0] + parScale[1]*pt +
459  parScale[2]*pt*pt)*pt );
460  }
461  // Fill the scaleVec with neutral parameters
462  virtual void resetParameters(std::vector<double> * scaleVec) const {
463  scaleVec->push_back(1);
464  for( int i=1; i<this->parNum_; ++i ) {
465  scaleVec->push_back(0);
466  }
467  }
468  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
469  double thisStep[] = {0.001, 0.01, 0.01};
470  TString thisParName[] = {"Pt offset", "Pt slope", "Pt quadr"};
471  double thisMini[] = {0.97, -0.1, -0.001};
472  double thisMaxi[] = {1.03, 0.1, 0.001};
473  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
474  }
475 };
476 // Linear in pt, sinusoidal in phi with muon sign
477 // ----------------------------------------------
478 
479 // UNCOMMENT to get the original one ------
480 // template <class T>
481 // class scaleFunctionType11 : public scaleFunctionBase<T> {
482 // public:
483 // scaleFunctionType11() { this->parNum_ = 4; }
484 // virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
485 // return( (parScale[0] + parScale[1]*pt +
486 // (double)chg*parScale[2]*sin(phi+parScale[3]))*pt );
487 // }
488 // // Fill the scaleVec with neutral parameters
489 // virtual void resetParameters(std::vector<double> * scaleVec) const {
490 // scaleVec->push_back(1);
491 // for( int i=1; i<this->parNum_; ++i ) {
492 // scaleVec->push_back(0);
493 // }
494 // }
495 // virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
496 // double thisStep[] = {0.001, 0.001, 0.01, 0.1};
497 // TString thisParName[] = {"Pt scale", "Pt slope", "Phi ampl", "Phi phase"};
498 // double thisMini[] = {0.97, -0.01, -0.02, -3.1416};
499 // double thisMaxi[] = {1.03, 0.01, 0.02, 3.1416};
500 // this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
501 // }
502 // };
503 
504 // VALID FUNCTION 23-01-2010 ---------
505 template <class T>
506 class scaleFunctionType11 : public scaleFunctionBase<T> {
507 public:
508  scaleFunctionType11() { this->parNum_ = 5; }
509  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
510  return( (parScale[0] + parScale[1]*pt + (double)chg*parScale[4]*eta +
511  (double)chg*parScale[2]*sin(phi+parScale[3]))*pt );
512  }
513  // Fill the scaleVec with neutral parameters
514  virtual void resetParameters(std::vector<double> * scaleVec) const {
515  scaleVec->push_back(1);
516  for( int i=1; i<this->parNum_; ++i ) {
517  scaleVec->push_back(0);
518  }
519  }
520  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
521  double thisStep[] = {0.001, 0.01, 0.01, 0.1,0.01};
522  TString thisParName[] = {"Pt scale", "Pt slope", "Phi ampl", "Phi phase","Eta coeff"};
523  double thisMini[] = {0.9, -0.1, -0.02, -3.1416,-0.2};
524  double thisMaxi[] = {1.1, 0.1, 0.02, 3.1416,0.2};
525 
526  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
527  }
528 };
529 
531 // template <class T>
532 // class scaleFunctionType11 : public scaleFunctionBase<T> {
533 // public:
534 // scaleFunctionType11() { this->parNum_ = 8; }
535 // virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
536 
537 // if (chg>0){
538 // return( (parScale[0] + parScale[1]*pt + parScale[2]*eta +
539 // parScale[3]*sin(phi+parScale[4]))*pt );
540 // }
541 // // if (chg<0){
542 // return( (parScale[0] + parScale[1]*pt + parScale[5]*eta +
543 // parScale[6]*sin(phi+parScale[7]))*pt );
544 // // }
545 
546 // }
547 // // Fill the scaleVec with neutral parameters
548 // virtual void resetParameters(std::vector<double> * scaleVec) const {
549 // scaleVec->push_back(1);
550 // for( int i=1; i<this->parNum_; ++i ) {
551 // scaleVec->push_back(0);
552 // }
553 // }
554 // virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
555 // double thisStep[] = {0.001, 0.01, 0.01, 0.1,0.01,0.01, 0.1,0.01};
556 // TString thisParName[] = {"Pt scale", "Pt slope", "Eta coeff pos.","Phi ampl pos.", "Phi phase pos.","Eta coeff neg.","Phi ampl neg.", "Phi phase neg."};
557 // double thisMini[] = {0.9, -0.1,-0.2, -0.02, -3.1416,-0.2, -0.02, -3.1416};
558 // double thisMaxi[] = {1.1, 0.1, 0.2, 0.02, 3.1416, 0.2, 0.02, 3.1416};
559 // this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
560 // }
561 // };
562 
563 
564 // // Linear in pt, parabolic in eta, sinusoidal in phi with muon sign
565 // ----------------------------------------------------------------
566 template <class T>
567 class scaleFunctionType12 : public scaleFunctionBase<T> {
568 public:
569  scaleFunctionType12() { this->parNum_ = 6; }
570  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
571  return( (parScale[0] + parScale[1]*pt +
572  parScale[2]*std::fabs(eta) +
573  parScale[3]*eta*eta +
574  (double)chg*parScale[4]*sin(phi+parScale[5]))*pt );
575  }
576  // Fill the scaleVec with neutral parameters
577  virtual void resetParameters(std::vector<double> * scaleVec) const {
578  scaleVec->push_back(1);
579  for( int i=1; i<this->parNum_; ++i ) {
580  scaleVec->push_back(0);
581  }
582  }
583  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
584  double thisStep[] = {0.001, 0.01, 0.01, 0.01, 0.01, 0.1};
585  TString thisParName[] = {"Pt scale", "Pt slope", "Eta slope", "Eta quadr", "Phi ampl", "Phi phase"};
586  double thisMini[] = {0.97, -0.1, -0.2, -0.2, -0.02, 0.0};
587  double thisMaxi[] = {1.03, 0.1, 0.2, 0.2, 0.02, 3.1416};
588  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
589  }
590 };
591 
592 
593 
594 
595 
596 // Linear in pt, parabolic in eta, sinusoidal in phi with muon sign
597 // ----------------------------------------------------------------
598 template <class T>
599 class scaleFunctionType13 : public scaleFunctionBase<T> {
600 public:
601  scaleFunctionType13() { this->parNum_ = 8; }
602  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
603  if (chg>0) {
604  return( (parScale[0] + parScale[1]*pt +
605  parScale[2]*std::fabs(eta) +
606  parScale[3]*eta*eta +
607  parScale[4]*sin(phi+parScale[5]))*pt );
608  }
609  // else {
610  return( (parScale[0] + parScale[1]*pt +
611  parScale[2]*std::fabs(eta) +
612  parScale[3]*eta*eta +
613  parScale[6]*sin(phi+parScale[7]))*pt );
614  // }
615  }
616  // Fill the scaleVec with neutral parameters
617  virtual void resetParameters(std::vector<double> * scaleVec) const {
618  scaleVec->push_back(1);
619  for( int i=1; i<this->parNum_; ++i ) {
620  scaleVec->push_back(0);
621  }
622  }
623  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
624  double thisStep[] = {0.001, 0.01, 0.01, 0.01, 0.01, 0.1, 0.01, 0.1};
625  TString thisParName[] = {"Pt scale", "Pt slope", "Eta slope", "Eta quadr", "Phi ampl+", "Phi phase+", "Phi ampl-", "Phi phase-"};
626  double thisMini[] = {0.99, -0.01, -0.02, -0.02, -0.02, 0.0, -0.02, 0.0};
627  double thisMaxi[] = {1.01, 0.01, 0.02, 0.02, 0.02, 3.1416, 0.02, 3.1416};
628  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
629  }
630 };
631 
632 // linear in pt and cubic in |eta|
633 // --------------------------------------
634 template <class T>
635 class scaleFunctionType14 : public scaleFunctionBase<T> {
636 public:
637  scaleFunctionType14() { this->parNum_ = 10; }
638  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
639 // for( int i=0; i<10; ++i ) {
640 // std::cout << " parScale["<<i<<"] = " << parScale[i];
641 // }
642 // std::cout << " newPt = " << ( parScale[0] +
643 // parScale[1]*pt + parScale[2]*pt*pt + parScale[3]*pt*pt*pt +
644 // parScale[4]*std::fabs(eta) + parScale[5]*eta*eta + parScale[6]*std::fabs(eta*eta*eta) +
645 // parScale[7]*eta*eta*eta*eta + parScale[8]*std::fabs(eta*eta*eta*eta*eta) +
646 // parScale[9]*eta*eta*eta*eta*eta*eta )*pt << std::endl;
647  return( ( parScale[0] +
648  parScale[1]*pt + parScale[2]*pt*pt + parScale[3]*pt*pt*pt +
649  parScale[4]*std::fabs(eta) + parScale[5]*eta*eta + parScale[6]*std::fabs(eta*eta*eta) +
650  parScale[7]*eta*eta*eta*eta + parScale[8]*std::fabs(eta*eta*eta*eta*eta) +
651  parScale[9]*eta*eta*eta*eta*eta*eta )*pt );
652  }
653  // Fill the scaleVec with neutral parameters
654  virtual void resetParameters(std::vector<double> * scaleVec) const {
655  scaleVec->push_back(1);
656  for( int i=1; i<this->parNum_; ++i ) {
657  scaleVec->push_back(0);
658  }
659  }
660  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
661  double thisStep[] = {0.001,
662  0.01, 0.01, 0.001,
663  0.01, 0.00001, 0.0000001, 0.00000001, 0.00000001, 0.000000001};
664  TString thisParName[] = {"Pt offset",
665  "Pt slope", "Pt quadr", "Pt cubic",
666  "Eta slope", "Eta quadr", "Eta cubic", "Eta quartic", "Eta fifth grade", "Eta sixth grade"};
667  if( muonType == 1 ) {
668  double thisMini[] = {0.9,
669  -0.3, -0.3, -0.3,
670  -0.3, -0.3, -0.01, -0.001, -0.0001, -0.00001};
671  double thisMaxi[] = {1.1,
672  0.3, 0.3, 0.3,
673  0.3, 0.3, 0.01, 0.001, 0.0001, 0.00001};
674  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
675  } else {
676  double thisMini[] = {0.97,
677  -0.1, -0.001, -0.001,
678  -0.1, -0.1, -0.1, -0.0001, -0.00001, -0.000001};
679  double thisMaxi[] = {1.03,
680  0.1, 0.001, 0.001,
681  0.1, 0.1, 0.1, 0.0001, 0.00001, 0.000001};
682  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
683  }
684  }
685 };
686 
687 // linear in pt and cubic in |eta|
688 // --------------------------------------
689 template <class T>
690 class scaleFunctionType15 : public scaleFunctionBase<T> {
691 public:
692  scaleFunctionType15() { this->parNum_ = 5; }
693  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
694  if( pt > parScale[0] ) {
695  return( ( parScale[1] + parScale[3]*std::fabs(eta) + parScale[4]*pow(eta,2) )*pt );
696  }
697  else {
698  return( ( parScale[2] + parScale[3]*std::fabs(eta) + parScale[4]*pow(eta,2) )*pt );
699  }
700  }
701  // Fill the scaleVec with neutral parameters
702  virtual void resetParameters(std::vector<double> * scaleVec) const {
703  // For the first, reset to the original pt region separator
704  scaleVec->push_back(originalPtRegionSeparator_);
705  // The next two are the scale in the two regions
706  scaleVec->push_back(1);
707  scaleVec->push_back(1);
708  for( int i=1; i<this->parNum_; ++i ) {
709  scaleVec->push_back(0);
710  }
711  }
712  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
713  originalPtRegionSeparator_ = parScale[0];
714  double thisStep[] = {0.001,
715  0.01, 0.01,
716  0.01, 0.00001};
717  TString thisParName[] = {"Pt offset",
718  "Pt slope 1", "Pt slope 2",
719  "Eta slope", "Eta quadr"};
720  if( muonType == 1 ) {
721  double thisMini[] = {30.,
722  0.9, 0.9,
723  -0.3, -0.3};
724  double thisMaxi[] = {50.,
725  1.1, 1.1,
726  0.3, 0.3};
727  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
728  } else {
729  double thisMini[] = {30.,
730  0.97, 0.97,
731  -0.1, -0.01};
732  double thisMaxi[] = {50.,
733  1.03, 1.03,
734  0.1, 0.01};
735  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
736  }
737  }
738 protected:
739  double originalPtRegionSeparator_;
740 };
741 
742 //
743 // --------------------------------------
744 template <class T>
745 class scaleFunctionType16 : public scaleFunctionBase<T> {
746 public:
747  scaleFunctionType16() { this->parNum_ = 5; }
748  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
749  return (parScale[0] + parScale[1]*std::fabs(eta)+ parScale[2]*eta*eta + parScale[3]*pt + parScale[4]/(pt*pt))*pt;
750  }
751  // Fill the scaleVec with neutral parameters
752  virtual void resetParameters(std::vector<double> * scaleVec) const {
753  scaleVec->push_back(1);
754  for( int i=1; i<this->parNum_; ++i ) {
755  scaleVec->push_back(0);
756  }
757  }
758  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
759  double thisStep[] = {0.0000001, 0.00000001, 0.0000001, 0.00000001, 0.00000001};
760  TString thisParName[] = {"offset", "linearEta", "parabEta", "linearPt", "coeffOverPt2"};
761  if( muonType == 1 ) {
762  double thisMini[] = {30.,
763  0.9, 0.9,
764  -0.3, -0.3};
765  double thisMaxi[] = {50.,
766  1.1, 1.1,
767  0.3, 0.3};
768  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
769  } else {
770  double thisMini[] = {0.9, -0.000001, -0.000001, -0.00001, -0.00001};
771  double thisMaxi[] = { 1.1, 0.01, 0.001, 0.001, 0.1};
772  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
773  }
774  }
775 };
776 
777 template <class T>
778 class scaleFunctionType17 : public scaleFunctionBase<T> {
779 public:
780  scaleFunctionType17() { this->parNum_ = 4; }
781  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
782  return (parScale[0]*std::fabs(eta)+ parScale[1]*eta*eta + pt/(parScale[2]*pt + parScale[3]))*pt;
783  }
784 
785  // Fill the scaleVec with neutral parameters
786  virtual void resetParameters(std::vector<double> * scaleVec) const {
787  scaleVec->push_back(1);
788  for( int i=1; i<this->parNum_; ++i ) {
789  scaleVec->push_back(0);
790  }
791  }
792  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
793  double thisStep[] = {0.00000001, 0.000000001, 0.00000001, 0.00000001};
794  TString thisParName[] = {"linearEta", "parabEta", "coeffPt", "coeffOverPt"};
795  if( muonType == 1 ) {
796  double thisMini[] = {30.,
797  0.9, 0.9,
798  -0.3};
799  double thisMaxi[] = {50.,
800  1.1, 1.1,
801  0.3};
802  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
803  } else {
804  double thisMini[] = {-0.000001, -0.000001, 0.8, -0.001};
805  double thisMaxi[] = { 0.01, 0.005, 1.2, 0.001};
806  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
807  }
808  }
809 };
810 template <class T>
811 class scaleFunctionType18 : public scaleFunctionBase<T> {
812 public:
813  scaleFunctionType18() { this->parNum_ = 4; }
814  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
815 
816  if(std::fabs(eta)<0.2)
817  return parScale[0]*pt;
818  else if(std::fabs(eta)>0.2 && std::fabs(eta)<1.1)
819  return parScale[1]*pt;
820  else if(std::fabs(eta)>1.1 && std::fabs(eta)<1.5)
821  return parScale[2]*pt;
822  else
823  return parScale[3]*pt;
824  }
825  // Fill the scaleVec with neutral parameters
826  virtual void resetParameters(std::vector<double> * scaleVec) const {
827  for( int i=1; i<this->parNum_; ++i ) {
828  scaleVec->push_back(1);
829  }
830  }
831 
832  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
833  double thisStep[] = {0.00000001, 0.000000001, 0.00000001, 0.00000001};
834  TString thisParName[] = {"etaCentr", "barrel", "overlap", "endcaps"};
835  if( muonType == 1 ) {
836  double thisMini[] = {30.,
837  0.9, 0.9,
838  -0.3};
839  double thisMaxi[] = {50.,
840  1.1, 1.1,
841  0.3};
842  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
843  } else {
844  double thisMini[] = {0.9, 0.9, 0.9, 0.9};
845  double thisMaxi[] = {1.1, 1.1, 1.1, 1.1};
846  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
847  }
848  }
849 };
850 
851 
852 // ---- R.C.Nov.09 ---
853 // Scale function for Z mass (misalignment STARTUP scenario) corrections
854 // Linear in pt, sinusoidal in phi (muon-charge dependent) and parabolic in Eta
855 
856 template <class T>
857 class scaleFunctionType19 : public scaleFunctionBase<T> {
858 public:
859  scaleFunctionType19() { this->parNum_ = 9; }
860  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
861  if (chg>0) {
862  return( (parScale[0] + parScale[1]*sin(parScale[2]*phi + parScale[3])+ parScale[4]*std::fabs(eta) + parScale[5]*eta*eta )*pt);
863  }
864  return( (parScale[0] + parScale[6]*sin(parScale[7]*phi + parScale[8])+ parScale[4]*std::fabs(eta) + parScale[5]*eta*eta )*pt );
865  }
866 
867  // Fill the scaleVec with neutral parameters
868  virtual void resetParameters(std::vector<double> * scaleVec) const {
869  scaleVec->push_back(1);
870  for( int i=1; i<this->parNum_; ++i ) {
871  scaleVec->push_back(0);
872  }
873  }
874 
875  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const
876  std::vector<int> & parScaleOrder, const int muonType)
877  {
878  double thisStep[] = {0.001, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01};
879  TString thisParName[] = {"Phi offset", "Phi ampl Pos","Phi freq Pos", "Phi phase Pos","Eta slope", "Eta quadr","Phi ampl Neg","Phi freq Neg", "Phi phase Neg"};
880  if( muonType == 1 ) {
881  double thisMini[] = {0.9, -0.1, -0.1, -0.1, -0.02, -0.02, -0.1, -0.1, -0.1};
882  double thisMaxi[] = {1.1, 0.1, 0.1, 0.1, 0.02, 0.02, 0.1, 0.1, 0.1};
883  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
884  } else {
885  double thisMini[] = {0.9, -0.1, -2.0, 0., -0.1, -0.01, -0.1, -2.0, 0. };
886  double thisMaxi[] = {1.1, 0.1, 2.0, 6.28, 0.1, 0.01, 0.1, 2.0, 3.14 };
887 
888  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
889  }
890  }
891 };
892 
893 // This function allows to use three different pt functions for three pt ranges
894 template <class T>
895 class scaleFunctionType20 : public scaleFunctionBase<T> {
896 public:
897  scaleFunctionType20() { this->parNum_ = 10; }
898  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
899  if( pt < parScale[8] ) {
900  return( (parScale[0] + parScale[3] + parScale[6]*std::fabs(eta) + parScale[7]*eta*eta )*pt);
901  }
902  else if( pt < parScale[9] ) {
903  return( (parScale[1] + parScale[4] + parScale[6]*std::fabs(eta) + parScale[7]*eta*eta )*pt);
904  }
905  return( (parScale[2] + parScale[5] + parScale[6]*std::fabs(eta) + parScale[7]*eta*eta )*pt);
906  }
907 
908  // Fill the scaleVec with neutral parameters
909  virtual void resetParameters(std::vector<double> * scaleVec) const {
910  scaleVec->push_back(1);
911  scaleVec->push_back(1);
912  scaleVec->push_back(1);
913  for( int i=1; i<this->parNum_-2; ++i ) {
914  scaleVec->push_back(0);
915  }
916  scaleVec->push_back(this->originalTransition1_);
917  scaleVec->push_back(this->originalTransition2_);
918  }
919 
920  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const
921  std::vector<int> & parScaleOrder, const int muonType) {
922 
923  originalTransition1_ = parScale[8];
924  originalTransition2_ = parScale[9];
925 
926  double thisStep[] = {0.001, 0.01, 0.01, 0.1, 0.01, 0.01, 0.001, 0.001, 0.1, 0.1};
927 
928  TString thisParName[] = {"offset1", "offset2", "offset3", "linearPt1", "linearPt2", "linearPt3",
929  "linearEta", "parabEta", "transition1", "transition2"};
930  if( muonType == 1 ) {
931  double thisMini[] = {0.9, 0.9, 0.9, -1., -1., -1., -1., -1., 0., 0.};
932  double thisMaxi[] = {1.1, 1.1, 1.1, 1., 1., 1., 1., 1., 100., 100.};
933  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
934  } else {
935  double thisMini[] = {0.9, 0.9, 0.9, -1., -1., -1., -1., -1., 0., 0.};
936  double thisMaxi[] = {1.1, 1.1, 1.1, 1., 1., 1., 1., 1., 100., 100.};
937 
938  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
939  }
940  }
941 
942  protected:
943 
944  double originalTransition1_;
945  double originalTransition2_;
946 };
947 
948 
949 // Linear in pt and up to cubic in |eta| with possible eta asymmetry: two parabolic branches are used one for eta+ and one for eta-
950 // --------------------------------------------------------------------------------------------------------------------------------
951 template <class T>
952 class scaleFunctionType21 : public scaleFunctionBase<T> {
953 public:
954  scaleFunctionType21() { this->parNum_ = 8; }
955  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
956  double ptPart = parScale[0] + parScale[1]*pt;
957  if( eta >= 0 ) {
958  return( (ptPart+
959  parScale[2]*eta +
960  parScale[3]*eta*eta +
961  parScale[4]*eta*eta*eta)*pt );
962  }
963  return( (ptPart +
964  parScale[5]*(-eta) +
965  parScale[6]*eta*eta +
966  parScale[7]*(-eta*eta*eta))*pt );
967  }
968  // Fill the scaleVec with neutral parameters
969  virtual void resetParameters(std::vector<double> * scaleVec) const {
970  scaleVec->push_back(1);
971  for( int i=1; i<this->parNum_; ++i ) {
972  scaleVec->push_back(0);
973  }
974  }
975  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
976  double thisStep[] = {0.00001, 0.000001, 0.0000001, 0.0000001, 0.0000001, 0.0000001, 0.0000001, 0.0000001};
977  TString thisParName[] = {"Pt offset", "Pt slope", "Eta slope pos eta", "Eta quadr pos eta", "Eta cubic pos eta", "Eta slope neg eta", "Eta quadr neg eta", "Eta cubic neg eta"};
978  if( muonType == 1 ) {
979  double thisMini[] = {0.9, -0.3, -0.3, -0.3, -0.3, -0.3, -0.3, -0.3};
980  double thisMaxi[] = {1.1, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3};
981  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
982  } else {
983  double thisMini[] = {0.9, -0.002, -0.01, -0.005, -0.005, -0.01, -0.005, -0.005};
984  double thisMaxi[] = {1.1, 0.002, 0.01, 0.005, 0.005, 0.01, 0.005, 0.005};
985  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
986  }
987  }
988 };
989 
990 
991 // Function built to correct STARTUP MC
992 template <class T>
993 class scaleFunctionType22 : public scaleFunctionBase<T>
994 {
995 public:
996  scaleFunctionType22() { this->parNum_ = 5; }
997  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const
998  {
999  // Set to 0: use the same parameters for negative and positive muons
1000  int negChg = 0;
1001  if( chg > 0 ) {
1002  if( phi > 0 ) {
1003  return (parScale[0] + parScale[1]*TMath::Abs(phi)*sin(2*phi + parScale[2]))*pt;
1004  }
1005  else {
1006  return (parScale[0] + parScale[3]*TMath::Abs(phi)*sin(2*phi + parScale[4]))*pt;
1007  }
1008  }
1009  else if( chg < 0 ) {
1010  if( phi > 0 ) {
1011  return (parScale[0] - parScale[1+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[2+negChg]))*pt;
1012  }
1013  else {
1014  return (parScale[0] - parScale[3+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[4+negChg]))*pt;
1015  }
1016  }
1017  std::cout << "Error: we should not be here." << std::endl;
1018  exit(1);
1019  return 1;
1020  }
1021  // Fill the scaleVec with neutral parameters
1022  virtual void resetParameters(std::vector<double> * scaleVec) const
1023  {
1024  scaleVec->push_back(1);
1025  for( int i=1; i<this->parNum_; ++i ) {
1026  scaleVec->push_back(0);
1027  }
1028  }
1029  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType)
1030  {
1031  double thisStep[] = {0.0001, 0.0001, 0.01, 0.0001, 0.01};
1032  // , 0.0001, 0.01, 0.0001, 0.01};
1033  TString thisParName[] = {"Phi offset",
1034  "amplitude pos phi", "phase pos phi",
1035  "amplitude neg phi", "phase neg phi"};
1036  // "amplitude pos charge pos phi", "phase pos charge pos phi",
1037  // "amplitude pos charge neg phi", "phase pos charge neg phi",
1038  // "amplitude neg charge pos phi", "phase neg charge pos phi",
1039  // "amplitude neg charge neg phi", "phase neg charge neg phi" };
1040  if( muonType == 1 ) {
1041  double thisMini[] = {0.9, -0.3, -0.3, -0.3, -0.3};
1042  // , -0.3, -0.3, -0.3, -0.3};
1043  double thisMaxi[] = {1.1, 0.3, 0.3, 0.3, 0.3};
1044  // , 0.3, 0.3, 0.3, 0.3};
1045  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1046  } else {
1047  double thisMini[] = {0.9, -0.1, -3, -0.1, -3};
1048  // , -0.1, -3, -0.1, -3};
1049  double thisMaxi[] = {1.1, 0.1, 3, 0.1, 3};
1050  // , 0.1, 3, 0.1, 3};
1051  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1052  }
1053  }
1054 };
1055 
1056 
1057 // Function built to correct STARTUP MC
1058 // Independent parameters for mu+ and mu-
1059 template <class T>
1060 class scaleFunctionType23 : public scaleFunctionBase<T>
1061 {
1062 public:
1063  scaleFunctionType23() { this->parNum_ = 11; }
1064  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const
1065  {
1066  // Set to 0: use the same parameters for negative and positive muons
1067  int negChg = 4;
1068  if( chg > 0 ) {
1069  if( phi > 0 ) {
1070  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[10]*eta*eta + parScale[1]*TMath::Abs(phi)*sin(2*phi + parScale[2]))*pt;
1071  }
1072  else {
1073  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[10]*eta*eta + parScale[3]*TMath::Abs(phi)*sin(2*phi + parScale[4]))*pt;
1074  }
1075  }
1076  else if( chg < 0 ) {
1077  if( phi > 0 ) {
1078  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[10]*eta*eta - parScale[1+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[2+negChg]))*pt;
1079  }
1080  else {
1081  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[10]*eta*eta - parScale[3+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[4+negChg]))*pt;
1082  }
1083  }
1084  std::cout << "Error: we should not be here." << std::endl;
1085  exit(1);
1086  return 1;
1087  }
1088  double etaCorrection(const double & eta) const
1089  {
1090  double fabsEta = std::fabs(eta);
1091  if( fabsEta < 0.2) return -0.00063509;
1092  else if( fabsEta < 0.4 ) return -0.000585369;
1093  else if( fabsEta < 0.6 ) return -0.00077363;
1094  else if( fabsEta < 0.8 ) return -0.000547868;
1095  else if( fabsEta < 1.0 ) return -0.000954819;
1096  else if( fabsEta < 1.2 ) return -0.000162139;
1097  else if( fabsEta < 1.4 ) return 0.0026909;
1098  else if( fabsEta < 1.6 ) return 0.000684376;
1099  else if( fabsEta < 1.8 ) return -0.00174534;
1100  else if( fabsEta < 2.0 ) return -0.00177076;
1101  else if( fabsEta < 2.2 ) return 0.00117463;
1102  else if( fabsEta < 2.4 ) return 0.000985705;
1103  else if( fabsEta < 2.6 ) return 0.00163941;
1104  return 0.;
1105  }
1106 
1107  // Fill the scaleVec with neutral parameters
1108  virtual void resetParameters(std::vector<double> * scaleVec) const
1109  {
1110  scaleVec->push_back(1);
1111  for( int i=1; i<this->parNum_; ++i ) {
1112  scaleVec->push_back(0);
1113  }
1114  }
1115  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType)
1116  {
1117  double thisStep[] = {0.0001,
1118  0.0001, 0.01, 0.0001, 0.01,
1119  0.0001, 0.01, 0.0001, 0.01,
1120  0.001,
1121  0.00001};
1122  TString thisParName[] = {"Phi offset",
1123  // "amplitude pos phi", "phase pos phi",
1124  // "amplitude neg phi", "phase neg phi"};
1125  "amplitude pos charge pos phi", "phase pos charge pos phi",
1126  "amplitude pos charge neg phi", "phase pos charge neg phi",
1127  "amplitude neg charge pos phi", "phase neg charge pos phi",
1128  "amplitude neg charge neg phi", "phase neg charge neg phi",
1129  "amplitude of eta correction",
1130  "quadratic eta"};
1131  if( muonType == 1 ) {
1132  double thisMini[] = {0.9,
1133  -0.3, -0.3, -0.3, -0.3,
1134  -0.3, -0.3, -0.3, -0.3,
1135  -10.,
1136  -1.};
1137  double thisMaxi[] = {1.1,
1138  0.3, 0.3, 0.3, 0.3,
1139  0.3, 0.3, 0.3, 0.3,
1140  10.,
1141  1.};
1142  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1143  } else {
1144  double thisMini[] = {0.9,
1145  -0.1, -3, -0.1, -3,
1146  -0.1, -3, -0.1, -3,
1147  -10.,
1148  -1.};
1149  double thisMaxi[] = {1.1,
1150  0.1, 3, 0.1, 3,
1151  0.1, 3, 0.1, 3,
1152  10.,
1153  1.};
1154  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1155  }
1156  }
1157 
1158  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1159  const T & parResol, const std::vector<int> & parResolOrder,
1160  const std::vector<double> & parStep,
1161  const std::vector<double> & parMin,
1162  const std::vector<double> & parMax,
1163  const int muonType)
1164  {
1165  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1166  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1167  std::cout << "parNum = " << this->parNum_ << std::endl;
1168  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1169  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1170  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1171  exit(1);
1172  }
1173  std::vector<ParameterSet> parSet(this->parNum_);
1174  // name, step, mini, maxi
1175 
1176  parSet[0] = ParameterSet( "Phi offset", parStep[0], parMin[0], parMax[0] );
1177  parSet[1] = ParameterSet( "amplitude pos charge pos phi", parStep[1], parMin[1], parMax[1] );
1178  parSet[2] = ParameterSet( "phase pos charge pos phi", parStep[2], parMin[2], parMax[2] );
1179  parSet[3] = ParameterSet( "amplitude pos charge neg phi", parStep[3], parMin[3], parMax[3] );
1180  parSet[4] = ParameterSet( "phase pos charge neg phi", parStep[4], parMin[4], parMax[4] );
1181  parSet[5] = ParameterSet( "amplitude neg charge pos phi", parStep[5], parMin[5], parMax[5] );
1182  parSet[6] = ParameterSet( "phase neg charge pos phi", parStep[6], parMin[6], parMax[6] );
1183  parSet[7] = ParameterSet( "amplitude neg charge neg phi", parStep[7], parMin[7], parMax[7] );
1184  parSet[8] = ParameterSet( "phase neg charge neg phi", parStep[8], parMin[8], parMax[8] );
1185  parSet[9] = ParameterSet( "amplitude of eta correction", parStep[9], parMin[9], parMax[9] );
1186  parSet[10] = ParameterSet( "quadratic eta", parStep[10], parMin[10], parMax[10] );
1187 
1188  std::cout << "setting parameters" << std::endl;
1189  for( int i=0; i<this->parNum_; ++i ) {
1190  std::cout << "parStep["<<i<<"] = " << parStep[i]
1191  << ", parMin["<<i<<"] = " << parMin[i]
1192  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1193  }
1194  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1195  }
1196 };
1197 
1198 // Function built to correct STARTUP MC
1199 // Independent parameters for mu+ and mu-
1200 template <class T>
1201 class scaleFunctionType24 : public scaleFunctionBase<T>
1202 {
1203 public:
1204  scaleFunctionType24() { this->parNum_ = 10; }
1205  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const
1206  {
1207  // Set to 0: use the same parameters for negative and positive muons
1208  int negChg = 4;
1209  if( chg > 0 ) {
1210  if( phi > 0 ) {
1211  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[1]*TMath::Abs(phi)*sin(2*phi + parScale[2]))*pt;
1212  }
1213  else {
1214  return (parScale[0] + parScale[9]*etaCorrection(eta) + parScale[3]*TMath::Abs(phi)*sin(2*phi + parScale[4]))*pt;
1215  }
1216  }
1217  else if( chg < 0 ) {
1218  if( phi > 0 ) {
1219  return (parScale[0] + parScale[9]*etaCorrection(eta) - parScale[1+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[2+negChg]))*pt;
1220  }
1221  else {
1222  return (parScale[0] + parScale[9]*etaCorrection(eta) - parScale[3+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[4+negChg]))*pt;
1223  }
1224  }
1225  std::cout << "Error: we should not be here." << std::endl;
1226  exit(1);
1227  return 1;
1228  }
1229  double etaCorrection(const double & eta) const
1230  {
1231  if( eta < -2.6 ) return 0.;
1232  else if( eta < -2.4) return 0.00205594;
1233  else if( eta < -2.2) return 0.000880532;
1234  else if( eta < -2.0) return 0.0013714;
1235  else if( eta < -1.8) return -0.00153122;
1236  else if( eta < -1.6) return -0.000894437;
1237  else if( eta < -1.4) return 0.000883338;
1238  else if( eta < -1.2) return 0.0027599;
1239  else if( eta < -1.0) return 8.57009e-05;
1240  else if( eta < -0.8) return -0.00092294;
1241  else if( eta < -0.6) return -0.000492001;
1242  else if( eta < -0.4) return -0.000948406;
1243  else if( eta < -0.2) return -0.000478767;
1244  else if( eta < 0.0) return -0.0006909;
1245  else if( eta < 0.2) return -0.000579281;
1246  else if( eta < 0.4) return -0.000691971;
1247  else if( eta < 0.6) return -0.000598853;
1248  else if( eta < 0.8) return -0.000603736;
1249  else if( eta < 1.0) return -0.000986699;
1250  else if( eta < 1.2) return -0.00040998;
1251  else if( eta < 1.4) return 0.00262189;
1252  else if( eta < 1.6) return 0.000485414;
1253  else if( eta < 1.8) return -0.00259624;
1254  else if( eta < 2.0) return -0.00201031;
1255  else if( eta < 2.2) return 0.000977849;
1256  else if( eta < 2.5) return 0.00109088;
1257  else if( eta < 2.6) return 0.00122289;
1258  return 0.;
1259  }
1260 
1261  // Fill the scaleVec with neutral parameters
1262  virtual void resetParameters(std::vector<double> * scaleVec) const
1263  {
1264  scaleVec->push_back(1);
1265  for( int i=1; i<this->parNum_; ++i ) {
1266  scaleVec->push_back(0);
1267  }
1268  }
1269  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType)
1270  {
1271  double thisStep[] = {0.0001,
1272  0.0001, 0.01, 0.0001, 0.01,
1273  0.0001, 0.01, 0.0001, 0.01,
1274  0.001};
1275  TString thisParName[] = {"Phi offset",
1276  // "amplitude pos phi", "phase pos phi",
1277  // "amplitude neg phi", "phase neg phi"};
1278  "amplitude pos charge pos phi", "phase pos charge pos phi",
1279  "amplitude pos charge neg phi", "phase pos charge neg phi",
1280  "amplitude neg charge pos phi", "phase neg charge pos phi",
1281  "amplitude neg charge neg phi", "phase neg charge neg phi",
1282  "amplitude of eta correction"};
1283  if( muonType == 1 ) {
1284  double thisMini[] = {0.9,
1285  -0.3, -0.3, -0.3, -0.3,
1286  -0.3, -0.3, -0.3, -0.3,
1287  -10.};
1288  double thisMaxi[] = {1.1,
1289  0.3, 0.3, 0.3, 0.3,
1290  0.3, 0.3, 0.3, 0.3,
1291  10.};
1292  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1293  } else {
1294  double thisMini[] = {0.9,
1295  -0.1, -3, -0.1, -3,
1296  -0.1, -3, -0.1, -3,
1297  -10.};
1298  double thisMaxi[] = {1.1,
1299  0.1, 3, 0.1, 3,
1300  0.1, 3, 0.1, 3,
1301  10.};
1302  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1303  }
1304  }
1305 };
1306 
1307 
1308 // Function built to correct STARTUP MC
1309 // Analytical description in eta
1310 template <class T>
1311 class scaleFunctionType25 : public scaleFunctionBase<T>
1312 {
1313 public:
1314  scaleFunctionType25() { this->parNum_ = 19; }
1315  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const
1316  {
1317  // Set to 0: use the same parameters for negative and positive muons
1318  int negChg = 4;
1319  if( chg > 0 ) {
1320  if( phi > 0 ) {
1321  return (parScale[0] + etaCorrection(eta, parScale) + parScale[1]*TMath::Abs(phi)*sin(2*phi + parScale[2]))*pt;
1322  }
1323  else {
1324  return (parScale[0] + etaCorrection(eta, parScale) + parScale[3]*TMath::Abs(phi)*sin(2*phi + parScale[4]))*pt;
1325  }
1326  }
1327  else if( chg < 0 ) {
1328  if( phi > 0 ) {
1329  return (parScale[0] + etaCorrection(eta, parScale) - parScale[1+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[2+negChg]))*pt;
1330  }
1331  else {
1332  return (parScale[0] + etaCorrection(eta, parScale) - parScale[3+negChg]*TMath::Abs(phi)*sin(2*phi + parScale[4+negChg]))*pt;
1333  }
1334  }
1335  std::cout << "Error: we should not be here." << std::endl;
1336  exit(1);
1337  return 1;
1338  }
1339  double etaCorrection(const double & eta, const T & parScale) const
1340  {
1341  if( eta < -2.06 ) return cubicEta(-2.06, parScale, 9);
1342  else if( eta < -1.06 ) return cubicEta(eta, parScale, 9);
1343  else if( eta < 1.1 ) return( parScale[13] + parScale[14]*eta );
1344  else if( eta < 2. ) return cubicEta(eta, parScale, 15);
1345  return cubicEta(2., parScale, 15);
1346  }
1347  double cubicEta(const double & eta, const T & parScale, const int shift ) const
1348  {
1349  return( parScale[shift] + parScale[shift+1]*eta + parScale[shift+2]*eta*eta + parScale[shift+3]*eta*eta*eta );
1350  }
1351 
1352  // Fill the scaleVec with neutral parameters
1353  virtual void resetParameters(std::vector<double> * scaleVec) const
1354  {
1355  scaleVec->push_back(1);
1356  for( int i=1; i<this->parNum_; ++i ) {
1357  scaleVec->push_back(0);
1358  }
1359  }
1360  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType)
1361  {
1362  double thisStep[] = {0.0001,
1363  0.0001, 0.01, 0.0001, 0.01,
1364  0.0001, 0.01, 0.0001, 0.01,
1365  0.0001, 0.0001, 0.0001, 0.0001,
1366  0.0001, 0.0001,
1367  0.0001, 0.0001, 0.0001, 0.0001};
1368  TString thisParName[] = {"Phi offset",
1369  // "amplitude pos phi", "phase pos phi",
1370  // "amplitude neg phi", "phase neg phi"};
1371  "amplitude pos charge pos phi", "phase pos charge pos phi",
1372  "amplitude pos charge neg phi", "phase pos charge neg phi",
1373  "amplitude neg charge pos phi", "phase neg charge pos phi",
1374  "amplitude neg charge neg phi", "phase neg charge neg phi",
1375  "etaNeg0", "etaNeg1", "etaNeg2", "etaNeg3",
1376  "etaCent0", "etaCent1",
1377  "etaPos0", "etaPos1", "etaPos2", "etaPos3"};
1378  if( muonType == 1 ) {
1379  double thisMini[] = {0.9,
1380  -0.3, -0.3, -0.3, -0.3,
1381  -0.3, -0.3, -0.3, -0.3,
1382  -0.1, -1., -1., -1.,
1383  -0.1, -1.,
1384  -0.1, -1., -1., -1.};
1385  double thisMaxi[] = {1.1,
1386  0.3, 0.3, 0.3, 0.3,
1387  0.3, 0.3, 0.3, 0.3,
1388  0.1, 1., 1., 1.,
1389  0.1, 1.,
1390  0.1, 1., 1., 1.};
1391  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1392  } else {
1393  double thisMini[] = {0.9,
1394  -0.1, -3, -0.1, -3,
1395  -0.1, -3, -0.1, -3,
1396  -0.1, -0.6, -0.5, -0.08,
1397  -0.1, -0.001,
1398  -0.1, -0.1, -0.4, -0.01};
1399  double thisMaxi[] = {1.1,
1400  0.1, 3, 0.1, 3,
1401  0.1, 3, 0.1, 3,
1402  0.1, 0.1, 0.1, 0.01,
1403  0.1, 0.002,
1404  0.1, 0.8, 0.1, 0.2};
1405  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1406  }
1407  }
1408 };
1409 
1410 // Built for the first 100/nb of J/Psi in data
1411 // It has eta dependent corrections only for |eta| > parScale[6] and separate parabolic corrections for eta > 0 or < 0.
1412 template <class T>
1413 class scaleFunctionType26 : public scaleFunctionBase<T> {
1414 public:
1415  scaleFunctionType26() { this->parNum_ = 9; }
1416  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1417  double ptPart = parScale[0] + parScale[1]*pt;
1418  double fabsEta = std::fabs(eta);
1419 
1420  if( fabsEta > parScale[8] ) {
1421  if( eta > 0 ) {
1422  return( (ptPart+
1423  parScale[2]*eta +
1424  parScale[3]*eta*eta)*pt );
1425  }
1426  else {
1427  return( (ptPart+
1428  parScale[4]*eta +
1429  parScale[5]*eta*eta)*pt );
1430  }
1431  }
1432  return( (ptPart + parScale[6]*fabsEta + parScale[7]*eta*eta)*pt );
1433  }
1434  // Fill the scaleVec with neutral parameters
1435  virtual void resetParameters(std::vector<double> * scaleVec) const {
1436  scaleVec->push_back(1);
1437  for( int i=1; i<this->parNum_; ++i ) {
1438  scaleVec->push_back(0);
1439  }
1440  }
1441  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
1442  double thisStep[] = {0.00001, 0.000001, 0.0000001, 0.0000001, 0.0000001, 0.0000001, 0.0000001, 0.00001, 0.000001};
1443  TString thisParName[] = {"Pt offset", "Pt slope", "Eta slope pos eta", "Eta quadr pos eta", "Eta slope neg eta", "Eta quadr neg eta", "Eta splope barrel", "Eta quadr barrel", "Eta corr region"};
1444  if( muonType == 1 ) {
1445  double thisMini[] = {0.9, -0.3, -0.3, -0.3, -0.3, -0.3, -0.3, 0.3, 0.};
1446  double thisMaxi[] = {1.1, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3};
1447  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1448  } else {
1449  double thisMini[] = {0.9, -0.002, -0.01, -0.005, -0.005, -0.01, -0.01, -0.005, 0.};
1450  double thisMaxi[] = {1.1, 0.002, 0.01, 0.005, 0.005, 0.01, 0.01, 0.005, 2.4};
1451  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1452  }
1453  }
1454 };
1455 
1456 
1457 
1458 // Built for the first 100/nb of J/Psi in data
1459 // It has eta dependent corrections only for |eta| > parScale[6] and separate parabolic corrections for eta > 0 or < 0.
1460 template <class T>
1461 class scaleFunctionType27 : public scaleFunctionBase<T> {
1462 public:
1463  scaleFunctionType27() { this->parNum_ = 13; }
1464  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1465  double ptPart = parScale[0] + parScale[1]*pt;
1466  double fabsEta = std::fabs(eta);
1467 
1468  if( fabsEta > parScale[12] ) {
1469  if( eta > 0 ) {
1470  return( (ptPart+parScale[2]+
1471  parScale[3]*(fabsEta - parScale[5]) +
1472  parScale[4]*(fabsEta - parScale[5])*(fabsEta - parScale[5]))*pt );
1473  }
1474  else {
1475  return( (ptPart+parScale[6]+
1476  parScale[7]*(fabsEta - parScale[9]) +
1477  parScale[8]*(fabsEta - parScale[9])*(fabsEta - parScale[9]))*pt );
1478  }
1479  }
1480  return( (ptPart + parScale[10]*fabsEta + parScale[11]*eta*eta)*pt );
1481  }
1482  // Fill the scaleVec with neutral parameters
1483  virtual void resetParameters(std::vector<double> * scaleVec) const {
1484  scaleVec->push_back(1);
1485  for( int i=1; i<this->parNum_; ++i ) {
1486  scaleVec->push_back(0);
1487  }
1488  }
1489  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
1490  double thisStep[] = {0.00001, 0.000001,
1491  0.000001, 0.0000001, 0.0000001, 0.0000001,
1492  0.000001, 0.0000001, 0.0000001, 0.0000001,
1493  0.0000001, 0.0000001,
1494  0.00001};
1495  TString thisParName[] = {"Pt offset", "Pt slope",
1496  "Eta shift pos eta", "Eta slope pos eta", "Eta quadr pos eta", "Eta center pos eta",
1497  "Eta shift neg eta", "Eta slope neg eta", "Eta quadr neg eta", "Eta center neg eta",
1498  "Eta splope barrel", "Eta quadr barrel",
1499  "Eta corr region"};
1500  if( muonType == 1 ) {
1501  double thisMini[] = {0.9, -0.3,
1502  -0.3, -0.3, -0.3, -0.3,
1503  -0.3, -0.3, -0.3, -0.3,
1504  -0.3, -0.3,
1505  0.};
1506  double thisMaxi[] = {1.1, 0.3,
1507  0.3, 0.3, 0.3, 0.3,
1508  0.3, 0.3, 0.3, 0.3,
1509  0.3, 0.3,
1510  0.3};
1511  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1512  } else {
1513  double thisMini[] = {0.9, -0.002,
1514  -0.01, -0.01, -0.005, 0.,
1515  -0.01, -0.01, -0.005, 0.,
1516  -0.01, -0.005,
1517  0.};
1518  double thisMaxi[] = {1.1, 0.002,
1519  0.01, 0.01, 0.005, 2.4,
1520  0.01, 0.01, 0.005, 2.4,
1521  0.01, 0.005,
1522  2.4};
1523  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1524  }
1525  }
1526 };
1527 
1528 template <class T>
1529 class scaleFunctionType28 : public scaleFunctionBase<T> {
1530 public:
1531  scaleFunctionType28() { this->parNum_ = 5; }
1532  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1533  return( (parScale[0] + parScale[1]*pt + (double)chg*parScale[4]*eta +
1534  (double)chg*parScale[2]*sin(phi+parScale[3]))*pt );
1535  }
1536  // Fill the scaleVec with neutral parameters
1537  virtual void resetParameters(std::vector<double> * scaleVec) const {
1538  scaleVec->push_back(1);
1539  for( int i=1; i<this->parNum_; ++i ) {
1540  scaleVec->push_back(0);
1541  }
1542  }
1543  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const
1544  std::vector<int> & parScaleOrder, const int muonType) {
1545  double thisStep[] = {0.001, 0.01, 0.01, 0.1,0.01};
1546  TString thisParName[] = {"Pt scale", "Pt slope", "Phi ampl", "Phi phase","Eta coeff"};
1547  double thisMini[] = {0.9, -0.1, -0.02, -3.1416,-0.2};
1548  double thisMaxi[] = {1.1, 0.1, 0.02, 3.1416,0.2}; this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1549  }
1550 };
1551 
1552 
1553 // As type 11 but with no Pt constant dependence -i.e. no "a" term + explicit dependence from pT
1554 // of phi coefficient (assuming only alignment effects). Suitable for 4Nov (Zmumu 36/pb) or
1555 // 22Dec (note: enable eta linear coefficient!)
1556 
1557 template <class T>
1558 class scaleFunctionType29 : public scaleFunctionBase<T> {
1559 public:
1560  scaleFunctionType29() { this->parNum_ = 5; }
1561  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1562  return( (1+ parScale[0]*pt +
1563  (double)chg*pt*parScale[1]*eta
1564  +parScale[2]*eta*eta +
1565  pt*(double)chg*parScale[3]*sin(phi+parScale[4]))*pt );
1566  }
1567  // Fill the scaleVec with neutral parameters
1568  virtual void resetParameters(std::vector<double> * scaleVec) const {
1569  // scaleVec->push_back(1);
1570  for( int i=0; i<this->parNum_; ++i ) {
1571  scaleVec->push_back(0);
1572  }
1573  }
1574 
1575  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
1576  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
1577  const int muonType)
1578  {
1579  std::vector<ParameterSet> parSet(this->parNum_);
1580  // name, step, mini, maxi
1581  parSet[0] = ParameterSet( "Pt bias", 0.0001, -0.02, 0.02 );
1582  parSet[1] = ParameterSet( "Eta linear coeff", 0.01, -0.2, 0.2 );
1583  parSet[2] = ParameterSet( "Eta parabolic coeff", 0.0001, -0.02, 0.02 );
1584  parSet[3] = ParameterSet( "Phi ampl", 0.001, -0.02, 0.02 );
1585  parSet[4] = ParameterSet( "Phi phase", 0.1, -3.1416, 3.1416 );
1586 
1587  std::cout << "setting parameters" << std::endl;
1588  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1589  }
1590 
1591  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1592  const T & parResol, const std::vector<int> & parResolOrder,
1593  const std::vector<double> & parStep,
1594  const std::vector<double> & parMin,
1595  const std::vector<double> & parMax,
1596  const int muonType)
1597  {
1598  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1599  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1600  std::cout << "parNum = " << this->parNum_ << std::endl;
1601  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1602  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1603  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1604  exit(1);
1605  }
1606  std::vector<ParameterSet> parSet(this->parNum_);
1607  // name, step, mini, maxi
1608  parSet[0] = ParameterSet( "Pt bias", parStep[0], parMin[0], parMax[0] );
1609  parSet[1] = ParameterSet( "Eta linear coeff", parStep[1], parMin[1], parMax[1] );
1610  parSet[2] = ParameterSet( "Eta parabolic coeff", parStep[2], parMin[2], parMax[2] );
1611  parSet[3] = ParameterSet( "Phi ampl", parStep[3], parMin[3], parMax[3] );
1612  parSet[4] = ParameterSet( "Phi phase", parStep[4], parMin[4], parMax[4] );
1613 
1614  std::cout << "setting parameters" << std::endl;
1615  for( int i=0; i<this->parNum_; ++i ) {
1616  std::cout << "parStep["<<i<<"] = " << parStep[i]
1617  << ", parMin["<<i<<"] = " << parMin[i]
1618  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1619  }
1620  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1621  }
1622 };
1623 
1624 template <class T>
1625 class scaleFunctionType30 : public scaleFunctionBase<T> {
1626  public:
1627  scaleFunctionType30() { this->parNum_ = 8; }
1628  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & par) const
1629  //Bir alt satirdan Gul'u sonuna kadar ben ekledim bu fonksiyonu.
1630  {
1631  double etaCorr = 0.;
1632  if( (chg < 0 && eta > par[4]) || (chg > 0 && eta < -par[4]) ) {
1633  etaCorr = par[1]+par[2]*fabs(fabs(eta)-par[4])+par[3]*(fabs(eta)-par[4])*(fabs(eta)-par[4]);
1634  }
1635 
1636  //don't forget par[3] = 1.6
1637 
1638  double ptCorr = 0.;
1639  if( pt < par[7] ) {
1640  ptCorr = 1+par[5]*(pt - par[7]) + par[6]*(pt - par[7])*(pt - par[7]);
1641  }
1642 
1643  //don't forget par[6] = 6
1644 
1645  return par[0]*pt/(1 + etaCorr + ptCorr);
1646  } //Gul araya yaz
1647 
1648  // Fill the scaleVec with neutral parameters
1649  virtual void resetParameters(std::vector<double> * scaleVec) const
1650  {
1651  scaleVec->push_back(1);
1652  for( int i=1; i<this->parNum_; ++i ) {
1653  scaleVec->push_back(0);
1654  }
1655  }
1656  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {}
1657 
1658  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1659  const T & parResol, const std::vector<int> & parResolOrder,
1660  const std::vector<double> & parStep,
1661  const std::vector<double> & parMin,
1662  const std::vector<double> & parMax,
1663  const int muonType)
1664  {
1665  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1666  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1667  std::cout << "parNum = " << this->parNum_ << std::endl;
1668  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1669  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1670  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1671  exit(1);
1672  }
1673  std::vector<ParameterSet> parSet(this->parNum_);
1674  // name, step, mini, maxi Bunun altindakileri degistirdik. Parametre sayisini 6'ya dusurduk.
1675 
1676  parSet[0] = ParameterSet( "Overall scale term", parStep[0], parMin[0], parMax[0] );
1677  parSet[1] = ParameterSet( "eta scale term ", parStep[1], parMin[1], parMax[1] );
1678  parSet[2] = ParameterSet( "multiplies eta", parStep[2], parMin[2], parMax[2] );
1679  parSet[3] = ParameterSet( "phase pos charge pos phi", parStep[3], parMin[3], parMax[3] );
1680  parSet[4] = ParameterSet( "amplitude pos charge neg phi", parStep[4], parMin[4], parMax[4] );
1681  parSet[5] = ParameterSet( "phase pos charge neg phi", parStep[5], parMin[5], parMax[5] );
1682  parSet[6] = ParameterSet( "amplitude neg charge pos phi", parStep[6], parMin[6], parMax[6] );
1683  parSet[7] = ParameterSet( "phase neg charge pos phi", parStep[7], parMin[7], parMax[7] );
1684  std::cout << "setting parameters" << std::endl;
1685  for( int i=0; i<this->parNum_; ++i ) {
1686  std::cout << "parStep["<<i<<"] = " << parStep[i]
1687  << ", parMin["<<i<<"] = " << parMin[i]
1688  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1689  }
1690  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1691  }
1692 };
1693 
1694 template <class T>
1695 class scaleFunctionType31 : public scaleFunctionBase<T> {
1696  public:
1697  scaleFunctionType31() { this->parNum_ = 8; }
1698  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & par) const
1699  //Bir alt satirdan Gul'u sonuna kadar ben ekledim bu fonksiyonu.
1700  {
1701  double etaCorr = 0.;
1702  if( (chg < 0 && eta > par[4]) || (chg > 0 && eta < -par[4]) ) {
1703  etaCorr = par[1]+par[2]*fabs(fabs(eta)-par[4])+par[3]*(fabs(eta)-par[4])*(fabs(eta)-par[4]);
1704  }
1705 
1706  //don't forget par[3] = 1.6
1707 
1708  double ptCorr = 0.;
1709  if( pt < par[7] ) {
1710  ptCorr = par[5]*(pt - par[7]) + par[6]*(pt - par[7])*(pt - par[7]);
1711  }
1712 
1713  //don't forget par[6] = 6
1714 
1715  return par[0]*pt*(1 + etaCorr + ptCorr);
1716  } //Gul araya yaz
1717 
1718  // Fill the scaleVec with neutral parameters
1719  virtual void resetParameters(std::vector<double> * scaleVec) const
1720  {
1721  scaleVec->push_back(1);
1722  for( int i=1; i<this->parNum_; ++i ) {
1723  scaleVec->push_back(0);
1724  }
1725  }
1726  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {}
1727 
1728  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1729  const T & parResol, const std::vector<int> & parResolOrder,
1730  const std::vector<double> & parStep,
1731  const std::vector<double> & parMin,
1732  const std::vector<double> & parMax,
1733  const int muonType)
1734  {
1735  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1736  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1737  std::cout << "parNum = " << this->parNum_ << std::endl;
1738  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1739  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1740  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1741  exit(1);
1742  }
1743  std::vector<ParameterSet> parSet(this->parNum_);
1744  // name, step, mini, maxi Bunun altindakileri degistirdik. Parametre sayisini 6'ya dusurduk.
1745 
1746  parSet[0] = ParameterSet( "Overall scale term", parStep[0], parMin[0], parMax[0] );
1747  parSet[1] = ParameterSet( "eta scale term ", parStep[1], parMin[1], parMax[1] );
1748  parSet[2] = ParameterSet( "multiplies eta", parStep[2], parMin[2], parMax[2] );
1749  parSet[3] = ParameterSet( "phase pos charge pos phi", parStep[3], parMin[3], parMax[3] );
1750  parSet[4] = ParameterSet( "amplitude pos charge neg phi", parStep[4], parMin[4], parMax[4] );
1751  parSet[5] = ParameterSet( "phase pos charge neg phi", parStep[5], parMin[5], parMax[5] );
1752  parSet[6] = ParameterSet( "amplitude neg charge pos phi", parStep[6], parMin[6], parMax[6] );
1753  parSet[7] = ParameterSet( "phase neg charge pos phi", parStep[7], parMin[7], parMax[7] );
1754  std::cout << "setting parameters" << std::endl;
1755  for( int i=0; i<this->parNum_; ++i ) {
1756  std::cout << "parStep["<<i<<"] = " << parStep[i]
1757  << ", parMin["<<i<<"] = " << parMin[i]
1758  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1759  }
1760  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1761  }
1762 };
1763 
1764 template <class T>
1765 class scaleFunctionType32 : public scaleFunctionBase<T> {
1766  public:
1767  scaleFunctionType32() { this->parNum_ = 22; }
1768  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & par) const
1769  {
1770  double fabsEta = fabs(eta);
1771  double etaCorr = 0.;
1772  // Eta bins
1773  if( fabsEta < 0.8 ) etaCorr = par[8];
1774  else if( fabsEta < 1.2 ) etaCorr = par[9];
1775  else if( fabsEta < 1.4 ) etaCorr = par[10];
1776  else if( fabsEta < 1.6 ) etaCorr = par[11];
1777  else if( fabsEta < 1.8 ) etaCorr = par[12];
1778  else if( fabsEta < 2.0 ) etaCorr = par[13];
1779  else if( fabsEta < 2.2 ) etaCorr = par[14];
1780  else etaCorr = par[15];
1781 
1782  // Charge-asymmetric eta-dependent correction
1783  if( (chg < 0 && eta > par[4]) || (chg > 0 && eta < -par[4]) ) {
1784  etaCorr += par[1]+par[2]*fabs(fabsEta-par[4])+par[3]*(fabsEta-par[4])*(fabsEta-par[4]);
1785  }
1786 
1787  // Phi bins
1788  double phiCorr = 0.;
1789  if( phi < -2.0 ) phiCorr = par[16];
1790  else if( phi < -1.6 ) phiCorr = par[17];
1791  else if( phi < -1.2 ) phiCorr = par[18];
1792  else if( phi < 1.2 ) phiCorr = par[19];
1793  else if( phi < 1.6 ) phiCorr = par[20];
1794  else if( phi < 2.0 ) phiCorr = par[21];
1795  // Removed to remove the degeneracy. The overall shift of the eta bins will account for this paramter.
1796  // else phiCorr = par[22];
1797 
1798  double ptCorr = 0.;
1799  if( pt < par[7] ) {
1800  ptCorr = par[5]*(pt - par[7]) + par[6]*(pt - par[7])*(pt - par[7]);
1801  }
1802 
1803  return par[0]*pt*(1 + etaCorr + ptCorr + phiCorr);
1804  }
1805 
1806  // Fill the scaleVec with neutral parameters
1807  virtual void resetParameters(std::vector<double> * scaleVec) const
1808  {
1809  // scaleVec->push_back(1);
1810  for( int i=1; i<this->parNum_; ++i ) {
1811  scaleVec->push_back(0);
1812  }
1813  }
1814  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {}
1815 
1816  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1817  const T & parResol, const std::vector<int> & parResolOrder,
1818  const std::vector<double> & parStep,
1819  const std::vector<double> & parMin,
1820  const std::vector<double> & parMax,
1821  const int muonType)
1822  {
1823  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1824  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1825  std::cout << "parNum = " << this->parNum_ << std::endl;
1826  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1827  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1828  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1829  exit(1);
1830  }
1831  std::vector<ParameterSet> parSet(this->parNum_);
1832  // name, step, mini, maxi
1833  parSet[0] = ParameterSet( "Overall scale term", parStep[0], parMin[0], parMax[0] );
1834  parSet[1] = ParameterSet( "eta scale term ", parStep[1], parMin[1], parMax[1] );
1835  parSet[2] = ParameterSet( "multiplies eta", parStep[2], parMin[2], parMax[2] );
1836  parSet[3] = ParameterSet( "phase pos charge pos phi", parStep[3], parMin[3], parMax[3] );
1837  parSet[4] = ParameterSet( "amplitude pos charge neg phi", parStep[4], parMin[4], parMax[4] );
1838  parSet[5] = ParameterSet( "phase pos charge neg phi", parStep[5], parMin[5], parMax[5] );
1839  parSet[6] = ParameterSet( "amplitude neg charge pos phi", parStep[6], parMin[6], parMax[6] );
1840  parSet[7] = ParameterSet( "phase neg charge pos phi", parStep[7], parMin[7], parMax[7] );
1841  // Eta bins
1842  parSet[8] = ParameterSet( "eta bin scale", parStep[8], parMin[8], parMax[8] );
1843  parSet[9] = ParameterSet( "eta bin scale", parStep[9], parMin[9], parMax[9] );
1844  parSet[10] = ParameterSet( "eta bin scale", parStep[10], parMin[10], parMax[10] );
1845  parSet[11] = ParameterSet( "eta bin scale", parStep[11], parMin[11], parMax[11] );
1846  parSet[12] = ParameterSet( "eta bin scale", parStep[12], parMin[12], parMax[12] );
1847  parSet[13] = ParameterSet( "eta bin scale", parStep[13], parMin[13], parMax[13] );
1848  parSet[14] = ParameterSet( "eta bin scale", parStep[14], parMin[14], parMax[14] );
1849  parSet[15] = ParameterSet( "eta bin scale", parStep[15], parMin[15], parMax[15] );
1850  // Phi bins
1851  parSet[16] = ParameterSet( "phi bin scale", parStep[16], parMin[16], parMax[16] );
1852  parSet[17] = ParameterSet( "phi bin scale", parStep[17], parMin[17], parMax[17] );
1853  parSet[18] = ParameterSet( "phi bin scale", parStep[18], parMin[18], parMax[18] );
1854  parSet[19] = ParameterSet( "phi bin scale", parStep[19], parMin[19], parMax[19] );
1855  parSet[20] = ParameterSet( "phi bin scale", parStep[20], parMin[20], parMax[20] );
1856  parSet[21] = ParameterSet( "phi bin scale", parStep[21], parMin[21], parMax[21] );
1857  // parSet[22] = ParameterSet( "phi bin scale", parStep[22], parMin[22], parMax[22] );
1858 
1859  std::cout << "setting parameters" << std::endl;
1860  for( int i=0; i<this->parNum_; ++i ) {
1861  std::cout << "parStep["<<i<<"] = " << parStep[i]
1862  << ", parMin["<<i<<"] = " << parMin[i]
1863  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1864  }
1865  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
1866  }
1867 };
1868 
1869 
1870 //
1871 // Curvature: (linear in eta + sinusoidal in phi) * global scale
1872 // ------------------------------------------------------------
1873 template <class T>
1874 class scaleFunctionType33 : public scaleFunctionBase<T> {
1875 public:
1876  scaleFunctionType33() { this->parNum_ = 5; }
1877  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1878  double curv = (1.+parScale[0])*((double)chg/pt-(parScale[1]*eta+parScale[2]*eta*eta)-parScale[3]*sin(phi+parScale[4]));
1879  return 1./((double)chg*curv);
1880  }
1881  // Fill the scaleVec with neutral parameters
1882  virtual void resetParameters(std::vector<double> * scaleVec) const {
1883  // scaleVec->push_back(1);
1884  for( int i=0; i<this->parNum_; ++i ) {
1885  scaleVec->push_back(0);
1886  }
1887  }
1888  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
1889  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
1890  double thisStep[] = {0.000001, 0.000001, 0.000001, 0.000001, 0.01};
1891  TString thisParName[] = {"Curv global scale", "Eta slope", "Eta parabolic" "Phi ampl", "Phi phase"};
1892  if( muonType == 1 ) {
1893  double thisMini[] = {0.9, -0.1, -0.3, -0.3, -3.1416};
1894  double thisMaxi[] = {1.1, 0.1, 0.3, 0.3, 3.1416};
1895  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1896  } else {
1897  double thisMini[] = {0.97, -0.02, -0.3, -0.3, -3.1416};
1898  double thisMaxi[] = {1.03, 0.02, 0.3, 0.3, 3.1416};
1899  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1900  }
1901  }
1902  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1903  const T & parScale, const std::vector<int> & parScaleOrder,
1904  const std::vector<double> & parStep,
1905  const std::vector<double> & parMin,
1906  const std::vector<double> & parMax,
1907  const int muonType)
1908  {
1909  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1910  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1911  std::cout << "parNum = " << this->parNum_ << std::endl;
1912  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1913  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1914  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1915  exit(1);
1916  }
1917  std::vector<ParameterSet> parSet(this->parNum_);
1918  // name, step, mini, maxi
1919  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
1920  parSet[1] = ParameterSet( "Eta slope", parStep[1], parMin[1], parMax[1] );
1921  parSet[2] = ParameterSet( "Eta parabolic", parStep[2], parMin[2], parMax[2] );
1922  parSet[3] = ParameterSet( "Phi ampl", parStep[3], parMin[3], parMax[3] );
1923  parSet[4] = ParameterSet( "Phi phase", parStep[4], parMin[4], parMax[4] );
1924 
1925  std::cout << "setting parameters" << std::endl;
1926  for( int i=0; i<this->parNum_; ++i ) {
1927  std::cout << "parStep["<<i<<"] = " << parStep[i]
1928  << ", parMin["<<i<<"] = " << parMin[i]
1929  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1930  }
1931  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
1932  }
1933 
1934 };
1935 
1936 //
1937 // Curvature: (constant shift + linear in eta + sinusoidal in phi) * global scale
1938 // ------------------------------------------------------------
1939 template <class T>
1940 class scaleFunctionType34 : public scaleFunctionBase<T> {
1941 public:
1942  scaleFunctionType34() { this->parNum_ = 6; }
1943  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
1944  double curv = (1.+parScale[0])*((double)chg/pt-(double)chg*parScale[1]-(parScale[2]*eta+parScale[3]*eta*eta)-parScale[4]*sin(phi+parScale[5]));
1945  return 1./((double)chg*curv);
1946  }
1947  // Fill the scaleVec with neutral parameters
1948  virtual void resetParameters(std::vector<double> * scaleVec) const {
1949  // scaleVec->push_back(1);
1950  for( int i=0; i<this->parNum_; ++i ) {
1951  scaleVec->push_back(0);
1952  }
1953  }
1954  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
1955  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
1956  double thisStep[] = {0.000001, 0.000001, 0.000001, 0.000001, 0.000001, 0.000001};
1957  TString thisParName[] = {"Curv global scale", "Curv offset", "Eta slope", "Eta parabolic" "Phi ampl", "Phi phase"};
1958  if( muonType == 1 ) {
1959  double thisMini[] = {0.9, -0.1, -0.1, -0.3, -0.3, -3.1416};
1960  double thisMaxi[] = {1.1, 0.1, 0.1, 0.3, 0.3, 3.1416};
1961  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1962  } else {
1963  double thisMini[] = {0.97, -0.02, -0.02, -0.3, -0.3, -3.1416};
1964  double thisMaxi[] = {1.03, 0.02, 0.02, 0.3, 0.3, 3.1416};
1965  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
1966  }
1967  }
1968  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
1969  const T & parScale, const std::vector<int> & parScaleOrder,
1970  const std::vector<double> & parStep,
1971  const std::vector<double> & parMin,
1972  const std::vector<double> & parMax,
1973  const int muonType)
1974  {
1975  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
1976  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
1977  std::cout << "parNum = " << this->parNum_ << std::endl;
1978  std::cout << "parStep.size() = " << parStep.size() << std::endl;
1979  std::cout << "parMin.size() = " << parMin.size() << std::endl;
1980  std::cout << "parMax.size() = " << parMax.size() << std::endl;
1981  exit(1);
1982  }
1983  std::vector<ParameterSet> parSet(this->parNum_);
1984  // name, step, mini, maxi
1985  parSet[0] = ParameterSet( "Curv scale", parStep[0], parMin[0], parMax[0] );
1986  parSet[1] = ParameterSet( "Curv offset", parStep[1], parMin[1], parMax[1] );
1987  parSet[2] = ParameterSet( "Eta slope", parStep[2], parMin[2], parMax[2] );
1988  parSet[3] = ParameterSet( "Eta parabolic", parStep[3], parMin[3], parMax[3] );
1989  parSet[4] = ParameterSet( "Phi ampl", parStep[4], parMin[4], parMax[4] );
1990  parSet[5] = ParameterSet( "Phi phase", parStep[5], parMin[5], parMax[5] );
1991 
1992  std::cout << "setting parameters" << std::endl;
1993  for( int i=0; i<this->parNum_; ++i ) {
1994  std::cout << "parStep["<<i<<"] = " << parStep[i]
1995  << ", parMin["<<i<<"] = " << parMin[i]
1996  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
1997  }
1998  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
1999  }
2000 
2001 };
2002 
2003 //
2004 // Curvature: (linear in eta + sinusoidal in phi (in 7 eta bins)) * global scale
2005 // ------------------------------------------------------------
2006 template <class T>
2007 class scaleFunctionType35 : public scaleFunctionBase<T> {
2008 public:
2009  scaleFunctionType35() { this->parNum_ = 18; }
2010  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2011  double ampl(0), phase(0);
2012  if ( eta < -2.1 ) {
2013  ampl = parScale[3]; phase = parScale[4];
2014  } else if ( -2.1 <= eta && eta < -1.7 ) {
2015  ampl = parScale[5]; phase = parScale[6];
2016  } else if ( -1.7 <= eta && eta < -0.9 ) {
2017  ampl = parScale[7]; phase = parScale[8];
2018  } else if ( -0.9 <= eta && eta <= +0.9 ) {
2019  ampl = parScale[9]; phase = parScale[10];
2020  } else if ( +0.9 < eta && eta <= +1.7 ) {
2021  ampl = parScale[11]; phase = parScale[12];
2022  } else if ( +1.7 < eta && eta <= 2.1 ) {
2023  ampl = parScale[13]; phase = parScale[14];
2024  } else if ( +2.1 < eta ) {
2025  ampl = parScale[15]; phase = parScale[16];
2026  }
2027 
2028  double curv = (1.+parScale[0])*((double)chg/pt
2029  -(parScale[1]*eta+parScale[2]*eta*eta*eta)
2030  -ampl*sin(phi+phase)
2031  -0.5*(double)chg*parScale[17]);
2032  return 1./((double)chg*curv);
2033  }
2034  // Fill the scaleVec with neutral parameters
2035  virtual void resetParameters(std::vector<double> * scaleVec) const {
2036  // scaleVec->push_back(1);
2037  for( int i=0; i<this->parNum_; ++i ) {
2038  scaleVec->push_back(0);
2039  }
2040  }
2041  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2042  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2043  double thisStep[] = {0.000001, 0.000001, 0.000001, 0.000001, 0.01, 0.000001, 0.01, 0.000001, 0.01,0.000001, 0.01, 0.000001, 0.01, 0.000001};
2044  TString thisParName[] = {"Curv global scale" , "Eta slope", "Eta parabolic",
2045  "Phi ampl eta<-2.1" , "Phi phase eta<-2.1",
2046  "Phi ampl -2.1<eta<-1.7", "Phi phase -2.1<eta<-1.7",
2047  "Phi ampl -1.7<eta<-0.9", "Phi phase -1.7<eta<-0.9",
2048  "Phi ampl |eta|<0.9" , "Phi phase |eta|<0.9",
2049  "Phi ampl 0.9<eta<1.7" , "Phi phase 0.9<eta<1.7",
2050  "Phi ampl 1.7<eta<2.1" , "Phi phase 1.7<eta<2.1",
2051  "Phi ampl eta>+2.1" , "Phi phase eta>+2.1",
2052  "Charge depend bias" };
2053 
2054  if( muonType == 1 ) {
2055  double thisMini[] = {0.9, -0.1, -0.3, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.1};
2056  double thisMaxi[] = {1.1, 0.1, 0.3, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.1};
2057  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2058  } else {
2059  double thisMini[] = {0.97, -0.02, -0.3, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.3, -3.1416, -0.1};
2060  double thisMaxi[] = {1.03, 0.02, 0.3, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.1};
2061  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2062  }
2063  }
2064  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2065  const T & parScale, const std::vector<int> & parScaleOrder,
2066  const std::vector<double> & parStep,
2067  const std::vector<double> & parMin,
2068  const std::vector<double> & parMax,
2069  const int muonType)
2070  {
2071  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2072  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2073  std::cout << "parNum = " << this->parNum_ << std::endl;
2074  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2075  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2076  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2077  exit(1);
2078  }
2079  std::vector<ParameterSet> parSet(this->parNum_);
2080  // name, step, mini, maxi
2081  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2082  parSet[1] = ParameterSet( "Eta slope", parStep[1], parMin[1], parMax[1] );
2083  parSet[2] = ParameterSet( "Eta parabolic", parStep[2], parMin[2], parMax[2] );
2084  parSet[3] = ParameterSet( "Phi ampl eta<-2.1", parStep[3], parMin[3], parMax[3] );
2085  parSet[4] = ParameterSet( "Phi phase eta<-2.1", parStep[4], parMin[4], parMax[4] );
2086  parSet[5] = ParameterSet( "Phi ampl -2.1<eta<-1.7",parStep[5], parMin[5], parMax[5] );
2087  parSet[6] = ParameterSet( "Phi phase -2.1<eta<-1.7",parStep[6], parMin[6], parMax[6] );
2088  parSet[7] = ParameterSet( "Phi ampl -1.7<eta<-0.9",parStep[7], parMin[7], parMax[7] );
2089  parSet[8] = ParameterSet( "Phi phase -1.7<eta<-0.9",parStep[8], parMin[8], parMax[8] );
2090  parSet[9] = ParameterSet( "Phi ampl |eta|<0.9", parStep[9], parMin[9], parMax[9] );
2091  parSet[10] = ParameterSet( "Phi phase |eta|<0.9", parStep[10], parMin[10], parMax[10] );
2092  parSet[11] = ParameterSet( "Phi ampl 0.9<eta<1.7", parStep[11], parMin[11], parMax[11] );
2093  parSet[12] = ParameterSet( "Phi phase 0.9<eta<1.7", parStep[12], parMin[12], parMax[12] );
2094  parSet[13] = ParameterSet( "Phi ampl 1.7<eta<2.1", parStep[13], parMin[13], parMax[13] );
2095  parSet[14] = ParameterSet( "Phi phase 1.7<eta<2.1", parStep[14], parMin[14], parMax[14] );
2096  parSet[15] = ParameterSet( "Phi ampl eta>2.1", parStep[15], parMin[15], parMax[15] );
2097  parSet[16] = ParameterSet( "Phi phase eta>2.1", parStep[16], parMin[16], parMax[16] );
2098  parSet[17] = ParameterSet( "Charge depend bias", parStep[17], parMin[17], parMax[17] );
2099 
2100  std::cout << "setting parameters" << std::endl;
2101  for( int i=0; i<this->parNum_; ++i ) {
2102  std::cout << "parStep["<<i<<"] = " << parStep[i]
2103  << ", parMin["<<i<<"] = " << parMin[i]
2104  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2105  }
2106  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2107  }
2108 
2109 };
2110 
2111 //
2112 // Curvature: (SinHyp in eta + sinusoidal in phi (both in 3 eta bins)) * global scale
2113 // ------------------------------------------------------------
2114 template <class T>
2115 class scaleFunctionType36 : public scaleFunctionBase<T> {
2116 public:
2117  scaleFunctionType36() { this->parNum_ = 13; }
2118  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2119  double ampl(0), phase(0), twist(0);
2120  if ( eta < parScale[11] ) {
2121  ampl = parScale[1]; phase = parScale[2];
2122  twist = parScale[3]*TMath::SinH(eta-parScale[11])+parScale[6]*TMath::SinH(parScale[11]) ;
2123  } else if ( parScale[11] <= eta && eta <= parScale[12] ) {
2124  ampl = parScale[4]; phase = parScale[5];
2125  twist = parScale[6]*TMath::SinH(eta);
2126  } else if ( parScale[12] < eta ) {
2127  ampl = parScale[7]; phase = parScale[8];
2128  twist = parScale[9]*TMath::SinH(eta-parScale[12])+parScale[6]*TMath::SinH(parScale[12]) ;
2129  }
2130  double curv = (1.+parScale[0])*((double)chg/pt
2131  -twist
2132  -ampl*sin(phi+phase)
2133  -0.5*(double)chg*parScale[10]);
2134  return 1./((double)chg*curv);
2135  }
2136  // Fill the scaleVec with neutral parameters
2137  virtual void resetParameters(std::vector<double> * scaleVec) const {
2138  // scaleVec->push_back(1);
2139  for( int i=0; i<this->parNum_; ++i ) {
2140  scaleVec->push_back(0);
2141  }
2142  }
2143  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2144  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2145  double thisStep[] = {0.000001,
2146  0.000001, 0.01, 0.000001,
2147  0.000001, 0.01, 0.000001,
2148  0.000001, 0.01, 0.000001,
2149  0.000001,
2150  -0.01, 0.01};
2151  TString thisParName[] = {"Curv global scale" ,
2152  "Phi ampl eta<-1.5" , "Phi phase eta<-1.5" , "Twist eta<-1.5" ,
2153  "Phi ampl |eta|<1.5" , "Phi phase |eta|<1.5", "Twist |eta|<1.5" ,
2154  "Phi ampl eta>+1.5" , "Phi phase eta>+1.5" , "Twist eta>+1.5" ,
2155  "Charge depend bias",
2156  "eta neg boundary", "eta pos boundary"};
2157  if( muonType == 1 ) {
2158  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2159  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2160  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2161  } else {
2162  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2163  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2164  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2165  }
2166  }
2167  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2168  const T & parScale, const std::vector<int> & parScaleOrder,
2169  const std::vector<double> & parStep,
2170  const std::vector<double> & parMin,
2171  const std::vector<double> & parMax,
2172  const int muonType)
2173  {
2174  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2175  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2176  std::cout << "parNum = " << this->parNum_ << std::endl;
2177  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2178  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2179  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2180  exit(1);
2181  }
2182  std::vector<ParameterSet> parSet(this->parNum_);
2183  // name, step, mini, maxi
2184  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2185  parSet[1] = ParameterSet( "Phi ampl eta<-1.5", parStep[1], parMin[1], parMax[1] );
2186  parSet[2] = ParameterSet( "Phi phase eta<-1.5", parStep[2], parMin[2], parMax[2] );
2187  parSet[3] = ParameterSet( "Twist eta<-1.5", parStep[3], parMin[3], parMax[3] );
2188  parSet[4] = ParameterSet( "Phi ampl |eta|<1.5", parStep[4], parMin[4], parMax[4] );
2189  parSet[5] = ParameterSet( "Phi phase |eta|<1.5", parStep[5], parMin[5], parMax[5] );
2190  parSet[6] = ParameterSet( "Twist |eta|<1.5", parStep[6], parMin[6], parMax[6] );
2191  parSet[7] = ParameterSet( "Phi ampl eta>1.5", parStep[7], parMin[7], parMax[7] );
2192  parSet[8] = ParameterSet( "Phi phase eta>1.5", parStep[8], parMin[8], parMax[8] );
2193  parSet[9] = ParameterSet( "Twist eta>1.5" , parStep[9], parMin[9], parMax[9] );
2194  parSet[10] = ParameterSet( "Charge depend bias", parStep[10],parMin[10],parMax[10] );
2195  parSet[11] = ParameterSet( "Eta neg boundary", parStep[11],parMin[11],parMax[11] );
2196  parSet[12] = ParameterSet( "Eta pos boundary", parStep[12],parMin[12],parMax[12] );
2197 
2198 
2199  std::cout << "setting parameters" << std::endl;
2200  for( int i=0; i<this->parNum_; ++i ) {
2201  std::cout << "parStep["<<i<<"] = " << parStep[i]
2202  << ", parMin["<<i<<"] = " << parMin[i]
2203  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2204  }
2205  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2206  }
2207 
2208 };
2209 
2210 //
2211 // Curvature: (SinHyp in eta + sinusoidal in phi (both in 3 eta bins)) * global scale >> Not continuous in eta
2212 // ------------------------------------------------------------
2213 template <class T>
2214 class scaleFunctionType37 : public scaleFunctionBase<T> {
2215 public:
2216  scaleFunctionType37() { this->parNum_ = 13; }
2217  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2218  double ampl(0), phase(0), twist(0);
2219  if ( eta < parScale[11] ) {
2220  ampl = parScale[1]; phase = parScale[2];
2221  twist = parScale[3]*TMath::SinH(eta);
2222  } else if ( parScale[11] <= eta && eta <= parScale[12] ) {
2223  ampl = parScale[4]; phase = parScale[5];
2224  twist = parScale[6]*TMath::SinH(eta);
2225  } else if ( parScale[12] < eta ) {
2226  ampl = parScale[7]; phase = parScale[8];
2227  twist = parScale[9]*TMath::SinH(eta);
2228  }
2229  double curv = (1.+parScale[0])*((double)chg/pt
2230  -twist
2231  -ampl*sin(phi+phase)
2232  -0.5*parScale[10]);
2233  return 1./((double)chg*curv);
2234  }
2235  // Fill the scaleVec with neutral parameters
2236  virtual void resetParameters(std::vector<double> * scaleVec) const {
2237  // scaleVec->push_back(1);
2238  for( int i=0; i<this->parNum_; ++i ) {
2239  scaleVec->push_back(0);
2240  }
2241  }
2242  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2243  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2244  double thisStep[] = {0.000001,
2245  0.000001, 0.01, 0.000001,
2246  0.000001, 0.01, 0.000001,
2247  0.000001, 0.01, 0.000001,
2248  0.000001,
2249  -0.01, 0.01};
2250  TString thisParName[] = {"Curv global scale" ,
2251  "Phi ampl eta<-1.5" , "Phi phase eta<-1.5" , "Twist eta<-1.5" ,
2252  "Phi ampl |eta|<1.5" , "Phi phase |eta|<1.5", "Twist |eta|<1.5" ,
2253  "Phi ampl eta>+1.5" , "Phi phase eta>+1.5" , "Twist eta>+1.5" ,
2254  "Charge depend bias",
2255  "eta neg boundary", "eta pos boundary"};
2256  if( muonType == 1 ) {
2257  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2258  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2259  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2260  } else {
2261  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2262  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2263  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2264  }
2265  }
2266  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2267  const T & parScale, const std::vector<int> & parScaleOrder,
2268  const std::vector<double> & parStep,
2269  const std::vector<double> & parMin,
2270  const std::vector<double> & parMax,
2271  const int muonType)
2272  {
2273  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2274  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2275  std::cout << "parNum = " << this->parNum_ << std::endl;
2276  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2277  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2278  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2279  exit(1);
2280  }
2281  std::vector<ParameterSet> parSet(this->parNum_);
2282  // name, step, mini, maxi
2283  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2284  parSet[1] = ParameterSet( "Phi ampl eta<-1.5", parStep[1], parMin[1], parMax[1] );
2285  parSet[2] = ParameterSet( "Phi phase eta<-1.5", parStep[2], parMin[2], parMax[2] );
2286  parSet[3] = ParameterSet( "Twist eta<-1.5", parStep[3], parMin[3], parMax[3] );
2287  parSet[4] = ParameterSet( "Phi ampl |eta|<1.5", parStep[4], parMin[4], parMax[4] );
2288  parSet[5] = ParameterSet( "Phi phase |eta|<1.5", parStep[5], parMin[5], parMax[5] );
2289  parSet[6] = ParameterSet( "Twist |eta|<1.5", parStep[6], parMin[6], parMax[6] );
2290  parSet[7] = ParameterSet( "Phi ampl eta>1.5", parStep[7], parMin[7], parMax[7] );
2291  parSet[8] = ParameterSet( "Phi phase eta>1.5", parStep[8], parMin[8], parMax[8] );
2292  parSet[9] = ParameterSet( "Twist eta>1.5" , parStep[9], parMin[9], parMax[9] );
2293  parSet[10] = ParameterSet( "Charge depend bias", parStep[10],parMin[10],parMax[10] );
2294  parSet[11] = ParameterSet( "Eta neg boundary", parStep[11],parMin[11],parMax[11] );
2295  parSet[12] = ParameterSet( "Eta pos boundary", parStep[12],parMin[12],parMax[12] );
2296 
2297 
2298  std::cout << "setting parameters" << std::endl;
2299  for( int i=0; i<this->parNum_; ++i ) {
2300  std::cout << "parStep["<<i<<"] = " << parStep[i]
2301  << ", parMin["<<i<<"] = " << parMin[i]
2302  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2303  }
2304  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2305  }
2306 
2307 };
2308 
2309 
2310 //
2311 // Curvature: (SinHyp in eta + sinusoidal in phi (both in 3 eta bins)) * global scale
2312 // ------------------------------------------------------------
2313 template <class T>
2314 class scaleFunctionType38 : public scaleFunctionBase<T> {
2315 public:
2316  scaleFunctionType38() { this->parNum_ = 13; }
2317  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2318  double ampl(0), phase(0), twist(0);
2319  if ( eta < parScale[11] ) {
2320  ampl = parScale[1]; phase = parScale[2];
2321  twist = parScale[3]*(eta-parScale[11])+parScale[6]*parScale[11] ;
2322  } else if ( parScale[11] <= eta && eta <= parScale[12] ) {
2323  ampl = parScale[4]; phase = parScale[5];
2324  twist = parScale[6]*TMath::SinH(eta);
2325  } else if ( parScale[12] < eta ) {
2326  ampl = parScale[7]; phase = parScale[8];
2327  twist = parScale[9]*(eta-parScale[12])+parScale[6]*parScale[12];
2328  }
2329  double curv = (1.+parScale[0])*((double)chg/pt
2330  -twist
2331  -ampl*sin(phi+phase)
2332  -0.5*parScale[10]);
2333  return 1./((double)chg*curv);
2334  }
2335  // Fill the scaleVec with neutral parameters
2336  virtual void resetParameters(std::vector<double> * scaleVec) const {
2337  // scaleVec->push_back(1);
2338  for( int i=0; i<this->parNum_; ++i ) {
2339  scaleVec->push_back(0);
2340  }
2341  }
2342  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2343  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2344  double thisStep[] = {0.000001,
2345  0.000001, 0.01, 0.000001,
2346  0.000001, 0.01, 0.000001,
2347  0.000001, 0.01, 0.000001,
2348  0.000001,
2349  0.01, 0.01};
2350  TString thisParName[] = {"Curv global scale" ,
2351  "Phi ampl eta<-1.5" , "Phi phase eta<-1.5" , "Twist eta<-1.5" ,
2352  "Phi ampl |eta|<1.5" , "Phi phase |eta|<1.5", "Twist |eta|<1.5" ,
2353  "Phi ampl eta>+1.5" , "Phi phase eta>+1.5" , "Twist eta>+1.5" ,
2354  "Charge depend bias",
2355  "eta neg boundary", "eta pos boundary"};
2356  if( muonType == 1 ) {
2357  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2358  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2359  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2360  } else {
2361  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -3.1416, -0.3, -0.3, -2.6, 0.};
2362  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 3.1416, 0.3, 0.3, 0., 2.6};
2363  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2364  }
2365  }
2366  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2367  const T & parScale, const std::vector<int> & parScaleOrder,
2368  const std::vector<double> & parStep,
2369  const std::vector<double> & parMin,
2370  const std::vector<double> & parMax,
2371  const int muonType)
2372  {
2373  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2374  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2375  std::cout << "parNum = " << this->parNum_ << std::endl;
2376  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2377  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2378  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2379  exit(1);
2380  }
2381  std::vector<ParameterSet> parSet(this->parNum_);
2382  // name, step, mini, maxi
2383  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2384  parSet[1] = ParameterSet( "Phi ampl eta<-1.5", parStep[1], parMin[1], parMax[1] );
2385  parSet[2] = ParameterSet( "Phi phase eta<-1.5", parStep[2], parMin[2], parMax[2] );
2386  parSet[3] = ParameterSet( "Twist eta<-1.5", parStep[3], parMin[3], parMax[3] );
2387  parSet[4] = ParameterSet( "Phi ampl |eta|<1.5", parStep[4], parMin[4], parMax[4] );
2388  parSet[5] = ParameterSet( "Phi phase |eta|<1.5", parStep[5], parMin[5], parMax[5] );
2389  parSet[6] = ParameterSet( "Twist |eta|<1.5", parStep[6], parMin[6], parMax[6] );
2390  parSet[7] = ParameterSet( "Phi ampl eta>1.5", parStep[7], parMin[7], parMax[7] );
2391  parSet[8] = ParameterSet( "Phi phase eta>1.5", parStep[8], parMin[8], parMax[8] );
2392  parSet[9] = ParameterSet( "Twist eta>1.5" , parStep[9], parMin[9], parMax[9] );
2393  parSet[10] = ParameterSet( "Charge depend bias", parStep[10],parMin[10],parMax[10] );
2394  parSet[11] = ParameterSet( "Eta neg boundary", parStep[11],parMin[11],parMax[11] );
2395  parSet[12] = ParameterSet( "Eta pos boundary", parStep[12],parMin[12],parMax[12] );
2396 
2397 
2398  std::cout << "setting parameters" << std::endl;
2399  for( int i=0; i<this->parNum_; ++i ) {
2400  std::cout << "parStep["<<i<<"] = " << parStep[i]
2401  << ", parMin["<<i<<"] = " << parMin[i]
2402  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2403  }
2404  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2405  }
2406 
2407 };
2408 
2409 
2410 
2411 //
2412 // Curvature: (linear eta + sinusoidal in phi (both in 5 eta bins)) * global scale
2413 // ------------------------------------------------------------
2414 template <class T>
2415 class scaleFunctionType50 : public scaleFunctionBase<T> {
2416 public:
2417  scaleFunctionType50() { this->parNum_ = 27; }
2418  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2419  double ampl(0), phase(0), twist(0), ampl2(0), freq2(0), phase2(0);
2420 
2421 // very bwd bin
2422  if ( eta < parScale[4] ) {
2423  ampl = parScale[1]; phase = parScale[2]; ampl2 = parScale[21]; freq2 = parScale[22]; phase2 = parScale[23];
2424  twist = parScale[3]*(eta-parScale[4])+parScale[7]*(parScale[4]-parScale[8])+parScale[11]*parScale[8];
2425 // bwd bin
2426  } else if ( parScale[4] <= eta && eta < parScale[8] ) {
2427  ampl = parScale[5]; phase = parScale[6];
2428  twist = parScale[7]*(eta-parScale[8])+parScale[11]*parScale[8] ;
2429 // barrel bin
2430  } else if ( parScale[8] <= eta && eta < parScale[12] ) {
2431  ampl = parScale[9]; phase = parScale[10];
2432  twist = parScale[11]*eta;
2433 // fwd bin
2434  } else if ( parScale[12] <= eta && eta < parScale[16] ) {
2435  ampl = parScale[13]; phase = parScale[14];
2436  twist = parScale[15]*(eta-parScale[12])+parScale[11]*parScale[12];
2437 // very fwd bin
2438  } else if ( parScale[16] < eta ) {
2439  ampl = parScale[17]; phase = parScale[18]; ampl2 = parScale[24]; freq2 = parScale[25]; phase2 = parScale[26];
2440  twist = parScale[19]*(eta-parScale[16])+parScale[15]*(parScale[16]-parScale[12])+parScale[11]*parScale[12];
2441  }
2442 
2443 // apply the correction
2444  double curv = (1.+parScale[0])*((double)chg/pt
2445  -twist
2446  -ampl*sin(phi+phase)
2447  -ampl2*sin((int)freq2*phi+phase2)
2448  -0.5*parScale[20]);
2449  return 1./((double)chg*curv);
2450  }
2451  // Fill the scaleVec with neutral parameters
2452  virtual void resetParameters(std::vector<double> * scaleVec) const {
2453  // scaleVec->push_back(1);
2454  for( int i=0; i<this->parNum_; ++i ) {
2455  scaleVec->push_back(0);
2456  }
2457  }
2458  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2459  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2460 
2461  double thisStep[] = {0.000001,
2462  0.000001, 0.01, 0.000001, 0.01,
2463  0.000001, 0.01, 0.000001, 0.01,
2464  0.000001, 0.01, 0.000001, 0.01,
2465  0.000001, 0.01, 0.000001, 0.01,
2466  0.000001, 0.01, 0.000001,
2467  0.000001,
2468  0.000001, 0.01, 0.01,
2469  0.000001, 0.01, 0.01};
2470 
2471  TString thisParName[] = { "Curv global scale"
2472  , "Phi ampl eta vbwd" , "Phi phase eta vbwd" , "Twist eta vbwd", "vbwd/bwd bndry"
2473  , "Phi ampl eta bwd" , "Phi phase eta bwd" , "Twist eta bwd", "bwd/bar bndry"
2474  , "Phi ampl eta bar" , "Phi phase eta bar" , "Twist eta bar", "bar/fwd bndry"
2475  , "Phi ampl eta fwd" , "Phi phase eta fwd" , "Twist eta fwd", "fwd/vfwd bndry"
2476  , "Phi ampl eta vfwd" , "Phi phase eta vfwd" , "Twist eta vfwd"
2477  , "Charge depend bias"
2478  , "Phi ampl eta vbwd (2nd harmon.)", "Phi freq. eta vbwd (2nd harmon.)", "Phi phase eta vbwd (2nd harmon.)"
2479  , "Phi ampl eta vfwd (2nd harmon.)", "Phi freq. eta vfwd (2nd harmon.)", "Phi phase eta vfwd (2nd harmon.)"};
2480 
2481  if( muonType == 1 ) {
2482  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1, -0.3, 1., -3.1416, -0.3, 1., -3.1416};
2483  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1, 0.3, 5., 3.1416, 0.3, 5., 3.1416};
2484  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2485  } else {
2486  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1, -0.3, 1., -3.1416, -0.3, 1., -3.1416};
2487  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1, 0.3, 5., 3.1416, 0.3, 5., 3.1416};
2488  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2489  }
2490  }
2491  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2492  const T & parScale, const std::vector<int> & parScaleOrder,
2493  const std::vector<double> & parStep,
2494  const std::vector<double> & parMin,
2495  const std::vector<double> & parMax,
2496  const int muonType)
2497  {
2498  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2499  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2500  std::cout << "parNum = " << this->parNum_ << std::endl;
2501  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2502  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2503  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2504  exit(1);
2505  }
2506  std::vector<ParameterSet> parSet(this->parNum_);
2507  // name, step, mini, maxi
2508  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2509  parSet[1] = ParameterSet( "Phi ampl vbwd", parStep[1], parMin[1], parMax[1] );
2510  parSet[2] = ParameterSet( "Phi phase vbwd", parStep[2], parMin[2], parMax[2] );
2511  parSet[3] = ParameterSet( "Twist vbwd", parStep[3], parMin[3], parMax[3] );
2512  parSet[4] = ParameterSet( "vbwd/bwd bndry", parStep[4], parMin[4], parMax[4] );
2513  parSet[5] = ParameterSet( "Phi ampl bwd", parStep[5], parMin[5], parMax[5] );
2514  parSet[6] = ParameterSet( "Phi phase bwd", parStep[6], parMin[6], parMax[6] );
2515  parSet[7] = ParameterSet( "Twist bwd", parStep[7], parMin[7], parMax[7] );
2516  parSet[8] = ParameterSet( "bwd/bar bndry", parStep[8], parMin[8], parMax[8] );
2517  parSet[9] = ParameterSet( "Phi ampl bar", parStep[9], parMin[9], parMax[9] );
2518  parSet[10] = ParameterSet( "Phi phase bar", parStep[10],parMin[10],parMax[10] );
2519  parSet[11] = ParameterSet( "Twist bar", parStep[11],parMin[11],parMax[11] );
2520  parSet[12] = ParameterSet( "bar/fwd bndry", parStep[12],parMin[12],parMax[12] );
2521  parSet[13] = ParameterSet( "Phi ampl fwd", parStep[13],parMin[13],parMax[13] );
2522  parSet[14] = ParameterSet( "Phi phase fwd", parStep[14],parMin[14],parMax[14] );
2523  parSet[15] = ParameterSet( "Twist fwd", parStep[15],parMin[15],parMax[15] );
2524  parSet[16] = ParameterSet( "fwd/vfwd bndry", parStep[16],parMin[16],parMax[16] );
2525  parSet[17] = ParameterSet( "Phi ampl vfwd", parStep[17],parMin[17],parMax[17] );
2526  parSet[18] = ParameterSet( "Phi phase vfwd", parStep[18],parMin[18],parMax[18] );
2527  parSet[19] = ParameterSet( "Twist vfwd", parStep[19],parMin[19],parMax[19] );
2528  parSet[20] = ParameterSet( "Charge depend bias", parStep[20],parMin[20],parMax[20] );
2529  parSet[21] = ParameterSet( "Phi ampl vbwd (2nd)", parStep[21],parMin[21],parMax[21] );
2530  parSet[22] = ParameterSet( "Phi freq vbwd (2nd)", parStep[22],parMin[22],parMax[22] );
2531  parSet[23] = ParameterSet( "Phi phase vbwd (2nd)",parStep[23],parMin[23],parMax[23] );
2532  parSet[24] = ParameterSet( "Phi ampl vfwd (2nd)", parStep[24],parMin[24],parMax[24] );
2533  parSet[25] = ParameterSet( "Phi freq vfwd (2nd)", parStep[25],parMin[25],parMax[25] );
2534  parSet[26] = ParameterSet( "Phi phase vfwd (2nd)",parStep[26],parMin[26],parMax[26] );
2535 
2536 
2537  std::cout << "setting parameters" << std::endl;
2538  for( int i=0; i<this->parNum_; ++i ) {
2539  std::cout << "parStep["<<i<<"] = " << parStep[i]
2540  << ", parMin["<<i<<"] = " << parMin[i]
2541  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2542  }
2543  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2544  }
2545 
2546 };
2547 
2548 //
2549 // Curvature: (linear eta (5 eta bins) + sinusoidal in phi (6 eta bins)) * global scale
2550 // ------------------------------------------------------------
2551 template <class T>
2552 class scaleFunctionType51 : public scaleFunctionBase<T> {
2553 public:
2554  scaleFunctionType51() { this->parNum_ = 23; }
2555  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2556  double ampl(0), phase(0), twist(0);
2557 
2558 // very bwd bin
2559  if ( eta < parScale[4] ) {
2560  ampl = parScale[1]; phase = parScale[2];
2561  twist = parScale[3]*(eta-parScale[4])+parScale[7]*(parScale[4]-parScale[8])+parScale[11]*parScale[8];
2562 // bwd bin
2563  } else if ( parScale[4] <= eta && eta < parScale[8] ) {
2564  ampl = parScale[5]; phase = parScale[6];
2565  twist = parScale[7]*(eta-parScale[8])+parScale[11]*parScale[8] ;
2566 // barrel bin 1
2567  } else if ( parScale[8] <= eta && eta < parScale[14] ) {
2568  if ( eta < 0 ) {
2569  ampl = parScale[9]; phase = parScale[10];
2570  } else if ( eta > 0 ) {
2571  ampl = parScale[11]; phase = parScale[12];
2572  }
2573  twist = parScale[13]*eta;
2574 // fwd bin
2575  } else if ( parScale[14] <= eta && eta < parScale[18] ) {
2576  ampl = parScale[15]; phase = parScale[16];
2577  twist = parScale[17]*(eta-parScale[14])+parScale[13]*parScale[14];
2578 // very fwd bin
2579  } else if ( parScale[18] < eta ) {
2580  ampl = parScale[19]; phase = parScale[20];
2581  twist = parScale[21]*(eta-parScale[18])+parScale[17]*(parScale[18]-parScale[14])+parScale[13]*parScale[14];
2582  }
2583 
2584 // apply the correction
2585  double curv = (1.+parScale[0])*((double)chg/pt
2586  -twist
2587  -ampl*sin(phi+phase)
2588  -0.5*parScale[22]);
2589  return 1./((double)chg*curv);
2590  }
2591  // Fill the scaleVec with neutral parameters
2592  virtual void resetParameters(std::vector<double> * scaleVec) const {
2593  // scaleVec->push_back(1);
2594  for( int i=0; i<this->parNum_; ++i ) {
2595  scaleVec->push_back(0);
2596  }
2597  }
2598  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2599  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2600 
2601  double thisStep[] = {0.000001,
2602  0.000001, 0.01, 0.000001, 0.01,
2603  0.000001, 0.01, 0.000001, 0.01,
2604  0.000001, 0.01, 0.000001, 0.01,
2605  0.000001, 0.01, 0.000001, 0.01,
2606  0.000001, 0.01, 0.000001, 0.01,
2607  0.000001, 0.01, 0.000001,
2608  0.000001};
2609 
2610  TString thisParName[] = { "Curv global scale"
2611  , "Phi ampl eta vbwd" , "Phi phase eta vbwd" , "Twist eta vbwd", "vbwd/bwd bndry"
2612  , "Phi ampl eta bwd" , "Phi phase eta bwd" , "Twist eta bwd", "bwd/bar bndry"
2613  , "Phi ampl eta bar-" ,"Phi phase eta bar-", "Phi ampl eta bar+","Phi phase eta bar+" , "Twist eta bar", "bar/fwd bndry"
2614  , "Phi ampl eta fwd" , "Phi phase eta fwd" , "Twist eta fwd", "fwd/vfwd bndry"
2615  , "Phi ampl eta vfwd" , "Phi phase eta vfwd" , "Twist eta vfwd"
2616  , "Charge depend bias"};
2617 
2618  if( muonType == 1 ) {
2619  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1};
2620  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1};
2621  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2622  } else {
2623  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1};
2624  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1};
2625  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2626  }
2627  }
2628  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2629  const T & parScale, const std::vector<int> & parScaleOrder,
2630  const std::vector<double> & parStep,
2631  const std::vector<double> & parMin,
2632  const std::vector<double> & parMax,
2633  const int muonType)
2634  {
2635  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2636  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2637  std::cout << "parNum = " << this->parNum_ << std::endl;
2638  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2639  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2640  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2641  exit(1);
2642  }
2643  std::vector<ParameterSet> parSet(this->parNum_);
2644  // name, step, mini, maxi
2645  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2646  parSet[1] = ParameterSet( "Phi ampl vbwd", parStep[1], parMin[1], parMax[1] );
2647  parSet[2] = ParameterSet( "Phi phase vbwd", parStep[2], parMin[2], parMax[2] );
2648  parSet[3] = ParameterSet( "Twist vbwd", parStep[3], parMin[3], parMax[3] );
2649  parSet[4] = ParameterSet( "vbwd/bwd bndry", parStep[4], parMin[4], parMax[4] );
2650  parSet[5] = ParameterSet( "Phi ampl bwd", parStep[5], parMin[5], parMax[5] );
2651  parSet[6] = ParameterSet( "Phi phase bwd", parStep[6], parMin[6], parMax[6] );
2652  parSet[7] = ParameterSet( "Twist bwd", parStep[7], parMin[7], parMax[7] );
2653  parSet[8] = ParameterSet( "bwd/bar bndry", parStep[8], parMin[8], parMax[8] );
2654  parSet[9] = ParameterSet( "Phi ampl bar-", parStep[9], parMin[9], parMax[9] );
2655  parSet[10] = ParameterSet( "Phi phase bar-", parStep[10],parMin[10],parMax[10] );
2656  parSet[11] = ParameterSet( "Phi ampl bar+", parStep[11],parMin[11],parMax[11] );
2657  parSet[12] = ParameterSet( "Phi phase bar+", parStep[12],parMin[12],parMax[12] );
2658  parSet[13] = ParameterSet( "Twist bar", parStep[13],parMin[13],parMax[13] );
2659  parSet[14] = ParameterSet( "bar/fwd bndry", parStep[14],parMin[14],parMax[14] );
2660  parSet[15] = ParameterSet( "Phi ampl fwd", parStep[15],parMin[15],parMax[15] );
2661  parSet[16] = ParameterSet( "Phi phase fwd", parStep[16],parMin[16],parMax[16] );
2662  parSet[17] = ParameterSet( "Twist fwd", parStep[17],parMin[17],parMax[17] );
2663  parSet[18] = ParameterSet( "fwd/vfwd bndry", parStep[18],parMin[18],parMax[18] );
2664  parSet[19] = ParameterSet( "Phi ampl vfwd", parStep[19],parMin[19],parMax[19] );
2665  parSet[20] = ParameterSet( "Phi phase vfwd", parStep[20],parMin[20],parMax[20] );
2666  parSet[21] = ParameterSet( "Twist vfwd", parStep[21],parMin[21],parMax[21] );
2667  parSet[22] = ParameterSet( "Charge depend bias", parStep[22],parMin[22],parMax[22] );
2668 
2669  std::cout << "setting parameters" << std::endl;
2670  for( int i=0; i<this->parNum_; ++i ) {
2671  std::cout << "parStep["<<i<<"] = " << parStep[i]
2672  << ", parMin["<<i<<"] = " << parMin[i]
2673  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2674  }
2675  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2676  }
2677 
2678 };
2679 
2680 
2681 //
2682 // Curvature: (linear eta + sinusoidal in phi (mode 1+2) (both in 5 eta bins)) * global scale
2683 // ------------------------------------------------------------
2684 template <class T>
2685 class scaleFunctionType52 : public scaleFunctionBase<T> {
2686 public:
2687  scaleFunctionType52() { this->parNum_ = 31; }
2688  virtual double scale(const double & pt, const double & eta, const double & phi, const int chg, const T & parScale) const {
2689  double ampl(0), phase(0), ampl2(0), phase2(0), twist(0);
2690 
2691 // very bwd bin
2692  if ( eta < parScale[4] ) {
2693  ampl = parScale[1]; phase = parScale[2];
2694  ampl2 = parScale[21]; phase2 = parScale[22];
2695  twist = parScale[3]*(eta-parScale[4])+parScale[7]*(parScale[4]-parScale[8])+parScale[11]*parScale[8];
2696 // bwd bin
2697  } else if ( parScale[4] <= eta && eta < parScale[8] ) {
2698  ampl = parScale[5]; phase = parScale[6];
2699  ampl2 = parScale[23]; phase2 = parScale[24];
2700  twist = parScale[7]*(eta-parScale[8])+parScale[11]*parScale[8] ;
2701 // barrel bin
2702  } else if ( parScale[8] <= eta && eta < parScale[12] ) {
2703  ampl = parScale[9]; phase = parScale[10];
2704  ampl2 = parScale[25]; phase2 = parScale[26];
2705  twist = parScale[11]*eta;
2706 // fwd bin
2707  } else if ( parScale[12] <= eta && eta < parScale[16] ) {
2708  ampl = parScale[13]; phase = parScale[14];
2709  ampl2 = parScale[27]; phase2 = parScale[28];
2710  twist = parScale[15]*(eta-parScale[12])+parScale[11]*parScale[12];
2711 // very fwd bin
2712  } else if ( parScale[16] < eta ) {
2713  ampl = parScale[17]; phase = parScale[18];
2714  ampl2 = parScale[29]; phase2 = parScale[30];
2715  twist = parScale[19]*(eta-parScale[16])+parScale[15]*(parScale[16]-parScale[12])+parScale[11]*parScale[12];
2716  }
2717 
2718 // apply the correction
2719  double curv = (1.+parScale[0])*((double)chg/pt
2720  -twist
2721  -ampl*sin(phi+phase)
2722  -ampl2*sin(2*phi+phase2)
2723  -0.5*parScale[20]);
2724  return 1./((double)chg*curv);
2725  }
2726  // Fill the scaleVec with neutral parameters
2727  virtual void resetParameters(std::vector<double> * scaleVec) const {
2728  // scaleVec->push_back(1);
2729  for( int i=0; i<this->parNum_; ++i ) {
2730  scaleVec->push_back(0);
2731  }
2732  }
2733  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
2734  TString* parname, const T & parScale, const std::vector<int> & parScaleOrder, const int muonType) {
2735 
2736  double thisStep[] = {0.000001,
2737  0.000001, 0.01, 0.000001, 0.01,
2738  0.000001, 0.01, 0.000001, 0.01,
2739  0.000001, 0.01, 0.000001, 0.01,
2740  0.000001, 0.01, 0.000001, 0.01,
2741  0.000001, 0.01, 0.000001,
2742  0.000001,
2743  0.000001, 0.01, 0.000001, 0.01, 0.000001, 0.01, 0.000001, 0.01, 0.000001, 0.01
2744  };
2745 
2746  TString thisParName[] = { "Curv global scale"
2747  , "Phi ampl eta vbwd" , "Phi phase eta vbwd" , "Twist eta vbwd", "vbwd/bwd bndry"
2748  , "Phi ampl eta bwd" , "Phi phase eta bwd" , "Twist eta bwd", "bwd/bar bndry"
2749  , "Phi ampl eta bar" , "Phi phase eta bar" , "Twist eta bar", "bar/fwd bndry"
2750  , "Phi ampl eta fwd" , "Phi phase eta fwd" , "Twist eta fwd", "fwd/vfwd bndry"
2751  , "Phi ampl eta vfwd" , "Phi phase eta vfwd" , "Twist eta vfwd"
2752  , "Charge depend bias"
2753  , "Phi ampl2 eta vbwd" , "Phi phase2 eta vbwd"
2754  , "Phi ampl2 eta bwd" , "Phi phase2 eta bwd"
2755  , "Phi ampl2 eta bar" , "Phi phase2 eta bar"
2756  , "Phi ampl2 eta fwd" , "Phi phase2 eta fwd"
2757  , "Phi ampl2 eta vfwd" , "Phi phase2 eta vfwd"
2758  };
2759 
2760  if( muonType == 1 ) {
2761  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416};
2762  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416};
2763  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2764  } else {
2765  double thisMini[] = {-0.1, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, -2.6, -0.3, -3.1416, -0.3, 0., -0.3, -3.1416, -0.3, 0. , -0.3, -3.1416, -0.3, -0.1,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416,-0.3, -3.1416};
2766  double thisMaxi[] = { 0.1, 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 0. , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 2.6 , 0.3, 3.1416, 0.3, 0.1, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416, 0.3, 3.1416};
2767  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, thisStep, thisMini, thisMaxi, thisParName );
2768  }
2769  }
2770  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
2771  const T & parScale, const std::vector<int> & parScaleOrder,
2772  const std::vector<double> & parStep,
2773  const std::vector<double> & parMin,
2774  const std::vector<double> & parMax,
2775  const int muonType)
2776  {
2777  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
2778  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
2779  std::cout << "parNum = " << this->parNum_ << std::endl;
2780  std::cout << "parStep.size() = " << parStep.size() << std::endl;
2781  std::cout << "parMin.size() = " << parMin.size() << std::endl;
2782  std::cout << "parMax.size() = " << parMax.size() << std::endl;
2783  exit(1);
2784  }
2785  std::vector<ParameterSet> parSet(this->parNum_);
2786  // name, step, mini, maxi
2787  parSet[0] = ParameterSet( "Curv global scale", parStep[0], parMin[0], parMax[0] );
2788  parSet[1] = ParameterSet( "Phi ampl vbwd", parStep[1], parMin[1], parMax[1] );
2789  parSet[2] = ParameterSet( "Phi phase vbwd", parStep[2], parMin[2], parMax[2] );
2790  parSet[3] = ParameterSet( "Twist vbwd", parStep[3], parMin[3], parMax[3] );
2791  parSet[4] = ParameterSet( "vbwd/bwd bndry", parStep[4], parMin[4], parMax[4] );
2792  parSet[5] = ParameterSet( "Phi ampl bwd", parStep[5], parMin[5], parMax[5] );
2793  parSet[6] = ParameterSet( "Phi phase bwd", parStep[6], parMin[6], parMax[6] );
2794  parSet[7] = ParameterSet( "Twist bwd", parStep[7], parMin[7], parMax[7] );
2795  parSet[8] = ParameterSet( "bwd/bar bndry", parStep[8], parMin[8], parMax[8] );
2796  parSet[9] = ParameterSet( "Phi ampl bar", parStep[9], parMin[9], parMax[9] );
2797  parSet[10] = ParameterSet( "Phi phase bar", parStep[10],parMin[10],parMax[10] );
2798  parSet[11] = ParameterSet( "Twist bar", parStep[11],parMin[11],parMax[11] );
2799  parSet[12] = ParameterSet( "bar/fwd bndry", parStep[12],parMin[12],parMax[12] );
2800  parSet[13] = ParameterSet( "Phi ampl fwd", parStep[13],parMin[13],parMax[13] );
2801  parSet[14] = ParameterSet( "Phi phase fwd", parStep[14],parMin[14],parMax[14] );
2802  parSet[15] = ParameterSet( "Twist fwd", parStep[15],parMin[15],parMax[15] );
2803  parSet[16] = ParameterSet( "fwd/vfwd bndry", parStep[16],parMin[16],parMax[16] );
2804  parSet[17] = ParameterSet( "Phi ampl vfwd", parStep[17],parMin[17],parMax[17] );
2805  parSet[18] = ParameterSet( "Phi phase vfwd", parStep[18],parMin[18],parMax[18] );
2806  parSet[19] = ParameterSet( "Twist vfwd", parStep[19],parMin[19],parMax[19] );
2807  parSet[20] = ParameterSet( "Charge depend bias", parStep[20],parMin[20],parMax[20] );
2808  parSet[21] = ParameterSet( "Phi ampl2 vbwd", parStep[21],parMin[21],parMax[21] );
2809  parSet[22] = ParameterSet( "Phi phase2 vbwd", parStep[22],parMin[22],parMax[22] );
2810  parSet[23] = ParameterSet( "Phi ampl2 bwd", parStep[23],parMin[23],parMax[23] );
2811  parSet[24] = ParameterSet( "Phi phase2 bwd", parStep[24],parMin[24],parMax[24] );
2812  parSet[25] = ParameterSet( "Phi ampl2 bar", parStep[25],parMin[25],parMax[25] );
2813  parSet[26] = ParameterSet( "Phi phase2 bar", parStep[26],parMin[26],parMax[26] );
2814  parSet[27] = ParameterSet( "Phi ampl2 fwd", parStep[27],parMin[27],parMax[27] );
2815  parSet[28] = ParameterSet( "Phi phase2 fwd", parStep[28],parMin[28],parMax[28] );
2816  parSet[29] = ParameterSet( "Phi ampl2 vfwd", parStep[29],parMin[29],parMax[29] );
2817  parSet[30] = ParameterSet( "Phi phase2 vfwd", parStep[30],parMin[30],parMax[30] );
2818 
2819 
2820 
2821  std::cout << "setting parameters" << std::endl;
2822  for( int i=0; i<this->parNum_; ++i ) {
2823  std::cout << "parStep["<<i<<"] = " << parStep[i]
2824  << ", parMin["<<i<<"] = " << parMin[i]
2825  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
2826  }
2827  this->setPar( Start, Step, Mini, Maxi, ind, parname, parScale, parScaleOrder, parSet );
2828  }
2829 
2830 };
2831 
2832 
2833 
2834 
2836 scaleFunctionBase<double * > * scaleFunctionService( const int identifier );
2837 
2839 scaleFunctionBase<std::vector<double> > * scaleFunctionVecService( const int identifier );
2840 
2841 // -------------- //
2842 // Smear functors //
2843 // -------------- //
2844 
2845 class smearFunctionBase {
2846  public:
2847  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) = 0;
2848  smearFunctionBase() {
2849  cotgth_ = 0.;
2850  gRandom_ = new TRandom();
2851  }
2852  virtual ~smearFunctionBase() = 0;
2853 protected:
2854  void smearEta(double & eta) {
2855  double theta;
2856  if (cotgth_!=0) {
2857  theta = atan(1/cotgth_);
2858  } else {
2859  theta = TMath::Pi()/2;
2860  }
2861  if (theta<0) theta += TMath::Pi();
2862  eta = -log(tan(theta/2));
2863  }
2864  double cotgth_;
2865  TRandom * gRandom_;
2866 };
2867 inline smearFunctionBase::~smearFunctionBase() { } // defined even though it's pure virtual; should be faster this way.
2868 
2869 // No smearing
2870 // -----------
2871 class smearFunctionType0 : public smearFunctionBase {
2872  public:
2873  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) { }
2874 };
2875 // The 3 parameters of smearType1 are: pt dependence of pt smear, phi smear and
2876 // cotgtheta smear.
2877 class smearFunctionType1 : public smearFunctionBase {
2878  public:
2879  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2880  pt = pt*(1.0+y[0]*parSmear[0]*pt);
2881  phi = phi*(1.0+y[1]*parSmear[1]);
2882  double tmp = 2*atan(exp(-eta));
2883  cotgth_ = cos(tmp)/sin(tmp)*(1.0+y[2]*parSmear[2]);
2884  smearEta(eta);
2885  }
2886 };
2887 
2888 class smearFunctionType2 : public smearFunctionBase {
2889  public:
2890  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2891  pt = pt*(1.0+y[0]*parSmear[0]*pt+y[1]*parSmear[1]*std::fabs(eta));
2892  phi = phi*(1.0+y[2]*parSmear[2]);
2893  double tmp = 2*atan(exp(-eta));
2894  cotgth_ = cos(tmp)/sin(tmp)*(1.0+y[3]*parSmear[3]);
2895  smearEta(eta);
2896  }
2897 };
2898 
2899 class smearFunctionType3 : public smearFunctionBase {
2900  public:
2901  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2902  pt = pt*(1.0+y[0]*parSmear[0]*pt+y[1]*parSmear[1]*std::fabs(eta));
2903  phi = phi*(1.0+y[2]*parSmear[2]);
2904  double tmp = 2*atan(exp(-eta));
2905  cotgth_ = cos(tmp)/sin(tmp)*(1.0+y[3]*parSmear[3]+y[4]*parSmear[4]*std::fabs(eta));
2906  smearEta(eta);
2907  }
2908 };
2909 // The six parameters of SmearType=4 are respectively:
2910 // Pt dep. of Pt res., |eta| dep. of Pt res., Phi res., |eta| res.,
2911 // |eta| dep. of |eta| res., Pt^2 dep. of Pt res.
2912 class smearFunctionType4 : public smearFunctionBase {
2913  public:
2914  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2915  pt = pt*(1.0+y[0]*parSmear[0]*pt+y[1]*parSmear[1]*std::fabs(eta)+y[5]*parSmear[5]*pow(pt,2));
2916  phi = phi*(1.0+y[2]*parSmear[2]);
2917  double tmp = 2*atan(exp(-eta));
2918  cotgth_ = cos(tmp)/sin(tmp)*(1.0+y[3]*parSmear[3]+y[4]*parSmear[4]*std::fabs(eta));
2919  smearEta(eta);
2920  }
2921 };
2922 
2923 class smearFunctionType5 : public smearFunctionBase {
2924  public:
2925  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2926  pt = pt*(1.0+y[0]*parSmear[0]*pt+y[1]*parSmear[1]*std::fabs(eta)+y[5]*parSmear[5]*pow(pt,2));
2927  phi = phi*(1.0+y[2]*parSmear[2]+y[6]*parSmear[6]*pt);
2928  double tmp = 2*atan(exp(-eta));
2929  cotgth_ = cos(tmp)/sin(tmp)*(1.0+y[3]*parSmear[3]+y[4]*parSmear[4]*std::fabs(eta));
2930  smearEta(eta);
2931  }
2932 };
2933 
2934 //Smearing for MC correction based on the resolution function Type 15 for misaligned MC
2935 class smearFunctionType6 : public smearFunctionBase {
2936  public:
2937  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear) {
2938  double sigmaSmear = 0;
2939  double sigmaPtAl = 0;
2940  double sigmaPtMisal = 0;
2941  double ptPart = parSmear[0] + parSmear[1]*1/pt + pt*parSmear[2];
2942  double fabsEta = std::fabs(eta);
2943 
2944  sigmaPtAl = parSmear[14]*etaByPoints(eta, parSmear[15]);
2945 
2946  if (std::fabs(eta)<=1.4){
2947  sigmaPtMisal = ptPart + parSmear[3] + parSmear[4]*std::fabs(eta) + parSmear[5]*eta*eta;
2948  sigmaSmear = sqrt(std::fabs(pow(sigmaPtMisal,2)-pow(sigmaPtAl,2)));
2949  pt = pt*gRandom_->Gaus(1,sigmaSmear);
2950  }
2951  else if (eta>1.4){//eta in right endcap
2952  double par = parSmear[3] + parSmear[4]*1.4 + parSmear[5]*1.4*1.4 - (parSmear[6] + parSmear[7]*(1.4-parSmear[8]) + parSmear[9]*(1.4-parSmear[8])*(1.4-parSmear[8]));
2953  sigmaPtMisal = par + ptPart + parSmear[6] + parSmear[7]*std::fabs((fabsEta-parSmear[8])) + parSmear[9]*(fabsEta-parSmear[8])*(fabsEta-parSmear[8]);
2954  sigmaSmear = sqrt(std::fabs(pow(sigmaPtMisal,2)-pow(sigmaPtAl,2)));
2955  pt = pt*gRandom_->Gaus(1,sigmaSmear);
2956  }
2957  else{//eta in left endcap
2958  double par = parSmear[3] + parSmear[4]*1.4 + parSmear[5]*1.4*1.4 - (parSmear[10] + parSmear[11]*(1.4-parSmear[12]) + parSmear[13]*(1.4-parSmear[12])*(1.4-parSmear[12]));
2959  sigmaPtMisal = par + ptPart + parSmear[10] + parSmear[11]*std::fabs((fabsEta-parSmear[12])) + parSmear[13]*(fabsEta-parSmear[12])*(fabsEta-parSmear[12]);
2960  sigmaSmear = sqrt(std::fabs(pow(sigmaPtMisal,2)-pow(sigmaPtAl,2)));
2961  pt = pt*gRandom_->Gaus(1,sigmaSmear);
2962  }
2963  }
2964  protected:
2969  double etaByPoints(const double & inEta, const double & border) {
2970  Double_t eta = std::fabs(inEta);
2971  if( 0. <= eta && eta <= 0.2 ) return 0.00942984;
2972  else if( 0.2 < eta && eta <= 0.4 ) return 0.0104489;
2973  else if( 0.4 < eta && eta <= 0.6 ) return 0.0110521;
2974  else if( 0.6 < eta && eta <= 0.8 ) return 0.0117338;
2975  else if( 0.8 < eta && eta <= 1.0 ) return 0.0138142;
2976  else if( 1.0 < eta && eta <= 1.2 ) return 0.0165826;
2977  else if( 1.2 < eta && eta <= 1.4 ) return 0.0183663;
2978  else if( 1.4 < eta && eta <= 1.6 ) return 0.0169904;
2979  else if( 1.6 < eta && eta <= 1.8 ) return 0.0173289;
2980  else if( 1.8 < eta && eta <= 2.0 ) return 0.0205821;
2981  else if( 2.0 < eta && eta <= 2.2 ) return 0.0250032;
2982  else if( 2.2 < eta && eta <= 2.4 ) return 0.0339477;
2983  // ATTENTION: This point has a big error and it is very displaced from the rest of the distribution.
2984  else if( 2.4 < eta && eta <= 2.6 ) return border;
2985  return ( 0. );
2986  }
2987 };
2988 
2989 class smearFunctionType7 : public smearFunctionBase
2990 {
2991  public:
2992  virtual void smear(double & pt, double & eta, double & phi, const double * y, const std::vector<double> & parSmear)
2993  {
2994  double sigmaSquared = sigmaPtDiff.squaredDiff(eta);
2995  TF1 G("G", "[0]*exp(-0.5*pow(x,2)/[1])", -5., 5.);
2996  double norm = 1/(sqrt(2*TMath::Pi()*sigmaSquared));
2997  G.SetParameter (0,norm);
2998  G.SetParameter (1,sigmaSquared);
2999  pt = pt*(1-G.GetRandom());
3000  }
3001  SigmaPtDiff sigmaPtDiff;
3002 };
3003 
3005 smearFunctionBase * smearFunctionService( const int identifier );
3006 
3007 // // Defined globally...
3008 // static smearFunctionBase * smearFunctionArray[] = {
3009 // new smearFunctionType0,
3010 // new smearFunctionType1,
3011 // new smearFunctionType2,
3012 // new smearFunctionType3,
3013 // new smearFunctionType4,
3014 // new smearFunctionType5
3015 // };
3016 
3021 template <class T>
3022 class resolutionFunctionBase {
3023  public:
3024  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) = 0;
3025  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
3026  {
3027  return 0.;
3028  }
3029  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) = 0;
3030  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) = 0;
3031  virtual double covPt1Pt2(const double & pt1, const double & eta1, const double & pt2, const double & eta2, const T & parval)
3032  {
3033  return 0.;
3034  }
3035  resolutionFunctionBase() {}
3036  virtual ~resolutionFunctionBase() = 0;
3038  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
3039  const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {};
3040  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
3041  const T & parResol, const std::vector<int> & parResolOrder,
3042  const std::vector<double> & parStep,
3043  const std::vector<double> & parMin,
3044  const std::vector<double> & parMax,
3045  const int muonType)
3046  {
3047  std::cout << "The method setParameters must be implemented for this resolution function" << std::endl;
3048  exit(1);
3049  }
3050  virtual int parNum() const { return parNum_; }
3051  protected:
3052  int parNum_;
3054  virtual void setPar(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
3055  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
3056  double* thisStep, double* thisMini, double* thisMaxi, TString* thisParName ) {
3057  for( int iPar=0; iPar<this->parNum_; ++iPar ) {
3058  Start[iPar] = parResol[iPar];
3059  Step[iPar] = thisStep[iPar];
3060  Mini[iPar] = thisMini[iPar];
3061  Maxi[iPar] = thisMaxi[iPar];
3062  ind[iPar] = parResolOrder[iPar];
3063  parname[iPar] = thisParName[iPar];
3064  }
3065  }
3066  virtual void setPar(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
3067  TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const std::vector<ParameterSet> & parSet ) {
3068  if( int(parSet.size()) != this->parNum_ ) {
3069  std::cout << "Error: wrong number of parameter initializations = " << parSet.size() << ". Number of parameters is " << this->parNum_ << std::endl;
3070  exit(1);
3071  }
3072  for( int iPar=0; iPar<this->parNum_; ++iPar ) {
3073  Start[iPar] = parResol[iPar];
3074  Step[iPar] = parSet[iPar].step;
3075  Mini[iPar] = parSet[iPar].mini;
3076  Maxi[iPar] = parSet[iPar].maxi;
3077  ind[iPar] = parResolOrder[iPar];
3078  parname[iPar] = parSet[iPar].name;
3079  }
3080  }
3081 };
3082 template <class T> inline resolutionFunctionBase<T>::~resolutionFunctionBase() { } // defined even though it's pure virtual; should be faster this way.
3083 
3084 // Resolution Type 1
3085 template <class T>
3086 class resolutionFunctionType1 : public resolutionFunctionBase<T> {
3087  public:
3088  resolutionFunctionType1() { this->parNum_ = 3; }
3089  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3090  return parval[0];
3091  }
3092  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3093  return parval[1];
3094  }
3095  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3096  return parval[2];
3097  }
3098  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3099  double thisStep[] = {0.001, 0.001, 0.001};
3100  TString thisParName[] = {"Pt res. sc.", "Phi res. sc.", "CotgThs res. sc."};
3101  double thisMini[] = {0., 0., 0.};
3102  if( muonType == 1 ) {
3103  double thisMaxi[] = {0.4, 0.4, 0.4};
3104  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3105  } else {
3106  double thisMaxi[] = {0.01, 0.02, 0.02};
3107  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3108  }
3109  }
3110  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
3111  const T & parResol, const std::vector<int> & parResolOrder,
3112  const std::vector<double> & parStep,
3113  const std::vector<double> & parMin,
3114  const std::vector<double> & parMax,
3115  const int muonType) {}
3116 };
3117 
3118 // Resolution Type 6
3119 template <class T>
3120 class resolutionFunctionType6 : public resolutionFunctionBase<T> {
3121  public:
3122  resolutionFunctionType6() { this->parNum_ = 15; }
3123  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3124  return( parval[0]+parval[1]*pt+parval[2]*pow(pt,2)+parval[3]*pow(pt,3)+parval[4]*pow(pt,4)+parval[5]*std::fabs(eta)+parval[6]*pow(eta,2) );
3125  }
3126  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3127  return( parval[7]+parval[8]/pt+parval[9]*std::fabs(eta)+parval[10]*pow(eta,2) );
3128  }
3129  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3130  return( parval[11]+parval[12]/pt+parval[13]*std::fabs(eta)+parval[14]*pow(eta,2) );
3131  }
3132  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3133  double thisStep[] = { 0.005, 0.0005 ,0.000005 ,0.00000005 ,0.0000000005 ,0.0005 ,0.000005,
3134  0.000005 ,0.0005 ,0.00000005 ,0.0000005,
3135  0.00005 ,0.0005 ,0.00000005 ,0.000005};
3136  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Pt^2 sc.", "Pt res. Pt^3 sc.", "Pt res. Pt^4 sc.", "Pt res. Eta sc.", "Pt res. Eta^2 sc.",
3137  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
3138  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
3139  double thisMini[] = { 0.0, -0.01, -0.001, -0.01, -0.001, -0.001, -0.001,
3140  0.0, 0.0, -0.001, -0.001,
3141  0.0, 0.0, -0.001, -0.001 };
3142  if( muonType == 1 ) {
3143  double thisMaxi[] = { 1., 1., 1., 1., 1., 1., 1.,
3144  0.1, 1., 1., 1.,
3145  1., 1., 1., 1. };
3146  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3147  } else {
3148  double thisMaxi[] = { 0.1, 0.01, 0.01, 0.01, 0.01, 0.01, 0.1,
3149  0.01, 0.01, 0.01, 0.01,
3150  0.01, 0.01, 0.01, 0.01 };
3151  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3152  }
3153  }
3154 };
3155 
3156 // Resolution Type 7
3157 template <class T>
3158 class resolutionFunctionType7 : public resolutionFunctionBase<T> {
3159  public:
3160  resolutionFunctionType7() { this->parNum_ = 12; }
3161  // linear in pt and quadratic in eta
3162  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3163  return( parval[0]+parval[1]*pt + parval[2]*std::fabs(eta)+parval[3]*pow(eta,2) );
3164  }
3165  // 1/pt in pt and quadratic in eta
3166  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3167  return( parval[4]+parval[5]/pt + parval[6]*std::fabs(eta)+parval[7]*pow(eta,2) );
3168  }
3169  // 1/pt in pt and quadratic in eta
3170  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3171  return( parval[8]+parval[9]/pt + parval[10]*std::fabs(eta)+parval[11]*pow(eta,2) );
3172  }
3173  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3174  double thisStep[] = { 0.002, 0.00002, 0.000002, 0.0002,
3175  0.00002, 0.0002, 0.0000002, 0.000002,
3176  0.00002, 0.0002, 0.00000002, 0.000002 };
3177  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Eta sc.", "Pt res. Eta^2 sc.",
3178  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
3179  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
3180  double thisMini[] = { 0.0, -0.01, -0.001, -0.0001,
3181  0.0, -0.001, -0.001, -0.00001,
3182  0.0, -0.001, -0.0001, -0.0001 };
3183  if( muonType == 1 ) {
3184  double thisMaxi[] = { 1., 1., 1., 1.,
3185  1., 1., 1., 0.1,
3186  1., 1., 1., 1. };
3187  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3188  } else {
3189  double thisMaxi[] = { 0.1, 0.01, 0.01, 0.1,
3190  0.01, 0.01, 0.1, 0.01,
3191  0.01, 0.01, 0.01, 0.01 };
3192  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3193  }
3194  }
3195 };
3196 
3197 // Resolution Type 8
3198 template <class T>
3199 class resolutionFunctionType8 : public resolutionFunctionBase<T> {
3200  public:
3201  resolutionFunctionType8() { this->parNum_ = 12; }
3202  // linear in pt and by points in eta
3203  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3204  return( parval[0]+parval[1]*pt + parval[2]*etaByPoints(eta, parval[3]) );
3205  }
3206  // 1/pt in pt and quadratic in eta
3207  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3208  return( parval[4]+parval[5]/pt + parval[6]*std::fabs(eta)+parval[7]*eta*eta );
3209  }
3210  // 1/pt in pt and quadratic in eta
3211  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3212  return( parval[8]+parval[9]/pt + parval[10]*std::fabs(eta)+parval[11]*eta*eta );
3213  }
3214  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3215 
3216  double thisStep[] = { 0.0000002, 0.0000001, 0.00001, 0.02,
3217  0.00002, 0.0002, 0.0000002, 0.00002,
3218  0.00002, 0.0002, 0.00000002, 0.000002 };
3219  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Eta sc.", "Pt res. eta border",
3220  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
3221  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
3222  double thisMini[] = { -0.03, -0.0000001, 0.1, 0.01,
3223  -0.001, 0.002, -0.0001, -0.0001,
3224  -0.0001, 0.0005, -0.0001, -0.00001 };
3225  if( muonType == 1 ) {
3226  double thisMaxi[] = { 1., 1., 1., 1.,
3227  1., 1., 1., 0.1,
3228  1., 1., 1., 1. };
3229  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3230  } else {
3231  double thisMaxi[] = { 0.03, 0.1, 1.4, 0.6,
3232  0.001, 0.005, 0.00004, 0.0007,
3233  0.001, 0.01, -0.0000015, 0.0004 };
3234  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3235  }
3236  }
3237 protected:
3242  double etaByPoints(const double & inEta, const double & border) {
3243  Double_t eta = std::fabs(inEta);
3244  if( 0. <= eta && eta <= 0.2 ) return 0.00942984;
3245  else if( 0.2 < eta && eta <= 0.4 ) return 0.0104489;
3246  else if( 0.4 < eta && eta <= 0.6 ) return 0.0110521;
3247  else if( 0.6 < eta && eta <= 0.8 ) return 0.0117338;
3248  else if( 0.8 < eta && eta <= 1.0 ) return 0.0138142;
3249  else if( 1.0 < eta && eta <= 1.2 ) return 0.0165826;
3250  else if( 1.2 < eta && eta <= 1.4 ) return 0.0183663;
3251  else if( 1.4 < eta && eta <= 1.6 ) return 0.0169904;
3252  else if( 1.6 < eta && eta <= 1.8 ) return 0.0173289;
3253  else if( 1.8 < eta && eta <= 2.0 ) return 0.0205821;
3254  else if( 2.0 < eta && eta <= 2.2 ) return 0.0250032;
3255  else if( 2.2 < eta && eta <= 2.4 ) return 0.0339477;
3256  else if( 2.4 < eta && eta <= 2.6 ) return border;
3257  return ( 0. );
3258  }
3259 };
3260 
3261 // Resolution Type 9
3262 template <class T>
3263 class resolutionFunctionType9 : public resolutionFunctionBase<T> {
3264  public:
3265  resolutionFunctionType9() { this->parNum_ = 31; }
3266  // linear in pt and by points in eta
3267  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3268  double ptPart = 0.;
3269 
3270  if( pt < 3 ) ptPart = parval[15];
3271  else if( pt < 4 ) ptPart = parval[16];
3272  else if( pt < 5 ) ptPart = parval[17];
3273  else if( pt < 6 ) ptPart = parval[18];
3274  else if( pt < 7 ) ptPart = parval[19];
3275  else if( pt < 8 ) ptPart = parval[20];
3276  else if( pt < 9 ) ptPart = parval[21];
3277  else if( pt < 10 ) ptPart = parval[22];
3278 
3279  else ptPart = parval[0] + parval[1]*pt + parval[2]*pt*pt + parval[3]*pt*pt*pt + parval[4]*pt*pt*pt*pt;
3280 
3281  double fabsEta = std::fabs(eta);
3282  double etaCoeff = parval[5];
3283  if( fabsEta < 0.1 ) etaCoeff = parval[23];
3284  else if( fabsEta < 0.2 ) etaCoeff = parval[24];
3285  else if( fabsEta < 0.3 ) etaCoeff = parval[25];
3286  else if( fabsEta < 0.4 ) etaCoeff = parval[26];
3287  else if( fabsEta < 0.5 ) etaCoeff = parval[27];
3288  else if( fabsEta < 0.6 ) etaCoeff = parval[28];
3289  else if( fabsEta < 0.7 ) etaCoeff = parval[29];
3290  else if( fabsEta < 0.8 ) etaCoeff = parval[30];
3291 
3292  return( ptPart + etaCoeff*etaByPoints(eta, parval[6]) );
3293  }
3294  // 1/pt in pt and quadratic in eta
3295  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3296  return( parval[7]+parval[8]/pt + parval[9]*std::fabs(eta)+parval[10]*eta*eta );
3297  }
3298  // 1/pt in pt and quadratic in eta
3299  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3300  return( parval[11]+parval[12]/pt + parval[13]*std::fabs(eta)+parval[14]*eta*eta );
3301  }
3302  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3303 
3304  double thisStep[] = { 0.0002, 0.000002, 0.0000002, 0.00000002, 0.000000002, 0.02, 0.02,
3305  0.00002, 0.0002, 0.0000002, 0.00002,
3306  0.00002, 0.0002, 0.00000002, 0.000002,
3307  0.001, 0.001, 0.001, 0.001,
3308  0.001, 0.001, 0.001, 0.001,
3309  0.001, 0.001, 0.001, 0.001,
3310  0.001, 0.001, 0.001, 0.001 };
3311  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Pt^2 sc.", "Pt res. Pt^3 sc.", "Pt res. Pt^4 sc",
3312  "Pt res. Eta sc.", "Pt res. eta border",
3313  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
3314  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc.",
3315  "Pt by points sc. 0-3", "Pt by points sc. 3-4", "Pt by points sc. 4-5", "Pt by points sc. 5-6",
3316  "Pt by points sc. 6-7", "Pt by points sc. 7-8", "Pt by points sc. 8-9", "Pt by points sc. 9-10",
3317  "Eta scale for eta < 0.1", "Eta scale for eta < 0.2", "Eta scale for eta < 0.3", "Eta scale for eta < 0.4",
3318  "Eta scale for eta < 0.5", "Eta scale for eta < 0.6", "Eta scale for eta < 0.7", "Eta scale for eta < 0.8" };
3319  double thisMini[] = { -0.1, -0.001, -0.001, -0.001, -0.001, 0.001, 0.0001,
3320  -0.001, 0.002, -0.0001, -0.0001,
3321  -0.0001, 0.0005, -0.0001, -0.00001,
3322  -1., -1., -1., -1.,
3323  -1., -1., -1., -1.,
3324  -1., -1., -1., -1.,
3325  -1., -1., -1., -1. };
3326  if( muonType == 1 ) {
3327  double thisMaxi[] = { 1., 1., 1., 1., 1., 1., 1.,
3328  1., 1., 1., 0.1,
3329  1., 1., 1., 1.,
3330  1., 1., 1., 1.,
3331  1., 1., 1., 1.,
3332  1., 1., 1., 1.,
3333  3., 3., 3., 3. };
3334  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3335  } else {
3336  double thisMaxi[] = { 0.1, 0.001, 0.001, 0.001, 0.001, 1.5, 1.,
3337  0.001, 0.005, 0.00004, 0.0007,
3338  0.001, 0.01, -0.0000015, 0.0004,
3339  3., 3., 3., 3.,
3340  3., 3., 3., 3.,
3341  3., 3., 3., 3.,
3342  3., 3., 3., 3. };
3343  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3344  }
3345  }
3346 protected:
3351  double etaByPoints(const double & inEta, const double & border) {
3352  Double_t eta = std::fabs(inEta);
3353  // More detailed taken from Upsilon2S
3354 // if( 0.0 < eta && eta <= 0.1 ) return( (0.006496598 + 0.006713836)/2 );
3355 // else if( 0.1 < eta && eta <= 0.2 ) return( (0.006724315 + 0.006787474)/2 );
3356 // else if( 0.2 < eta && eta <= 0.3 ) return( (0.007284029 + 0.007293643)/2 );
3357 // else if( 0.3 < eta && eta <= 0.4 ) return( (0.008138282 + 0.008187387)/2 );
3358 // else if( 0.4 < eta && eta <= 0.5 ) return( (0.008174111 + 0.008030496)/2 );
3359 // else if( 0.5 < eta && eta <= 0.6 ) return( (0.008126558 + 0.008100443)/2 );
3360 // else if( 0.6 < eta && eta <= 0.7 ) return( (0.008602069 + 0.008626195)/2 );
3361 // else if( 0.7 < eta && eta <= 0.8 ) return( (0.009187699 + 0.009090244)/2 );
3362 // else if( 0.8 < eta && eta <= 0.9 ) return( (0.009835283 + 0.009875661)/2 );
3363 // else if( 0.9 < eta && eta <= 1.0 ) return( (0.01156847 + 0.011774)/2);
3364 // else if( 1.0 < eta && eta <= 1.1 ) return( (0.01319311 + 0.01312528)/2 );
3365 // else if( 1.1 < eta && eta <= 1.2 ) return( (0.01392963 + 0.01413793)/2 );
3366 // else if( 1.2 < eta && eta <= 1.3 ) return( (0.01430238 + 0.01385749)/2 );
3367 // else if( 1.3 < eta && eta <= 1.4 ) return( (0.01409375 + 0.01450355)/2 );
3368 // else if( 1.4 < eta && eta <= 1.5 ) return( (0.01395235 + 0.01419122)/2 );
3369 // else if( 1.5 < eta && eta <= 1.6 ) return( (0.01384032 + 0.01354162)/2 );
3370 // else if( 1.6 < eta && eta <= 1.7 ) return( (0.01325593 + 0.01302663)/2 );
3371 // else if( 1.7 < eta && eta <= 1.8 ) return( (0.01365382 + 0.01361993)/2 );
3372 // else if( 1.8 < eta && eta <= 1.9 ) return( (0.01516075 + 0.01514115)/2 );
3373 // else if( 1.9 < eta && eta <= 2.0 ) return( (0.01587837 + 0.01561742)/2 );
3374 // else if( 2.0 < eta && eta <= 2.1 ) return( (0.01696865 + 0.01760318)/2 );
3375 // else if( 2.1 < eta && eta <= 2.2 ) return( (0.01835451 + 0.01887852)/2 );
3376 // else if( 2.2 < eta && eta <= 2.3 ) return( (0.02116863 + 0.02254953)/2 );
3377 // else if( 2.3 < eta && eta <= 2.4 ) return( (0.0224906 + 0.02158211)/2 );
3378 
3379  // Less detailed
3380 // if( 0.0 < eta && eta <= 0.2 ) return( (0.006496598 + 0.006713836 + 0.006724315 + 0.006787474)/4 );
3381 // else if( 0.2 < eta && eta <= 0.4 ) return( (0.007284029 + 0.007293643 + 0.008138282 + 0.008187387)/4 );
3382 // else if( 0.4 < eta && eta <= 0.6 ) return( (0.008174111 + 0.008030496 + 0.008126558 + 0.008100443)/4 );
3383 // else if( 0.6 < eta && eta <= 0.8 ) return( (0.008602069 + 0.008626195 + 0.009187699 + 0.009090244)/4 );
3384 // else if( 0.8 < eta && eta <= 1.0 ) return( (0.009835283 + 0.009875661 + 0.01156847 + 0.011774)/4 );
3385 // else if( 1.0 < eta && eta <= 1.2 ) return( (0.01319311 + 0.01312528 + 0.01392963 + 0.01413793)/4 );
3386 // else if( 1.2 < eta && eta <= 1.4 ) return( (0.01430238 + 0.01385749 + 0.01409375 + 0.01450355)/4 );
3387 // else if( 1.4 < eta && eta <= 1.6 ) return( (0.01395235 + 0.01419122 + 0.01384032 + 0.01354162)/4 );
3388 // else if( 1.6 < eta && eta <= 1.8 ) return( (0.01325593 + 0.01302663 + 0.01365382 + 0.01361993)/4 );
3389 // else if( 1.8 < eta && eta <= 2.0 ) return( (0.01516075 + 0.01514115 + 0.01587837 + 0.01561742)/4 );
3390 // else if( 2.0 < eta && eta <= 2.2 ) return( (0.01696865 + 0.01760318 + 0.01835451 + 0.01887852)/4 );
3391 // // else if( 2.2 < eta && eta <= 2.4 ) return( (0.02116863 + 0.02254953 + 0.0224906 + 0.02158211)/4 );
3392 
3393 // return ( border );
3394 
3395  // From MuonGun
3396  if( 0. <= eta && eta <= 0.2 ) return 0.00942984;
3397  else if( 0.2 < eta && eta <= 0.4 ) return 0.0104489;
3398  else if( 0.4 < eta && eta <= 0.6 ) return 0.0110521;
3399  else if( 0.6 < eta && eta <= 0.8 ) return 0.0117338;
3400  else if( 0.8 < eta && eta <= 1.0 ) return 0.0138142;
3401  else if( 1.0 < eta && eta <= 1.2 ) return 0.0165826;
3402  else if( 1.2 < eta && eta <= 1.4 ) return 0.0183663;
3403  else if( 1.4 < eta && eta <= 1.6 ) return 0.0169904;
3404  else if( 1.6 < eta && eta <= 1.8 ) return 0.0173289;
3405  else if( 1.8 < eta && eta <= 2.0 ) return 0.0205821;
3406  else if( 2.0 < eta && eta <= 2.2 ) return 0.0250032;
3407  else if( 2.2 < eta && eta <= 2.4 ) return 0.0339477;
3408  else if( 2.4 < eta && eta <= 2.6 ) return border;
3409  return ( 0. );
3410 
3411  }
3412 };
3413 
3415 // Resolution Type 10
3416 template <class T>
3417 class resolutionFunctionType10 : public resolutionFunctionBase<T> {
3418  public:
3419  resolutionFunctionType10() { this->parNum_ = 21; }
3420  // linear in pt and by points in eta
3421  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3422  double fabsEta = std::fabs(eta);
3423  return( parval[0] + parval[1]*pt + parval[2]*pt*pt + parval[3]*pt*pt*pt + parval[4]*pt*pt*pt*pt
3424  + parval[5]*fabsEta + parval[6]*fabsEta*fabsEta + parval[7]*pow(fabsEta,3) + parval[8]*pow(fabsEta,4)
3425  + parval[9]*pow(fabsEta,5) + parval[10]*pow(fabsEta,6) + parval[11]*pow(fabsEta,7) + parval[12]*pow(fabsEta,8) );
3426  }
3427  // 1/pt in pt and quadratic in eta
3428  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3429  return( parval[13]+parval[14]/pt + parval[15]*std::fabs(eta)+parval[16]*eta*eta );
3430  }
3431  // 1/pt in pt and quadratic in eta
3432  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3433  return( parval[17]+parval[18]/pt + parval[19]*std::fabs(eta)+parval[20]*eta*eta );
3434  }
3435  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3436 
3437  double thisStep[] = { 0.0002, 0.000002, 0.0000002, 0.00000002, 0.000000002,
3438  0.02, 0.02, 0.002, 0.0002,
3439  0.00002, 0.000002, 0.0000002, 0.00000002,
3440  0.00002, 0.0002, 0.0000002, 0.00002,
3441  0.00002, 0.0002, 0.00000002, 0.000002 };
3442  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Pt^2 sc.", "Pt res. Pt^3 sc.", "Pt res. Pt^4 sc",
3443  "Pt res. Eta sc.", "Pt res. Eta^2 sc." ,"Pt res. Eta^3 sc.", "Pt res. Eta^4 sc.",
3444  "Pt res. Eta^5 sc.", "Pt res. Eta^6 sc.", "Pt res. Eta^7 sc.", "Pt res. Eta^8 sc.",
3445  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
3446  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
3447  double thisMini[] = { -0.1, -0.001, -0.001, -0.001, -0.001,
3448  -2., -1., -0.1, -0.1,
3449  -0.1, -0.1, -0.1, -0.1,
3450  -0.001, 0.002, -0.0001, -0.0001,
3451  -0.0001, 0.0005, -0.0001, -0.00001,
3452  0.};
3453  if( muonType == 1 ) {
3454  double thisMaxi[] = { 1., 1., 1., 1., 1.,
3455  1., 1., 1., 1.,
3456  1., 1., 1., 1.,
3457  1., 1., 1., 0.1,
3458  1., 1., 1., 1. };
3459  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3460  } else {
3461  double thisMaxi[] = { 0.1, 0.001, 0.001, 0.001, 0.001,
3462  2., 1., 0.1, 0.1, 0.1,
3463  0.1, 0.1, 0.1, 0.1, 0.1,
3464  0.001, 0.005, 0.00004, 0.0007,
3465  0.001, 0.01, -0.0000015, 0.0004 };
3466  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3467  }
3468  }
3469 };
3470 
3472 // Resolution Type 11
3473 template <class T>
3474 class resolutionFunctionType11 : public resolutionFunctionBase<T> {
3475  public:
3476  resolutionFunctionType11() { this->parNum_ = 8; }
3477  // linear in pt and by points in eta
3478  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3479  double fabsEta = std::fabs(eta);
3480  if(fabsEta<1.2)
3481  return (parval[0]+ parval[2]*1./pt + pt/(pt+parval[3]) + parval[4]*fabsEta + parval[5]*eta*eta);
3482  else
3483  return (parval[1]+ parval[2]*1./pt + pt/(pt+parval[3]) + parval[6]*std::fabs((fabsEta-1.6)) + parval[7]*(fabsEta-1.6)*(fabsEta-1.6));
3484  }
3485  // 1/pt in pt and quadratic in eta
3486  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3487  return( 0.004 );
3488  }
3489  // 1/pt in pt and quadratic in eta
3490  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3491  return( 0.001 );
3492  }
3493  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3494 
3495  double thisStep[] = { 0.00001, 0.00001, 0.0000001, 0.00000001,
3496  0.00000001, 0.00000001, 0.00000001, 0.00000001 };
3497  TString thisParName[] = { "offsetEtaCentral", "offsetEtaHigh", "coeffOverPt", "coeffHighPt", "linaerEtaCentral", "parabEtaCentral", "linaerEtaHigh", "parabEtaHigh" };
3498  double thisMini[] = { -1.1, -1.1, -0.1, -0.1 , 0.0001, 0.0005, 0.0005, 0.001};
3499  if( muonType == 1 ) {
3500  double thisMaxi[] = { 1., 1., 1., 1.,
3501  1., 1., 1., 1.};
3502  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3503  } else {
3504  double thisMaxi[] = { -0.8, -0.8, -0.001, -0.001 , 0.005, 0.05, 0.05, 0.05};
3505  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3506  }
3507  }
3508 };
3509 
3517 // Resolution Type 12
3518 template <class T>
3519 class resolutionFunctionType12 : public resolutionFunctionBase<T> {
3520  public:
3521  resolutionFunctionType12() { this->parNum_ = 15; }
3522  // linear in pt and by points in eta
3523  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3524  double fabsEta = std::fabs(eta);
3525 
3526  double ptPart = parval[2]*1./pt + pt/(pt+parval[3]) + pt*parval[9] + pt*pt*parval[10];
3527 
3528  if(fabsEta<parval[0]) {
3529  // To impose continuity we require that the parval[0] of type11 is
3530  double par = parval[1] + parval[6]*std::fabs((parval[0]-parval[8])) + parval[7]*(parval[0]-parval[8])*(parval[0]-parval[8]) - (parval[4]*parval[0] + parval[5]*parval[0]*parval[0]);
3531  return( par + ptPart + parval[4]*fabsEta + parval[5]*eta*eta );
3532  }
3533  else {
3534  return( parval[1]+ ptPart + parval[6]*std::fabs((fabsEta-parval[8])) + parval[7]*(fabsEta-parval[8])*(fabsEta-parval[8]) );
3535  }
3536  }
3537 
3538  // 1/pt in pt and quadratic in eta
3539  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3540  return( parval[11]+parval[12]/pt + parval[13]*std::fabs(eta)+parval[14]*eta*eta );
3541  }
3542 
3543  // // 1/pt in pt and quadratic in eta
3544  // virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3545  // return( parval[15]+parval[16]/pt + parval[17]*std::fabs(eta)+parval[18]*eta*eta );
3546  // }
3547 
3548  // constant sigmaCotgTh
3549  // virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3550  // return( 0.004 );
3551  // }
3552 
3553  // constant sigmaPhi
3554  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3555  return( 0.001 );
3556  }
3557 
3558  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3559 
3560  double thisStep[] = { 0.001, 0.00001, 0.0000001, 0.00000001,
3561  0.00000001, 0.00000001, 0.00000001, 0.00000001,
3562  0.001, 0.0001, 0.000001,
3563  0.00002, 0.0002, 0.0000002, 0.00002 };
3564  // 0.00002, 0.0002, 0.00000002, 0.000002 };
3565  TString thisParName[] = { "etaTransition", "offsetEtaHigh", "coeffOverPt", "coeffHighPt",
3566  "linaerEtaCentral", "parabEtaCentral", "linaerEtaHigh", "parabEtaHigh",
3567  "secondParabolaCenter", "linearPt", "quadraticPt",
3568  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc." };
3569  // "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
3570  double thisMini[] = { 0.8, -1.1, 0., -1.1,
3571  0., 0.0005, 0.0005, 0.001,
3572  1.4, 0., 0.,
3573  // -0.001, 0.002, -0.0001, -0.0001 };
3574  -0.1, 0., -0.1, -0.1 };
3575  // -0.0001, 0.0005, -0.0001, -0.00001 };
3576  if( muonType == 1 ) {
3577  double thisMaxi[] = { 1., 1., 1., 1.,
3578  1., 1., 1., 1.,
3579  1., 1., 1.,
3580  1., 1., 1., 1. };
3581  // 1., 1., 1., 1. };
3582 
3583  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3584  } else {
3585  double thisMaxi[] = { 1.8, 0.8, 0.1, 0.1,
3586  0.005, 0.05, 0.05, 0.05,
3587  2.4, 2.0, 2.0,
3588  // 0.001, 0.005, 0.00004, 0.0007 };
3589  0.1, 0.05, 0.1, 0.1 };
3590  // 0.001, 0.01, -0.0000015, 0.0004 };
3591  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3592  }
3593  }
3594 
3595  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
3596  const T & parResol, const std::vector<int> & parResolOrder,
3597  const std::vector<double> & parStep,
3598  const std::vector<double> & parMin,
3599  const std::vector<double> & parMax,
3600  const int muonType)
3601  {
3602  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
3603  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
3604  exit(1);
3605  }
3606  std::vector<ParameterSet> parSet(this->parNum_);
3607  // name, step, mini, maxi
3608 
3609  parSet[0] = ParameterSet( "etaTransition", parStep[0], parMin[0], parMax[0] );
3610  parSet[1] = ParameterSet( "offsetEtaHigh", parStep[1], parMin[1], parMax[1] );
3611  parSet[2] = ParameterSet( "coeffOverPt", parStep[2], parMin[2], parMax[2] );
3612  parSet[3] = ParameterSet( "coeffHighPt", parStep[3], parMin[3], parMax[3] );
3613  parSet[4] = ParameterSet( "linearEtaCentral", parStep[4], parMin[4], parMax[4] );
3614  parSet[5] = ParameterSet( "parabEtaCentral", parStep[5], parMin[5], parMax[5] );
3615  parSet[6] = ParameterSet( "linearEtaHigh", parStep[6], parMin[6], parMax[6] );
3616  parSet[7] = ParameterSet( "parabEtaHigh", parStep[7], parMin[7], parMax[7] );
3617  parSet[8] = ParameterSet( "secondParabolaCenter", parStep[8], parMin[8], parMax[8] );
3618  parSet[9] = ParameterSet( "linearPt", parStep[9], parMin[9], parMax[9] );
3619  parSet[10] = ParameterSet( "quadraticPt", parStep[10], parMin[10], parMax[10] );
3620  parSet[11] = ParameterSet( "Cth res. sc.", parStep[11], parMin[11], parMax[11] );
3621  parSet[12] = ParameterSet( "Cth res. 1/Pt sc.", parStep[12], parMin[12], parMax[12] );
3622  parSet[13] = ParameterSet( "Cth res. Eta sc.", parStep[13], parMin[13], parMax[13] );
3623  parSet[14] = ParameterSet( "Cth res. Eta^2 sc.", parStep[14], parMin[14], parMax[14] );
3624 
3625  std::cout << "setting parameters" << std::endl;
3626  for( int i=0; i<this->parNum_; ++i ) {
3627  std::cout << "parStep["<<i<<"] = " << parStep[i]
3628  << ", parMin["<<i<<"] = " << parMin[i]
3629  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
3630  }
3631  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
3632  }
3633 };
3634 
3640 // Resolution Type 13
3641 template <class T>
3642 class resolutionFunctionType13 : public resolutionFunctionBase<T> {
3643  public:
3644  resolutionFunctionType13() { this->parNum_ = 15; }
3645  // linear in pt and by points in eta
3646  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3647  double fabsEta = std::fabs(eta);
3648 
3649  double ptPart = parval[2]*1./pt + pt/(pt+parval[3]) + pt*parval[13] + pt*pt*parval[14];
3650 
3651  if(fabsEta<parval[9]) {
3652  // To impose continuity we require that
3653  double par2 = parval[1] + parval[6]*std::fabs(parval[9] - parval[8]) + parval[7]*pow(parval[9] - parval[8], 2) - parval[10]*std::fabs(parval[9] - parval[12]) - parval[11]*pow(parval[9] - parval[12], 2);
3654  if( fabsEta<parval[0]) {
3655  double par1 = par2 + parval[10]*std::fabs(parval[0] - parval[12]) + parval[11]*pow(parval[0] - parval[12], 2) - parval[4]*parval[0] - parval[5]*parval[0]*parval[0];
3656  return( par1 + ptPart + parval[4]*fabsEta + parval[5]*eta*eta );
3657  // return( parval[15] + ptPart + parval[4]*fabsEta + parval[5]*eta*eta );
3658  }
3659  // return( par2+ ptPart + parval[10]*std::fabs((fabsEta-parval[12])) + parval[11]*(fabsEta-parval[12])*(fabsEta-parval[12]) );
3660  return( par2+ ptPart + parval[10]*std::fabs((fabsEta-parval[12])) + parval[11]*(fabsEta-parval[12])*(fabsEta-parval[12]) );
3661  }
3662  return( parval[1]+ ptPart + parval[6]*std::fabs((fabsEta-parval[8])) + parval[7]*(fabsEta-parval[8])*(fabsEta-parval[8]) );
3663  }
3664  // 1/pt in pt and quadratic in eta
3665  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3666  return( 0.004 );
3667  }
3668  // 1/pt in pt and quadratic in eta
3669  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3670  return( 0.001 );
3671  }
3672  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3673 
3674  double thisStep[] = { 0.001, 0.00001, 0.0000001, 0.00000001,
3675  0.00000001, 0.00000001, 0.00000001, 0.00000001,
3676  0.00000001, 0.00000001, 0.00000001, 0.00000001,
3677  0.001, 0.0001, 0.000001 };
3678 // 0.001 };
3679  TString thisParName[] = { "etaTransition1", "offsetEtaHigh", "coeffOverPt", "coeffHighPt",
3680  "linearEtaCentral", "parabEtaCentral", "linearEtaHighEta", "parabEtaHighEta",
3681  "centerEtaHighEta", "etaTransition2", "linearEtaSecondEta", "parabEtaSecondEta",
3682  "centerEtaSecondEta", "linearPt", "quadraticPt" };
3683 // "scale2" };
3684  double thisMini[] = { 0.8, -1.1, -1.1, -1.1,
3685  -1., 0.0005, 0.0005, 0.001,
3686  0.8, 1.1, 0.0005, 0.001,
3687  0.0, -1.0, -1.0 };
3688 // -1.0 };
3689  if( muonType == 1 ) {
3690  double thisMaxi[] = { 1., 1., 1., 1.,
3691  1., 1., 1., 1.,
3692  1., 1., 1., 1.,
3693  1., 1., 1. };
3694 // 1. };
3695 
3696  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3697  } else {
3698  double thisMaxi[] = { 1.0, -0.8, 0.1, 0.1,
3699  0.005, 0.05, 0.05, 0.05,
3700  2.4, 1.4, 0.05, 0.05,
3701  1.8, 2.0, 2.0 };
3702 // 2.0 };
3703  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3704  }
3705  }
3706 };
3707 
3708 template <class T>
3709 class resolutionFunctionType14 : public resolutionFunctionBase<T> {
3710  public:
3711  resolutionFunctionType14() { this->parNum_ = 7; }
3712  // linear in pt and by points in eta
3713  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3714  double fabsEta = std::fabs(eta);
3715 
3716  if(fabsEta<1.3)
3717  return (parval[0] + parval[6]*pt + parval[2]*fabsEta + parval[3]*eta*eta);
3718  //if((1.3<eta<1.6) || (-1.6<eta<-1.3) )
3719  // return (parval[7] + parval[8]*fabsEta);
3720  else
3721  return (parval[1]+ parval[4]*std::fabs((fabsEta-1.6)) + parval[5]*(fabsEta-1.6)*(fabsEta-1.6));
3722 
3723 // if(fabsEta<1.35)
3724 // return (parval[0] + parval[6]*pt + parval[2]*fabsEta + parval[3]*eta*eta);
3725 // else
3726 // return (parval[0] + parval[6]*pt + parval[2]*fabsEta + parval[3]*eta*eta+ parval[4]*std::fabs((fabsEta-1.35)) + parval[5]*(fabsEta-1.35)*(fabsEta-1.35));
3727 
3728  }
3729  // 1/pt in pt and quadratic in eta
3730  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3731  return( 0.004 );
3732  }
3733  // 1/pt in pt and quadratic in eta
3734  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3735  return( 0.001 );
3736  }
3737  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3738 
3739  double thisStep[] = { 0.00001, 0.00001, 0.0000001, 0.00000001, 0.00000001, 0.00000001, 0.00000001 , 0.00002};
3740  TString thisParName[] = { "offsetEtaCentral", "offsetEtaHigh", "linaerEtaCentral", "parabEtaCentral", "linaerEtaHigh", "parabEtaHigh", "linearPt"};
3741  //, "offsetEtaOverlap","linaerEtaOverlap"};
3742  double thisMini[] = { 0.0, 0.0, -0.01, 0., -0.05, 0. , 0.};
3743  if( muonType == 1 ) {
3744  double thisMaxi[] = { 1., 1., 1., 1., 1.,
3745  1., 1.};
3746  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3747  } else {
3748  double thisMaxi[] = { 0.01, 0.02, 0.01, 0.05, 0.05, 0.1, 0.01};
3749  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3750  }
3751  }
3752 protected:
3753 };
3754 
3755 // par6,par7,par10
3756 // Resolution Type 15. For misaligned data. Linear in pt, parabolic in eta, regions separated: barrl+overlap, right endcap, left endcap.
3757 template <class T>
3758 class resolutionFunctionType15 : public resolutionFunctionBase<T> {
3759  public:
3760  resolutionFunctionType15() { this->parNum_ = 7; }
3761  // linear in pt and parabolic in eta
3762  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3763  double fabsEta = std::fabs(eta);
3764  double ptPart = pt*parval[0];
3765 
3766  if(fabsEta<=0.6)
3767  return (ptPart);
3768  else if(fabsEta>0.6 && fabsEta<=1.3) {//eta in barrel + overlap
3769  double par = - parval[1]*0.6*0.6;
3770  return( par + ptPart + parval[1]*eta*eta );
3771  }
3772  else if (eta>1.3){//eta in right endcap
3773  double par = parval[1]*1.3*1.3 - (parval[2]*(1.3-parval[3])*(1.3-parval[3]));
3774  return( par + ptPart + parval[2]*(fabsEta-parval[3])*(fabsEta-parval[3]) );
3775  }
3776  else{//eta in left endcap
3777  double par = parval[1]*1.3*1.3 - (parval[4]*(1.3-parval[5]) + parval[6]*(1.3-parval[5])*(1.3-parval[5]));
3778  return( par + ptPart + parval[4]*std::fabs((fabsEta-parval[5])) + parval[6]*(fabsEta-parval[5])*(fabsEta-parval[5]) );
3779  }
3780  }
3781  // 1/pt in pt and quadratic in eta
3782  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3783  // if (std::fabs(eta)<=1.2) return(0.000949148 );
3784  // else if(eta<-1.2) return(-0.00645458 + -0.00579458*eta);
3785  // else return(-0.00306283 + 0.00346136*eta);
3786  return 0;
3787 
3788  }
3789  // 1/pt in pt and quadratic in eta
3790  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3791  //return( 0.000211 + 0.00001*std::fabs(eta) + 0.0000789*eta*eta);
3792  return 0;
3793  }
3794  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3795  double thisStep[] = { 0.000001, 0.0000001,
3796  0.000001, 0.001,
3797  0.00000001, 0.001, 0.0001};
3798  TString thisParName[] = { "linearPt", "parabEtaCentral",
3799  "parabolicEtaRight", "rightParabCenter",
3800  "linearEtaLeft", "leftParabCenter", "parabolicEtaLeft" };
3801  double thisMini[] = { 0.00001, 0.0001,
3802  0.005, -5,
3803  -0.00006, 0.1, 0.002
3804  };
3805 
3806  if( muonType == 1 ) {
3807  double thisMaxi[] = { 1., 1.,
3808  1., 1.,
3809  1., 1. ,1.,
3810  };
3811  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3812  } else {
3813  double thisMaxi[] = { 0.0005, 0.05,
3814  0.15, 1.99,
3815  0.005, 1.99, 0.15,
3816  };
3817 
3818  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3819  }
3820  }
3821 };
3822 
3823 //Divides the resolution vs pt in three regions, barrel, overlap and endcaps. It gives excellent results for at least 15K Z
3824 template <class T>
3825 class resolutionFunctionType17 : public resolutionFunctionBase<T> {
3826  public:
3827  resolutionFunctionType17() { this->parNum_ = 18; }
3828  // linear in pt and parabolic in eta
3829  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3830  double fabsEta = std::fabs(eta);
3831  double ptPartBar = parval[0] + pt*parval[2];
3832  double ptPartOvlap = parval[16] + pt*parval[17];
3833  double ptPartEndc = parval[14] + pt*parval[15];
3834  if(fabsEta<=0.9) {//eta in barrel
3835  return( ptPartBar + parval[3] + parval[4]*fabsEta);
3836  }
3837  else if( (eta > 0.9 && eta <= 1.4) || (eta < -0.9 && eta > -1.4)){ //eta in overlap
3838  return( ptPartOvlap + parval[3] + parval[4]*eta + parval[5]*eta*eta);
3839  }
3840  else if (eta>1.4){//eta in right endcap
3841  double par = parval[3] + parval[4]*1.4 + parval[5]*1.4*1.4 - (parval[6] + parval[7]*(1.4-parval[8]) + parval[9]*(1.4-parval[8])*(1.4-parval[8]));
3842  return( par + ptPartEndc + parval[6] + parval[7]*std::fabs((fabsEta-parval[8])) + parval[9]*(fabsEta-parval[8])*(fabsEta-parval[8]) );
3843  }
3844  else {//eta in left endcap
3845  double par = parval[3] + parval[4]*1.4 + parval[5]*1.4*1.4 - (parval[10] + parval[11]*(1.4-parval[12]) + parval[13]*(1.4-parval[12])*(1.4-parval[12]));
3846  return( par + ptPartEndc + parval[10] + parval[11]*std::fabs((fabsEta-parval[12])) + parval[13]*(fabsEta-parval[12])*(fabsEta-parval[12]) );
3847  }
3848  }
3849  // 1/pt in pt and quadratic in eta
3850  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3851  return( 0.004 );
3852  }
3853  // 1/pt in pt and quadratic in eta
3854  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3855  return( 0.001 );
3856  }
3857  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3858  double thisStep[] = { 0.0001, 0.00001, 0.00001,
3859  0.001, 0.0001, 0.0000001,
3860  0.01, 0.001, 0.01, 0.001,
3861  0.01, 0.001, 0.01, 0.001,
3862  0.01, 0.00001, 0.01, 0.00001};
3863  TString thisParName[] = { "offsetPt", "hyperbolicPt", "linearPt",
3864  "offsetEtaCentral", "linaerEtaCentral", "parabEtaCentral",
3865  "offsetEtaEndcapRight", "linearEtaRight", "rightParabCenter", "parabolicEtaRight",
3866  "offsetEtaEndcapLeft", "linearEtaLeft", "leftParabCenter", "parabolicEtaLeft",
3867  "offsetPtEndc", "linearPtEndc", "offsetPtOvlap", "linearPtOvlap"
3868  };
3869  double thisMini[] = { -0.15, -0.001, 0.00005,
3870  -0.05, -0.1, 0.0,
3871  -0.6, -0.0009, 0., 0.0005,
3872  -0.6, -0.1, 1., 0.01,
3873  -1.5, 0.00005, -1.5, 0.00005
3874  };
3875 
3876  if( muonType == 1 ) {
3877  double thisMaxi[] = { 1., 1., 1.,
3878  1., 1., 1.,
3879  1., 1. ,1., 1.,
3880  1., 1., 1., 1.,
3881  1., 1., 1., 1.,
3882  };
3883  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3884  } else {
3885  double thisMaxi[] = { 0.15, 0.8, 0.005,
3886  0.05, 0.1, 0.08,
3887  0.9, 0.5, 1.99, 0.15,
3888  0.9, 0.5, 1.99, 0.15,
3889  1.1, 0.005, 1.1, 0.005
3890  };
3891 
3892  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3893  }
3894  }
3895 };
3896 
3897 template <class T>
3898 class resolutionFunctionType18 : public resolutionFunctionBase<T> {
3899  public:
3900  resolutionFunctionType18() { this->parNum_ = 14; }
3901  // linear in pt and parabolic in eta
3902  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3903  double fabsEta = std::fabs(eta);
3904  double ptPart = parval[0] + parval[1]*1./pt + pt*parval[2];
3905 
3906  if(fabsEta<=0.6)
3907  return( ptPart + parval[3]);
3908  else if((eta>0.6 && eta<=1.3) || (eta>=-1.3 && eta<-0.6)) {//eta in barrel + overlap
3909  double par = parval[3] - 0.6*parval[4] - 0.6*0.6*parval[5];
3910  return( ptPart + par + parval[4]*fabsEta + parval[5]*eta*eta );
3911  }
3912  else if (eta>1.3){//eta in right endcap
3913  double par = parval[3] - 0.6*parval[4] - 0.6*0.6*parval[5] + parval[4]*1.3 + parval[5]*1.3*1.3 - (parval[6] + parval[7]*std::fabs(1.3-parval[8]) + parval[9]*(1.3-parval[8])*(1.3-parval[8]));
3914  return( par + ptPart + parval[6] + parval[7]*std::fabs((fabsEta-parval[8])) + parval[9]*(fabsEta-parval[8])*(fabsEta-parval[8]) );
3915  }
3916  else{//eta in left endcap
3917  double par = parval[3] - 0.6*parval[4] - 0.6*0.6*parval[5] + parval[4]*1.3 + parval[5]*1.3*1.3 - (parval[10] + parval[11]*std::fabs(1.3-parval[12]) + parval[13]*(1.3-parval[12])*(1.3-parval[12]));
3918  return( par + ptPart + parval[10] + parval[11]*std::fabs((fabsEta-parval[12])) + parval[13]*(fabsEta-parval[12])*(fabsEta-parval[12]) );
3919  }
3920  }
3921  // 1/pt in pt and quadratic in eta
3922  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3923  return( 0.004 );
3924  }
3925  // 1/pt in pt and quadratic in eta
3926  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3927  return( 0.001 );
3928  }
3929  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
3930  double thisStep[] = { 0.01, 0.0001, 0.00001,
3931  0.001, 0.0001, 0.000001,
3932  0.01, 0.001, 0.01, 0.001,
3933  0.01, 0.001, 0.01, 0.001};
3934  TString thisParName[] = { "offsetPt", "hyperbolicPt", "linearPt",
3935  "offsetEtaCentral", "linaerEtaCentral", "parabEtaCentral",
3936  "offsetEtaEndcapRight", "linearEtaRight", "rightParabCenter", "parabolicEtaRight",
3937  "offsetEtaEndcapLeft", "linearEtaLeft", "leftParabCenter", "parabolicEtaLeft" };
3938  double thisMini[] = { -1.5, -0.001, 0.00005,
3939  -0.05, -0.1, 0.0,
3940  -0.6, -0.0009, 0., 0.0005,
3941  -0.6, -0.1, 1., 0.01
3942  };
3943 
3944  if( muonType == 1 ) {
3945  double thisMaxi[] = { 1., 1., 1.,
3946  1., 1., 1.,
3947  1., 1. ,1., 1.,
3948  1., 1., 1., 1.
3949  };
3950  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3951  } else {
3952  double thisMaxi[] = { 1.1, 0.8, 0.005,
3953  0.05, 0.1, 0.08,
3954  0.9, 0.5, 1.99, 0.15,
3955  0.9, 0.5, 1.99, 0.15
3956  };
3957 
3958  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3959  }
3960  }
3961 };
3962 
3963 // Resolution Type 19
3964 // Same as type 8, but the sigmaPhi and sigmaCotgTh are not free. This way the function results as having less parameters.
3965 // This was done to verify if fixed parameters have an influence in the computation of errors by minuit.
3966 template <class T>
3967 class resolutionFunctionType19 : public resolutionFunctionBase<T> {
3968  public:
3969  resolutionFunctionType19() { this->parNum_ = 4; }
3970  // linear in pt and by points in eta
3971  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
3972  double value = parval[0]+parval[1]*pt + parval[2]*etaByPoints(eta, parval[3]);
3973  if( value != value ) {
3974  std::cout << "parval[0] = " << parval[0] << ", parval[1]*"<<pt<<" = " << parval[1]*pt << "parval[2] = " << parval[1] << ",etaByPoints("<<eta<<", "<<parval[3]<<") = " << etaByPoints(eta, parval[3]) << std::endl;
3975  }
3976  return( parval[0] + parval[1]*pt + parval[2]*etaByPoints(eta, parval[3]) );
3977  }
3978  // 1/pt in pt and quadratic in eta
3979  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
3980  return( 0.00043 + 0.0041/pt + (2.8e-06)*std::fabs(eta) + (7.7e-05)*eta*eta );
3981  }
3982  // 1/pt in pt and quadratic in eta
3983  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
3984  return( 0.00011 + 0.0018/pt - (9.4e-07)*std::fabs(eta) + (2.2e-05)*eta*eta );
3985  }
3986  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
3987  {
3988  double thisStep[] = { 0.0000002, 0.0000001, 0.00001, 0.001 };
3989  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Eta sc.", "Pt res. eta border"};
3990  double thisMini[] = { -0.03, -0.0000001, 0.001, 0.01};
3991  if( muonType == 1 ) {
3992  double thisMaxi[] = { 1., 1., 1., 1.};
3993  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3994  } else {
3995  double thisMaxi[] = { 0.03, 0.1, 2., 0.6};
3996  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
3997  }
3998  }
3999 protected:
4004  double etaByPoints(const double & inEta, const double & border) {
4005  Double_t eta = std::fabs(inEta);
4006  if( 0. <= eta && eta <= 0.2 ) return 0.00942984;
4007  else if( 0.2 < eta && eta <= 0.4 ) return 0.0104489;
4008  else if( 0.4 < eta && eta <= 0.6 ) return 0.0110521;
4009  else if( 0.6 < eta && eta <= 0.8 ) return 0.0117338;
4010  else if( 0.8 < eta && eta <= 1.0 ) return 0.0138142;
4011  else if( 1.0 < eta && eta <= 1.2 ) return 0.0165826;
4012  else if( 1.2 < eta && eta <= 1.4 ) return 0.0183663;
4013  else if( 1.4 < eta && eta <= 1.6 ) return 0.0169904;
4014  else if( 1.6 < eta && eta <= 1.8 ) return 0.0173289;
4015  else if( 1.8 < eta && eta <= 2.0 ) return 0.0205821;
4016  else if( 2.0 < eta && eta <= 2.2 ) return 0.0250032;
4017  else if( 2.2 < eta && eta <= 2.4 ) return 0.0339477;
4018  else if( 2.4 < eta && eta <= 2.6 ) return border;
4019  return ( 0. );
4020  }
4021 };
4022 
4023 template <class T>
4024 class resolutionFunctionType20 : public resolutionFunctionBase<T> {
4025  public:
4026  resolutionFunctionType20() { this->parNum_ = 9; }
4027  // linear in pt and by points in eta
4028  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
4029  double fabsEta = std::fabs(eta);
4030 
4031  if(fabsEta<parval[0]) {
4032  // To impose continuity we require that the parval[0] of type11 is
4033  double par = parval[1] + parval[4]*std::fabs((parval[0]-parval[6])) + parval[5]*(parval[0]-parval[6])*(parval[0]-parval[6]) - (parval[2]*parval[0] + parval[3]*parval[0]*parval[0]);
4034  return( par + parval[2]*fabsEta + parval[3]*eta*eta );
4035  }
4036  else {
4037  return( parval[1]+ parval[4]*std::fabs((fabsEta-parval[6])) + parval[5]*(fabsEta-parval[6])*(fabsEta-parval[6]) );
4038  }
4039  }
4040 
4041  // 1/pt in pt and quadratic in eta
4042  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4043  return( parval[7]+parval[8]/pt );
4044  }
4045 
4046  // // 1/pt in pt and quadratic in eta
4047  // virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4048  // return( parval[15]+parval[16]/pt + parval[17]*std::fabs(eta)+parval[18]*eta*eta );
4049  // }
4050 
4051  // constant sigmaCotgTh
4052  // virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4053  // return( 0.004 );
4054  // }
4055 
4056  // constant sigmaPhi
4057  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4058  return( 0.001 );
4059  }
4060 
4061  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
4062 
4063  double thisStep[] = { 0.001, 0.00001,
4064  0.00000001, 0.00000001, 0.00000001, 0.00000001,
4065  0.001,
4066  0.00002, 0.0002 };
4067  // 0.00002, 0.0002, 0.00000002, 0.000002 };
4068  TString thisParName[] = { "etaTransition", "offsetEtaHigh",
4069  "linaerEtaCentral", "parabEtaCentral", "linaerEtaHigh", "parabEtaHigh",
4070  "secondParabolaCenter",
4071  "Cth res. sc.", "Cth res. 1/Pt sc." };
4072  // "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
4073  double thisMini[] = { 0.8, -0.1,
4074  0., 0., 0., 0.,
4075  1.0,
4076  -0.1, 0. };
4077  if( muonType == 1 ) {
4078  double thisMaxi[] = { 1., 1., 1., 1.,
4079  1., 1., 1., 1.,1.};
4080 
4081  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4082  } else {
4083  double thisMaxi[] = { 2., 0.1,
4084  0.01, 0.1, 0.1, 1.,
4085  4.,
4086  0.1, 0.1 };
4087 
4088  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4089  }
4090  }
4091 };
4092 
4093 
4097 // Resolution Type 30
4098 template <class T>
4099 class resolutionFunctionType30 : public resolutionFunctionBase<T> {
4100  public:
4101  resolutionFunctionType30() { this->parNum_ = 27; }
4102 
4103  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
4104  {
4105  double fabsEta = std::fabs(eta);
4106 
4107  double ptPart = parval[13]*pt;
4108  if( fabsEta > 2.0 ) {
4109  ptPart = parval[22]*pt + parval[23]*pt*pt;
4110  }
4111  else if( fabsEta > 1.4 ) {
4112  ptPart = parval[20]*pt + parval[21]*pt*pt;
4113  }
4114  if(fabsEta<parval[0]) {
4115  return( ptPart + parval[1] + parval[2]*fabsEta + parval[3]*eta*eta );
4116  }
4117  // Return a line connecting the two parabolas
4118  else if( fabsEta < parval[14] ) {
4119  double x_1 = parval[0];
4120  double y_1 = parval[1] + parval[2]*parval[0] + parval[3]*parval[0]*parval[0];
4121  double x_2 = parval[14];
4122  double y_2 = parval[4] + parval[5]*std::fabs((parval[14]-parval[7])) + parval[6]*(parval[14]-parval[7])*(parval[14]-parval[7]);
4123  return( (fabsEta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1 );
4124  }
4125  else if( fabsEta < parval[15] ) {
4126  return( ptPart + parval[4] + parval[5]*std::fabs(fabsEta-parval[7]) + parval[6]*(fabsEta-parval[7])*(fabsEta-parval[7]) );
4127  }
4128  else {
4129  return( ptPart + parval[16] + parval[17]*std::fabs(fabsEta-parval[19]) + parval[18]*(fabsEta-parval[19])*(fabsEta-parval[19]) );
4130  }
4131  }
4132 
4133  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4134  {
4135  double fabsEta = std::fabs(eta);
4136 
4137  double ptPart = parError[13]*pt;
4138  if( fabsEta > 2.0 ) {
4139  ptPart = parError[22]*pt + parError[23]*pt*pt;
4140  }
4141  else if( fabsEta > 1.4 ) {
4142  ptPart = parError[20]*pt + parError[21]*pt*pt;
4143  }
4144  if(fabsEta<parval[0]) {
4145  return( ptPart + parError[1] + parError[2]*fabsEta + parError[3]*eta*eta );
4146  }
4147  // Note: this is a rough approximation, it should be fixed
4148  else if( fabsEta < parval[14] ) {
4149  double x_1 = parval[0];
4150  double y_1 = parval[1] + parval[2]*parval[0] + parval[3]*parval[0]*parval[0];
4151  double x_2 = parval[14];
4152  double y_2 = parval[4] + parval[5]*std::fabs((parval[14]-parval[7])) + parval[6]*(parval[14]-parval[7])*(parval[14]-parval[7]);
4153  double lineValue = (fabsEta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1;
4154 
4155  // x_1 = parval[0];
4156  y_1 = parval[1] + parError[1] + (parval[2] + parError[2])*parval[0] + (parval[3] + parError[3])*parval[0]*parval[0];
4157  // x_2 = parval[14];
4158  y_2 = parval[4] + parError[4] + (parval[5] + parError[5])*std::fabs((parval[14]-parval[7])) + (parval[6] + parError[6])*(parval[14]-parval[7])*(parval[14]-parval[7]);
4159  double lineValuePlusError = (fabsEta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1;
4160 
4161  return(lineValuePlusError - lineValue );
4162  }
4163  else if( fabsEta < parval[15] ) {
4164  return( ptPart + parError[4] + parError[5]*std::fabs(fabsEta-parval[7]) + parError[6]*(fabsEta-parval[7])*(fabsEta-parval[7]) );
4165  }
4166  else {
4167  return( ptPart + parError[16] + parError[17]*std::fabs(fabsEta-parval[19]) + parError[18]*(fabsEta-parval[19])*(fabsEta-parval[19]) );
4168  }
4169  }
4170 
4171  // 1/pt in pt and quadratic in eta
4172  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4173  // return( parval[8] + parval[9]/(pt + parval[10]) + parval[11]*pt );
4174  double fabsEta = std::fabs(eta);
4175  double value = parval[8] + parval[9]*fabsEta + parval[10]*eta*eta + parval[11]*fabsEta*fabsEta*fabsEta;
4176  if( value > 0 ) {
4177  return( value );
4178  }
4179  return 0;
4180  }
4181 
4182  // constant sigmaPhi
4183  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4184  //std::cout << "parval[12] = " << parval[12] << std::endl;
4185 
4186  return( parval[12] );
4187 
4188 }
4189 
4190  virtual double covPt1Pt2(const double & pt1, const double & eta1, const double & pt2, const double & eta2, const T & parval)
4191  {
4192  return parval[24] + std::fabs(pt1 - pt2)*parval[25] + std::fabs(eta1 - eta2)*parval[26];
4193  }
4194 
4195  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
4196  {
4197  std::vector<ParameterSet> parSet(this->parNum_);
4198  // name, step, mini, maxi
4199  parSet[0] = ParameterSet( "etaTransition", 0.0001, 0., 2. );
4200  parSet[1] = ParameterSet( "constantCentral", 0.00001, 0., 1. );
4201  parSet[2] = ParameterSet( "linearEtaCentral", 0.00001, 0., 1. );
4202  parSet[3] = ParameterSet( "quadraticEtaCentral", 0.000001, 0., 1. );
4203  parSet[4] = ParameterSet( "constantForward", 0.00001, 0., 1. );
4204  parSet[5] = ParameterSet( "linearEtaForward", 0.00001, 0., 1. );
4205  parSet[6] = ParameterSet( "quadraticEtaForward", 0.000001, 0., 1. );
4206  parSet[7] = ParameterSet( "vertexForward", 0.0001, 0., 3. );
4207  parSet[8] = ParameterSet( "cotgThetaConstant", 0.00001, -1., 1. );
4208  parSet[9] = ParameterSet( "cotgThetaFactor", 0.00001, -1., 1. );
4209  parSet[10] = ParameterSet( "cotgThetaDenominatorTerm", 0.000001, -1., 1. );
4210  parSet[11] = ParameterSet( "cotgThetaLinearPt", 0.000001, -1., 1. );
4211  parSet[12] = ParameterSet( "sigmaPhi", 0.0001, 0., 1. );
4212  parSet[13] = ParameterSet( "barrelLinearPt", 0.00001, 0., 1. );
4213  parSet[14] = ParameterSet( "split", 0.0001, 0., 3. );
4214  parSet[15] = ParameterSet( "veryForwardSplit", 0.0001, 0., 3. );
4215  parSet[16] = ParameterSet( "constantVeryForward", 0.00001, 0., 1. );
4216  parSet[17] = ParameterSet( "linearEtaVeryForward", 0.00001, 0., 1. );
4217  parSet[18] = ParameterSet( "quadraticEtaVeryForward", 0.000001, 0., 1. );
4218  parSet[19] = ParameterSet( "vertexVeryForward", 0.0001, 0., 3. );
4219  parSet[20] = ParameterSet( "endcapsLinearPt", 0.00001, -1., 1. );
4220  parSet[21] = ParameterSet( "endcapsQuadraticPt", 0.000001, -1., 1. );
4221  parSet[22] = ParameterSet( "veryForwardLinearPt", 0.00001, -1., 1. );
4222  parSet[23] = ParameterSet( "veryForwardQuadraticPt", 0.000001, -1., 1. );
4223  parSet[24] = ParameterSet( "covPt1Pt2Constant", 0.000001, -1., 1. );
4224  parSet[25] = ParameterSet( "covPt1Pt2DeltaPt", 0.000001, -1., 1. );
4225  parSet[26] = ParameterSet( "covPt1Pt2DeltaEta", 0.000001, -1., 1. );
4226 
4227  std::cout << "setting parameters" << std::endl;
4228  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4229  }
4230 
4231  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
4232  const T & parResol, const std::vector<int> & parResolOrder,
4233  const std::vector<double> & parStep,
4234  const std::vector<double> & parMin,
4235  const std::vector<double> & parMax,
4236  const int muonType)
4237  {
4238  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
4239  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
4240  exit(1);
4241  }
4242  std::vector<ParameterSet> parSet(this->parNum_);
4243  // name, step, mini, maxi
4244 
4245  parSet[0] = ParameterSet( "etaTransition", parStep[0], parMin[0], parMax[0] );
4246  parSet[1] = ParameterSet( "constantCentral", parStep[1], parMin[1], parMax[1] );
4247  parSet[2] = ParameterSet( "linearEtaCentral", parStep[2], parMin[2], parMax[2] );
4248  parSet[3] = ParameterSet( "quadraticEtaCentral", parStep[3], parMin[3], parMax[3] );
4249  parSet[4] = ParameterSet( "constantForward", parStep[4], parMin[4], parMax[4] );
4250  parSet[5] = ParameterSet( "linearEtaForward", parStep[5], parMin[5], parMax[5] );
4251  parSet[6] = ParameterSet( "quadraticEtaForward", parStep[6], parMin[6], parMax[6] );
4252  parSet[7] = ParameterSet( "vertexForward", parStep[7], parMin[7], parMax[7] );
4253  parSet[8] = ParameterSet( "cotgThetaConstant", parStep[8], parMin[8], parMax[8] );
4254  parSet[9] = ParameterSet( "cotgThetaFactor", parStep[9], parMin[9], parMax[9] );
4255  parSet[10] = ParameterSet( "cotgThetaDenominatorTerm", parStep[10], parMin[10], parMax[10] );
4256  parSet[11] = ParameterSet( "cotgThetaLinearPt", parStep[11], parMin[11], parMax[11] );
4257  parSet[12] = ParameterSet( "sigmaPhi", parStep[12], parMin[12], parMax[12] );
4258  parSet[13] = ParameterSet( "barrelLinearPt", parStep[13], parMin[13], parMax[13] );
4259  parSet[14] = ParameterSet( "split", parStep[14], parMin[14], parMax[14] );
4260  parSet[15] = ParameterSet( "veryForwardSplit", parStep[15], parMin[15], parMax[15] );
4261  parSet[16] = ParameterSet( "constantVeryForward", parStep[16], parMin[16], parMax[16] );
4262  parSet[17] = ParameterSet( "linearEtaVeryForward", parStep[17], parMin[17], parMax[17] );
4263  parSet[18] = ParameterSet( "quadraticEtaVeryForward", parStep[18], parMin[18], parMax[18] );
4264  parSet[19] = ParameterSet( "vertexVeryForward", parStep[19], parMin[19], parMax[19] );
4265  parSet[20] = ParameterSet( "endcapsLinearPt", parStep[20], parMin[20], parMax[20] );
4266  parSet[21] = ParameterSet( "endcapsQuadraticPt", parStep[21], parMin[21], parMax[21] );
4267  parSet[22] = ParameterSet( "veryForwardLinearPt", parStep[22], parMin[22], parMax[22] );
4268  parSet[23] = ParameterSet( "veryForwardQuadraticPt", parStep[23], parMin[23], parMax[23] );
4269  parSet[24] = ParameterSet( "covPt1Pt2Constant", parStep[24], parMin[24], parMax[24] );
4270  parSet[25] = ParameterSet( "covPt1Pt2DeltaPt", parStep[25], parMin[25], parMax[25] );
4271  parSet[26] = ParameterSet( "covPt1Pt2DeltaEta", parStep[26], parMin[26], parMax[26] );
4272 
4273  std::cout << "setting parameters" << std::endl;
4274  for( int i=0; i<this->parNum_; ++i ) {
4275  std::cout << "parStep["<<i<<"] = " << parStep[i]
4276  << ", parMin["<<i<<"] = " << parMin[i]
4277  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
4278  }
4279  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4280  }
4281 };
4282 template <class T>
4283 class resolutionFunctionType31 : public resolutionFunctionBase<T> {
4284  public:
4285  resolutionFunctionType31() { this->parNum_ = 14; }
4286 
4287  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
4288  {
4289  double fabsEta = std::fabs(eta);
4290 
4291  if(fabsEta < 0.2 ) return parval[0];
4292  if(fabsEta < 0.4 ) return parval[1];
4293  if(fabsEta < 0.6 ) return parval[2];
4294  if(fabsEta < 0.8 ) return parval[3];
4295  if(fabsEta < 1.0 ) return parval[4];
4296  if(fabsEta < 1.2 ) return parval[5];
4297  if(fabsEta < 1.4 ) return parval[6];
4298  if(fabsEta < 1.6 ) return parval[7];
4299  if(fabsEta < 1.8 ) return parval[8];
4300  if(fabsEta < 2.0 ) return parval[9];
4301  if(fabsEta < 2.2 ) return parval[10];
4302  return parval[11];
4303  }
4304 
4305  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4306  {
4307  return 0;
4308  }
4309 
4310 
4311  // 1/pt in pt and quadratic in eta
4312  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval)
4313  {
4314  // return( parval[8] + parval[9]/(pt + parval[10]) + parval[11]*pt );
4315  // double fabsEta = std::fabs(eta);
4316  double value = parval[12] ;
4317  if( value > 0 ) {
4318  return( value );
4319  }
4320  return 0;
4321  }
4322 
4323  // constant sigmaPhi
4324  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval)
4325  {
4326  //std::cout << "parval[12] = " << parval[12] << std::endl;
4327  return( parval[13] );
4328  }
4329 
4330  virtual double covPt1Pt2(const double & pt1, const double & eta1, const double & pt2, const double & eta2, const T & parval)
4331  {
4332  return 0;
4333  }
4334 
4335  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
4336  {
4337  std::vector<ParameterSet> parSet(this->parNum_);
4338  // name, step, mini, maxi
4339  parSet[0] = ParameterSet( "sigmaPt |eta|<0.2", 0.00001, 0., 1. );
4340  parSet[1] = ParameterSet( "sigmaPt |eta|<0.4", 0.00001, 0., 1. );
4341  parSet[2] = ParameterSet( "sigmaPt |eta|<0.6", 0.00001, 0., 1. );
4342  parSet[3] = ParameterSet( "sigmaPt |eta|<0.8", 0.00001, 0., 1. );
4343  parSet[4] = ParameterSet( "sigmaPt |eta|<1.0", 0.00001, 0., 1. );
4344  parSet[5] = ParameterSet( "sigmaPt |eta|<1.2", 0.00001, 0., 1. );
4345  parSet[6] = ParameterSet( "sigmaPt |eta|<1.4", 0.00001, 0., 1. );
4346  parSet[7] = ParameterSet( "sigmaPt |eta|<1.6", 0.00001, 0., 1. );
4347  parSet[8] = ParameterSet( "sigmaPt |eta|<1.8", 0.00001, 0., 1. );
4348  parSet[9] = ParameterSet( "sigmaPt |eta|<2.0", 0.00001, 0., 1. );
4349  parSet[10] = ParameterSet( "sigmaPt |eta|<2.2", 0.00001, 0., 1. );
4350  parSet[11] = ParameterSet( "sigmaPt |eta|>2.2", 0.00001, 0., 1. );
4351  parSet[12] = ParameterSet( "sigmacotheta", 0.0001, 0., 1. );
4352  parSet[13] = ParameterSet( "sigmaPhi", 0.0001, 0. ,1.);
4353  std::cout << "setting parameters" << std::endl;
4354  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4355  }
4356 
4357  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
4358  const T & parResol, const std::vector<int> & parResolOrder,
4359  const std::vector<double> & parStep,
4360  const std::vector<double> & parMin,
4361  const std::vector<double> & parMax,
4362  const int muonType)
4363  {
4364  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
4365  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
4366  exit(1);
4367  }
4368  std::vector<ParameterSet> parSet(this->parNum_);
4369  // name, step, mini, maxi
4370 
4371  parSet[0] = ParameterSet( "sigmaPt |eta|<0.2", parStep[0], parMin[0], parMax[0] );
4372  parSet[1] = ParameterSet( "sigmaPt |eta|<0.4", parStep[1], parMin[1], parMax[1] );
4373  parSet[2] = ParameterSet( "sigmaPt |eta|<0.6", parStep[2], parMin[2], parMax[2] );
4374  parSet[3] = ParameterSet( "sigmaPt |eta|<0.8", parStep[3], parMin[3], parMax[3] );
4375  parSet[4] = ParameterSet( "sigmaPt |eta|<1.0", parStep[4], parMin[4], parMax[4] );
4376  parSet[5] = ParameterSet( "sigmaPt |eta|<1.2", parStep[5], parMin[5], parMax[5] );
4377  parSet[6] = ParameterSet( "sigmaPt |eta|<1.4", parStep[6], parMin[6], parMax[6] );
4378  parSet[7] = ParameterSet( "sigmaPt |eta|<1.6", parStep[7], parMin[7], parMax[7] );
4379  parSet[8] = ParameterSet( "sigmaPt |eta|<1.8", parStep[8], parMin[8], parMax[8] );
4380  parSet[9] = ParameterSet( "sigmaPt |eta|<2.0", parStep[9], parMin[9], parMax[9] );
4381  parSet[10] = ParameterSet( "sigmaPt |eta|<2.2", parStep[10], parMin[10], parMax[10] );
4382  parSet[11] = ParameterSet( "sigmaPt |eta|>2.2", parStep[11], parMin[11], parMax[11] );
4383  parSet[12] = ParameterSet( "sigmacotTheta", parStep[12], parMin[12], parMax[12] );
4384  parSet[13] = ParameterSet( "sigmaPhi", parStep[13], parMin[13], parMax[13] );
4385  std::cout << "setting parameters" << std::endl;
4386  for( int i=0; i<this->parNum_; ++i ) {
4387  std::cout << "parStep["<<i<<"] = " << parStep[i]
4388  << ", parMin["<<i<<"] = " << parMin[i]
4389  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
4390  }
4391  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4392  }
4393 };
4394 
4395 template <class T>
4396 class resolutionFunctionType32 : public resolutionFunctionBase<T> {
4397  public:
4398  resolutionFunctionType32()
4399  {
4400  this->parNum_ = 26;
4401  double tempBins[] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8,
4402  0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6,
4403  1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3 };
4404  std::copy( tempBins, tempBins+23, bins );
4405  }
4406 
4407  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
4408  {
4409  double fabsEta = std::fabs(eta);
4410  for( int i=0; i<23; ++i ) {
4411  if( fabsEta < bins[i] ) return parval[i];
4412  }
4413  // The last bin is |eta| > 2.3
4414  return parval[23];
4415  }
4416 
4417  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4418  {
4419  double fabsEta = std::fabs(eta);
4420  for( int i=0; i<23; ++i ) {
4421  if( fabsEta < bins[i] ) return parError[i];
4422  }
4423  return parError[23];
4424  }
4425 
4426  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval)
4427  {
4428  // double fabsEta = std::fabs(eta);
4429  double value = parval[24] ;
4430  if( value > 0 ) {
4431  return( value );
4432  }
4433  return 0;
4434  }
4435 
4436  // constant sigmaPhi
4437  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval)
4438  {
4439  return( parval[25] );
4440  }
4441 
4442  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
4443  const T & parResol, const std::vector<int> & parResolOrder,
4444  const std::vector<double> & parStep,
4445  const std::vector<double> & parMin,
4446  const std::vector<double> & parMax,
4447  const int muonType)
4448  {
4449  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
4450  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
4451  exit(1);
4452  }
4453  std::vector<ParameterSet> parSet(this->parNum_);
4454  // name, step, mini, maxi
4455  for( int i=0; i<24; ++i ) {
4456  parSet[i] = ParameterSet( "eta bin", parStep[i], parMin[i], parMax[i] );
4457  }
4458  parSet[24] = ParameterSet( "sigmaCotgTheta", parStep[24], parMin[24], parMax[24] );
4459  parSet[25] = ParameterSet( "sigmaPhi", parStep[25], parMin[25], parMax[25] );
4460 
4461  std::cout << "setting parameters" << std::endl;
4462  for( int i=0; i<this->parNum_; ++i ) {
4463  std::cout << "parStep["<<i<<"] = " << parStep[i]
4464  << ", parMin["<<i<<"] = " << parMin[i]
4465  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
4466  }
4467  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4468  }
4469  // Data members
4470  double bins[23];
4471 };
4472 
4473 // Daniele's function for Zmumu (36/pb)--------------------
4474 template <class T>
4475 class resolutionFunctionType40 : public resolutionFunctionBase<T> {
4476  public:
4477  resolutionFunctionType40() { this->parNum_ = 10; }
4478  // linear in pt and by points in eta parSet[0] = ParameterSet( "Phi ampl bin0 (neg muon)" , parStep[0], parMin[0], parMax[0] );
4479 
4480  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
4481  double fabsEta = std::fabs(eta);
4482  if(fabsEta<parval[0]) {
4483  // To impose continuity we require that the parval[0] of type11 is
4484  double par = parval[1];// + parval[5]*(parval[0]-parval[6])*(parval[0]-parval[6]) - parval[3]*parval[0]*parval[0]
4485  return( par + parval[3]*eta*eta + parval[9]*pt);
4486  }
4487  else {
4488  double coeff, centre;
4489  if(eta>0.) { coeff=parval[5]; centre=parval[6];
4490  }
4491  else { coeff=parval[2];centre=parval[4];
4492  }
4493  return( parval[1] + coeff*(fabsEta-centre)*(fabsEta-centre) + parval[9]*pt);
4494  }
4495  }
4496 
4497  // 1/pt in pt and quadratic in eta
4498  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4499  return( parval[7] );
4500  }
4501 
4502  // // 1/pt in pt and quadratic in eta
4503  // virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4504  // return( parval[15]+parval[16]/pt + parval[17]*std::fabs(eta)+parval[18]*eta*eta );
4505  // }
4506 
4507  // constant sigmaCotgTh
4508  // virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4509  // return( 0.004 );
4510  // }
4511 
4512  // constant sigmaPhi
4513  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4514  return( parval[8] );
4515  //return( 0.001 );
4516  }
4517 
4518  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
4519 
4520  double thisStep[] = { 0.001, 0.00001,
4521  0.00000001, 0.00000001, 0.001, 0.00000001,
4522  0.001,
4523  0.00002,
4524  0.0001,
4525  0.000002 };
4526  // 0.00002, 0.0002, 0.00000002, 0.000002 };
4527  TString thisParName[] = { "etaTransition", "offsetEtaHigh",
4528  "parabEtaHighNeg", "parabEtaCentral", "secondParabolaCenterNeg", "parabEtaHighPos",
4529  "secondParabolaCenterPos",
4530  "Cth res. sc.", "Phi res. sc.", "linearPt" };
4531  // "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc." };
4532  double thisMini[] = { 0.8, -0.1,
4533  0., 0., 0., 0.,
4534  0.,
4535  0.,
4536  0.,
4537  0. };
4538  if( muonType == 1 ) {
4539  double thisMaxi[] = { 1., 1., 1., 1., 1.,
4540  1., 1., 1.,
4541  0.1,
4542  0.001 };
4543 
4544  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4545  } else {
4546  double thisMaxi[] = { 2., 0.1,
4547  1., 0.1, 2.5, 1.,
4548  2.5,
4549  0.1,
4550  0.1,
4551  0.0005 };
4552 
4553  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4554  }
4555  }
4556 };
4557 
4558 //------------------------ 4Nov and 22 Dec data/MC Zmumu (36/pb) ---------
4559 template <class T>
4560 class resolutionFunctionType41 : public resolutionFunctionBase<T> {
4561  public:
4562  resolutionFunctionType41() { this->parNum_ = 18; }
4563  // linear in pt and quadratic in eta
4564  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
4565  double fabsEta = std::fabs(eta);
4566  if(eta>=parval[16] && eta<=parval[17]){
4567  return( parval[0]+parval[1]*pt + parval[2]*std::fabs(eta)+parval[3]*pow(eta,2) );
4568  }
4569  else if(eta<parval[16]){ //eta in left endcap
4570  double par = - parval[12]*parval[16]*parval[16] + parval[0]+parval[1]*pt + parval[2]*parval[16]+parval[3]*pow(parval[16],2);
4571  return( par + parval[12]*(fabsEta-parval[13])*(fabsEta-parval[13]) );
4572  }
4573 
4574  else{ //eta in righ endcap ///
4575  double par = - parval[14]*parval[17]*parval[17] + parval[0]+parval[1]*pt + parval[2]*parval[17]+parval[3]*pow(parval[17],2);
4576  return( par + parval[14]*(fabsEta-parval[15])*(fabsEta-parval[15]) );
4577  }
4578  }
4579  // 1/pt in pt and quadratic in eta
4580  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4581  return( parval[4]+parval[5]/pt + parval[6]*std::fabs(eta)+parval[7]*pow(eta,2) );
4582  }
4583  // 1/pt in pt and quadratic in eta
4584  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4585  return( parval[8]+parval[9]/pt + parval[10]*std::fabs(eta)+parval[11]*pow(eta,2) );
4586  }
4587 
4588  // derivatives ---------------
4589 
4590  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4591  {
4592  double fabsEta = std::fabs(eta);
4593  if(eta>=parval[16] && eta<=parval[17]){ //central region
4594  // return( parval[0]+parval[1]*pt + parval[2]*std::fabs(eta)+parval[3]*pow(eta,2) );
4595  return( sqrt(parError[0]*parError[0]+(pt*pt)*parError[1]*parError[1]+(eta*eta)*parError[2]*parError[2]+pow(eta,4)*parError[3]*parError[3]) );
4596  }
4597  else if(eta<parval[16]){ // Left endcap
4598  return( sqrt(pow(parval[16]+(fabsEta-parval[13])*(fabsEta-parval[13]),2)*parError[12]*parError[12]+
4599  pow(parError[16]*(2*parval[16]*parval[12]+parval[2]+2*parval[16]*parval[3]),2)+
4600  pow(parError[0],2)+
4601  pow(parError[1]*pt,2)+
4602  pow(parError[2]*parval[16],2)+
4603  pow(parval[16],4)*pow(parError[3],2)+
4604  pow(2*(fabsEta-parval[13])*parError[13],2)
4605  )
4606  );
4607  }
4608 
4609  else{ //eta in righ endcap ///
4610 
4611  return( sqrt(pow(parval[17]+(fabsEta-parval[15])*(fabsEta-parval[15]),2)*parError[14]*parError[14]+
4612  pow(parError[17]*(2*parval[17]*parval[14]+parval[2]+2*parval[17]*parval[3]),2)+
4613  pow(parError[0],2)+
4614  pow(parError[1]*pt,2)+
4615  pow(parError[2]*parval[17],2)+
4616  pow(parval[17],4)*pow(parError[3],2)+
4617  pow(2*(fabsEta-parval[15])*parError[15],2)
4618  )
4619  );
4620 
4621 
4622  }
4623  }
4624 
4625  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType) {
4626  double thisStep[] = { 0.002, 0.00002, 0.000002, 0.0002,
4627  0.00002, 0.0002, 0.0000002, 0.000002,
4628  0.00002, 0.0002, 0.00000002, 0.000002,
4629  0.0002, 0.001, 0.0002, 0.001,
4630  0.01,0.01
4631  };
4632  TString thisParName[] = { "Pt res. sc.", "Pt res. Pt sc.", "Pt res. Eta sc.", "Pt res. Eta^2 sc.",
4633  "Cth res. sc.", "Cth res. 1/Pt sc.", "Cth res. Eta sc.", "Cth res. Eta^2 sc.",
4634  "Phi res. sc.", "Phi res. 1/Pt sc.", "Phi res. Eta sc.", "Phi res. Eta^2 sc.",
4635  "Pt res. Eta^2 sc./offset (right)","Pt res. Eta^2 sc.(left)","Pt res. Eta^2 sc./offset (right)","Pt res. Eta^2 sc.(left)",
4636  "floating point right","floating poin left"
4637  };
4638  double thisMini[] = { 0.0, -0.01, -0.001, -0.0001,
4639  0.0, -0.001, -0.001, -0.00001,
4640  0.0, -0.001, -0.0001, -0.0001,
4641  -0.0001, 0.01, -0.0001, 0.01,
4642  -2.,0.
4643  };
4644  if( muonType == 1 ) {
4645  double thisMaxi[] = { 1., 1., 1., 1.,
4646  1., 1., 1., 0.1,
4647  1., 1., 1., 1.,
4648  1., 1. ,1. ,1.,
4649  1.,1.
4650  };
4651  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4652  } else {
4653  double thisMaxi[] = { 0.1, 0.01, 0.01, 0.1,
4654  0.01, 0.01, 0.1, 0.01,
4655  0.01, 0.01, 0.01, 0.01,
4656  0.1, 1.99, 0.1, 1.99,
4657  0.,2.
4658 
4659  };
4660  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, thisStep, thisMini, thisMaxi, thisParName );
4661  }
4662  }
4663 };
4664 
4665 
4666 
4667 
4668 
4669 
4670 
4671 //------------------------ 4Nov and 22 Dec data/MC Zmumu (36/pb) -- 3 parabolas (for MU-10-004) ---------
4672 template <class T>
4673 class resolutionFunctionType42 : public resolutionFunctionBase<T> {
4674  public:
4675  resolutionFunctionType42() { this->parNum_ = 15; }
4676 
4677  inline double centralParabola(const double & pt, const double & eta, const T & parval)
4678  {
4679  return( parval[0]+parval[1]*pt + parval[14]*pt*pt + parval[2]*std::fabs(eta) + parval[3]*eta*eta );
4680  }
4681  inline double leftParabola(const double & pt, const double & eta, const T & parval)
4682  {
4683  return( parval[1]*pt + parval[14]*pt*pt + parval[5]*fabs(eta-parval[7]) +
4684  parval[6]*(eta-parval[7])*(eta-parval[7]) );
4685  }
4686  inline double rightParabola(const double & pt, const double & eta, const T & parval)
4687  {
4688  return( parval[1]*pt + parval[14]*pt*pt + parval[9]*fabs(eta-parval[11]) +
4689  parval[10]*(eta-parval[11])*(eta-parval[11]) );
4690  }
4691 
4692  // linear in pt and quadratic in eta
4693  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
4694  //double fabsEta = std::fabs(eta);
4695  if(eta>=parval[12] && eta<=parval[13]){
4696  return centralParabola(pt, eta, parval);
4697  }
4698  else if(eta<parval[12]) { //eta in left endcap
4699  return( centralParabola(pt, parval[12], parval) - leftParabola(pt, parval[12], parval) + leftParabola(pt, eta, parval) );
4700  }
4701  // std::cout << "parval[13] = " << parval[13] << ", eta = " << eta << std::endl;
4702  return( centralParabola(pt, parval[13], parval) - rightParabola(pt, parval[13], parval) + rightParabola(pt, eta, parval) );
4703  }
4704  // 1/pt in pt and quadratic in eta
4705  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
4706  return 0;
4707  //0.00035 + eta*eta*0.00015; // fixed from MC (Mar. 2011)
4708  }
4709  // 1/pt in pt and quadratic in eta
4710  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
4711  return 0.;
4712  }
4713 
4714  // derivatives ---------------
4715 
4716  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4717  {
4718  double fabsEta = std::fabs(eta);
4719  if( eta >= parval[12] && eta <= parval[13] ) {
4720  return sqrt( pow(parError[0], 2) + pow(pt*parError[1], 2) + pow(pt*pt*parError[14], 2) + pow(fabsEta*parError[2], 2) + pow(eta*eta*parError[3], 2));
4721  }
4722  else if( eta < parval[12] ) {
4723  double sign1 = 1;
4724  // if( parval[12] < parval[7] ) sign1 = -1;
4725  double sign2 = 1;
4726  if( eta < parval[7] ) sign2 = -1;
4727  double sign3 = 1;
4728  if( parval[12] < 0 ) sign3 = -1; // This should be always true
4729 
4730  return(sqrt(pow(parError[0],2) + // parval[0]
4731  pow(pt*parError[1], 2) + // parval[1]
4732  pow(parval[12]*parError[2], 2) + // parval[2]
4733  pow(parval[12]*parval[12]*parError[3], 2) + // parval[3]
4734  pow((-fabs(parval[12]-parval[7])+fabs(eta-parval[7]))*parError[5], 2) + // parval[5]
4735  pow((- pow(parval[12]-parval[7], 2) + pow(eta-parval[7], 2))*parError[6], 2) + // parval[6]
4736  pow((sign1*parval[5] + 2*(parval[12]-parval[7])*parval[6] - sign2*parval[5] + - 2*(eta-parval[7])*parval[6])*parError[7], 2) +
4737  pow((sign3*parval[2] + 2*parval[12]*parval[3] - sign1*parval[5] - 2*(parval[12]-parval[7])*parval[6])*parError[12], 2) + // parval[12]
4738  pow(pt*pt*parError[14], 2)) );
4739 
4740 /* return sqrt( pow(parError[4], 2) + pow(pt*parError[1], 2) + pow(pt*pt*parError[14], 2) +
4741  pow((fabsEta-parval[7])*parError[5], 2) +
4742  pow(pow(fabsEta-parval[7], 2)*parError[6], 2) +
4743  pow(-parval[5] - 2*parval[6]*(fabsEta - parval[7]), 2)*pow(parError[7], 2) );*/
4744  }
4745 
4746  double sign1 = 1;
4747  // if( parval[13] < parval[11] ) sign1 = -1;
4748  double sign2 = 1;
4749  if( eta < parval[11] ) sign2 = -1;
4750  double sign3 = 1;
4751  if( parval[13] < 0 ) sign3 = -1; // This should never be true
4752 
4753  return(sqrt(pow(parError[0],2) + // parval[0]
4754  pow(pt*parError[1], 2) + // parval[1]
4755  pow(parval[13]*parError[2], 2) + // parval[2]
4756  pow(parval[13]*parval[13]*parError[3], 2) + // parval[3]
4757  pow((-fabs(parval[13]-parval[11])+fabs(eta-parval[11]))*parError[9], 2) + // parval[9]
4758  pow((- pow(parval[13]-parval[11], 2) + pow(eta-parval[11], 2))*parError[10], 2) + // parval[10]
4759  pow((sign1*parval[9] + 2*(parval[13]-parval[11])*parval[10] - sign2*parval[9] + - 2*(eta-parval[11])*parval[10])*parError[11], 2) + // parval[11]
4760  pow((sign3*parval[2] + 2*parval[13]*parval[3] - sign1*parval[9] - 2*(parval[13]-parval[11])*parval[10])*parError[13], 2) + // parval[13]
4761  pow(pt*pt*parError[14], 2)) );
4762  }
4763 
4764  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
4765  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
4766  const int muonType)
4767  {
4768  std::vector<ParameterSet> parSet(this->parNum_);
4769  // name, step, mini, maxi
4770  parSet[0] = ParameterSet( "Pt res. sc.", 0.002, -0.1, 0.1 );
4771  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", 0.00002, -0.01, 0.01 );
4772  parSet[2] = ParameterSet( "Pt res. Eta sc.", 0.000002, 0., 0.01 );
4773  parSet[3] = ParameterSet( "Pt res. Eta^2 sc.", 0.0002, -0.01, 0.02 );
4774  parSet[4] = ParameterSet( "Pt res. sc. (left)", 0.00002, 0., 0.01 );
4775  parSet[5] = ParameterSet( "Pt res. Eta sc. (left)", 0.0002, 0., 0.2 );
4776  parSet[6] = ParameterSet( "Pt res. Eta^2 sc. (left)", 0.0000002, -0.2, 0.5 );
4777  parSet[7] = ParameterSet( "Pt res. Eta^2 sc./offset (left)", 0.0002, -2.2, -0.8 );
4778  parSet[8] = ParameterSet( "Pt res. sc. (right)", 0.00002, 0., 0.01 );
4779  parSet[9] = ParameterSet( "Pt res. Eta sc. (right)", 0.0002, -0.2, 0.1 );
4780  parSet[10] = ParameterSet( "Pt res. Eta^2 sc. (right)", 0.000002, -0.1, 0.5 );
4781  parSet[11] = ParameterSet( "Pt res. Eta^2 sc./offset (right)", 0.0002, 0., 3. );
4782  parSet[12] = ParameterSet( "floating point left", 0.001, -2.2, -1.6 );
4783  parSet[13] = ParameterSet( "floating point right", 0.001, 1., 2.2 );
4784  parSet[14] = ParameterSet( "pt^2 sc.", 0.0001, 0., 0.01 );
4785 
4786  std::cout << "setting parameters" << std::endl;
4787  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4788  }
4789 
4790  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
4791  const T & parResol, const std::vector<int> & parResolOrder,
4792  const std::vector<double> & parStep,
4793  const std::vector<double> & parMin,
4794  const std::vector<double> & parMax,
4795  const int muonType)
4796  {
4797  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
4798  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
4799  exit(1);
4800  }
4801  std::vector<ParameterSet> parSet(this->parNum_);
4802  // name, step, mini, maxi
4803  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
4804  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", parStep[1], parMin[1], parMax[1] );
4805  parSet[2] = ParameterSet( "Pt res. Eta sc.", parStep[2], parMin[2], parMax[2] );
4806  parSet[3] = ParameterSet( "Pt res. Eta^2 sc.", parStep[3], parMin[3], parMax[3] );
4807  parSet[4] = ParameterSet( "Pt res. sc. (left)", parStep[4], parMin[4], parMax[4] );
4808  parSet[5] = ParameterSet( "Pt res. Eta sc. (left)", parStep[5], parMin[5], parMax[5] );
4809  parSet[6] = ParameterSet( "Pt res. Eta^2 sc. (left)", parStep[6], parMin[6], parMax[6] );
4810  parSet[7] = ParameterSet( "Pt res. Eta^2 sc./offset (left)", parStep[7], parMin[7], parMax[7] );
4811  parSet[8] = ParameterSet( "Pt res. sc. (right)", parStep[8], parMin[8], parMax[8] );
4812  parSet[9] = ParameterSet( "Pt res. Eta sc. (right)", parStep[9], parMin[9], parMax[9] );
4813  parSet[10] = ParameterSet( "Pt res. Eta^2 sc. (right)", parStep[10], parMin[10], parMax[10] );
4814  parSet[11] = ParameterSet( "Pt res. Eta^2 sc./offset (right)", parStep[11], parMin[11], parMax[11] );
4815  parSet[12] = ParameterSet( "floating point left", parStep[12], parMin[12], parMax[12] );
4816  parSet[13] = ParameterSet( "floating point right", parStep[13], parMin[13], parMax[13] );
4817  parSet[14] = ParameterSet( "pt^2 sc.", parStep[14], parMin[14], parMax[14] );
4818 
4819  std::cout << "setting parameters" << std::endl;
4820  for( int i=0; i<this->parNum_; ++i ) {
4821  std::cout << "parStep["<<i<<"] = " << parStep[i]
4822  << ", parMin["<<i<<"] = " << parMin[i]
4823  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
4824  }
4825  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
4826  }
4827 };
4828 
4829 
4830 
4831 //------------------------ 4Nov and 22 Dec data/MC Zmumu (36/pb) -- 3 parabolas (for MU-10-004) ---------
4832 template <class T>
4833 class resolutionFunctionType43 : public resolutionFunctionBase<T> {
4834  public:
4835  resolutionFunctionType43() { this->parNum_ = 17; }
4836 
4837  inline double centralParabola(const double & pt, const double & eta, const T & parval)
4838  {
4839  return( parval[0]+parval[1]*pt + parval[14]*pt*pt + parval[2]*std::fabs(eta)+parval[3]*eta*eta );
4840  }
4841  inline double leftParabola(const double & pt, const double & eta, const T & parval)
4842  {
4843  return( parval[0] + fabs(parval[12])*parval[2] + parval[12]*parval[12]*parval[3] -
4844  parval[5]*fabs(parval[12]-parval[7]) -
4845  parval[6]*(parval[12]-parval[7])*(parval[12]-parval[7]) +
4846  parval[1]*pt + parval[14]*pt*pt + parval[5]*fabs(eta-parval[7]) +
4847  parval[6]*(eta-parval[7])*(eta-parval[7]) );
4848  }
4849  inline double rightParabola(const double & pt, const double & eta, const T & parval)
4850  {
4851  return( parval[0] + fabs(parval[13])*parval[2] + parval[13]*parval[13]*parval[3] -
4852  parval[9]*fabs(parval[13]-parval[11]) -
4853  parval[10]*(parval[13]-parval[11])*(parval[13]-parval[11]) +
4854  parval[1]*pt + parval[14]*pt*pt + parval[9]*fabs(eta-parval[11]) +
4855  parval[10]*(eta-parval[11])*(eta-parval[11]) );
4856  }
4857  inline double leftLine(const double & pt, const double & eta, const T & parval)
4858  {
4859  double x_1 = parval[15];
4860  double y_1 = centralParabola(pt, parval[15], parval);
4861  double x_2 = parval[12];
4862  double y_2 = leftParabola(pt, parval[12], parval);
4863  return( (eta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1 );
4864  }
4865  inline double rightLine(const double & pt, const double & eta, const T & parval)
4866  {
4867  double x_1 = parval[16];
4868  double y_1 = centralParabola(pt, parval[16], parval);
4869  double x_2 = parval[13];
4870  double y_2 = rightParabola(pt, parval[13], parval);
4871  return( (eta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1 );
4872  }
4873 
4874  // linear in pt and quadratic in eta
4875  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
4876  {
4877  //double fabsEta = std::fabs(eta);
4878  if(eta>=parval[15] && eta<=parval[16]){
4879  return centralParabola(pt, eta, parval);
4880  }
4881  // Return a line connecting the two parabolas
4882  else if( (eta >= parval[12]) && (eta < parval[15]) ) {
4883  return leftLine(pt, eta, parval);
4884  }
4885  else if( eta < parval[12] ){ //eta in left endcap
4886  return leftParabola(pt, eta, parval);
4887  }
4888  // Return a line connecting the two parabolas
4889  else if( (eta > parval[16]) && (eta <= parval[13]) ) {
4890  return rightLine(pt, eta, parval);
4891  }
4892  return rightParabola(pt, eta, parval);
4893  }
4894 
4895  // 1/pt in pt and quadratic in eta
4896  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval)
4897  {
4898  return 0;
4899  //0.00035 + eta*eta*0.00015; // fixed from MC (Mar. 2011)
4900  }
4901  // 1/pt in pt and quadratic in eta
4902  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval)
4903  {
4904  return 0.;
4905  }
4906 
4907  // derivatives ---------------
4908  inline double centralParabolaError(const double & pt, const double & eta, const T & parval, const T & parError)
4909  {
4910  double fabsEta = std::fabs(eta);
4911  return sqrt( pow(parError[0], 2) + pow(pt*parError[1], 2) + pow(pt*pt*parError[14], 2) + pow(fabsEta*parError[2], 2) + pow(eta*eta*parError[3], 2));
4912  }
4913 
4914  inline double leftParabolaError(const double & pt, const double & eta, const T & parval, const T & parError)
4915  {
4916  double sign1 = 1;
4917  if( parval[12] < parval[7] ) sign1 = -1;
4918  double sign2 = 1;
4919  if( eta < parval[7] ) sign2 = -1;
4920  double sign3 = 1;
4921  if( parval[12] < 0 ) sign3 = -1; // This should be always true
4922 
4923  return(sqrt(pow(parError[0],2) + // parval[0]
4924  pow(pt*parError[1], 2) + // parval[1]
4925  pow(parval[12]*parError[2], 2) + // parval[2]
4926  pow(parval[12]*parval[12]*parError[3], 2) + // parval[3]
4927  pow((-fabs(parval[12]-parval[7])+fabs(eta-parval[7]))*parError[5], 2) + // parval[5]
4928  pow((- pow(parval[12]-parval[7], 2) + pow(eta-parval[7], 2))*parError[6], 2) + // parval[6]
4929  pow((sign1*parval[5] + 2*(parval[12]-parval[7])*parval[6] - sign2*parval[5] + - 2*(eta-parval[7])*parval[6])*parError[7], 2) +
4930  pow((sign3*parval[2] + 2*parval[12]*parval[3] - sign1*parval[5] - 2*(parval[12]-parval[7])*parval[6])*parError[12], 2) + // parval[12]
4931  pow(pt*pt*parError[14], 2)) );
4932  }
4933 
4934  inline double rightParabolaError(const double & pt, const double & eta, const T & parval, const T & parError) {
4935  double sign1 = 1;
4936  if( parval[13] < parval[11] ) sign1 = -1;
4937  double sign2 = 1;
4938  if( eta < parval[11] ) sign2 = -1;
4939  double sign3 = 1;
4940  if( parval[13] < 0 ) sign3 = -1; // This should never be true
4941 
4942  return(sqrt(pow(parError[0],2) + // parval[0]
4943  pow(pt*parError[1], 2) + // parval[1]
4944  pow(parval[13]*parError[2], 2) + // parval[2]
4945  pow(parval[13]*parval[13]*parError[3], 2) + // parval[3]
4946  pow((-fabs(parval[13]-parval[11])+fabs(eta-parval[11]))*parError[9], 2) + // parval[9]
4947  pow((- pow(parval[13]-parval[11], 2) + pow(eta-parval[11], 2))*parError[10], 2) + // parval[10]
4948  pow((sign1*parval[9] + 2*(parval[13]-parval[11])*parval[10] - sign2*parval[9] + - 2*(eta-parval[11])*parval[10])*parError[11], 2) + // parval[11]
4949  pow((sign3*parval[2] + 2*parval[13]*parval[3] - sign1*parval[9] - 2*(parval[13]-parval[11])*parval[10])*parError[13], 2) + // parval[13]
4950  pow(pt*pt*parError[14], 2)) );
4951  }
4952 
4953  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
4954  {
4955  // double fabsEta = std::fabs(eta);
4956  if( eta >= parval[15] && eta <= parval[16] ) {
4957  return centralParabolaError(pt, eta, parval, parError);
4958  }
4959  else if( (eta >= parval[12]) && (eta < parval[15]) ) {
4960  double lineValue = leftLine(pt, eta, parval);
4961 
4962  double x_1 = parval[15];
4963  double y_1 = centralParabola(pt, parval[15], parval) + centralParabolaError(pt, parval[15], parval, parError);
4964  double x_2 = parval[12];
4965  double y_2 = leftParabola(pt, parval[12], parval) + leftParabolaError(pt, parval[12], parval, parError);
4966  double lineValuePlusError = (eta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1;
4967 
4968  return( lineValuePlusError - lineValue );
4969  }
4970  else if( eta < parval[12] ) {
4971  return leftParabolaError(pt, eta, parval, parError);
4972  }
4973  else if( (eta > parval[16]) && (eta <= parval[13]) ) {
4974  double lineValue = rightLine(pt, eta, parval);
4975 
4976  double x_1 = parval[16];
4977  double y_1 = centralParabola(pt, parval[16], parval) + centralParabolaError(pt, parval[16], parval, parError);
4978  double x_2 = parval[13];
4979  double y_2 = rightParabola(pt, parval[13], parval) + leftParabolaError(pt, parval[13], parval, parError);
4980  double lineValuePlusError = (eta - x_1)*(y_2 - y_1)/(x_2 - x_1) + y_1;
4981 
4982  return( lineValuePlusError - lineValue );
4983  }
4984  return rightParabolaError(pt, eta, parval, parError);
4985  }
4986 
4987  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
4988  {
4989  std::vector<ParameterSet> parSet(this->parNum_);
4990  // name, step, mini, maxi
4991  parSet[0] = ParameterSet( "Pt res. sc.", 0.002, 0., 0.1 );
4992  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", 0.00002, -0.01, 0.01 );
4993  parSet[2] = ParameterSet( "Pt res. Eta sc. central", 0.000002, 0., 0.01 );
4994  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. central", 0.0002, -0.0001, 0.1 );
4995  parSet[4] = ParameterSet( "Not used", 0.00002, 0., 0.01 );
4996  parSet[5] = ParameterSet( "Pt res. Eta sc. (left)", 0.0002, -0.01, 0.1 );
4997  parSet[6] = ParameterSet( "Pt res. Eta^2 sc. (left)", 0.0000002, 0., 1. );
4998  parSet[7] = ParameterSet( "Pt res. Eta^2 sc./offset (left)", 0.0002, -2., 0. );
4999  parSet[8] = ParameterSet( "Not used", 0.00002, 0., 0.01 );
5000  parSet[9] = ParameterSet( "Pt res. Eta sc. (right)", 0.0002, -0.01, 0.1 );
5001  parSet[10] = ParameterSet( "Pt res. Eta^2 sc. (right)", 0.0000002, -1., 1. );
5002  parSet[11] = ParameterSet( "Pt res. Eta^2 sc./offset (right)", 0.0002, 0., 2. );
5003  parSet[12] = ParameterSet( "floating point left", 0.001, -2., 1. );
5004  parSet[13] = ParameterSet( "floating point right", 0.001, 1., 3. );
5005  parSet[14] = ParameterSet( "pt^2 sc.", 0.0001, 0., 0.01 );
5006  parSet[15] = ParameterSet( "left line point", 0.001, -2., 0.8 );
5007  parSet[16] = ParameterSet( "right line point", 0.001, 0.8, 2. );
5008 
5009  std::cout << "setting parameters" << std::endl;
5010  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5011  }
5012 
5013  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5014  const T & parResol, const std::vector<int> & parResolOrder,
5015  const std::vector<double> & parStep,
5016  const std::vector<double> & parMin,
5017  const std::vector<double> & parMax,
5018  const int muonType)
5019  {
5020  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5021  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5022  exit(1);
5023  }
5024  std::vector<ParameterSet> parSet(this->parNum_);
5025  // name, step, mini, maxi
5026  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5027  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", parStep[1], parMin[1], parMax[1] );
5028  parSet[2] = ParameterSet( "Pt res. Eta sc. central", parStep[2], parMin[2], parMax[2] );
5029  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. central", parStep[3], parMin[3], parMax[3] );
5030  parSet[4] = ParameterSet( "Not used", parStep[4], parMin[4], parMax[4] );
5031  parSet[5] = ParameterSet( "Pt res. Eta sc. (left)", parStep[5], parMin[5], parMax[5] );
5032  parSet[6] = ParameterSet( "Pt res. Eta^2 sc. (left)", parStep[6], parMin[6], parMax[6] );
5033  parSet[7] = ParameterSet( "Pt res. Eta^2 sc./offset (left)", parStep[7], parMin[7], parMax[7] );
5034  parSet[8] = ParameterSet( "Not used", parStep[8], parMin[8], parMax[8] );
5035  parSet[9] = ParameterSet( "Pt res. Eta sc. (right)", parStep[9], parMin[9], parMax[9] );
5036  parSet[10] = ParameterSet( "Pt res. Eta^2 sc. (right)", parStep[10], parMin[10], parMax[10] );
5037  parSet[11] = ParameterSet( "Pt res. Eta^2 sc./offset (right)", parStep[11], parMin[11], parMax[11] );
5038  parSet[12] = ParameterSet( "floating point left", parStep[12], parMin[12], parMax[12] );
5039  parSet[13] = ParameterSet( "floating point right", parStep[13], parMin[13], parMax[13] );
5040  parSet[14] = ParameterSet( "pt^2 sc.", parStep[14], parMin[14], parMax[14] );
5041  parSet[15] = ParameterSet( "left line point", parStep[15], parMin[15], parMax[15] );
5042  parSet[16] = ParameterSet( "right line point", parStep[16], parMin[16], parMax[16] );
5043 
5044  std::cout << "setting parameters" << std::endl;
5045  for( int i=0; i<this->parNum_; ++i ) {
5046  std::cout << "parStep["<<i<<"] = " << parStep[i]
5047  << ", parMin["<<i<<"] = " << parMin[i]
5048  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5049  }
5050  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5051  }
5052 };
5053 
5054 
5055 
5056 
5057 // Binned in eta to fit the Z (parametrization as linear sum)
5058 template <class T>
5059 class resolutionFunctionType45 : public resolutionFunctionBase<T> {
5060  public:
5061  int etaBin(const double & eta)
5062  {
5063  // 24 bins from -2.4 to 2.4
5064  // std::cout << "for eta = " << eta << ", bin = " << bin << std::endl;
5065 
5066  if( eta < -2.0 ) return 1;
5067  if( eta < -1.8 ) return 2;
5068  if( eta < -1.6 ) return 3;
5069  if( eta < -1.2 ) return 4;
5070  if( eta < -0.8 ) return 5;
5071  if( eta < 0. ) return 6;
5072  if( eta < 0.8 ) return 7;
5073  if( eta < 1.2 ) return 8;
5074  if( eta < 1.6 ) return 9;
5075  if( eta < 1.8 ) return 10;
5076  if( eta < 2.0 ) return 11;
5077  return 12;
5078  }
5079 
5080  // resolutionFunctionType45() { this->parNum_ = 21; }
5081  resolutionFunctionType45() { this->parNum_ = 13; }
5082  // linear in pt and quadratic in eta
5083  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
5084  {
5085  // std::cout << "parval["<<etaBin(eta)<<"] = " << parval[etaBin(eta)] << std::endl;
5086 
5087  if( eta < -2.0 ) return( parval[0]*pt + parval[1] );
5088  if( eta < -1.8 ) return( parval[0]*pt + parval[2] );
5089  if( eta < -1.6 ) return( parval[0]*pt + parval[3] );
5090  if( eta < -1.2 ) return( parval[0]*pt + parval[4] );
5091  if( eta < -0.8 ) return( parval[0]*pt + parval[5] );
5092  if( eta < 0. ) return( parval[0]*pt + parval[6] );
5093  if( eta < 0.8 ) return( parval[0]*pt + parval[7] );
5094  if( eta < 1.2 ) return( parval[0]*pt + parval[8] );
5095  if( eta < 1.6 ) return( parval[0]*pt + parval[9] );
5096  if( eta < 1.8 ) return( parval[0]*pt + parval[10] );
5097  if( eta < 2.0 ) return( parval[0]*pt + parval[11] );
5098  return( parval[0]*pt + parval[12] );
5099 
5100  }
5101  // 1/pt in pt and quadratic in eta
5102  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
5103  return 0;
5104  //0.00035 + eta*eta*0.00015; // fixed from MC (Mar. 2011)
5105  }
5106  // 1/pt in pt and quadratic in eta
5107  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
5108  return 0.;
5109  }
5110 
5111  // derivatives ---------------
5112 
5113  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
5114  {
5115  // Use the etaByPoints function to select the right bin for the parameter
5116  return sqrt( pow(pt*parError[0], 2) + pow(parError[etaBin(eta)], 2));
5117  }
5118 
5119  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
5120  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
5121  const int muonType)
5122  {
5123  std::vector<ParameterSet> parSet(this->parNum_);
5124  // name, step, mini, maxi
5125  parSet[0] = ParameterSet( "Pt res. sc.", 0.002, -0.1, 0.1 );
5126  parSet[1] = ParameterSet( "eta bin 1", 0.00002, -0.01, 0.01 );
5127  parSet[2] = ParameterSet( "eta bin 2", 0.00002, -0.01, 0.01 );
5128  parSet[3] = ParameterSet( "eta bin 3", 0.00002, -0.01, 0.01 );
5129  parSet[4] = ParameterSet( "eta bin 4", 0.00002, -0.01, 0.01 );
5130  parSet[5] = ParameterSet( "eta bin 5", 0.00002, -0.01, 0.01 );
5131  parSet[6] = ParameterSet( "eta bin 6", 0.00002, -0.01, 0.01 );
5132  parSet[7] = ParameterSet( "eta bin 7", 0.00002, -0.01, 0.01 );
5133  parSet[8] = ParameterSet( "eta bin 8", 0.00002, -0.01, 0.01 );
5134  parSet[9] = ParameterSet( "eta bin 9", 0.00002, -0.01, 0.01 );
5135  parSet[10] = ParameterSet( "eta bin 10", 0.00002, -0.01, 0.01 );
5136  parSet[11] = ParameterSet( "eta bin 11", 0.00002, -0.01, 0.01 );
5137  parSet[12] = ParameterSet( "eta bin 12", 0.00002, -0.01, 0.01 );
5138 
5139 
5140  std::cout << "setting parameters" << std::endl;
5141  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5142  }
5143 
5144  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5145  const T & parResol, const std::vector<int> & parResolOrder,
5146  const std::vector<double> & parStep,
5147  const std::vector<double> & parMin,
5148  const std::vector<double> & parMax,
5149  const int muonType)
5150  {
5151  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5152  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5153  std::cout << "parNum = " << this->parNum_ << std::endl;
5154  std::cout << "parStep.size() = " << parStep.size() << std::endl;
5155  std::cout << "parMin.size() = " << parMin.size() << std::endl;
5156  std::cout << "parMax.size() = " << parMax.size() << std::endl;
5157  exit(1);
5158  }
5159  std::vector<ParameterSet> parSet(this->parNum_);
5160  // name, step, mini, maxi
5161  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5162  parSet[1] = ParameterSet( "eta bin 1", parStep[1], parMin[1], parMax[1] );
5163  parSet[2] = ParameterSet( "eta bin 2", parStep[2], parMin[2], parMax[2] );
5164  parSet[3] = ParameterSet( "eta bin 3", parStep[3], parMin[3], parMax[3] );
5165  parSet[4] = ParameterSet( "eta bin 4", parStep[4], parMin[4], parMax[4] );
5166  parSet[5] = ParameterSet( "eta bin 5", parStep[5], parMin[5], parMax[5] );
5167  parSet[6] = ParameterSet( "eta bin 6", parStep[6], parMin[6], parMax[6] );
5168  parSet[7] = ParameterSet( "eta bin 7", parStep[7], parMin[7], parMax[7] );
5169  parSet[8] = ParameterSet( "eta bin 8", parStep[8], parMin[8], parMax[8] );
5170  parSet[9] = ParameterSet( "eta bin 9", parStep[9], parMin[9], parMax[9] );
5171  parSet[10] = ParameterSet( "eta bin 10", parStep[10], parMin[10], parMax[10] );
5172  parSet[11] = ParameterSet( "eta bin 11", parStep[11], parMin[11], parMax[11] );
5173  parSet[12] = ParameterSet( "eta bin 12", parStep[12], parMin[12], parMax[12] );
5174 
5175  std::cout << "setting parameters" << std::endl;
5176  for( int i=0; i<this->parNum_; ++i ) {
5177  std::cout << "parStep["<<i<<"] = " << parStep[i]
5178  << ", parMin["<<i<<"] = " << parMin[i]
5179  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5180  }
5181  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5182  }
5183 };
5184 
5185 
5186 
5187 
5188 // Binned in eta to fit the Z (parametrization as sum in quadrature)
5189 template <class T>
5190 class resolutionFunctionType46 : public resolutionFunctionBase<T> {
5191  public:
5192  int etaBin(const double & eta)
5193  {
5194  // 24 bins from -2.4 to 2.4
5195  // std::cout << "for eta = " << eta << ", bin = " << bin << std::endl;
5196 
5197  if( eta < -2.0 ) return 1;
5198  if( eta < -1.8 ) return 2;
5199  if( eta < -1.6 ) return 3;
5200  if( eta < -1.2 ) return 4;
5201  if( eta < -0.8 ) return 5;
5202  if( eta < 0. ) return 6;
5203  if( eta < 0.8 ) return 7;
5204  if( eta < 1.2 ) return 8;
5205  if( eta < 1.6 ) return 9;
5206  if( eta < 1.8 ) return 10;
5207  if( eta < 2.0 ) return 11;
5208  return 12;
5209  }
5210 
5211  // resolutionFunctionType46() { this->parNum_ = 21; }
5212  resolutionFunctionType46() { this->parNum_ = 13; }
5213 
5214  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
5215  {
5216  // std::cout << "parval["<<etaBin(eta)<<"] = " << parval[etaBin(eta)] << std::endl;
5217  return sqrt(pow(parval[0]*pt,2) + pow(parval[etaBin(eta)],2));
5218  }
5219  //
5220  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
5221  return 0;
5222  }
5223  //
5224  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
5225  return 0.;
5226  }
5227 
5228  // derivatives ---------------
5229 
5230  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
5231  {
5232  // Use the etaByPoints function to select the right bin for the parameter
5233  double r = sqrt(pow(parval[0]*pt,2) + pow(parval[etaBin(eta)],2));
5234  return sqrt( pow(pt*pt*parval[0]*parError[0],2) + pow(parval[etaBin(eta)]*parError[etaBin(eta)],2) )/r;
5235  }
5236 
5237  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
5238  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
5239  const int muonType)
5240  {
5241  std::vector<ParameterSet> parSet(this->parNum_);
5242  // name, step, mini, maxi
5243  parSet[0] = ParameterSet( "Pt res. sc.", 0.0002, 0., 0.1 );
5244  parSet[1] = ParameterSet( "eta bin 1", 0.00002, 0., 0.01 );
5245  parSet[2] = ParameterSet( "eta bin 2", 0.00002, 0., 0.01 );
5246  parSet[3] = ParameterSet( "eta bin 3", 0.00002, 0., 0.01 );
5247  parSet[4] = ParameterSet( "eta bin 4", 0.00002, 0., 0.01 );
5248  parSet[5] = ParameterSet( "eta bin 5", 0.00002, 0., 0.01 );
5249  parSet[6] = ParameterSet( "eta bin 6", 0.00002, 0., 0.01 );
5250  parSet[7] = ParameterSet( "eta bin 7", 0.00002, 0., 0.01 );
5251  parSet[8] = ParameterSet( "eta bin 8", 0.00002, 0., 0.01 );
5252  parSet[9] = ParameterSet( "eta bin 9", 0.00002, 0., 0.01 );
5253  parSet[10] = ParameterSet( "eta bin 10", 0.00002, 0., 0.01 );
5254  parSet[11] = ParameterSet( "eta bin 11", 0.00002, 0., 0.01 );
5255  parSet[12] = ParameterSet( "eta bin 12", 0.00002, 0., 0.01 );
5256 
5257 
5258  std::cout << "setting parameters" << std::endl;
5259  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5260  }
5261 
5262  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5263  const T & parResol, const std::vector<int> & parResolOrder,
5264  const std::vector<double> & parStep,
5265  const std::vector<double> & parMin,
5266  const std::vector<double> & parMax,
5267  const int muonType)
5268  {
5269  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5270  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5271  std::cout << "parNum = " << this->parNum_ << std::endl;
5272  std::cout << "parStep.size() = " << parStep.size() << std::endl;
5273  std::cout << "parMin.size() = " << parMin.size() << std::endl;
5274  std::cout << "parMax.size() = " << parMax.size() << std::endl;
5275  exit(1);
5276  }
5277  std::vector<ParameterSet> parSet(this->parNum_);
5278  // name, step, mini, maxi
5279  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5280  parSet[1] = ParameterSet( "eta bin 1", parStep[1], parMin[1], parMax[1] );
5281  parSet[2] = ParameterSet( "eta bin 2", parStep[2], parMin[2], parMax[2] );
5282  parSet[3] = ParameterSet( "eta bin 3", parStep[3], parMin[3], parMax[3] );
5283  parSet[4] = ParameterSet( "eta bin 4", parStep[4], parMin[4], parMax[4] );
5284  parSet[5] = ParameterSet( "eta bin 5", parStep[5], parMin[5], parMax[5] );
5285  parSet[6] = ParameterSet( "eta bin 6", parStep[6], parMin[6], parMax[6] );
5286  parSet[7] = ParameterSet( "eta bin 7", parStep[7], parMin[7], parMax[7] );
5287  parSet[8] = ParameterSet( "eta bin 8", parStep[8], parMin[8], parMax[8] );
5288  parSet[9] = ParameterSet( "eta bin 9", parStep[9], parMin[9], parMax[9] );
5289  parSet[10] = ParameterSet( "eta bin 10", parStep[10], parMin[10], parMax[10] );
5290  parSet[11] = ParameterSet( "eta bin 11", parStep[11], parMin[11], parMax[11] );
5291  parSet[12] = ParameterSet( "eta bin 12", parStep[12], parMin[12], parMax[12] );
5292 
5293  std::cout << "setting parameters" << std::endl;
5294  for( int i=0; i<this->parNum_; ++i ) {
5295  std::cout << "parStep["<<i<<"] = " << parStep[i]
5296  << ", parMin["<<i<<"] = " << parMin[i]
5297  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5298  }
5299  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5300  }
5301 };
5302 
5303 
5304 // Binned in eta to fit the Z (parametrization as sum in quadrature) and including an overall covariance
5305 template <class T>
5306 class resolutionFunctionType47 : public resolutionFunctionBase<T> {
5307  public:
5308  int etaBin(const double & eta)
5309  {
5310  // 24 bins from -2.4 to 2.4
5311  // std::cout << "for eta = " << eta << ", bin = " << bin << std::endl;
5312 
5313  if( eta < -2.0 ) return 1;
5314  if( eta < -1.8 ) return 2;
5315  if( eta < -1.6 ) return 3;
5316  if( eta < -1.2 ) return 4;
5317  if( eta < -0.8 ) return 5;
5318  if( eta < 0. ) return 6;
5319  if( eta < 0.8 ) return 7;
5320  if( eta < 1.2 ) return 8;
5321  if( eta < 1.6 ) return 9;
5322  if( eta < 1.8 ) return 10;
5323  if( eta < 2.0 ) return 11;
5324  return 12;
5325  }
5326 
5327  // resolutionFunctionType47() { this->parNum_ = 21; }
5328  resolutionFunctionType47() { this->parNum_ = 14; }
5329 
5330  virtual double sigmaPt(const double & pt, const double & eta, const T & parval)
5331  {
5332  // std::cout << "parval["<<etaBin(eta)<<"] = " << parval[etaBin(eta)] << std::endl;
5333  return sqrt(pow(parval[0]*pt,2) + pow(parval[etaBin(eta)],2) + pow(parval[13],2));
5334  }
5335  //
5336  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
5337  return 0;
5338  }
5339  //
5340  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
5341  return 0.;
5342  }
5343 
5344  virtual double covPt1Pt2(const double & pt1, const double & eta1, const double & pt2, const double & eta2, const T & parval)
5345  {
5346  return parval[14];
5347  }
5348 
5349  // derivatives ---------------
5350 
5351  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
5352  {
5353  // Use the etaByPoints function to select the right bin for the parameter
5354  double r = sqrt(pow(parval[0]*pt,2) + pow(parval[etaBin(eta)],2) + pow(parval[13],2));
5355  return sqrt( pow(pt*pt*parval[0]*parError[0],2) + pow(parval[etaBin(eta)]*parError[etaBin(eta)],2) + pow(parval[13]*parError[13],2) )/r;
5356  }
5357 
5358  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind,
5359  TString* parname, const T & parResol, const std::vector<int> & parResolOrder,
5360  const int muonType)
5361  {
5362  std::vector<ParameterSet> parSet(this->parNum_);
5363  // name, step, mini, maxi
5364  parSet[0] = ParameterSet( "Pt res. sc.", 0.0002, 0., 0.1 );
5365  parSet[1] = ParameterSet( "eta bin 1", 0.00002, 0., 0.01 );
5366  parSet[2] = ParameterSet( "eta bin 2", 0.00002, 0., 0.01 );
5367  parSet[3] = ParameterSet( "eta bin 3", 0.00002, 0., 0.01 );
5368  parSet[4] = ParameterSet( "eta bin 4", 0.00002, 0., 0.01 );
5369  parSet[5] = ParameterSet( "eta bin 5", 0.00002, 0., 0.01 );
5370  parSet[6] = ParameterSet( "eta bin 6", 0.00002, 0., 0.01 );
5371  parSet[7] = ParameterSet( "eta bin 7", 0.00002, 0., 0.01 );
5372  parSet[8] = ParameterSet( "eta bin 8", 0.00002, 0., 0.01 );
5373  parSet[9] = ParameterSet( "eta bin 9", 0.00002, 0., 0.01 );
5374  parSet[10] = ParameterSet( "eta bin 10", 0.00002, 0., 0.01 );
5375  parSet[11] = ParameterSet( "eta bin 11", 0.00002, 0., 0.01 );
5376  parSet[12] = ParameterSet( "eta bin 12", 0.00002, 0., 0.01 );
5377  parSet[13] = ParameterSet( "cov(pt1,pt2)", 0.00002, 0., 0.01 );
5378 
5379 
5380  std::cout << "setting parameters" << std::endl;
5381  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5382  }
5383 
5384  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5385  const T & parResol, const std::vector<int> & parResolOrder,
5386  const std::vector<double> & parStep,
5387  const std::vector<double> & parMin,
5388  const std::vector<double> & parMax,
5389  const int muonType)
5390  {
5391  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5392  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5393  std::cout << "parNum = " << this->parNum_ << std::endl;
5394  std::cout << "parStep.size() = " << parStep.size() << std::endl;
5395  std::cout << "parMin.size() = " << parMin.size() << std::endl;
5396  std::cout << "parMax.size() = " << parMax.size() << std::endl;
5397  exit(1);
5398  }
5399  std::vector<ParameterSet> parSet(this->parNum_);
5400  // name, step, mini, maxi
5401  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5402  parSet[1] = ParameterSet( "eta bin 1", parStep[1], parMin[1], parMax[1] );
5403  parSet[2] = ParameterSet( "eta bin 2", parStep[2], parMin[2], parMax[2] );
5404  parSet[3] = ParameterSet( "eta bin 3", parStep[3], parMin[3], parMax[3] );
5405  parSet[4] = ParameterSet( "eta bin 4", parStep[4], parMin[4], parMax[4] );
5406  parSet[5] = ParameterSet( "eta bin 5", parStep[5], parMin[5], parMax[5] );
5407  parSet[6] = ParameterSet( "eta bin 6", parStep[6], parMin[6], parMax[6] );
5408  parSet[7] = ParameterSet( "eta bin 7", parStep[7], parMin[7], parMax[7] );
5409  parSet[8] = ParameterSet( "eta bin 8", parStep[8], parMin[8], parMax[8] );
5410  parSet[9] = ParameterSet( "eta bin 9", parStep[9], parMin[9], parMax[9] );
5411  parSet[10] = ParameterSet( "eta bin 10", parStep[10], parMin[10], parMax[10] );
5412  parSet[11] = ParameterSet( "eta bin 11", parStep[11], parMin[11], parMax[11] );
5413  parSet[12] = ParameterSet( "eta bin 12", parStep[12], parMin[12], parMax[12] );
5414  parSet[13] = ParameterSet( "cov(pt1,pt2)",parStep[13], parMin[13], parMax[13] );
5415 
5416  std::cout << "setting parameters" << std::endl;
5417  for( int i=0; i<this->parNum_; ++i ) {
5418  std::cout << "parStep["<<i<<"] = " << parStep[i]
5419  << ", parMin["<<i<<"] = " << parMin[i]
5420  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5421  }
5422  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5423  }
5424 };
5425 
5426 
5427 
5428 
5429 
5430 //------------------------ 4Nov and 22 Dec data/MC Zmumu (36/pb) -- 3 parabolas (for MU-10-004) ---------
5431 template <class T>
5432 class resolutionFunctionType44 : public resolutionFunctionBase<T> {
5433  public:
5434  resolutionFunctionType44() { this->parNum_ = 6; }
5435 
5436  inline double leftParabola(const double & pt, const double & eta, const T & parval)
5437  {
5438  return( parval[0] + parval[1]*pt + parval[2]*std::fabs(eta) + parval[3]*eta*eta );
5439  }
5440  inline double rightParabola(const double & pt, const double & eta, const T & parval)
5441  {
5442  return( parval[0] + parval[1]*pt + parval[4]*fabs(eta) + parval[5]*eta*eta );
5443  }
5444 
5445  // linear in pt and quadratic in eta
5446  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
5447  //double fabsEta = std::fabs(eta);
5448  if( eta <= 0 ){
5449  return leftParabola(pt, eta, parval);
5450  }
5451  else
5452  return rightParabola(pt, eta, parval);
5453 
5454  }
5455  // 1/pt in pt and quadratic in eta
5456  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
5457  return 0;
5458  }
5459  // 1/pt in pt and quadratic in eta
5460  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
5461  return 0.;
5462  }
5463 
5464  // derivatives ---------------
5465 
5466  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError)
5467  {
5468  double fabsEta = std::fabs(eta);
5469  if( eta <= 0 ) {
5470  return sqrt( pow(parError[0], 2) + pow(pt*parError[1], 2) + pow(fabsEta*parError[2], 2) + pow(eta*eta*parError[3], 2));
5471  }
5472  else {
5473  return sqrt( pow(parError[0], 2) + pow(pt*parError[1], 2) + pow(fabsEta*parError[4], 2) + pow(eta*eta*parError[5], 2));
5474  }
5475  }
5476 
5477  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
5478  {
5479  std::vector<ParameterSet> parSet(this->parNum_);
5480  // name, step, mini, maxi
5481  parSet[0] = ParameterSet( "Pt res. sc.", 0.002, -0.1, 0.1 );
5482  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", 0.00002, -0.01, 0.01 );
5483  parSet[2] = ParameterSet( "Pt res. Eta sc. (left)", 0.000002, 0., 0.01 );
5484  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. (left)", 0.0002, -0.01, 0.02 );
5485  parSet[4] = ParameterSet( "Pt res. Eta sc. (right)", 0.000002, 0., 0.01 );
5486  parSet[5] = ParameterSet( "Pt res. Eta^2 sc. (right)", 0.0002, -0.01, 0.02 );
5487 
5488  std::cout << "setting parameters" << std::endl;
5489  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5490  }
5491 
5492  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5493  const T & parResol, const std::vector<int> & parResolOrder,
5494  const std::vector<double> & parStep,
5495  const std::vector<double> & parMin,
5496  const std::vector<double> & parMax,
5497  const int muonType)
5498  {
5499  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5500  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5501  exit(1);
5502  }
5503  std::vector<ParameterSet> parSet(this->parNum_);
5504  // name, step, mini, maxi
5505  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5506  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", parStep[1], parMin[1], parMax[1] );
5507  parSet[2] = ParameterSet( "Pt res. Eta sc. (left)", parStep[2], parMin[2], parMax[2] );
5508  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. (left)", parStep[3], parMin[3], parMax[3] );
5509  parSet[4] = ParameterSet( "Pt res. sc. (right)", parStep[4], parMin[4], parMax[4] );
5510  parSet[5] = ParameterSet( "Pt res. Eta sc. (right)", parStep[5], parMin[5], parMax[5] );
5511 
5512  std::cout << "setting parameters" << std::endl;
5513  for( int i=0; i<this->parNum_; ++i ) {
5514  std::cout << "parStep["<<i<<"] = " << parStep[i]
5515  << ", parMin["<<i<<"] = " << parMin[i]
5516  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5517  }
5518  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5519  }
5520 };
5521 
5522 //--- 2012.04.05 ---//
5523 
5524 template <class T>
5525 class resolutionFunctionType99 : public resolutionFunctionBase<T> {
5526 public:
5527  resolutionFunctionType99() { this->parNum_ = 4; }
5528 
5529  virtual double sigmaPt(const double & pt, const double & eta, const T & parval) {
5530 
5531  if( eta <=0 ) {
5532  return (parval[0] + parval[1]*pt + parval[2]*eta*eta);
5533  }
5534  else {
5535  return (parval[0] + parval[1]*pt + parval[3]*eta*eta);
5536  }
5537 
5538  }
5539 
5540  virtual double sigmaCotgTh(const double & pt, const double & eta, const T & parval) {
5541  return 0;
5542  }
5543  virtual double sigmaPhi(const double & pt, const double & eta, const T & parval) {
5544  return 0.;
5545  }
5546 
5547  // derivatives ---------------
5548  virtual double sigmaPtError(const double & pt, const double & eta, const T & parval, const T & parError) {
5549  if( eta <=0 ) {
5550  return( parError[0] + parError[1]*pt + parError[2]*eta*eta );
5551  }
5552  else {
5553  return( parError[0] + parError[1]*pt + parError[3]*eta*eta );
5554  }
5555  }
5556 
5557 
5558 
5559  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const T & parResol, const std::vector<int> & parResolOrder, const int muonType)
5560  {
5561  std::vector<ParameterSet> parSet(this->parNum_);
5562  // name, step, mini, maxi
5563  parSet[0] = ParameterSet( "Pt res. sc.", 0.002, 0., 0.1 );
5564  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", 0.00002, -0.01, 0.01 );
5565  parSet[2] = ParameterSet( "Pt res. Eta^2 sc. (left)", 0.0000002, -1., 1. );
5566  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. (right)", 0.0000002, -1., 1. );
5567 
5568 
5569  std::cout << "setting parameters" << std::endl;
5570  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5571  }
5572 
5573  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5574  const T & parResol, const std::vector<int> & parResolOrder,
5575  const std::vector<double> & parStep,
5576  const std::vector<double> & parMin,
5577  const std::vector<double> & parMax,
5578  const int muonType)
5579  {
5580  if( (int(parStep.size()) != this->parNum_) || (int(parMin.size()) != this->parNum_) || (int(parMax.size()) != this->parNum_) ) {
5581  std::cout << "Error: par step or min or max do not match with number of parameters" << std::endl;
5582  exit(1);
5583  }
5584  std::vector<ParameterSet> parSet(this->parNum_);
5585  // name, step, mini, maxi
5586  parSet[0] = ParameterSet( "Pt res. sc.", parStep[0], parMin[0], parMax[0] );
5587  parSet[1] = ParameterSet( "Pt res. Pt sc. (all)", parStep[1], parMin[1], parMax[1] );
5588  parSet[2] = ParameterSet( "Pt res. Eta^2 sc. (left)", parStep[2], parMin[2], parMax[2] );
5589  parSet[3] = ParameterSet( "Pt res. Eta^2 sc. (right)", parStep[3], parMin[3], parMax[3] );
5590 
5591 
5592 
5593  std::cout << "setting parameters" << std::endl;
5594  for( int i=0; i<this->parNum_; ++i ) {
5595  std::cout << "parStep["<<i<<"] = " << parStep[i]
5596  << ", parMin["<<i<<"] = " << parMin[i]
5597  << ", parMax["<<i<<"] = " << parMin[i] << std::endl;
5598  }
5599  this->setPar( Start, Step, Mini, Maxi, ind, parname, parResol, parResolOrder, parSet );
5600  }
5601 };
5602 
5603 //-----------------//
5604 
5605 // ------------ ATTENTION ----------- //
5606 // Other functions are not in for now //
5607 // ---------------------------------- //
5608 
5610 resolutionFunctionBase<double *> * resolutionFunctionService( const int identifier );
5611 
5613 resolutionFunctionBase<std::vector<double> > * resolutionFunctionVecService( const int identifier );
5614 
5639 class backgroundFunctionBase {
5640  public:
5641  backgroundFunctionBase(const double & lowerLimit, const double & upperLimit) :
5642  lowerLimit_(lowerLimit), upperLimit_(upperLimit) {}
5643  virtual ~backgroundFunctionBase()
5644  {
5645  delete functionForIntegral_;
5646  };
5647  virtual double operator()( const double * parval, const double & mass, const double & eta ) const = 0;
5648  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
5649  {
5650  return operator()(parval, mass, eta1);
5651  }
5652  virtual int parNum() const { return parNum_; }
5654  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) = 0;
5655  virtual TF1* functionForIntegral(const std::vector<double>::const_iterator & parBgrIt) const
5656  {
5657  functionForIntegral_ = new FunctionForIntegral(this, parBgrIt);
5658  TF1 * backgroundFunctionForIntegral = new TF1("backgroundFunctionForIntegral", functionForIntegral_,
5659  lowerLimit_, upperLimit_, this->parNum_);
5660  return( backgroundFunctionForIntegral );
5661  }
5662  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const { return 1.; }
5663 
5664 protected:
5665  int parNum_;
5666  double lowerLimit_;
5667  double upperLimit_;
5669  virtual void setPar(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname,
5670  const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt,
5671  double* thisStep, double* thisMini, double* thisMaxi, TString* thisParName ) {
5672  for( int iPar=0; iPar<this->parNum_; ++iPar ) {
5673  Start[iPar] = *(parBgrIt+iPar);
5674  Step[iPar] = thisStep[iPar];
5675  Mini[iPar] = thisMini[iPar];
5676  Maxi[iPar] = thisMaxi[iPar];
5677  ind[iPar] = *(parBgrOrderIt+iPar);
5678  // EM 2012.05.22 this line is crashing cmsRun (need to be fixed) parname[iPar] = thisParName[iPar];
5679  }
5680  }
5681  class FunctionForIntegral
5682  {
5683  public:
5684  FunctionForIntegral( const backgroundFunctionBase * function,
5685  const std::vector<double>::const_iterator & parBgrIt ) :
5686  function_(function)
5687  {
5688  parval_ = new double[function_->parNum()];
5689  for( int i=0; i < function_->parNum(); ++i ) {
5690  parval_[i] = *(parBgrIt+i);
5691  }
5692  }
5693  ~FunctionForIntegral()
5694  {
5695  delete parval_;
5696  }
5697  double operator()(const double * mass, const double *) const
5698  {
5699  // FIXME: this is a gross approximation. The function should be integrated in eta over the sample.
5700  return( (*function_)(parval_, *mass, 0.) );
5701  }
5702  protected:
5703  const backgroundFunctionBase * function_;
5704  double * parval_;
5705  };
5706  mutable FunctionForIntegral * functionForIntegral_;
5707 };
5708 
5710 // -------
5711 class backgroundFunctionType1 : public backgroundFunctionBase
5712 {
5713  public:
5720  backgroundFunctionType1(const double & lowerLimit, const double & upperLimit) :
5721  backgroundFunctionBase(lowerLimit, upperLimit)
5722  { this->parNum_ = 2; }
5723  virtual double operator()( const double * parval, const double & mass, const double & eta ) const
5724  {
5725  double a = 1.;
5726  double b = parval[1];
5727 
5728  double norm = -(a*lowerLimit_ + b*lowerLimit_*lowerLimit_/2.);
5729 
5730  if( -a/b > upperLimit_ ) norm += a*upperLimit_ + b*upperLimit_*upperLimit_/2.;
5731  else norm += -a*a/(2*b);
5732 
5733  if( mass < -a/b && norm != 0 ) return (a + b*mass)/norm;
5734  else return 0;
5735  }
5736  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5737  double thisStep[] = {0.01, 0.01};
5738  TString thisParName[] = {"Constant", "Linear"};
5739  if( muonType == 1 ) {
5740  double thisMini[] = {0.0, -300.};
5741  double thisMaxi[] = {1.0, 0.};
5742  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5743  } else {
5744  double thisMini[] = {0.0, -300.};
5745  double thisMaxi[] = {1.0, 0.};
5746  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5747  }
5748  }
5749 };
5751 // ------------
5752 class backgroundFunctionType2 : public backgroundFunctionBase {
5753  public:
5759  backgroundFunctionType2(const double & lowerLimit, const double & upperLimit) :
5760  backgroundFunctionBase(lowerLimit, upperLimit)
5761  { this->parNum_ = 2; }
5762  virtual double operator()( const double * parval, const double & mass, const double & eta ) const
5763  {
5764  double Bgrp2 = parval[1];
5765  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
5766  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
5767  else return 0.;
5768  }
5769  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5770  double thisStep[] = {0.01, 0.01};
5771  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
5772  if( muonType == 1 ) {
5773  double thisMini[] = {0.0, 0.};
5774  double thisMaxi[] = {1.0, 10.};
5775  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5776  } else {
5777  double thisMini[] = {0.0, 0.};
5778  double thisMaxi[] = {1.0, 10.};
5779  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5780  }
5781  }
5782 
5783 
5784 
5785 
5786  // virtual double fracVsEta(const double * parval, const double & resEta) const
5787  // {
5788  // // return( 0.6120 - 0.0225*eta*eta );
5789  // return( 1. - 0.0225*resEta*resEta ); // so that a = 1 for eta = 0.
5790  // }
5791 
5792 
5793 
5794 
5795 };
5796 
5797 
5798 
5799 
5800 
5801 
5802 
5807 //
5808 //class backgroundFunctionType3 : public backgroundFunctionBase {
5809 // public:
5810 // // pass parval[shift]
5811 // backgroundFunctionType3(const double & lowerLimit, const double & upperLimit) :
5812 // backgroundFunctionBase(lowerLimit, upperLimit)
5813 // { this->parNum_ = 3; }
5814 // virtual double operator()( const double * parval, const int resTotNum, const int ires, const bool * resConsidered,
5815 // const double * ResMass, const double ResHalfWidth[], const int MuonType, const double & mass, const int nbins ) {
5816 // double PB = 0.;
5817 // double Bgrp2 = parval[1];
5818 // double Bgrp3 = parval[2];
5819 // for (int ires=0; ires<resTotNum; ires++) {
5820 // // In this case, by integrating between A and B, we get for f=exp(a-bx)+k:
5821 // // INT = exp(a)/b*(exp(-bA)-exp(-bB))+k*(B-A) so our function, which in 1000 bins between A and B
5822 // // gets a total of 1, is f = (exp(a-bx)+k)*(B-A)/nbins / (INT)
5823 // // ----------------------------------------------------------------------------------------------
5824 // if (resConsidered[ires]) {
5825 // if (exp(-Bgrp2*(ResMass[ires]-ResHalfWidth[ires]))-exp(-Bgrp2*(ResMass[ires]+ResHalfWidth[ires]))>0) {
5826 // PB += (exp(-Bgrp2*mass)+Bgrp3) *
5827 // 2*ResHalfWidth[ires]/(double)nbins /
5828 // ( (exp(-Bgrp2*(ResMass[ires]-ResHalfWidth[ires]))-exp(-Bgrp2*(ResMass[ires]+ResHalfWidth[ires])))/
5829 // Bgrp2 + Bgrp3*2*ResHalfWidth[ires] );
5830 // } else {
5831 // std::cout << "Impossible to compute Background probability! - some fix needed - Bgrp2=" << Bgrp2 << std::endl;
5832 // }
5833 // }
5834 // }
5835 // return PB;
5836 // }
5837 // virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5838 // double thisStep[] = {0.1, 0.001, 0.1};
5839 // TString thisParName[] = {"Bgr fraction", "Bgr slope", "Bgr constant"};
5840 // if( muonType == 1 ) {
5841 // double thisMini[] = {0.0, 0.000000001, 0.0};
5842 // double thisMaxi[] = {1.0, 0.2, 1000};
5843 // this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5844 // } else {
5845 // double thisMini[] = {0.0, 0.000000001, 0.0};
5846 // double thisMaxi[] = {1.0, 0.2, 1000};
5847 // this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5848 // }
5849 // }
5850 // virtual TF1* functionForIntegral(const std::vector<double>::const_iterator & parBgrIt) const {return 0;};
5851 //};
5852 
5853 
5854 
5856 // --------------------------------
5857 class backgroundFunctionType4 : public backgroundFunctionBase
5858 {
5859  public:
5865  backgroundFunctionType4(const double & lowerLimit, const double & upperLimit) :
5866  backgroundFunctionBase(lowerLimit, upperLimit)
5867  { this->parNum_ = 4; }
5868  virtual double operator()( const double * parval, const double & mass, const double & eta ) const
5869  {
5870  double Bgrp2 = parval[1] + parval[2]*eta*eta;
5871  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
5872  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
5873  else return 0.;
5874  }
5875  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5876  double thisStep[] = {0.01, 0.01, 0.01, 0.01};
5877  TString thisParName[] = {"Bgr fraction", "Bgr slope", "Bgr slope eta^2 dependence", "background fraction eta dependence"};
5878  if( muonType == 1 ) {
5879  double thisMini[] = {0.0, 0., 0., -1.};
5880  double thisMaxi[] = {1.0, 10., 10., 1.};
5881  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5882  } else {
5883  double thisMini[] = {0.0, 0., -1., -1.};
5884  double thisMaxi[] = {1.0, 10., 1., 1.};
5885  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5886  }
5887  }
5888  /* virtual double fracVsEta(const double * parval, const double & resEta) const */
5889  /* { */
5890  /* return( 1. - parval[3]*resEta*resEta ); // so that a = 1 for eta = 0. */
5891  /* } */
5892 };
5893 
5895 // ---------------------------
5896 class backgroundFunctionType5 : public backgroundFunctionBase
5897 {
5898  public:
5903  backgroundFunctionType5(const double & lowerLimit, const double & upperLimit) :
5904  backgroundFunctionBase(lowerLimit, upperLimit)
5905  { this->parNum_ = 3; }
5906  virtual double operator()( const double * parval, const double & mass, const double & eta ) const
5907  {
5908  double b = parval[1];
5909  // double c = parval[2];
5910  double a = 1 + parval[2]*eta*eta;
5911 
5912  double norm = -(a*lowerLimit_ + b*lowerLimit_*lowerLimit_/2.);
5913 
5914  if( -a/b > upperLimit_ ) norm += a*upperLimit_ + b*upperLimit_*upperLimit_/2.;
5915  else norm += -a*a/(2*b);
5916 
5917  if( mass < -a/b && norm != 0 ) return (a + b*mass)/norm;
5918  else return 0;
5919  }
5920  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5921  double thisStep[] = {0.01, 0.01, 0.01};
5922  TString thisParName[] = {"Bgr fraction", "Constant", "Linear"};
5923  if( muonType == 1 ) {
5924  double thisMini[] = {0.0, 0., -300.};
5925  double thisMaxi[] = {1.0, 300., 0.};
5926  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5927  } else {
5928  double thisMini[] = {0.0, 0., -300.};
5929  double thisMaxi[] = {1.0, 300., 0.};
5930  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5931  }
5932  }
5933 };
5934 
5935 
5937 // --------------------------
5938 class backgroundFunctionType6 : public backgroundFunctionBase {
5939  public:
5940  backgroundFunctionType6(const double & lowerLimit, const double & upperLimit) :
5941  backgroundFunctionBase(lowerLimit, upperLimit)
5942  {
5943  this->parNum_ = 2;
5944  }
5945  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
5946  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
5947  {
5948  double Bgrp2 = 0.;
5949  if( fabs(eta1) <= 1.3 && fabs(eta2) <= 1.3 ) {
5950  Bgrp2 = -1.20528;
5951  }
5952  else if( (fabs(eta1) <= 1.6 && fabs(eta1) > 1.3) && (fabs(eta2) <= 1.6 && fabs(eta2) > 1.3) ) {
5953  Bgrp2 = 0.234713;
5954  }
5955  else if( fabs(eta1) > 1.6 && fabs(eta2) > 1.6 ) {
5956  Bgrp2 = -0.667103;
5957  }
5958  else if( (fabs(eta1) <= 1.3 && (fabs(eta2) > 1.3 && fabs(eta2) <= 1.6)) ||
5959  (fabs(eta2) <= 1.3 && (fabs(eta1) > 1.3 && fabs(eta1) <= 1.6)) ) {
5960  Bgrp2 = -0.656904;
5961  }
5962  else if( (fabs(eta1) <= 1.3 && fabs(eta2) > 1.6) ||
5963  (fabs(eta2) <= 1.3 && fabs(eta1) > 1.6) ) {
5964  Bgrp2 = 0.155328;
5965  }
5966  else if( ((fabs(eta1) > 1.3 && fabs(eta1) <= 1.6) && fabs(eta2) > 1.6) ||
5967  ((fabs(eta2) > 1.3 && fabs(eta2) <= 1.6) && fabs(eta1) > 1.6) ) {
5968  Bgrp2 = -0.177154;
5969  }
5970  else {
5971  std::cout << "WARNING: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
5972  Bgrp2 = -0.667103;
5973  }
5974  Bgrp2*=-1.;
5975  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
5976  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
5977  else return 0.;
5978 
5979  }
5980  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
5981  double thisStep[] = {0.01, 0.01};
5982  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
5983  if( muonType == 1 ) {
5984  double thisMini[] = {0.0, 0.};
5985  double thisMaxi[] = {1.0, 10.};
5986  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5987  } else {
5988  double thisMini[] = {0.0, 0.};
5989  double thisMaxi[] = {1.0, 10.};
5990  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
5991  }
5992  }
5993 
5994  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
5995  {
5996  if( fabs(eta1) <= 1.3 && fabs(eta2) <= 1.3 ) {
5997  return (1.-0.910903);
5998  }
5999  else if( (fabs(eta1) <= 1.6 && fabs(eta1) > 1.3) && (fabs(eta2) <= 1.6 && fabs(eta2) > 1.3) ) {
6000  return (1.-0.801469);
6001  }
6002  else if( fabs(eta1) > 1.6 && fabs(eta2) > 1.6 ) {
6003  return (1.-0.658196);
6004  }
6005  else if( (fabs(eta1) <= 1.3 && (fabs(eta2) > 1.3 && fabs(eta2) <= 1.6)) ||
6006  (fabs(eta2) <= 1.3 && (fabs(eta1) > 1.3 && fabs(eta1) <= 1.6)) ) {
6007  return (1.-0.873411);
6008  }
6009  else if( (fabs(eta1) <= 1.3 && fabs(eta2) > 1.6) ||
6010  (fabs(eta2) <= 1.3 && fabs(eta1) > 1.6) ) {
6011  return (1.-0.784674);
6012  }
6013  else if( ((fabs(eta1) > 1.3 && fabs(eta1) <= 1.6) && fabs(eta2) > 1.6) ||
6014  ((fabs(eta2) > 1.3 && fabs(eta2) <= 1.6) && fabs(eta1) > 1.6) ) {
6015  return (1.-0.714398);
6016  }
6017  else {
6018  std::cout << "WARNING: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
6019  return (1.-0.658196);
6020  }
6021  }
6022 };
6023 
6025 // ---------------------------------------------------------
6026 class backgroundFunctionType7 : public backgroundFunctionBase {
6027  public:
6028  backgroundFunctionType7(const double & lowerLimit, const double & upperLimit) :
6029  backgroundFunctionBase(lowerLimit, upperLimit)
6030  {
6031  this->parNum_ = 2;
6032  }
6033  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
6034  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
6035  {
6036  double Bgrp2 = 0.;
6037  if( (fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 0. && fabs(eta2) < 0.9) ) {
6038  Bgrp2 = (-1.42465);
6039  }
6040  else if( (fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) ) {
6041  Bgrp2 = (-1.38576);
6042  }
6043  else if( (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) ) {
6044  Bgrp2 = (-0.333728);
6045  }
6046  else if( (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) ) {
6047  Bgrp2 = (0.94066);
6048  }
6049  else if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) ) {
6050  Bgrp2 = (0.371026);
6051  }
6052  else if( (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) ) {
6053  Bgrp2 = (-0.959101);
6054  }
6055  else if( (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) ) {
6056  Bgrp2 = (-1.13829);
6057  }
6058  else if( (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0) ) {
6059  Bgrp2 = (-0.921581);
6060  }
6061  else if( (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.) ) {
6062  Bgrp2 = (-0.664338);
6063  }
6064  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 0.9 && fabs(eta2) < 1.3)) ||
6065  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 0.9 && fabs(eta1) < 1.3)) ) {
6066  Bgrp2 = (-1.07581);
6067  }
6068  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5)) ||
6069  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5)) ) {
6070  Bgrp2 = (-0.250272);
6071  }
6072  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6073  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6074  Bgrp2 = (0.101785);
6075  }
6076  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6077  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6078  Bgrp2 = (0.360397);
6079  }
6080  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6081  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6082  Bgrp2 = (0.689136);
6083  }
6084  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6085  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6086  Bgrp2 = (0.860723);
6087  }
6088  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6089  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6090  Bgrp2 = (1.21908);
6091  }
6092  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6093  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6094  Bgrp2 = (2.4453);
6095  }
6096  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5)) ||
6097  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5)) ) {
6098  Bgrp2 = (-1.14152);
6099  }
6100  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6101  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6102  Bgrp2 = (-0.77241);
6103  }
6104  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6105  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6106  Bgrp2 = (-0.516479);
6107  }
6108  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6109  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6110  Bgrp2 = (-0.361401);
6111  }
6112  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6113  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6114  Bgrp2 = (-0.33143);
6115  }
6116  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6117  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6118  Bgrp2 = (-0.20813);
6119  }
6120  else if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6121  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6122  Bgrp2 = (0.158002);
6123  }
6124  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6125  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6126  Bgrp2 = (0.273222);
6127  }
6128  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6129  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6130  Bgrp2 = (0.247639);
6131  }
6132  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6133  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6134  Bgrp2 = (-0.148616);
6135  }
6136  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6137  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6138  Bgrp2 = (-0.413175);
6139  }
6140  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6141  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6142  Bgrp2 = (-0.230031);
6143  }
6144  else if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6145  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6146  Bgrp2 = (-0.122756);
6147  }
6148  else if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6149  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6150  Bgrp2 = (0.650851);
6151  }
6152  else if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6153  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6154  Bgrp2 = (-0.0985001);
6155  }
6156  else if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6157  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6158  Bgrp2 = (-0.402548);
6159  }
6160  else if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6161  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6162  Bgrp2 = (-0.27401);
6163  }
6164  else if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6165  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6166  Bgrp2 = (-0.22863);
6167  }
6168  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6169  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6170  Bgrp2 = (-0.436959);
6171  }
6172  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6173  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6174  Bgrp2 = (-0.506041);
6175  }
6176  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6177  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6178  Bgrp2 = (-0.31618);
6179  }
6180  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6181  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6182  Bgrp2 = (-0.365653);
6183  }
6184  else if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6185  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6186  Bgrp2 = (-1.16783);
6187  }
6188  else if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6189  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6190  Bgrp2 = (-0.730701);
6191  }
6192  else if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6193  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6194  Bgrp2 = (-0.5271);
6195  }
6196  else if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6197  ((fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6198  Bgrp2 = (-0.99893);
6199  }
6200  else if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6201  ((fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6202  Bgrp2 = (-0.687263);
6203  }
6204  else if( ((fabs(eta1) >= 1.9 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6205  ((fabs(eta2) >= 1.9 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6206  Bgrp2 = (-0.722394);
6207  }
6208  else {
6209  std::cout << "WARNING: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
6210  Bgrp2 = -0.664338;
6211  }
6212  Bgrp2*=-1.;
6213  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
6214  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
6215  else return 0.;
6216 
6217  }
6218  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
6219  double thisStep[] = {0.01, 0.01};
6220  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
6221  if( muonType == 1 ) {
6222  double thisMini[] = {0.0, 0.};
6223  double thisMaxi[] = {1.0, 10.};
6224  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6225  } else {
6226  double thisMini[] = {0.0, 0.};
6227  double thisMaxi[] = {1.0, 10.};
6228  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6229  }
6230  }
6231 
6232  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
6233  {
6234  if( (fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 0. && fabs(eta2) < 0.9) ) {
6235  return (1.-0.915365);
6236  }
6237  if( (fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) ) {
6238  return (1.-0.914149);
6239  }
6240  if( (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) ) {
6241  return (1.-0.855918);
6242  }
6243  if( (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) ) {
6244  return (1.-0.70221);
6245  }
6246  if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) ) {
6247  return (1.-0.701489);
6248  }
6249  if( (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) ) {
6250  return (1.-0.651162);
6251  }
6252  if( (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) ) {
6253  return (1.-0.639839);
6254  }
6255  if( (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0) ) {
6256  return (1.-0.64915);
6257  }
6258  if( (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.) ) {
6259  return (1.-0.687878);
6260  }
6261  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 0.9 && fabs(eta2) < 1.3)) ||
6262  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 0.9 && fabs(eta1) < 1.3)) ) {
6263  return (1.-0.903486);
6264  }
6265  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5)) ||
6266  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5)) ) {
6267  return (1.-0.882516);
6268  }
6269  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6270  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6271  return (1.-0.85477);
6272  }
6273  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6274  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6275  return (1.-0.804919);
6276  }
6277  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6278  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6279  return (1.-0.75411);
6280  }
6281  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6282  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6283  return (1.-0.714128);
6284  }
6285  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6286  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6287  return (1.-0.645403);
6288  }
6289  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.9) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6290  ((fabs(eta2) >= 0. && fabs(eta2) < 0.9) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6291  return (1.-0.588049);
6292  }
6293  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.3 && fabs(eta2) < 1.5)) ||
6294  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.3 && fabs(eta1) < 1.5)) ) {
6295  return (1.-0.901123);
6296  }
6297  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6298  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6299  return (1.-0.87852);
6300  }
6301  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6302  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6303  return (1.-0.862266);
6304  }
6305  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6306  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6307  return (1.-0.846385);
6308  }
6309  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6310  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6311  return (1.-0.825401);
6312  }
6313  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6314  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6315  return (1.-0.812449);
6316  }
6317  if( ((fabs(eta1) >= 0.9 && fabs(eta1) < 1.3) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6318  ((fabs(eta2) >= 0.9 && fabs(eta2) < 1.3) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6319  return (1.-0.753754);
6320  }
6321  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.5 && fabs(eta2) < 1.6)) ||
6322  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.5 && fabs(eta1) < 1.6)) ) {
6323  return (1.-0.794143);
6324  }
6325  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6326  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6327  return (1.-0.761375);
6328  }
6329  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6330  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6331  return (1.-0.765572);
6332  }
6333  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6334  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6335  return (1.-0.749438);
6336  }
6337  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6338  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6339  return (1.-0.750941);
6340  }
6341  if( ((fabs(eta1) >= 1.3 && fabs(eta1) < 1.5) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6342  ((fabs(eta2) >= 1.3 && fabs(eta2) < 1.5) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6343  return (1.-0.722832);
6344  }
6345  if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.7)) ||
6346  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.7)) ) {
6347  return (1.-0.699723);
6348  }
6349  if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6350  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6351  return (1.-0.734044);
6352  }
6353  if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6354  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6355  return (1.-0.719434);
6356  }
6357  if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6358  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6359  return (1.-0.718889);
6360  }
6361  if( ((fabs(eta1) >= 1.5 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6362  ((fabs(eta2) >= 1.5 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6363  return (1.-0.689382);
6364  }
6365  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.7 && fabs(eta2) < 1.8)) ||
6366  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.7 && fabs(eta1) < 1.8)) ) {
6367  return (1.-0.681106);
6368  }
6369  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6370  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6371  return (1.-0.685783);
6372  }
6373  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6374  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6375  return (1.-0.695924);
6376  }
6377  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.7) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6378  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.7) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6379  return (1.-0.670977);
6380  }
6381  if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.8 && fabs(eta2) < 1.9)) ||
6382  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.8 && fabs(eta1) < 1.9)) ) {
6383  return (1.-0.654816);
6384  }
6385  if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6386  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6387  return (1.-0.670969);
6388  }
6389  if( ((fabs(eta1) >= 1.7 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6390  ((fabs(eta2) >= 1.7 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6391  return (1.-0.659082);
6392  }
6393  if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 1.9 && fabs(eta2) < 2.0)) ||
6394  ((fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) && (fabs(eta1) >= 1.9 && fabs(eta1) < 2.0)) ) {
6395  return (1.-0.648371);
6396  }
6397  if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 1.9) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6398  ((fabs(eta2) >= 1.8 && fabs(eta2) < 1.9) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6399  return (1.-0.659114);
6400  }
6401  if( ((fabs(eta1) >= 1.9 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.0 && fabs(eta2) < 1000.)) ||
6402  ((fabs(eta2) >= 1.9 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.0 && fabs(eta1) < 1000.)) ) {
6403  return (1.-0.660482);
6404  }
6405  else {
6406  std::cout << "WARNING: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
6407  return (1.-0.687878);
6408  }
6409  }
6410 };
6411 //Function 8
6412 class backgroundFunctionType8 : public backgroundFunctionBase {
6413  public:
6414  backgroundFunctionType8(const double & lowerLimit, const double & upperLimit) :
6415  backgroundFunctionBase(lowerLimit, upperLimit)
6416  {
6417  this->parNum_ = 2;
6418  }
6419  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
6420  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
6421  {
6422  double Bgrp2 = 0.;
6423 if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6424  Bgrp2 = (-2.17047);
6425 }
6426 else if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6427  Bgrp2 = (-2.12913);
6428 }
6429 else if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6430  Bgrp2 = (-2.19963);
6431 }
6432 else if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1000) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000) ) {
6433  Bgrp2 = (-0.386394);
6434 }
6435 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6436  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6437  Bgrp2 = (-1.71339);
6438 }
6439 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6440  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6441  Bgrp2 = (-0.206566);
6442 }
6443 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6444  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6445  Bgrp2 = (4.4815);
6446 }
6447 else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6448  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6449  Bgrp2 = (-1.87985);
6450 }
6451 else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6452  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6453  Bgrp2 = (-0.163569);
6454 }
6455 else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6456  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6457  Bgrp2 = (-1.67935);
6458 }
6459  Bgrp2*=-1.;
6460  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
6461  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
6462  else return 0.;
6463 
6464  }
6465  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
6466  double thisStep[] = {0.01, 0.01};
6467  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
6468  if( muonType == 1 ) {
6469  double thisMini[] = {0.0, 0.};
6470  double thisMaxi[] = {1.0, 10.};
6471  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6472  } else {
6473  double thisMini[] = {0.0, 0.};
6474  double thisMaxi[] = {1.0, 10.};
6475  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6476  }
6477  }
6478 
6479  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
6480  {
6481 if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6482  return (1.-0.907727);
6483 }
6484 if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6485  return (1.-0.907715);
6486 }
6487 if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6488  return (1.-0.912233);
6489 }
6490 if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1000) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000) ) {
6491  return (1.-0.876776);
6492 }
6493 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6494  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6495  return (1.-0.913046);
6496 }
6497 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6498  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6499  return (1.-0.916765);
6500 }
6501 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6502  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6503  return (1.-0.6);
6504 }
6505 if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6506  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6507  return (1.-0.907471);
6508 }
6509 if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6510  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6511  return (1.-0.899253);
6512 }
6513 if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6514  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6515  return (1.-0.879108);
6516 }
6517  return 0;}
6518 };
6519 
6521 backgroundFunctionBase * backgroundFunctionService( const int identifier, const double & lowerLimit, const double & upperLimit );
6522 
6523 //Function Type 9
6524 
6525 class backgroundFunctionType9 : public backgroundFunctionBase {
6526  public:
6527  backgroundFunctionType9(const double & lowerLimit, const double & upperLimit) :
6528  backgroundFunctionBase(lowerLimit, upperLimit)
6529  {
6530  this->parNum_ = 2;
6531  }
6532  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
6533  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
6534  {
6535  double Bgrp2 = 0.;
6536 
6537 if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6538  Bgrp2 = (-1.80833);
6539 }
6540 else if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6541  Bgrp2 = (-1.98281);
6542 }
6543 else if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6544  Bgrp2 = (-1.79632);
6545 }
6546 else if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1000) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000) ) {
6547  Bgrp2 = (-1.14645);
6548 }
6549 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6550  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6551  Bgrp2 = (-1.55747);
6552 }
6553 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6554  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6555  Bgrp2 = (-0.337598);
6556 }
6557 else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6558  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6559  Bgrp2 = (5.36513);
6560 }
6561 else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6562  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6563  Bgrp2 = (-1.44363);
6564 }
6565 else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6566  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6567  Bgrp2 = (-0.54614);
6568 }
6569 else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6570  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6571  Bgrp2 = (-1.41059);
6572 }
6573 else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6574  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6575  Bgrp2 = (-1.41059);
6576 }
6577  Bgrp2*=-1.;
6578  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
6579  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
6580  else return 0.;
6581 
6582  }
6583  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
6584  double thisStep[] = {0.01, 0.01};
6585  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
6586  if( muonType == 1 ) {
6587  double thisMini[] = {0.0, 0.};
6588  double thisMaxi[] = {1.0, 10.};
6589  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6590  } else {
6591  double thisMini[] = {0.0, 0.};
6592  double thisMaxi[] = {1.0, 10.};
6593  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6594  }
6595  }
6596 
6597  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
6598 
6599  {
6600  // std::cout << "Eta1 " << eta1 << " eta2 = " << eta2 << std::endl;
6601 if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6602  return (1.-0.893683);
6603 }
6604 if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6605  return (1.-0.888968);
6606 }
6607 if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6608  return (1.-0.885926);
6609 }
6610 if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1000) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000) ) {
6611  return (1.-0.866615);
6612 }
6613 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6614  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6615  return (1.-0.892856);
6616 }
6617 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6618  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6619  return (1.-0.884864);
6620 }
6621 if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6622  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6623  return (1.-0.6);
6624 }
6625 if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6626  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6627  return (1.-0.894739);
6628 }
6629 if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6630  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6631  return (1.-0.880597);
6632 }
6633 if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6634  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6635  return (1.-0.869165);
6636 }
6637 if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6638  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6639  return (1.-0.869165);
6640 }
6641  return 0;}
6642 };
6643 
6644 
6645 class backgroundFunctionType10 : public backgroundFunctionBase {
6646  public:
6647  backgroundFunctionType10(const double & lowerLimit, const double & upperLimit) :
6648  backgroundFunctionBase(lowerLimit, upperLimit)
6649  {
6650  this->parNum_ = 2;
6651  }
6652  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
6653  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
6654  {
6655  double Bgrp2 = 0.;
6656  if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6657  Bgrp2 = (-1.80833);
6658  }
6659  else if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6660  Bgrp2 = (-1.98281);
6661  }
6662  else if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6663  Bgrp2 = (-1.79632);
6664  }
6665  else if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) ) {
6666  Bgrp2 = (-1.50855);
6667  }
6668  else if( (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) ) {
6669  Bgrp2 = (-0.498511);
6670  }
6671  else if( (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2) ) {
6672  Bgrp2 = (-0.897031);
6673  }
6674  else if( (fabs(eta1) >= 2.2 && fabs(eta1) < 1000) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000) ) {
6675  Bgrp2 = (-0.75954);
6676  }
6677  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6678  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6679  Bgrp2 = (-1.55747);
6680  }
6681  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6682  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6683  Bgrp2 = (-0.337598);
6684  }
6685  else if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6686  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6687  Bgrp2 = (3.5163);
6688  }
6689  else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6690  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6691  Bgrp2 = (-1.44363);
6692  }
6693  else if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6694  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6695  Bgrp2 = (-0.54614);
6696  }
6697  else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.8)) ||
6698  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.8)) ) {
6699  Bgrp2 = (-1.36442);
6700  }
6701  else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0)) ||
6702  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0)) ) {
6703  Bgrp2 = (-1.66202);
6704  }
6705  else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6706  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6707  Bgrp2 = (-0.62038);
6708  }
6709  else if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6710  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6711  Bgrp2 = (0.662449);
6712  }
6713  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0)) ||
6714  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0)) ) {
6715  Bgrp2 = (-0.723325);
6716  }
6717  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6718  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6719  Bgrp2 = (-1.54405);
6720  }
6721  else if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6722  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6723  Bgrp2 = (-1.1104);
6724  }
6725  else if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6726  ((fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6727  Bgrp2 = (-1.56277);
6728  }
6729  else if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6730  ((fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6731  Bgrp2 = (-1.0827);
6732  }
6733  else if( ((fabs(eta1) >= 2.0 && fabs(eta1) < 2.2) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6734  ((fabs(eta2) >= 2.0 && fabs(eta2) < 2.2) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6735  Bgrp2 = (-1.05662);
6736  }
6737  Bgrp2*=-1.;
6738  double norm = -(exp(-Bgrp2*upperLimit_) - exp(-Bgrp2*lowerLimit_))/Bgrp2;
6739  if( norm != 0 ) return exp(-Bgrp2*mass)/norm;
6740  else return 0.;
6741  }
6742  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
6743  double thisStep[] = {0.01, 0.01};
6744  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
6745  if( muonType == 1 ) {
6746  double thisMini[] = {0.0, 0.};
6747  double thisMaxi[] = {1.0, 10.};
6748  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6749  } else {
6750  double thisMini[] = {0.0, 0.};
6751  double thisMaxi[] = {1.0, 10.};
6752  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6753  }
6754  }
6755 
6756  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
6757  {
6758  if( (fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0. && fabs(eta2) < 0.85) ) {
6759  return (1.-0.893683);
6760  }
6761  if( (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) ) {
6762  return (1.-0.888968);
6763  }
6764  if( (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) ) {
6765  return (1.-0.885926);
6766  }
6767  if( (fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) ) {
6768  return (1.-0.892823);
6769  }
6770  if( (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) ) {
6771  return (1.-0.888735);
6772  }
6773  if( (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2) ) {
6774  return (1.-0.87497);
6775  }
6776  if( (fabs(eta1) >= 2.2 && fabs(eta1) < 1000) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000) ) {
6777  return (1.-0.895275);
6778  }
6779  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 0.85 && fabs(eta2) < 1.25)) ||
6780  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 0.85 && fabs(eta1) < 1.25)) ) {
6781  return (1.-0.892856);
6782  }
6783  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6784  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6785  return (1.-0.884864);
6786  }
6787  if( ((fabs(eta1) >= 0. && fabs(eta1) < 0.85) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6788  ((fabs(eta2) >= 0. && fabs(eta2) < 0.85) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6789  return (1.-0.834572);
6790  }
6791  if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.25 && fabs(eta2) < 1.6)) ||
6792  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.25 && fabs(eta1) < 1.6)) ) {
6793  return (1.-0.894739);
6794  }
6795  if( ((fabs(eta1) >= 0.85 && fabs(eta1) < 1.25) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1000)) ||
6796  ((fabs(eta2) >= 0.85 && fabs(eta2) < 1.25) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1000)) ) {
6797  return (1.-0.880597);
6798  }
6799  if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.6 && fabs(eta2) < 1.8)) ||
6800  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.6 && fabs(eta1) < 1.8)) ) {
6801  return (1.-0.892911);
6802  }
6803  if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0)) ||
6804  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0)) ) {
6805  return (1.-0.880506);
6806  }
6807  if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6808  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6809  return (1.-0.885718);
6810  }
6811  if( ((fabs(eta1) >= 1.25 && fabs(eta1) < 1.6) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6812  ((fabs(eta2) >= 1.25 && fabs(eta2) < 1.6) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6813  return (1.-0.853141);
6814  }
6815  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 1.8 && fabs(eta2) < 2.0)) ||
6816  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 1.8 && fabs(eta1) < 2.0)) ) {
6817  return (1.-0.88822);
6818  }
6819  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6820  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6821  return (1.-0.87028);
6822  }
6823  if( ((fabs(eta1) >= 1.6 && fabs(eta1) < 1.8) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6824  ((fabs(eta2) >= 1.6 && fabs(eta2) < 1.8) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6825  return (1.-0.869603);
6826  }
6827  if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.0 && fabs(eta2) < 2.2)) ||
6828  ((fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.0 && fabs(eta1) < 2.2)) ) {
6829  return (1.-0.877922);
6830  }
6831  if( ((fabs(eta1) >= 1.8 && fabs(eta1) < 2.0) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6832  ((fabs(eta2) >= 1.8 && fabs(eta2) < 2.0) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6833  return (1.-0.865997);
6834  }
6835  if( ((fabs(eta1) >= 2.0 && fabs(eta1) < 2.2) && (fabs(eta2) >= 2.2 && fabs(eta2) < 1000)) ||
6836  ((fabs(eta2) >= 2.0 && fabs(eta2) < 2.2) && (fabs(eta1) >= 2.2 && fabs(eta1) < 1000)) ) {
6837  return (1.-0.886109);
6838  }
6839  return 0;
6840  }
6841 };
6842 
6843 
6845 // --------------------------
6846 class backgroundFunctionType11 : public backgroundFunctionBase {
6847  public:
6848  backgroundFunctionType11(const double & lowerLimit, const double & upperLimit) :
6849  backgroundFunctionBase(lowerLimit, upperLimit)
6850  {
6851  this->parNum_ = 2;
6852  }
6853  virtual double operator()( const double * parval, const double & mass, const double & eta ) const {return 0.;}
6854  virtual double operator()( const double * parval, const double & mass, const double & eta1, const double & eta2 ) const
6855  {
6856  double Bgrp2 = 0.;
6857  if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= -100. && eta2 < -0.8) ) {
6858  Bgrp2 = (-0.0512353);
6859  }
6860  else if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= -0.8 && eta2 < 0.) ) {
6861  Bgrp2 = (-0.0448482);
6862  }
6863  else if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= 0. && eta2 < 0.8) ) {
6864  Bgrp2 = (-0.0193726);
6865  }
6866  else if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= 0.8 && eta2 < 100.) ) {
6867  Bgrp2 = (0.0225765);
6868  }
6869  else if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= -100. && eta2 < -0.8) ) {
6870  Bgrp2 = (-0.0822936);
6871  }
6872  else if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= -0.8 && eta2 < 0.) ) {
6873  Bgrp2 = (-0.0676357);
6874  }
6875  else if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= 0. && eta2 < 0.8) ) {
6876  Bgrp2 = (-0.0591544);
6877  }
6878  else if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= 0.8 && eta2 < 100.) ) {
6879  Bgrp2 = (-0.0235858);
6880  }
6881  else if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= -100. && eta2 < -0.8) ) {
6882  Bgrp2 = (-0.0317051);
6883  }
6884  else if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= -0.8 && eta2 < 0.) ) {
6885  Bgrp2 = (-0.06139);
6886  }
6887  else if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= 0. && eta2 < 0.8) ) {
6888  Bgrp2 = (-0.0747737);
6889  }
6890  else if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= 0.8 && eta2 < 100.) ) {
6891  Bgrp2 = (-0.0810139);
6892  }
6893  else if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= -100. && eta2 < -0.8) ) {
6894  Bgrp2 = (0.0229602);
6895  }
6896  else if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= -0.8 && eta2 < 0.) ) {
6897  Bgrp2 = (-0.0224212);
6898  }
6899  else if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= 0. && eta2 < 0.8) ) {
6900  Bgrp2 = (-0.0446273);
6901  }
6902  else if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= 0.8 && eta2 < 100.) ) {
6903  Bgrp2 = (-0.0554561);
6904  }
6905  else {
6906  std::cout << "WARNING, backgroundFunctionType11: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
6907  return (-0.05);
6908  }
6909  double norm = (exp(Bgrp2*upperLimit_) - exp(Bgrp2*lowerLimit_))/Bgrp2;
6910  if( norm != 0 ) return exp(Bgrp2*mass)/norm;
6911  else return 0.;
6912 
6913  }
6914  virtual void setParameters(double* Start, double* Step, double* Mini, double* Maxi, int* ind, TString* parname, const std::vector<double>::const_iterator & parBgrIt, const std::vector<int>::const_iterator & parBgrOrderIt, const int muonType) {
6915  double thisStep[] = {0.01, 0.01};
6916  TString thisParName[] = {"Bgr fraction", "Bgr slope"};
6917  if( muonType == 1 ) {
6918  double thisMini[] = {-1.0, 10.};
6919  double thisMaxi[] = {1.0 , 10.};
6920  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6921  } else {
6922  double thisMini[] = {-1.0, 10.};
6923  double thisMaxi[] = { 1.0, 10.};
6924  this->setPar( Start, Step, Mini, Maxi, ind, parname, parBgrIt, parBgrOrderIt, thisStep, thisMini, thisMaxi, thisParName );
6925  }
6926  }
6927 
6928  virtual double fracVsEta(const double * parval, const double & eta1, const double & eta2) const
6929  {
6930  if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= -100. && eta2 < -0.8) ) {
6931  return (1.-0.966316);
6932  }
6933  if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= -0.8 && eta2 < 0.) ) {
6934  return (1.-0.966875);
6935  }
6936  if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= 0. && eta2 < 0.8) ) {
6937  return (1.-0.955311);
6938  }
6939  if( (eta1 >= -100. && eta1 < -0.8) && (eta2 >= 0.8 && eta2 < 100.) ) {
6940  return (1.-0.928771);
6941  }
6942  if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= -100. && eta2 < -0.8) ) {
6943  return (1.-0.983255);
6944  }
6945  if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= -0.8 && eta2 < 0.) ) {
6946  return (1.-0.982203);
6947  }
6948  if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= 0. && eta2 < 0.8) ) {
6949  return (1.-0.972127);
6950  }
6951  if( (eta1 >= -0.8 && eta1 < 0.) && (eta2 >= 0.8 && eta2 < 100.) ) {
6952  return (1.-0.962929);
6953  }
6954  if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= -100. && eta2 < -0.8) ) {
6955  return (1.-0.965597);
6956  }
6957  if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= -0.8 && eta2 < 0.) ) {
6958  return (1.-0.969461);
6959  }
6960  if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= 0. && eta2 < 0.8) ) {
6961  return (1.-0.979922);
6962  }
6963  if( (eta1 >= 0. && eta1 < 0.8) && (eta2 >= 0.8 && eta2 < 100.) ) {
6964  return (1.-0.984247);
6965  }
6966  if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= -100. && eta2 < -0.8) ) {
6967  return (1.-0.934252);
6968  }
6969  if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= -0.8 && eta2 < 0.) ) {
6970  return (1.-0.952914);
6971  }
6972  if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= 0. && eta2 < 0.8) ) {
6973  return (1.-0.960191);
6974  }
6975  if( (eta1 >= 0.8 && eta1 < 100.) && (eta2 >= 0.8 && eta2 < 100.) ) {
6976  return (1.-0.966175);
6977  }
6978  else {
6979  std::cout << "WARNING, backgroundFunctionType11: this should not happen for eta1 = " << eta1 << " and eta2 = " << eta2 << std::endl;
6980  return (1.-0.97);
6981  }
6982  }
6983 };
6984 
6985 
6986 #endif // FUNCTIONS_H
scaleFunctionType7::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:372
scaleFunctionType24::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1205
backgroundFunctionType2::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:5762
scaleFunctionType38::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2366
resolutionFunctionType7::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3170
backgroundFunctionType6::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:5945
Pi
const double Pi
Definition: CosmicMuonParameters.h:18
scaleFunctionType9::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:433
backgroundFunctionType9::backgroundFunctionType9
backgroundFunctionType9(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:6527
scaleFunctionService
scaleFunctionBase< double * > * scaleFunctionService(const int identifier)
Service to build the scale functor corresponding to the passed identifier.
Definition: Functions.cc:3
resolutionFunctionType13::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3672
resolutionFunctionType1::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3098
resolutionFunctionType43::leftLine
double leftLine(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4857
resolutionFunctionType43::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4896
resolutionFunctionType31::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4312
resolutionFunctionType40::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4518
i
int i
Definition: DBlmapReader.cc:9
backgroundFunctionType9::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:6583
scaleFunctionType19::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:860
function
Definition: vlib.h:257
backgroundFunctionType11::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:6914
scaleFunctionType36::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2137
resolutionFunctionType42::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4705
resolutionFunctionType12::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3539
smearFunctionType4::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2914
backgroundFunctionType11::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:6854
backgroundFunctionType1::backgroundFunctionType1
backgroundFunctionType1(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5720
backgroundFunctionType10::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:6756
resolutionFunctionType99::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5573
scaleFunctionType4::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:252
resolutionFunctionType18::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3926
ParameterSet::name
TString name
Definition: Functions.h:27
resolutionFunctionType32::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4417
ParameterSet::mini
double mini
Definition: Functions.h:28
resolutionFunctionType45::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5144
create_public_lumi_plots.exp
tuple exp
Definition: create_public_lumi_plots.py:1093
scaleFunctionType12::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:577
SigmaPtDiff
Returns ( sigmaPt/Pt(data)^2 - sigmaPt/Pt(MC)^2 )
Definition: SigmaPtDiff.h:68
backgroundFunctionType7
Exponential binned in eta, much finer binning then type6.
Definition: Functions.h:6026
scaleFunctionType27::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1483
resolutionFunctionType12::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3558
resolutionFunctionType42::centralParabola
double centralParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4677
backgroundFunctionType6::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:5946
resolutionFunctionType42::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4716
resolutionFunctionType1::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3092
smearFunctionType7::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2992
backgroundFunctionType8::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:6420
backgroundFunctionBase::functionForIntegral
virtual TF1 * functionForIntegral(const std::vector< double >::const_iterator &parBgrIt) const
Definition: Functions.h:5655
backgroundFunctionType7::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:6232
scaleFunctionType52::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2727
resolutionFunctionType9::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3302
scaleFunctionType30::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1649
scaleFunctionType35::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2064
backgroundFunctionBase::FunctionForIntegral::operator()
double operator()(const double *mass, const double *) const
Definition: Functions.h:5697
resolutionFunctionType10::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3432
scaleFunctionType27::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1464
backgroundFunctionType5::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5920
resolutionFunctionType40::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4513
resolutionFunctionType8::etaByPoints
double etaByPoints(const double &inEta, const double &border)
Definition: Functions.h:3242
smearFunctionType6::etaByPoints
double etaByPoints(const double &inEta, const double &border)
Definition: Functions.h:2969
resolutionFunctionType12::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3523
resolutionFunctionType42::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4710
scaleFunctionType5::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:272
resolutionFunctionType99::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5559
resolutionFunctionType11
This is resolution function where sigmaPt/Pt is described by f(Pt) = a + b/pt + pt/(pt+c)and f(Eta) =...
Definition: Functions.h:3474
scaleFunctionType10::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:457
smearFunctionType3::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2901
scaleFunctionType20::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:920
scaleFunctionType15::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:702
resolutionFunctionType44::leftParabola
double leftParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5436
resolutionFunctionType17::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3854
resolutionFunctionType31::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4305
scaleFunctionType28::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1543
backgroundFunctionType8::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:6479
resolutionFunctionType99::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5540
scaleFunctionType11::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:520
smearFunctionBase::gRandom_
TRandom * gRandom_
Definition: Functions.h:2865
scaleFunctionType17::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:786
resolutionFunctionType7::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3166
scaleFunctionType6::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:314
scaleFunctionType14::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:660
scaleFunctionType33::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1888
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
resolutionFunctionType43::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4875
smearFunctionBase::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)=0
resolutionFunctionType47::etaBin
int etaBin(const double &eta)
Definition: Functions.h:5308
scaleFunctionType51::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2628
backgroundFunctionType11::backgroundFunctionType11
backgroundFunctionType11(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:6848
scaleFunctionType18::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:814
create_public_lumi_plots.log
log
Definition: create_public_lumi_plots.py:1108
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:165
resolutionFunctionType9::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3295
scaleFunctionType12::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:583
scaleFunctionType32::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1814
scaleFunctionType19::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:868
resolutionFunctionType42::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:4790
scaleFunctionType22::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1022
resolutionFunctionType45::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:5113
scaleFunctionType32::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &par) const
Definition: Functions.h:1768
resolutionFunctionType31::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4287
scaleFunctionType36::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2167
resolutionFunctionType13::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3665
scaleFunctionBase::setPar
virtual void setPar(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< ParameterSet > &parSet)
Definition: Functions.h:82
scaleFunctionType7::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:378
resolutionFunctionType99::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:5548
scaleFunctionType0::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:112
resolutionFunctionType20::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4028
scaleFunctionType31::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1719
scaleFunctionType16::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:752
scaleFunctionType14::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:638
resolutionFunctionType45::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5083
resolutionFunctionBase::setPar
virtual void setPar(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, double *thisStep, double *thisMini, double *thisMaxi, TString *thisParName)
This method sets the parameters.
Definition: Functions.h:3054
eta
T eta() const
Definition: Basic3DVectorLD.h:172
smearFunctionType2::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2890
resolutionFunctionType43::centralParabola
double centralParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4837
scaleFunctionType37::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2266
resolutionFunctionType32::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4426
scaleFunctionType3::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:221
resolutionFunctionType43::rightParabola
double rightParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4849
scaleFunctionType29::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1575
scaleFunctionType10::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:462
scaleFunctionBase::~scaleFunctionBase
virtual ~scaleFunctionBase()=0
Definition: Functions.h:99
scaleFunctionType14::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:654
backgroundFunctionType4::backgroundFunctionType4
backgroundFunctionType4(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5865
resolutionFunctionType19::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3983
resolutionFunctionBase::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:3040
scaleFunctionType16::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:748
resolutionFunctionType44::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5477
smearFunctionBase::smearEta
void smearEta(double &eta)
Definition: Functions.h:2854
resolutionFunctionType44::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:5466
scaleFunctionType17::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:781
resolutionFunctionType45::etaBin
int etaBin(const double &eta)
Definition: Functions.h:5061
backgroundFunctionType5::backgroundFunctionType5
backgroundFunctionType5(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5903
scaleFunctionType2::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:191
resolutionFunctionType44::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5446
backgroundFunctionType2::backgroundFunctionType2
backgroundFunctionType2(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5759
scaleFunctionType25::cubicEta
double cubicEta(const double &eta, const T &parScale, const int shift) const
Definition: Functions.h:1347
scaleFunctionType34::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1954
scaleFunctionType50::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2458
scaleFunctionType32::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1816
resolutionFunctionType8::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3211
backgroundFunctionType10::backgroundFunctionType10
backgroundFunctionType10(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:6647
backgroundFunctionType7::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:6034
backgroundFunctionBase::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const =0
scaleFunctionType2::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:181
backgroundFunctionBase::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:5648
resolutionFunctionType99::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5543
resolutionFunctionType40::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4480
scaleFunctionType30::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1656
backgroundFunctionBase::~backgroundFunctionBase
virtual ~backgroundFunctionBase()
Definition: Functions.h:5643
resolutionFunctionType44::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5456
backgroundFunctionBase::FunctionForIntegral::function_
const backgroundFunctionBase * function_
Definition: Functions.h:5703
resolutionFunctionBase::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)=0
scaleFunctionType12
TESTED on 23-01-2011.
Definition: Functions.h:567
scaleFunctionType11::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:514
scaleFunctionType27::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1489
resolutionFunctionType1::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3089
resolutionFunctionType46::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5214
scaleFunctionType1::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:124
scaleFunctionType25::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1353
backgroundFunctionBase::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:5662
resolutionFunctionType47::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5330
backgroundFunctionType7::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:6218
resolutionFunctionType31::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4335
scaleFunctionType23::etaCorrection
double etaCorrection(const double &eta) const
Definition: Functions.h:1088
scaleFunctionType37::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2242
scaleFunctionType3::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:215
smearFunctionType0::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2873
backgroundFunctionType4::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:5868
resolutionFunctionType20::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4061
resolutionFunctionType47::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:5351
scaleFunctionType10::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:468
resolutionFunctionType15::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3762
resolutionFunctionVecService
resolutionFunctionBase< std::vector< double > > * resolutionFunctionVecService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier when receiving a std::...
Definition: Functions.cc:156
resolutionFunctionType20::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4057
resolutionFunctionType6::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3129
scaleFunctionType29::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1561
backgroundFunctionType4
Exponential with eta dependence.
Definition: Functions.h:5857
resolutionFunctionBase::parNum
virtual int parNum() const
Definition: Functions.h:3050
resolutionFunctionType44::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5492
resolutionFunctionType8::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3203
resolutionFunctionType8::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3207
resolutionFunctionType47::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5384
scaleFunctionType1::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:144
scaleFunctionType36::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2118
backgroundFunctionType8::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:6419
scaleFunctionType2::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:185
resolutionFunctionType43::leftParabola
double leftParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4841
resolutionFunctionType30::covPt1Pt2
virtual double covPt1Pt2(const double &pt1, const double &eta1, const double &pt2, const double &eta2, const T &parval)
Definition: Functions.h:4190
resolutionFunctionType18::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3902
scaleFunctionType5::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:283
backgroundFunctionType5::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:5906
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:46
scaleFunctionType30::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &par) const
Definition: Functions.h:1628
scaleFunctionType0::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:110
scaleFunctionType33::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1877
freq2
int freq2
Definition: ROSDebugUtility.h:26
scaleFunctionBase::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)=0
This method is used to differentiate parameters among the different functions.
resolutionFunctionType7::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3173
scaleFunctionBase::setPar
virtual void setPar(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, double *thisStep, double *thisMini, double *thisMaxi, TString *thisParName)
This method sets the parameters.
Definition: Functions.h:70
resolutionFunctionType1::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3095
scaleFunctionType51::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2592
scaleFunctionType52::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2688
resolutionFunctionType19::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3971
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
resolutionFunctionBase::setPar
virtual void setPar(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< ParameterSet > &parSet)
Definition: Functions.h:3066
resolutionFunctionType19::etaByPoints
double etaByPoints(const double &inEta, const double &border)
Definition: Functions.h:4004
scaleFunctionType51::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2555
resolutionFunctionType44::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5460
resolutionFunctionType30::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:4231
resolutionFunctionType17::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3829
resolutionFunctionType47::covPt1Pt2
virtual double covPt1Pt2(const double &pt1, const double &eta1, const double &pt2, const double &eta2, const T &parval)
Definition: Functions.h:5344
backgroundFunctionType6::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:5994
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
resolutionFunctionBase::covPt1Pt2
virtual double covPt1Pt2(const double &pt1, const double &eta1, const double &pt2, const double &eta2, const T &parval)
Definition: Functions.h:3031
backgroundFunctionBase::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)=0
This method is used to differentiate parameters among the different functions.
backgroundFunctionBase::backgroundFunctionBase
backgroundFunctionBase(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5641
scaleFunctionType34::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1968
resolutionFunctionType13::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3646
scaleFunctionBase::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:56
scaleFunctionType4::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:241
scaleFunctionType9::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:443
resolutionFunctionType31::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4324
resolutionFunctionType45::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5102
scaleFunctionType28::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1532
resolutionFunctionType43::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5013
scaleFunctionType8::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:399
backgroundFunctionType11::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:6853
scaleFunctionType31::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1726
resolutionFunctionType46::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:5262
scaleFunctionType50::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2491
resolutionFunctionType47::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5340
resolutionFunctionType45::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5119
ParameterSet::ParameterSet
ParameterSet(const TString &inputName, const double &inputStep, const double &inputMini, const double &inputMaxi)
Definition: Functions.h:19
scaleFunctionType18::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:826
scaleFunctionType6::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:308
scaleFunctionType24::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1269
smearFunctionService
smearFunctionBase * smearFunctionService(const int identifier)
Service to build the smearing functor corresponding to the passed identifier.
Definition: Functions.cc:101
scaleFunctionType1::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:130
scaleFunctionType21::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:955
scaleFunctionBase::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const =0
scaleFunctionType50::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2452
scaleFunctionType36::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2143
scaleFunctionType4::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:246
resolutionFunctionType12::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3554
resolutionFunctionType17::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3850
backgroundFunctionType8::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:6465
resolutionFunctionType15::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3782
resolutionFunctionType41::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4625
resolutionFunctionType14::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3734
scaleFunctionType7::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:366
resolutionFunctionType45::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5107
resolutionFunctionType41::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4580
resolutionFunctionType9::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3299
resolutionFunctionType46::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:5230
resolutionFunctionType43::leftParabolaError
double leftParabolaError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4914
SigmaPtDiff::squaredDiff
double squaredDiff(const double &eta)
Definition: SigmaPtDiff.h:136
resolutionFunctionType46::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5224
resolutionFunctionType30::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4195
scaleFunctionType29::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1568
scaleFunctionType9::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:437
resolutionFunctionType43::centralParabolaError
double centralParabolaError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4908
scaleFunctionType26::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1416
smearFunctionType6::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2937
ParameterSet::step
double step
Definition: Functions.h:28
resolutionFunctionType30::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4103
resolutionFunctionType11::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3490
smearFunctionType1::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2879
scaleFunctionVecService
scaleFunctionBase< std::vector< double > > * scaleFunctionVecService(const int identifier)
Service to build the scale functor corresponding to the passed identifier when receiving a std::vecto...
Definition: Functions.cc:52
scaleFunctionType51::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2598
resolutionFunctionType41::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4590
resolutionFunctionType13::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3669
scaleFunctionType21::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:969
resolutionFunctionType19::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3986
resolutionFunctionType1::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:3110
scaleFunctionType25::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1315
resolutionFunctionBase::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)=0
scaleFunctionType15::originalPtRegionSeparator_
double originalPtRegionSeparator_
Definition: Functions.h:739
scaleFunctionType6::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:329
resolutionFunctionType9::etaByPoints
double etaByPoints(const double &inEta, const double &border)
Definition: Functions.h:3351
scaleFunctionType38::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2336
scaleFunctionType30::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1658
scaleFunctionType33::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1902
resolutionFunctionType14::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3730
backgroundFunctionType9::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:6533
resolutionFunctionType46::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5237
scaleFunctionType5::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:277
scaleFunctionType20::originalTransition1_
double originalTransition1_
Definition: Functions.h:944
resolutionFunctionType8::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3214
resolutionFunctionType30::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4183
resolutionFunctionType32::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4437
resolutionFunctionType44::rightParabola
double rightParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5440
resolutionFunctionType12::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:3595
scaleFunctionType28::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1537
b
double b
Definition: hdecay.h:120
backgroundFunctionType7::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:6033
resolutionFunctionType46::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5220
backgroundFunctionType2::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5769
scaleFunctionType35::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2010
backgroundFunctionBase::FunctionForIntegral::FunctionForIntegral
FunctionForIntegral(const backgroundFunctionBase *function, const std::vector< double >::const_iterator &parBgrIt)
Definition: Functions.h:5684
ParameterSet::maxi
double maxi
Definition: Functions.h:28
scaleFunctionType35::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2035
backgroundFunctionType6::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5980
resolutionFunctionType11::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3493
scaleFunctionType34::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1948
scaleFunctionType24::etaCorrection
double etaCorrection(const double &eta) const
Definition: Functions.h:1229
scaleFunctionType13::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:602
scaleFunctionType18::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:832
smearFunctionType7::sigmaPtDiff
SigmaPtDiff sigmaPtDiff
Definition: Functions.h:3001
scaleFunctionType13::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:617
scaleFunctionType23::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1108
scaleFunctionType23::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1158
resolutionFunctionType6::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3126
backgroundFunctionBase::functionForIntegral_
FunctionForIntegral * functionForIntegral_
Definition: Functions.h:5706
resolutionFunctionType46::etaBin
int etaBin(const double &eta)
Definition: Functions.h:5192
scaleFunctionType24::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1262
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
backgroundFunctionType11::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:6928
scaleFunctionType25::etaCorrection
double etaCorrection(const double &eta, const T &parScale) const
Definition: Functions.h:1339
backgroundFunctionType5
Linear with eta dependence.
Definition: Functions.h:5896
scaleFunctionType15::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:693
resolutionFunctionType10::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3428
scaleFunctionType50::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2418
resolutionFunctionType10
This is resolution function where sigmaPt/Pt is described by f(Pt) = polynomial(4th grade) and f(Eta)...
Definition: Functions.h:3417
scaleFunctionType6::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:303
scaleFunctionType1::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:120
resolutionFunctionType42::leftParabola
double leftParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4681
resolutionFunctionType10::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3435
backgroundFunctionBase::parNum
virtual int parNum() const
Definition: Functions.h:5652
backgroundFunctionType9::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:6532
resolutionFunctionType42::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4693
scaleFunctionType35::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2041
scaleFunctionType37::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:2236
a
double a
Definition: hdecay.h:121
resolutionFunctionType14::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3737
scaleFunctionType26::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1441
scaleFunctionType3::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:211
scaleCards.mass
tuple mass
Definition: scaleCards.py:27
resolutionFunctionType6::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3132
scaleFunctionType20::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:898
resolutionFunctionType30::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4133
scaleFunctionType0::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:111
resolutionFunctionService
resolutionFunctionBase< double * > * resolutionFunctionService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier.
Definition: Functions.cc:116
resolutionFunctionType19::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3979
resolutionFunctionType31::covPt1Pt2
virtual double covPt1Pt2(const double &pt1, const double &eta1, const double &pt2, const double &eta2, const T &parval)
Definition: Functions.h:4330
backgroundFunctionType11
Exponential binned in eta (Z, Run2012C PromptReco-v1 + PromptReco-v2)
Definition: Functions.h:6846
backgroundFunctionType1::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:5723
scaleFunctionType11::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:509
scaleFunctionType52::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:2770
backgroundFunctionType10::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:6742
scaleFunctionType20::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:909
edm::shift
static unsigned int const shift
Definition: LuminosityBlockID.cc:9
resolutionFunctionType10::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3421
resolutionFunctionBase::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3038
backgroundFunctionType9::fracVsEta
virtual double fracVsEta(const double *parval, const double &eta1, const double &eta2) const
Definition: Functions.h:6597
scaleFunctionType15::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:712
backgroundFunctionType4::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5875
resolutionFunctionType6::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3123
resolutionFunctionType17::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3857
resolutionFunctionType18::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3922
scaleFunctionType12::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:570
resolutionFunctionType40::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4498
backgroundFunctionType7::backgroundFunctionType7
backgroundFunctionType7(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:6028
scaleFunctionType16::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:758
resolutionFunctionType32::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4407
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
resolutionFunctionType47::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5358
resolutionFunctionType18::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3929
resolutionFunctionType42::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4764
backgroundFunctionType1::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:5736
scaleFunctionType13::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:623
resolutionFunctionType43::rightParabolaError
double rightParabolaError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4934
resolutionFunctionBase::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)=0
resolutionFunctionType15::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:3794
scaleFunctionType31::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1728
resolutionFunctionType20::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4042
scaleFunctionType52::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2733
scaleFunctionType21::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:975
scaleFunctionType17::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:792
resolutionFunctionType41::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4564
scaleFunctionBase::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:49
scaleFunctionType38::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2317
resolutionFunctionType9::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3267
resolutionFunctionType31::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:4357
resolutionFunctionType43::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:4987
smearFunctionBase::~smearFunctionBase
virtual ~smearFunctionBase()=0
Definition: Functions.h:2867
scaleFunctionType37::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:2217
backgroundFunctionType10::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta) const
Definition: Functions.h:6652
resolutionFunctionType99::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5529
resolutionFunctionType11::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3486
resolutionFunctionType41::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4584
resolutionFunctionType43::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:4953
backgroundFunctionService
backgroundFunctionBase * backgroundFunctionService(const int identifier, const double &lowerLimit, const double &upperLimit)
Service to build the background functor corresponding to the passed identifier.
Definition: Functions.cc:196
T
long double T
Definition: Basic3DVectorLD.h:59
resolutionFunctionType47::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:5336
scaleFunctionType19::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:875
scaleFunctionType8::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:405
resolutionFunctionType43::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4902
scaleFunctionBase::parNum
virtual int parNum() const
Definition: Functions.h:66
resolutionFunctionBase::sigmaPtError
virtual double sigmaPtError(const double &pt, const double &eta, const T &parval, const T &parError)
Definition: Functions.h:3025
scaleFunctionType26::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1435
backgroundFunctionBase::setPar
virtual void setPar(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, double *thisStep, double *thisMini, double *thisMaxi, TString *thisParName)
This method sets the parameters.
Definition: Functions.h:5669
scaleFunctionType22::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:997
resolutionFunctionBase::~resolutionFunctionBase
virtual ~resolutionFunctionBase()=0
Definition: Functions.h:3082
resolutionFunctionType15::sigmaPhi
virtual double sigmaPhi(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3790
smearFunctionType5::smear
virtual void smear(double &pt, double &eta, double &phi, const double *y, const std::vector< double > &parSmear)
Definition: Functions.h:2925
scaleFunctionType22::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1029
backgroundFunctionType6::backgroundFunctionType6
backgroundFunctionType6(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:5940
resolutionFunctionType30::sigmaCotgTh
virtual double sigmaCotgTh(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4172
resolutionFunctionType42::rightParabola
double rightParabola(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4686
backgroundFunctionType8::backgroundFunctionType8
backgroundFunctionType8(const double &lowerLimit, const double &upperLimit)
Definition: Functions.h:6414
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
scaleFunctionType25::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1360
scaleFunctionType38::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:2342
backgroundFunctionType10::operator()
virtual double operator()(const double *parval, const double &mass, const double &eta1, const double &eta2) const
Definition: Functions.h:6653
resolutionFunctionType7::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3162
resolutionFunctionType11::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3478
scaleFunctionType20::originalTransition2_
double originalTransition2_
Definition: Functions.h:945
scaleFunctionType23::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1064
scaleFunctionType23::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:1115
scaleFunctionType32::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1807
resolutionFunctionType14::sigmaPt
virtual double sigmaPt(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:3713
scaleFunctionType33::resetParameters
virtual void resetParameters(std::vector< double > *scaleVec) const
This method is used to reset the scale parameters to neutral values (useful for iterations &gt; 0) ...
Definition: Functions.h:1882
resolutionFunctionType43::rightLine
double rightLine(const double &pt, const double &eta, const T &parval)
Definition: Functions.h:4865
resolutionFunctionType32::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:4442
scaleFunctionType34::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &parScale) const
Definition: Functions.h:1943
scaleFunctionType8::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parScale, const std::vector< int > &parScaleOrder, const int muonType)
This method is used to differentiate parameters among the different functions.
Definition: Functions.h:411
scaleFunctionType29::setParameters
virtual void setParameters(double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const T &parResol, const std::vector< int > &parResolOrder, const std::vector< double > &parStep, const std::vector< double > &parMin, const std::vector< double > &parMax, const int muonType)
Definition: Functions.h:1591
scaleFunctionType31::scale
virtual double scale(const double &pt, const double &eta, const double &phi, const int chg, const T &par) const
Definition: Functions.h:1698
phi
Definition: DDAxes.h:10
backgroundFunctionType6
Exponential binned in eta.
Definition: Functions.h:5938
Generated for CMSSW Reference Manual by doxygen 1.8.5