// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIOscProbdItmpdIlibOscProb #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 "/km3net/OscProb/inc/PMNS_Iter.h" #include "/km3net/OscProb/inc/PMNS_Deco.h" #include "/km3net/OscProb/inc/PremModel.h" #include "/km3net/OscProb/inc/complexsolver.h" #include "/km3net/OscProb/inc/PMNS_Fast.h" #include "/km3net/OscProb/inc/NuPath.h" #include "/km3net/OscProb/inc/PMNS_NSI.h" #include "/km3net/OscProb/inc/EarthModelBinned.h" #include "/km3net/OscProb/inc/PMNS_Base.h" #include "/km3net/OscProb/inc/PMNS_Decay.h" #include "/km3net/OscProb/inc/Absorption.h" #include "/km3net/OscProb/inc/Definitions.h" #include "/km3net/OscProb/inc/EarthModelBase.h" #include "/km3net/OscProb/inc/PMNS_LIV.h" #include "/km3net/OscProb/inc/EigenPoint.h" #include "/km3net/OscProb/inc/PMNS_SNSI.h" #include "/km3net/OscProb/inc/PMNS_Sterile.h" // Header files passed via #pragma extra_include namespace OscProb { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *OscProb_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("OscProb", 0 /*version*/, "Definitions.h", 14, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &OscProb_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProb_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ROOT { static TClass *OscProbcLcLNuPath_Dictionary(); static void OscProbcLcLNuPath_TClassManip(TClass*); static void *new_OscProbcLcLNuPath(void *p = 0); static void *newArray_OscProbcLcLNuPath(Long_t size, void *p); static void delete_OscProbcLcLNuPath(void *p); static void deleteArray_OscProbcLcLNuPath(void *p); static void destruct_OscProbcLcLNuPath(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::NuPath*) { ::OscProb::NuPath *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::NuPath)); static ::ROOT::TGenericClassInfo instance("OscProb::NuPath", "NuPath.h", 34, typeid(::OscProb::NuPath), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLNuPath_Dictionary, isa_proxy, 4, sizeof(::OscProb::NuPath) ); instance.SetNew(&new_OscProbcLcLNuPath); instance.SetNewArray(&newArray_OscProbcLcLNuPath); instance.SetDelete(&delete_OscProbcLcLNuPath); instance.SetDeleteArray(&deleteArray_OscProbcLcLNuPath); instance.SetDestructor(&destruct_OscProbcLcLNuPath); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::NuPath*) { return GenerateInitInstanceLocal((::OscProb::NuPath*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::NuPath*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLNuPath_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::NuPath*)0x0)->GetClass(); OscProbcLcLNuPath_TClassManip(theClass); return theClass; } static void OscProbcLcLNuPath_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPremLayer_Dictionary(); static void OscProbcLcLPremLayer_TClassManip(TClass*); static void *new_OscProbcLcLPremLayer(void *p = 0); static void *newArray_OscProbcLcLPremLayer(Long_t size, void *p); static void delete_OscProbcLcLPremLayer(void *p); static void deleteArray_OscProbcLcLPremLayer(void *p); static void destruct_OscProbcLcLPremLayer(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PremLayer*) { ::OscProb::PremLayer *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PremLayer)); static ::ROOT::TGenericClassInfo instance("OscProb::PremLayer", "NuPath.h", 84, typeid(::OscProb::PremLayer), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPremLayer_Dictionary, isa_proxy, 4, sizeof(::OscProb::PremLayer) ); instance.SetNew(&new_OscProbcLcLPremLayer); instance.SetNewArray(&newArray_OscProbcLcLPremLayer); instance.SetDelete(&delete_OscProbcLcLPremLayer); instance.SetDeleteArray(&deleteArray_OscProbcLcLPremLayer); instance.SetDestructor(&destruct_OscProbcLcLPremLayer); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PremLayer*) { return GenerateInitInstanceLocal((::OscProb::PremLayer*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PremLayer*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPremLayer_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PremLayer*)0x0)->GetClass(); OscProbcLcLPremLayer_TClassManip(theClass); return theClass; } static void OscProbcLcLPremLayer_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLEigenPoint_Dictionary(); static void OscProbcLcLEigenPoint_TClassManip(TClass*); static void *new_OscProbcLcLEigenPoint(void *p = 0); static void *newArray_OscProbcLcLEigenPoint(Long_t size, void *p); static void delete_OscProbcLcLEigenPoint(void *p); static void deleteArray_OscProbcLcLEigenPoint(void *p); static void destruct_OscProbcLcLEigenPoint(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::EigenPoint*) { ::OscProb::EigenPoint *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::EigenPoint)); static ::ROOT::TGenericClassInfo instance("OscProb::EigenPoint", "EigenPoint.h", 20, typeid(::OscProb::EigenPoint), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLEigenPoint_Dictionary, isa_proxy, 4, sizeof(::OscProb::EigenPoint) ); instance.SetNew(&new_OscProbcLcLEigenPoint); instance.SetNewArray(&newArray_OscProbcLcLEigenPoint); instance.SetDelete(&delete_OscProbcLcLEigenPoint); instance.SetDeleteArray(&deleteArray_OscProbcLcLEigenPoint); instance.SetDestructor(&destruct_OscProbcLcLEigenPoint); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::EigenPoint*) { return GenerateInitInstanceLocal((::OscProb::EigenPoint*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::EigenPoint*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLEigenPoint_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::EigenPoint*)0x0)->GetClass(); OscProbcLcLEigenPoint_TClassManip(theClass); return theClass; } static void OscProbcLcLEigenPoint_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Base_Dictionary(); static void OscProbcLcLPMNS_Base_TClassManip(TClass*); static void delete_OscProbcLcLPMNS_Base(void *p); static void deleteArray_OscProbcLcLPMNS_Base(void *p); static void destruct_OscProbcLcLPMNS_Base(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Base*) { ::OscProb::PMNS_Base *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Base)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Base", "PMNS_Base.h", 26, typeid(::OscProb::PMNS_Base), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Base_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Base) ); instance.SetDelete(&delete_OscProbcLcLPMNS_Base); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Base); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Base); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Base*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Base*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Base*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Base_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Base*)0x0)->GetClass(); OscProbcLcLPMNS_Base_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Base_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Fast_Dictionary(); static void OscProbcLcLPMNS_Fast_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_Fast(void *p = 0); static void *newArray_OscProbcLcLPMNS_Fast(Long_t size, void *p); static void delete_OscProbcLcLPMNS_Fast(void *p); static void deleteArray_OscProbcLcLPMNS_Fast(void *p); static void destruct_OscProbcLcLPMNS_Fast(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Fast*) { ::OscProb::PMNS_Fast *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Fast)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Fast", "PMNS_Fast.h", 40, typeid(::OscProb::PMNS_Fast), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Fast_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Fast) ); instance.SetNew(&new_OscProbcLcLPMNS_Fast); instance.SetNewArray(&newArray_OscProbcLcLPMNS_Fast); instance.SetDelete(&delete_OscProbcLcLPMNS_Fast); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Fast); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Fast); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Fast*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Fast*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Fast*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Fast_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Fast*)0x0)->GetClass(); OscProbcLcLPMNS_Fast_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Fast_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Iter_Dictionary(); static void OscProbcLcLPMNS_Iter_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_Iter(void *p = 0); static void *newArray_OscProbcLcLPMNS_Iter(Long_t size, void *p); static void delete_OscProbcLcLPMNS_Iter(void *p); static void deleteArray_OscProbcLcLPMNS_Iter(void *p); static void destruct_OscProbcLcLPMNS_Iter(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Iter*) { ::OscProb::PMNS_Iter *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Iter)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Iter", "PMNS_Iter.h", 35, typeid(::OscProb::PMNS_Iter), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Iter_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Iter) ); instance.SetNew(&new_OscProbcLcLPMNS_Iter); instance.SetNewArray(&newArray_OscProbcLcLPMNS_Iter); instance.SetDelete(&delete_OscProbcLcLPMNS_Iter); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Iter); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Iter); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Iter*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Iter*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Iter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Iter_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Iter*)0x0)->GetClass(); OscProbcLcLPMNS_Iter_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Iter_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Deco_Dictionary(); static void OscProbcLcLPMNS_Deco_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_Deco(void *p = 0); static void *newArray_OscProbcLcLPMNS_Deco(Long_t size, void *p); static void delete_OscProbcLcLPMNS_Deco(void *p); static void deleteArray_OscProbcLcLPMNS_Deco(void *p); static void destruct_OscProbcLcLPMNS_Deco(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Deco*) { ::OscProb::PMNS_Deco *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Deco)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Deco", "PMNS_Deco.h", 27, typeid(::OscProb::PMNS_Deco), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Deco_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Deco) ); instance.SetNew(&new_OscProbcLcLPMNS_Deco); instance.SetNewArray(&newArray_OscProbcLcLPMNS_Deco); instance.SetDelete(&delete_OscProbcLcLPMNS_Deco); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Deco); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Deco); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Deco*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Deco*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Deco*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Deco_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Deco*)0x0)->GetClass(); OscProbcLcLPMNS_Deco_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Deco_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void delete_OscProbcLcLEarthModelBase(void *p); static void deleteArray_OscProbcLcLEarthModelBase(void *p); static void destruct_OscProbcLcLEarthModelBase(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::EarthModelBase*) { ::OscProb::EarthModelBase *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OscProb::EarthModelBase >(0); static ::ROOT::TGenericClassInfo instance("OscProb::EarthModelBase", ::OscProb::EarthModelBase::Class_Version(), "EarthModelBase.h", 27, typeid(::OscProb::EarthModelBase), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OscProb::EarthModelBase::Dictionary, isa_proxy, 4, sizeof(::OscProb::EarthModelBase) ); instance.SetDelete(&delete_OscProbcLcLEarthModelBase); instance.SetDeleteArray(&deleteArray_OscProbcLcLEarthModelBase); instance.SetDestructor(&destruct_OscProbcLcLEarthModelBase); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::EarthModelBase*) { return GenerateInitInstanceLocal((::OscProb::EarthModelBase*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::EarthModelBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OscProbcLcLPremModel(void *p = 0); static void *newArray_OscProbcLcLPremModel(Long_t size, void *p); static void delete_OscProbcLcLPremModel(void *p); static void deleteArray_OscProbcLcLPremModel(void *p); static void destruct_OscProbcLcLPremModel(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PremModel*) { ::OscProb::PremModel *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OscProb::PremModel >(0); static ::ROOT::TGenericClassInfo instance("OscProb::PremModel", ::OscProb::PremModel::Class_Version(), "PremModel.h", 33, typeid(::OscProb::PremModel), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OscProb::PremModel::Dictionary, isa_proxy, 4, sizeof(::OscProb::PremModel) ); instance.SetNew(&new_OscProbcLcLPremModel); instance.SetNewArray(&newArray_OscProbcLcLPremModel); instance.SetDelete(&delete_OscProbcLcLPremModel); instance.SetDeleteArray(&deleteArray_OscProbcLcLPremModel); instance.SetDestructor(&destruct_OscProbcLcLPremModel); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PremModel*) { return GenerateInitInstanceLocal((::OscProb::PremModel*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PremModel*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_NSI_Dictionary(); static void OscProbcLcLPMNS_NSI_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_NSI(void *p = 0); static void *newArray_OscProbcLcLPMNS_NSI(Long_t size, void *p); static void delete_OscProbcLcLPMNS_NSI(void *p); static void deleteArray_OscProbcLcLPMNS_NSI(void *p); static void destruct_OscProbcLcLPMNS_NSI(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_NSI*) { ::OscProb::PMNS_NSI *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_NSI)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_NSI", "PMNS_NSI.h", 28, typeid(::OscProb::PMNS_NSI), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_NSI_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_NSI) ); instance.SetNew(&new_OscProbcLcLPMNS_NSI); instance.SetNewArray(&newArray_OscProbcLcLPMNS_NSI); instance.SetDelete(&delete_OscProbcLcLPMNS_NSI); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_NSI); instance.SetDestructor(&destruct_OscProbcLcLPMNS_NSI); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_NSI*) { return GenerateInitInstanceLocal((::OscProb::PMNS_NSI*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_NSI*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_NSI_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_NSI*)0x0)->GetClass(); OscProbcLcLPMNS_NSI_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_NSI_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLTrajConstants_Dictionary(); static void OscProbcLcLTrajConstants_TClassManip(TClass*); static void *new_OscProbcLcLTrajConstants(void *p = 0); static void *newArray_OscProbcLcLTrajConstants(Long_t size, void *p); static void delete_OscProbcLcLTrajConstants(void *p); static void deleteArray_OscProbcLcLTrajConstants(void *p); static void destruct_OscProbcLcLTrajConstants(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::TrajConstants*) { ::OscProb::TrajConstants *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::TrajConstants)); static ::ROOT::TGenericClassInfo instance("OscProb::TrajConstants", "EarthModelBinned.h", 80, typeid(::OscProb::TrajConstants), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLTrajConstants_Dictionary, isa_proxy, 4, sizeof(::OscProb::TrajConstants) ); instance.SetNew(&new_OscProbcLcLTrajConstants); instance.SetNewArray(&newArray_OscProbcLcLTrajConstants); instance.SetDelete(&delete_OscProbcLcLTrajConstants); instance.SetDeleteArray(&deleteArray_OscProbcLcLTrajConstants); instance.SetDestructor(&destruct_OscProbcLcLTrajConstants); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::TrajConstants*) { return GenerateInitInstanceLocal((::OscProb::TrajConstants*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::TrajConstants*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLTrajConstants_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::TrajConstants*)0x0)->GetClass(); OscProbcLcLTrajConstants_TClassManip(theClass); return theClass; } static void OscProbcLcLTrajConstants_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLEarthBin_Dictionary(); static void OscProbcLcLEarthBin_TClassManip(TClass*); static void *new_OscProbcLcLEarthBin(void *p = 0); static void *newArray_OscProbcLcLEarthBin(Long_t size, void *p); static void delete_OscProbcLcLEarthBin(void *p); static void deleteArray_OscProbcLcLEarthBin(void *p); static void destruct_OscProbcLcLEarthBin(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::EarthBin*) { ::OscProb::EarthBin *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::EarthBin)); static ::ROOT::TGenericClassInfo instance("OscProb::EarthBin", "EarthModelBinned.h", 150, typeid(::OscProb::EarthBin), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLEarthBin_Dictionary, isa_proxy, 4, sizeof(::OscProb::EarthBin) ); instance.SetNew(&new_OscProbcLcLEarthBin); instance.SetNewArray(&newArray_OscProbcLcLEarthBin); instance.SetDelete(&delete_OscProbcLcLEarthBin); instance.SetDeleteArray(&deleteArray_OscProbcLcLEarthBin); instance.SetDestructor(&destruct_OscProbcLcLEarthBin); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::EarthBin*) { return GenerateInitInstanceLocal((::OscProb::EarthBin*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::EarthBin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLEarthBin_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthBin*)0x0)->GetClass(); OscProbcLcLEarthBin_TClassManip(theClass); return theClass; } static void OscProbcLcLEarthBin_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_OscProbcLcLEarthModelBinned(void *p = 0); static void *newArray_OscProbcLcLEarthModelBinned(Long_t size, void *p); static void delete_OscProbcLcLEarthModelBinned(void *p); static void deleteArray_OscProbcLcLEarthModelBinned(void *p); static void destruct_OscProbcLcLEarthModelBinned(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::EarthModelBinned*) { ::OscProb::EarthModelBinned *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OscProb::EarthModelBinned >(0); static ::ROOT::TGenericClassInfo instance("OscProb::EarthModelBinned", ::OscProb::EarthModelBinned::Class_Version(), "EarthModelBinned.h", 214, typeid(::OscProb::EarthModelBinned), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OscProb::EarthModelBinned::Dictionary, isa_proxy, 4, sizeof(::OscProb::EarthModelBinned) ); instance.SetNew(&new_OscProbcLcLEarthModelBinned); instance.SetNewArray(&newArray_OscProbcLcLEarthModelBinned); instance.SetDelete(&delete_OscProbcLcLEarthModelBinned); instance.SetDeleteArray(&deleteArray_OscProbcLcLEarthModelBinned); instance.SetDestructor(&destruct_OscProbcLcLEarthModelBinned); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::EarthModelBinned*) { return GenerateInitInstanceLocal((::OscProb::EarthModelBinned*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::EarthModelBinned*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Decay_Dictionary(); static void OscProbcLcLPMNS_Decay_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_Decay(void *p = 0); static void *newArray_OscProbcLcLPMNS_Decay(Long_t size, void *p); static void delete_OscProbcLcLPMNS_Decay(void *p); static void deleteArray_OscProbcLcLPMNS_Decay(void *p); static void destruct_OscProbcLcLPMNS_Decay(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Decay*) { ::OscProb::PMNS_Decay *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Decay)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Decay", "PMNS_Decay.h", 30, typeid(::OscProb::PMNS_Decay), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Decay_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Decay) ); instance.SetNew(&new_OscProbcLcLPMNS_Decay); instance.SetNewArray(&newArray_OscProbcLcLPMNS_Decay); instance.SetDelete(&delete_OscProbcLcLPMNS_Decay); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Decay); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Decay); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Decay*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Decay*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Decay*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Decay_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Decay*)0x0)->GetClass(); OscProbcLcLPMNS_Decay_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Decay_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_LIV_Dictionary(); static void OscProbcLcLPMNS_LIV_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_LIV(void *p = 0); static void *newArray_OscProbcLcLPMNS_LIV(Long_t size, void *p); static void delete_OscProbcLcLPMNS_LIV(void *p); static void deleteArray_OscProbcLcLPMNS_LIV(void *p); static void destruct_OscProbcLcLPMNS_LIV(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_LIV*) { ::OscProb::PMNS_LIV *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_LIV)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_LIV", "PMNS_LIV.h", 28, typeid(::OscProb::PMNS_LIV), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_LIV_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_LIV) ); instance.SetNew(&new_OscProbcLcLPMNS_LIV); instance.SetNewArray(&newArray_OscProbcLcLPMNS_LIV); instance.SetDelete(&delete_OscProbcLcLPMNS_LIV); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_LIV); instance.SetDestructor(&destruct_OscProbcLcLPMNS_LIV); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_LIV*) { return GenerateInitInstanceLocal((::OscProb::PMNS_LIV*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_LIV*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_LIV_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_LIV*)0x0)->GetClass(); OscProbcLcLPMNS_LIV_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_LIV_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_SNSI_Dictionary(); static void OscProbcLcLPMNS_SNSI_TClassManip(TClass*); static void *new_OscProbcLcLPMNS_SNSI(void *p = 0); static void *newArray_OscProbcLcLPMNS_SNSI(Long_t size, void *p); static void delete_OscProbcLcLPMNS_SNSI(void *p); static void deleteArray_OscProbcLcLPMNS_SNSI(void *p); static void destruct_OscProbcLcLPMNS_SNSI(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_SNSI*) { ::OscProb::PMNS_SNSI *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_SNSI)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_SNSI", "PMNS_SNSI.h", 26, typeid(::OscProb::PMNS_SNSI), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_SNSI_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_SNSI) ); instance.SetNew(&new_OscProbcLcLPMNS_SNSI); instance.SetNewArray(&newArray_OscProbcLcLPMNS_SNSI); instance.SetDelete(&delete_OscProbcLcLPMNS_SNSI); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_SNSI); instance.SetDestructor(&destruct_OscProbcLcLPMNS_SNSI); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_SNSI*) { return GenerateInitInstanceLocal((::OscProb::PMNS_SNSI*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_SNSI*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_SNSI_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_SNSI*)0x0)->GetClass(); OscProbcLcLPMNS_SNSI_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_SNSI_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *OscProbcLcLPMNS_Sterile_Dictionary(); static void OscProbcLcLPMNS_Sterile_TClassManip(TClass*); static void delete_OscProbcLcLPMNS_Sterile(void *p); static void deleteArray_OscProbcLcLPMNS_Sterile(void *p); static void destruct_OscProbcLcLPMNS_Sterile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OscProb::PMNS_Sterile*) { ::OscProb::PMNS_Sterile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::OscProb::PMNS_Sterile)); static ::ROOT::TGenericClassInfo instance("OscProb::PMNS_Sterile", "PMNS_Sterile.h", 31, typeid(::OscProb::PMNS_Sterile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &OscProbcLcLPMNS_Sterile_Dictionary, isa_proxy, 4, sizeof(::OscProb::PMNS_Sterile) ); instance.SetDelete(&delete_OscProbcLcLPMNS_Sterile); instance.SetDeleteArray(&deleteArray_OscProbcLcLPMNS_Sterile); instance.SetDestructor(&destruct_OscProbcLcLPMNS_Sterile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OscProb::PMNS_Sterile*) { return GenerateInitInstanceLocal((::OscProb::PMNS_Sterile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::OscProb::PMNS_Sterile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *OscProbcLcLPMNS_Sterile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::OscProb::PMNS_Sterile*)0x0)->GetClass(); OscProbcLcLPMNS_Sterile_TClassManip(theClass); return theClass; } static void OscProbcLcLPMNS_Sterile_TClassManip(TClass* ){ } } // end of namespace ROOT namespace OscProb { //______________________________________________________________________________ atomic_TClass_ptr EarthModelBase::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *EarthModelBase::Class_Name() { return "OscProb::EarthModelBase"; } //______________________________________________________________________________ const char *EarthModelBase::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBase*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int EarthModelBase::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBase*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EarthModelBase::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBase*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EarthModelBase::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBase*)0x0)->GetClass(); } return fgIsA; } } // namespace OscProb namespace OscProb { //______________________________________________________________________________ atomic_TClass_ptr PremModel::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *PremModel::Class_Name() { return "OscProb::PremModel"; } //______________________________________________________________________________ const char *PremModel::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::PremModel*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int PremModel::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::PremModel*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PremModel::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::PremModel*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PremModel::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::PremModel*)0x0)->GetClass(); } return fgIsA; } } // namespace OscProb namespace OscProb { //______________________________________________________________________________ atomic_TClass_ptr EarthModelBinned::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *EarthModelBinned::Class_Name() { return "OscProb::EarthModelBinned"; } //______________________________________________________________________________ const char *EarthModelBinned::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBinned*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int EarthModelBinned::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBinned*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EarthModelBinned::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBinned*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EarthModelBinned::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OscProb::EarthModelBinned*)0x0)->GetClass(); } return fgIsA; } } // namespace OscProb namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLNuPath(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::NuPath : new ::OscProb::NuPath; } static void *newArray_OscProbcLcLNuPath(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::NuPath[nElements] : new ::OscProb::NuPath[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLNuPath(void *p) { delete ((::OscProb::NuPath*)p); } static void deleteArray_OscProbcLcLNuPath(void *p) { delete [] ((::OscProb::NuPath*)p); } static void destruct_OscProbcLcLNuPath(void *p) { typedef ::OscProb::NuPath current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::NuPath namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPremLayer(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PremLayer : new ::OscProb::PremLayer; } static void *newArray_OscProbcLcLPremLayer(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PremLayer[nElements] : new ::OscProb::PremLayer[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPremLayer(void *p) { delete ((::OscProb::PremLayer*)p); } static void deleteArray_OscProbcLcLPremLayer(void *p) { delete [] ((::OscProb::PremLayer*)p); } static void destruct_OscProbcLcLPremLayer(void *p) { typedef ::OscProb::PremLayer current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PremLayer namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLEigenPoint(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::EigenPoint : new ::OscProb::EigenPoint; } static void *newArray_OscProbcLcLEigenPoint(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::EigenPoint[nElements] : new ::OscProb::EigenPoint[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLEigenPoint(void *p) { delete ((::OscProb::EigenPoint*)p); } static void deleteArray_OscProbcLcLEigenPoint(void *p) { delete [] ((::OscProb::EigenPoint*)p); } static void destruct_OscProbcLcLEigenPoint(void *p) { typedef ::OscProb::EigenPoint current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::EigenPoint namespace ROOT { // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Base(void *p) { delete ((::OscProb::PMNS_Base*)p); } static void deleteArray_OscProbcLcLPMNS_Base(void *p) { delete [] ((::OscProb::PMNS_Base*)p); } static void destruct_OscProbcLcLPMNS_Base(void *p) { typedef ::OscProb::PMNS_Base current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Base namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_Fast(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Fast : new ::OscProb::PMNS_Fast; } static void *newArray_OscProbcLcLPMNS_Fast(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Fast[nElements] : new ::OscProb::PMNS_Fast[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Fast(void *p) { delete ((::OscProb::PMNS_Fast*)p); } static void deleteArray_OscProbcLcLPMNS_Fast(void *p) { delete [] ((::OscProb::PMNS_Fast*)p); } static void destruct_OscProbcLcLPMNS_Fast(void *p) { typedef ::OscProb::PMNS_Fast current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Fast namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_Iter(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Iter : new ::OscProb::PMNS_Iter; } static void *newArray_OscProbcLcLPMNS_Iter(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Iter[nElements] : new ::OscProb::PMNS_Iter[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Iter(void *p) { delete ((::OscProb::PMNS_Iter*)p); } static void deleteArray_OscProbcLcLPMNS_Iter(void *p) { delete [] ((::OscProb::PMNS_Iter*)p); } static void destruct_OscProbcLcLPMNS_Iter(void *p) { typedef ::OscProb::PMNS_Iter current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Iter namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_Deco(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Deco : new ::OscProb::PMNS_Deco; } static void *newArray_OscProbcLcLPMNS_Deco(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Deco[nElements] : new ::OscProb::PMNS_Deco[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Deco(void *p) { delete ((::OscProb::PMNS_Deco*)p); } static void deleteArray_OscProbcLcLPMNS_Deco(void *p) { delete [] ((::OscProb::PMNS_Deco*)p); } static void destruct_OscProbcLcLPMNS_Deco(void *p) { typedef ::OscProb::PMNS_Deco current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Deco namespace OscProb { //______________________________________________________________________________ void EarthModelBase::Streamer(TBuffer &R__b) { // Stream an object of class OscProb::EarthModelBase. if (R__b.IsReading()) { R__b.ReadClassBuffer(OscProb::EarthModelBase::Class(),this); } else { R__b.WriteClassBuffer(OscProb::EarthModelBase::Class(),this); } } } // namespace OscProb namespace ROOT { // Wrapper around operator delete static void delete_OscProbcLcLEarthModelBase(void *p) { delete ((::OscProb::EarthModelBase*)p); } static void deleteArray_OscProbcLcLEarthModelBase(void *p) { delete [] ((::OscProb::EarthModelBase*)p); } static void destruct_OscProbcLcLEarthModelBase(void *p) { typedef ::OscProb::EarthModelBase current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::EarthModelBase namespace OscProb { //______________________________________________________________________________ void PremModel::Streamer(TBuffer &R__b) { // Stream an object of class OscProb::PremModel. if (R__b.IsReading()) { R__b.ReadClassBuffer(OscProb::PremModel::Class(),this); } else { R__b.WriteClassBuffer(OscProb::PremModel::Class(),this); } } } // namespace OscProb namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPremModel(void *p) { return p ? new(p) ::OscProb::PremModel : new ::OscProb::PremModel; } static void *newArray_OscProbcLcLPremModel(Long_t nElements, void *p) { return p ? new(p) ::OscProb::PremModel[nElements] : new ::OscProb::PremModel[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPremModel(void *p) { delete ((::OscProb::PremModel*)p); } static void deleteArray_OscProbcLcLPremModel(void *p) { delete [] ((::OscProb::PremModel*)p); } static void destruct_OscProbcLcLPremModel(void *p) { typedef ::OscProb::PremModel current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PremModel namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_NSI(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_NSI : new ::OscProb::PMNS_NSI; } static void *newArray_OscProbcLcLPMNS_NSI(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_NSI[nElements] : new ::OscProb::PMNS_NSI[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_NSI(void *p) { delete ((::OscProb::PMNS_NSI*)p); } static void deleteArray_OscProbcLcLPMNS_NSI(void *p) { delete [] ((::OscProb::PMNS_NSI*)p); } static void destruct_OscProbcLcLPMNS_NSI(void *p) { typedef ::OscProb::PMNS_NSI current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_NSI namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLTrajConstants(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::TrajConstants : new ::OscProb::TrajConstants; } static void *newArray_OscProbcLcLTrajConstants(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::TrajConstants[nElements] : new ::OscProb::TrajConstants[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLTrajConstants(void *p) { delete ((::OscProb::TrajConstants*)p); } static void deleteArray_OscProbcLcLTrajConstants(void *p) { delete [] ((::OscProb::TrajConstants*)p); } static void destruct_OscProbcLcLTrajConstants(void *p) { typedef ::OscProb::TrajConstants current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::TrajConstants namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLEarthBin(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::EarthBin : new ::OscProb::EarthBin; } static void *newArray_OscProbcLcLEarthBin(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::EarthBin[nElements] : new ::OscProb::EarthBin[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLEarthBin(void *p) { delete ((::OscProb::EarthBin*)p); } static void deleteArray_OscProbcLcLEarthBin(void *p) { delete [] ((::OscProb::EarthBin*)p); } static void destruct_OscProbcLcLEarthBin(void *p) { typedef ::OscProb::EarthBin current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::EarthBin namespace OscProb { //______________________________________________________________________________ void EarthModelBinned::Streamer(TBuffer &R__b) { // Stream an object of class OscProb::EarthModelBinned. if (R__b.IsReading()) { R__b.ReadClassBuffer(OscProb::EarthModelBinned::Class(),this); } else { R__b.WriteClassBuffer(OscProb::EarthModelBinned::Class(),this); } } } // namespace OscProb namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLEarthModelBinned(void *p) { return p ? new(p) ::OscProb::EarthModelBinned : new ::OscProb::EarthModelBinned; } static void *newArray_OscProbcLcLEarthModelBinned(Long_t nElements, void *p) { return p ? new(p) ::OscProb::EarthModelBinned[nElements] : new ::OscProb::EarthModelBinned[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLEarthModelBinned(void *p) { delete ((::OscProb::EarthModelBinned*)p); } static void deleteArray_OscProbcLcLEarthModelBinned(void *p) { delete [] ((::OscProb::EarthModelBinned*)p); } static void destruct_OscProbcLcLEarthModelBinned(void *p) { typedef ::OscProb::EarthModelBinned current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::EarthModelBinned namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_Decay(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Decay : new ::OscProb::PMNS_Decay; } static void *newArray_OscProbcLcLPMNS_Decay(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_Decay[nElements] : new ::OscProb::PMNS_Decay[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Decay(void *p) { delete ((::OscProb::PMNS_Decay*)p); } static void deleteArray_OscProbcLcLPMNS_Decay(void *p) { delete [] ((::OscProb::PMNS_Decay*)p); } static void destruct_OscProbcLcLPMNS_Decay(void *p) { typedef ::OscProb::PMNS_Decay current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Decay namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_LIV(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_LIV : new ::OscProb::PMNS_LIV; } static void *newArray_OscProbcLcLPMNS_LIV(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_LIV[nElements] : new ::OscProb::PMNS_LIV[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_LIV(void *p) { delete ((::OscProb::PMNS_LIV*)p); } static void deleteArray_OscProbcLcLPMNS_LIV(void *p) { delete [] ((::OscProb::PMNS_LIV*)p); } static void destruct_OscProbcLcLPMNS_LIV(void *p) { typedef ::OscProb::PMNS_LIV current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_LIV namespace ROOT { // Wrappers around operator new static void *new_OscProbcLcLPMNS_SNSI(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_SNSI : new ::OscProb::PMNS_SNSI; } static void *newArray_OscProbcLcLPMNS_SNSI(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::OscProb::PMNS_SNSI[nElements] : new ::OscProb::PMNS_SNSI[nElements]; } // Wrapper around operator delete static void delete_OscProbcLcLPMNS_SNSI(void *p) { delete ((::OscProb::PMNS_SNSI*)p); } static void deleteArray_OscProbcLcLPMNS_SNSI(void *p) { delete [] ((::OscProb::PMNS_SNSI*)p); } static void destruct_OscProbcLcLPMNS_SNSI(void *p) { typedef ::OscProb::PMNS_SNSI current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_SNSI namespace ROOT { // Wrapper around operator delete static void delete_OscProbcLcLPMNS_Sterile(void *p) { delete ((::OscProb::PMNS_Sterile*)p); } static void deleteArray_OscProbcLcLPMNS_Sterile(void *p) { delete [] ((::OscProb::PMNS_Sterile*)p); } static void destruct_OscProbcLcLPMNS_Sterile(void *p) { typedef ::OscProb::PMNS_Sterile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::OscProb::PMNS_Sterile namespace ROOT { static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary(); static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass*); static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0); static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p); static void delete_vectorlEvectorlEdoublegRsPgR(void *p); static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p); static void destruct_vectorlEvectorlEdoublegRsPgR(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), &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR); instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR); instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR); instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > >())); ::ROOT::AddClassAlternate("vector >","std::vector >, std::allocator > > >"); 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 *vectorlEvectorlEdoublegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector >*)0x0)->GetClass(); vectorlEvectorlEdoublegRsPgR_TClassManip(theClass); return theClass; } static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEvectorlEdoublegRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > : new vector >; } static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlEvectorlEdoublegRsPgR(void *p) { delete ((vector >*)p); } static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) { delete [] ((vector >*)p); } static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) { typedef vector > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > namespace ROOT { static TClass *vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_Dictionary(); static void vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p = 0); static void *newArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p); static void deleteArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p); static void destruct_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(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), &vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector > >) ); instance.SetNew(&new_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR); instance.SetDelete(&delete_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > > >())); ::ROOT::AddClassAlternate("vector > >","std::vector, std::allocator > >, std::allocator, std::allocator > > > >"); 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 *vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector > >*)0x0)->GetClass(); vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEvectorlEcomplexlEdoublegRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > : new vector > >; } static void *newArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > >[nElements] : new vector > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p) { delete ((vector > >*)p); } static void deleteArray_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p) { delete [] ((vector > >*)p); } static void destruct_vectorlEvectorlEcomplexlEdoublegRsPgRsPgR(void *p) { typedef vector > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > > 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 *vectorlEcomplexlEdoublegRsPgR_Dictionary(); static void vectorlEcomplexlEdoublegRsPgR_TClassManip(TClass*); static void *new_vectorlEcomplexlEdoublegRsPgR(void *p = 0); static void *newArray_vectorlEcomplexlEdoublegRsPgR(Long_t size, void *p); static void delete_vectorlEcomplexlEdoublegRsPgR(void *p); static void deleteArray_vectorlEcomplexlEdoublegRsPgR(void *p); static void destruct_vectorlEcomplexlEdoublegRsPgR(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), &vectorlEcomplexlEdoublegRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); instance.SetNew(&new_vectorlEcomplexlEdoublegRsPgR); instance.SetNewArray(&newArray_vectorlEcomplexlEdoublegRsPgR); instance.SetDelete(&delete_vectorlEcomplexlEdoublegRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEcomplexlEdoublegRsPgR); instance.SetDestructor(&destruct_vectorlEcomplexlEdoublegRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > >())); ::ROOT::AddClassAlternate("vector >","std::vector, std::allocator > >"); 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 *vectorlEcomplexlEdoublegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector >*)0x0)->GetClass(); vectorlEcomplexlEdoublegRsPgR_TClassManip(theClass); return theClass; } static void vectorlEcomplexlEdoublegRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEcomplexlEdoublegRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > : new vector >; } static void *newArray_vectorlEcomplexlEdoublegRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlEcomplexlEdoublegRsPgR(void *p) { delete ((vector >*)p); } static void deleteArray_vectorlEcomplexlEdoublegRsPgR(void *p) { delete [] ((vector >*)p); } static void destruct_vectorlEcomplexlEdoublegRsPgR(void *p) { typedef vector > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > namespace ROOT { static TClass *vectorlEOscProbcLcLPremLayergR_Dictionary(); static void vectorlEOscProbcLcLPremLayergR_TClassManip(TClass*); static void *new_vectorlEOscProbcLcLPremLayergR(void *p = 0); static void *newArray_vectorlEOscProbcLcLPremLayergR(Long_t size, void *p); static void delete_vectorlEOscProbcLcLPremLayergR(void *p); static void deleteArray_vectorlEOscProbcLcLPremLayergR(void *p); static void destruct_vectorlEOscProbcLcLPremLayergR(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), &vectorlEOscProbcLcLPremLayergR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlEOscProbcLcLPremLayergR); instance.SetNewArray(&newArray_vectorlEOscProbcLcLPremLayergR); instance.SetDelete(&delete_vectorlEOscProbcLcLPremLayergR); instance.SetDeleteArray(&deleteArray_vectorlEOscProbcLcLPremLayergR); instance.SetDestructor(&destruct_vectorlEOscProbcLcLPremLayergR); 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 *vectorlEOscProbcLcLPremLayergR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEOscProbcLcLPremLayergR_TClassManip(theClass); return theClass; } static void vectorlEOscProbcLcLPremLayergR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEOscProbcLcLPremLayergR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEOscProbcLcLPremLayergR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEOscProbcLcLPremLayergR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEOscProbcLcLPremLayergR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEOscProbcLcLPremLayergR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEOscProbcLcLNuPathgR_Dictionary(); static void vectorlEOscProbcLcLNuPathgR_TClassManip(TClass*); static void *new_vectorlEOscProbcLcLNuPathgR(void *p = 0); static void *newArray_vectorlEOscProbcLcLNuPathgR(Long_t size, void *p); static void delete_vectorlEOscProbcLcLNuPathgR(void *p); static void deleteArray_vectorlEOscProbcLcLNuPathgR(void *p); static void destruct_vectorlEOscProbcLcLNuPathgR(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), &vectorlEOscProbcLcLNuPathgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlEOscProbcLcLNuPathgR); instance.SetNewArray(&newArray_vectorlEOscProbcLcLNuPathgR); instance.SetDelete(&delete_vectorlEOscProbcLcLNuPathgR); instance.SetDeleteArray(&deleteArray_vectorlEOscProbcLcLNuPathgR); instance.SetDestructor(&destruct_vectorlEOscProbcLcLNuPathgR); 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 *vectorlEOscProbcLcLNuPathgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEOscProbcLcLNuPathgR_TClassManip(theClass); return theClass; } static void vectorlEOscProbcLcLNuPathgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEOscProbcLcLNuPathgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEOscProbcLcLNuPathgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEOscProbcLcLNuPathgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEOscProbcLcLNuPathgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEOscProbcLcLNuPathgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEOscProbcLcLEarthBingR_Dictionary(); static void vectorlEOscProbcLcLEarthBingR_TClassManip(TClass*); static void *new_vectorlEOscProbcLcLEarthBingR(void *p = 0); static void *newArray_vectorlEOscProbcLcLEarthBingR(Long_t size, void *p); static void delete_vectorlEOscProbcLcLEarthBingR(void *p); static void deleteArray_vectorlEOscProbcLcLEarthBingR(void *p); static void destruct_vectorlEOscProbcLcLEarthBingR(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), &vectorlEOscProbcLcLEarthBingR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlEOscProbcLcLEarthBingR); instance.SetNewArray(&newArray_vectorlEOscProbcLcLEarthBingR); instance.SetDelete(&delete_vectorlEOscProbcLcLEarthBingR); instance.SetDeleteArray(&deleteArray_vectorlEOscProbcLcLEarthBingR); instance.SetDestructor(&destruct_vectorlEOscProbcLcLEarthBingR); 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 *vectorlEOscProbcLcLEarthBingR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEOscProbcLcLEarthBingR_TClassManip(theClass); return theClass; } static void vectorlEOscProbcLcLEarthBingR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEOscProbcLcLEarthBingR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEOscProbcLcLEarthBingR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEOscProbcLcLEarthBingR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEOscProbcLcLEarthBingR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEOscProbcLcLEarthBingR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *unordered_setlEOscProbcLcLEigenPointgR_Dictionary(); static void unordered_setlEOscProbcLcLEigenPointgR_TClassManip(TClass*); static void *new_unordered_setlEOscProbcLcLEigenPointgR(void *p = 0); static void *newArray_unordered_setlEOscProbcLcLEigenPointgR(Long_t size, void *p); static void delete_unordered_setlEOscProbcLcLEigenPointgR(void *p); static void deleteArray_unordered_setlEOscProbcLcLEigenPointgR(void *p); static void destruct_unordered_setlEOscProbcLcLEigenPointgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const unordered_set*) { unordered_set *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(unordered_set)); static ::ROOT::TGenericClassInfo instance("unordered_set", -2, "unordered_set", 93, typeid(unordered_set), ::ROOT::Internal::DefineBehavior(ptr, ptr), &unordered_setlEOscProbcLcLEigenPointgR_Dictionary, isa_proxy, 4, sizeof(unordered_set) ); instance.SetNew(&new_unordered_setlEOscProbcLcLEigenPointgR); instance.SetNewArray(&newArray_unordered_setlEOscProbcLcLEigenPointgR); instance.SetDelete(&delete_unordered_setlEOscProbcLcLEigenPointgR); instance.SetDeleteArray(&deleteArray_unordered_setlEOscProbcLcLEigenPointgR); instance.SetDestructor(&destruct_unordered_setlEOscProbcLcLEigenPointgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< unordered_set >())); ::ROOT::AddClassAlternate("unordered_set","std::unordered_set, std::equal_to, std::allocator >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const unordered_set*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *unordered_setlEOscProbcLcLEigenPointgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const unordered_set*)0x0)->GetClass(); unordered_setlEOscProbcLcLEigenPointgR_TClassManip(theClass); return theClass; } static void unordered_setlEOscProbcLcLEigenPointgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_unordered_setlEOscProbcLcLEigenPointgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) unordered_set : new unordered_set; } static void *newArray_unordered_setlEOscProbcLcLEigenPointgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) unordered_set[nElements] : new unordered_set[nElements]; } // Wrapper around operator delete static void delete_unordered_setlEOscProbcLcLEigenPointgR(void *p) { delete ((unordered_set*)p); } static void deleteArray_unordered_setlEOscProbcLcLEigenPointgR(void *p) { delete [] ((unordered_set*)p); } static void destruct_unordered_setlEOscProbcLcLEigenPointgR(void *p) { typedef unordered_set current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class unordered_set namespace { void TriggerDictionaryInitialization_libOscProb_Impl() { static const char* headers[] = { "inc/PMNS_Iter.h", "inc/PMNS_Deco.h", "inc/PremModel.h", "inc/complexsolver.h", "inc/PMNS_Fast.h", "inc/NuPath.h", "inc/PMNS_NSI.h", "inc/EarthModelBinned.h", "inc/PMNS_Base.h", "inc/PMNS_Decay.h", "inc/Absorption.h", "inc/Definitions.h", "inc/EarthModelBase.h", "inc/PMNS_LIV.h", "inc/EigenPoint.h", "inc/PMNS_SNSI.h", "inc/PMNS_Sterile.h", 0 }; static const char* includePaths[] = { "/km3net/OscProb", "/km3net/OscProb/inc", "/km3net/OscProb/eigen", "/usr/local/include/", "/km3net/OscProb/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "libOscProb 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; namespace OscProb{struct __attribute__((annotate("$clingAutoload$NuPath.h"))) __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) NuPath;} namespace std{template class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator; } namespace OscProb{struct __attribute__((annotate("$clingAutoload$NuPath.h"))) __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) PremLayer;} namespace OscProb{struct __attribute__((annotate("$clingAutoload$inc/EarthModelBinned.h"))) EarthBin;} namespace OscProb{struct __attribute__((annotate("$clingAutoload$EigenPoint.h"))) __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) EigenPoint;} namespace std{template struct __attribute__((annotate("$clingAutoload$bits/functional_hash.h"))) __attribute__((annotate("$clingAutoload$string"))) hash; } namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_function.h"))) __attribute__((annotate("$clingAutoload$string"))) equal_to; } namespace OscProb{class __attribute__((annotate("$clingAutoload$PMNS_Base.h"))) __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) PMNS_Base;} namespace OscProb{class __attribute__((annotate("$clingAutoload$PMNS_Fast.h"))) __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) PMNS_Fast;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_Iter.h"))) PMNS_Iter;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_Deco.h"))) PMNS_Deco;} namespace OscProb{class __attribute__((annotate("$clingAutoload$EarthModelBase.h"))) __attribute__((annotate("$clingAutoload$inc/PremModel.h"))) EarthModelBase;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PremModel.h"))) PremModel;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_NSI.h"))) PMNS_NSI;} namespace OscProb{struct __attribute__((annotate("$clingAutoload$inc/EarthModelBinned.h"))) TrajConstants;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/EarthModelBinned.h"))) EarthModelBinned;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_Decay.h"))) PMNS_Decay;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_LIV.h"))) PMNS_LIV;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_SNSI.h"))) PMNS_SNSI;} namespace OscProb{class __attribute__((annotate("$clingAutoload$inc/PMNS_Sterile.h"))) PMNS_Sterile;} )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "libOscProb dictionary payload" #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "inc/PMNS_Iter.h" #include "inc/PMNS_Deco.h" #include "inc/PremModel.h" #include "inc/complexsolver.h" #include "inc/PMNS_Fast.h" #include "inc/NuPath.h" #include "inc/PMNS_NSI.h" #include "inc/EarthModelBinned.h" #include "inc/PMNS_Base.h" #include "inc/PMNS_Decay.h" #include "inc/Absorption.h" #include "inc/Definitions.h" #include "inc/EarthModelBase.h" #include "inc/PMNS_LIV.h" #include "inc/EigenPoint.h" #include "inc/PMNS_SNSI.h" #include "inc/PMNS_Sterile.h" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "OscProb::EarthBin", payloadCode, "@", "OscProb::EarthModelBase", payloadCode, "@", "OscProb::EarthModelBinned", payloadCode, "@", "OscProb::EigenPoint", payloadCode, "@", "OscProb::NuPath", payloadCode, "@", "OscProb::PMNS_Base", payloadCode, "@", "OscProb::PMNS_Decay", payloadCode, "@", "OscProb::PMNS_Deco", payloadCode, "@", "OscProb::PMNS_Fast", payloadCode, "@", "OscProb::PMNS_Iter", payloadCode, "@", "OscProb::PMNS_LIV", payloadCode, "@", "OscProb::PMNS_NSI", payloadCode, "@", "OscProb::PMNS_SNSI", payloadCode, "@", "OscProb::PMNS_Sterile", payloadCode, "@", "OscProb::PremLayer", payloadCode, "@", "OscProb::PremModel", payloadCode, "@", "OscProb::TrajConstants", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("libOscProb", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_libOscProb_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_libOscProb_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_libOscProb() { TriggerDictionaryInitialization_libOscProb_Impl(); }