BAT  0.9.4
The Bayesian analysis toolkit
 All Classes Namespaces Functions Variables Enumerations
libBATmtf_rdict.cxx
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME libBATmtf_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 "BCMTFAnalysisFacility.h"
42 #include "BCMTFChannel.h"
43 #include "BCMTFComparisonTool.h"
44 #include "BCMTF.h"
45 #include "BCMTFProcess.h"
46 #include "BCMTFSystematic.h"
47 #include "BCMTFSystematicVariation.h"
48 #include "BCMTFTemplate.h"
49 
50 // Header files passed via #pragma extra_include
51 
52 namespace ROOT {
53  static TClass *BCMTFAnalysisFacility_Dictionary();
54  static void BCMTFAnalysisFacility_TClassManip(TClass*);
55  static void delete_BCMTFAnalysisFacility(void *p);
56  static void deleteArray_BCMTFAnalysisFacility(void *p);
57  static void destruct_BCMTFAnalysisFacility(void *p);
58 
59  // Function generating the singleton type initializer
60  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFAnalysisFacility*)
61  {
62  ::BCMTFAnalysisFacility *ptr = 0;
63  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFAnalysisFacility),0);
64  static ::ROOT::TGenericClassInfo
65  instance("BCMTFAnalysisFacility", "BAT/BCMTFAnalysisFacility.h", 35,
66  typeid(::BCMTFAnalysisFacility), DefineBehavior(ptr, ptr),
67  &BCMTFAnalysisFacility_Dictionary, isa_proxy, 0,
68  sizeof(::BCMTFAnalysisFacility) );
69  instance.SetDelete(&delete_BCMTFAnalysisFacility);
70  instance.SetDeleteArray(&deleteArray_BCMTFAnalysisFacility);
71  instance.SetDestructor(&destruct_BCMTFAnalysisFacility);
72  return &instance;
73  }
74  TGenericClassInfo *GenerateInitInstance(const ::BCMTFAnalysisFacility*)
75  {
76  return GenerateInitInstanceLocal((::BCMTFAnalysisFacility*)0);
77  }
78  // Static variable to force the class initialization
79  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFAnalysisFacility*)0x0); R__UseDummy(_R__UNIQUE_(Init));
80 
81  // Dictionary for non-ClassDef classes
82  static TClass *BCMTFAnalysisFacility_Dictionary() {
83  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFAnalysisFacility*)0x0)->GetClass();
84  BCMTFAnalysisFacility_TClassManip(theClass);
85  return theClass;
86  }
87 
88  static void BCMTFAnalysisFacility_TClassManip(TClass* ){
89  }
90 
91 } // end of namespace ROOT
92 
93 namespace ROOT {
94  static TClass *BCMTFChannel_Dictionary();
95  static void BCMTFChannel_TClassManip(TClass*);
96  static void delete_BCMTFChannel(void *p);
97  static void deleteArray_BCMTFChannel(void *p);
98  static void destruct_BCMTFChannel(void *p);
99 
100  // Function generating the singleton type initializer
101  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFChannel*)
102  {
103  ::BCMTFChannel *ptr = 0;
104  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFChannel),0);
105  static ::ROOT::TGenericClassInfo
106  instance("BCMTFChannel", "BAT/BCMTFChannel.h", 33,
107  typeid(::BCMTFChannel), DefineBehavior(ptr, ptr),
108  &BCMTFChannel_Dictionary, isa_proxy, 0,
109  sizeof(::BCMTFChannel) );
110  instance.SetDelete(&delete_BCMTFChannel);
111  instance.SetDeleteArray(&deleteArray_BCMTFChannel);
112  instance.SetDestructor(&destruct_BCMTFChannel);
113  return &instance;
114  }
115  TGenericClassInfo *GenerateInitInstance(const ::BCMTFChannel*)
116  {
117  return GenerateInitInstanceLocal((::BCMTFChannel*)0);
118  }
119  // Static variable to force the class initialization
120  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFChannel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
121 
122  // Dictionary for non-ClassDef classes
123  static TClass *BCMTFChannel_Dictionary() {
124  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFChannel*)0x0)->GetClass();
125  BCMTFChannel_TClassManip(theClass);
126  return theClass;
127  }
128 
129  static void BCMTFChannel_TClassManip(TClass* ){
130  }
131 
132 } // end of namespace ROOT
133 
134 namespace ROOT {
135  static TClass *BCMTFComparisonTool_Dictionary();
136  static void BCMTFComparisonTool_TClassManip(TClass*);
137  static void delete_BCMTFComparisonTool(void *p);
138  static void deleteArray_BCMTFComparisonTool(void *p);
139  static void destruct_BCMTFComparisonTool(void *p);
140 
141  // Function generating the singleton type initializer
142  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFComparisonTool*)
143  {
144  ::BCMTFComparisonTool *ptr = 0;
145  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFComparisonTool),0);
146  static ::ROOT::TGenericClassInfo
147  instance("BCMTFComparisonTool", "BAT/BCMTFComparisonTool.h", 29,
148  typeid(::BCMTFComparisonTool), DefineBehavior(ptr, ptr),
149  &BCMTFComparisonTool_Dictionary, isa_proxy, 0,
150  sizeof(::BCMTFComparisonTool) );
151  instance.SetDelete(&delete_BCMTFComparisonTool);
152  instance.SetDeleteArray(&deleteArray_BCMTFComparisonTool);
153  instance.SetDestructor(&destruct_BCMTFComparisonTool);
154  return &instance;
155  }
156  TGenericClassInfo *GenerateInitInstance(const ::BCMTFComparisonTool*)
157  {
158  return GenerateInitInstanceLocal((::BCMTFComparisonTool*)0);
159  }
160  // Static variable to force the class initialization
161  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFComparisonTool*)0x0); R__UseDummy(_R__UNIQUE_(Init));
162 
163  // Dictionary for non-ClassDef classes
164  static TClass *BCMTFComparisonTool_Dictionary() {
165  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFComparisonTool*)0x0)->GetClass();
166  BCMTFComparisonTool_TClassManip(theClass);
167  return theClass;
168  }
169 
170  static void BCMTFComparisonTool_TClassManip(TClass* ){
171  }
172 
173 } // end of namespace ROOT
174 
175 namespace ROOT {
176  static TClass *BCMTF_Dictionary();
177  static void BCMTF_TClassManip(TClass*);
178  static void *new_BCMTF(void *p = 0);
179  static void *newArray_BCMTF(Long_t size, void *p);
180  static void delete_BCMTF(void *p);
181  static void deleteArray_BCMTF(void *p);
182  static void destruct_BCMTF(void *p);
183 
184  // Function generating the singleton type initializer
185  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTF*)
186  {
187  ::BCMTF *ptr = 0;
188  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTF),0);
189  static ::ROOT::TGenericClassInfo
190  instance("BCMTF", "BAT/BCMTF.h", 38,
191  typeid(::BCMTF), DefineBehavior(ptr, ptr),
192  &BCMTF_Dictionary, isa_proxy, 0,
193  sizeof(::BCMTF) );
194  instance.SetNew(&new_BCMTF);
195  instance.SetNewArray(&newArray_BCMTF);
196  instance.SetDelete(&delete_BCMTF);
197  instance.SetDeleteArray(&deleteArray_BCMTF);
198  instance.SetDestructor(&destruct_BCMTF);
199  return &instance;
200  }
201  TGenericClassInfo *GenerateInitInstance(const ::BCMTF*)
202  {
203  return GenerateInitInstanceLocal((::BCMTF*)0);
204  }
205  // Static variable to force the class initialization
206  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTF*)0x0); R__UseDummy(_R__UNIQUE_(Init));
207 
208  // Dictionary for non-ClassDef classes
209  static TClass *BCMTF_Dictionary() {
210  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTF*)0x0)->GetClass();
211  BCMTF_TClassManip(theClass);
212  return theClass;
213  }
214 
215  static void BCMTF_TClassManip(TClass* ){
216  }
217 
218 } // end of namespace ROOT
219 
220 namespace ROOT {
221  static TClass *BCMTFProcess_Dictionary();
222  static void BCMTFProcess_TClassManip(TClass*);
223  static void delete_BCMTFProcess(void *p);
224  static void deleteArray_BCMTFProcess(void *p);
225  static void destruct_BCMTFProcess(void *p);
226 
227  // Function generating the singleton type initializer
228  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFProcess*)
229  {
230  ::BCMTFProcess *ptr = 0;
231  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFProcess),0);
232  static ::ROOT::TGenericClassInfo
233  instance("BCMTFProcess", "BAT/BCMTFProcess.h", 27,
234  typeid(::BCMTFProcess), DefineBehavior(ptr, ptr),
235  &BCMTFProcess_Dictionary, isa_proxy, 0,
236  sizeof(::BCMTFProcess) );
237  instance.SetDelete(&delete_BCMTFProcess);
238  instance.SetDeleteArray(&deleteArray_BCMTFProcess);
239  instance.SetDestructor(&destruct_BCMTFProcess);
240  return &instance;
241  }
242  TGenericClassInfo *GenerateInitInstance(const ::BCMTFProcess*)
243  {
244  return GenerateInitInstanceLocal((::BCMTFProcess*)0);
245  }
246  // Static variable to force the class initialization
247  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFProcess*)0x0); R__UseDummy(_R__UNIQUE_(Init));
248 
249  // Dictionary for non-ClassDef classes
250  static TClass *BCMTFProcess_Dictionary() {
251  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFProcess*)0x0)->GetClass();
252  BCMTFProcess_TClassManip(theClass);
253  return theClass;
254  }
255 
256  static void BCMTFProcess_TClassManip(TClass* ){
257  }
258 
259 } // end of namespace ROOT
260 
261 namespace ROOT {
262  static TClass *BCMTFSystematic_Dictionary();
263  static void BCMTFSystematic_TClassManip(TClass*);
264  static void delete_BCMTFSystematic(void *p);
265  static void deleteArray_BCMTFSystematic(void *p);
266  static void destruct_BCMTFSystematic(void *p);
267 
268  // Function generating the singleton type initializer
269  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFSystematic*)
270  {
271  ::BCMTFSystematic *ptr = 0;
272  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFSystematic),0);
273  static ::ROOT::TGenericClassInfo
274  instance("BCMTFSystematic", "BAT/BCMTFSystematic.h", 27,
275  typeid(::BCMTFSystematic), DefineBehavior(ptr, ptr),
276  &BCMTFSystematic_Dictionary, isa_proxy, 0,
277  sizeof(::BCMTFSystematic) );
278  instance.SetDelete(&delete_BCMTFSystematic);
279  instance.SetDeleteArray(&deleteArray_BCMTFSystematic);
280  instance.SetDestructor(&destruct_BCMTFSystematic);
281  return &instance;
282  }
283  TGenericClassInfo *GenerateInitInstance(const ::BCMTFSystematic*)
284  {
285  return GenerateInitInstanceLocal((::BCMTFSystematic*)0);
286  }
287  // Static variable to force the class initialization
288  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFSystematic*)0x0); R__UseDummy(_R__UNIQUE_(Init));
289 
290  // Dictionary for non-ClassDef classes
291  static TClass *BCMTFSystematic_Dictionary() {
292  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFSystematic*)0x0)->GetClass();
293  BCMTFSystematic_TClassManip(theClass);
294  return theClass;
295  }
296 
297  static void BCMTFSystematic_TClassManip(TClass* ){
298  }
299 
300 } // end of namespace ROOT
301 
302 namespace ROOT {
303  static TClass *BCMTFSystematicVariation_Dictionary();
304  static void BCMTFSystematicVariation_TClassManip(TClass*);
305  static void delete_BCMTFSystematicVariation(void *p);
306  static void deleteArray_BCMTFSystematicVariation(void *p);
307  static void destruct_BCMTFSystematicVariation(void *p);
308 
309  // Function generating the singleton type initializer
310  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFSystematicVariation*)
311  {
312  ::BCMTFSystematicVariation *ptr = 0;
313  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFSystematicVariation),0);
314  static ::ROOT::TGenericClassInfo
315  instance("BCMTFSystematicVariation", "BAT/BCMTFSystematicVariation.h", 31,
316  typeid(::BCMTFSystematicVariation), DefineBehavior(ptr, ptr),
317  &BCMTFSystematicVariation_Dictionary, isa_proxy, 0,
318  sizeof(::BCMTFSystematicVariation) );
319  instance.SetDelete(&delete_BCMTFSystematicVariation);
320  instance.SetDeleteArray(&deleteArray_BCMTFSystematicVariation);
321  instance.SetDestructor(&destruct_BCMTFSystematicVariation);
322  return &instance;
323  }
324  TGenericClassInfo *GenerateInitInstance(const ::BCMTFSystematicVariation*)
325  {
326  return GenerateInitInstanceLocal((::BCMTFSystematicVariation*)0);
327  }
328  // Static variable to force the class initialization
329  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFSystematicVariation*)0x0); R__UseDummy(_R__UNIQUE_(Init));
330 
331  // Dictionary for non-ClassDef classes
332  static TClass *BCMTFSystematicVariation_Dictionary() {
333  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFSystematicVariation*)0x0)->GetClass();
334  BCMTFSystematicVariation_TClassManip(theClass);
335  return theClass;
336  }
337 
338  static void BCMTFSystematicVariation_TClassManip(TClass* ){
339  }
340 
341 } // end of namespace ROOT
342 
343 namespace ROOT {
344  static TClass *BCMTFTemplate_Dictionary();
345  static void BCMTFTemplate_TClassManip(TClass*);
346  static void delete_BCMTFTemplate(void *p);
347  static void deleteArray_BCMTFTemplate(void *p);
348  static void destruct_BCMTFTemplate(void *p);
349 
350  // Function generating the singleton type initializer
351  static TGenericClassInfo *GenerateInitInstanceLocal(const ::BCMTFTemplate*)
352  {
353  ::BCMTFTemplate *ptr = 0;
354  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCMTFTemplate),0);
355  static ::ROOT::TGenericClassInfo
356  instance("BCMTFTemplate", "BAT/BCMTFTemplate.h", 32,
357  typeid(::BCMTFTemplate), DefineBehavior(ptr, ptr),
358  &BCMTFTemplate_Dictionary, isa_proxy, 0,
359  sizeof(::BCMTFTemplate) );
360  instance.SetDelete(&delete_BCMTFTemplate);
361  instance.SetDeleteArray(&deleteArray_BCMTFTemplate);
362  instance.SetDestructor(&destruct_BCMTFTemplate);
363  return &instance;
364  }
365  TGenericClassInfo *GenerateInitInstance(const ::BCMTFTemplate*)
366  {
367  return GenerateInitInstanceLocal((::BCMTFTemplate*)0);
368  }
369  // Static variable to force the class initialization
370  static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCMTFTemplate*)0x0); R__UseDummy(_R__UNIQUE_(Init));
371 
372  // Dictionary for non-ClassDef classes
373  static TClass *BCMTFTemplate_Dictionary() {
374  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BCMTFTemplate*)0x0)->GetClass();
375  BCMTFTemplate_TClassManip(theClass);
376  return theClass;
377  }
378 
379  static void BCMTFTemplate_TClassManip(TClass* ){
380  }
381 
382 } // end of namespace ROOT
383 
384 namespace ROOT {
385  // Wrapper around operator delete
386  static void delete_BCMTFAnalysisFacility(void *p) {
387  delete ((::BCMTFAnalysisFacility*)p);
388  }
389  static void deleteArray_BCMTFAnalysisFacility(void *p) {
390  delete [] ((::BCMTFAnalysisFacility*)p);
391  }
392  static void destruct_BCMTFAnalysisFacility(void *p) {
393  typedef ::BCMTFAnalysisFacility current_t;
394  ((current_t*)p)->~current_t();
395  }
396 } // end of namespace ROOT for class ::BCMTFAnalysisFacility
397 
398 namespace ROOT {
399  // Wrapper around operator delete
400  static void delete_BCMTFChannel(void *p) {
401  delete ((::BCMTFChannel*)p);
402  }
403  static void deleteArray_BCMTFChannel(void *p) {
404  delete [] ((::BCMTFChannel*)p);
405  }
406  static void destruct_BCMTFChannel(void *p) {
407  typedef ::BCMTFChannel current_t;
408  ((current_t*)p)->~current_t();
409  }
410 } // end of namespace ROOT for class ::BCMTFChannel
411 
412 namespace ROOT {
413  // Wrapper around operator delete
414  static void delete_BCMTFComparisonTool(void *p) {
415  delete ((::BCMTFComparisonTool*)p);
416  }
417  static void deleteArray_BCMTFComparisonTool(void *p) {
418  delete [] ((::BCMTFComparisonTool*)p);
419  }
420  static void destruct_BCMTFComparisonTool(void *p) {
421  typedef ::BCMTFComparisonTool current_t;
422  ((current_t*)p)->~current_t();
423  }
424 } // end of namespace ROOT for class ::BCMTFComparisonTool
425 
426 namespace ROOT {
427  // Wrappers around operator new
428  static void *new_BCMTF(void *p) {
429  return p ? new(p) ::BCMTF : new ::BCMTF;
430  }
431  static void *newArray_BCMTF(Long_t nElements, void *p) {
432  return p ? new(p) ::BCMTF[nElements] : new ::BCMTF[nElements];
433  }
434  // Wrapper around operator delete
435  static void delete_BCMTF(void *p) {
436  delete ((::BCMTF*)p);
437  }
438  static void deleteArray_BCMTF(void *p) {
439  delete [] ((::BCMTF*)p);
440  }
441  static void destruct_BCMTF(void *p) {
442  typedef ::BCMTF current_t;
443  ((current_t*)p)->~current_t();
444  }
445 } // end of namespace ROOT for class ::BCMTF
446 
447 namespace ROOT {
448  // Wrapper around operator delete
449  static void delete_BCMTFProcess(void *p) {
450  delete ((::BCMTFProcess*)p);
451  }
452  static void deleteArray_BCMTFProcess(void *p) {
453  delete [] ((::BCMTFProcess*)p);
454  }
455  static void destruct_BCMTFProcess(void *p) {
456  typedef ::BCMTFProcess current_t;
457  ((current_t*)p)->~current_t();
458  }
459 } // end of namespace ROOT for class ::BCMTFProcess
460 
461 namespace ROOT {
462  // Wrapper around operator delete
463  static void delete_BCMTFSystematic(void *p) {
464  delete ((::BCMTFSystematic*)p);
465  }
466  static void deleteArray_BCMTFSystematic(void *p) {
467  delete [] ((::BCMTFSystematic*)p);
468  }
469  static void destruct_BCMTFSystematic(void *p) {
470  typedef ::BCMTFSystematic current_t;
471  ((current_t*)p)->~current_t();
472  }
473 } // end of namespace ROOT for class ::BCMTFSystematic
474 
475 namespace ROOT {
476  // Wrapper around operator delete
477  static void delete_BCMTFSystematicVariation(void *p) {
478  delete ((::BCMTFSystematicVariation*)p);
479  }
480  static void deleteArray_BCMTFSystematicVariation(void *p) {
481  delete [] ((::BCMTFSystematicVariation*)p);
482  }
483  static void destruct_BCMTFSystematicVariation(void *p) {
484  typedef ::BCMTFSystematicVariation current_t;
485  ((current_t*)p)->~current_t();
486  }
487 } // end of namespace ROOT for class ::BCMTFSystematicVariation
488 
489 namespace ROOT {
490  // Wrapper around operator delete
491  static void delete_BCMTFTemplate(void *p) {
492  delete ((::BCMTFTemplate*)p);
493  }
494  static void deleteArray_BCMTFTemplate(void *p) {
495  delete [] ((::BCMTFTemplate*)p);
496  }
497  static void destruct_BCMTFTemplate(void *p) {
498  typedef ::BCMTFTemplate current_t;
499  ((current_t*)p)->~current_t();
500  }
501 } // end of namespace ROOT for class ::BCMTFTemplate
502 
503 namespace {
504  void TriggerDictionaryInitialization_libBATmtf_Impl() {
505  static const char* headers[] = {
506 "BAT/BCMTFAnalysisFacility.h",
507 "BAT/BCMTFChannel.h",
508 "BAT/BCMTFComparisonTool.h",
509 "BAT/BCMTF.h",
510 "BAT/BCMTFProcess.h",
511 "BAT/BCMTFSystematic.h",
512 "BAT/BCMTFSystematicVariation.h",
513 "BAT/BCMTFTemplate.h",
514 0
515  };
516  static const char* includePaths[] = {
517 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
518 "/home/beaujean/.local/sw/cuba/linux-ubuntu-14.04-x86_64/4.0/include",
519 "/home/beaujean/.local/sw/bat/linux-ubuntu-14.04-x86_64/0.9.4/include",
520 "/home/beaujean/.local/sw/root/linux-ubuntu-14.04-x86_64/6.02.00/include/root",
521 0
522  };
523  static const char* fwdDeclCode =
524 R"DICTFWDDCLS(
525 #pragma clang diagnostic ignored "-Wkeyword-compat"
526 #pragma clang diagnostic ignored "-Wignored-attributes"
527 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
528 extern int __Cling_Autoloading_Map;
529 class __attribute__((annotate("$clingAutoload$BAT/BCMTFAnalysisFacility.h"))) BCMTFAnalysisFacility;
530 class __attribute__((annotate("$clingAutoload$BAT/BCMTFChannel.h"))) BCMTFChannel;
531 class __attribute__((annotate("$clingAutoload$BAT/BCMTFComparisonTool.h"))) BCMTFComparisonTool;
532 class __attribute__((annotate("$clingAutoload$BAT/BCMTF.h"))) BCMTF;
533 class __attribute__((annotate("$clingAutoload$BAT/BCMTFProcess.h"))) BCMTFProcess;
534 class __attribute__((annotate("$clingAutoload$BAT/BCMTFSystematic.h"))) BCMTFSystematic;
535 class __attribute__((annotate("$clingAutoload$BAT/BCMTFSystematicVariation.h"))) BCMTFSystematicVariation;
536 class __attribute__((annotate("$clingAutoload$BAT/BCMTFTemplate.h"))) BCMTFTemplate;
537 )DICTFWDDCLS";
538  static const char* payloadCode = R"DICTPAYLOAD(
539 
540 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
541  #define G__VECTOR_HAS_CLASS_ITERATOR
542 #endif
543 
544 #define _BACKWARD_BACKWARD_WARNING_H
545 #include <BAT/BCMTFAnalysisFacility.h>
546 #include <BAT/BCMTFChannel.h>
547 #include <BAT/BCMTFComparisonTool.h>
548 #include <BAT/BCMTF.h>
549 #include <BAT/BCMTFProcess.h>
550 #include <BAT/BCMTFSystematic.h>
551 #include <BAT/BCMTFSystematicVariation.h>
552 #include <BAT/BCMTFTemplate.h>
553 
554 #undef _BACKWARD_BACKWARD_WARNING_H
555 )DICTPAYLOAD";
556  static const char* classesHeaders[]={
557 "BCMTF", payloadCode, "@",
558 "BCMTFAnalysisFacility", payloadCode, "@",
559 "BCMTFChannel", payloadCode, "@",
560 "BCMTFComparisonTool", payloadCode, "@",
561 "BCMTFProcess", payloadCode, "@",
562 "BCMTFSystematic", payloadCode, "@",
563 "BCMTFSystematicVariation", payloadCode, "@",
564 "BCMTFTemplate", payloadCode, "@",
565 nullptr};
566 
567  static bool isInitialized = false;
568  if (!isInitialized) {
569  TROOT::RegisterModule("libBATmtf",
570  headers, includePaths, payloadCode, fwdDeclCode,
571  TriggerDictionaryInitialization_libBATmtf_Impl, {}, classesHeaders);
572  isInitialized = true;
573  }
574  }
575  static struct DictInit {
576  DictInit() {
577  TriggerDictionaryInitialization_libBATmtf_Impl();
578  }
579  } __TheDictionaryInitializer;
580 }
581 void TriggerDictionaryInitialization_libBATmtf() {
582  TriggerDictionaryInitialization_libBATmtf_Impl();
583 }
BCMTFTemplate
A class describing a template.
Definition: BCMTFTemplate.h:32
BCMTFComparisonTool
A helper class for BCMTFAnalysisFacility storing information.
Definition: BCMTFComparisonTool.h:29
BCMTFProcess
A class describing a process.
Definition: BCMTFProcess.h:27
BCMTFChannel
A class describing a physics channel.
Definition: BCMTFChannel.h:33
BCMTFAnalysisFacility
A class summarizing a set of predefined measurements.
Definition: BCMTFAnalysisFacility.h:35
BCMTF
A class for fitting several templates to a data set.
Definition: BCMTF.h:38
BCMTFSystematic
A class desribing a systematic uncertainty.
Definition: BCMTFSystematic.h:27
BCMTFSystematicVariation
A class describing a systematic variation.
Definition: BCMTFSystematicVariation.h:31