HighLAND
BinnedParams.cxx
1 #include "BinnedParams.hxx"
2 
3 //*********************************************************
4 BinnedParams::BinnedParams(){
5  //*********************************************************
6 
7  _name = "";
8  _type = kUnknown;
9  _typeShort = kUnknownShort;
10  _nBins = 0;
11  _nGraphBins = 0;
12  _useInterpolation = false;
13 }
14 
15 //*********************************************************
16 void BinnedParams::Initialize(
17  const std::string& folder_name,
18  const std::string& name,
19  TypeEnum type,
20  const std::string& extension,
21  bool useInterpolation){
22 //*********************************************************
23 
24  _name = name;
25  _type = type;
26  _useInterpolation = useInterpolation;
27  SetShortType();
28 
29  _nBins = 0;
30  _nGraphBins = 0;
31 
32  BinnedParams::Read(folder_name, extension);
33 }
34 
35 //*********************************************************
36 void BinnedParams::SetType(TypeEnum type){
37  //*********************************************************
38  _type = type;
39  SetShortType();
40 }
41 
42 //*********************************************************
43 void BinnedParams::SetShortType(){
44  //*********************************************************
45  if (_type == k1D_SYMMETRIC ||
46  _type == k1D_SYMMETRIC_NOMEAN ||
47  _type == k1D_DATA ||
48  _type == k1D_EFF_SYMMETRIC ||
49  _type == k1D_EFF_ASSYMMETRIC){
50  _typeShort = k1D;
51  }
52 
53  else if ( _type == k2D_SYMMETRIC ||
54  _type == k2D_SYMMETRIC_NOMEAN ||
55  _type == k2D_DATA ||
56  _type == k2D_EFF_SYMMETRIC ||
57  _type == k2D_EFF_ASSYMMETRIC){
58  _typeShort = k2D;
59  }
60  else
61  _typeShort = k3D;
62 }
63 
64 
65 //*********************************************************
66 void BinnedParams::Print(){
67  //*********************************************************
68 
69  std::cout << "-------- BinnedParams: " << _name << "--------------------" << std::endl;
70  std::cout << std::endl;
71  Int_t it = 0;
72  Int_t i=0;
73  if (_type==k1D_SYMMETRIC){
74  std::cout << "#: \t min \t max \t mean \t sigma" << std::endl;
75  for (it=0;it<_nBins;it++, i++)
76  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_mean << "\t " << _bins[it]->_sigma << std::endl;
77  }
78  else if (_type==k2D_SYMMETRIC){
79  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t mean \t sigma" << std::endl;
80  for (it=0; it<_nBins;it++, i++)
81  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t "
82  << _bins[it]->_max2 << "\t " << _bins[it]->_mean << "\t " << _bins[it]->_sigma << std::endl;
83  }
84  else if (_type==k3D_SYMMETRIC){
85  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t min3 \t max3 \t mean \t sigma" << std::endl;
86  for (it=0; it<_nBins;it++, i++)
87  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
88  << "\t" << _bins[it]->_min3 << "\t " << _bins[it]->_max3
89  << "\t " << _bins[it]->_mean << "\t " << _bins[it]->_sigma << std::endl;
90  }
91 
92  else if (_type==k1D_SYMMETRIC_NOMEAN){
93  std::cout << "#: \t min \t max \t sigma" << std::endl;
94  for (it=0;it<_nBins;it++, i++)
95  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_sigma << std::endl;
96  }
97  else if (_type==k2D_SYMMETRIC_NOMEAN){
98  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t sigma" << std::endl;
99  for (it=0; it<_nBins;it++, i++)
100  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t "
101  << _bins[it]->_max2 << "\t " << _bins[it]->_sigma << std::endl;
102  }
103  else if (_type==k3D_SYMMETRIC_NOMEAN){
104  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t min3 \t max3 \t sigma" << std::endl;
105  for (it=0; it<_nBins;it++, i++)
106  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
107  << "\t" << _bins[it]->_min3 << "\t " << _bins[it]->_max3 << "\t " << _bins[it]->_sigma << std::endl;
108  }
109 
110  else if (_type==k1D_DATA){
111  std::cout << "#: \t min \t max \t value" << std::endl;
112  for (it=0;it<_nBins;it++, i++)
113  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_mean << std::endl;
114  }
115  else if (_type==k2D_DATA){
116  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t data" << std::endl;
117  for (it=0; it<_nBins;it++, i++)
118  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t "
119  << _bins[it]->_max2 << "\t " << _bins[it]->_mean << std::endl;
120  }
121  else if (_type==k3D_DATA){
122  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t min3 \t max3 \t data" << std::endl;
123  for (it=0; it<_nBins;it++, i++)
124  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
125  << "\t" << _bins[it]->_min3 << "\t " << _bins[it]->_max3 << "\t " << _bins[it]->_mean << std::endl;
126  }
127 
128  else if (_type==k1D_EFF_SYMMETRIC){
129  std::cout << "#: \t min \t max \t real \t meanmc \t sigmamc \t meandata \t sigmadata" << std::endl;
130  for (it=0; it<_nBins;it++, i++)
131  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_meanREAL << "\t "
132  << _bins[it]->_meanMC << "\t " << _bins[it]->_sigmaMCl<< _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl << std::endl;
133  }
134  else if (_type==k2D_EFF_SYMMETRIC){
135  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t real \t meanmc \t sigmamc \t meandata \t sigmadata" << std::endl;
136  for (it=0; it<_nBins;it++, i++)
137  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2 << "\t "
138  << _bins[it]->_meanREAL << "\t "<< _bins[it]->_meanMC << "\t " << _bins[it]->_sigmaMCl<< _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl << std::endl;
139  }
140 
141  else if (_type==k3D_EFF_SYMMETRIC){
142  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t min3 \t max3 \t real \t meanmc \t sigmamc \t meandata \t sigmadata" << std::endl;
143  for (it=0; it<_nBins;it++, i++)
144  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
145  << "\t" << _bins[it]->_min3 << "\t " << _bins[it]->_max3
146  << "\t" << _bins[it]->_meanREAL << "\t "<< _bins[it]->_meanMC << "\t " << _bins[it]->_sigmaMCl<< _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl << std::endl;
147  }
148 
149  else if (_type==k1D_EFF_ASSYMMETRIC){
150  std::cout << "#: \t min \t max \t real \t meanmc \t sigmamcl \t sigmamch \t meandata \t sigmadatal \t sigmadatah" << std::endl;
151  for (it=0; it<_nBins;it++, i++)
152  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_meanREAL << "\t "<< _bins[it]->_meanMC << "\t "
153  << _bins[it]->_sigmaMCl <<"\t " << _bins[it]->_sigmaMCh << _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl<<" \t "
154  << _bins[it]->_sigmaDATAh << std::endl;
155  }
156  else if (_type==k2D_EFF_ASSYMMETRIC){
157  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t real \t meanmc \t sigmamcl \t sigmamch \t meandata \t sigmadatal \t sigmadatah" << std::endl;
158  for (it=0; it<_nBins;it++, i++)
159  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2 << "\t "
160  << _bins[it]->_meanREAL << "\t "<< _bins[it]->_meanMC << "\t " << _bins[it]->_sigmaMCl <<"\t " << _bins[it]->_sigmaMCh<<"\t "
161  << _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl<< "\t " << _bins[it]->_sigmaDATAh << std::endl;
162  }
163 
164  else if (_type==k3D_EFF_ASSYMMETRIC){
165  std::cout << "#: \t min1 \t max1 \t min2 \t max2 \t min3 \t max3 \t real \t meanmc \t sigmamcl \t sigmamch \t meandata \t sigmadatal \t sigmadatah" << std::endl;
166  for (it=0; it<_nBins;it++, i++)
167  std::cout << i << ": \t " << _bins[it]->_min << "\t " << _bins[it]->_max << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
168  << "\t " << _bins[it]->_min2 << "\t " << _bins[it]->_max2
169  << "\t" << _bins[it]->_meanREAL << "\t " << _bins[it]->_meanMC << "\t " << _bins[it]->_sigmaMCl << "\t " << _bins[it]->_sigmaMCh
170  << "\t" << _bins[it]->_meanDATA << "\t " << _bins[it]->_sigmaDATAl << "\t " << _bins[it]->_sigmaDATAh << std::endl;
171  }
172 
173 }
174 
175 //********************************************************************
176 void BinnedParams::Read(const std::string& inputDirName, const std::string& extension){
177  //********************************************************************
178 
179  // The file should have the same name as the BinnedParams
180  std::string inputFileName = inputDirName+"/"+_name+extension+".dat";
181 
182  std::ifstream inputFile(inputFileName.c_str(), std::ios::in);
183 
184  if (!inputFile) {
185  std::cerr << "Cannot open input file '" << inputFileName << "'. Exit!" << std::endl;
186  exit(0);
187  }
188 
189  std::string start, end, start2, end2, start3, end3, mean, sigma;
190  std::string mean_REAL, mean_CS_MC, sig_CS_MCl, sig_CS_MCh, mean_CS_DATA, sig_CS_DATAl, sig_CS_DATAh ;
191  char* pEnd;
192  if(_type==k1D_SYMMETRIC){
193  while (inputFile >> start >> end >> mean >> sigma ) {
194  AddBin(strtod(start.c_str(), &pEnd),
195  strtod(end.c_str(), &pEnd),
196  strtod(mean.c_str(), &pEnd),
197  strtod(sigma.c_str(), &pEnd));
198  }
199  }
200  else if(_type==k2D_SYMMETRIC){
201  while (inputFile >> start >> end >> start2 >> end2 >> mean >> sigma ) {
202  AddBin(strtod(start.c_str(), &pEnd),
203  strtod(end.c_str(), &pEnd),
204  strtod(start2.c_str(), &pEnd),
205  strtod(end2.c_str(), &pEnd),
206  strtod(mean.c_str(), &pEnd),
207  strtod(sigma.c_str(), &pEnd));
208  }
209  }
210 
211  else if(_type==k3D_SYMMETRIC){
212  while (inputFile >> start >> end >> start2 >> end2 >> start3 >> end3 >> mean >> sigma ) {
213  AddBin(strtod(start.c_str(), &pEnd),
214  strtod(end.c_str(), &pEnd),
215  strtod(start2.c_str(), &pEnd),
216  strtod(end2.c_str(), &pEnd),
217  strtod(start3.c_str(), &pEnd),
218  strtod(end3.c_str(), &pEnd),
219  strtod(mean.c_str(), &pEnd),
220  strtod(sigma.c_str(), &pEnd));
221  }
222  }
223  // Only sigma values
224  if(_type==k1D_SYMMETRIC_NOMEAN){
225  while (inputFile >> start >> end >> sigma) {
226  AddBin(strtod(start.c_str(), &pEnd),
227  strtod(end.c_str(), &pEnd),
228  0., // no mean
229  strtod(sigma.c_str(), &pEnd));
230  }
231  }
232  else if(_type==k2D_SYMMETRIC_NOMEAN){
233  while (inputFile >> start >> end >> start2 >> end2 >> sigma) {
234  AddBin(strtod(start.c_str(), &pEnd),
235  strtod(end.c_str(), &pEnd),
236  strtod(start2.c_str(), &pEnd),
237  strtod(end2.c_str(), &pEnd),
238  0., // no mean
239  strtod(sigma.c_str(), &pEnd));
240  }
241  }
242 
243  else if(_type==k3D_SYMMETRIC_NOMEAN){
244  while (inputFile >> start >> end >> start2 >> end2 >> start3 >> end3 >> sigma ) {
245  AddBin(strtod(start.c_str(), &pEnd),
246  strtod(end.c_str(), &pEnd),
247  strtod(start2.c_str(), &pEnd),
248  strtod(end2.c_str(), &pEnd),
249  strtod(start3.c_str(), &pEnd),
250  strtod(end3.c_str(), &pEnd),
251  0., // no mean
252  strtod(sigma.c_str(), &pEnd));
253  }
254  }
255 
256  if(_type==k1D_DATA){
257  while (inputFile >> start >> end >> mean) {
258  AddBin(strtod(start.c_str(), &pEnd),
259  strtod(end.c_str(), &pEnd),
260  strtod(mean.c_str(), &pEnd),
261  0.); // no sigma
262  }
263  }
264  else if(_type==k2D_DATA){
265  while (inputFile >> start >> end >> start2 >> end2 >> mean) {
266  AddBin(strtod(start.c_str(), &pEnd),
267  strtod(end.c_str(), &pEnd),
268  strtod(start2.c_str(), &pEnd),
269  strtod(end2.c_str(), &pEnd),
270  strtod(mean.c_str(), &pEnd),
271  0.); // no sigma
272  }
273  }
274 
275  else if(_type==k3D_DATA){
276  while (inputFile >> start >> end >> start2 >> end2 >> start3 >> end3 >> mean) {
277  AddBin(strtod(start.c_str(), &pEnd),
278  strtod(end.c_str(), &pEnd),
279  strtod(start2.c_str(), &pEnd),
280  strtod(end2.c_str(), &pEnd),
281  strtod(start3.c_str(), &pEnd),
282  strtod(end3.c_str(), &pEnd),
283  strtod(mean.c_str(), &pEnd),
284  0.); // no sigma
285  }
286  }
287 
288  else if(_type==k1D_EFF_SYMMETRIC){
289  while (inputFile >> start >> end >> mean_REAL >> mean_CS_MC >> sig_CS_MCl >> mean_CS_DATA >> sig_CS_DATAl) {
290  AddBin(strtod(start.c_str(), &pEnd),
291  strtod(end.c_str(), &pEnd),
292  strtod(mean_REAL.c_str(), &pEnd),
293  strtod(mean_CS_MC.c_str(), &pEnd),
294  strtod(sig_CS_MCl.c_str(), &pEnd),
295  strtod(sig_CS_MCl.c_str(), &pEnd),
296  strtod(mean_CS_DATA.c_str(), &pEnd),
297  strtod(sig_CS_DATAl.c_str(), &pEnd),
298  strtod(sig_CS_DATAl.c_str(), &pEnd));
299  }
300  }
301  else if(_type==k2D_EFF_SYMMETRIC){
302  while (inputFile >> start >> end >> start2 >> end2 >> mean_REAL >> mean_CS_MC >> sig_CS_MCl >> mean_CS_DATA >> sig_CS_DATAl) {
303  AddBin(strtod(start.c_str(), &pEnd),
304  strtod(end.c_str(), &pEnd),
305  strtod(start2.c_str(), &pEnd),
306  strtod(end2.c_str(), &pEnd),
307  strtod(mean_REAL.c_str(), &pEnd),
308  strtod(mean_CS_MC.c_str(), &pEnd),
309  strtod(sig_CS_MCl.c_str(), &pEnd),
310  strtod(sig_CS_MCl.c_str(), &pEnd),
311  strtod(mean_CS_DATA.c_str(), &pEnd),
312  strtod(sig_CS_DATAl.c_str(), &pEnd),
313  strtod(sig_CS_DATAl.c_str(), &pEnd));
314  }
315  }
316  else if(_type==k3D_EFF_SYMMETRIC){
317  while (inputFile >> start >> end >> start2 >> end2 >> start3 >> end3 >> mean_REAL >> mean_CS_MC >> sig_CS_MCl >> mean_CS_DATA >> sig_CS_DATAl) {
318  AddBin(strtod(start.c_str(), &pEnd),
319  strtod(end.c_str(), &pEnd),
320  strtod(start2.c_str(), &pEnd),
321  strtod(end2.c_str(), &pEnd),
322  strtod(start3.c_str(), &pEnd),
323  strtod(end3.c_str(), &pEnd),
324  strtod(mean_REAL.c_str(), &pEnd),
325  strtod(mean_CS_MC.c_str(), &pEnd),
326  strtod(sig_CS_MCl.c_str(), &pEnd),
327  strtod(sig_CS_MCl.c_str(), &pEnd),
328  strtod(mean_CS_DATA.c_str(), &pEnd),
329  strtod(sig_CS_DATAl.c_str(), &pEnd),
330  strtod(sig_CS_DATAl.c_str(), &pEnd));
331  }
332  }
333 
334  else if(_type==k1D_EFF_ASSYMMETRIC){
335  while (inputFile >> start >> end >> mean_REAL >> mean_CS_MC >> sig_CS_MCl >> sig_CS_MCh >> mean_CS_DATA >> sig_CS_DATAl >> sig_CS_DATAh ) {
336  AddBin(strtod(start.c_str(), &pEnd),
337  strtod(end.c_str(), &pEnd),
338  strtod(mean_REAL.c_str(), &pEnd),
339  strtod(mean_CS_MC.c_str(), &pEnd),
340  strtod(sig_CS_MCl.c_str(), &pEnd),
341  strtod(sig_CS_MCh.c_str(), &pEnd),
342  strtod(mean_CS_DATA.c_str(), &pEnd),
343  strtod(sig_CS_DATAl.c_str(), &pEnd),
344  strtod(sig_CS_DATAh.c_str(), &pEnd));
345  }
346  }
347  else if(_type==k2D_EFF_ASSYMMETRIC){
348  while (inputFile >> start >> end >> start2 >> end2 >> mean_REAL >> mean_CS_MC >> sig_CS_MCl >> sig_CS_MCh >> mean_CS_DATA >> sig_CS_DATAl >> sig_CS_DATAh ) {
349  AddBin(strtod(start.c_str(), &pEnd),
350  strtod(end.c_str(), &pEnd),
351  strtod(start2.c_str(), &pEnd),
352  strtod(end2.c_str(), &pEnd),
353  strtod(mean_REAL.c_str(), &pEnd),
354  strtod(mean_CS_MC.c_str(), &pEnd),
355  strtod(sig_CS_MCl.c_str(), &pEnd),
356  strtod(sig_CS_MCh.c_str(), &pEnd),
357  strtod(mean_CS_DATA.c_str(), &pEnd),
358  strtod(sig_CS_DATAl.c_str(), &pEnd),
359  strtod(sig_CS_DATAh.c_str(), &pEnd));
360 
361  }
362  }
363  else if(_type==k3D_EFF_ASSYMMETRIC){
364  while (inputFile >> start >> end >> start2 >> end2 >> start3 >> end3
365  >> mean_REAL>> mean_CS_MC >> sig_CS_MCl >> sig_CS_MCh >> mean_CS_DATA >> sig_CS_DATAl >> sig_CS_DATAh ) {
366  AddBin(strtod(start.c_str(), &pEnd),
367  strtod(end.c_str(), &pEnd),
368  strtod(start2.c_str(), &pEnd),
369  strtod(end2.c_str(), &pEnd),
370  strtod(start3.c_str(), &pEnd),
371  strtod(end3.c_str(), &pEnd),
372  strtod(mean_REAL.c_str(), &pEnd),
373  strtod(mean_CS_MC.c_str(), &pEnd),
374  strtod(sig_CS_MCl.c_str(), &pEnd),
375  strtod(sig_CS_MCh.c_str(), &pEnd),
376  strtod(mean_CS_DATA.c_str(), &pEnd),
377  strtod(sig_CS_DATAl.c_str(), &pEnd),
378  strtod(sig_CS_DATAh.c_str(), &pEnd));
379 
380  }
381  }
382 
383 
384  inputFile.close();
385 }
386 
387 //********************************************************************
388 bool BinnedParams::GetBin(Float_t value, BinnedParamsBin*& bin){
389  //********************************************************************
390 
391  if (_typeShort!=k1D) return false;
392 
393  Int_t idx=0;
394  Int_t it = 0;
395  for (it=0; it<_nBins;it++){
396  if (value>=_bins[it]->_min && value<_bins[it]->_max){
397  bin = _bins[it];
398  bin->_index=idx;
399  return true;
400  }
401  idx++;
402  }
403 
404  return false;
405 }
406 
407 
408 //********************************************************************
409 bool BinnedParams::GetBin(Float_t value1, Float_t value2, BinnedParamsBin*& bin){
410  //********************************************************************
411 
412  if (_typeShort!=k2D) return false;
413 
414  Int_t idx=0;
415  for (Int_t it=0; it<_nBins;it++){
416  if (value1>=_bins[it]->_min && value1<_bins[it]->_max && value2>= _bins[it]->_min2 && value2 < _bins[it]->_max2 ){
417  bin = _bins[it];
418  bin->_index=idx;
419  return true;
420  }
421  idx++;
422  }
423 
424  return false;
425 }
426 
427 //********************************************************************
428 bool BinnedParams::GetBin(Float_t value1, Float_t value2, Float_t value3, BinnedParamsBin*& bin){
429  //********************************************************************
430 
431  if (_typeShort!=k3D) return false;
432 
433  Int_t idx=0;
434  for (Int_t it=0; it<_nBins;it++){
435  if (value1>=_bins[it]->_min && value1<_bins[it]->_max
436  && value2>= _bins[it]->_min2 && value2 < _bins[it]->_max2
437  && value3>= _bins[it]->_min3 && value3 < _bins[it]->_max3 ){
438  bin = _bins[it];
439  bin->_index=idx;
440  return true;
441  }
442  idx++;
443  }
444 
445  return false;
446 }
447 
448 
449 //********************************************************************
450 bool BinnedParams::GetBinIndex(Float_t value, int& index){
451  //********************************************************************
452 
453  if (_typeShort!=k1D) return false;
454 
455  Int_t it = 0;
456  Int_t idx=0;
457  for (it=0; it<_nBins;it++){
458  if (value>=_bins[it]->_min && value<_bins[it]->_max){
459  index=idx;
460  return true;
461  }
462  idx++;
463  }
464 
465  return false;
466 }
467 
468 //********************************************************************
469 bool BinnedParams::GetParametersForBin(Int_t index, Float_t& mean, Float_t& sigma){
470  //********************************************************************
471 
472  Int_t it = 0;
473  Int_t idx = 0;
474  for (it=0; it<_nBins;it++){
475  if(index==idx){
476  mean =_bins[it]->_mean;
477  sigma =_bins[it]->_sigma;
478  return true;
479  }
480  idx++;
481  }
482 
483  return false;
484 }
485 
486 
487 //********************************************************************
488 bool BinnedParams::GetParametersForBin(Int_t index, BinnedParamsParams& params){
489  //********************************************************************
490 
491  Int_t it = 0;
492  Int_t idx = 0;
493  for (it=0; it<_nBins;it++){
494  if(index==idx){
495  const BinnedParamsBin* bin = _bins[it];
496  params.mean = bin->_mean;
497  params.sigma = bin->_sigma;
498  params.meanMCANA = bin->_meanREAL;
499  params.meanMC = bin->_meanMC;
500  params.sigmaMCl = bin->_sigmaMCl;
501  params.sigmaMCh = bin->_sigmaMCh;
502  params.meanDATA = bin->_meanDATA;
503  params.sigmaDATAl = bin->_sigmaDATAl;
504  params.sigmaDATAh = bin->_sigmaDATAh;
505  return true;
506  }
507  idx++;
508  }
509 
510  return false;
511 }
512 
513 
514 //********************************************************************
515 bool BinnedParams::GetBinValues(Float_t value, Float_t& mean, Float_t& sigma, Int_t& index){
516  //********************************************************************
517 
518  BinnedParamsBin* bin = NULL;
519  if (!GetBin(value, bin)) return false;
520 
521  mean = bin->_mean;
522  sigma = bin->_sigma;
523  index = bin->_index;
524 
525  return true;
526 }
527 
528 
529 //********************************************************************
530 bool BinnedParams::GetBinValues(Float_t value, BinnedParamsParams& params, Int_t& index){
531  //********************************************************************
532 
533  BinnedParamsBin* bin = NULL;
534  if (!GetBin(value, bin)) return false;
535 
536  params.mean = bin->_mean;
537  params.sigma = bin->_sigma;
538  params.meanMCANA = bin->_meanREAL;
539  params.meanMC = bin->_meanMC;
540  params.sigmaMCl = bin->_sigmaMCl;
541  params.sigmaMCh = bin->_sigmaMCh;
542  params.meanDATA = bin->_meanDATA;
543  params.sigmaDATAl = bin->_sigmaDATAl;
544  params.sigmaDATAh = bin->_sigmaDATAh;
545 
546  index = bin->_index;
547 
548  return true;
549 }
550 
551 
552 //********************************************************************
553 bool BinnedParams::GetBinValues(Float_t value1, Float_t value2, Float_t& mean, Float_t& sigma, Int_t& index){
554  //********************************************************************
555 
556  BinnedParamsBin* bin = NULL;
557  if (!GetBin(value1, value2, bin)) return false;
558 
559  mean = bin->_mean;
560  sigma = bin->_sigma;
561  index = bin->_index;
562 
563  return true;
564 }
565 
566 //********************************************************************
567 bool BinnedParams::GetBinValues(Float_t value1, Float_t value2, BinnedParamsParams& params, Int_t& index){
568  //********************************************************************
569 
570  BinnedParamsBin* bin = NULL;
571  if (!GetBin(value1, value2, bin)) return false;
572 
573  params.mean = bin->_mean;
574  params.sigma = bin->_sigma;
575  params.meanMCANA = bin->_meanREAL;
576  params.meanMC = bin->_meanMC;
577  params.sigmaMCl = bin->_sigmaMCl;
578  params.sigmaMCh = bin->_sigmaMCh;
579  params.meanDATA = bin->_meanDATA;
580  params.sigmaDATAl = bin->_sigmaDATAl;
581  params.sigmaDATAh = bin->_sigmaDATAh;
582 
583  index = bin->_index;
584 
585  return true;
586 }
587 
588 //********************************************************************
589 bool BinnedParams::GetBinValues(Float_t value1, Float_t value2, Float_t value3, Float_t& mean, Float_t& sigma, Int_t& index){
590  //********************************************************************
591 
592  BinnedParamsBin* bin = NULL;
593  if (!GetBin(value1, value2, value3, bin)) return false;
594 
595  mean = bin->_mean;
596  sigma = bin->_sigma;
597  index = bin->_index;
598 
599  return true;
600 }
601 
602 //********************************************************************
603 bool BinnedParams::GetBinValues(Float_t value1, Float_t value2, Float_t value3, BinnedParamsParams& params, Int_t& index){
604  //********************************************************************
605 
606  BinnedParamsBin* bin = NULL;
607  if (!GetBin(value1, value2, value3, bin)) return false;
608 
609  params.mean = bin->_mean;
610  params.sigma = bin->_sigma;
611  params.meanMCANA = bin->_meanREAL;
612  params.meanMC = bin->_meanMC;
613  params.sigmaMCl = bin->_sigmaMCl;
614  params.sigmaMCh = bin->_sigmaMCh;
615  params.meanDATA = bin->_meanDATA;
616  params.sigmaDATAl = bin->_sigmaDATAl;
617  params.sigmaDATAh = bin->_sigmaDATAh;
618 
619  index = bin->_index;
620 
621  return true;
622 }
623 
624 //********************************************************************
625 bool BinnedParams::UpdateEfficiencyCounter(Int_t index, bool correct){
626  //********************************************************************
627  if((UInt_t)index>=NMAXSYSTSOURCEBINS) {
628  std::cout<<" problem size of the array is " << NMAXSYSTSOURCEBINS << ", bin index is "<<index<<std::endl;
629  return false;
630  }
631  if (correct) _ncorrect[index]++;
632  else _nwrong[index]++;
633 
634  return true;
635 }
636 
637 //********************************************************************
638 void BinnedParams::AddGraphBin(Float_t min, Float_t max,
639  Float_t mean,
640  Float_t sigma){
641  //********************************************************************
642 
643  if (_nGraphBins == 0)
644  _graphBins[_nGraphBins++] = new BinnedParamsGraphBin();
645 
646  _graphBins[0]->Update(min, max, mean, sigma);
647  return;
648 
649 }
650 
651 //********************************************************************
652 void BinnedParams::AddGraphBin(Float_t max, Float_t min,
653  Float_t meanREAL,
654  Float_t meanMC,
655  Float_t sigmaMCl,
656  Float_t sigmaMCh,
657  Float_t meanDATA,
658  Float_t sigmaDATAl,
659  Float_t sigmaDATAh){
660  //********************************************************************
661  if (_nGraphBins == 0)
662  _graphBins[_nGraphBins++] = new BinnedParamsGraphBin();
663 
664  _graphBins[0]->Update(min, max,
665  meanREAL,
666  meanMC,
667  sigmaMCl,
668  sigmaMCh,
669  meanDATA,
670  sigmaDATAl,
671  sigmaDATAh);
672  return;
673 }
674 
675 
676 
677 //********************************************************************
678 void BinnedParams::AddGraphBin(Float_t min, Float_t max, Float_t min2, Float_t max2,
679  Float_t mean,
680  Float_t sigma){
681  //********************************************************************
682 
683  //check whether a bin already exists
684  BinnedParamsGraphBin* bin = NULL;
685  Float_t value = (max + min)/2;
686 
687  if (!GetGraphBin(value, bin)){
688  bin = new BinnedParamsGraphBin(min, max);
689  _graphBins[_nGraphBins++] = bin;
690  }
691 
692  bin->Update(min2, max2,
693  mean,
694  sigma);
695 
696 }
697 
698 //********************************************************************
699 void BinnedParams::AddGraphBin(Float_t min, Float_t max, Float_t min2, Float_t max2,
700  Float_t meanREAL,
701  Float_t meanMC,
702  Float_t sigmaMCl,
703  Float_t sigmaMCh,
704  Float_t meanDATA,
705  Float_t sigmaDATAl,
706  Float_t sigmaDATAh){
707  //********************************************************************
708 
709  //check whether a bin already exists
710  BinnedParamsGraphBin* bin = NULL;
711  Float_t value = (max + min)/2;
712 
713  if (!GetGraphBin(value, bin)){
714  bin = new BinnedParamsGraphBin(min, max);
715  _graphBins[_nGraphBins++] = bin;
716  }
717 
718  bin->Update(min2, max2,
719  meanREAL,
720  meanMC,
721  sigmaMCl,
722  sigmaMCh,
723  meanDATA,
724  sigmaDATAl,
725  sigmaDATAh);
726 }
727 
728 //********************************************************************
729 void BinnedParams::AddGraphBin(Float_t min, Float_t max, Float_t min2, Float_t max2, Float_t min3, Float_t max3,
730  Float_t mean,
731  Float_t sigma){
732  //********************************************************************
733 
734  //check whether a bin already exists
735  BinnedParamsGraphBin* bin = NULL;
736  Float_t value1 = (max + min)/2;
737 
738  Float_t value2 = (max2 + min2)/2;
739 
740 
741  if (!GetGraphBin(value1, value2, bin)){
742  bin = new BinnedParamsGraphBin(min, max, min2, max2);
743  _graphBins[_nGraphBins++] = bin;
744  }
745 
746  bin->Update(min3, max3,
747  mean,
748  sigma);
749 
750 }
751 
752 //********************************************************************
753 void BinnedParams::AddGraphBin(Float_t min, Float_t max, Float_t min2, Float_t max2, Float_t min3, Float_t max3,
754  Float_t meanREAL,
755  Float_t meanMC,
756  Float_t sigmaMCl,
757  Float_t sigmaMCh,
758  Float_t meanDATA,
759  Float_t sigmaDATAl,
760  Float_t sigmaDATAh){
761  //********************************************************************
762 
763 
764  //check whether a bin already exists
765  BinnedParamsGraphBin* bin = NULL;
766  Float_t value1 = (max + min)/2;
767 
768  Float_t value2 = (max2 + min2)/2;
769 
770 
771  if (!GetGraphBin(value1, value2, bin)){
772  bin = new BinnedParamsGraphBin(min, max, min2, max2);
773  _graphBins[_nGraphBins++] = bin;
774  }
775 
776  bin->Update(min3, max3,
777  meanREAL,
778  meanMC,
779  sigmaMCl,
780  sigmaMCh,
781  meanDATA,
782  sigmaDATAl,
783  sigmaDATAh);
784 
785 
786 }
787 
788 
789 //********************************************************************
790 bool BinnedParams::GetGraphBin(Float_t value1, BinnedParamsGraphBin*& bin){
791  //********************************************************************
792 
793  if (_typeShort!=k2D) return false;
794 
795  Int_t idx=0;
796  for (Int_t it=0; it<_nGraphBins;it++){
797  if (value1>=_graphBins[it]->_min && value1<_graphBins[it]->_max){
798  bin = _graphBins[it];
799  bin->_index=idx;
800  return true;
801  }
802  idx++;
803  }
804 
805  return false;
806 }
807 
808 //********************************************************************
809 bool BinnedParams::GetGraphBin(Float_t value1, Float_t value2, BinnedParamsGraphBin*& bin){
810  //********************************************************************
811 
812  if (_typeShort!=k3D) return false;
813 
814  Int_t idx=0;
815  for (Int_t it=0; it<_nGraphBins;it++){
816  if (value1>=_graphBins[it]->_min && value1<_graphBins[it]->_max
817  && value2>= _graphBins[it]->_min2 && value2 < _graphBins[it]->_max2){
818  bin = _graphBins[it];
819  bin->_index=idx;
820  return true;
821  }
822  idx++;
823  }
824 
825  return false;
826 }
827 
828 //********************************************************************
829 bool BinnedParams::GetInterBinValues(Float_t value1, BinnedParamsParams& params){
830  //********************************************************************
831  //check whether a bin already exists
832  if (_nGraphBins == 0) return false;
833  BinnedParamsGraphBin* bin = _graphBins[0];
834 
835  if (!bin) return false;
836 
837  return bin->GetParams(value1, params);
838 }
839 
840 //********************************************************************
841 bool BinnedParams::GetInterBinValues(Float_t value1, Float_t value2, BinnedParamsParams& params){
842  //********************************************************************
843 
844  //check whether a bin exists
845  BinnedParamsGraphBin* bin = NULL;
846 
847  if (!GetGraphBin(value1, bin)) return false;
848 
849  return bin->GetParams(value2, params);
850 }
851 
852 //********************************************************************
853 bool BinnedParams::GetInterBinValues(Float_t value1, Float_t value2, Float_t value3, BinnedParamsParams& params){
854  //********************************************************************
855 
856  //check whether a bin exists
857  BinnedParamsGraphBin* bin = NULL;
858 
859  if (!GetGraphBin(value1, value2, bin)) return false;
860 
861  return bin->GetParams(value3, params);
862 
863 }
864 
865 //********************************************************************
866 bool BinnedParamsGraphBin::GetParams(Float_t value, BinnedParamsParams& params){
867  //********************************************************************
868 
869  if (!GetValue( BinnedParamsGraphBin::kMean, value, params.mean ))
870  return false;
871  if (!GetValue( BinnedParamsGraphBin::kSigma, value, params.sigma ))
872  return false;
873  if (!GetValue( BinnedParamsGraphBin::kMeanMCANA, value, params.meanMCANA ))
874  return false;
875  if (!GetValue( BinnedParamsGraphBin::kMeanMC, value, params.meanMC ))
876  return false;
877  if (!GetValue( BinnedParamsGraphBin::kSigmaMCl, value, params.sigmaMCl ))
878  return false;
879  if (!GetValue( BinnedParamsGraphBin::kSigmaMCh, value, params.sigmaMCh ))
880  return false;
881  if (!GetValue( BinnedParamsGraphBin::kMeanDATA, value, params.meanDATA ))
882  return false;
883  if (!GetValue( BinnedParamsGraphBin::kSigmaDATAl, value, params.sigmaDATAl ))
884  return false;
885  if (!GetValue( BinnedParamsGraphBin::kSigmaDATAh, value, params.sigmaDATAh ))
886  return false;
887 
888  return true;
889 
890 }
891 
BinnedParamsBin::_meanREAL
Float_t _meanREAL
mean and sigma for this bin
Definition: BinnedParams.hxx:237
BinnedParams::GetBinIndex
bool GetBinIndex(Float_t value, Int_t &index)
Gets the bin index for a 1D source.
Definition: BinnedParams.cxx:450
BinnedParamsGraphBin::GetParams
bool GetParams(Float_t value, BinnedParamsParams &params)
Fill params given a value.
Definition: BinnedParams.cxx:866
BinnedParams::Print
void Print()
Dump into the screen the systematic source values.
Definition: BinnedParams.cxx:66
BinnedParams::SetType
void SetType(TypeEnum type)
Set the type.
Definition: BinnedParams.cxx:36
BinnedParamsParams::sigma
Float_t sigma
The sigma value for each of the systematic parameters of the control sample taking errors from data a...
Definition: BinnedParams.hxx:67
BinnedParams::GetGraphBin
bool GetGraphBin(Float_t value, BinnedParamsGraphBin *&bin)
Gets the bin for a 2D source.
Definition: BinnedParams.cxx:790
BinnedParams::GetBinValues
bool GetBinValues(Float_t value, Float_t &mean, Float_t &sigma)
Gets the bin values for a 1D source.
Definition: BinnedParams.hxx:559
BinnedParamsParams::meanDATA
Float_t meanDATA
The mean value for each of the systematic parameters of the control sample.
Definition: BinnedParams.hxx:44
BinnedParams::UpdateEfficiencyCounter
bool UpdateEfficiencyCounter(Int_t index, bool correct)
Update the efficiency variables _ncorrect and _nwrong.
Definition: BinnedParams.cxx:625
BinnedParamsBin::_sigmaDATAl
Float_t _sigmaDATAl
Efficiency of the DATA control sample.
Definition: BinnedParams.hxx:242
BinnedParamsBin::_mean
Float_t _mean
mean and sigma for this bin
Definition: BinnedParams.hxx:233
BinnedParamsParams::meanMC
Float_t meanMC
The mean value for each of the systematic parameters of the control sample.
Definition: BinnedParams.hxx:52
BinnedParams::Read
void Read(const std::string &inputDirName, const std::string &extension="")
Read from a file the systematic source values.
Definition: BinnedParams.cxx:176
BinnedParams::AddBin
void AddBin(Float_t min, Float_t max, Float_t meanREAL, Float_t meanMC, Float_t sigmaMCl, Float_t sigmaMCh, Float_t meanDATA, Float_t sigmaDATAl, Float_t sigmaDATAh)
Add a new bin for a 1D source.
Definition: BinnedParams.hxx:340
BinnedParamsBin::_sigmaMCl
Float_t _sigmaMCl
Efficiency of the MC control sample.
Definition: BinnedParams.hxx:239
BinnedParams::GetInterBinValues
bool GetInterBinValues(Float_t value1, BinnedParamsParams &params)
Get values using interpolation.
Definition: BinnedParams.cxx:829
BinnedParams::TypeEnum
TypeEnum
Enumerator describing the values that _type member can take.
Definition: BinnedParams.hxx:255
BinnedParamsParams::mean
Float_t mean
The mean value for each of the systematic parameters of the control sample.
Definition: BinnedParams.hxx:64
BinnedParamsParams::meanMCANA
Float_t meanMCANA
The mean value for each of the systematic parameters of the analysis sample.
Definition: BinnedParams.hxx:61
BinnedParamsBin::_sigmaMCh
Float_t _sigmaMCh
Low error on Efficiency of the MC control sample.
Definition: BinnedParams.hxx:240
BinnedParamsBin::_meanMC
Float_t _meanMC
Efficiency of the MC analysis sample.
Definition: BinnedParams.hxx:238
BinnedParams::GetBin
bool GetBin(Float_t value, BinnedParamsBin *&bin)
Gets the bin for a 1D source.
Definition: BinnedParams.cxx:388
BinnedParams::AddGraphBin
void AddGraphBin(Float_t min, Float_t max, Float_t meanREAL, Float_t meanMC, Float_t sigmaMCl, Float_t sigmaMCh, Float_t meanDATA, Float_t sigmaDATAl, Float_t sigmaDATAh)
Add a new bin graph for a 1D source.
Definition: BinnedParams.cxx:652
BinnedParamsParams::sigmaDATAl
Float_t sigmaDATAl
The sigma value for each of the systematic parameters of the control sample /// with possibility of a...
Definition: BinnedParams.hxx:48
BinnedParams::GetParametersForBin
bool GetParametersForBin(Int_t index, Float_t &mean, Float_t &sigma)
Gets the bin values for a source provided the bin index.
Definition: BinnedParams.cxx:469
BinnedParamsBin::_index
Int_t _index
high error on Efficiency of the DATA control sample
Definition: BinnedParams.hxx:246
BinnedParamsBin::_sigmaDATAh
Float_t _sigmaDATAh
Low error on Efficiency of the DATA control sample.
Definition: BinnedParams.hxx:243
BinnedParamsGraphBin::Update
void Update(Float_t min, Float_t max, Float_t meanREAL, Float_t meanMC, Float_t sigmaMCl, Float_t sigmaMCh, Float_t meanDATA, Float_t sigmaDATAl, Float_t sigmaDATAh)
Update.
Definition: BinnedParams.hxx:111
BinnedParamsBin::_meanDATA
Float_t _meanDATA
high error on Efficiency of the MC control sample
Definition: BinnedParams.hxx:241
Generated by   doxygen 1.8.13