BAT  0.9.4
The Bayesian analysis toolkit
 All Classes Namespaces Functions Variables Enumerations
libBAT_rdict.cxx
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME libBAT_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 "../BAT/BCDataPoint.h"
42 #include "../BAT/BCDataSet.h"
43 #include "../BAT/BCH1D.h"
44 #include "../BAT/BCH2D.h"
45 #include "../BAT/BCParameter.h"
46 #include "../BAT/BCParameterSet.h"
47 #include "../BAT/BCEngineMCMC.h"
48 #include "../BAT/BCIntegrate.h"
49 #include "../BAT/BCModel.h"
50 #include "../BAT/BCModelManager.h"
51 #include "../BAT/BCModelOutput.h"
52 #include "../BAT/BCGoFTest.h"
53 #include "../BAT/BCLog.h"
54 #include "../BAT/BCMath.h"
55 #include "../BAT/BCAux.h"
56 #include "../BAT/BCSummaryTool.h"
57 #include "../BAT/BCSummaryPriorModel.h"
58 
59 // Header files passed via #pragma extra_include
60 
61 namespace BCMath {
62  namespace ROOT {
63  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
64  static TClass *BCMath_Dictionary();
65 
66  // Function generating the singleton type initializer
67  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
68  {
69  static ::ROOT::TGenericClassInfo
70  instance("BCMath", 0 /*version*/, "BAT/BCMath.h", 35,
71  ::ROOT::DefineBehavior((void*)0,(void*)0),
72  &BCMath_Dictionary, 0);
73  return &instance;
74  }
75  // Insure that the inline function is _not_ optimized away by the compiler
76  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;
77  // Static variable to force the class initialization
78  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
79 
80  // Dictionary for non-ClassDef classes
81  static TClass *BCMath_Dictionary() {
82  return GenerateInitInstance()->GetClass();
83  }
84 
85  }
86 }
87 
88 namespace BCAux {
89  namespace ROOT {
90  inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
91  static TClass *BCAux_Dictionary();
92 
93  // Function generating the singleton type initializer
94  inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
95  {
96  static ::ROOT::TGenericClassInfo
97  instance("BCAux", 0 /*version*/, "BAT/BCAux.h", 25,
98  ::ROOT::DefineBehavior((void*)0,(void*)0),
99  &BCAux_Dictionary, 0);
100  return &instance;
101  }
102  // Insure that the inline function is _not_ optimized away by the compiler
103  ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;
104  // Static variable to force the class initialization
105  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
106 
107  // Dictionary for non-ClassDef classes
108  static TClass *BCAux_Dictionary() {
109  return GenerateInitInstance()->GetClass();
110  }
111 
112  }
113 }
114 
115 namespace ROOT {
116  static TClass *BCDataPoint_Dictionary();
117  static void BCDataPoint_TClassManip(TClass*);
118  static void delete_BCDataPoint(void *p);
119  static void deleteArray_BCDataPoint(void *p);
120  static void destruct_BCDataPoint(void *p);
121 
122  // Function generating the singleton type initializer
123  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCDataPoint*)
124  {
125  ::BCDataPoint *ptr = 0;
126  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCDataPoint),0);
127  static ::ROOT::TGenericClassInfo
128  instance("BCDataPoint", "BAT/BCDataPoint.h", 31,
129  typeid(::BCDataPoint), DefineBehavior(ptr, ptr),
130  &BCDataPoint_Dictionary, isa_proxy, 1,
131  sizeof(::BCDataPoint) );
132  instance.SetDelete(&delete_BCDataPoint);
133  instance.SetDeleteArray(&deleteArray_BCDataPoint);
134  instance.SetDestructor(&destruct_BCDataPoint);
135  return &instance;
136  }
137  TGenericClassInfo *GenerateInitInstance(const ::BCDataPoint*)
138  {
139  return GenerateInitInstanceLocal((::BCDataPoint*)0);
140  }
141  // Static variable to force the class initialization
142  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCDataPoint*)0x0); R__UseDummy(_R__UNIQUE_(Init));
143 
144  // Dictionary for non-ClassDef classes
145  static TClass *BCDataPoint_Dictionary() {
146  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCDataPoint*)0x0)->GetClass();
147  BCDataPoint_TClassManip(theClass);
148  return theClass;
149  }
150 
151  static void BCDataPoint_TClassManip(TClass* ){
152  }
153 
154 } // end of namespace ROOT
155 
156 namespace ROOT {
157  static TClass *BCDataSet_Dictionary();
158  static void BCDataSet_TClassManip(TClass*);
159  static void *new_BCDataSet(void *p = 0);
160  static void *newArray_BCDataSet(Long_t size, void *p);
161  static void delete_BCDataSet(void *p);
162  static void deleteArray_BCDataSet(void *p);
163  static void destruct_BCDataSet(void *p);
164 
165  // Function generating the singleton type initializer
166  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCDataSet*)
167  {
168  ::BCDataSet *ptr = 0;
169  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCDataSet),0);
170  static ::ROOT::TGenericClassInfo
171  instance("BCDataSet", "BAT/BCDataSet.h", 37,
172  typeid(::BCDataSet), DefineBehavior(ptr, ptr),
173  &BCDataSet_Dictionary, isa_proxy, 1,
174  sizeof(::BCDataSet) );
175  instance.SetNew(&new_BCDataSet);
176  instance.SetNewArray(&newArray_BCDataSet);
177  instance.SetDelete(&delete_BCDataSet);
178  instance.SetDeleteArray(&deleteArray_BCDataSet);
179  instance.SetDestructor(&destruct_BCDataSet);
180  return &instance;
181  }
182  TGenericClassInfo *GenerateInitInstance(const ::BCDataSet*)
183  {
184  return GenerateInitInstanceLocal((::BCDataSet*)0);
185  }
186  // Static variable to force the class initialization
187  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCDataSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
188 
189  // Dictionary for non-ClassDef classes
190  static TClass *BCDataSet_Dictionary() {
191  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCDataSet*)0x0)->GetClass();
192  BCDataSet_TClassManip(theClass);
193  return theClass;
194  }
195 
196  static void BCDataSet_TClassManip(TClass* ){
197  }
198 
199 } // end of namespace ROOT
200 
201 namespace ROOT {
202  static TClass *BCEngineMCMC_Dictionary();
203  static void BCEngineMCMC_TClassManip(TClass*);
204  static void *new_BCEngineMCMC(void *p = 0);
205  static void *newArray_BCEngineMCMC(Long_t size, void *p);
206  static void delete_BCEngineMCMC(void *p);
207  static void deleteArray_BCEngineMCMC(void *p);
208  static void destruct_BCEngineMCMC(void *p);
209 
210  // Function generating the singleton type initializer
211  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCEngineMCMC*)
212  {
213  ::BCEngineMCMC *ptr = 0;
214  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCEngineMCMC),0);
215  static ::ROOT::TGenericClassInfo
216  instance("BCEngineMCMC", "BAT/BCEngineMCMC.h", 41,
217  typeid(::BCEngineMCMC), DefineBehavior(ptr, ptr),
218  &BCEngineMCMC_Dictionary, isa_proxy, 1,
219  sizeof(::BCEngineMCMC) );
220  instance.SetNew(&new_BCEngineMCMC);
221  instance.SetNewArray(&newArray_BCEngineMCMC);
222  instance.SetDelete(&delete_BCEngineMCMC);
223  instance.SetDeleteArray(&deleteArray_BCEngineMCMC);
224  instance.SetDestructor(&destruct_BCEngineMCMC);
225  return &instance;
226  }
227  TGenericClassInfo *GenerateInitInstance(const ::BCEngineMCMC*)
228  {
229  return GenerateInitInstanceLocal((::BCEngineMCMC*)0);
230  }
231  // Static variable to force the class initialization
232  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCEngineMCMC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
233 
234  // Dictionary for non-ClassDef classes
235  static TClass *BCEngineMCMC_Dictionary() {
236  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCEngineMCMC*)0x0)->GetClass();
237  BCEngineMCMC_TClassManip(theClass);
238  return theClass;
239  }
240 
241  static void BCEngineMCMC_TClassManip(TClass* ){
242  }
243 
244 } // end of namespace ROOT
245 
246 namespace ROOT {
247  static TClass *BCGoFTest_Dictionary();
248  static void BCGoFTest_TClassManip(TClass*);
249  static void delete_BCGoFTest(void *p);
250  static void deleteArray_BCGoFTest(void *p);
251  static void destruct_BCGoFTest(void *p);
252 
253  // Function generating the singleton type initializer
254  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCGoFTest*)
255  {
256  ::BCGoFTest *ptr = 0;
257  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCGoFTest),0);
258  static ::ROOT::TGenericClassInfo
259  instance("BCGoFTest", "BAT/BCGoFTest.h", 34,
260  typeid(::BCGoFTest), DefineBehavior(ptr, ptr),
261  &BCGoFTest_Dictionary, isa_proxy, 1,
262  sizeof(::BCGoFTest) );
263  instance.SetDelete(&delete_BCGoFTest);
264  instance.SetDeleteArray(&deleteArray_BCGoFTest);
265  instance.SetDestructor(&destruct_BCGoFTest);
266  return &instance;
267  }
268  TGenericClassInfo *GenerateInitInstance(const ::BCGoFTest*)
269  {
270  return GenerateInitInstanceLocal((::BCGoFTest*)0);
271  }
272  // Static variable to force the class initialization
273  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCGoFTest*)0x0); R__UseDummy(_R__UNIQUE_(Init));
274 
275  // Dictionary for non-ClassDef classes
276  static TClass *BCGoFTest_Dictionary() {
277  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCGoFTest*)0x0)->GetClass();
278  BCGoFTest_TClassManip(theClass);
279  return theClass;
280  }
281 
282  static void BCGoFTest_TClassManip(TClass* ){
283  }
284 
285 } // end of namespace ROOT
286 
287 namespace ROOT {
288  static TClass *BCH1D_Dictionary();
289  static void BCH1D_TClassManip(TClass*);
290  static void *new_BCH1D(void *p = 0);
291  static void *newArray_BCH1D(Long_t size, void *p);
292  static void delete_BCH1D(void *p);
293  static void deleteArray_BCH1D(void *p);
294  static void destruct_BCH1D(void *p);
295 
296  // Function generating the singleton type initializer
297  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCH1D*)
298  {
299  ::BCH1D *ptr = 0;
300  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCH1D),0);
301  static ::ROOT::TGenericClassInfo
302  instance("BCH1D", "BAT/BCH1D.h", 31,
303  typeid(::BCH1D), DefineBehavior(ptr, ptr),
304  &BCH1D_Dictionary, isa_proxy, 1,
305  sizeof(::BCH1D) );
306  instance.SetNew(&new_BCH1D);
307  instance.SetNewArray(&newArray_BCH1D);
308  instance.SetDelete(&delete_BCH1D);
309  instance.SetDeleteArray(&deleteArray_BCH1D);
310  instance.SetDestructor(&destruct_BCH1D);
311  return &instance;
312  }
313  TGenericClassInfo *GenerateInitInstance(const ::BCH1D*)
314  {
315  return GenerateInitInstanceLocal((::BCH1D*)0);
316  }
317  // Static variable to force the class initialization
318  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCH1D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
319 
320  // Dictionary for non-ClassDef classes
321  static TClass *BCH1D_Dictionary() {
322  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCH1D*)0x0)->GetClass();
323  BCH1D_TClassManip(theClass);
324  return theClass;
325  }
326 
327  static void BCH1D_TClassManip(TClass* ){
328  }
329 
330 } // end of namespace ROOT
331 
332 namespace ROOT {
333  static TClass *BCH2D_Dictionary();
334  static void BCH2D_TClassManip(TClass*);
335  static void *new_BCH2D(void *p = 0);
336  static void *newArray_BCH2D(Long_t size, void *p);
337  static void delete_BCH2D(void *p);
338  static void deleteArray_BCH2D(void *p);
339  static void destruct_BCH2D(void *p);
340 
341  // Function generating the singleton type initializer
342  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCH2D*)
343  {
344  ::BCH2D *ptr = 0;
345  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCH2D),0);
346  static ::ROOT::TGenericClassInfo
347  instance("BCH2D", "BAT/BCH2D.h", 37,
348  typeid(::BCH2D), DefineBehavior(ptr, ptr),
349  &BCH2D_Dictionary, isa_proxy, 1,
350  sizeof(::BCH2D) );
351  instance.SetNew(&new_BCH2D);
352  instance.SetNewArray(&newArray_BCH2D);
353  instance.SetDelete(&delete_BCH2D);
354  instance.SetDeleteArray(&deleteArray_BCH2D);
355  instance.SetDestructor(&destruct_BCH2D);
356  return &instance;
357  }
358  TGenericClassInfo *GenerateInitInstance(const ::BCH2D*)
359  {
360  return GenerateInitInstanceLocal((::BCH2D*)0);
361  }
362  // Static variable to force the class initialization
363  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCH2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
364 
365  // Dictionary for non-ClassDef classes
366  static TClass *BCH2D_Dictionary() {
367  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCH2D*)0x0)->GetClass();
368  BCH2D_TClassManip(theClass);
369  return theClass;
370  }
371 
372  static void BCH2D_TClassManip(TClass* ){
373  }
374 
375 } // end of namespace ROOT
376 
377 namespace ROOT {
378  static TClass *BCIntegrate_Dictionary();
379  static void BCIntegrate_TClassManip(TClass*);
380  static void *new_BCIntegrate(void *p = 0);
381  static void *newArray_BCIntegrate(Long_t size, void *p);
382  static void delete_BCIntegrate(void *p);
383  static void deleteArray_BCIntegrate(void *p);
384  static void destruct_BCIntegrate(void *p);
385 
386  // Function generating the singleton type initializer
387  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCIntegrate*)
388  {
389  ::BCIntegrate *ptr = 0;
390  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCIntegrate),0);
391  static ::ROOT::TGenericClassInfo
392  instance("BCIntegrate", "BAT/BCIntegrate.h", 83,
393  typeid(::BCIntegrate), DefineBehavior(ptr, ptr),
394  &BCIntegrate_Dictionary, isa_proxy, 1,
395  sizeof(::BCIntegrate) );
396  instance.SetNew(&new_BCIntegrate);
397  instance.SetNewArray(&newArray_BCIntegrate);
398  instance.SetDelete(&delete_BCIntegrate);
399  instance.SetDeleteArray(&deleteArray_BCIntegrate);
400  instance.SetDestructor(&destruct_BCIntegrate);
401  return &instance;
402  }
403  TGenericClassInfo *GenerateInitInstance(const ::BCIntegrate*)
404  {
405  return GenerateInitInstanceLocal((::BCIntegrate*)0);
406  }
407  // Static variable to force the class initialization
408  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCIntegrate*)0x0); R__UseDummy(_R__UNIQUE_(Init));
409 
410  // Dictionary for non-ClassDef classes
411  static TClass *BCIntegrate_Dictionary() {
412  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCIntegrate*)0x0)->GetClass();
413  BCIntegrate_TClassManip(theClass);
414  return theClass;
415  }
416 
417  static void BCIntegrate_TClassManip(TClass* ){
418  }
419 
420 } // end of namespace ROOT
421 
422 namespace ROOT {
423  static TClass *BCLog_Dictionary();
424  static void BCLog_TClassManip(TClass*);
425  static void *new_BCLog(void *p = 0);
426  static void *newArray_BCLog(Long_t size, void *p);
427  static void delete_BCLog(void *p);
428  static void deleteArray_BCLog(void *p);
429  static void destruct_BCLog(void *p);
430 
431  // Function generating the singleton type initializer
432  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCLog*)
433  {
434  ::BCLog *ptr = 0;
435  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCLog),0);
436  static ::ROOT::TGenericClassInfo
437  instance("BCLog", "BAT/BCLog.h", 29,
438  typeid(::BCLog), DefineBehavior(ptr, ptr),
439  &BCLog_Dictionary, isa_proxy, 1,
440  sizeof(::BCLog) );
441  instance.SetNew(&new_BCLog);
442  instance.SetNewArray(&newArray_BCLog);
443  instance.SetDelete(&delete_BCLog);
444  instance.SetDeleteArray(&deleteArray_BCLog);
445  instance.SetDestructor(&destruct_BCLog);
446  return &instance;
447  }
448  TGenericClassInfo *GenerateInitInstance(const ::BCLog*)
449  {
450  return GenerateInitInstanceLocal((::BCLog*)0);
451  }
452  // Static variable to force the class initialization
453  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCLog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
454 
455  // Dictionary for non-ClassDef classes
456  static TClass *BCLog_Dictionary() {
457  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCLog*)0x0)->GetClass();
458  BCLog_TClassManip(theClass);
459  return theClass;
460  }
461 
462  static void BCLog_TClassManip(TClass* ){
463  }
464 
465 } // end of namespace ROOT
466 
467 namespace ROOT {
468  static TClass *BCModel_Dictionary();
469  static void BCModel_TClassManip(TClass*);
470  static void delete_BCModel(void *p);
471  static void deleteArray_BCModel(void *p);
472  static void destruct_BCModel(void *p);
473 
474  // Function generating the singleton type initializer
475  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCModel*)
476  {
477  ::BCModel *ptr = 0;
478  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCModel),0);
479  static ::ROOT::TGenericClassInfo
480  instance("BCModel", "BAT/BCModel.h", 50,
481  typeid(::BCModel), DefineBehavior(ptr, ptr),
482  &BCModel_Dictionary, isa_proxy, 1,
483  sizeof(::BCModel) );
484  instance.SetDelete(&delete_BCModel);
485  instance.SetDeleteArray(&deleteArray_BCModel);
486  instance.SetDestructor(&destruct_BCModel);
487  return &instance;
488  }
489  TGenericClassInfo *GenerateInitInstance(const ::BCModel*)
490  {
491  return GenerateInitInstanceLocal((::BCModel*)0);
492  }
493  // Static variable to force the class initialization
494  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
495 
496  // Dictionary for non-ClassDef classes
497  static TClass *BCModel_Dictionary() {
498  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCModel*)0x0)->GetClass();
499  BCModel_TClassManip(theClass);
500  return theClass;
501  }
502 
503  static void BCModel_TClassManip(TClass* ){
504  }
505 
506 } // end of namespace ROOT
507 
508 namespace ROOT {
509  static TClass *BCModelManager_Dictionary();
510  static void BCModelManager_TClassManip(TClass*);
511  static void *new_BCModelManager(void *p = 0);
512  static void *newArray_BCModelManager(Long_t size, void *p);
513  static void delete_BCModelManager(void *p);
514  static void deleteArray_BCModelManager(void *p);
515  static void destruct_BCModelManager(void *p);
516 
517  // Function generating the singleton type initializer
518  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCModelManager*)
519  {
520  ::BCModelManager *ptr = 0;
521  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCModelManager),0);
522  static ::ROOT::TGenericClassInfo
523  instance("BCModelManager", "BAT/BCModelManager.h", 32,
524  typeid(::BCModelManager), DefineBehavior(ptr, ptr),
525  &BCModelManager_Dictionary, isa_proxy, 1,
526  sizeof(::BCModelManager) );
527  instance.SetNew(&new_BCModelManager);
528  instance.SetNewArray(&newArray_BCModelManager);
529  instance.SetDelete(&delete_BCModelManager);
530  instance.SetDeleteArray(&deleteArray_BCModelManager);
531  instance.SetDestructor(&destruct_BCModelManager);
532  return &instance;
533  }
534  TGenericClassInfo *GenerateInitInstance(const ::BCModelManager*)
535  {
536  return GenerateInitInstanceLocal((::BCModelManager*)0);
537  }
538  // Static variable to force the class initialization
539  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCModelManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
540 
541  // Dictionary for non-ClassDef classes
542  static TClass *BCModelManager_Dictionary() {
543  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCModelManager*)0x0)->GetClass();
544  BCModelManager_TClassManip(theClass);
545  return theClass;
546  }
547 
548  static void BCModelManager_TClassManip(TClass* ){
549  }
550 
551 } // end of namespace ROOT
552 
553 namespace ROOT {
554  static TClass *BCModelOutput_Dictionary();
555  static void BCModelOutput_TClassManip(TClass*);
556  static void *new_BCModelOutput(void *p = 0);
557  static void *newArray_BCModelOutput(Long_t size, void *p);
558  static void delete_BCModelOutput(void *p);
559  static void deleteArray_BCModelOutput(void *p);
560  static void destruct_BCModelOutput(void *p);
561 
562  // Function generating the singleton type initializer
563  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCModelOutput*)
564  {
565  ::BCModelOutput *ptr = 0;
566  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCModelOutput),0);
567  static ::ROOT::TGenericClassInfo
568  instance("BCModelOutput", "BAT/BCModelOutput.h", 38,
569  typeid(::BCModelOutput), DefineBehavior(ptr, ptr),
570  &BCModelOutput_Dictionary, isa_proxy, 1,
571  sizeof(::BCModelOutput) );
572  instance.SetNew(&new_BCModelOutput);
573  instance.SetNewArray(&newArray_BCModelOutput);
574  instance.SetDelete(&delete_BCModelOutput);
575  instance.SetDeleteArray(&deleteArray_BCModelOutput);
576  instance.SetDestructor(&destruct_BCModelOutput);
577  return &instance;
578  }
579  TGenericClassInfo *GenerateInitInstance(const ::BCModelOutput*)
580  {
581  return GenerateInitInstanceLocal((::BCModelOutput*)0);
582  }
583  // Static variable to force the class initialization
584  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCModelOutput*)0x0); R__UseDummy(_R__UNIQUE_(Init));
585 
586  // Dictionary for non-ClassDef classes
587  static TClass *BCModelOutput_Dictionary() {
588  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCModelOutput*)0x0)->GetClass();
589  BCModelOutput_TClassManip(theClass);
590  return theClass;
591  }
592 
593  static void BCModelOutput_TClassManip(TClass* ){
594  }
595 
596 } // end of namespace ROOT
597 
598 namespace ROOT {
599  static TClass *BCParameter_Dictionary();
600  static void BCParameter_TClassManip(TClass*);
601  static void *new_BCParameter(void *p = 0);
602  static void *newArray_BCParameter(Long_t size, void *p);
603  static void delete_BCParameter(void *p);
604  static void deleteArray_BCParameter(void *p);
605  static void destruct_BCParameter(void *p);
606 
607  // Function generating the singleton type initializer
608  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCParameter*)
609  {
610  ::BCParameter *ptr = 0;
611  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCParameter),0);
612  static ::ROOT::TGenericClassInfo
613  instance("BCParameter", "BAT/BCParameter.h", 28,
614  typeid(::BCParameter), DefineBehavior(ptr, ptr),
615  &BCParameter_Dictionary, isa_proxy, 1,
616  sizeof(::BCParameter) );
617  instance.SetNew(&new_BCParameter);
618  instance.SetNewArray(&newArray_BCParameter);
619  instance.SetDelete(&delete_BCParameter);
620  instance.SetDeleteArray(&deleteArray_BCParameter);
621  instance.SetDestructor(&destruct_BCParameter);
622  return &instance;
623  }
624  TGenericClassInfo *GenerateInitInstance(const ::BCParameter*)
625  {
626  return GenerateInitInstanceLocal((::BCParameter*)0);
627  }
628  // Static variable to force the class initialization
629  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCParameter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
630 
631  // Dictionary for non-ClassDef classes
632  static TClass *BCParameter_Dictionary() {
633  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCParameter*)0x0)->GetClass();
634  BCParameter_TClassManip(theClass);
635  return theClass;
636  }
637 
638  static void BCParameter_TClassManip(TClass* ){
639  }
640 
641 } // end of namespace ROOT
642 
643 namespace ROOT {
644  static TClass *BCParameterSet_Dictionary();
645  static void BCParameterSet_TClassManip(TClass*);
646  static void *new_BCParameterSet(void *p = 0);
647  static void *newArray_BCParameterSet(Long_t size, void *p);
648  static void delete_BCParameterSet(void *p);
649  static void deleteArray_BCParameterSet(void *p);
650  static void destruct_BCParameterSet(void *p);
651 
652  // Function generating the singleton type initializer
653  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCParameterSet*)
654  {
655  ::BCParameterSet *ptr = 0;
656  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCParameterSet),0);
657  static ::ROOT::TGenericClassInfo
658  instance("BCParameterSet", "BAT/BCParameterSet.h", 28,
659  typeid(::BCParameterSet), DefineBehavior(ptr, ptr),
660  &BCParameterSet_Dictionary, isa_proxy, 1,
661  sizeof(::BCParameterSet) );
662  instance.SetNew(&new_BCParameterSet);
663  instance.SetNewArray(&newArray_BCParameterSet);
664  instance.SetDelete(&delete_BCParameterSet);
665  instance.SetDeleteArray(&deleteArray_BCParameterSet);
666  instance.SetDestructor(&destruct_BCParameterSet);
667  return &instance;
668  }
669  TGenericClassInfo *GenerateInitInstance(const ::BCParameterSet*)
670  {
671  return GenerateInitInstanceLocal((::BCParameterSet*)0);
672  }
673  // Static variable to force the class initialization
674  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCParameterSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
675 
676  // Dictionary for non-ClassDef classes
677  static TClass *BCParameterSet_Dictionary() {
678  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCParameterSet*)0x0)->GetClass();
679  BCParameterSet_TClassManip(theClass);
680  return theClass;
681  }
682 
683  static void BCParameterSet_TClassManip(TClass* ){
684  }
685 
686 } // end of namespace ROOT
687 
688 namespace ROOT {
689  static TClass *BCSummaryPriorModel_Dictionary();
690  static void BCSummaryPriorModel_TClassManip(TClass*);
691  static void *new_BCSummaryPriorModel(void *p = 0);
692  static void *newArray_BCSummaryPriorModel(Long_t size, void *p);
693  static void delete_BCSummaryPriorModel(void *p);
694  static void deleteArray_BCSummaryPriorModel(void *p);
695  static void destruct_BCSummaryPriorModel(void *p);
696 
697  // Function generating the singleton type initializer
698  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCSummaryPriorModel*)
699  {
700  ::BCSummaryPriorModel *ptr = 0;
701  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCSummaryPriorModel),0);
702  static ::ROOT::TGenericClassInfo
703  instance("BCSummaryPriorModel", "BAT/BCSummaryPriorModel.h", 29,
704  typeid(::BCSummaryPriorModel), DefineBehavior(ptr, ptr),
705  &BCSummaryPriorModel_Dictionary, isa_proxy, 1,
706  sizeof(::BCSummaryPriorModel) );
707  instance.SetNew(&new_BCSummaryPriorModel);
708  instance.SetNewArray(&newArray_BCSummaryPriorModel);
709  instance.SetDelete(&delete_BCSummaryPriorModel);
710  instance.SetDeleteArray(&deleteArray_BCSummaryPriorModel);
711  instance.SetDestructor(&destruct_BCSummaryPriorModel);
712  return &instance;
713  }
714  TGenericClassInfo *GenerateInitInstance(const ::BCSummaryPriorModel*)
715  {
716  return GenerateInitInstanceLocal((::BCSummaryPriorModel*)0);
717  }
718  // Static variable to force the class initialization
719  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCSummaryPriorModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
720 
721  // Dictionary for non-ClassDef classes
722  static TClass *BCSummaryPriorModel_Dictionary() {
723  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCSummaryPriorModel*)0x0)->GetClass();
724  BCSummaryPriorModel_TClassManip(theClass);
725  return theClass;
726  }
727 
728  static void BCSummaryPriorModel_TClassManip(TClass* ){
729  }
730 
731 } // end of namespace ROOT
732 
733 namespace ROOT {
734  static TClass *BCSummaryTool_Dictionary();
735  static void BCSummaryTool_TClassManip(TClass*);
736  static void *new_BCSummaryTool(void *p = 0);
737  static void *newArray_BCSummaryTool(Long_t size, void *p);
738  static void delete_BCSummaryTool(void *p);
739  static void deleteArray_BCSummaryTool(void *p);
740  static void destruct_BCSummaryTool(void *p);
741 
742  // Function generating the singleton type initializer
743  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCSummaryTool*)
744  {
745  ::BCSummaryTool *ptr = 0;
746  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCSummaryTool),0);
747  static ::ROOT::TGenericClassInfo
748  instance("BCSummaryTool", "BAT/BCSummaryTool.h", 34,
749  typeid(::BCSummaryTool), DefineBehavior(ptr, ptr),
750  &BCSummaryTool_Dictionary, isa_proxy, 1,
751  sizeof(::BCSummaryTool) );
752  instance.SetNew(&new_BCSummaryTool);
753  instance.SetNewArray(&newArray_BCSummaryTool);
754  instance.SetDelete(&delete_BCSummaryTool);
755  instance.SetDeleteArray(&deleteArray_BCSummaryTool);
756  instance.SetDestructor(&destruct_BCSummaryTool);
757  return &instance;
758  }
759  TGenericClassInfo *GenerateInitInstance(const ::BCSummaryTool*)
760  {
761  return GenerateInitInstanceLocal((::BCSummaryTool*)0);
762  }
763  // Static variable to force the class initialization
764  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCSummaryTool*)0x0); R__UseDummy(_R__UNIQUE_(Init));
765 
766  // Dictionary for non-ClassDef classes
767  static TClass *BCSummaryTool_Dictionary() {
768  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCSummaryTool*)0x0)->GetClass();
769  BCSummaryTool_TClassManip(theClass);
770  return theClass;
771  }
772 
773  static void BCSummaryTool_TClassManip(TClass* ){
774  }
775 
776 } // end of namespace ROOT
777 
778 namespace ROOT {
779  // Wrapper around operator delete
780  static void delete_BCDataPoint(void *p) {
781  delete ((::BCDataPoint*)p);
782  }
783  static void deleteArray_BCDataPoint(void *p) {
784  delete [] ((::BCDataPoint*)p);
785  }
786  static void destruct_BCDataPoint(void *p) {
787  typedef ::BCDataPoint current_t;
788  ((current_t*)p)->~current_t();
789  }
790 } // end of namespace ROOT for class ::BCDataPoint
791 
792 namespace ROOT {
793  // Wrappers around operator new
794  static void *new_BCDataSet(void *p) {
795  return p ? new(p) ::BCDataSet : new ::BCDataSet;
796  }
797  static void *newArray_BCDataSet(Long_t nElements, void *p) {
798  return p ? new(p) ::BCDataSet[nElements] : new ::BCDataSet[nElements];
799  }
800  // Wrapper around operator delete
801  static void delete_BCDataSet(void *p) {
802  delete ((::BCDataSet*)p);
803  }
804  static void deleteArray_BCDataSet(void *p) {
805  delete [] ((::BCDataSet*)p);
806  }
807  static void destruct_BCDataSet(void *p) {
808  typedef ::BCDataSet current_t;
809  ((current_t*)p)->~current_t();
810  }
811 } // end of namespace ROOT for class ::BCDataSet
812 
813 namespace ROOT {
814  // Wrappers around operator new
815  static void *new_BCEngineMCMC(void *p) {
816  return p ? new(p) ::BCEngineMCMC : new ::BCEngineMCMC;
817  }
818  static void *newArray_BCEngineMCMC(Long_t nElements, void *p) {
819  return p ? new(p) ::BCEngineMCMC[nElements] : new ::BCEngineMCMC[nElements];
820  }
821  // Wrapper around operator delete
822  static void delete_BCEngineMCMC(void *p) {
823  delete ((::BCEngineMCMC*)p);
824  }
825  static void deleteArray_BCEngineMCMC(void *p) {
826  delete [] ((::BCEngineMCMC*)p);
827  }
828  static void destruct_BCEngineMCMC(void *p) {
829  typedef ::BCEngineMCMC current_t;
830  ((current_t*)p)->~current_t();
831  }
832 } // end of namespace ROOT for class ::BCEngineMCMC
833 
834 namespace ROOT {
835  // Wrapper around operator delete
836  static void delete_BCGoFTest(void *p) {
837  delete ((::BCGoFTest*)p);
838  }
839  static void deleteArray_BCGoFTest(void *p) {
840  delete [] ((::BCGoFTest*)p);
841  }
842  static void destruct_BCGoFTest(void *p) {
843  typedef ::BCGoFTest current_t;
844  ((current_t*)p)->~current_t();
845  }
846 } // end of namespace ROOT for class ::BCGoFTest
847 
848 namespace ROOT {
849  // Wrappers around operator new
850  static void *new_BCH1D(void *p) {
851  return p ? new(p) ::BCH1D : new ::BCH1D;
852  }
853  static void *newArray_BCH1D(Long_t nElements, void *p) {
854  return p ? new(p) ::BCH1D[nElements] : new ::BCH1D[nElements];
855  }
856  // Wrapper around operator delete
857  static void delete_BCH1D(void *p) {
858  delete ((::BCH1D*)p);
859  }
860  static void deleteArray_BCH1D(void *p) {
861  delete [] ((::BCH1D*)p);
862  }
863  static void destruct_BCH1D(void *p) {
864  typedef ::BCH1D current_t;
865  ((current_t*)p)->~current_t();
866  }
867 } // end of namespace ROOT for class ::BCH1D
868 
869 namespace ROOT {
870  // Wrappers around operator new
871  static void *new_BCH2D(void *p) {
872  return p ? new(p) ::BCH2D : new ::BCH2D;
873  }
874  static void *newArray_BCH2D(Long_t nElements, void *p) {
875  return p ? new(p) ::BCH2D[nElements] : new ::BCH2D[nElements];
876  }
877  // Wrapper around operator delete
878  static void delete_BCH2D(void *p) {
879  delete ((::BCH2D*)p);
880  }
881  static void deleteArray_BCH2D(void *p) {
882  delete [] ((::BCH2D*)p);
883  }
884  static void destruct_BCH2D(void *p) {
885  typedef ::BCH2D current_t;
886  ((current_t*)p)->~current_t();
887  }
888 } // end of namespace ROOT for class ::BCH2D
889 
890 namespace ROOT {
891  // Wrappers around operator new
892  static void *new_BCIntegrate(void *p) {
893  return p ? new(p) ::BCIntegrate : new ::BCIntegrate;
894  }
895  static void *newArray_BCIntegrate(Long_t nElements, void *p) {
896  return p ? new(p) ::BCIntegrate[nElements] : new ::BCIntegrate[nElements];
897  }
898  // Wrapper around operator delete
899  static void delete_BCIntegrate(void *p) {
900  delete ((::BCIntegrate*)p);
901  }
902  static void deleteArray_BCIntegrate(void *p) {
903  delete [] ((::BCIntegrate*)p);
904  }
905  static void destruct_BCIntegrate(void *p) {
906  typedef ::BCIntegrate current_t;
907  ((current_t*)p)->~current_t();
908  }
909 } // end of namespace ROOT for class ::BCIntegrate
910 
911 namespace ROOT {
912  // Wrappers around operator new
913  static void *new_BCLog(void *p) {
914  return p ? new(p) ::BCLog : new ::BCLog;
915  }
916  static void *newArray_BCLog(Long_t nElements, void *p) {
917  return p ? new(p) ::BCLog[nElements] : new ::BCLog[nElements];
918  }
919  // Wrapper around operator delete
920  static void delete_BCLog(void *p) {
921  delete ((::BCLog*)p);
922  }
923  static void deleteArray_BCLog(void *p) {
924  delete [] ((::BCLog*)p);
925  }
926  static void destruct_BCLog(void *p) {
927  typedef ::BCLog current_t;
928  ((current_t*)p)->~current_t();
929  }
930 } // end of namespace ROOT for class ::BCLog
931 
932 namespace ROOT {
933  // Wrapper around operator delete
934  static void delete_BCModel(void *p) {
935  delete ((::BCModel*)p);
936  }
937  static void deleteArray_BCModel(void *p) {
938  delete [] ((::BCModel*)p);
939  }
940  static void destruct_BCModel(void *p) {
941  typedef ::BCModel current_t;
942  ((current_t*)p)->~current_t();
943  }
944 } // end of namespace ROOT for class ::BCModel
945 
946 namespace ROOT {
947  // Wrappers around operator new
948  static void *new_BCModelManager(void *p) {
949  return p ? new(p) ::BCModelManager : new ::BCModelManager;
950  }
951  static void *newArray_BCModelManager(Long_t nElements, void *p) {
952  return p ? new(p) ::BCModelManager[nElements] : new ::BCModelManager[nElements];
953  }
954  // Wrapper around operator delete
955  static void delete_BCModelManager(void *p) {
956  delete ((::BCModelManager*)p);
957  }
958  static void deleteArray_BCModelManager(void *p) {
959  delete [] ((::BCModelManager*)p);
960  }
961  static void destruct_BCModelManager(void *p) {
962  typedef ::BCModelManager current_t;
963  ((current_t*)p)->~current_t();
964  }
965 } // end of namespace ROOT for class ::BCModelManager
966 
967 namespace ROOT {
968  // Wrappers around operator new
969  static void *new_BCModelOutput(void *p) {
970  return p ? new(p) ::BCModelOutput : new ::BCModelOutput;
971  }
972  static void *newArray_BCModelOutput(Long_t nElements, void *p) {
973  return p ? new(p) ::BCModelOutput[nElements] : new ::BCModelOutput[nElements];
974  }
975  // Wrapper around operator delete
976  static void delete_BCModelOutput(void *p) {
977  delete ((::BCModelOutput*)p);
978  }
979  static void deleteArray_BCModelOutput(void *p) {
980  delete [] ((::BCModelOutput*)p);
981  }
982  static void destruct_BCModelOutput(void *p) {
983  typedef ::BCModelOutput current_t;
984  ((current_t*)p)->~current_t();
985  }
986 } // end of namespace ROOT for class ::BCModelOutput
987 
988 namespace ROOT {
989  // Wrappers around operator new
990  static void *new_BCParameter(void *p) {
991  return p ? new(p) ::BCParameter : new ::BCParameter;
992  }
993  static void *newArray_BCParameter(Long_t nElements, void *p) {
994  return p ? new(p) ::BCParameter[nElements] : new ::BCParameter[nElements];
995  }
996  // Wrapper around operator delete
997  static void delete_BCParameter(void *p) {
998  delete ((::BCParameter*)p);
999  }
1000  static void deleteArray_BCParameter(void *p) {
1001  delete [] ((::BCParameter*)p);
1002  }
1003  static void destruct_BCParameter(void *p) {
1004  typedef ::BCParameter current_t;
1005  ((current_t*)p)->~current_t();
1006  }
1007 } // end of namespace ROOT for class ::BCParameter
1008 
1009 namespace ROOT {
1010  // Wrappers around operator new
1011  static void *new_BCParameterSet(void *p) {
1012  return p ? new(p) ::BCParameterSet : new ::BCParameterSet;
1013  }
1014  static void *newArray_BCParameterSet(Long_t nElements, void *p) {
1015  return p ? new(p) ::BCParameterSet[nElements] : new ::BCParameterSet[nElements];
1016  }
1017  // Wrapper around operator delete
1018  static void delete_BCParameterSet(void *p) {
1019  delete ((::BCParameterSet*)p);
1020  }
1021  static void deleteArray_BCParameterSet(void *p) {
1022  delete [] ((::BCParameterSet*)p);
1023  }
1024  static void destruct_BCParameterSet(void *p) {
1025  typedef ::BCParameterSet current_t;
1026  ((current_t*)p)->~current_t();
1027  }
1028 } // end of namespace ROOT for class ::BCParameterSet
1029 
1030 namespace ROOT {
1031  // Wrappers around operator new
1032  static void *new_BCSummaryPriorModel(void *p) {
1033  return p ? new(p) ::BCSummaryPriorModel : new ::BCSummaryPriorModel;
1034  }
1035  static void *newArray_BCSummaryPriorModel(Long_t nElements, void *p) {
1036  return p ? new(p) ::BCSummaryPriorModel[nElements] : new ::BCSummaryPriorModel[nElements];
1037  }
1038  // Wrapper around operator delete
1039  static void delete_BCSummaryPriorModel(void *p) {
1040  delete ((::BCSummaryPriorModel*)p);
1041  }
1042  static void deleteArray_BCSummaryPriorModel(void *p) {
1043  delete [] ((::BCSummaryPriorModel*)p);
1044  }
1045  static void destruct_BCSummaryPriorModel(void *p) {
1046  typedef ::BCSummaryPriorModel current_t;
1047  ((current_t*)p)->~current_t();
1048  }
1049 } // end of namespace ROOT for class ::BCSummaryPriorModel
1050 
1051 namespace ROOT {
1052  // Wrappers around operator new
1053  static void *new_BCSummaryTool(void *p) {
1054  return p ? new(p) ::BCSummaryTool : new ::BCSummaryTool;
1055  }
1056  static void *newArray_BCSummaryTool(Long_t nElements, void *p) {
1057  return p ? new(p) ::BCSummaryTool[nElements] : new ::BCSummaryTool[nElements];
1058  }
1059  // Wrapper around operator delete
1060  static void delete_BCSummaryTool(void *p) {
1061  delete ((::BCSummaryTool*)p);
1062  }
1063  static void deleteArray_BCSummaryTool(void *p) {
1064  delete [] ((::BCSummaryTool*)p);
1065  }
1066  static void destruct_BCSummaryTool(void *p) {
1067  typedef ::BCSummaryTool current_t;
1068  ((current_t*)p)->~current_t();
1069  }
1070 } // end of namespace ROOT for class ::BCSummaryTool
1071 
1072 namespace {
1073  void TriggerDictionaryInitialization_libBAT_Impl() {
1074  static const char* headers[] = {
1075 "BAT/BCDataPoint.h",
1076 "BAT/BCDataSet.h",
1077 "BAT/BCH1D.h",
1078 "BAT/BCH2D.h",
1079 "BAT/BCParameter.h",
1080 "BAT/BCParameterSet.h",
1081 "BAT/BCEngineMCMC.h",
1082 "BAT/BCIntegrate.h",
1083 "BAT/BCModel.h",
1084 "BAT/BCModelManager.h",
1085 "BAT/BCModelOutput.h",
1086 "BAT/BCGoFTest.h",
1087 "BAT/BCLog.h",
1088 "BAT/BCMath.h",
1089 "BAT/BCAux.h",
1090 "BAT/BCSummaryTool.h",
1091 "BAT/BCSummaryPriorModel.h",
1092 0
1093  };
1094  static const char* includePaths[] = {
1095 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
1096 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
1097 "/home/beaujean/.local/sw/bat/linux-ubuntu-14.04-x86_64/0.9.4/include",
1098 "/home/beaujean/.local/sw/root/linux-ubuntu-14.04-x86_64/6.02.00/include/root",
1099 0
1100  };
1101  static const char* fwdDeclCode =
1102 R"DICTFWDDCLS(
1103 #pragma clang diagnostic ignored "-Wkeyword-compat"
1104 #pragma clang diagnostic ignored "-Wignored-attributes"
1105 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
1106 extern int __Cling_Autoloading_Map;
1107 class __attribute__((annotate("$clingAutoload$BAT/BCDataPoint.h"))) BCDataPoint;
1108 class __attribute__((annotate("$clingAutoload$BAT/BCDataSet.h"))) BCDataSet;
1109 class __attribute__((annotate("$clingAutoload$BAT/BCEngineMCMC.h"))) BCEngineMCMC;
1110 class __attribute__((annotate("$clingAutoload$BAT/BCGoFTest.h"))) BCGoFTest;
1111 class __attribute__((annotate("$clingAutoload$BAT/BCH1D.h"))) BCH1D;
1112 class __attribute__((annotate("$clingAutoload$BAT/BCH2D.h"))) BCH2D;
1113 class __attribute__((annotate("$clingAutoload$BAT/BCIntegrate.h"))) BCIntegrate;
1114 class __attribute__((annotate("$clingAutoload$BAT/BCLog.h"))) BCLog;
1115 class __attribute__((annotate("$clingAutoload$BAT/BCModel.h"))) BCModel;
1116 class __attribute__((annotate("$clingAutoload$BAT/BCModelManager.h"))) BCModelManager;
1117 class __attribute__((annotate("$clingAutoload$BAT/BCModelOutput.h"))) BCModelOutput;
1118 class __attribute__((annotate("$clingAutoload$BAT/BCParameter.h"))) BCParameter;
1119 class __attribute__((annotate("$clingAutoload$BAT/BCParameterSet.h"))) BCParameterSet;
1120 class __attribute__((annotate("$clingAutoload$BAT/BCSummaryPriorModel.h"))) BCSummaryPriorModel;
1121 class __attribute__((annotate("$clingAutoload$BAT/BCSummaryTool.h"))) BCSummaryTool;
1122 )DICTFWDDCLS";
1123  static const char* payloadCode = R"DICTPAYLOAD(
1124 
1125 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
1126  #define G__VECTOR_HAS_CLASS_ITERATOR
1127 #endif
1128 
1129 #define _BACKWARD_BACKWARD_WARNING_H
1130 #include <BAT/BCDataPoint.h>
1131 #include <BAT/BCDataSet.h>
1132 #include <BAT/BCH1D.h>
1133 #include <BAT/BCH2D.h>
1134 #include <BAT/BCParameter.h>
1135 #include <BAT/BCParameterSet.h>
1136 #include <BAT/BCEngineMCMC.h>
1137 #include <BAT/BCIntegrate.h>
1138 #include <BAT/BCModel.h>
1139 #include <BAT/BCModelManager.h>
1140 #include <BAT/BCModelOutput.h>
1141 #include <BAT/BCGoFTest.h>
1142 #include <BAT/BCLog.h>
1143 #include <BAT/BCMath.h>
1144 #include <BAT/BCAux.h>
1145 #include <BAT/BCSummaryTool.h>
1146 #include <BAT/BCSummaryPriorModel.h>
1147 
1148 #undef _BACKWARD_BACKWARD_WARNING_H
1149 )DICTPAYLOAD";
1150  static const char* classesHeaders[]={
1151 "BCDataPoint", payloadCode, "@",
1152 "BCDataSet", payloadCode, "@",
1153 "BCEngineMCMC", payloadCode, "@",
1154 "BCGoFTest", payloadCode, "@",
1155 "BCH1D", payloadCode, "@",
1156 "BCH2D", payloadCode, "@",
1157 "BCIntegrate", payloadCode, "@",
1158 "BCLog", payloadCode, "@",
1159 "BCModel", payloadCode, "@",
1160 "BCModelManager", payloadCode, "@",
1161 "BCModelOutput", payloadCode, "@",
1162 "BCParameter", payloadCode, "@",
1163 "BCParameterSet", payloadCode, "@",
1164 "BCSummaryPriorModel", payloadCode, "@",
1165 "BCSummaryTool", payloadCode, "@",
1166 nullptr};
1167 
1168  static bool isInitialized = false;
1169  if (!isInitialized) {
1170  TROOT::RegisterModule("libBAT",
1171  headers, includePaths, payloadCode, fwdDeclCode,
1172  TriggerDictionaryInitialization_libBAT_Impl, {}, classesHeaders);
1173  isInitialized = true;
1174  }
1175  }
1176  static struct DictInit {
1177  DictInit() {
1178  TriggerDictionaryInitialization_libBAT_Impl();
1179  }
1180  } __TheDictionaryInitializer;
1181 }
1182 void TriggerDictionaryInitialization_libBAT() {
1183  TriggerDictionaryInitialization_libBAT_Impl();
1184 }
BCSummaryPriorModel
A helper class for the BCSummaryTool.
Definition: BCSummaryPriorModel.h:29
BCDataPoint
A class representing a data point.
Definition: BCDataPoint.h:31
BCSummaryTool
A class for summarizing the results of an analysis.
Definition: BCSummaryTool.h:34
BCModelManager
A class representing a set of BCModels.
Definition: BCModelManager.h:32
BCIntegrate
A class for handling numerical operations for models.
BCModel
The base class for all user-defined models.
Definition: BCModel.h:50
BCH2D
A class for handling 2D distributions.
Definition: BCH2D.h:37
BCDataSet
A class representing a set of data points.
Definition: BCDataSet.h:37
BCModelOutput
A class for creating an (ROOT) output file.
Definition: BCModelOutput.h:38
BCParameter
A class representing a parameter of a model.
Definition: BCParameter.h:28
BCEngineMCMC
An engine class for Markov Chain Monte Carlo.
Definition: BCEngineMCMC.h:41
BCGoFTest
The class for testing model hypotheses.
Definition: BCGoFTest.h:34
BCH1D
A class for handling 1D distributions.
Definition: BCH1D.h:31
BCLog
A class for managing log messages.
Definition: BCLog.h:29