// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdICascadeLikelihooddOdict #define R__NO_DEPRECATION /*******************************************************************/ #include #include #include #include #include #define G__DICTIONARY #include "RConfig.h" #include "TClass.h" #include "TDictAttributeMap.h" #include "TInterpreter.h" #include "TROOT.h" #include "TBuffer.h" #include "TMemberInspector.h" #include "TInterpreter.h" #include "TVirtualMutex.h" #include "TError.h" #ifndef G__ROOT #define G__ROOT #endif #include "RtypesImp.h" #include "TIsAProxy.h" #include "TFileMergeInfo.h" #include #include "TCollectionProxyInfo.h" /*******************************************************************/ #include "TDataMember.h" // The generated code does not explicitly qualifies STL entities namespace std {} using namespace std; // Header files passed as explicit arguments #include "CascadeLikelihood.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *PmtSum_Dictionary(); static void PmtSum_TClassManip(TClass*); static void *new_PmtSum(void *p = 0); static void *newArray_PmtSum(Long_t size, void *p); static void delete_PmtSum(void *p); static void deleteArray_PmtSum(void *p); static void destruct_PmtSum(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PmtSum*) { ::PmtSum *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PmtSum)); static ::ROOT::TGenericClassInfo instance("PmtSum", "CascadeLikelihood.hh", 19, typeid(::PmtSum), ::ROOT::Internal::DefineBehavior(ptr, ptr), &PmtSum_Dictionary, isa_proxy, 4, sizeof(::PmtSum) ); instance.SetNew(&new_PmtSum); instance.SetNewArray(&newArray_PmtSum); instance.SetDelete(&delete_PmtSum); instance.SetDeleteArray(&deleteArray_PmtSum); instance.SetDestructor(&destruct_PmtSum); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PmtSum*) { return GenerateInitInstanceLocal((::PmtSum*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PmtSum*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *PmtSum_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::PmtSum*)0x0)->GetClass(); PmtSum_TClassManip(theClass); return theClass; } static void PmtSum_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","CascadeLikelihood.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *CascadeLikelihood_Dictionary(); static void CascadeLikelihood_TClassManip(TClass*); static void *new_CascadeLikelihood(void *p = 0); static void *newArray_CascadeLikelihood(Long_t size, void *p); static void delete_CascadeLikelihood(void *p); static void deleteArray_CascadeLikelihood(void *p); static void destruct_CascadeLikelihood(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::CascadeLikelihood*) { ::CascadeLikelihood *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::CascadeLikelihood)); static ::ROOT::TGenericClassInfo instance("CascadeLikelihood", "CascadeLikelihood.hh", 28, typeid(::CascadeLikelihood), ::ROOT::Internal::DefineBehavior(ptr, ptr), &CascadeLikelihood_Dictionary, isa_proxy, 4, sizeof(::CascadeLikelihood) ); instance.SetNew(&new_CascadeLikelihood); instance.SetNewArray(&newArray_CascadeLikelihood); instance.SetDelete(&delete_CascadeLikelihood); instance.SetDeleteArray(&deleteArray_CascadeLikelihood); instance.SetDestructor(&destruct_CascadeLikelihood); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::CascadeLikelihood*) { return GenerateInitInstanceLocal((::CascadeLikelihood*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CascadeLikelihood*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *CascadeLikelihood_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::CascadeLikelihood*)0x0)->GetClass(); CascadeLikelihood_TClassManip(theClass); return theClass; } static void CascadeLikelihood_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","CascadeLikelihood.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *CascadeLikelihoodcLcLPmtLikelihood_Dictionary(); static void CascadeLikelihoodcLcLPmtLikelihood_TClassManip(TClass*); static void delete_CascadeLikelihoodcLcLPmtLikelihood(void *p); static void deleteArray_CascadeLikelihoodcLcLPmtLikelihood(void *p); static void destruct_CascadeLikelihoodcLcLPmtLikelihood(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::CascadeLikelihood::PmtLikelihood*) { ::CascadeLikelihood::PmtLikelihood *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::CascadeLikelihood::PmtLikelihood)); static ::ROOT::TGenericClassInfo instance("CascadeLikelihood::PmtLikelihood", "CascadeLikelihood.hh", 159, typeid(::CascadeLikelihood::PmtLikelihood), ::ROOT::Internal::DefineBehavior(ptr, ptr), &CascadeLikelihoodcLcLPmtLikelihood_Dictionary, isa_proxy, 4, sizeof(::CascadeLikelihood::PmtLikelihood) ); instance.SetDelete(&delete_CascadeLikelihoodcLcLPmtLikelihood); instance.SetDeleteArray(&deleteArray_CascadeLikelihoodcLcLPmtLikelihood); instance.SetDestructor(&destruct_CascadeLikelihoodcLcLPmtLikelihood); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::CascadeLikelihood::PmtLikelihood*) { return GenerateInitInstanceLocal((::CascadeLikelihood::PmtLikelihood*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CascadeLikelihood::PmtLikelihood*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *CascadeLikelihoodcLcLPmtLikelihood_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::CascadeLikelihood::PmtLikelihood*)0x0)->GetClass(); CascadeLikelihoodcLcLPmtLikelihood_TClassManip(theClass); return theClass; } static void CascadeLikelihoodcLcLPmtLikelihood_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","CascadeLikelihood.hh"); } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_PmtSum(void *p) { return p ? new(p) ::PmtSum : new ::PmtSum; } static void *newArray_PmtSum(Long_t nElements, void *p) { return p ? new(p) ::PmtSum[nElements] : new ::PmtSum[nElements]; } // Wrapper around operator delete static void delete_PmtSum(void *p) { delete ((::PmtSum*)p); } static void deleteArray_PmtSum(void *p) { delete [] ((::PmtSum*)p); } static void destruct_PmtSum(void *p) { typedef ::PmtSum current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::PmtSum namespace ROOT { // Wrappers around operator new static void *new_CascadeLikelihood(void *p) { return p ? new(p) ::CascadeLikelihood : new ::CascadeLikelihood; } static void *newArray_CascadeLikelihood(Long_t nElements, void *p) { return p ? new(p) ::CascadeLikelihood[nElements] : new ::CascadeLikelihood[nElements]; } // Wrapper around operator delete static void delete_CascadeLikelihood(void *p) { delete ((::CascadeLikelihood*)p); } static void deleteArray_CascadeLikelihood(void *p) { delete [] ((::CascadeLikelihood*)p); } static void destruct_CascadeLikelihood(void *p) { typedef ::CascadeLikelihood current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::CascadeLikelihood namespace ROOT { // Wrapper around operator delete static void delete_CascadeLikelihoodcLcLPmtLikelihood(void *p) { delete ((::CascadeLikelihood::PmtLikelihood*)p); } static void deleteArray_CascadeLikelihoodcLcLPmtLikelihood(void *p) { delete [] ((::CascadeLikelihood::PmtLikelihood*)p); } static void destruct_CascadeLikelihoodcLcLPmtLikelihood(void *p) { typedef ::CascadeLikelihood::PmtLikelihood current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::CascadeLikelihood::PmtLikelihood namespace ROOT { static TClass *vectorlEdoublegR_Dictionary(); static void vectorlEdoublegR_TClassManip(TClass*); static void *new_vectorlEdoublegR(void *p = 0); static void *newArray_vectorlEdoublegR(Long_t size, void *p); static void delete_vectorlEdoublegR(void *p); static void deleteArray_vectorlEdoublegR(void *p); static void destruct_vectorlEdoublegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEdoublegR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEdoublegR); instance.SetNewArray(&newArray_vectorlEdoublegR); instance.SetDelete(&delete_vectorlEdoublegR); instance.SetDeleteArray(&deleteArray_vectorlEdoublegR); instance.SetDestructor(&destruct_vectorlEdoublegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEdoublegR_TClassManip(theClass); return theClass; } static void vectorlEdoublegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEdoublegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdoublegR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEdoublegR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEdoublegR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEPmtSumgR_Dictionary(); static void vectorlEPmtSumgR_TClassManip(TClass*); static void *new_vectorlEPmtSumgR(void *p = 0); static void *newArray_vectorlEPmtSumgR(Long_t size, void *p); static void delete_vectorlEPmtSumgR(void *p); static void deleteArray_vectorlEPmtSumgR(void *p); static void destruct_vectorlEPmtSumgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEPmtSumgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEPmtSumgR); instance.SetNewArray(&newArray_vectorlEPmtSumgR); instance.SetDelete(&delete_vectorlEPmtSumgR); instance.SetDeleteArray(&deleteArray_vectorlEPmtSumgR); instance.SetDestructor(&destruct_vectorlEPmtSumgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEPmtSumgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEPmtSumgR_TClassManip(theClass); return theClass; } static void vectorlEPmtSumgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEPmtSumgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEPmtSumgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEPmtSumgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEPmtSumgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEPmtSumgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEHitgR_Dictionary(); static void vectorlEHitgR_TClassManip(TClass*); static void *new_vectorlEHitgR(void *p = 0); static void *newArray_vectorlEHitgR(Long_t size, void *p); static void delete_vectorlEHitgR(void *p); static void deleteArray_vectorlEHitgR(void *p); static void destruct_vectorlEHitgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEHitgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEHitgR); instance.SetNewArray(&newArray_vectorlEHitgR); instance.SetDelete(&delete_vectorlEHitgR); instance.SetDeleteArray(&deleteArray_vectorlEHitgR); instance.SetDestructor(&destruct_vectorlEHitgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEHitgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEHitgR_TClassManip(theClass); return theClass; } static void vectorlEHitgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEHitgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEHitgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEHitgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEHitgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEHitgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace { void TriggerDictionaryInitialization_CascadeLikelihooddOdict_Impl() { static const char* headers[] = { "CascadeLikelihood.hh", 0 }; static const char* includePaths[] = { "/usr/local/include", "/km3net/aanet/evt", "/km3net/aanet/astro", "/km3net/aanet", "/km3net/aanet/externals", "/km3net/aanet/externals/km3net-dataformat/offline", "/km3net/aanet/externals/km3net-dataformat/online", "/km3net/aanet/externals/flux", "/Jpp/software/", "/Jpp/externals/antares-daq/include/", "/usr/local/include/", "/km3net/aanet/rec/rec2/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "CascadeLikelihooddOdict dictionary forward declarations' payload" #pragma clang diagnostic ignored "-Wkeyword-compat" #pragma clang diagnostic ignored "-Wignored-attributes" #pragma clang diagnostic ignored "-Wreturn-type-c-linkage" extern int __Cling_AutoLoading_Map; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@CascadeLikelihood.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$CascadeLikelihood.hh"))) PmtSum; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@CascadeLikelihood.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$CascadeLikelihood.hh"))) CascadeLikelihood; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "CascadeLikelihooddOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "CascadeLikelihood.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "CascadeLikelihood", payloadCode, "@", "PmtSum", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("CascadeLikelihood.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_CascadeLikelihooddOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_CascadeLikelihooddOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_CascadeLikelihooddOdict() { TriggerDictionaryInitialization_CascadeLikelihooddOdict_Impl(); }