BAT  0.9.4
The Bayesian analysis toolkit
 All Classes Namespaces Functions Variables Enumerations
libBATmodels_rdict.cxx
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME libBATmodels_rdictdOcxx
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <math.h>
10 #include <string.h>
11 #include <assert.h>
12 #define G__DICTIONARY
13 #include "RConfig.h"
14 #include "TClass.h"
15 #include "TDictAttributeMap.h"
16 #include "TInterpreter.h"
17 #include "TROOT.h"
18 #include "TBuffer.h"
19 #include "TMemberInspector.h"
20 #include "TInterpreter.h"
21 #include "TVirtualMutex.h"
22 #include "TError.h"
23 
24 #ifndef G__ROOT
25 #define G__ROOT
26 #endif
27 
28 #include "RtypesImp.h"
29 #include "TIsAProxy.h"
30 #include "TFileMergeInfo.h"
31 #include <algorithm>
32 #include "TCollectionProxyInfo.h"
33 /*******************************************************************/
34 
35 #include "TDataMember.h"
36 
37 // Since CINT ignores the std namespace, we need to do so in this file.
38 namespace std {} using namespace std;
39 
40 // Header files passed as explicit arguments
41 #include "BCFitter.h"
42 #include "BCEfficiencyFitter.h"
43 #include "BCGraphFitter.h"
44 #include "BCHistogramFitter.h"
45 #include "BCRooInterface.h"
46 #include "BATCalculator.h"
47 
48 // Header files passed via #pragma extra_include
49 
50 namespace RooStats {
51  namespace ROOT {
52  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
53  static TClass *RooStats_Dictionary();
54 
55  // Function generating the singleton type initializer
56  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
57  {
58  static ::ROOT::TGenericClassInfo
59  instance("RooStats", 0 /*version*/, "BAT/MarkovChain.h", 40,
60  ::ROOT::DefineBehavior((void*)0,(void*)0),
61  &RooStats_Dictionary, 0);
62  return &instance;
63  }
64  // Insure that the inline function is _not_ optimized away by the compiler
65  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;
66  // Static variable to force the class initialization
67  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
68 
69  // Dictionary for non-ClassDef classes
70  static TClass *RooStats_Dictionary() {
71  return GenerateInitInstance()->GetClass();
72  }
73 
74  }
75 }
76 
77 namespace ROOT {
78  static TClass *BCFitter_Dictionary();
79  static void BCFitter_TClassManip(TClass*);
80  static void delete_BCFitter(void *p);
81  static void deleteArray_BCFitter(void *p);
82  static void destruct_BCFitter(void *p);
83 
84  // Function generating the singleton type initializer
85  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCFitter*)
86  {
87  ::BCFitter *ptr = 0;
88  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCFitter),0);
89  static ::ROOT::TGenericClassInfo
90  instance("BCFitter", "BAT/BCFitter.h", 27,
91  typeid(::BCFitter), DefineBehavior(ptr, ptr),
92  &BCFitter_Dictionary, isa_proxy, 1,
93  sizeof(::BCFitter) );
94  instance.SetDelete(&delete_BCFitter);
95  instance.SetDeleteArray(&deleteArray_BCFitter);
96  instance.SetDestructor(&destruct_BCFitter);
97  return &instance;
98  }
99  TGenericClassInfo *GenerateInitInstance(const ::BCFitter*)
100  {
101  return GenerateInitInstanceLocal((::BCFitter*)0);
102  }
103  // Static variable to force the class initialization
104  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
105 
106  // Dictionary for non-ClassDef classes
107  static TClass *BCFitter_Dictionary() {
108  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCFitter*)0x0)->GetClass();
109  BCFitter_TClassManip(theClass);
110  return theClass;
111  }
112 
113  static void BCFitter_TClassManip(TClass* ){
114  }
115 
116 } // end of namespace ROOT
117 
118 namespace ROOT {
119  static TClass *BCGraphFitter_Dictionary();
120  static void BCGraphFitter_TClassManip(TClass*);
121  static void *new_BCGraphFitter(void *p = 0);
122  static void *newArray_BCGraphFitter(Long_t size, void *p);
123  static void delete_BCGraphFitter(void *p);
124  static void deleteArray_BCGraphFitter(void *p);
125  static void destruct_BCGraphFitter(void *p);
126 
127  // Function generating the singleton type initializer
128  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCGraphFitter*)
129  {
130  ::BCGraphFitter *ptr = 0;
131  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCGraphFitter),0);
132  static ::ROOT::TGenericClassInfo
133  instance("BCGraphFitter", "BAT/BCGraphFitter.h", 35,
134  typeid(::BCGraphFitter), DefineBehavior(ptr, ptr),
135  &BCGraphFitter_Dictionary, isa_proxy, 1,
136  sizeof(::BCGraphFitter) );
137  instance.SetNew(&new_BCGraphFitter);
138  instance.SetNewArray(&newArray_BCGraphFitter);
139  instance.SetDelete(&delete_BCGraphFitter);
140  instance.SetDeleteArray(&deleteArray_BCGraphFitter);
141  instance.SetDestructor(&destruct_BCGraphFitter);
142  return &instance;
143  }
144  TGenericClassInfo *GenerateInitInstance(const ::BCGraphFitter*)
145  {
146  return GenerateInitInstanceLocal((::BCGraphFitter*)0);
147  }
148  // Static variable to force the class initialization
149  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCGraphFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
150 
151  // Dictionary for non-ClassDef classes
152  static TClass *BCGraphFitter_Dictionary() {
153  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCGraphFitter*)0x0)->GetClass();
154  BCGraphFitter_TClassManip(theClass);
155  return theClass;
156  }
157 
158  static void BCGraphFitter_TClassManip(TClass* ){
159  }
160 
161 } // end of namespace ROOT
162 
163 namespace ROOT {
164  static TClass *BCEfficiencyFitter_Dictionary();
165  static void BCEfficiencyFitter_TClassManip(TClass*);
166  static void *new_BCEfficiencyFitter(void *p = 0);
167  static void *newArray_BCEfficiencyFitter(Long_t size, void *p);
168  static void delete_BCEfficiencyFitter(void *p);
169  static void deleteArray_BCEfficiencyFitter(void *p);
170  static void destruct_BCEfficiencyFitter(void *p);
171 
172  // Function generating the singleton type initializer
173  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCEfficiencyFitter*)
174  {
175  ::BCEfficiencyFitter *ptr = 0;
176  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCEfficiencyFitter),0);
177  static ::ROOT::TGenericClassInfo
178  instance("BCEfficiencyFitter", "BAT/BCEfficiencyFitter.h", 39,
179  typeid(::BCEfficiencyFitter), DefineBehavior(ptr, ptr),
180  &BCEfficiencyFitter_Dictionary, isa_proxy, 1,
181  sizeof(::BCEfficiencyFitter) );
182  instance.SetNew(&new_BCEfficiencyFitter);
183  instance.SetNewArray(&newArray_BCEfficiencyFitter);
184  instance.SetDelete(&delete_BCEfficiencyFitter);
185  instance.SetDeleteArray(&deleteArray_BCEfficiencyFitter);
186  instance.SetDestructor(&destruct_BCEfficiencyFitter);
187  return &instance;
188  }
189  TGenericClassInfo *GenerateInitInstance(const ::BCEfficiencyFitter*)
190  {
191  return GenerateInitInstanceLocal((::BCEfficiencyFitter*)0);
192  }
193  // Static variable to force the class initialization
194  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCEfficiencyFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
195 
196  // Dictionary for non-ClassDef classes
197  static TClass *BCEfficiencyFitter_Dictionary() {
198  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCEfficiencyFitter*)0x0)->GetClass();
199  BCEfficiencyFitter_TClassManip(theClass);
200  return theClass;
201  }
202 
203  static void BCEfficiencyFitter_TClassManip(TClass* ){
204  }
205 
206 } // end of namespace ROOT
207 
208 namespace ROOT {
209  static TClass *BCHistogramFitter_Dictionary();
210  static void BCHistogramFitter_TClassManip(TClass*);
211  static void *new_BCHistogramFitter(void *p = 0);
212  static void *newArray_BCHistogramFitter(Long_t size, void *p);
213  static void delete_BCHistogramFitter(void *p);
214  static void deleteArray_BCHistogramFitter(void *p);
215  static void destruct_BCHistogramFitter(void *p);
216 
217  // Function generating the singleton type initializer
218  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCHistogramFitter*)
219  {
220  ::BCHistogramFitter *ptr = 0;
221  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCHistogramFitter),0);
222  static ::ROOT::TGenericClassInfo
223  instance("BCHistogramFitter", "BAT/BCHistogramFitter.h", 35,
224  typeid(::BCHistogramFitter), DefineBehavior(ptr, ptr),
225  &BCHistogramFitter_Dictionary, isa_proxy, 1,
226  sizeof(::BCHistogramFitter) );
227  instance.SetNew(&new_BCHistogramFitter);
228  instance.SetNewArray(&newArray_BCHistogramFitter);
229  instance.SetDelete(&delete_BCHistogramFitter);
230  instance.SetDeleteArray(&deleteArray_BCHistogramFitter);
231  instance.SetDestructor(&destruct_BCHistogramFitter);
232  return &instance;
233  }
234  TGenericClassInfo *GenerateInitInstance(const ::BCHistogramFitter*)
235  {
236  return GenerateInitInstanceLocal((::BCHistogramFitter*)0);
237  }
238  // Static variable to force the class initialization
239  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCHistogramFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
240 
241  // Dictionary for non-ClassDef classes
242  static TClass *BCHistogramFitter_Dictionary() {
243  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCHistogramFitter*)0x0)->GetClass();
244  BCHistogramFitter_TClassManip(theClass);
245  return theClass;
246  }
247 
248  static void BCHistogramFitter_TClassManip(TClass* ){
249  }
250 
251 } // end of namespace ROOT
252 
253 namespace ROOT {
254  static TClass *BCRooInterface_Dictionary();
255  static void BCRooInterface_TClassManip(TClass*);
256  static void *new_BCRooInterface(void *p = 0);
257  static void *newArray_BCRooInterface(Long_t size, void *p);
258  static void delete_BCRooInterface(void *p);
259  static void deleteArray_BCRooInterface(void *p);
260  static void destruct_BCRooInterface(void *p);
261 
262  // Function generating the singleton type initializer
263  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCRooInterface*)
264  {
265  ::BCRooInterface *ptr = 0;
266  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCRooInterface),0);
267  static ::ROOT::TGenericClassInfo
268  instance("BCRooInterface", "BAT/BCRooInterface.h", 23,
269  typeid(::BCRooInterface), DefineBehavior(ptr, ptr),
270  &BCRooInterface_Dictionary, isa_proxy, 1,
271  sizeof(::BCRooInterface) );
272  instance.SetNew(&new_BCRooInterface);
273  instance.SetNewArray(&newArray_BCRooInterface);
274  instance.SetDelete(&delete_BCRooInterface);
275  instance.SetDeleteArray(&deleteArray_BCRooInterface);
276  instance.SetDestructor(&destruct_BCRooInterface);
277  return &instance;
278  }
279  TGenericClassInfo *GenerateInitInstance(const ::BCRooInterface*)
280  {
281  return GenerateInitInstanceLocal((::BCRooInterface*)0);
282  }
283  // Static variable to force the class initialization
284  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCRooInterface*)0x0); R__UseDummy(_R__UNIQUE_(Init));
285 
286  // Dictionary for non-ClassDef classes
287  static TClass *BCRooInterface_Dictionary() {
288  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCRooInterface*)0x0)->GetClass();
289  BCRooInterface_TClassManip(theClass);
290  return theClass;
291  }
292 
293  static void BCRooInterface_TClassManip(TClass* ){
294  }
295 
296 } // end of namespace ROOT
297 
298 namespace ROOT {
299  static void *new_RooStatscLcLBATCalculator(void *p = 0);
300  static void *newArray_RooStatscLcLBATCalculator(Long_t size, void *p);
301  static void delete_RooStatscLcLBATCalculator(void *p);
302  static void deleteArray_RooStatscLcLBATCalculator(void *p);
303  static void destruct_RooStatscLcLBATCalculator(void *p);
304 
305  // Function generating the singleton type initializer
306  static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::BATCalculator*)
307  {
308  ::RooStats::BATCalculator *ptr = 0;
309  static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::BATCalculator >(0);
310  static ::ROOT::TGenericClassInfo
311  instance("RooStats::BATCalculator", ::RooStats::BATCalculator::Class_Version(), "BAT/BATCalculator.h", 31,
312  typeid(::RooStats::BATCalculator), DefineBehavior(ptr, ptr),
313  &::RooStats::BATCalculator::Dictionary, isa_proxy, 4,
314  sizeof(::RooStats::BATCalculator) );
315  instance.SetNew(&new_RooStatscLcLBATCalculator);
316  instance.SetNewArray(&newArray_RooStatscLcLBATCalculator);
317  instance.SetDelete(&delete_RooStatscLcLBATCalculator);
318  instance.SetDeleteArray(&deleteArray_RooStatscLcLBATCalculator);
319  instance.SetDestructor(&destruct_RooStatscLcLBATCalculator);
320  return &instance;
321  }
322  TGenericClassInfo *GenerateInitInstance(const ::RooStats::BATCalculator*)
323  {
324  return GenerateInitInstanceLocal((::RooStats::BATCalculator*)0);
325  }
326  // Static variable to force the class initialization
327  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::BATCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
328 } // end of namespace ROOT
329 
330 namespace RooStats {
331 //______________________________________________________________________________
332 atomic_TClass_ptr BATCalculator::fgIsA(0); // static to hold class pointer
333 
334 //______________________________________________________________________________
335 const char *BATCalculator::Class_Name()
336 {
337  return "RooStats::BATCalculator";
338 }
339 
340 //______________________________________________________________________________
341 const char *BATCalculator::ImplFileName()
342 {
343  return ::ROOT::GenerateInitInstanceLocal((const ::RooStats::BATCalculator*)0x0)->GetImplFileName();
344 }
345 
346 //______________________________________________________________________________
347 int BATCalculator::ImplFileLine()
348 {
349  return ::ROOT::GenerateInitInstanceLocal((const ::RooStats::BATCalculator*)0x0)->GetImplFileLine();
350 }
351 
352 //______________________________________________________________________________
353 TClass *BATCalculator::Dictionary()
354 {
355  fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RooStats::BATCalculator*)0x0)->GetClass();
356  return fgIsA;
357 }
358 
359 //______________________________________________________________________________
360 TClass *BATCalculator::Class()
361 {
362  if (!fgIsA) { R__LOCKGUARD2(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RooStats::BATCalculator*)0x0)->GetClass(); }
363  return fgIsA;
364 }
365 
366 } // namespace RooStats
367 namespace ROOT {
368  // Wrapper around operator delete
369  static void delete_BCFitter(void *p) {
370  delete ((::BCFitter*)p);
371  }
372  static void deleteArray_BCFitter(void *p) {
373  delete [] ((::BCFitter*)p);
374  }
375  static void destruct_BCFitter(void *p) {
376  typedef ::BCFitter current_t;
377  ((current_t*)p)->~current_t();
378  }
379 } // end of namespace ROOT for class ::BCFitter
380 
381 namespace ROOT {
382  // Wrappers around operator new
383  static void *new_BCGraphFitter(void *p) {
384  return p ? new(p) ::BCGraphFitter : new ::BCGraphFitter;
385  }
386  static void *newArray_BCGraphFitter(Long_t nElements, void *p) {
387  return p ? new(p) ::BCGraphFitter[nElements] : new ::BCGraphFitter[nElements];
388  }
389  // Wrapper around operator delete
390  static void delete_BCGraphFitter(void *p) {
391  delete ((::BCGraphFitter*)p);
392  }
393  static void deleteArray_BCGraphFitter(void *p) {
394  delete [] ((::BCGraphFitter*)p);
395  }
396  static void destruct_BCGraphFitter(void *p) {
397  typedef ::BCGraphFitter current_t;
398  ((current_t*)p)->~current_t();
399  }
400 } // end of namespace ROOT for class ::BCGraphFitter
401 
402 namespace ROOT {
403  // Wrappers around operator new
404  static void *new_BCEfficiencyFitter(void *p) {
405  return p ? new(p) ::BCEfficiencyFitter : new ::BCEfficiencyFitter;
406  }
407  static void *newArray_BCEfficiencyFitter(Long_t nElements, void *p) {
408  return p ? new(p) ::BCEfficiencyFitter[nElements] : new ::BCEfficiencyFitter[nElements];
409  }
410  // Wrapper around operator delete
411  static void delete_BCEfficiencyFitter(void *p) {
412  delete ((::BCEfficiencyFitter*)p);
413  }
414  static void deleteArray_BCEfficiencyFitter(void *p) {
415  delete [] ((::BCEfficiencyFitter*)p);
416  }
417  static void destruct_BCEfficiencyFitter(void *p) {
418  typedef ::BCEfficiencyFitter current_t;
419  ((current_t*)p)->~current_t();
420  }
421 } // end of namespace ROOT for class ::BCEfficiencyFitter
422 
423 namespace ROOT {
424  // Wrappers around operator new
425  static void *new_BCHistogramFitter(void *p) {
426  return p ? new(p) ::BCHistogramFitter : new ::BCHistogramFitter;
427  }
428  static void *newArray_BCHistogramFitter(Long_t nElements, void *p) {
429  return p ? new(p) ::BCHistogramFitter[nElements] : new ::BCHistogramFitter[nElements];
430  }
431  // Wrapper around operator delete
432  static void delete_BCHistogramFitter(void *p) {
433  delete ((::BCHistogramFitter*)p);
434  }
435  static void deleteArray_BCHistogramFitter(void *p) {
436  delete [] ((::BCHistogramFitter*)p);
437  }
438  static void destruct_BCHistogramFitter(void *p) {
439  typedef ::BCHistogramFitter current_t;
440  ((current_t*)p)->~current_t();
441  }
442 } // end of namespace ROOT for class ::BCHistogramFitter
443 
444 namespace ROOT {
445  // Wrappers around operator new
446  static void *new_BCRooInterface(void *p) {
447  return p ? new(p) ::BCRooInterface : new ::BCRooInterface;
448  }
449  static void *newArray_BCRooInterface(Long_t nElements, void *p) {
450  return p ? new(p) ::BCRooInterface[nElements] : new ::BCRooInterface[nElements];
451  }
452  // Wrapper around operator delete
453  static void delete_BCRooInterface(void *p) {
454  delete ((::BCRooInterface*)p);
455  }
456  static void deleteArray_BCRooInterface(void *p) {
457  delete [] ((::BCRooInterface*)p);
458  }
459  static void destruct_BCRooInterface(void *p) {
460  typedef ::BCRooInterface current_t;
461  ((current_t*)p)->~current_t();
462  }
463 } // end of namespace ROOT for class ::BCRooInterface
464 
465 namespace RooStats {
466 //______________________________________________________________________________
467 void BATCalculator::Streamer(TBuffer &R__b)
468 {
469  // Stream an object of class RooStats::BATCalculator.
470 
471  if (R__b.IsReading()) {
472  R__b.ReadClassBuffer(RooStats::BATCalculator::Class(),this);
473  } else {
474  R__b.WriteClassBuffer(RooStats::BATCalculator::Class(),this);
475  }
476 }
477 
478 } // namespace RooStats
479 namespace ROOT {
480  // Wrappers around operator new
481  static void *new_RooStatscLcLBATCalculator(void *p) {
482  return p ? new(p) ::RooStats::BATCalculator : new ::RooStats::BATCalculator;
483  }
484  static void *newArray_RooStatscLcLBATCalculator(Long_t nElements, void *p) {
485  return p ? new(p) ::RooStats::BATCalculator[nElements] : new ::RooStats::BATCalculator[nElements];
486  }
487  // Wrapper around operator delete
488  static void delete_RooStatscLcLBATCalculator(void *p) {
489  delete ((::RooStats::BATCalculator*)p);
490  }
491  static void deleteArray_RooStatscLcLBATCalculator(void *p) {
492  delete [] ((::RooStats::BATCalculator*)p);
493  }
494  static void destruct_RooStatscLcLBATCalculator(void *p) {
495  typedef ::RooStats::BATCalculator current_t;
496  ((current_t*)p)->~current_t();
497  }
498 } // end of namespace ROOT for class ::RooStats::BATCalculator
499 
500 namespace ROOT {
501  static TClass *vectorlEdoublegR_Dictionary();
502  static void vectorlEdoublegR_TClassManip(TClass*);
503  static void *new_vectorlEdoublegR(void *p = 0);
504  static void *newArray_vectorlEdoublegR(Long_t size, void *p);
505  static void delete_vectorlEdoublegR(void *p);
506  static void deleteArray_vectorlEdoublegR(void *p);
507  static void destruct_vectorlEdoublegR(void *p);
508 
509  // Function generating the singleton type initializer
510  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
511  {
512  vector<double> *ptr = 0;
513  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
514  static ::ROOT::TGenericClassInfo
515  instance("vector<double>", -2, "vector", 210,
516  typeid(vector<double>), DefineBehavior(ptr, ptr),
517  &vectorlEdoublegR_Dictionary, isa_proxy, 0,
518  sizeof(vector<double>) );
519  instance.SetNew(&new_vectorlEdoublegR);
520  instance.SetNewArray(&newArray_vectorlEdoublegR);
521  instance.SetDelete(&delete_vectorlEdoublegR);
522  instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
523  instance.SetDestructor(&destruct_vectorlEdoublegR);
524  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
525  return &instance;
526  }
527  // Static variable to force the class initialization
528  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
529 
530  // Dictionary for non-ClassDef classes
531  static TClass *vectorlEdoublegR_Dictionary() {
532  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
533  vectorlEdoublegR_TClassManip(theClass);
534  return theClass;
535  }
536 
537  static void vectorlEdoublegR_TClassManip(TClass* ){
538  }
539 
540 } // end of namespace ROOT
541 
542 namespace ROOT {
543  // Wrappers around operator new
544  static void *new_vectorlEdoublegR(void *p) {
545  return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
546  }
547  static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
548  return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
549  }
550  // Wrapper around operator delete
551  static void delete_vectorlEdoublegR(void *p) {
552  delete ((vector<double>*)p);
553  }
554  static void deleteArray_vectorlEdoublegR(void *p) {
555  delete [] ((vector<double>*)p);
556  }
557  static void destruct_vectorlEdoublegR(void *p) {
558  typedef vector<double> current_t;
559  ((current_t*)p)->~current_t();
560  }
561 } // end of namespace ROOT for class vector<double>
562 
563 namespace {
564  void TriggerDictionaryInitialization_libBATmodels_Impl() {
565  static const char* headers[] = {
566 "BAT/BCFitter.h",
567 "BAT/BCEfficiencyFitter.h",
568 "BAT/BCGraphFitter.h",
569 "BAT/BCHistogramFitter.h",
570 "BAT/BCRooInterface.h",
571 "BAT/BATCalculator.h",
572 0
573  };
574  static const char* includePaths[] = {
575 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
576 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
577 "/home/beaujean/.local/sw/bat/linux-ubuntu-14.04-x86_64/0.9.4/include",
578 "/home/beaujean/.local/sw/root/linux-ubuntu-14.04-x86_64/6.02.00/include/root",
579 0
580  };
581  static const char* fwdDeclCode =
582 R"DICTFWDDCLS(
583 #pragma clang diagnostic ignored "-Wkeyword-compat"
584 #pragma clang diagnostic ignored "-Wignored-attributes"
585 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
586 extern int __Cling_Autoloading_Map;
587 class __attribute__((annotate("$clingAutoload$BAT/BCFitter.h"))) BCFitter;
588 class __attribute__((annotate("$clingAutoload$BAT/BCGraphFitter.h"))) BCGraphFitter;
589 class __attribute__((annotate("$clingAutoload$BAT/BCEfficiencyFitter.h"))) BCEfficiencyFitter;
590 class __attribute__((annotate("$clingAutoload$BAT/BCHistogramFitter.h"))) BCHistogramFitter;
591 class __attribute__((annotate("$clingAutoload$BAT/BCRooInterface.h"))) BCRooInterface;
592 namespace RooStats{class __attribute__((annotate(R"ATTRDUMP(BATCalculator class)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$BAT/BATCalculator.h"))) BATCalculator;}
593 )DICTFWDDCLS";
594  static const char* payloadCode = R"DICTPAYLOAD(
595 
596 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
597  #define G__VECTOR_HAS_CLASS_ITERATOR
598 #endif
599 
600 #define _BACKWARD_BACKWARD_WARNING_H
601 #include <BAT/BCFitter.h>
602 #include <BAT/BCEfficiencyFitter.h>
603 #include <BAT/BCGraphFitter.h>
604 #include <BAT/BCHistogramFitter.h>
605 #include <BAT/BCRooInterface.h>
606 #include <BAT/BATCalculator.h>
607 
608 #undef _BACKWARD_BACKWARD_WARNING_H
609 )DICTPAYLOAD";
610  static const char* classesHeaders[]={
611 "BCEfficiencyFitter", payloadCode, "@",
612 "BCFitter", payloadCode, "@",
613 "BCGraphFitter", payloadCode, "@",
614 "BCHistogramFitter", payloadCode, "@",
615 "BCRooInterface", payloadCode, "@",
616 "RooStats::BATCalculator", payloadCode, "@",
617 nullptr};
618 
619  static bool isInitialized = false;
620  if (!isInitialized) {
621  TROOT::RegisterModule("libBATmodels",
622  headers, includePaths, payloadCode, fwdDeclCode,
623  TriggerDictionaryInitialization_libBATmodels_Impl, {}, classesHeaders);
624  isInitialized = true;
625  }
626  }
627  static struct DictInit {
628  DictInit() {
629  TriggerDictionaryInitialization_libBATmodels_Impl();
630  }
631  } __TheDictionaryInitializer;
632 }
633 void TriggerDictionaryInitialization_libBATmodels() {
634  TriggerDictionaryInitialization_libBATmodels_Impl();
635 }
BCEfficiencyFitter
A class for fitting histograms with functions.
Definition: BCEfficiencyFitter.h:39
BCHistogramFitter
A class for fitting histograms with functions.
Definition: BCHistogramFitter.h:35
BCGraphFitter
A class for fitting graphs with functions.
Definition: BCGraphFitter.h:35
BCFitter
A base class for all fitting classes.
Definition: BCFitter.h:27